/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/org/waxworlds/edam/importcontacts/VCFImporter.java

  • Committer: edam
  • Date: 2010-12-12 00:16:42 UTC
  • Revision ID: edam@waxworlds.org-20101212001642-dqxbxww4ik9x7zbp
- update TODO

Show diffs side-by-side

added added

removed removed

src/org/waxworlds/edam/importcontacts/VCFImporter.java
350
350
                        }
351
351
 
352
352
                        // ignore empty lines
353
 
                        if( line.trim().equals( "" ) ) return;
 
353
                        if( line.trim() == "" ) return;
354
354
 
355
355
                        // split line into name and value parts (this may turn out to be
356
356
                        // unwanted if the line is a subsequent line in a multi-line
362
362
                        // malformed property:name pairs.
363
363
                        String name_and_params, string_value;
364
364
                        {
365
 
                                String[] parts = line.split( ":", 2 );
366
 
                                if( parts.length == 2 ) {
367
 
                                        name_and_params = parts[ 0 ].trim();
368
 
                                        string_value = parts[ 1 ].trim();
 
365
                                String[] bits = line.split(  ":", 2 );
 
366
                                if( bits.length == 2 ) {
 
367
                                        name_and_params = bits[ 0 ].trim();
 
368
                                        string_value = bits[ 1 ].trim();
369
369
                                        if( name_and_params.length() == 0 )
370
370
                                                throw new ParseException( R.string.error_vcf_malformed );
371
371
                                }
431
431
                                }
432
432
                                else
433
433
                                {
 
434
                                        // ignore empty values
 
435
                                        if( string_value.length() < 1 ) return;
 
436
 
434
437
                                        // calculate how many chars to skip from beginning of line
435
438
                                        // so we skip the property "name:" part
436
439
                                        int pos = buffer.position() + name_and_params.length() + 1;
445
448
                                }
446
449
 
447
450
                                // get parameter parts
448
 
                                String[] name_param_parts = name_and_params.split( ";", -1 );
449
 
                                for( int i = 0; i < name_param_parts.length; i++ )
450
 
                                        name_param_parts[ i ] = name_param_parts[ i ].trim();
 
451
                                String[] name_and_param_bits = name_and_params.split( ";" );
 
452
                                for( int i = 0; i < name_and_param_bits.length; i++ )
 
453
                                        name_and_param_bits[ i ] = name_and_param_bits[ i ].trim();
451
454
 
452
455
                                // parse encoding parameter
453
 
                                String encoding = checkParam( name_param_parts, "ENCODING" );
 
456
                                String encoding = checkParam( name_and_param_bits, "ENCODING" );
454
457
                                if( encoding != null ) encoding = encoding.toUpperCase();
455
458
                                if( encoding != null && !encoding.equals( "8BIT" ) &&
456
459
                                        !encoding.equals( "QUOTED-PRINTABLE" ) )
460
463
                                }
461
464
 
462
465
                                // parse charset parameter
463
 
                                String charset = checkParam( name_param_parts, "CHARSET" );
 
466
                                String charset = checkParam( name_and_param_bits, "CHARSET" );
464
467
                                if( charset != null ) charset = charset.toUpperCase();
465
468
                                if( charset != null && !charset.equals( "US-ASCII" ) &&
466
469
                                        !charset.equals( "ASCII" ) && !charset.equals( "UTF-8" ) )
474
477
                                if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
475
478
                                        unencoding_result = unencodeQuotedPrintable( value );
476
479
//                              else if( encoding != null && encoding.equals( "BASE64" ) )
477
 
//                                      unencoding_result = unencodeBase64( props[ 1 ], charset );
 
480
//                                      result = unencodeBase64( props[ 1 ], charset );
478
481
                                if( unencoding_result != null ) {
479
482
                                        value = unencoding_result.getBuffer();
480
483
                                        _parser_in_multiline =
482
485
                                }
483
486
 
484
487
                                // convert 8-bit ASCII charset to US-ASCII
