/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-12-19 17:41:29 UTC
  • Revision ID: tim@ed.am-20121219174129-41i7vrz0jviideqi
fix intro strings

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 2011 Tim Marston <tim@ed.am>
 
4
 * Copyright (C) 2009 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
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;
36
34
import android.content.SharedPreferences;
37
 
import android.net.Uri;
38
35
import android.os.Message;
39
 
import android.provider.Contacts;
40
36
import android.provider.Contacts.PhonesColumns;
41
37
 
42
 
 
43
38
public class Importer extends Thread
44
39
{
45
40
        public final static int ACTION_ABORT = 1;
59
54
        private boolean _abort = false;
60
55
        private boolean _is_finished = false;
61
56
        private ContactsCache _contacts_cache = null;
 
57
        private Backend _backend = null;
62
58
 
63
59
        /**
64
60
         * Data about a contact
274
270
                        email = sanitisesEmailAddress( email );
275
271
                        if( email == null )
276
272
                        {
277
 
                                // TODO: warn that an imported email addtrss is being ignored
 
273
                                // TODO: warn that an imported email address is being ignored
278
274
                                return;
279
275
                        }
280
276
 
421
417
                        // update UI
422
418
                        setProgressMessage( R.string.doit_caching );
423
419
 
424
 
                        // build a cache of existing contacts
 
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
425
427
                        _contacts_cache = new ContactsCache();
426
 
                        _contacts_cache.buildCache( _doit );
 
428
                        _backend.populateCache( _contacts_cache );
427
429
 
428
430
                        // do the import
429
431
                        onImport();
683
685
                        // should we skip this import altogether?
684
686
                        if( _last_merge_decision == Doit.ACTION_KEEP ) return;
685
687
 
686
 
                        // get contact's URI
687
 
                        Uri contact_uri = ContentUris.withAppendedId(
688
 
                                Contacts.People.CONTENT_URI, id );
689
 
 
690
688
                        // should we destroy the existing contact before importing?
691
689
                        if( _last_merge_decision == Doit.ACTION_OVERWRITE )
692
690
                        {
693
691
                                // remove from device
694
 
                                _doit.getContentResolver().delete( contact_uri, null, null );
 
692
                                _backend.deleteContact( id );
695
693
 
696
694
                                // update cache
697
 
                                _contacts_cache.removeLookup( contact.getCacheIdentifier() );
 
695
                                _contacts_cache.removeLookup( cache_identifier );
698
696
                                _contacts_cache.removeAssociatedData( id );
699
697
 
700
698
                                // show that we're overwriting a contact
707
705
                        }
708
706
                }
709
707
 
710
 
                // if we don't have a contact id yet (or if we did, but we destroyed it
 
708
                // if we don't have a contact id yet (or we did, but we destroyed it
711
709
                // when we deleted the contact), we'll have to create a new contact
712
710
                if( id == null )
713
711
                {
714
712
                        // create a new contact
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 )
 
713
                        id = _backend.addContact( contact._name );
 
714
                        if( id == null )
721
715
                                showError( R.string.error_unabletoaddcontact );
722
716
 
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
 
 
732
717
                        // update cache
733
 
                        _contacts_cache.addLookup(
734
 
                                ContactsCache.createIdentifier( contact ), id );
 
718
                        _contacts_cache.addLookup( cache_identifier, id );
735
719
 
736
720
                        // if we haven't already shown that we're overwriting a contact,
737
721
                        // show that we're creating a new contact
760
744
        private void importContactPhones( Long id,
761
745
                        HashMap< String, ContactData.PreferredDetail > datas )
762
746
        {
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
 
 
769
747
                // add phone numbers
 
748
                Set< String > datas_keys = datas.keySet();
770
749
                Iterator< String > i = datas_keys.iterator();
771
750
                while( i.hasNext() ) {
772
751
                        String number = i.next();
783
762
                                continue;
784
763
 
785
764
                        // add phone number
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 );
 
765
                        _backend.addContactPhone( id, number, data );
792
766
 
793
767
                        // and add this address to the cache to prevent a addition of
794
768
                        // duplicate date from another file
799
773
        private void importContactEmails( Long id,
800
774
                        HashMap< String, ContactData.PreferredDetail > datas )
801
775
        {
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
 
 
808
776
                // add email addresses
 
777
                Set< String > datas_keys = datas.keySet();
809
778
                Iterator< String > i = datas_keys.iterator();
810
779
                while( i.hasNext() ) {
811
780
                        String email = i.next();
817
786
                                continue;
818
787
 
819
788
                        // add phone number
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 );
 
789
                        _backend.addContactEmail( id, email, data );
828
790
 
829
791
                        // and add this address to the cache to prevent a addition of
830
792
                        // duplicate date from another file
835
797
        private void importContactAddresses( Long id,
836
798
                HashMap< String, ContactData.TypeDetail > datas )
837
799
        {
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
 
 
843
800
                // add addresses
844
801
                Set< String > datas_keys = datas.keySet();
845
802
                Iterator< String > i = datas_keys.iterator();
853
810
                                continue;
854
811
 
855
812
                        // add postal address
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 );
 
813
                        _backend.addContactAddresses( id, address, data );
862
814
 
863
815
                        // and add this address to the cache to prevent a addition of
864
816
                        // duplicate date from another file
882
834
                                continue;
883
835
 
884
836
                        // add organisation address
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 );
 
837
                        _backend.addContactOrganisation( id, organisation, data );
894
838
 
895
839
                        // and add this address to the cache to prevent a addition of
896
840
                        // duplicate date from another file