/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: Tim Marston
  • Date: 2016-03-28 18:13:50 UTC
  • Revision ID: tim@ed.am-20160328181350-ytxvox60fxj1tevm
fixed typo in 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 2012 Tim Marston <tim@ed.am>
 
4
 * Copyright (C) 2009 to 2013 Tim Marston <tim@ed.am>
5
5
 *
6
6
 * This file is part of the Import Contacts program (hereafter referred
7
 
 * to as "this program"). For more information, see
 
7
 * to as "this program").  For more information, see
8
8
 * http://ed.am/dev/android/import-contacts
9
9
 *
10
10
 * This program is free software: you can redistribute it and/or modify
141
141
                protected HashMap< String, PreferredDetail > _numbers = null;
142
142
                protected HashMap< String, PreferredDetail > _emails = null;
143
143
                protected HashMap< String, TypeDetail > _addresses = null;
 
144
                protected HashSet< String > _notes = null;
 
145
                protected String _birthday = null;
144
146
 
145
147
                private ContactsCache.CacheIdentifier _cache_identifier = null;
146
148
 
184
186
 
185
187
                        // if this is the first organisation added, or it's a preferred
186
188
                        // organisation and the current primary organisation isn't, then
187
 
                        // record this as the primary organisation.
 
189
                        // record this as the primary organisation
188
190
                        if( _primary_organisation == null ||
189
191
                                ( is_preferred && !_primary_organisation_is_preferred ) )
