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

  • Committer: edam
  • Date: 2012-04-24 09:59:29 UTC
  • Revision ID: tim@ed.am-20120424095929-xqba0cyao1hxlg6r
updated project homepage URL to ed.am

Show diffs side-by-side

added added

removed removed

src/am/ed/importcontacts/Importer.java
1
1
/*
2
2
 * Importer.java
3
3
 *
4
 
 * Copyright (C) 2009 to 2012 Tim Marston <tim@ed.am>
 
4
 * Copyright (C) 2009 to 2011 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
31
31
import java.util.regex.Matcher;
32
32
import java.util.regex.Pattern;
33
33
 
 
34
import android.content.ContentUris;
 
35
import android.content.ContentValues;
34
36
import android.content.SharedPreferences;
 
37
import android.net.Uri;
35
38
import android.os.Message;
 
39
import android.provider.Contacts;
36
40
import android.provider.Contacts.PhonesColumns;
37
41
 
 
42
 
38
43
public class Importer extends Thread
39
44
{
40
45
        public final static int ACTION_ABORT = 1;
54
59
        private boolean _abort = false;
55
60
        private boolean _is_finished = false;
56
61
        private ContactsCache _contacts_cache = null;
57
 
        private Backend _backend = null;
58
62
 
59
63
        /**
60
64
         * Data about a contact
270
274
                        email = sanitisesEmailAddress( email );
271
275
                        if( email == null )
272
276
                        {
273
 
                                // TODO: warn that an imported email address is being ignored
 
277
                                // TODO: warn that an imported email addtrss is being ignored
274
278
                                return;
275
279
                        }
276
280
 
417
421
                        // update UI
418
422
                        setProgressMessage( R.string.doit_caching );
419
423
 
420
 
                        // create the appropriate backend
421
 
//                      if( Integer.parseInt( android.os.Build.VERSION.SDK ) >= 5 )
422
 
//                              _backend = new ContactsContractBackend( _doit );
423
 
//                      else
424
 
                                _backend = new ContactsBackend( _doit );
425
 
 
426
 
                        // create a cache of existing contacts and populate it
 
424
                        // build a cache of existing contacts
427
425
                        _contacts_cache = new ContactsCache();
428
 
                        _backend.populateCache( _contacts_cache );
 
426
                        _contacts_cache.buildCache( _doit );
429
427
 
430
428
                        // do the import
431
429
                        onImport();
685
683
                        // should we skip this import altogether?
686
684
                        if( _last_merge_decision == Doit.ACTION_KEEP ) return;
687
685
 
 
686
                        // get contact's URI
 
687
                        Uri contact_uri = ContentUris.withAppendedId(
 
688
                                Contacts.People.CONTENT_URI, id );
 
689
 
688
690
                        // should we destroy the existing contact before importing?
689
691
                        if( _last_merge_decision == Doit.ACTION_OVERWRITE )
690
692
                        {
691
693
                                // remove from device
692
 
                                _backend.deleteContact( id );
 
694
                                _doit.getContentResolver().delete( contact_uri, null, null );
693
695
 
694
696
                                // update cache
695
 
                                _contacts_cache.removeLookup( cache_identifier );
 
697
                                _contacts_cache.removeLookup( contact.getCacheIdentifier() );
696
698
                                _contacts_cache.removeAssociatedData( id );
697
699
 
698
700
                                // show that we're overwriting a contact
705
707
                        }
706
708
                }
707
709
 
708
 
                // if we don't have a contact id yet (or we did, but we destroyed it
 
710
                // if we don't have a contact id yet (or if we did, but we destroyed it
709
711
                // when we deleted the contact), we'll have to create a new contact
710
712
                if( id == null )
711
713
                {
712
714
                        // create a new contact
713
 
                        id = _backend.addContact( contact._name );
714
 
                        if( id == null )
 
715
                        ContentValues values = new ContentValues();
 
716
                        values.put( Contacts.People.NAME, contact._name );
 
717
                        Uri contact_uri = _doit.getContentResolver().insert(
 
718
                                Contacts.People.CONTENT_URI, values );
 
719
                        id = ContentUris.parseId( contact_uri );
 
720
                        if( id == null || id <= 0 )
715
721
                                showError( R.string.error_unabletoaddcontact );
716
722
 
 
723
                        // try to add them to the "My Contacts" group
 
724
                        try {
 
725
                                Contacts.People.addToMyContactsGroup(
 
726
                                        _doit.getContentResolver(), id );
 
727
                        }
 
728
                        catch( IllegalStateException e ) {
 
729
                                // ignore any failure
 
730
                        }
 
731
 
717
732
                        // update cache
718
 
                        _contacts_cache.addLookup( cache_identifier, id );
 
733
                        _contacts_cache.addLookup(
 
734
                                ContactsCache.createIdentifier( contact ), id );
719
735
 
720
736
                        // if we haven't already shown that we're overwriting a contact,
721
737
                        // show that we're creating a new contact
744
760
        private void importContactPhones( Long id,
745
761
                        HashMap< String, ContactData.PreferredDetail > datas )
746
762
        {
 
763
                // get URI to contact's phones
 
764
                Uri contact_phones_uri = Uri.withAppendedPath(
 
765
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id ),
 
766
                        Contacts.People.Phones.CONTENT_DIRECTORY );
 
767
                Set< String > datas_keys = datas.keySet();
 
768
 
747
769
                // add phone numbers
748
 
                Set< String > datas_keys = datas.keySet();
749
770
                Iterator< String > i = datas_keys.iterator();
750
771
                while( i.hasNext() ) {
751
772
                        String number = i.next();
762
783
                                continue;
763
784
 
764
785
                        // add phone number
765
 
                        _backend.addContactPhone( id, number, data );
 
786
                        ContentValues values = new ContentValues();
 
787
                        values.put( Contacts.Phones.TYPE, data.getType() );
 
788
                        values.put( Contacts.Phones.NUMBER, number );
 
789
                        if( data.isPreferred() )
 
790
                                values.put( Contacts.Phones.ISPRIMARY, 1 );
 
791
                        _doit.getContentResolver().insert( contact_phones_uri, values );
766
792
 
767
793
                        // and add this address to the cache to prevent a addition of
768
794
                        // duplicate date from another file
773
799
        private void importContactEmails( Long id,
774
800
                        HashMap< String, ContactData.PreferredDetail > datas )
775
801
        {
 
802
                // get URI to contact's contact methods
 
803
                Uri contact_contact_methods_uri = Uri.withAppendedPath(
 
804
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id ),
 
805
                        Contacts.People.ContactMethods.CONTENT_DIRECTORY );
 
806
                Set< String > datas_keys = datas.keySet();
 
807
 
776
808
                // add email addresses
777
 
                Set< String > datas_keys = datas.keySet();
778
809
                Iterator< String > i = datas_keys.iterator();
779
810
                while( i.hasNext() ) {
780
811
                        String email = i.next();
786
817
                                continue;
787
818
 
788
819
                        // add phone number
789
 
                        _backend.addContactEmail( id, email, data );
 
820
                        ContentValues values = new ContentValues();
 
821
                        values.put( Contacts.ContactMethods.KIND, Contacts.KIND_EMAIL );
 
822
                        values.put( Contacts.ContactMethods.DATA, email );
 
823
                        values.put( Contacts.ContactMethods.TYPE, data.getType() );
 
824
                        if( data.isPreferred() )
 
825
                                values.put( Contacts.ContactMethods.ISPRIMARY, 1 );
 
826
                        _doit.getContentResolver().insert( contact_contact_methods_uri,
 
827
                                values );
790
828
 
791
829
                        // and add this address to the cache to prevent a addition of
792
830
                        // duplicate date from another file
797
835
        private void importContactAddresses( Long id,
798
836
                HashMap< String, ContactData.TypeDetail > datas )
799
837
        {
 
838
                // get URI to contact's contact methods
 
839
                Uri contact_contact_methods_uri = Uri.withAppendedPath(
 
840
                        ContentUris.withAppendedId( Contacts.People.CONTENT_URI, id ),
 
841
                        Contacts.People.ContactMethods.CONTENT_DIRECTORY );
 
842
 
800
843
                // add addresses
801
844
                Set< String > datas_keys = datas.keySet();
802
845
                Iterator< String > i = datas_keys.iterator();
810
853
                                continue;
811
854
 
812
855
                        // add postal address
813
 
                        _backend.addContactAddresses( id, address, data );
 
856
                        ContentValues values = new ContentValues();
 
857
                        values.put( Contacts.ContactMethods.KIND, Contacts.KIND_POSTAL );
 
858
                        values.put( Contacts.ContactMethods.DATA, address );
 
859
                        values.put( Contacts.ContactMethods.TYPE, data.getType() );
 
860
                        _doit.getContentResolver().insert( contact_contact_methods_uri,
 
861
                                values );
814
862
 
815
863
                        // and add this address to the cache to prevent a addition of
816
864
                        // duplicate date from another file
834
882
                                continue;
835
883
 
836
884
                        // add organisation address
837
 
                        _backend.addContactOrganisation( id, organisation, data );
 
885
                        ContentValues values = new ContentValues();
 
886
                        values.put( Contacts.Organizations.PERSON_ID, id );
 
887
                        values.put( Contacts.Organizations.COMPANY, organisation );
 
888
                        values.put( Contacts.ContactMethods.TYPE,
 
889
                                Contacts.OrganizationColumns.TYPE_WORK );
 
890
                        if( data.getExtra() != null )
 
891
                                values.put( Contacts.Organizations.TITLE, data.getExtra() );
 
892
                        _doit.getContentResolver().insert(
 
893
                                Contacts.Organizations.CONTENT_URI, values );
838
894
 
839
895
                        // and add this address to the cache to prevent a addition of
840
896
                        // duplicate date from another file