/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-10-17 18:43:13 UTC
  • Revision ID: edam@waxworlds.org-20101017184313-y2m6gsdzctjq5wtl
- changed case on charset and encoding warning strings (it looked bad)
- properly handle quoted-printable unencoding (including multi-line values)
- ignore blank lines in vCard
- ignore empty properties in vCard

Show diffs side-by-side

added added

removed removed

src/org/waxworlds/edam/importcontacts/VCFImporter.java
1
 
package org.waxworlds.importcontacts;
 
1
/*
 
2
 * VCFImporter.java
 
3
 *
 
4
 * Copyright (C) 2009 Tim Marston <edam@waxworlds.org>
 
5
 *
 
6
 * This file is part of the Import Contacts program (hereafter referred
 
7
 * to as "this program"). For more information, see
 
8
 * http://www.waxworlds.org/edam/software/android/import-contacts
 
9
 *
 
10
 * This program is free software: you can redistribute it and/or modify
 
11
 * it under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 *
 
15
 * This program is distributed in the hope that it will be useful,
 
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
 * GNU General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
22
 */
 
23
 
 
24
package org.waxworlds.edam.importcontacts;
2
25
 
3
26
import java.io.BufferedReader;
4
27
import java.io.File;
15
38
import java.util.regex.Matcher;
16
39
import java.util.regex.Pattern;
17
40
 
18
 
import org.waxworlds.importcontacts.Importer.AbortImportException;
19
 
 
20
41
import android.content.SharedPreferences;
21
42
import android.provider.Contacts;
22
43
import android.provider.Contacts.PhonesColumns;
46
67
                        // open directory
47
68
                        String location = prefs.getString( "location", "" );
48
69
                        File dir = new File( location );
49
 
                        if( !dir.exists() || !dir.isDirectory() )
 
70
                        if( !dir.exists() )
50
71
                                showError( R.string.error_locationnotfound );
51
72
 
52
 
                        // get files
53
 
                        class VCardFilter implements FilenameFilter {
54
 
                            public boolean accept( File dir, String name ) {
55
 
                                return name.toLowerCase().endsWith( ".vcf" );
56
 
                            }
57
 
                        }
58
 
                        files = dir.listFiles( new VCardFilter() );
 
73
                        // directory, or file?
 
74
                        if( dir.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 = dir.listFiles( new VCardFilter() );
 
83
                        }
 
84
                        else
 
85
                        {
 
86
                                // use just this file
 
87
                                files = new File[ 1 ];
 
88
                                files[ 0 ] = dir;
 
89
                        }
59
90
                }
60
91
                catch( SecurityException e ) {
61
92
                        showError( R.string.error_locationpermissions );
107
138
 
108
139
                }
109
140
                catch( FileNotFoundException e ) {
110
 
                        showError( getText( R.string.error_filenotfound ) + file.getName() );
 
141
                        showError( getText( R.string.error_filenotfound ) +
 
142
                                file.getName() );
111
143
                }
112
144
                catch( IOException e ) {
113
145
                        showError( getText( R.string.error_ioerror ) + file.getName() );
131
163
                        importVCardFileContent( content.toString(), file.getName() );
132
164
                }
133
165
                catch( FileNotFoundException e ) {
134
 
                        showError( getText( R.string.error_filenotfound ) + file.getName() );
 
166
                        showError( getText( R.string.error_filenotfound ) +
 
167
                                file.getName() );
135
168
                }
