/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/ContactsCache.java

  • Committer: edam
  • Date: 2012-12-19 17:51:35 UTC
  • Revision ID: tim@ed.am-20121219175135-1cpuafp76jg1ib1p
added preliminary (buggy) ContactsContract backend

Show diffs side-by-side

added added

removed removed

src/am/ed/importcontacts/ContactsCache.java
1
1
/*
2
2
 * ContactsCache.java
3
3
 *
4
 
 * Copyright (C) 2011 Tim Marston <edam@waxworlds.org>
 
4
 * Copyright (C) 2011 to 2012 Tim Marston <tim@ed.am>
5
5
 *
6
6
 * This file is part of the Import Contacts program (hereafter referred
7
7
 * to as "this program"). For more information, see
8
 
 * http://www.waxworlds.org/edam/software/android/import-contacts
 
8
 * http://ed.am/dev/android/import-contacts
9
9
 *
10
10
 * This program is free software: you can redistribute it and/or modify
11
11
 * it under the terms of the GNU General Public License as published by
21
21
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
22
 */
23
23
 
24
 
package org.waxworlds.edam.importcontacts;
 
24
package am.ed.importcontacts;
25
25
 
26
26
import java.util.HashMap;
27
27
import java.util.HashSet;
28
28
 
29
 
import org.waxworlds.edam.importcontacts.Importer.AbortImportException;
30
 
 
31
 
import android.app.Activity;
32
 
import android.database.Cursor;
33
 
