/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/am/ed/importcontacts/ContactsBackend.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/am/ed/importcontacts/ContactsBackend.java
1
 
/*
2
 
 * ContactsBackend.java
3
 
 *
4
 
 * Copyright (C) 2012 Tim Marston <tim@ed.am>
5
 
 *
6
 
 * This file is part of the Import Contacts program (hereafter referred
7
 
 * to as "this program"). For more information, see
8
 
 * http://ed.am/dev/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
 
package am.ed.importcontacts;
25
 
 
26
 
import java.util.HashSet;
27
 
 
28
 
import am.ed.importcontacts.ContactsCache.CacheIdentifier;
29
 
import am.ed.importcontacts.Importer.ContactData;
30
 
import android.app.Activity;
31
 
import android.content.ContentUris;
32
 
import android.content.ContentValues;
33
 
import android.database.Cursor;
34
 
import android.net.Uri;
35
 
import android.provider.Contacts;
36
 
 
37
 
 
38
 
public class ContactsBackend implements Backend
39
 
{
40
 
        private Activity _activity = null;
41
 
 
42
 
        ContactsBackend( Activity activity )
43
 
        {
44
 
                _activity = activity;
45
 
        }
46
 
 
47
 
        @Override
48
 
        public void populateCache( ContactsCache cache )
49
 
        {
50
 
                Cursor cur;
51
 
 
52
 
                // set of contact ids that we have not yet added
53
 
                HashSet< Long > unadded = new HashSet< Long >();
54
 
 
55
 
                // get all contacts
56
 
                cur = _activity.managedQuery( Contacts.People.CONTENT_URI,
57
 
                        new String[] {
58
 
                                Contacts.People._ID,
59
 
                                Contacts.People.NAME,
60
 
                        }, null, null, null );
61
 
                while( cur.moveToNext() ) {
62
 
                        Long id = cur.getLong(
63
 
                                cur.getColumnIndex( Contacts.People._ID ) );
64
 
                        String name =
65
 
                                ContactsCache.normaliseName( cur.getString(
66
 
                                        cur.getColumnIndex( Contacts.People.NAME ) ) );
67
 
                        if( name != null )
68
 
                        {
69
 
                                // if we can, add a lookup for the contact id by name
70
 
                                if( name.length() > 0 ) {
71
 
                                        cache.addLookup( new CacheIdentifier(
72
 
                                                CacheIdentifier.Type.NAME, name ), id );
73
 
                                        continue;
74
 
                                }
75
 
                        }
76
 
 
77
 
                        // record that a lookup for this contact's id still needs to be
78
 
                        // added by some other means
79
 
                        unadded.add( id );
80
 
                }
81
 
 
82
 
                // get contact organisations, primary ones first
83
 
                cur = _activity.managedQuery( Contacts.Organizations.CONTENT_URI,
84
 
                        new String[] {
85
 
                                Contacts.Phones.PERSON_ID,
86
 
                                Contacts.Organizations.COMPANY,
87
 
                        }, null, null, Contacts.Organizations.ISPRIMARY + " DESC" );
88
 
                while( cur.moveToNext() ) {
89
 
                        Long id = cur.getLong( cur.getColumnIndex(
90
 
                                Contacts.Organizations.PERSON_ID ) );
91
 
                        String organisation =
92
 
                                ContactsCache.normaliseOrganisation( cur.getString(
93
 
                                        cur.getColumnIndex( Contacts.Organizations.COMPANY ) ) );
94
 
                        if( organisation != null )
95
 
                        {
96
 
                                // if this is an organisation name for a contact for whom we
97
 
                                // have not added a lookup, add a lookup for the contact id
98
 
                                // by organisation
99
 
                                if( unadded.contains( id ) ) {
100
 
                                        cache.addLookup( new CacheIdentifier(
101
 
                                                CacheIdentifier.Type.ORGANISATION, organisation ), id );
102
 
                                        unadded.remove( id );
103
 
                                }
104
 
 
105
 
                                // add associated data
106
 
                                cache.addAssociatedOrganisation( id, organisation );
107
 
                        }
108
 
                }
109
 
 
110
 
                // get all phone numbers, primary ones first
111
 
                cur = _activity.managedQuery( Contacts.Phones.CONTENT_URI,
112
 
                        new String[] {
113
 
                                Contacts.Phones.PERSON_ID,
114
 
                                Contacts.Phones.NUMBER,
115
 
                        }, null, null, Contacts.Phones.ISPRIMARY + " DESC" );
116
 
                while( cur.moveToNext() ) {
117
 
                        Long id = cur.getLong(
118
 
                                cur.getColumnIndex( Contacts.Phones.PERSON_ID ) );
119
 
                        String number =
120
 
                                ContactsCache.normalisePhoneNumber( cur.getString(
121
 
                                        cur.getColumnIndex( Contacts.Phones.NUMBER ) ) );
122
 
                        if( number != null )
123
 
                        {
124
 
                                // if this is a number for a contact for whom we have not
125
 
                                // added a lookup, add a lookup for the contact id by phone
126
 
                                // number
127
 
                                if( unadded.contains( id ) ) {
128
 
                                        cache.addLookup( new CacheIdentifier(
129
 
                                                CacheIdentifier.Type.PRIMARY_NUMBER, number ), id );
130
 
                                        unadded.remove( id );
131
 
                                }
132
 
 
133
 
                                // add associated data
134
 
                                cache.addAssociatedNumber( id, number );
135
 
                        }
136
 
                }
137
 
 
138
 
                // now get all email addresses, primary ones first, and postal addresses
139
 
                cur = _activity.managedQuery( Contacts.ContactMethods.CONTENT_URI,
140
 
                        new String[] {
141
 
                                Contacts.ContactMethods.PERSON_ID,
142
 
                                Contacts.ContactMethods.DATA,
143
 
                                Contacts.ContactMethods.KIND,
144
 
                        }, Contacts.ContactMethods.KIND + " IN( ?, ? )", new String[] {
145
 
                                "" + Contacts.KIND_EMAIL,
146
 
                                "" + Contacts.KIND_POSTAL,
147
 
                        }, Contacts.ContactMethods.ISPRIMARY + " DESC" );
148
 
                while( cur.moveToNext() ) {
149
 
                        Long id = cur.getLong(
150
 
                                cur.getColumnIndex( Contacts.ContactMethods.PERSON_ID ) );
151
 
                        int kind = cur.getInt(
152
 
                                cur.getColumnIndex( Contacts.ContactMethods.KIND ) );
153
 
                        if( kind == Contacts.KIND_EMAIL )
154
 
                        {
155
 
                                String email =
156
 
                                        ContactsCache.normaliseEmailAddress( cur.getString(
157
 
                                                cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );
158
 
                                if( email != null )
159
 
                                {
160
 
                                        // if this is an email address for a contact for whom we
161
 
                                        // have not added a lookup, add a lookup for the contact
162
 
                                        // id by email address
163
 
                                        if( unadded.contains( id ) ) {
164
 
                                                cache.addLookup( new CacheIdentifier(
165
 
                                                        CacheIdentifier.Type.PRIMARY_EMAIL, email ), id );
166
 
                                                unadded.remove( id );
167
 
                                        }
168
 
 
169
 
                                        // add associated data
170
 
                                        cache.addAssociatedEmail( id, email );
171
 
                                }
172
 
                        }
173
 
                        else if( kind == Contacts.KIND_POSTAL )
174
 
                        {
175
 
                                String address =
176
 
                                        ContactsCache.normaliseAddress( cur.getString(
177
 
                                                cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );
178
 
                                if( address != null )
179
 
                                {
180
 
                                        // add associated data
181
 
                                        cache.addAssociatedAddress( id, address );
182
 
                                }
183
 
                        }
184
 
                }
185
 
        }
186
 
 
187
 
        @Override
188
 
        public void deleteContact( Long id )
189
 
        {
190
 
                Uri contact_uri =
191
 
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id );
192
 
                _activity.getContentResolver().delete( contact_uri, null, null );
193
 
        }
194
 
 
195
 
        @Override
196
 
        public Long addContact( String name )
197
 
        {
198
 
                ContentValues values = new ContentValues();
199
 
                values.put( Contacts.People.NAME, name );
200
 
                Uri contact_uri = _activity.getContentResolver().insert(
201
 
                        Contacts.People.CONTENT_URI, values );
202
 
                Long id = ContentUris.parseId( contact_uri );
203
 
 
204
 
                // try to add them to the "My Contacts" group
205
 
                if( id != null && id > 0 ) {
206
 
                        try {
207
 
                                Contacts.People.addToMyContactsGroup(
208
 
                                        _activity.getContentResolver(), id );
209
 
                        }
210
 
                        catch( IllegalStateException e ) {
211
 
                                // ignore any failure
212
 
                        }
213
 
                }
214
 
 
215
 
                return id == null? 0 : id;
216
 
        }
217
 
 
218
 
        @Override
219
 
        public void addContactPhone( Long id, String number,
220
 
                ContactData.PreferredDetail data )
221
 
        {
222
 
                Uri contact_phones_uri = Uri.withAppendedPath(
223
 
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id ),
224
 
                        Contacts.People.Phones.CONTENT_DIRECTORY );
225
 
 
226
 
                ContentValues values = new ContentValues();
227
 
                values.put( Contacts.Phones.TYPE, data.getType() );
228
 
                values.put( Contacts.Phones.NUMBER, number );
229
 
                if( data.isPreferred() )
230
 
                        values.put( Contacts.Phones.ISPRIMARY, 1 );
231
 
 
232
 
                _activity.getContentResolver().insert( contact_phones_uri, values );
233
 
        }
234
 
 
235
 
        @Override
236
 
        public void addContactEmail( Long id, String email,
237
 
                ContactData.PreferredDetail data )
238
 
        {
239
 
                Uri contact_contact_methods_uri = Uri.withAppendedPath(
240
 
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id ),
241
 
                        Contacts.People.ContactMethods.CONTENT_DIRECTORY );
242
 
 
243
 
                ContentValues values = new ContentValues();
244
 
                values.put( Contacts.ContactMethods.KIND, Contacts.KIND_EMAIL );
245
 
                values.put( Contacts.ContactMethods.DATA, email );
246
 
                values.put( Contacts.ContactMethods.TYPE, data.getType() );
247
 
                if( data.isPreferred() )
248
 
                        values.put( Contacts.ContactMethods.ISPRIMARY, 1 );
249
 
 
250
 
                _activity.getContentResolver().insert( contact_contact_methods_uri,
251
 
                        values );
252
 
        }
253
 
 
254
 
        @Override
255
 
        public void addContactAddresses( Long id, String address,
256
 
                ContactData.TypeDetail data )
257
 
        {
258
 
                Uri contact_contact_methods_uri = Uri.withAppendedPath(
259
 
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id ),
260
 
                        Contacts.People.ContactMethods.CONTENT_DIRECTORY );
261
 
 
262
 
                ContentValues values = new ContentValues();
263
 
                values.put( Contacts.ContactMethods.KIND, Contacts.KIND_POSTAL );
264
 
                values.put( Contacts.ContactMethods.DATA, address );
265
 
                values.put( Contacts.ContactMethods.TYPE, data.getType() );
266
 
 
267
 
                _activity.getContentResolver().insert( contact_contact_methods_uri,
268
 
                        values );
269
 
        }
270
 
 
271
 
        @Override
272
 
        public void addContactOrganisation( Long id, String organisation,
273
 
                ContactData.ExtraDetail data )
274
 
        {
275
 
                ContentValues values = new ContentValues();
276
 
                values.put( Contacts.Organizations.PERSON_ID, id );
277
 
                values.put( Contacts.Organizations.COMPANY, organisation );
278
 
                values.put( Contacts.ContactMethods.TYPE,
279
 
                        Contacts.OrganizationColumns.TYPE_WORK );
280
 
                if( data.getExtra() != null )
281
 
                        values.put( Contacts.Organizations.TITLE, data.getExtra() );
282
 
 
283
 
                _activity.getContentResolver().insert(
284
 
                        Contacts.Organizations.CONTENT_URI, values );
285
 
        }
286
 
 
287
 
 
288
 
}