/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-13 06:35:26 UTC
  • Revision ID: edam@waxworlds.org-20090113063526-l9t1s9git4bav60a
- new contact's phone numebrs and email addresses are added to the caches after those contacts are updated to account for the situation where the same contact is imported again from another file (or the contact exists twice in the same file!?)

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
 
1
24
package org.waxworlds.importcontacts;
2
25
 
3
26
import android.app.AlertDialog;
24
47
        private final static int DIALOG_CONTINUEORABORT = 1;
25
48
        private final static int DIALOG_MERGEPROMPT = 2;
26
49
 
 
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
 
27
65
        private boolean _startedProgress;
28
66
        private int _maxProgress;
29
67
        private int _tmpProgress;
37
75
        private int _countMerges;
38
76
        private int _countSkips;
39
77
 
40
 
        protected Importer _importer;
 
78
        protected Importer _importer = null;
41
79
 
42
80
        public Handler _handler;
43
81
 
47
85
                public void handleMessage( Message msg ) {
48
86
                        switch( msg.what )
49
87
                        {
50
 
                        case Importer.MESSAGE_FINISHED:
 
88
                        case MESSAGE_FINISHED_ALLDONE:
 
89
                                ( (TextView)findViewById( R.id.doit_alldone ) ).
 
90
                                                setVisibility( View.VISIBLE );
 
91
                                // fall through
 
92
                        case MESSAGE_FINISHED:
51
93
                                ( (LinearLayout)findViewById( R.id.doit_closedisplay ) ).
52
94
                                                setVisibility( View.VISIBLE );
53
95
                                break;
54
 
                        case Importer.MESSAGE_FINISHED_BACK:
 
96
                        case MESSAGE_FINISHED_GOBACK:
55
97
                                ( (Button)findViewById( R.id.back ) ).setEnabled( true );
56
98
                                break;
57
 
                        case Importer.MESSAGE_ERROR:
 
99
                        case MESSAGE_ERROR:
58
100
                                Doit.this._dialogMessage = (String)msg.obj;
59
101
                                showDialog( DIALOG_ERROR );
60
102
                                break;
61
 
                        case Importer.MESSAGE_CONTINUEORABORT:
 
103
                        case MESSAGE_CONTINUEORABORT:
62
104
                                Doit.this._dialogMessage = (String)msg.obj;
63
105
                                showDialog( DIALOG_CONTINUEORABORT );
64
106
                                break;
65
 
                        case Importer.MESSAGE_SETPROGRESSMESSAGE:
 
107
                        case MESSAGE_SETPROGRESSMESSAGE:
66
108
                                ( (TextView)findViewById( R.id.doit_percentage ) ).
67
109
                                                setText( (String)msg.obj );
68
110
                                break;
69
 
                        case Importer.MESSAGE_SETMAXPROGRESS:
 
111
                        case MESSAGE_SETMAXPROGRESS:
70
112
                                if( _maxProgress > 0 ) {
71
113
                                        if( _tmpProgress == _maxProgress )
72
114
                                                _tmpProgress = (Integer)msg.obj;
76
118
                                _maxProgress = (Integer)msg.obj;
77
119
                                updateProgress();
78
120
                                break;
79
 
                        case Importer.MESSAGE_SETTMPPROGRESS:
 
121
                        case MESSAGE_SETTMPPROGRESS:
80
122
                                _tmpProgress = (Integer)msg.obj;
81
123
                                updateProgress();
82
124
                                break;
83
 
                        case Importer.MESSAGE_SETPROGRESS:
 
125
                        case MESSAGE_SETPROGRESS:
84
126
                                _startedProgress = true;
85
127
                                _progress = (Integer)msg.obj;
86
128
                                updateProgress();
87
129
                                break;
88
 
                        case Importer.MESSAGE_MERGEPROMPT:
 
130
                        case MESSAGE_MERGEPROMPT:
89
131
                                _dialogMessage = (String)msg.obj;
90
132
                                showDialog( DIALOG_MERGEPROMPT );
91
133
                                break;
92
 
                        case Importer.MESSAGE_CONTACTOVERWRITTEN:
 
134
                        case MESSAGE_CONTACTOVERWRITTEN:
93
135
                                _countOverwrites++;
94
136
                                updateStats();
95
137
                                break;
96
 
                        case Importer.MESSAGE_CONTACTCREATED:
 
138
                        case MESSAGE_CONTACTCREATED:
97
139
                                _countCreates++;
98
140
                                updateStats();
99
141
                                break;
100
 
                        case Importer.MESSAGE_CONTACTMERGED:
 
142
                        case MESSAGE_CONTACTMERGED:
101
143
                                _countMerges++;
102
144
                                updateStats();
103
145
                                break;
104
 
                        case Importer.MESSAGE_CONTACTSKIPPED:
 
146
                        case MESSAGE_CONTACTSKIPPED:
105
147
                                _countSkips++;
106
148
                                updateStats();
107
149
                                break;
160
202
                // saving the state of an import sounds complicated! Lets just abort!
161
203
                abortImport();
162
204
 
163
 
                // notify the user
164
 
        Toast.makeText( this, R.string.doit_importaborted,
165
 
                        Toast.LENGTH_LONG ).show();
 
205
                // destroy some stuff
 
206
                _importer = null;
 
207
                _handler = null;
166
208
        }
167
209
 
168
210
        @Override
338
380
        {
339
381
                if( _importer != null )
340
382
                {
341
 
                        _importer.setAbort();
342
 
                        while( true ) {
343
 
                                try {
344
 
                                        _importer.join();
345
 
                                        break;
 
383
                        // try and flag worker thread - did we need to?
 
384
                        if( _importer.setAbort() )
 
385
                        {
 
386
                                // wait for worker thread to end
 
387
                                while( true ) {
 
388
                                        try {
 
389
                                                _importer.join();
 
390
                                                break;
 
391
                                        }
 
392
                                        catch( InterruptedException e ) {}
346
393
                                }
347
 
                                catch( InterruptedException e ) {}
 
394
 
 
395
                                // notify the user
 
396
                        Toast.makeText( this, R.string.doit_importaborted,
 
397
                                        Toast.LENGTH_LONG ).show();
348
398
                        }
349
399
                }
350
400
        }