/android/import-contacts

To get this branch, use:
bzr branch http://bzr.ed.am/android/import-contacts

« back to all changes in this revision

Viewing changes to src/org/waxworlds/importcontacts/Doit.java

  • Committer: edam
  • Date: 2009-01-10 19:16:04 UTC
  • Revision ID: edam@waxworlds.org-20090110191604-24xjo5brlvislhqw
- added toaster message about import abortion in onPause()
- added TODO list

Show diffs side-by-side

added added

removed removed

src/org/waxworlds/importcontacts/Doit.java
1
 
/*
2
 
 * Doit.java
3
 
 *
4
 
 * Copyright (C) 2009 Tim Marston <edam@waxworlds.org>
5
 
 *
6
 
 * This file is part of the Import Contacts program (hereafter referred
7
 
 * to as "this program"). For more information, see
8
 
 * http://www.waxworlds.org/edam/software/android/import-contacts
9
 
 *
10
 
 * This program is free software: you can redistribute it and/or modify
11
 
 * it under the terms of the GNU General Public License as published by
12
 
 * the Free Software Foundation, either version 3 of the License, or
13
 
 * (at your option) any later version.
14
 
 *
15
 
 * This program is distributed in the hope that it will be useful,
16
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
 
 * GNU General Public License for more details.
19
 
 *
20
 
 * You should have received a copy of the GNU General Public License
21
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
 
 */
23
 
 
24
1
package org.waxworlds.importcontacts;
25
2
 
26
3
import android.app.AlertDialog;
47
24
        private final static int DIALOG_CONTINUEORABORT = 1;
48
25
        private final static int DIALOG_MERGEPROMPT = 2;
49
26
 
50
 
        public final static int MESSAGE_FINISHED_ALLDONE = 0;
51
 
        public final static int MESSAGE_FINISHED = 1;
52
 
        public final static int MESSAGE_FINISHED_GOBACK = 2;
53
 
        public final static int MESSAGE_ERROR = 3;
54
 
        public final static int MESSAGE_CONTINUEORABORT = 4;
55
 
        public final static int MESSAGE_SETPROGRESSMESSAGE = 5;
56
 
        public final static int MESSAGE_SETMAXPROGRESS = 6;
57
 
        public final static int MESSAGE_SETTMPPROGRESS = 7;
58
 
        public final static int MESSAGE_SETPROGRESS = 8;
59
 
        public final static int MESSAGE_MERGEPROMPT = 9;
60
 
        public final static int MESSAGE_CONTACTOVERWRITTEN = 10;
61
 
        public final static int MESSAGE_CONTACTCREATED = 11;
62
 
        public final static int MESSAGE_CONTACTMERGED = 12;
63
 
        public final static int MESSAGE_CONTACTSKIPPED = 13;
64
 
 
65
 
        public final static int ACTION_PROMPT = 0;
66
 
        public final static int ACTION_KEEP = 1;
67
 
        public final static int ACTION_MERGE_MERGE = 2;
68
 
        public final static int ACTION_OVERWRITE = 3;
69
 
 
70
27
        private boolean _startedProgress;
71
28
        private int _maxProgress;
72
29
        private int _tmpProgress;
80
37
        private int _countMerges;
81
38
        private int _countSkips;
82
39
 
83
 
        protected Importer _importer = null;
 
40
        protected Importer _importer;
84
41
 
85
42
        public Handler _handler;
86
43
 