136
169
                catch( IOException e ) {
137
170
                        showError( getText( R.string.error_ioerror ) + file.getName() );
141
174
        private void importVCardFileContent( String content, String fileName )
142
175
                        throws AbortImportException
143
176
        {
144
 
                // unfold RFC2425 section 5.8.1 folded lines, except that we must also
145
 
                // handle embedded Quoted-Printable encodings that have a trailing '='.
146
 
                // So we remove these first before doing RFC2425 unfolding.
147
 
                content = content.replaceAll( "=\n[ \\t]", "" )
148
 
                                .replaceAll( "\n[ \\t]", "" );
149
 
 
150
177
                // get lines and parse them
151
178
                String[] lines = content.split( "\n" );
152
179
                VCard vCard = null;
175
202
                                                if( !showContinue(
176
203
                                                                getText( R.string.error_vcf_parse ).toString()
177
204
                                                                + fileName + "\n" + e.getMessage() ) )
178
 
                                                        abort();
 
205
                                                        finish( ACTION_ABORT );
179
206
                                        }
180
207
                                        catch( VCard.SkipContactException e ) {
181
208
                                                skipContact();
194
221
                                                if( !showContinue(
195
222
                                                                getText( R.string.error_vcf_parse ).toString()
196
223
                                                                + fileName + "\n" + e.getMessage() ) )
197
 
                                                        abort();
 
224
                                                        finish( ACTION_ABORT );
198
225
 
199
226
                                                // although we're continuing, we still need to abort
200
227
                                                // this vCard. Further lines will be ignored until we
221
248
 
222
249
                private String _version = null;
223
250
                private Vector< String > _lines = null;
224
 
                private int _nameLevel = NAMELEVEL_NONE;
225
 
 
 
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")
226
287
                protected class ParseException extends Exception
227
288
                {
 
289
                        @SuppressWarnings("unused")
228
290
                        public ParseException( String error )
229
291
                        {
230
292
                                super( error );
236
298
                        }
237
299
                }
238
300
 
 
301
                @SuppressWarnings("serial")
239
302
                protected class SkipContactException extends Exception { }
240
303
 
241
304
                public void parseLine( String line )
242
305
                                throws ParseException, SkipContactException,
243
306
                                AbortImportException
244
307
                {
245
 
                        // get property halves
246
 
                        String[] props = line.split( ":" );
 
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 );
247
316
                        for( int i = 0; i < props.length; i++ )
248
317
                                props[ i ] = props[ i ].trim();
249
 
                        if( props.length < 2 ||
250
 
                                        props[ 0 ].length() < 1 || props[ 1 ].length() < 1 )
251
 
                                throw new ParseException( R.string.error_vcf_malformed );
252
318
 
 
319
                        // if we haven't yet got a version, we won't be paring anything!
253
320
                        if( _version == null )
254
321
                        {
255
 
                                if( props[ 0 ].equals( "VERSION" ) )
 
322
                                // is this a version?
 
323
                                if( props.length == 2 && props[ 0 ].equals( "VERSION" ) )
256
324
                                {
257
 
                                        // get version
 
325
                                        // yes, check/store it
258
326
                                        if( !props[ 1 ].equals( "2.1" ) &&
259
327
                                                        !props[ 1 ].equals( "3.0" ) )
260
328
                                                throw new ParseException( R.string.error_vcf_version );
268
336
                                }
269
337
                                else
270
338
                                {
271
 
                                        // stash this line till we have a version
 
339
                                        // no, so stash this line till we have a version
272
340
                                        if( _lines == null )
273
341
                                                _lines = new Vector< String >();
274
342
                                        _lines.add( line );
276
344
                        }
277
345
                        else
278
346
                        {
 
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
 
279
371
                                // get parameter parts
280
372
                                String[] params = props[ 0 ].split( ";" );
281
373
                                for( int i = 0; i < params.length; i++ )
282
374
                                        params[ i ] = params[ i ].trim();
283
375
 
 
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
 
284
421
                                // parse some properties
285
422
                                if( params[ 0 ].equals( "N" ) )
286
 
                                        parseN( params, props[ 1 ] );
 
423
                                        parseN( params, value );
287
424
                                else if( params[ 0 ].equals( "FN" ) )
288
 
                                        parseFN( params, props[ 1 ] );
 
425
                                        parseFN( params, value );
289
426
                                else if( params[ 0 ].equals( "ORG" ) )
290
 
                                        parseORG( params, props[ 1 ] );
 
427
                                        parseORG( params, value );
291
428
                                else if( params[ 0 ].equals( "TEL" ) )
292
 
                                        parseTEL( params, props[ 1 ] );
 
429
                                        parseTEL( params, value );
293
430
                                else if( params[ 0 ].equals( "EMAIL" ) )
294
 
                                        parseEMAIL( params, props[ 1 ] );
 
431
                                        parseEMAIL( params, value );
295
432
                        }
296
433
                }
297
434
 
300
437
                                AbortImportException
301
438
                {
302
439
                        // already got a better name?
303
 
                        if( _nameLevel >= NAMELEVEL_N ) return;
 
440
                        if( _name_level >= NAMELEVEL_N ) return;
304
441
 
305
442
                        // get name parts
306
443
                        String[] nameparts = value.split( ";" );
315
452
                                value += ( value.length() == 0? "" : " " ) + nameparts[ 0 ];
316
453
 
317
454
                        // set name
318
 
                        setName( undoCharsetAndEncoding( params, value ) );
319
 
                        _nameLevel = NAMELEVEL_N;
 
455
                        setName( value );
 
456
                        _name_level = NAMELEVEL_N;
320
457
 
321
458
                        // check now to see if we need to import this contact (to avoid
322
459
                        // parsing the rest of the vCard unnecessarily)
328
465
                                throws ParseException, SkipContactException
329
466
                {
330
467
                        // already got a better name?
331
 
                        if( _nameLevel >= NAMELEVEL_FN ) return;
 
468
                        if( _name_level >= NAMELEVEL_FN ) return;
332
469
 
333
470
                        // set name
334
 
                        setName( undoCharsetAndEncoding( params, value ) );
335
 
                        _nameLevel = NAMELEVEL_FN;
 
471
                        setName( value );
 
472
                        _name_level = NAMELEVEL_FN;
336
473
                }
337
474
 
338
475
                private void parseORG( String[] params, String value )
339
476
                                throws ParseException, SkipContactException
340
477
                {
341
478
                        // already got a better name?
342
 
                        if( _nameLevel >= NAMELEVEL_ORG ) return;
 
479
                        if( _name_level >= NAMELEVEL_ORG ) return;
343
480
 
344
481
                        // get org parts
345
482
                        String[] orgparts = value.split( ";" );
353
490
                                value = orgparts[ 0 ];
354
491
 
355
492
                        // set name
356
 
                        setName( undoCharsetAndEncoding( params, value ) );
357
 
                        _nameLevel = NAMELEVEL_ORG;
 
493
                        setName( value );
 
494
                        _name_level = NAMELEVEL_ORG;
358
495
                }
359
496
 
360
497
                private void parseTEL( String[] params, String value )
385
522
                }
386
523
 
387
524
                public void parseEMAIL( String[] params, String value )
 
525
                                throws ParseException
388
526
                {
389
527
                        if( value.length() == 0 ) return;
390
528
 
408
546
                                throw new ParseException( R.string.error_vcf_malformed );
409
547
 
410
548
                        //  missing name properties?
411
 
                        if( _nameLevel == NAMELEVEL_NONE )
 
549
                        if( _name_level == NAMELEVEL_NONE )
412
550
                                throw new ParseException( R.string.error_vcf_noname );
413
551
 
414
552
                        // check if we should import this one? If we've already got an 'N'-
415
553
                        // type name, this will already have been done by parseN() so we
416
554
                        // mustn't do this here (or it could prompt twice!)
417
 
                        if( _nameLevel < NAMELEVEL_N && !isImportRequired( getName() ) )
 
555
                        if( _name_level < NAMELEVEL_N && !isImportRequired( getName() ) )
418
556
                                throw new SkipContactException();
419
557
                }
420
558
 
421
 
                private String undoCharsetAndEncoding( String[] params, String value )
422
 
                                throws ParseException
423
 
                {
424
 
                        // check encoding/charset
425
 
                        String charset, encoding;
426
 
                        if( ( charset = checkParam( params, "CHARSET" ) ) != null &&
427
 
                                        !charset.equals( "UTF-8" ) && !charset.equals( "UTF-16" ) )
428
 
                                throw new ParseException( R.string.error_vcf_charset );
429
 
                        if( ( encoding = checkParam( params, "ENCODING" ) ) != null &&
430
 
                                        !encoding.equals( "QUOTED-PRINTABLE" ) )
431
 
                                throw new ParseException( R.string.error_vcf_encoding );
432
 
 
433
 
                        // do decoding?
434
 
                        if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
435
 
                                return unencodeQuotedPrintable( value, charset );
436
 
 
437
 
                        // nothing to do!
438
 
                        return value;
439
 
                }
440
 
 
441
559
                private String checkParam( String[] params, String name )
442
560
                {
443
561
                        Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
473
591
                        return types;
474
592
                }
475
593
 
476
 
                private String unencodeQuotedPrintable( String str, String charset )
 
594
                private UnencodeResult unencodeQuotedPrintable( String str, String charset )
477
595
                {
 
596
                        boolean another = false;
 
597
 
478
598
                        // default encoding scheme
479
599
                        if( charset == null ) charset = "UTF-8";
480
600
 
481
601
                        // unencode quoted-pritable encoding, as per RFC1521 section 5.1
482
602
                        byte[] bytes = new byte[ str.length() ];
483
603
                        int j = 0;
484
 
                        for( int i = 0; i < str.length(); i++, j++ ) {
 
604
                        for( int i = 0; i < str.length(); i++ )
 
605
                        {
 
606
                                // get next char and process...
485
607
                                char ch = str.charAt( i );
486
 
                                if( ch == '=' && i < str.length() - 2 ) {
 
608
                                if( ch == '=' && i < str.length() - 2 )
 
609
                                {
 
610
                                        // we found a =XX format byte, add it
487
611
                                        bytes[ j ] = (byte)(
488
612
                                                        Character.digit( str.charAt( i + 1 ), 16 ) * 16 +
489
613
                                                        Character.digit( str.charAt( i + 2 ), 16 ) );
490
614
                                        i += 2;
491
615
                                }
 
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
                                }
492
623
                                else
 
624
                                        // just a normal char...
493
625
                                        bytes[ j ] = (byte)ch;
 
626
                                j++;
494
627
                        }
495
 
                        try {
496
 
                                return new String( bytes, 0, j, charset );
497
 
                        } catch( UnsupportedEncodingException e ) { }
498
 
                        return null;
 
628
 
 
629
                        return new UnencodeResult( another, bytes, j );
499
630
                }
500
631
        }
501
632
}