485
 
                                if( charset == null || charset.equals( "ASCII" ) ) {
 
488
                                if( charset == null || charset == "ASCII" ) {
486
489
                                        value = transcodeAsciiToUtf8( value );
487
490
                                        charset = "UTF-8";
488
491
                                }
506
509
                                String complete_value =
507
510
                                        _parser_buffered_value_so_far + string_value;
508
511
 
509
 
                                // ignore empty values
510
 
                                if( complete_value.length() < 1 ) return;
511
 
 
512
512
                                // parse some properties
513
 
                                if( name_param_parts[ 0 ].equals( "N" ) )
514
 
                                        parseN( name_param_parts, complete_value );
515
 
                                else if( name_param_parts[ 0 ].equals( "FN" ) )
516
 
                                        parseFN( name_param_parts, complete_value );
517
 
                                else if( name_param_parts[ 0 ].equals( "ORG" ) )
518
 
                                        parseORG( name_param_parts, complete_value );
519
 
                                else if( name_param_parts[ 0 ].equals( "TEL" ) )
520
 
                                        parseTEL( name_param_parts, complete_value );
521
 
                                else if( name_param_parts[ 0 ].equals( "EMAIL" ) )
522
 
                                        parseEMAIL( name_param_parts, complete_value );
 
513
                                if( name_and_param_bits[ 0 ].equals( "N" ) )
 
514
                                        parseN( name_and_param_bits, complete_value );
 
515
                                else if( name_and_param_bits[ 0 ].equals( "FN" ) )
 
516
                                        parseFN( name_and_param_bits, complete_value );
 
517
                                else if( name_and_param_bits[ 0 ].equals( "ORG" ) )
 
518
                                        parseORG( name_and_param_bits, complete_value );
 
519
                                else if( name_and_param_bits[ 0 ].equals( "TEL" ) )
 
520
                                        parseTEL( name_and_param_bits, complete_value );
 
521
                                else if( name_and_param_bits[ 0 ].equals( "EMAIL" ) )
 
522
                                        parseEMAIL( name_and_param_bits, complete_value );
523
523
                        }
524
524
                }
525
525
 
531
531
                        if( _name_level >= NAMELEVEL_N ) return;
532
532
 
533
533
                        // get name parts
534
 
                        String[] name_parts = value.split( ";" );
535
 
                        for( int i = 0; i < name_parts.length; i++ )
536
 
                                name_parts[ i ] = name_parts[ i ].trim();
 
534
                        String[] nameparts = value.split( ";" );
 
535
                        for( int i = 0; i < nameparts.length; i++ )
 
536
                                nameparts[ i ] = nameparts[ i ].trim();
537
537
 
538
538
                        // build name
539
539
                        value = "";
540
 
                        if( name_parts.length > 1 && name_parts[ 1 ].length() > 0 )
541
 
                                value += name_parts[ 1 ];
542
 
                        if( name_parts.length > 0 && name_parts[ 0 ].length() > 0 )
543
 
                                value += ( value.length() == 0? "" : " " ) + name_parts[ 0 ];
 
540
                        if( nameparts.length > 1 && nameparts[ 1 ].length() > 0 )
 
541
                                value += nameparts[ 1 ];
 
542
                        if( nameparts[ 0 ].length() > 0 )
 
543
                                value += ( value.length() == 0? "" : " " ) + nameparts[ 0 ];
544
544
 
545
545
                        // set name
546
546
                        setName( value );
570
570
                        if( _name_level >= NAMELEVEL_ORG ) return;
571
571
 
572
572
                        // get org parts
573
 
                        String[] org_parts = value.split( ";" );
574
 
                        for( int i = 0; i < org_parts.length; i++ )
575
 
                                org_parts[ i ] = org_parts[ i ].trim();
 
573
                        String[] orgparts = value.split( ";" );
 
574
                        for( int i = 0; i < orgparts.length; i++ )
 
575
                                orgparts[ i ] = orgparts[ i ].trim();
576
576
 
577
577
                        // build name
578
 
                        if( org_parts.length > 1 && org_parts[ 0 ].length() == 0 )
579
 
                                value = org_parts[ 1 ];
 
