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

  • Committer: edam
  • Date: 2009-01-28 00:45:02 UTC
  • Revision ID: edam@waxworlds.org-20090128004502-erfklxlwmwhkx4i5
- added scroll view to all layouts
- added intro activity (with disclaimer)
- added action constants so that updates (and changed ids) won't affect saved data
- updated todo

Show diffs side-by-side

added added

removed removed

src/org/waxworlds/importcontacts/VCFImporter.java
21
21
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
22
 */
23
23
 
24
 
package org.waxworlds.edam.importcontacts;
 
24
package org.waxworlds.importcontacts;
25
25
 
26
26
import java.io.BufferedReader;
27
27
import java.io.File;
38
38
import java.util.regex.Matcher;
39
39
import java.util.regex.Pattern;
40
40
 
 
41
import org.waxworlds.importcontacts.Importer.AbortImportException;
 
42
 
41
43
import android.content.SharedPreferences;
42
44
import android.provider.Contacts;
43
45
import android.provider.Contacts.PhonesColumns;
65
67
                try
66
68
                {
67
69
                        // open directory
68
 
                        String path = "/sdcard" + prefs.getString( "location", "/" );
69
 
                        File file = new File( path );
70
 
                        if( !file.exists() )
 
70
                        String location = prefs.getString( "location", "" );
 
71
                        File dir = new File( location );
 
72
                        if( !dir.exists() || !dir.isDirectory() )
71
73
                                showError( R.string.error_locationnotfound );
72
74
 
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
 
                                        }
81
 
                                }
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
 
                        }
 
75
                        // get files
 
76
                        class VCardFilter implements FilenameFilter {
 
77
                            public boolean accept( File dir, String name ) {
 
78
                                return name.toLowerCase().endsWith( ".vcf" );
 
79
                            }
 
80
                        }
 
81
                        files = dir.listFiles( new VCardFilter() );
90
82
                }
91
83
                catch( SecurityException e ) {
92
84
                        showError( R.string.error_locationpermissions );
138
130
 
139
131
                }
140
132
                catch( FileNotFoundException e ) {
141
 
                        showError( getText( R.string.error_filenotfound ) +
142
 
                                file.getName() );
 
133
                        showError( getText( R.string.error_filenotfound ) + file.getName() );
143
134
                }
144
135
                catch( IOException e ) {
145
136
                        showError( getText( R.string.error_ioerror ) + file.getName() );
163
154
                        importVCardFileContent( content.toString(), file.getName() );
164
155
                }
165
156
                catch( FileNotFoundException e ) {
166
 
                        showError( getText( R.string.error_filenotfound ) +
167
 
                                file.getName() );
 
157
                        showError( getText( R.string.error_filenotfound ) + file.getName() );
168
158
                }