190
192
                        {
238
240
                        // and the current primary number isn't, or this number is on equal
239
241
                        // standing with the primary number in terms of preference and it is
240
242
                        // a voice number and the primary number isn't, then record this as
241
 
                        // the primary number.
 
243
                        // the primary number
242
244
                        if( _primary_number == null ||
243
245
                                ( is_preferred && !_primary_number_is_preferred ) ||
244
246
                                ( is_preferred == _primary_number_is_preferred &&
290
292
 
291
293
                        // if this is the first email added, or it's a preferred email and
292
294
                        // the current primary organisation isn't, then record this as the
293
 
                        // primary email.
 
295
                        // primary email
294
296
                        if( _primary_email == null ||
295
297
                                ( is_preferred && !_primary_email_is_preferred ) )
296
298
                        {
344
346
                        return _addresses;
345
347
                }
346
348
 
 
349
                protected void addNote( String note )
 
350
                {
 
351
                        if( _notes == null ) _notes = new HashSet< String >();
 
352
                        if( !_notes.contains( note ) )
 
353
                                _notes.add( note );
 
354
                }
 
355
 
 
356
                public boolean hasNotes()
 
357
                {
 
358
                        return _notes != null && _notes.size() > 0;
 
359
                }
 
360
 
 
361
                public HashSet< String > getNotes()
 
362
                {
 
363
                        return _notes;
 
364
                }
 
365
 
 
366
                public void setBirthday( String birthday )
 
367
                {
 
368
                        _birthday = birthday;
 
369
                }
 
370
 
 
371
                public boolean hasBirthday()
 
372
                {
 
373
                        return _birthday != null;
 
374
                }
 
375
 
 
376
                public String getBirthday()
 
377
                {
 
378
                        return _birthday;
 
379
                }
 
380
 
347
381
                protected void finalise()
348
382
                        throws ContactNotIdentifiableException
349
383
                {
350
 
                        // ensure that if there is a primary number, it is preferred so
351
 
                        // that there is always one preferred number. Android will assign
 
384
                        // Ensure that if there is a primary number, it is preferred so
 
385
                        // that there is always one preferred number.  Android will assign
352
386
                        // preference to one anyway so we might as well decide one sensibly.
353
387
                        if( _primary_number != null ) {
354
388
                                PreferredDetail data = _numbers.get( _primary_number );
372
406
 
373
407
                        // create a cache identifier from this contact data, which can be
374
408
                        // used to look-up an existing contact
375
 
                        _cache_identifier = ContactsCache.createIdentifier( this );
 
409
                        _cache_identifier = ContactsCache.CacheIdentifier.factory( this );
376
410
                        if( _cache_identifier == null )
377
411
                                throw new ContactNotIdentifiableException();
378
412
                }
399
433
                        Matcher m = p.matcher( email );
400
434
                        if( m.matches() ) {
401
435
                                String[] bits = email.split( "@" );
402
 
                                return bits[ 0 ] + "@" + bits[ 1 ].toLowerCase( Locale.US );
 
436
                                return bits[ 0 ] + "@" +
 
437
                                        bits[ 1 ].toLowerCase( Locale.ENGLISH );
403
438
                        }
404
439
                        return null;
405
440
                }
509
544
                finish( ACTION_ABORT );
510
545
        }
511
546
 
512
 
        protected void showFatalError( int res ) throws AbortImportException
513
 
        {
514
 
                showFatalError( _doit.getText( res ).toString() );
515
 
        }
516
 
 
517
 
        synchronized protected void showFatalError( String message )
518
 
                        throws AbortImportException
519
 
        {
520
 
                checkAbort();
521
 
                _doit._handler.sendMessage( Message.obtain(
522
 
                        _doit._handler, Doit.MESSAGE_ERROR, message ) );
523
 
                try {
524
 
                        wait();
525
 
                }
526
 
                catch( InterruptedException e ) { }
527
 
 
528
 
                // no need to check if an abortion happened during the wait, we are
529
 
                // about to finish anyway!
530
 
                finish( ACTION_ABORT );
531
 
        }
532
 
 
533
 
        protected boolean showContinue( int res ) throws AbortImportException
534
 
        {
535
 
                return showContinue( _doit.getText( res ).toString() );
536
 
        }
537
 
 
538
 
        synchronized protected boolean showContinue( String message )
 
547
        protected void showContinueOrAbort( int res ) throws AbortImportException
 
548
        {
 
549
                showContinueOrAbort( _doit.getText( res ).toString() );
 
550
        }
 
551
 
 
552
        synchronized protected void showContinueOrAbort( String message )
539
553
                        throws AbortImportException
540
554
        {
541
555
                checkAbort();
546
560
                }
547
561
                catch( InterruptedException e ) { }
548
562
 
549
 
                // check if an abortion happened during the wait
550
 
                checkAbort();
551
 
 
552
 
                return _response == RESPONSE_POSITIVE;
 
563
                // if we're aborting, there's no need to check if an abortion happened
 
564
                // during the wait
 
565
                if( _response == RESPONSE_NEGATIVE )
 
566
                        finish( ACTION_ABORT );
 
567
                else
 
568
                        checkAbort();
553
569
        }
554
570
 
555
571
        protected void setProgressMessage( int res ) throws AbortImportException
609
625
        /**
610
626
         * Should we skip a contact, given whether it exists or not and the current
611
627
         * merge setting?  This routine handles throwing up a prompt, if required.
 
628
         *
612
629
         * @param contact_detail the display name of the contact
613
630
         * @param exists true if this contact matches one in the cache
614
631
         * @param merge_setting the merge setting to use
668
685
        {
669
686
                checkAbort();
670
687
 
671
 
                // It is expected that we use contact.getCacheIdentifier() here. The
 
688
                // It is expected that we use contact.getCacheIdentifier() here.  The
672
689
                // contact we are passed should have been successfully finalise()d,
673
690
                // which includes generating a valid cache identifier.
674
691
                ContactsCache.CacheIdentifier cache_identifier =
741
758
                                importContactAddresses( id, contact.getAddresses() );
742
759
                        if( contact.hasOrganisations() )
743
760
                                importContactOrganisations( id, contact.getOrganisations() );
 
761
                        if( contact.hasNotes() )
 
762
                                importContactNotes( id, contact.getNotes() );
 
763
                        if( contact.hasBirthday() )
 
764
                                importContactBirthday( id, contact.getBirthday() );
744
765
                }
745
766
                catch( Backend.ContactCreationException e )
746
767
                {
759
780
                        String number = i.next();
760
781
                        ContactData.PreferredDetail data = datas.get( number );
761
782
 
762
 
                        // we don't want to add this number if it's crap, or it already
763
 
                        // exists (which would cause a duplicate to be created). We don't
764
 
                        // take in to account the type when checking for duplicates. This is
765
 
                        // intentional: types aren't really very reliable. We assume that
766
 
                        // if the number exists at all, it doesn't need importing. Because
767
 
                        // of this, we also can't update the cache (which we don't need to
768
 
                        // anyway, so it's not a problem).
 
783
                        // We don't want to add this number if it's crap, or it already
 
784
                        // exists (which would cause a duplicate to be created).  We don't
 
785
                        // take in to account the type when checking for duplicates.  This
 
786
                        // is intentional: types aren't really very reliable.  We assume
 
787
                        // that if the number exists at all, it doesn't need importing.
 
788
                        // Because of this, we also can't update the cache (which we don't
 
789
                        // need to anyway, so it's not a problem).
769
790
                        if( _contacts_cache.hasAssociatedNumber( id, number ) )
770
791
                                continue;
771
792
 
790
811
                        ContactData.PreferredDetail data = datas.get( email );
791
812
 
792
813
                        // we don't want to add this email address if it exists already or
793
 
                        // we would introduce duplicates.
 
814
                        // we would introduce duplicates
794
815
                        if( _contacts_cache.hasAssociatedEmail( id, email ) )
795
816
                                continue;
796
817
 
853
874
                }
854
875
        }
855
876
 
 
877
        private void importContactNotes( Long id, HashSet< String > datas )
 
878
                throws ContactCreationException
 
879
        {
 
880
                // add notes
 
881
                Iterator< String > i = datas.iterator();
 
882
                while( i.hasNext() ) {
 
883
                        String note = i.next();
 
884
 
 
885
                        // we don't want to add this note if it exists already or we would
 
886
                        // introduce duplicates
 
887
                        if( _contacts_cache.hasAssociatedNote( id, note ) )
 
888
                                continue;
 
889
 
 
890
                        // add note
 
891
                        _backend.addContactNote( id, note );
 
892
 
 
893
                        // and add this note to the cache to prevent a addition of duplicate
 
894
                        // date from another file
 
895
                        _contacts_cache.addAssociatedNote( id, note );
 
896
                }
 
897
        }
 
898
 
 
899
        private void importContactBirthday( Long id, String birthday )
 
900
                throws ContactCreationException
 
901
        {
 
902
                // we don't want to import this birthday if it already exists
 
903
                if( _contacts_cache.hasAssociatedBirthday( id, birthday ) )
 
904
                        return;
 
905
 
 
906
                // add birthday
 
907
                _backend.addContactBirthday( id, birthday );
 
908
 
 
909
                // and update the cache
 
910
                _contacts_cache.addAssociatedBirthday( id, birthday );
 
911
        }
 
912
 
856
913
        synchronized protected void checkAbort() throws AbortImportException
857
914
        {
858
915
                if( _abort ) {