578
                        if( orgparts[ 0 ].length() == 0 && orgparts.length > 1 )
 
579
                                value = orgparts[ 1 ];
580
580
                        else
581
 
                                value = org_parts[ 0 ];
 
581
                                value = orgparts[ 0 ];
582
582
 
583
583
                        // set name
584
584
                        setName( value );
596
596
 
597
597
                        // here's the logic...
598
598
                        boolean preferred = types.contains( "PREF" );
599
 
                        int type = PhonesColumns.TYPE_MOBILE;
600
599
                        if( types.contains( "VOICE" ) )
601
600
                                if( types.contains( "WORK" ) )
602
 
                                        type = PhonesColumns.TYPE_WORK;
 
601
                                        addPhone( value, PhonesColumns.TYPE_WORK, preferred );
603
602
                                else
604
 
                                        type = PhonesColumns.TYPE_HOME;
 
603
                                        addPhone( value, PhonesColumns.TYPE_HOME, preferred );
605
604
                        else if( types.contains( "CELL" ) || types.contains( "VIDEO" ) )
606
 
                                type = PhonesColumns.TYPE_MOBILE;
 
605
                                addPhone( value, PhonesColumns.TYPE_MOBILE, preferred );
607
606
                        if( types.contains( "FAX" ) )
608
607
                                if( types.contains( "HOME" ) )
609
 
                                        type = PhonesColumns.TYPE_FAX_HOME;
 
608
                                        addPhone( value, PhonesColumns.TYPE_FAX_HOME, preferred );
610
609
                                else
611
 
                                        type = PhonesColumns.TYPE_FAX_WORK;
 
610
                                        addPhone( value, PhonesColumns.TYPE_FAX_WORK, preferred );
612
611
                        if( types.contains( "PAGER" ) )
613
 
                                type = PhonesColumns.TYPE_PAGER;
614
 
 
615
 
                        // add phone number
616
 
                        addPhone( value, type, preferred );
 
612
                                addPhone( value, PhonesColumns.TYPE_PAGER, preferred );
617
613
                }
618
614
 
619
615
                public void parseEMAIL( String[] params, String value )
653
649
 
654
650
                private String checkParam( String[] params, String name )
655
651
                {
656
 
                        Pattern p = Pattern.compile(
657
 
                                        "^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$" );
 
652
                        Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
658
653
                        for( int i = 0; i < params.length; i++ ) {
659
654
                                Matcher m = p.matcher( params[ i ] );
660
655
                                if( m.matches() )
661
 
                                        return m.group( 2 );
 
656
                                        return m.group( 1 );
662
657
                        }
663
658
                        return null;
664
659
                }
665
660
 
666
661
                private Set< String > extractTypes( String[] params,
667
 
                                List< String > valid_types )
 
662
                                List< String > validTypes )
668
663
                {
669
664
                        HashSet< String > types = new HashSet< String >();
670
665
 
671
666
                        // get 3.0-style TYPE= param
672
 
                        String type_param;
673
 
                        if( ( type_param = checkParam( params, "TYPE" ) ) != null ) {
674
 
                                String[] parts = type_param.split( "," );
675
 
                                for( int i = 0; i < parts.length; i++ )
676
 
                                        if( valid_types.contains( parts[ i ] ) )
677
 
                                                types.add( parts[ i ] );
 
667
                        String typeParam;
 
668
                        if( ( typeParam = checkParam( params, "TYPE" ) ) != null ) {
 
669
                                String[] bits = typeParam.split( "," );
 
670
                                for( int i = 0; i < bits.length; i++ )
 
671
                                        if( validTypes.contains( bits[ i ] ) )
 
672
                                                types.add( bits[ i ] );
678
673
                        }
679
674
 
680
675
                        // get 2.1-style type param
681
676
                        if( _version.equals( "2.1" ) ) {
682
677
                                for( int i = 1; i < params.length; i++ )
683
 
                                        if( valid_types.contains( params[ i ] ) )
 
678
                                        if( validTypes.contains( params[ i ] ) )
684
679
                                                types.add( params[ i ] );
685
680
                        }
686
681