90
47
                public void handleMessage( Message msg ) {
91
48
                        switch( msg.what )
92
49
                        {
93
 
                        case MESSAGE_FINISHED_ALLDONE:
94
 
                                ( (TextView)findViewById( R.id.doit_alldone ) ).
95
 
                                                setVisibility( View.VISIBLE );
96
 
                                // fall through
97
 
                        case MESSAGE_FINISHED:
 
50
                        case Importer.MESSAGE_FINISHED:
98
51
                                ( (LinearLayout)findViewById( R.id.doit_closedisplay ) ).
99
52
                                                setVisibility( View.VISIBLE );
100
53
                                break;
101
 
                        case MESSAGE_FINISHED_GOBACK:
 
54
                        case Importer.MESSAGE_FINISHED_BACK:
102
55
                                ( (Button)findViewById( R.id.back ) ).setEnabled( true );
103
56
                                break;
104
 
                        case MESSAGE_ERROR:
 
57
                        case Importer.MESSAGE_ERROR:
105
58
                                Doit.this._dialogMessage = (String)msg.obj;
106
59
                                showDialog( DIALOG_ERROR );
107
60
                                break;
108
 
                        case MESSAGE_CONTINUEORABORT:
 
61
                        case Importer.MESSAGE_CONTINUEORABORT:
109
62
                                Doit.this._dialogMessage = (String)msg.obj;
110
63
                                showDialog( DIALOG_CONTINUEORABORT );
111
64
                                break;
112
 
                        case MESSAGE_SETPROGRESSMESSAGE:
 
65
                        case Importer.MESSAGE_SETPROGRESSMESSAGE:
113
66
                                ( (TextView)findViewById( R.id.doit_percentage ) ).
114
67
                                                setText( (String)msg.obj );
115
68
                                break;
116
 
                        case MESSAGE_SETMAXPROGRESS:
 
69
                        case Importer.MESSAGE_SETMAXPROGRESS:
117
70
                                if( _maxProgress > 0 ) {
118
71
                                        if( _tmpProgress == _maxProgress )
119
72
                                                _tmpProgress = (Integer)msg.obj;
123
76
                                _maxProgress = (Integer)msg.obj;
124
77
                                updateProgress();
125
78
                                break;
126
 
                        case MESSAGE_SETTMPPROGRESS:
 
79
                        case Importer.MESSAGE_SETTMPPROGRESS:
127
80
                                _tmpProgress = (Integer)msg.obj;
128
81
                                updateProgress();
129
82
                                break;
130
 
                        case MESSAGE_SETPROGRESS:
 
83
                        case Importer.MESSAGE_SETPROGRESS:
131
84
                                _startedProgress = true;
132
85
                                _progress = (Integer)msg.obj;
133
86
                                updateProgress();
134
87
                                break;
135
 
                        case MESSAGE_MERGEPROMPT:
 
88
                        case Importer.MESSAGE_MERGEPROMPT:
136
89
                                _dialogMessage = (String)msg.obj;
137
90
                                showDialog( DIALOG_MERGEPROMPT );
138
91
                                break;
139
 
                        case MESSAGE_CONTACTOVERWRITTEN:
 
92
                        case Importer.MESSAGE_CONTACTOVERWRITTEN:
140
93
                                _countOverwrites++;
141
94
                                updateStats();
142
95
                                break;
143
 
                        case MESSAGE_CONTACTCREATED:
 
96
                        case Importer.MESSAGE_CONTACTCREATED:
144
97
                                _countCreates++;
145
98
                                updateStats();
146
99
                                break;
147
 
                        case MESSAGE_CONTACTMERGED:
 
100
                        case Importer.MESSAGE_CONTACTMERGED:
148
101
                                _countMerges++;
149
102
                                updateStats();
150
103
                                break;
151
 
                        case MESSAGE_CONTACTSKIPPED:
 
104
                        case Importer.MESSAGE_CONTACTSKIPPED:
152
105
                                _countSkips++;
153
106
                                updateStats();
154
107
                                break;
207
160
                // saving the state of an import sounds complicated! Lets just abort!
208
161
                abortImport();
209
162
 
210
 
                // destroy some stuff
211
 
                _importer = null;
212
 
                _handler = null;
 
163
                // notify the user
 
164
        Toast.makeText( this, R.string.doit_importaborted,
 
165
                        Toast.LENGTH_LONG ).show();
213
166
        }
214
167
 
215
168
        @Override
289
242
                        int responseExtra = _mergePromptAlwaysSelected?
290
243
                                        Importer.RESPONSEEXTRA_ALWAYS : Importer.RESPONSEEXTRA_NONE;
291
244
                        Doit.this._mergePromptDialog.dismiss();
292
 
                        Doit.this._mergePromptDialog = null;    // don't keep a reference!
293
 
                        Doit.this._importer.wake( convertIdToAction( view.getId() ),
294
 
                                        responseExtra );
 
245
                        Doit.this._mergePromptDialog = null;    // dont keep a reference!
 
246
                        Doit.this._importer.wake( view.getId(), responseExtra );
295
247
                }
296
248
        };
297
249
 
298
 
        public static int convertIdToAction( int id ) {
299
 
                switch( id ) {
300
 
                case R.id.merge_keep:           return ACTION_KEEP;
301
 
                case R.id.merge_merge:          return ACTION_MERGE_MERGE;
302
 
                case R.id.merge_overwrite:      return ACTION_OVERWRITE;
303
 
                default: return ACTION_PROMPT;
304
 
                }
305
 
        }
306
 
 
307
 
        public static int convertActionToId( int action ) {
308
 
                switch( action ) {
309
 
                case ACTION_KEEP:               return R.id.merge_keep;
310
 
                case ACTION_MERGE_MERGE:return R.id.merge_merge;
311
 
                case ACTION_OVERWRITE:  return R.id.merge_overwrite;
312
 
                default: return R.id.merge_prompt;
313
 
                }
314
 
        }
315
 
 
316
250
        private DialogInterface.OnCancelListener _dialogOnCancelListener =
317
251
                        new DialogInterface.OnCancelListener() {
318
252
                public void onCancel( DialogInterface dialog ) {
404
338
        {
405
339
                if( _importer != null )
406
340
                {
407
 
                        // try and flag worker thread - did we need to?
408
 
                        if( _importer.setAbort() )
409
 
                        {
410
 
                                // wait for worker thread to end
411
 
                                while( true ) {
412
 
                                        try {
413
 
                                                _importer.join();
414
 
                                                break;
415
 
                                        }
416
 
                                        catch( InterruptedException e ) {}
 
341
                        _importer.setAbort();
 
342
                        while( true ) {
 
343
                                try {
 
344
                                        _importer.join();
 
345
                                        break;
417
346
                                }
418
 
 
419
 
                                // notify the user
420
 
                        Toast.makeText( this, R.string.doit_importaborted,
421
 
                                        Toast.LENGTH_LONG ).show();
 
347
                                catch( InterruptedException e ) {}
422
348
                        }
423
349
                }
424
350
        }