/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/ContactsContractBackend.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/ContactsContractBackend.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.HashMap;
27
 
import java.util.HashSet;
28
 
 
29
 
import am.ed.importcontacts.ContactsCache.CacheIdentifier;
30
 
import am.ed.importcontacts.Importer.ContactData;
31
 
import android.annotation.TargetApi;
32
 
import android.app.Activity;
33
 
import android.content.ContentUris;
34
 
import android.content.ContentValues;
35
 
import android.database.Cursor;
36
 
import android.net.Uri;
37
 
import android.provider.ContactsContract;
38
 
import android.provider.ContactsContract.CommonDataKinds;
39
 
 
40
 
@TargetApi(5)
41
 
public class ContactsContractBackend implements Backend
42
 
{
43
 
        private Activity _activity = null;
44
 
        private HashMap< Long, Long > _aggregate_to_raw_ids = null;
45
 
 
46
 
        ContactsContractBackend( Activity activity )
47
 
        {
48
 
                _activity = activity;
49
 
                _aggregate_to_raw_ids = new HashMap< Long, Long >();
50
 
        }
51
 
 
52
 
        @Override
53
 
        public void populateCache( ContactsCache cache )
54
 
        {
55
 
                Cursor cur;
56
 
 
57
 
                // build a set of aggregate contact ids that haven't been added to the
58
 
                // cache yet
59
 
                HashSet< Long > unadded_ids = new HashSet< Long >();
60
 
                cur = _activity.getContentResolver().query(
61
 
                        ContactsContract.Contacts.CONTENT_URI,
62
 
                        new String[] {
63
 
                                ContactsContract.Contacts._ID,
64
 
                        }, null, null, null );
65
 
                while( cur.moveToNext() ) {
66
 
                        Long id = cur.getLong(
67
 
                                cur.getColumnIndex( ContactsContract.Contacts._ID ) );
68
 
                        unadded_ids.add( id );
69
 
                }
70
 
                cur.close();
71
 
 
72
 
                // build a mapping of the ids of raw contacts to the ids of their
73
 
                // aggregate contacts
74
 
                HashMap< Long, Long > raw_to_aggregate_ids =
75
 
                        new HashMap< Long, Long >();
76
 
                cur = _activity.getContentResolver().query(
77
 
                        ContactsContract.RawContacts.CONTENT_URI,
78
 
                        new String[] {
79
 
                                ContactsContract.RawContacts._ID,
80
 
                                ContactsContract.RawContacts.CONTACT_ID,
81
 
                        }, ContactsContract.RawContacts.DELETED + " = 0", null, null );
82
 
                while( cur.moveToNext() ) {
83
 
                        Long raw_id = cur.getLong(
84
 
                                cur.getColumnIndex( ContactsContract.RawContacts._ID ) );
85
 
                        Long id = cur.getLong(
86
 
                                cur.getColumnIndex( ContactsContract.RawContacts.CONTACT_ID ) );
87
 
                        raw_to_aggregate_ids.put( raw_id, id );
88
 
                }
89
 
                cur.close();
90
 
 
91
 
                // get structured names, primary ones first
92
 
                cur = _activity.getContentResolver().query(
93
 
                        ContactsContract.Data.CONTENT_URI,
94
 
                        new String[] {
95
 
                                ContactsContract.Data.RAW_CONTACT_ID,
96
 
                                CommonDataKinds.StructuredName.DISPLAY_NAME,
97
 
                        },
98
 
                        ContactsContract.Data.MIMETYPE + " = '" +
99
 
                                CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE + "'",
100
 
                        null, ContactsContract.Data.IS_PRIMARY + " DESC" );
101
 
                while( cur.moveToNext() ) {
102
 
                        Long raw_id = cur.getLong( cur.getColumnIndex(
103
 
                                ContactsContract.Data.RAW_CONTACT_ID ) );
104
 
                        Long id = raw_to_aggregate_ids.get( raw_id );
105
 
                        if( id != null )
106
 
                        {
107
 
                                String name = cur.getString( cur.getColumnIndex(
108
 
                                        CommonDataKinds.StructuredName.DISPLAY_NAME ) );
109
 
 
110
 
                                // if this is a name for a contact for whom we have not added a
111
 
                                // lookup, add a lookup for the contact id by name
112
 
                                if( unadded_ids.contains( id ) ) {
113
 
                                        CacheIdentifier cache_identifier = CacheIdentifier.factory(
114
 
                                                CacheIdentifier.Type.NAME, name );
115
 
                                        if( cache_identifier != null ) {
116
 
                                                cache.addLookup( cache_identifier, id );
117
 
                                                unadded_ids.remove( id );
118
 
                                        }
119
 
                                }
120
 
                        }
121
 
                }
122
 
                cur.close();
123
 
 
124
 
                // get contact organisations, primary ones first
125
 
                cur = _activity.getContentResolver().query(
126
 
                        ContactsContract.Data.CONTENT_URI,
127
 
                        new String[] {
128
 
                                ContactsContract.Data.RAW_CONTACT_ID,
129
 
                                CommonDataKinds.Organization.COMPANY,
130
 
                        },
131
 
                        ContactsContract.Data.MIMETYPE + " = '" +
132
 
                                CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'",
133
 
                        null, ContactsContract.Data.IS_PRIMARY + " DESC" );
134
 
                while( cur.moveToNext() ) {
135
 
                        Long raw_id = cur.getLong( cur.getColumnIndex(
136
 
                                ContactsContract.Data.RAW_CONTACT_ID ) );
137
 
                        Long id = raw_to_aggregate_ids.get( raw_id );
138
 
                        if( id != null )
139
 
                        {
140
 
                                String organisation = cur.getString( cur.getColumnIndex(
141
 
                                        CommonDataKinds.Organization.COMPANY ) );
142
 
 
143
 
                                // if this is an organisation name for a contact for whom we
144
 
                                // have not added a lookup, add a lookup for the contact id
145
 
                                // by organisation
146
 
                                if( unadded_ids.contains( id ) ) {
147
 
                                        CacheIdentifier cache_identifier = CacheIdentifier.factory(
148
 
                                                CacheIdentifier.Type.ORGANISATION, organisation );
149
 
                                        if( cache_identifier != null ) {
150
 
                                                cache.addLookup( cache_identifier, id );
151
 
                                                unadded_ids.remove( id );
152
 
                                        }
153
 
                                }
154
 
 
155
 
                                // add associated data
156
 
                                cache.addAssociatedOrganisation( id, organisation );
157
 
                        }
158
 
                }
159
 
                cur.close();
160
 
 
161
 
                // get all phone numbers, primary ones first
162
 
                cur = _activity.getContentResolver().query(
163
 
                        ContactsContract.Data.CONTENT_URI,
164
 
                        new String[] {
165
 
                                ContactsContract.Data.RAW_CONTACT_ID,
166
 
                                CommonDataKinds.Phone.NUMBER,
167
 
                        },
168
 
                        ContactsContract.Data.MIMETYPE + " = '" +
169
 
                                CommonDataKinds.Phone.CONTENT_ITEM_TYPE + "'",
170
 
                        null, ContactsContract.Data.IS_PRIMARY + " DESC" );
171
 
                while( cur.moveToNext() ) {
172
 
                        Long raw_id = cur.getLong( cur.getColumnIndex(
173
 
                                ContactsContract.Data.RAW_CONTACT_ID ) );
174
 
                        Long id = raw_to_aggregate_ids.get( raw_id );
175
 
                        if( id != null )
176
 
                        {
177
 
                                String number = cur.getString( cur.getColumnIndex(
178
 
                                        CommonDataKinds.Phone.NUMBER ) );
179
 
 
180
 
                                // if this is a number for a contact for whom we have not
181
 
                                // added a lookup, add a lookup for the contact id by phone
182
 
                                // number
183
 
                                if( unadded_ids.contains( id ) ) {
184
 
                                        CacheIdentifier cache_identifier = CacheIdentifier.factory(
185
 
                                                CacheIdentifier.Type.PRIMARY_NUMBER, number );
186
 
                                        if( cache_identifier != null ) {
187
 
                                                cache.addLookup( cache_identifier, id );
188
 
                                                unadded_ids.remove( id );
189
 
                                        }
190
 
                                }
191
 
 
192
 
                                // add associated data
193
 
                                cache.addAssociatedNumber( id, number );
194
 
                        }
195
 
                }
196
 
                cur.close();
197
 
 
198
 
                // get all email addresses, primary ones first
199
 
                cur = _activity.getContentResolver().query(
200
 
                        ContactsContract.Data.CONTENT_URI,
201
 
                        new String[] {
202
 
                                ContactsContract.Data.RAW_CONTACT_ID,
203
 
                                CommonDataKinds.Email.DATA,
204
 
                        },
205
 
                        ContactsContract.Data.MIMETYPE + " = '" +
206
 
                                CommonDataKinds.Email.CONTENT_ITEM_TYPE + "'",
207
 
                        null, ContactsContract.Data.IS_PRIMARY + " DESC" );
208
 
                while( cur.moveToNext() ) {
209
 
                        Long raw_id = cur.getLong( cur.getColumnIndex(
210
 
                                ContactsContract.Data.RAW_CONTACT_ID ) );
211
 
                        Long id = raw_to_aggregate_ids.get( raw_id );
212
 
                        if( id != null )
213
 
                        {
214
 
                                String email = cur.getString( cur.getColumnIndex(
215
 
                                        CommonDataKinds.Email.DATA ) );
216
 
 
217
 
                                // if this is an email address for a contact for whom we have
218
 
                                // not added a lookup, add a lookup for the contact id by email
219
 
                                // address
220
 
                                if( unadded_ids.contains( id ) ) {
221
 
                                        CacheIdentifier cache_identifier = CacheIdentifier.factory(
222
 
                                                CacheIdentifier.Type.PRIMARY_EMAIL, email );
223
 
                                        if( cache_identifier != null ) {
224
 
                                                cache.addLookup( cache_identifier, id );
225
 
                                                unadded_ids.remove( id );
226
 
                                        }
227
 
                                }
228
 
 
229
 
                                // add associated data
230
 
                                cache.addAssociatedEmail( id, email );
231
 
                        }
232
 
                }
233
 
                cur.close();
234
 
 
235
 
                // get all postal addresses, primary ones first
236
 
                cur = _activity.getContentResolver().query(
237
 
                        ContactsContract.Data.CONTENT_URI,
238
 
                        new String[] {
239
 
                                ContactsContract.Data.RAW_CONTACT_ID,
240
 
                                CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS,
241
 
                        },
242
 
                        ContactsContract.Data.MIMETYPE + " = '" +
243
 
                                CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE + "'",
244
 
                        null, ContactsContract.Data.IS_PRIMARY + " DESC" );
245
 
                while( cur.moveToNext() ) {
246
 
                        Long raw_id = cur.getLong( cur.getColumnIndex(
247
 
                                ContactsContract.Data.RAW_CONTACT_ID ) );
248
 
                        Long id = raw_to_aggregate_ids.get( raw_id );
249
 
                        if( id != null )
250
 
                        {
251
 
                                String address = cur.getString( cur.getColumnIndex(
252
 
                                        CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS ) );
253
 
 
254
 
                                // add associated data
255
 
                                cache.addAssociatedAddress( id, address );
256
 
                        }
257
 
                }
258
 
                cur.close();
259
 
 
260
 
                // get all notes
261
 
                cur = _activity.getContentResolver().query(
262
 
                        ContactsContract.Data.CONTENT_URI,
263
 
                        new String[] {
264
 
                                ContactsContract.Data.RAW_CONTACT_ID,
265
 
                                CommonDataKinds.Note.NOTE,
266
 
                        },
267
 
                        ContactsContract.Data.MIMETYPE + " = '" +
268
 
                                CommonDataKinds.Note.CONTENT_ITEM_TYPE + "'",
269
 
                        null, null );
270
 
                while( cur.moveToNext() ) {
271
 
                        Long raw_id = cur.getLong( cur.getColumnIndex(
272
 
                                ContactsContract.Data.RAW_CONTACT_ID ) );
273
 
                        Long id = raw_to_aggregate_ids.get( raw_id );
274
 
                        if( id != null )
275
 
                        {
276
 
                                String note = cur.getString( cur.getColumnIndex(
277
 
                                        CommonDataKinds.Note.NOTE ) );
278
 
 
279
 
                                // add associated data
280
 
                                cache.addAssociatedNote( id, note );
281
 
                        }
282
 
                }
283
 
                cur.close();
284
 
        }
285
 
 
286
 
        @Override
287
 
        public void deleteContact( Long id )
288
 
        {
289
 
                Uri contact_uri = ContentUris.withAppendedId(
290
 
                        ContactsContract.Contacts.CONTENT_URI, id );
291
 
                _activity.getContentResolver().delete( contact_uri, null, null );
292
 
        }
293
 
 
294
 
        @Override
295
 
        public Long addContact( String name ) throws ContactCreationException
296
 
        {
297
 
                // create raw contact
298
 
                ContentValues values = new ContentValues();
299
 
                Uri contact_uri = _activity.getContentResolver().insert(
300
 
                        ContactsContract.RawContacts.CONTENT_URI, values);
301
 
                Long raw_id = ContentUris.parseId( contact_uri );
302
 
                if( raw_id == 0 ) throw new ContactCreationException();
303
 
 
304
 
                // add name data for this raw contact
305
 
                if( name != null ) {
306
 
                        values.put( ContactsContract.Data.RAW_CONTACT_ID, raw_id );
307
 
                        values.put( ContactsContract.Data.MIMETYPE,
308
 
                                CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE );
309
 
                        values.put( CommonDataKinds.StructuredName.DISPLAY_NAME, name );
310
 
                        _activity.getContentResolver().insert(
311
 
                                ContactsContract.Data.CONTENT_URI, values );
312
 
                }
313
 
 
314
 
                // find corresponding aggregate contact
315
 
                contact_uri = Uri.withAppendedPath(
316
 
                        ContentUris.withAppendedId(
317
 
                                ContactsContract.RawContacts.CONTENT_URI, raw_id ),
318
 
                        ContactsContract.RawContacts.Entity.CONTENT_DIRECTORY );
319
 
                Cursor cur = _activity.getContentResolver().query( contact_uri,
320
 
                        new String[] {
321
 
                                ContactsContract.RawContacts.CONTACT_ID,
322
 
                        }, null, null, null );
323
 
                Long id = null;
324
 
                if( cur.moveToNext() )
325
 
                        id = cur.getLong(
326
 
                                cur.getColumnIndex( ContactsContract.RawContacts.CONTACT_ID ) );
327
 
                cur.close();
328
 
                if( id == null || id == 0 )
329
 
                {
330
 
                        // we didn't find an aggregate contact id, so try to clean up (by
331
 
                        // deleting the raw contact we just created) before bailing
332
 
                        contact_uri = ContentUris.withAppendedId(
333
 
                                ContactsContract.RawContacts.CONTENT_URI, id );
334
 
                        _activity.getContentResolver().delete( contact_uri, null, null );
335
 
 
336
 
                        throw new ContactCreationException();
337
 
                }
338
 
 
339
 
                return id;
340
 
        }
341
 
 
342
 
        /**
343
 
         * Obtain the raw contact id for the phone-only raw contact that is
344
 
         * associated with the aggregate contact id.  One will be created if
345
 
         * necessary.
346
 
         * @param id the aggregate contact id
347
 
         * @return the raw contact id
348
 
         * @throws ContactCreationException
349
 
         */
350
 
        Long obtainRawContact( Long id ) throws ContactCreationException
351
 
        {
352
 
                // attempt to lookup cached value
353
 
                Long raw_id = _aggregate_to_raw_ids.get( id );
354
 
                if( raw_id != null ) return raw_id;
355
 
 
356
 
                // find a corresponding raw contact that has no account name/type
357
 
                Cursor cur = _activity.getContentResolver().query(
358
 
                        ContactsContract.RawContacts.CONTENT_URI,
359
 
                        new String[] {
360
 
                                ContactsContract.RawContacts._ID,
361
 
                                ContactsContract.RawContacts.ACCOUNT_NAME,
362
 
                        },
363
 
                        ContactsContract.RawContacts.DELETED + " = 0 AND " +
364
 
                                ContactsContract.RawContacts.CONTACT_ID + " = ? AND " +
365
 
                                "IFNULL( " + ContactsContract.RawContacts.ACCOUNT_NAME +
366
 
                                        ", '' ) = '' AND " +
367
 
                                "IFNULL( " + ContactsContract.RawContacts.ACCOUNT_TYPE +
368
 
                                        ", '' ) = ''",
369
 
                        new String[] {
370
 
                                String.valueOf( id ),
371
 
                        }, null );
372
 
                if( cur.moveToNext() )
373
 
                        raw_id = cur.getLong(
374
 
                                cur.getColumnIndex( ContactsContract.RawContacts._ID ) );
375
 
                cur.close();
376
 
 
377
 
                // if one wasn't found, we'll need to create one
378
 
                if( raw_id == null ) {
379
 
                        ContentValues values = new ContentValues();
380
 
                        Uri contact_uri = _activity.getContentResolver().insert(
381
 
                                ContactsContract.RawContacts.CONTENT_URI, values);
382
 
                        raw_id = ContentUris.parseId( contact_uri );
383
 
                        if( raw_id == 0 ) throw new ContactCreationException();
384
 
                }
385
 
 
386
 
                // save value in our cache
387
 
                _aggregate_to_raw_ids.put( id, raw_id );
388
 
                return raw_id;
389
 
        }
390
 
 
391
 
        private int convertTypeToBackendType( Class< ? > cls, int type )
392
 
                throws ContactCreationException
393
 
        {
394
 
                if( cls == CommonDataKinds.Phone.class )
395
 
                {
396
 
                        switch( type )
397
 
                        {
398
 
                        case ContactData.TYPE_HOME:
399
 
                                return CommonDataKinds.Phone.TYPE_HOME;
400
 
                        case ContactData.TYPE_WORK:
401
 
                                return CommonDataKinds.Phone.TYPE_WORK;
402
 
                        case ContactData.TYPE_MOBILE:
403
 
                                return CommonDataKinds.Phone.TYPE_MOBILE;
404
 
                        case ContactData.TYPE_FAX_HOME:
405
 
                                return CommonDataKinds.Phone.TYPE_FAX_HOME;
406
 
                        case ContactData.TYPE_FAX_WORK:
407
 
                                return CommonDataKinds.Phone.TYPE_FAX_WORK;
408
 
                        case ContactData.TYPE_PAGER:
409
 
                                return CommonDataKinds.Phone.TYPE_PAGER;
410
 
                        }
411
 
                }
412
 
                else if( cls == CommonDataKinds.Email.class )
413
 
                {
414
 
                        switch( type )
415
 
                        {
416
 
                        case ContactData.TYPE_HOME:
417
 
                                return CommonDataKinds.Email.TYPE_HOME;
418
 
                        case ContactData.TYPE_WORK:
419
 
                                return CommonDataKinds.Email.TYPE_WORK;
420
 
                        }
421
 
                }
422
 
                else if( cls == CommonDataKinds.StructuredPostal.class )
423
 
                {
424
 
                        switch( type )
425
 
                        {
426
 
                        case ContactData.TYPE_HOME:
427
 
                                return CommonDataKinds.StructuredPostal.TYPE_HOME;
428
 
                        case ContactData.TYPE_WORK:
429
 
                                return CommonDataKinds.StructuredPostal.TYPE_WORK;
430
 
                        }
431
 
                }
432
 
 
433
 
                // still here?
434
 
                throw new ContactCreationException();
435
 
        }
436
 
 
437
 
        @Override
438
 
        public void addContactPhone( Long id, String number,
439
 
                ContactData.PreferredDetail data ) throws ContactCreationException
440
 
        {
441
 
                ContentValues values = new ContentValues();
442
 
                values.put( ContactsContract.Data.RAW_CONTACT_ID,
443
 
                        obtainRawContact( id ) );
444
 
                values.put( ContactsContract.Data.MIMETYPE,
445
 
                        CommonDataKinds.Phone.CONTENT_ITEM_TYPE );
446
 
                values.put( CommonDataKinds.Phone.TYPE,
447
 
                        convertTypeToBackendType( CommonDataKinds.Phone.class,
448
 
                                data.getType() ) );
449
 
                values.put( CommonDataKinds.Phone.NUMBER, number );
450
 
                if( data.isPreferred() )
451
 
                        values.put( CommonDataKinds.Phone.IS_PRIMARY, 1 );
452
 
 
453
 
                _activity.getContentResolver().insert(
454
 
                        ContactsContract.Data.CONTENT_URI, values );
455
 
        }
456
 
 
457
 
        @Override
458
 
        public void addContactEmail( Long id, String email,
459
 
                ContactData.PreferredDetail data ) throws ContactCreationException
460
 
        {
461
 
                ContentValues values = new ContentValues();
462
 
                values.put( ContactsContract.Data.RAW_CONTACT_ID,
463
 
                        obtainRawContact( id ) );
464
 
                values.put( ContactsContract.Data.MIMETYPE,
465
 
                        CommonDataKinds.Email.CONTENT_ITEM_TYPE );
466
 
                values.put( CommonDataKinds.Email.TYPE,
467
 
                        convertTypeToBackendType( CommonDataKinds.Email.class,
468
 
                                data.getType() ) );
469
 
                values.put( CommonDataKinds.Email.DATA, email );
470
 
                if( data.isPreferred() )
471
 
                        values.put( CommonDataKinds.Email.IS_PRIMARY, 1 );
472
 
 
473
 
                _activity.getContentResolver().insert(
474
 
                        ContactsContract.Data.CONTENT_URI, values );
475
 
        }
476
 
 
477
 
        @Override
478
 
        public void addContactAddresses( Long id, String address,
479
 
                ContactData.TypeDetail data ) throws ContactCreationException
480
 
        {
481
 
                ContentValues values = new ContentValues();
482
 
                values.put( ContactsContract.Data.RAW_CONTACT_ID,
483
 
                        obtainRawContact( id ) );
484
 
                values.put( ContactsContract.Data.MIMETYPE,
485
 
                        CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE );
486
 
                values.put( CommonDataKinds.StructuredPostal.TYPE,
487
 
                        convertTypeToBackendType( CommonDataKinds.StructuredPostal.class,
488
 
                                data.getType() ) );
489
 
                values.put(
490
 
                        CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, address );
491
 
 
492
 
                _activity.getContentResolver().insert(
493
 
                        ContactsContract.Data.CONTENT_URI, values );
494
 
        }
495
 
 
496
 
        @Override
497
 
        public void addContactOrganisation( Long id, String organisation,
498
 
                ContactData.ExtraDetail data ) throws ContactCreationException
499
 
        {
500
 
                ContentValues values = new ContentValues();
501
 
                values.put( ContactsContract.Data.RAW_CONTACT_ID,
502
 
                        obtainRawContact( id ) );
503
 
                values.put( ContactsContract.Data.MIMETYPE,
504
 
                        CommonDataKinds.Organization.CONTENT_ITEM_TYPE );
505
 
                values.put( CommonDataKinds.Organization.TYPE,
506
 
                        CommonDataKinds.Organization.TYPE_WORK );
507
 
                values.put(
508
 
                        CommonDataKinds.Organization.COMPANY, organisation );
509
 
                if( data.getExtra() != null )
510
 
                        values.put( CommonDataKinds.Organization.TITLE, data.getExtra() );
511
 
 
512
 
                _activity.getContentResolver().insert(
513
 
                        ContactsContract.Data.CONTENT_URI, values );
514
 
        }
515
 
 
516
 
        @Override
517
 
        public void addContactNote( Long id, String note )
518
 
                throws ContactCreationException
519
 
        {
520
 
                ContentValues values = new ContentValues();
521
 
                values.put( ContactsContract.Data.RAW_CONTACT_ID,
522
 
                        obtainRawContact( id ) );
523
 
                values.put( ContactsContract.Data.MIMETYPE,
524
 
                        CommonDataKinds.Note.CONTENT_ITEM_TYPE );
525
 
                values.put(
526
 
                        CommonDataKinds.Note.NOTE, note );
527
 
 
528
 
                _activity.getContentResolver().insert(
529
 
                        ContactsContract.Data.CONTENT_URI, values );
530
 
        }
531
 
 
532
 
}