/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-07-04 14:44:48 UTC
  • Revision ID: edam@waxworlds.org-20100704144448-1m30v811opup20fs
- got rid of the pretend ImportContacts activity alltogether (and made the Intro activity the startup one)
- massively simplified the WizzardActivity class so it works propperly
- moved all code to org.waxworlds.edam
- added an "aborted" message when the importion is aborted
- simplified the 3 actions the worker thread can take when stopping (only 2 were actualy used) to "aborted" or "alldone"
- changed intro message to match website
- bugfix: don't blow up when the My Contacts group is missing

Show diffs side-by-side

added added

removed removed

src/org/waxworlds/edam/importcontacts/VCFImporter.java
65
65
                try
66
66
                {
67
67
                        // open directory
68
 
                        String path = "/sdcard" + prefs.getString( "location", "/" );
69
 
                        File file = new File( path );
70
 
                        if( !file.exists() )
 
68
                        String location = prefs.getString( "location", "" );
 
69
                        File dir = new File( location );
 
70
                        if( !dir.exists() || !dir.isDirectory() )
71
71
                                showError( R.string.error_locationnotfound );
72
72
 
73
 
                        // directory, or file?
74
 
                        if( file.isDirectory() )
75
 
                        {
76
 
                                // get files
77
 
                                class VCardFilter implements FilenameFilter {
78
 
                                        public boolean accept( File dir, String name ) {
79
 
                                                return name.toLowerCase().endsWith( ".vcf" );
80
 
                                        }
 
73
                        // get files
 
74
                        class VCardFilter implements FilenameFilter {
 
75
                                public boolean accept( File dir, String name ) {
 
76
                                        return name.toLowerCase().endsWith( ".vcf" );
81
77
                                }
82
 
                                files = file.listFiles( new VCardFilter() );
83
 
                        }
84
 
                        else
85
 
                        {
86
 
                                // use just this file
87
 
                                files = new File[ 1 ];
88
 
                                files[ 0 ] = file;
89
 
                        }
 
78
                        }
 
79
                        files = dir.listFiles( new VCardFilter() );
90
80
                }
91
81
                catch( SecurityException e ) {
92
82
                        showError( R.string.error_locationpermissions );
138
128
 
139
129
                }
140
130
                catch( FileNotFoundException e ) {
141
 
                        showError( getText( R.string.error_filenotfound ) +
142
 
                                file.getName() );
 
131
                        showError( getText( R.string.error_filenotfound ) + file.getName() );
143
132
                }
144
133
                catch( IOException e ) {
145
134
                        showError( getText( R.string.error_ioerror ) + file.getName() );
163
152
                        importVCardFileContent( content.toString(), file.getName() );
164
153
                }
165
154
                catch( FileNotFoundException e ) {
166
 
                        showError( getText( R.string.error_filenotfound ) +
167
 
                                file.getName() );
 
155
                        showError( getText( R.string.error_filenotfound ) + file.getName() );
168
156
                }
169
157
                catch( IOException e ) {
170
158
                        showError( getText( R.string.error_ioerror ) + file.getName() );
174
162
        private void importVCardFileContent( String content, String fileName )
175
163
                        throws AbortImportException
176
164
        {
 
165
                // unfold RFC2425 section 5.8.1 folded lines, except that we must also
 
166
                // handle embedded Quoted-Printable encodings that have a trailing '='.
 
167
                // So we remove these first before doing RFC2425 unfolding.
 
168
                content = content.replaceAll( "=\n[ \\t]", "" )
 
169
                                .replaceAll( "\n[ \\t]", "" );
 
170
 
177
171
                // get lines and parse them
178
172
                String[] lines = content.split( "\n" );
179
173
                VCard vCard = null;
248
242
 
249
243
                private String _version = null;
250
244
                private Vector< String > _lines = null;
251
 
                private int _name_level = NAMELEVEL_NONE;
252
 
                private boolean _parser_in_multiline = false;
253
 
                private String _parser_current_name_and_params = null;
254
 
                private String _parser_buffered_value_so_far = "";
255
 
 
256
 
                protected class UnencodeResult
257
 
                {
258
 
                        private boolean _another_line_required;
259
 
                        private byte[] _bytes;
260
 
                        private int _num_bytes;
261
 
 
262
 
                        public UnencodeResult( boolean another_line_required, byte[] bytes,
263
 
                                int num_bytes )
264
 
                        {
265
 
                                _another_line_required = another_line_required;
266
 
                                _bytes = bytes;
267
 
                                _num_bytes = num_bytes;
268
 
                        }
269
 
 
270
 
                        public boolean isAnotherLineRequired()
271
 
                        {
272
 
                                return _another_line_required;
273
 
                        }
274
 
 
275
 
                        public byte[] getBytes()
276
 
                        {
277
 
                                return _bytes;
278
 
                        }
279
 
 
280
 
                        public int getNumBytes()
281
 
                        {
282
 
                                return _num_bytes;
283
 
                        }
284
 
                }
 
245
                private int _nameLevel = NAMELEVEL_NONE;
285
246
 
286
247
                @SuppressWarnings("serial")
287
248
                protected class ParseException extends Exception
305
266
                                throws ParseException, SkipContactException,
306
267
                                AbortImportException
307
268
                {
308
 
                        // ignore empty lines
309
 
                        if( line.trim() == "" ) return;
310
 
 
311
 
                        // split line into name and value parts (this may turn out to be
312
 
                        // unwanted if the line is a subsequent line in a multi-line
313
 
                        // value, but we have to do this now to check for and handle VCF
314
 
                        // versions first)
315
 
                        String[] props = line.split(  ":", 2 );
 
269
                        // get property halves
 
270
                        String[] props = line.split( ":" );
316
271
                        for( int i = 0; i < props.length; i++ )
317
272
                                props[ i ] = props[ i ].trim();
 
273
                        if( props.length < 2 ||
 
274
                                        props[ 0 ].length() < 1 || props[ 1 ].length() < 1 )
 
275
                                throw new ParseException( R.string.error_vcf_malformed );
318
276
 
319
 
                        // if we haven't yet got a version, we won't be paring anything!
320
277
                        if( _version == null )
321
278
                        {
322
 
                                // is this a version?
323
 
                                if( props.length == 2 && props[ 0 ].equals( "VERSION" ) )
 
279
                                if( props[ 0 ].equals( "VERSION" ) )
324
280
                                {
325
 
                                        // yes, check/store it
 
281
                                        // get version
326
282
                                        if( !props[ 1 ].equals( "2.1" ) &&
327
283
                                                        !props[ 1 ].equals( "3.0" ) )
328
284
                                                throw new ParseException( R.string.error_vcf_version );
336
292
                                }
337
293
                                else
338
294
                                {
339
 
                                        // no, so stash this line till we have a version
 
295
                                        // stash this line till we have a version
340
296
                                        if( _lines == null )
341
297
                                                _lines = new Vector< String >();
342
298
                                        _lines.add( line );
344
300
                        }
345
301
                        else
346
302
                        {
347
 
                                if( _parser_in_multiline )
348
 
                                {
349
 
                                        // if we're currently in a multi-line value, use the stored
350
 
                                        // property name and parameters
351
 
                                        props = new String[ 2 ];
352
 
                                        props[ 0 ] = _parser_current_name_and_params;
353
 
                                        props[ 1 ] = line.trim();
354
 
                                }
355
 
                                else
356
 
                                {
357
 
                                        // for normal lines, check the property name/value bits
358
 
                                        if( props.length < 2 || props[ 0 ].length() == 0 )
359
 
                                                throw new ParseException(
360
 
                                                        R.string.error_vcf_malformed );
361
 
 
362
 
                                        // ignore empty properties
363
 
                                        if( props[ 1 ].length() < 1 )
364
 
                                                return;
365
 
 
366
 
                                        // reset the saved multi-line state
367
 
                                        _parser_current_name_and_params = props[ 0 ];
368
 
                                        _parser_buffered_value_so_far = "";
369
 
                                }
370
 
 
371
303
                                // get parameter parts
372
304
                                String[] params = props[ 0 ].split( ";" );
373
305
                                for( int i = 0; i < params.length; i++ )
374
306
                                        params[ i ] = params[ i ].trim();
375
307
 
376
 
                                // parse charset and encoding parameters
377
 
                                String charset, encoding;
378
 
                                if( ( charset = checkParam( params, "CHARSET" ) ) != null &&
379
 
                                        !charset.equals( "UTF-8" ) && !charset.equals( "UTF-16" ) )
380
 
                                {
381
 
                                        throw new ParseException( R.string.error_vcf_charset );
382
 
                                }
383
 
                                if( ( encoding = checkParam( params, "ENCODING" ) ) != null &&
384
 
                                        !encoding.equals( "QUOTED-PRINTABLE" ) &&
385
 
                                        !encoding.equals( "8BIT" ) )
386
 
                                        //&& !encoding.equals( "BASE64" ) )
387
 
                                {
388
 
                                        throw new ParseException( R.string.error_vcf_encoding );
389
 
                                }
390
 
 
391
 
                                // do unencoding (or default to a fake unencoding result with
392
 
                                // the raw string)
393
 
                                UnencodeResult result;
394
 
                                if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
395
 
                                        result = unencodeQuotedPrintable( props[ 1 ], charset );
396
 
//                              else if( encoding != null && encoding.equals( "BASE64" ) )
397
 
//                                      result = unencodeBase64( props[ 1 ], charset );
398
 
                                else
399
 
                                        result = new UnencodeResult( false, props[ 1 ].getBytes(),
400
 
                                                props[ 1 ].getBytes().length );
401
 
 
402
 
                                // process charset
403
 
                                try {
404
 
                                        props[ 1 ] = new String( result.getBytes(), 0,
405
 
                                                result.getNumBytes(),
406
 
                                                charset == null? "UTF-8" : charset );
407
 
                                } catch( UnsupportedEncodingException e ) {
408
 
                                        throw new ParseException( R.string.error_vcf_charset );
409
 
                                }
410
 
 
411
 
                                // handle multi-line requests
412
 
                                _parser_in_multiline = result.isAnotherLineRequired();
413
 
                                if( _parser_in_multiline ) {
414
 
                                        _parser_buffered_value_so_far += props[ 1 ];
415
 
                                        return;
416
 
                                }
417
 
 
418
 
                                // add on buffered multi-line content
419
 
                                String value = _parser_buffered_value_so_far + props[ 1 ];
420
 
 
421
308
                                // parse some properties
422
309
                                if( params[ 0 ].equals( "N" ) )
423
 
                                        parseN( params, value );
 
310
                                        parseN( params, props[ 1 ] );
424
311
                                else if( params[ 0 ].equals( "FN" ) )
425
 
                                        parseFN( params, value );
 
312
                                        parseFN( params, props[ 1 ] );
426
313
                                else if( params[ 0 ].equals( "ORG" ) )
427
 
                                        parseORG( params, value );
 
314
                                        parseORG( params, props[ 1 ] );
428
315
                                else if( params[ 0 ].equals( "TEL" ) )
429
 
                                        parseTEL( params, value );
 
316
                                        parseTEL( params, props[ 1 ] );
430
317
                                else if( params[ 0 ].equals( "EMAIL" ) )
431
 
                                        parseEMAIL( params, value );
 
318
                                        parseEMAIL( params, props[ 1 ] );
432
319
                        }
433
320
                }
434
321
 
437
324
                                AbortImportException
438
325
                {
439
326
                        // already got a better name?
440
 
                        if( _name_level >= NAMELEVEL_N ) return;
 
327
                        if( _nameLevel >= NAMELEVEL_N ) return;
441
328
 
442
329
                        // get name parts
443
330
                        String[] nameparts = value.split( ";" );
452
339
                                value += ( value.length() == 0? "" : " " ) + nameparts[ 0 ];
453
340
 
454
341
                        // set name
455
 
                        setName( value );
456
 
                        _name_level = NAMELEVEL_N;
 
342
                        setName( undoCharsetAndEncoding( params, value ) );
 
343
                        _nameLevel = NAMELEVEL_N;
457
344
 
458
345
                        // check now to see if we need to import this contact (to avoid
459
346
                        // parsing the rest of the vCard unnecessarily)
465
352
                                throws ParseException, SkipContactException
466
353
                {
467
354
                        // already got a better name?
468
 
                        if( _name_level >= NAMELEVEL_FN ) return;
 
355
                        if( _nameLevel >= NAMELEVEL_FN ) return;
469
356
 
470
357
                        // set name
471
 
                        setName( value );
472
 
                        _name_level = NAMELEVEL_FN;
 
358
                        setName( undoCharsetAndEncoding( params, value ) );
 
359
                        _nameLevel = NAMELEVEL_FN;
473
360
                }
474
361
 
475
362
                private void parseORG( String[] params, String value )
476
363
                                throws ParseException, SkipContactException
477
364
                {
478
365
                        // already got a better name?
479
 
                        if( _name_level >= NAMELEVEL_ORG ) return;
 
366
                        if( _nameLevel >= NAMELEVEL_ORG ) return;
480
367
 
481
368
                        // get org parts
482
369
                        String[] orgparts = value.split( ";" );
490
377
                                value = orgparts[ 0 ];
491
378
 
492
379
                        // set name
493
 
                        setName( value );
494
 
                        _name_level = NAMELEVEL_ORG;
 
380
                        setName( undoCharsetAndEncoding( params, value ) );
 
381
                        _nameLevel = NAMELEVEL_ORG;
495
382
                }
496
383
 
497
384
                private void parseTEL( String[] params, String value )
522
409
                }
523
410
 
524
411
                public void parseEMAIL( String[] params, String value )
525
 
                                throws ParseException
526
412
                {
527
413
                        if( value.length() == 0 ) return;
528
414
 
546
432
                                throw new ParseException( R.string.error_vcf_malformed );
547
433
 
548
434
                        //  missing name properties?
549
 
                        if( _name_level == NAMELEVEL_NONE )
 
435
                        if( _nameLevel == NAMELEVEL_NONE )
550
436
                                throw new ParseException( R.string.error_vcf_noname );
551
437
 
552
438
                        // check if we should import this one? If we've already got an 'N'-
553
439
                        // type name, this will already have been done by parseN() so we
554
440
                        // mustn't do this here (or it could prompt twice!)
555
 
                        if( _name_level < NAMELEVEL_N && !isImportRequired( getName() ) )
 
441
                        if( _nameLevel < NAMELEVEL_N && !isImportRequired( getName() ) )
556
442
                                throw new SkipContactException();
557
443
                }
558
444
 
 
445
                private String undoCharsetAndEncoding( String[] params, String value )
 
446
                                throws ParseException
 
447
                {
 
448
                        // check encoding/charset
 
449
                        String charset, encoding;
 
450
                        if( ( charset = checkParam( params, "CHARSET" ) ) != null &&
 
451
                                        !charset.equals( "UTF-8" ) && !charset.equals( "UTF-16" ) )
 
452
                                throw new ParseException( R.string.error_vcf_charset );
 
453
                        if( ( encoding = checkParam( params, "ENCODING" ) ) != null &&
 
454
                                        !encoding.equals( "QUOTED-PRINTABLE" ) )
 
455
                                throw new ParseException( R.string.error_vcf_encoding );
 
456
 
 
457
                        // do decoding?
 
458
                        if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
 
459
                                return unencodeQuotedPrintable( value, charset );
 
460
 
 
461
                        // nothing to do!
 
462
                        return value;
 
463
                }
 
464
 
559
465
                private String checkParam( String[] params, String name )
560
466
                {
561
467
                        Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
591
497
                        return types;
592
498
                }
593
499
 
594
 
                private UnencodeResult unencodeQuotedPrintable( String str, String charset )
 
500
                private String unencodeQuotedPrintable( String str, String charset )
595
501
                {
596
 
                        boolean another = false;
597
 
 
598
502
                        // default encoding scheme
599
503
                        if( charset == null ) charset = "UTF-8";
600
504
 
601
505
                        // unencode quoted-pritable encoding, as per RFC1521 section 5.1
602
506
                        byte[] bytes = new byte[ str.length() ];
603
507
                        int j = 0;
604
 
                        for( int i = 0; i < str.length(); i++ )
605
 
                        {
606
 
                                // get next char and process...
 
508
                        for( int i = 0; i < str.length(); i++, j++ ) {
607
509
                                char ch = str.charAt( i );
608
 
                                if( ch == '=' && i < str.length() - 2 )
609
 
                                {
610
 
                                        // we found a =XX format byte, add it
 
510
                                if( ch == '=' && i < str.length() - 2 ) {
611
511
                                        bytes[ j ] = (byte)(
612
512
                                                        Character.digit( str.charAt( i + 1 ), 16 ) * 16 +
613
513
                                                        Character.digit( str.charAt( i + 2 ), 16 ) );
614
514
                                        i += 2;
615
515
                                }
616
 
                                else if( ch == '=' && i == str.length() - 1 )
617
 
                                {
618
 
                                        // we found a '=' at the end of a line signifying a multi-
619
 
                                        // line string, so we don't add it.
620
 
                                        another = true;
621
 
                                        continue;
622
 
                                }
623
516
                                else
624
 
                                        // just a normal char...
625
517
                                        bytes[ j ] = (byte)ch;
626
 
                                j++;
627
518
                        }
628
 
 
629
 
                        return new UnencodeResult( another, bytes, j );
 
519
                        try {
 
520
                                return new String( bytes, 0, j, charset );
 
521
                        } catch( UnsupportedEncodingException e ) { }
 
522
                        return null;
630
523
                }
631
524
        }
632
525
}