169
159
                catch( IOException e ) {
170
160
                        showError( getText( R.string.error_ioerror ) + file.getName() );
174
164
        private void importVCardFileContent( String content, String fileName )
175
165
                        throws AbortImportException
176
166
        {
 
167
                // unfold RFC2425 section 5.8.1 folded lines, except that we must also
 
168
                // handle embedded Quoted-Printable encodings that have a trailing '='.
 
169
                // So we remove these first before doing RFC2425 unfolding.
 
170
                content = content.replaceAll( "=\n[ \\t]", "" )
 
171
                                .replaceAll( "\n[ \\t]", "" );
 
172
 
177
173
                // get lines and parse them
178
174
                String[] lines = content.split( "\n" );
179
175
                VCard vCard = null;
248
244
 
249
245
                private String _version = null;
250
246
                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
 
                }
285
 
 
286
 
                @SuppressWarnings("serial")
 
247
                private int _nameLevel = NAMELEVEL_NONE;
 
248
 
287
249
                protected class ParseException extends Exception
288
250
                {
289
 
                        @SuppressWarnings("unused")
290
251
                        public ParseException( String error )
291
252
                        {
292
253
                                super( error );
298
259
                        }
299
260
                }
300
261
 
301
 
                @SuppressWarnings("serial")
302
262
                protected class SkipContactException extends Exception { }
303
263
 
304
264
                public void parseLine( String line )
305
265
                                throws ParseException, SkipContactException,
306
266
                                AbortImportException
307
267
                {
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 );
 
268
                        // get property halves
 
269
                        String[] props = line.split( ":" );
316
270
                        for( int i = 0; i < props.length; i++ )
317
271
                                props[ i ] = props[ i ].trim();
 
272
                        if( props.length < 2 ||
 
273
                                        props[ 0 ].length() < 1 || props[ 1 ].length() < 1 )
 
274
                                throw new ParseException( R.string.error_vcf_malformed );
318
275
 
319
 
                        // if we haven't yet got a version, we won't be paring anything!
320
276
                        if( _version == null )
321
277
                        {
322
 
                                // is this a version?
323
 
                                if( props.length == 2 && props[ 0 ].equals( "VERSION" ) )
 
278
                                if( props[ 0 ].equals( "VERSION" ) )
324
279
                                {
325
 
                                        // yes, check/store it
 
280
                                        // get version
326
281
                                        if( !props[ 1 ].equals( "2.1" ) &&
327
282
                                                        !props[ 1 ].equals( "3.0" ) )
328
283
                                                throw new ParseException( R.string.error_vcf_version );
336
291
                                }
337
292
                                else
338
293
                                {
339
 
                                        // no, so stash this line till we have a version
 
294
                                        // stash this line till we have a version
340
295
                                        if( _lines == null )
341
296
                                                _lines = new Vector< String >();
342
297
                                        _lines.add( line );
344
299
                        }
345
300
                        else
346
301
                        {
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
302
                                // get parameter parts
372
303
                                String[] params = props[ 0 ].split( ";" );
373
304
                                for( int i = 0; i < params.length; i++ )
374
305
                                        params[ i ] = params[ i ].trim();
375
306
 
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
307
                                // parse some properties
422
308
                                if( params[ 0 ].equals( "N" ) )
423
 
                                        parseN( params, value );
 
309
                                        parseN( params, props[ 1 ] );
424
310
                                else if( params[ 0 ].equals( "FN" ) )
425
 
                                        parseFN( params, value );
 
311
                                        parseFN( params, props[ 1 ] );
426
312
                                else if( params[ 0 ].equals( "ORG" ) )
427
 
                                        parseORG( params, value );
 
313
                                        parseORG( params, props[ 1 ] );
428
314
                                else if( params[ 0 ].equals( "TEL" ) )
429
 
                                        parseTEL( params, value );
 
315
                                        parseTEL( params, props[ 1 ] );
430
316
                                else if( params[ 0 ].equals( "EMAIL" ) )
431
 
                                        parseEMAIL( params, value );
 
317
                                        parseEMAIL( params, props[ 1 ] );
432
318
                        }
433
319
                }
434
320
 
437
323
                                AbortImportException
438
324
                {
439
325
                        // already got a better name?
440
 
                        if( _name_level >= NAMELEVEL_N ) return;
 
326
                        if( _nameLevel >= NAMELEVEL_N ) return;
441
327
 
442
328
                        // get name parts
443
329
                        String[] nameparts = value.split( ";" );
452
338
                                value += ( value.length() == 0? "" : " " ) + nameparts[ 0 ];
453
339
 
454
340
                        // set name
455
 
                        setName( value );
456
 
                        _name_level = NAMELEVEL_N;
 
341
                        setName( undoCharsetAndEncoding( params, value ) );
 
342
                        _nameLevel = NAMELEVEL_N;
457
343
 
458
344
                        // check now to see if we need to import this contact (to avoid
459
345
                        // parsing the rest of the vCard unnecessarily)
465
351
                                throws ParseException, SkipContactException
466
352
                {
467
353
                        // already got a better name?
468
 
                        if( _name_level >= NAMELEVEL_FN ) return;
 
354
                        if( _nameLevel >= NAMELEVEL_FN ) return;
469
355
 
470
356
                        // set name
471
 
                        setName( value );
472
 
                        _name_level = NAMELEVEL_FN;
 
357
                        setName( undoCharsetAndEncoding( params, value ) );
 
358
                        _nameLevel = NAMELEVEL_FN;
473
359
                }
474
360
 
475
361
                private void parseORG( String[] params, String value )
476
362
                                throws ParseException, SkipContactException
477
363
                {
478
364
                        // already got a better name?
479
 
                        if( _name_level >= NAMELEVEL_ORG ) return;
 
365
                        if( _nameLevel >= NAMELEVEL_ORG ) return;
480
366
 
481
367
                        // get org parts
482
368
                        String[] orgparts = value.split( ";" );
490
376
                                value = orgparts[ 0 ];
491
377
 
492
378
                        // set name
493
 
                        setName( value );
494
 
                        _name_level = NAMELEVEL_ORG;
 
379
                        setName( undoCharsetAndEncoding( params, value ) );
 
380
                        _nameLevel = NAMELEVEL_ORG;
495
381
                }
496
382
 
497
383
                private void parseTEL( String[] params, String value )
522
408
                }
523
409
 
524
410
                public void parseEMAIL( String[] params, String value )
525
 
                                throws ParseException
526
411
                {
527
412
                        if( value.length() == 0 ) return;
528
413
 
546
431
                                throw new ParseException( R.string.error_vcf_malformed );
547
432
 
548
433
                        //  missing name properties?
549
 
                        if( _name_level == NAMELEVEL_NONE )
 
434
                        if( _nameLevel == NAMELEVEL_NONE )
550
435
                                throw new ParseException( R.string.error_vcf_noname );
551
436
 
552
437
                        // check if we should import this one? If we've already got an 'N'-
553
438
                        // type name, this will already have been done by parseN() so we
554
439
                        // mustn't do this here (or it could prompt twice!)
555
 
                        if( _name_level < NAMELEVEL_N && !isImportRequired( getName() ) )
 
440
                        if( _nameLevel < NAMELEVEL_N && !isImportRequired( getName() ) )
556
441
                                throw new SkipContactException();
557
442
                }
558
443
 
 
444
                private String undoCharsetAndEncoding( String[] params, String value )
 
445
                                throws ParseException
 
446
                {
 
447
                        // check encoding/charset
 
448
                        String charset, encoding;
 
449
                        if( ( charset = checkParam( params, "CHARSET" ) ) != null &&
 
450
                                        !charset.equals( "UTF-8" ) && !charset.equals( "UTF-16" ) )
 
451
                                throw new ParseException( R.string.error_vcf_charset );
 
452
                        if( ( encoding = checkParam( params, "ENCODING" ) ) != null &&
 
453
                                        !encoding.equals( "QUOTED-PRINTABLE" ) )
 
454
                                throw new ParseException( R.string.error_vcf_encoding );
 
455
 
 
456
                        // do decoding?
 
457
                        if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
 
458
                                return unencodeQuotedPrintable( value, charset );
 
459
 
 
460
                        // nothing to do!
 
461
                        return value;
 
462
                }
 
463
 
559
464
                private String checkParam( String[] params, String name )
560
465
                {
561
466
                        Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
591
496
                        return types;
592
497
                }
593
498
 
594
 
                private UnencodeResult unencodeQuotedPrintable( String str, String charset )
 
499
                private String unencodeQuotedPrintable( String str, String charset )
595
500
                {
596
 
                        boolean another = false;
597
 
 
598
501
                        // default encoding scheme
599
502
                        if( charset == null ) charset = "UTF-8";
600
503
 
601
504
                        // unencode quoted-pritable encoding, as per RFC1521 section 5.1
602
505
                        byte[] bytes = new byte[ str.length() ];
603
506
                        int j = 0;
604
 
                        for( int i = 0; i < str.length(); i++ )
605
 
                        {
606
 
                                // get next char and process...
 
507
                        for( int i = 0; i < str.length(); i++, j++ ) {
607
508
                                char ch = str.charAt( i );
608
 
                                if( ch == '=' && i < str.length() - 2 )
609
 
                                {
610
 
                                        // we found a =XX format byte, add it
 
509
                                if( ch == '=' && i < str.length() - 2 ) {
611
510
                                        bytes[ j ] = (byte)(
612
511
                                                        Character.digit( str.charAt( i + 1 ), 16 ) * 16 +
613
512
                                                        Character.digit( str.charAt( i + 2 ), 16 ) );
614
513
                                        i += 2;
615
514
                                }
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
515
                                else
624
 
                                        // just a normal char...
625
516
                                        bytes[ j ] = (byte)ch;
626
 
                                j++;
627
517
                        }
628
 
 
629
 
                        return new UnencodeResult( another, bytes, j );
 
518
                        try {
 
519
                                return new String( bytes, 0, j, charset );
 
520
                        } catch( UnsupportedEncodingException e ) { }
 
521
                        return null;
630
522
                }
631
523
        }
632
524
}