import android.provider.Contacts;
34
 
 
35
 
 
36
29
public class ContactsCache
37
30
{
38
31
        /**
69
62
        }
70
63
 
71
64
        // mappings of contact names, organisations and primary numbers to ids
72
 
        private HashMap< String, Long > _contactsByName;
73
 
        private HashMap< String, Long > _contactsByOrg;
74
 
        private HashMap< String, Long > _contactsByNumber;
75
 
        private HashMap< String, Long > _contactsByEmail;
 
65
        private HashMap< String, Long > _contactsByName
 
66
                = new HashMap< String, Long >();
 
67
        private HashMap< String, Long > _contactsByOrg
 
68
                = new HashMap< String, Long >();
 
69
        private HashMap< String, Long > _contactsByNumber
 
70
                = new HashMap< String, Long >();
 
71
        private HashMap< String, Long > _contactsByEmail
 
72
                = new HashMap< String, Long >();
76
73
 
77
74
        // mapping of contact ids to sets of associated data
78
 
        private HashMap< Long, HashSet< String > > _contactNumbers;
79
 
        private HashMap< Long, HashSet< String > > _contactEmails;
80
 
        private HashMap< Long, HashSet< String > > _contactAddresses;
81
 
        private HashMap< Long, HashSet< String > > _contactOrganisations;
 
75
        private HashMap< Long, HashSet< String > > _contactNumbers
 
76
                = new HashMap< Long, HashSet< String > >();
 
77
        private HashMap< Long, HashSet< String > > _contactEmails
 
78
                = new HashMap< Long, HashSet< String > >();
 
79
        private HashMap< Long, HashSet< String > > _contactAddresses
 
80
                = new HashMap< Long, HashSet< String > >();
 
81
        private HashMap< Long, HashSet< String > > _contactOrganisations
 
82
                = new HashMap< Long, HashSet< String > >();
82
83
 
83
84
        public static CacheIdentifier createIdentifier(
84
85
                Importer.ContactData contact )
268
269
                set.add( normaliseOrganisation( organisation ) );
269
270
        }
270
271
 
271
 
        public void buildCache( Activity activity )
272
 
                throws AbortImportException
273
 
        {
274
 
                Cursor cur;
275
 
 
276
 
                // init id lookups
277
 
                _contactsByName = new HashMap< String, Long >();
278
 
                _contactsByOrg = new HashMap< String, Long >();
279
 
                _contactsByNumber = new HashMap< String, Long >();
280
 
                _contactsByEmail = new HashMap< String, Long >();
281
 
 
282
 
                // init associated data cache
283
 
                _contactNumbers = new HashMap< Long, HashSet< String > >();
284
 
                _contactEmails = new HashMap< Long, HashSet< String > >();
285
 
                _contactAddresses = new HashMap< Long, HashSet< String > >();
286
 
                _contactOrganisations = new HashMap< Long, HashSet< String > >();
287
 
 
288
 
                // set of contact ids that we have not yet added
289
 
                HashSet< Long > unadded = new HashSet< Long >();
290
 
 
291
 
                // get all contacts
292
 
                cur = activity.managedQuery( Contacts.People.CONTENT_URI,
293
 
                        new String[] {
294
 
                                Contacts.People._ID,
295
 
                                Contacts.People.NAME,
296
 
                        }, null, null, null );
297
 
                while( cur.moveToNext() ) {
298
 
                        Long id = cur.getLong(
299
 
                                cur.getColumnIndex( Contacts.People._ID ) );
300
 
                        String name = normaliseName( cur.getString(
301
 
                                cur.getColumnIndex( Contacts.People.NAME ) ) );
302
 
                        if( name != null )
303
 
                        {
304
 
                                // if we can, add a lookup for the contact id by name
305
 
                                if( name.length() > 0 ) {
306
 
                                        addLookup( new CacheIdentifier(
307
 
                                                CacheIdentifier.Type.NAME, name ), id );
308
 
                                        continue;
309
 
                                }
310
 
                        }
311
 
 
312
 
                        // record that a lookup for this contact's id still needs to be
313
 
                        // added by some other means
314
 
                        unadded.add( id );
315
 
                }
316
 
 
317
 
                // get contact organisations, primary ones first
318
 
                cur = activity.managedQuery( Contacts.Organizations.CONTENT_URI,
319
 
                        new String[] {
320
 
                                Contacts.Phones.PERSON_ID,
321
 
                                Contacts.Organizations.COMPANY,
322
 
                        }, null, null, Contacts.Organizations.ISPRIMARY + " DESC" );
323
 
                while( cur.moveToNext() ) {
324
 
                        Long id = cur.getLong( cur.getColumnIndex(
325
 
                                Contacts.Organizations.PERSON_ID ) );
326
 
                        String organisation = normaliseOrganisation( cur.getString(
327
 
                                cur.getColumnIndex( Contacts.Organizations.COMPANY ) ) );
328
 
                        if( organisation != null )
329
 
                        {
330
 
                                // if this is an organisation name for a contact for whom we
331
 
                                // have not added a lookup, add a lookup for the contact id
332
 
                                // by organisation
333
 
                                if( unadded.contains( id ) ) {
334
 
                                        addLookup( new CacheIdentifier(
335
 
                                                CacheIdentifier.Type.ORGANISATION, organisation ), id );
336
 
                                        unadded.remove( id );
337
 
                                }
338
 
 
339
 
                                // add associated data
340
 
                                addAssociatedOrganisation( id, organisation );
341
 
                        }
342
 
                }
343
 
 
344
 
                // get all phone numbers, primary ones first
345
 
                cur = activity.managedQuery( Contacts.Phones.CONTENT_URI,
346
 
                        new String[] {
347
 
                                Contacts.Phones.PERSON_ID,
348
 
                                Contacts.Phones.NUMBER,
349
 
                        }, null, null, Contacts.Phones.ISPRIMARY + " DESC" );
350
 
                while( cur.moveToNext() ) {
351
 
                        Long id = cur.getLong(
352
 
                                cur.getColumnIndex( Contacts.Phones.PERSON_ID ) );
353
 
                        String number = normalisePhoneNumber( cur.getString(
354
 
                                cur.getColumnIndex( Contacts.Phones.NUMBER ) ) );
355
 
                        if( number != null )
356
 
                        {
357
 
                                // if this is a number for a contact for whom we have not
358
 
                                // added a lookup, add a lookup for the contact id by phone
359
 
                                // number
360
 
                                if( unadded.contains( id ) ) {
361
 
                                        addLookup( new CacheIdentifier(
362
 
                                                CacheIdentifier.Type.PRIMARY_NUMBER, number ), id );
363
 
                                        unadded.remove( id );
364
 
                                }
365
 
 
366
 
                                // add associated data
367
 
                                addAssociatedNumber( id, number );
368
 
                        }
369
 
                }
370
 
 
371
 
                // now get all email addresses, primary ones first, and postal addresses
372
 
                cur = activity.managedQuery( Contacts.ContactMethods.CONTENT_URI,
373
 
                        new String[] {
374
 
                                Contacts.ContactMethods.PERSON_ID,
375
 
                                Contacts.ContactMethods.DATA,
376
 
                                Contacts.ContactMethods.KIND,
377
 
                        }, Contacts.ContactMethods.KIND + " IN( ?, ? )", new String[] {
378
 
                                "" + Contacts.KIND_EMAIL,
379
 
                                "" + Contacts.KIND_POSTAL,
380
 
                        }, Contacts.ContactMethods.ISPRIMARY + " DESC" );
381
 
                while( cur.moveToNext() ) {
382
 
                        Long id = cur.getLong(
383
 
                                cur.getColumnIndex( Contacts.ContactMethods.PERSON_ID ) );
384
 
                        int kind = cur.getInt(
385
 
                                cur.getColumnIndex( Contacts.ContactMethods.KIND ) );
386
 
                        if( kind == Contacts.KIND_EMAIL )
387
 
                        {
388
 
                                String email = normaliseEmailAddress( cur.getString(
389
 
                                        cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );
390
 
                                if( email != null )
391
 
                                {
392
 
                                        // if this is an email address for a contact for whom we
393
 
                                        // have not added a lookup, add a lookup for the contact
394
 
                                        // id by email address
395
 
                                        if( unadded.contains( id ) ) {
396
 
                                                addLookup( new CacheIdentifier(
397
 
                                                        CacheIdentifier.Type.PRIMARY_EMAIL, email ), id );
398
 
                                                unadded.remove( id );
399
 
                                        }
400
 
 
401
 
                                        // add associated data
402
 
                                        addAssociatedEmail( id, email );
403
 
                                }
404
 
                        }
405
 
                        else if( kind == Contacts.KIND_POSTAL )
406
 
                        {
407
 
                                String address = normaliseAddress( cur.getString(
408
 
                                        cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );
409
 
                                if( address != null )
410
 
                                {
411
 
                                        // add associated data
412
 
                                        addAssociatedAddress( id, address );
413
 
                                }
414
 
                        }
415
 
                }
416
 
        }
417
 
 
418
 
        static private String normaliseName( String name )
 
272
        static public String normaliseName( String name )
419
273
        {
420
274
                if( name == null ) return null;
421
275
                name = name.trim();
422
276
                return name.length() > 0? name : null;
423
277
        }
424
278
 
425
 
        static private String normalisePhoneNumber( String number )
 
279
        static public String normalisePhoneNumber( String number )
426
280
        {
427
281
                if( number == null ) return null;
428
282
                number = number.trim().replaceAll( "[-\\(\\) ]", "" );
429
283
                return number.length() > 0? number : null;
430
284
        }
431
285
 
432
 
        static private String normaliseEmailAddress( String email )
 
286
        static public String normaliseEmailAddress( String email )
433
287
        {
434
288
                if( email == null ) return null;
435
289
                email = email.trim().toLowerCase();
436
290
                return email.length() > 0? email : null;
437
291
        }
438
292
 
439
 
        static private String normaliseOrganisation( String organisation )
 
293
        static public String normaliseOrganisation( String organisation )
440
294
        {
441
295
                if( organisation == null ) return null;
442
296
                organisation = organisation.trim();
443
297
                return organisation.length() > 0? organisation : null;
444
298
        }
445
299
 
446
 
        static private String normaliseAddress( String address )
 
300
        static public String normaliseAddress( String address )
447
301
        {
448
302
                if( address == null ) return null;
449
303
                address = address.trim();