/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: 2011-04-22 15:36:06 UTC
  • Revision ID: edam@waxworlds.org-20110422153606-9x9l0nbmvx6oxfxu
- pulled contacts cache out in to seperate class

Show diffs side-by-side

added added

removed removed

1
1
/*
2
2
 * VCFImporter.java
3
3
 *
4
 
 * Copyright (C) 2009 to 2013 Tim Marston <tim@ed.am>
 
4
 * Copyright (C) 2009 Tim Marston <edam@waxworlds.org>
5
5
 *
6
6
 * This file is part of the Import Contacts program (hereafter referred
7
 
 * to as "this program").  For more information, see
8
 
 * http://ed.am/dev/android/import-contacts
 
7
 * to as "this program"). For more information, see
 
8
 * http://www.waxworlds.org/edam/software/android/import-contacts
9
9
 *
10
10
 * This program is free software: you can redistribute it and/or modify
11
11
 * it under the terms of the GNU General Public License as published by
21
21
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
22
 */
23
23
 
24
 
package am.ed.importcontacts;
 
24
package org.waxworlds.edam.importcontacts;
25
25
 
26
26
import java.io.BufferedReader;
27
27
import java.io.File;
34
34
import java.nio.ByteBuffer;
35
35
import java.util.ArrayList;
36
36
import java.util.Arrays;
37
 
import java.util.HashMap;
38
37
import java.util.HashSet;
39
38
import java.util.Iterator;
40
39
import java.util.List;
41
 
import java.util.Locale;
42
40
import java.util.NoSuchElementException;
43
41
import java.util.Set;
44
42
import java.util.Vector;
46
44
import java.util.regex.Pattern;
47
45
 
48
46
import android.content.SharedPreferences;
49
 
import android.os.Environment;
 
47
import android.provider.Contacts;
 
48
import android.provider.Contacts.PhonesColumns;
50
49
 
51
 
public class VcardImporter extends Importer
 
50
public class VCFImporter extends Importer
52
51
{
53
 
        private int _vcard_count = 0;
 
52
        private int _vCardCount = 0;
54
53
        private int _progress = 0;
55
54
 
56
 
        public VcardImporter( Doit doit )
 
55
        public VCFImporter( Doit doit )
57
56
        {
58
57
                super( doit );
59
58
        }
70
69
                File[] files = null;
71
70
                try
72
71
                {
73
 
                        // check SD card is mounted
74
 
                        String state = Environment.getExternalStorageState();
75
 
                        if( !Environment.MEDIA_MOUNTED.equals( state ) &&
76
 
                                !Environment.MEDIA_MOUNTED_READ_ONLY.equals( state ) )
77
 
                        {
78
 
                                showError( R.string.error_nosdcard );
79
 
                        }
80
 
 
81
72
                        // open directory
82
 
                        File file = new File( Environment.getExternalStorageDirectory(),
83
 
                                prefs.getString( "location", "/" ) );
 
73
                        String path = "/sdcard" + prefs.getString( "location", "/" );
 
74
                        File file = new File( path );
84
75
                        if( !file.exists() )
85
76
                                showError( R.string.error_locationnotfound );
86
77
 
90
81
                                // get files
91
82
                                class VCardFilter implements FilenameFilter {
92
83
                                        public boolean accept( File dir, String name ) {
93
 
                                                return name.toLowerCase( Locale.ENGLISH )
94
 
                                                        .endsWith( ".vcf" );
 
84
                                                return name.toLowerCase().endsWith( ".vcf" );
95
85
                                        }
96
86
                                }
97
87
                                files = file.listFiles( new VCardFilter() );
119
109
                        countVCardFile( files[ i ] );
120
110
                        setTmpProgress( i );
121
111
                }
122
 
                setProgressMax( _vcard_count ); // will also update tmp progress
 
112
                setProgressMax( _vCardCount );  // will also update tmp progress
123
113
 
124
114
                // import them
125
115
                setProgress( 0 );
126
116
                for( int i = 0; i < files.length; i++ )
127
117
                        importVCardFile( files[ i ] );
128
 
                setProgress( _vcard_count );
129
118
        }
130
119
 
131
120
        private void countVCardFile( File file ) throws AbortImportException
138
127
 
139
128
                        // read
140
129
                        String line;
141
 
                        boolean in_vcard = false;
 
130
                        boolean inVCard = false;
142
131
                        while( ( line = reader.readLine() ) != null )
143
132
                        {
144
 
                                if( !in_vcard )
145
 
                                {
 
133
                                if( !inVCard ) {
146
134
                                        // look for vcard beginning
147
 
                                        if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {
148
 
                                                in_vcard = true;
149
 
                                                _vcard_count++;
150
 
                                        }
151
 
                                        // check for vMsg files
152
 
                                        else if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VMSG.*" ) ) {
153
 
                                                showError( getText( R.string.error_vcf_vmsgfile )
154
 
                                                        + file.getName() );
 
135
                                        if( line.matches( "^BEGIN:VCARD" ) ) {
 
136
                                                inVCard = true;
 
137
                                                _vCardCount++;
155
138
                                        }
156
139
                                }
157
 
                                else if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )
158
 
                                        in_vcard = false;
 
140
                                else if( line.matches( "^END:VCARD" ) )
 
141
                                        inVCard = false;
159
142
                        }
160
 
                        reader.close();
161
143
 
162
144
                }
163
145
                catch( FileNotFoundException e ) {
185
167
                        FileInputStream istream = new FileInputStream( file );
186
168
                        byte[] content = new byte[ (int)file.length() ];
187
169
                        istream.read( content );
188
 
                        istream.close();
189
170
 
190
171
                        // import
191
172
                        importVCardFileContent( content, file.getName() );
192
173
                }
193
 
                catch( OutOfMemoryError e ) {
194
 
                        showError( R.string.error_outofmemory );
195
 
                }
196
174
                catch( FileNotFoundException e ) {
197
175
                        showError( getText( R.string.error_filenotfound ) +
198
176
                                file.getName() );
206
184
                throws AbortImportException
207
185
        {
208
186
                // go through lines
209
 
                Vcard vcard = null;
210
 
                int vcard_start_line = 0;
 
187
                VCard vCard = null;
211
188
                ContentLineIterator cli = new ContentLineIterator( content );
212
189
                while( cli.hasNext() )
213
190
                {
214
 
                        ContentLine content_line = cli.next();
215
 
 
216
 
                        // get a US-ASCII version of the string, for processing
217
 
                        String line = content_line.getUsAsciiLine();
218
 
 
219
 
                        if( vcard == null ) {
 
191
                        ByteBuffer buffer = cli.next();
 
192
 
 
193
                        // get a US-ASCII version of the line for processing
 
194
                        String line;
 
195
                        try {
 
196
                                line = new String( buffer.array(), buffer.position(),
 
197
                                        buffer.limit() - buffer.position(), "US-ASCII" );
 
198
                        }
 
199
                        catch( UnsupportedEncodingException e ) {
 
200
                                // we know US-ASCII is supported, so appease the compiler...
 
201
                                line = "";
 
202
                        }
 
203
 
 
204
                        if( vCard == null ) {
220
205
                                // look for vcard beginning
221
 
                                if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {
222
 
                                        setProgress( _progress++ );
223
 
                                        vcard = new Vcard();
224
 
                                        vcard_start_line = cli.getLineNumber();
 
206
                                if( line.matches( "^BEGIN:VCARD" ) ) {
 
207
                                        setProgress( ++_progress );
 
208
                                        vCard = new VCard();
225
209
                                }
226
210
                        }
227
211
                        else {
228
212
                                // look for vcard content or ending
229
 
                                if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )
 
213
                                if( line.matches( "^END:VCARD" ) )
230
214
                                {
231
 
                                        // finalise the vcard/contact
 
215
                                        // store vcard and do away with it
232
216
                                        try {
233
 
                                                vcard.finaliseVcard();
234
 
 
235
 
                                                // pass the finalised contact to the importer
236
 
                                                importContact( vcard );
237
 
                                        }
238
 
                                        catch( Vcard.ParseException e ) {
239
 
                                                showContinueOrAbort(
240
 
                                                        getText( R.string.error_vcf_parse ).toString()
241
 
                                                        + fileName +
242
 
                                                        getText( R.string.error_vcf_parse_line ).toString()
243
 
                                                        + cli.getLineNumber() + ":\n" + e.getMessage() );
244
 
                                                skipContact();
245
 
                                        }
246
 
                                        catch( ContactData.ContactNotIdentifiableException e ) {
247
 
                                                showContinueOrAbort(
248
 
                                                        getText( R.string.error_vcf_parse ).toString()
249
 
                                                        + fileName +
250
 
                                                        getText( R.string.error_vcf_parse_line ).toString()
251
 
                                                        + vcard_start_line + ":\n" + getText(
252
 
                                                                R.string.error_vcf_notenoughinfo ).toString() );
253
 
                                                skipContact();
254
 
                                        }
255
 
 
256
 
                                        // discard this vcard
257
 
                                        vcard = null;
 
217
                                                vCard.finaliseParsing();
 
218
                                                importContact( vCard );
 
219
                                        }
 
220
                                        catch( VCard.ParseException e ) {
 
221
                                                skipContact();
 
222
                                                if( !showContinue(
 
223
                                                        getText( R.string.error_vcf_parse ).toString()
 
224
                                                        + fileName + "\n" + e.getMessage() ) )
 
225
                                                {
 
226
                                                        finish( ACTION_ABORT );
 
227
                                                }
 
228
                                        }
 
229
                                        catch( VCard.SkipContactException e ) {
 
230
                                                skipContact();
 
231
                                                // do nothing
 
232
                                        }
 
233
                                        vCard = null;
258
234
                                }
259
235
                                else
260
236
                                {
261
237
                                        // try giving the line to the vcard
262
238
                                        try {
263
 
                                                vcard.parseLine( content_line );
 
239
                                                vCard.parseLine( buffer, line,
 
240
                                                        cli.doesNextLineLookFolded() );
264
241
                                        }
265
 
                                        catch( Vcard.ParseException e ) {
 
242
                                        catch( VCard.ParseException e ) {
266
243
                                                skipContact();
267
 
                                                showContinueOrAbort(
 
244
                                                if( !showContinue(
268
245
                                                        getText( R.string.error_vcf_parse ).toString()
269
 
                                                        + fileName +
270
 
                                                        getText( R.string.error_vcf_parse_line ).toString()
271
 
                                                        + cli.getLineNumber() + "\n" + e.getMessage() );
 
246
                                                        + fileName + "\n" + e.getMessage() ) )
 
247
                                                {
 
248
                                                        finish( ACTION_ABORT );
 
249
                                                }
272
250
 
273
 
                                                // Although we're continuing, we still need to abort
274
 
                                                // this vCard.  Further lines will be ignored until we
 
251
                                                // although we're continuing, we still need to abort
 
252
                                                // this vCard. Further lines will be ignored until we
275
253
                                                // get to another BEGIN:VCARD line.
276
 
                                                vcard = null;
 
254
                                                vCard = null;
277
255
                                        }
278
 
                                        catch( Vcard.SkipImportException e ) {
 
256
                                        catch( VCard.SkipContactException e ) {
279
257
                                                skipContact();
280
 
                                                // Abort this vCard.  Further lines will be ignored until
 
258
                                                // abort this vCard. Further lines will be ignored until
281
259
                                                // we get to another BEGIN:VCARD line.
282
 
                                                vcard = null;
 
260
                                                vCard = null;
283
261
                                        }
284
262
                                }
285
263
                        }
286
264
                }
287
265
        }
288
266
 
289
 
        class ContentLine
290
 
        {
291
 
                private ByteBuffer _buffer;
292
 
                private boolean _folded_next;
293
 
                private String _line;
294
 
 
295
 
                public ContentLine( ByteBuffer buffer, boolean folded_next )
296
 
                {
297
 
                        _buffer = buffer;
298
 
                        _folded_next = folded_next;
299
 
                        _line = null;
300
 
                }
301
 
 
302
 
                public ByteBuffer getBuffer()
303
 
                {
304
 
                        return _buffer;
305
 
                }
306
 
 
307
 
                public boolean doesNextLineLookFolded()
308
 
                {
309
 
                        return _folded_next;
310
 
                }
311
 
 
312
 
                public String getUsAsciiLine()
313
 
                {
314
 
                        // generated line and cache it
315
 
                        if( _line == null ) {
316
 
                                try {
317
 
                                        _line = new String( _buffer.array(), _buffer.position(),
318
 
                                                _buffer.limit() - _buffer.position(), "US-ASCII" );
319
 
                                }
320
 
                                catch( UnsupportedEncodingException e ) {
321
 
                                        // we know US-ASCII *is* supported, so appease the
322
 
                                        // compiler...
323
 
                                }
324
 
                        }
325
 
 
326
 
                        // return cached line
327
 
                        return _line;
328
 
                }
329
 
        }
330
 
 
331
 
        class ContentLineIterator implements Iterator< ContentLine >
 
267
        class ContentLineIterator implements Iterator< ByteBuffer >
332
268
        {
333
269
                protected byte[] _content = null;
334
270
                protected int _pos = 0;
335
 
                protected int _line = 0;
336
271
 
337
272
                public ContentLineIterator( byte[] content )
338
273
                {
346
281
                }
347
282
 
348
283
                @Override
349
 
                public ContentLine next()
 
284
                public ByteBuffer next()
350
285
                {
351
286
                        int initial_pos = _pos;
352
287
 
358
293
                                        int to = ( _pos > 0 && _content[ _pos - 1 ] == '\r' &&
359
294
                                                _pos > initial_pos )? _pos - 1 : _pos;
360
295
                                        _pos++;
361
 
                                        _line++;
362
 
                                        return new ContentLine(
363
 
                                                ByteBuffer.wrap( _content, initial_pos,
364
 
                                                        to - initial_pos ),
365
 
                                                doesNextLineLookFolded() );
 
296
                                        return ByteBuffer.wrap( _content, initial_pos,
 
297
                                                to - initial_pos );
366
298
                                }
367
299
 
368
300
                        // we didn't find one, but were there bytes left?
369
301
                        if( _pos != initial_pos ) {
370
302
                                int to = _pos;
371
303
                                _pos++;
372
 
                                _line++;
373
 
                                return new ContentLine(
374
 
                                        ByteBuffer.wrap( _content, initial_pos,
375
 
                                                to - initial_pos ),
376
 
                                        doesNextLineLookFolded() );
 
304
                                return ByteBuffer.wrap( _content, initial_pos,
 
305
                                        to - initial_pos );
377
306
                        }
378
307
 
379
308
                        // no bytes left
391
320
                 * onto the end of this one?
392
321
                 * @return
393
322
                 */
394
 
                private boolean doesNextLineLookFolded()
 
323
                public boolean doesNextLineLookFolded()
395
324
                {
396
325
                        return _pos > 0 && _pos < _content.length &&
397
 
                                _content[ _pos - 1 ] == '\n' &&
398
 
                                ( _content[ _pos ] == ' ' || _content[ _pos ] == '\t' );
399
 
                }
400
 
 
401
 
                public int getLineNumber()
402
 
                {
403
 
                        return _line;
 
326
                                _content[ _pos - 1 ] == '\n' && _content[ _pos ] == ' ';
404
327
                }
405
328
        }
406
329
 
407
 
        private class Vcard extends ContactData
 
330
        private class VCard extends ContactData
408
331
        {
409
332
                private final static int NAMELEVEL_NONE = 0;
410
 
                private final static int NAMELEVEL_N = 1;
 
333
                private final static int NAMELEVEL_ORG = 1;
411
334
                private final static int NAMELEVEL_FN = 2;
 
335
                private final static int NAMELEVEL_N = 3;
412
336
 
413
337
                private final static int MULTILINE_NONE = 0;
414
338
                private final static int MULTILINE_ENCODED = 1; // v2.1 quoted-printable
415
339
                private final static int MULTILINE_ESCAPED = 2; // v2.1 \\CRLF
416
 
                private final static int MULTILINE_FOLDED = 3;  // MIME-DIR folding
 
340
                private final static int MULTILINE_FOLDED = 3;  // v3.0 folding
417
341
 
418
342
                private String _version = null;
419
 
                private Vector< ContentLine > _content_lines = null;
 
343
                private Vector< ByteBuffer > _buffers = null;
420
344
                private int _name_level = NAMELEVEL_NONE;
421
345
                private int _parser_multiline_state = MULTILINE_NONE;
422
346
                private String _parser_current_name_and_params = null;
423
347
                private String _parser_buffered_value_so_far = "";
424
 
                private String _cached_organisation = null;
425
 
                private String _cached_title = null;
426
348
 
427
349
                protected class UnencodeResult
428
350
                {
458
380
 
459
381
                        public ParseException( int res )
460
382
                        {
461
 
                                super( VcardImporter.this.getText( res ).toString() );
 
383
                                super( VCFImporter.this.getText( res ).toString() );
462
384
                        }
463
385
                }
464
386
 
465
387
                @SuppressWarnings("serial")
466
 
                protected class SkipImportException extends Exception { }
 
388
                protected class SkipContactException extends Exception { }
467
389
 
468
 
                private String extractCollonPartFromLine( ContentLine content_line,
469
 
                        boolean former )
 
390
                private String extractCollonPartFromLine( ByteBuffer buffer,
 
391
                        String line, boolean former )
470
392
                {
 
393
                        String ret = null;
 
394
 
 
395
                        // get a US-ASCII version of the line for processing, unless we were
 
396
                        // supplied with one
 
397
                        if( line == null ) {
 
398
                                try {
 
399
                                        line = new String( buffer.array(), buffer.position(),
 
400
                                                buffer.limit() - buffer.position(), "US-ASCII" );
 
401
                                }
 
402
                                catch( UnsupportedEncodingException e ) {
 
403
                                        // we know US-ASCII is supported, so appease the compiler...
 
404
                                        line = "";
 
405
                                }
 
406
                        }
 
407
 
471
408
                        // split line into name and value parts and check to make sure we
472
409
                        // only got 2 parts and that the first part is not zero in length
473
 
                        String[] parts = content_line.getUsAsciiLine().split( ":", 2 );
 
410
                        String[] parts = line.split( ":", 2 );
474
411
                        if( parts.length == 2 && parts[ 0 ].length() > 0 )
475
 
                                return parts[ former? 0 : 1 ].trim();
476
 
 
477
 
                        return null;
478
 
                }
479
 
 
480
 
                private String extractNameAndParamsFromLine( ContentLine content_line )
481
 
                {
482
 
                        return extractCollonPartFromLine( content_line, true );
483
 
                }
484
 
 
485
 
                private String extractValueFromLine( ContentLine content_line )
486
 
                {
487
 
                        return extractCollonPartFromLine( content_line, false );
488
 
                }
489
 
 
490
 
                public void parseLine( ContentLine content_line )
491
 
                        throws ParseException, SkipImportException,
 
412
                                ret = parts[ former? 0 : 1 ];
 
413
 
 
414
                        return ret;
 
415
                }
 
416
 
 
417
                private String extractNameAndParamsFromLine( ByteBuffer buffer,
 
418
                        String line )
 
419
                {
 
420
                        return extractCollonPartFromLine( buffer, line, true );
 
421
                }
 
422
 
 
423
                private String extractValueFromLine( ByteBuffer buffer, String line )
 
424
                {
 
425
                        return extractCollonPartFromLine( buffer, line, false );
 
426
                }
 
427
 
 
428
                public void parseLine( ByteBuffer buffer, String line,
 
429
                        boolean next_line_looks_folded )
 
430
                        throws ParseException, SkipContactException,
492
431
                        AbortImportException
493
432
                {
494
433
                        // do we have a version yet?
496
435
                        {
497
436
                                // tentatively get name and params from line
498
437
                                String name_and_params =
499
 
                                        extractNameAndParamsFromLine( content_line );
 
438
                                        extractNameAndParamsFromLine( buffer, line );
500
439
 
501
440
                                // is it a version line?
502
441
                                if( name_and_params != null &&
503
 
                                        name_and_params.equalsIgnoreCase( "VERSION" ) )
 
442
                                        name_and_params.equals( "VERSION" ) )
504
443
                                {
505
444
                                        // yes, get it!
506
 
                                        String value = extractValueFromLine( content_line );
507
 
                                        if( value == null || (
508
 
                                                !value.equals( "2.1" ) && !value.equals( "3.0" ) ) )
509
 
                                        {
 
445
                                        String value = extractValueFromLine( buffer, line );
 
446
                                        if( !value.equals( "2.1" ) && !value.equals( "3.0" ) )
510
447
                                                throw new ParseException( R.string.error_vcf_version );
511
 
                                        }
512
448
                                        _version = value;
513
449
 
514
450
                                        // parse any buffers we've been accumulating while we waited
515
451
                                        // for a version
516
 
                                        if( _content_lines != null )
517
 
                                                for( int i = 0; i < _content_lines.size(); i++ )
518
 
                                                        parseLine( _content_lines.get( i ) );
519
 
                                        _content_lines = null;
 
452
                                        if( _buffers != null )
 
453
                                                for( int i = 0; i < _buffers.size(); i++ )
 
454
                                                        parseLine( _buffers.get( i ), null,
 
455
                                                                i + 1 < _buffers.size() &&
 
456
                                                                _buffers.get( i + 1 ).hasRemaining() &&
 
457
                                                                _buffers.get( i + 1 ).get(
 
458
                                                                        _buffers.get( i + 1 ).position() ) == ' ' );
 
459
                                        _buffers = null;
520
460
                                }
521
461
                                else
522
462
                                {
523
463
                                        // no, so stash this line till we get a version
524
 
                                        if( _content_lines == null )
525
 
                                                _content_lines = new Vector< ContentLine >();
526
 
                                        _content_lines.add( content_line );
 
464
                                        if( _buffers == null )
 
465
                                                _buffers = new Vector< ByteBuffer >();
 
466
                                        _buffers.add( buffer );
527
467
                                }
528
468
                        }
529
469
                        else
530
470
                        {
531
471
                                // name and params and the position in the buffer where the
532
 
                                // "value" part of the line starts
 
472
                                // "value" part of the line start
533
473
                                String name_and_params;
534
474
                                int pos;
535
475
 
541
481
 
542
482
                                        // skip some initial line characters, depending on the type
543
483
                                        // of multi-line we're handling
544
 
                                        pos = content_line.getBuffer().position();
 
484
                                        pos = buffer.position();
545
485
                                        switch( _parser_multiline_state )
546
486
                                        {
547
487
                                        case MULTILINE_FOLDED:
548
488
                                                pos++;
549
489
                                                break;
550
490
                                        case MULTILINE_ENCODED:
551
 
                                                while( pos < content_line.getBuffer().limit() && (
552
 
                                                        content_line.getBuffer().get( pos ) == ' ' ||
553
 
                                                        content_line.getBuffer().get( pos ) == '\t' ) )
 
491
                                                while( pos < buffer.limit() && (
 
492
                                                        buffer.get( pos ) == ' ' ||
 
493
                                                        buffer.get( pos ) == '\t' ) )
554
494
                                                {
555
495
                                                        pos++;
556
496
                                                }
565
505
                                }
566
506
                                else
567
507
                                {
568
 
                                        // skip empty lines
569
 
                                        if( content_line.getUsAsciiLine().trim().length() == 0 )
570
 
                                                return;
571
 
 
572
508
                                        // get name and params from line, and since we're not
573
509
                                        // parsing a subsequent line in a multi-line, this should
574
510
                                        // not fail, or it's an error
575
511
                                        name_and_params =
576
 
                                                extractNameAndParamsFromLine( content_line );
 
512
                                                extractNameAndParamsFromLine( buffer, line );
577
513
                                        if( name_and_params == null )
578
514
                                                throw new ParseException(
579
515
                                                        R.string.error_vcf_malformed );
580
516
 
581
517
                                        // calculate how many chars to skip from beginning of line
582
518
                                        // so we skip the property "name:" part
583
 
                                        pos = content_line.getBuffer().position() +
584
 
                                                name_and_params.length() + 1;
 
519
                                        pos = buffer.position() + name_and_params.length() + 1;
585
520
 
586
521
                                        // reset the saved multi-line state
587
522
                                        _parser_current_name_and_params = name_and_params;
590
525
 
591
526
                                // get value from buffer, as raw bytes
592
527
                                ByteBuffer value;
593
 
                                value = ByteBuffer.wrap( content_line.getBuffer().array(), pos,
594
 
                                        content_line.getBuffer().limit() - pos );
 
528
                                value = ByteBuffer.wrap( buffer.array(), pos,
 
529
                                        buffer.limit() - pos );
595
530
 
596
531
                                // get parameter parts
597
532
                                String[] name_param_parts = name_and_params.split( ";", -1 );
598
533
                                for( int i = 0; i < name_param_parts.length; i++ )
599
534
                                        name_param_parts[ i ] = name_param_parts[ i ].trim();
600
535
 
601
 
                                // determine whether we care about this entry
602
 
                                final HashSet< String > interesting_fields =
603
 
                                        new HashSet< String >( Arrays.asList( new String[] { "N",
604
 
                                                "FN", "ORG", "TITLE", "TEL", "EMAIL", "ADR", "LABEL" }
605
 
                                ) );
606
 
                                boolean is_interesting_field =
607
 
                                        interesting_fields.contains(
608
 
                                                name_param_parts[ 0 ].toUpperCase( Locale.ENGLISH ) );
609
 
 
610
536
                                // parse encoding parameter
611
537
                                String encoding = checkParam( name_param_parts, "ENCODING" );
612
 
                                if( encoding != null )
613
 
                                        encoding = encoding.toUpperCase( Locale.ENGLISH );
614
 
                                if( is_interesting_field && encoding != null &&
615
 
                                        !encoding.equalsIgnoreCase( "8BIT" ) &&
616
 
                                        !encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )
617
 
                                        //&& !encoding.equalsIgnoreCase( "BASE64" ) )
 
538
                                if( encoding != null ) encoding = encoding.toUpperCase();
 
539
                                if( encoding != null && !encoding.equals( "8BIT" ) &&
 
540
                                        !encoding.equals( "QUOTED-PRINTABLE" ) )
 
541
                                        //&& !encoding.equals( "BASE64" ) )
618
542
                                {
619
543
                                        throw new ParseException( R.string.error_vcf_encoding );
620
544
                                }
621
545
 
622
546
                                // parse charset parameter
623
547
                                String charset = checkParam( name_param_parts, "CHARSET" );
624
 
                                if( charset != null )
625
 
                                        charset = charset.toUpperCase( Locale.ENGLISH );
626
 
                                if( charset != null &&
627
 
                                        !charset.equalsIgnoreCase( "US-ASCII" ) &&
628
 
                                        !charset.equalsIgnoreCase( "ASCII" ) &&
629
 
                                        !charset.equalsIgnoreCase( "UTF-8" ) )
 
548
                                if( charset != null ) charset = charset.toUpperCase();
 
549
                                if( charset != null && !charset.equals( "US-ASCII" ) &&
 
550
                                        !charset.equals( "ASCII" ) &&
 
551
                                        !charset.equals( "UTF-8" ) )
630
552
                                {
631
553
                                        throw new ParseException( R.string.error_vcf_charset );
632
554
                                }
634
556
                                // do unencoding (or default to a fake unencoding result with
635
557
                                // the raw string)
636
558
                                UnencodeResult unencoding_result = null;
637
 
                                if( encoding != null &&
638
 
                                        encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )
639
 
                                {
 
559
                                if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
640
560
                                        unencoding_result = unencodeQuotedPrintable( value );
641
 
                                }
642
 
//                              else if( encoding != null &&
643
 
//                                      encoding.equalsIgnoreCase( "BASE64" ) )
644
 
//                              {
 
561
//                              else if( encoding != null && encoding.equals( "BASE64" ) )
645
562
//                                      unencoding_result = unencodeBase64( props[ 1 ], charset );
646
 
//                              }
647
563
                                if( unencoding_result != null ) {
648
564
                                        value = unencoding_result.getBuffer();
649
565
                                        if( unencoding_result.isAnotherLineRequired() )
650
566
                                                _parser_multiline_state = MULTILINE_ENCODED;
651
567
                                }
652
568
 
653
 
                                // convert 8-bit US-ASCII charset to UTF-8 (where no charset is
654
 
                                // specified for a v2.1 vcard entry, we assume it's US-ASCII)
655
 
                                if( ( charset == null && _version.equals( "2.1" ) ) ||
656
 
                                        ( charset != null && (
657
 
                                                charset.equalsIgnoreCase( "ASCII" ) ||
658
 
                                                charset.equalsIgnoreCase( "US-ASCII" ) ) ) )
659
 
                                {
 
569
                                // convert 8-bit ASCII charset to US-ASCII
 
570
                                if( charset == null || charset.equals( "ASCII" ) ) {
660
571
                                        value = transcodeAsciiToUtf8( value );
 
572
                                        charset = "UTF-8";
661
573
                                }
662
574
 
663
 
                                // process charset (value is now in UTF-8)
 
575
                                // process charset
664
576
                                String string_value;
665
577
                                try {
666
578
                                        string_value = new String( value.array(), value.position(),
667
 
                                                value.limit() - value.position(), "UTF-8" );
 
579
                                                value.limit() - value.position(), charset );
668
580
                                } catch( UnsupportedEncodingException e ) {
669
581
                                        throw new ParseException( R.string.error_vcf_charset );
670
582
                                }
672
584
                                // for some entries that have semicolon-separated value parts,
673
585
                                // check to see if the value ends in an escape character, which
674
586
                                // indicates that we have a multi-line value
675
 
                                if( ( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) ||
676
 
                                        name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) ||
677
 
                                        name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) ) &&
 
587
                                if( ( name_param_parts[ 0 ].equals( "N" ) ||
 
588
                                        name_param_parts[ 0 ].equals( "ORG" ) ||
 
589
                                        name_param_parts[ 0 ].equals( "ADR" ) ) &&
678
590
                                        doesStringEndInAnEscapeChar( string_value ) )
679
591
                                {
680
592
                                        _parser_multiline_state = MULTILINE_ESCAPED;
682
594
                                                string_value.length() - 1 );
683
595
                                }
684
596
 
685
 
                                // if we know we're not in an encoding-based multi-line, check
686
 
                                // to see if we're in a folded multi-line
 
597
                                // now we know whether we're in an encoding multi-line,
 
598
                                // determine if we're in a v3 folded multi-line or not
687
599
                                if( _parser_multiline_state == MULTILINE_NONE &&
688
 
                                        content_line.doesNextLineLookFolded() )
 
600
                                        _version.equals( "3.0" ) && next_line_looks_folded )
689
601
                                {
690
602
                                        _parser_multiline_state = MULTILINE_FOLDED;
691
603
                                }
703
615
                                if( complete_value.length() < 1 ) return;
704
616
 
705
617
                                // parse some properties
706
 
                                if( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) )
 
618
                                if( name_param_parts[ 0 ].equals( "N" ) )
707
619
                                        parseN( name_param_parts, complete_value );
708
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "FN" ) )
 
620
                                else if( name_param_parts[ 0 ].equals( "FN" ) )
709
621
                                        parseFN( name_param_parts, complete_value );
710
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) )
 
622
                                else if( name_param_parts[ 0 ].equals( "ORG" ) )
711
623
                                        parseORG( name_param_parts, complete_value );
712
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "TITLE" ) )
713
 
                                        parseTITLE( name_param_parts, complete_value );
714
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "TEL" ) )
 
624
                                else if( name_param_parts[ 0 ].equals( "TEL" ) )
715
625
                                        parseTEL( name_param_parts, complete_value );
716
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "EMAIL" ) )
 
626
                                else if( name_param_parts[ 0 ].equals( "EMAIL" ) )
717
627
                                        parseEMAIL( name_param_parts, complete_value );
718
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) )
 
628
                                else if( name_param_parts[ 0 ].equals( "ADR" ) )
719
629
                                        parseADR( name_param_parts, complete_value );
720
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "LABEL" ) )
721
 
                                        parseLABEL( name_param_parts, complete_value );
722
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "NOTE" ) )
723
 
                                        parseNOTE( name_param_parts, complete_value );
724
 
                                else if( name_param_parts[ 0 ].equalsIgnoreCase( "BDAY" ) )
725
 
                                        parseBDAY( name_param_parts, complete_value );
726
630
                        }
727
631
                }
728
632
 
741
645
                        return ( count & 1 ) == 1;
742
646
                }
743
647
 
744
 
                private String[] splitValueByCharacter( String value, char character )
 
648
                private String[] splitValueBySemicolon( String value )
745
649
                {
746
 
                        // split string in to parts by specified character
 
650
                        // split string in to parts by semicolon
747
651
                        ArrayList< String > parts = new ArrayList< String >(
748
 
                                Arrays.asList( value.split( "" + character ) ) );
 
652
                                Arrays.asList( value.split(  ";" ) ) );
749
653
 
750
654
                        // go through parts
751
655
                        for( int a = 0; a < parts.size(); a++ )
752
656
                        {
753
657
                                String str = parts.get( a );
754
658
 
755
 
                                // Look for parts that end in an escape character, but ignore
756
 
                                // the final part.  We've already detected escape chars at the
 
659
                                // look for parts that end in an escape character, but ignore
 
660
                                // the final part. We've already detected escape chars at the
757
661
                                // end of the final part in parseLine() and handled multi-lines
758
662
                                // accordingly.
759
663
                                if( a < parts.size() - 1 &&
760
664
                                        doesStringEndInAnEscapeChar( str ) )
761
665
                                {
762
 
                                        // append the escaped character, join the next part to this
763
 
                                        // part and remove the next part
 
666
                                        // join the next part to this part and remove the next part
764
667
                                        parts.set( a, str.substring( 0, str.length() - 1 ) +
765
 
                                                character + parts.get( a + 1 ) );
 
668
                                                ';' + parts.get( a + 1 ) );
766
669
                                        parts.remove( a + 1 );
767
670
 
768
671
                                        // re-visit this part
779
682
                        return parts.toArray( ret );
780
683
                }
781
684
 
782
 
                private String unescapeValue( String value )
783
 
                {
784
 
                        StringBuilder ret = new StringBuilder( value.length() );
785
 
                        boolean in_escape = false;
786
 
                        for( int a = 0; a < value.length(); a++ )
787
 
                        {
788
 
                                int c = value.codePointAt( a );
789
 
 
790
 
                                // process a normal character
791
 
                                if( !in_escape ) {
792
 
                                        if( c == '\\' )
793
 
                                                in_escape = true;
794
 
                                        else
795
 
                                                ret.append( Character.toChars( c ) );
796
 
                                        continue;
797
 
                                }
798
 
 
799
 
                                // process an escape sequence
800
 
                                in_escape = false;
801
 
                                switch( c )
802
 
                                {
803
 
                                case 'T':
804
 
                                case 't':
805
 
                                        // add tab (invalid/non-standard, but accepted)
806
 
                                        ret.append( '\t' );
807
 
                                        break;
808
 
                                case 'N':
809
 
                                case 'n':
810
 
                                        // add newline
811
 
                                        ret.append( '\n' );
812
 
                                        break;
813
 
                                case '\\':
814
 
                                case ',':
815
 
                                case ';':
816
 
                                        // add escaped character
817
 
                                        ret.append( Character.toChars( c ) );
818
 
                                        break;
819
 
                                default:
820
 
                                        // unknown escape sequence, so add it unescaped
821
 
                                        // (invalid/non-standard, but accepted)
822
 
                                        ret.append( "\\" );
823
 
                                        ret.append( Character.toChars( c ) );
824
 
                                        break;
825
 
                                }
826
 
                        }
827
 
 
828
 
                        return ret.toString();
829
 
                }
830
 
 
831
685
                private void parseN( String[] params, String value )
 
686
                        throws ParseException, SkipContactException,
 
687
                        AbortImportException
832
688
                {
833
689
                        // already got a better name?
834
690
                        if( _name_level >= NAMELEVEL_N ) return;
835
691
 
836
692
                        // get name parts
837
 
                        String[] name_parts = splitValueByCharacter( value, ';' );
 
693
                        String[] name_parts = splitValueBySemicolon( value );
838
694
 
839
695
                        // build name
840
696
                        value = "";
841
 
                        final int[] part_order = { 3, 1, 2, 0, 4 };
842
 
                        for( int a = 0; a < part_order.length; a++ )
843
 
                                if( name_parts.length > part_order[ a ] &&
844
 
                                        name_parts[ part_order[ a ] ].length() > 0 )
845
 
                                {
846
 
                                        // split this part in to it's comma-separated bits
847
 
                                        String[] name_part_parts = splitValueByCharacter(
848
 
                                                name_parts[ part_order[ a ] ], ',' );
849
 
                                        for( int b = 0; b < name_part_parts.length; b++ )
850
 
                                                if( name_part_parts[ b ].length() > 0 )
851
 
                                                {
852
 
                                                        if( value.length() > 0 ) value += " ";
853
 
                                                        value += name_part_parts[ b ];
854
 
                                                }
855
 
                                }
 
697
                        if( name_parts.length > 1 && name_parts[ 1 ].length() > 0 )
 
698
                                value += name_parts[ 1 ];
 
699
                        if( name_parts.length > 0 && name_parts[ 0 ].length() > 0 )
 
700
                                value += ( value.length() == 0? "" : " " ) + name_parts[ 0 ];
856
701
 
857
702
                        // set name
858
 
                        setName( unescapeValue( value ) );
 
703
                        setName( value );
859
704
                        _name_level = NAMELEVEL_N;
 
705
 
 
706
                        // check now to see if we need to import this contact (to avoid
 
707
                        // parsing the rest of the vCard unnecessarily)
 
708
                        if( !isImportRequired( getName() ) )
 
709
                                throw new SkipContactException();
860
710
                }
861
711
 
862
712
                private void parseFN( String[] params, String value )
 
713
                        throws ParseException, SkipContactException
863
714
                {
864
715
                        // already got a better name?
865
716
                        if( _name_level >= NAMELEVEL_FN ) return;
866
717
 
867
718
                        // set name
868
 
                        setName( unescapeValue( value ) );
 
719
                        setName( value );
869
720
                        _name_level = NAMELEVEL_FN;
870
721
                }
871
722
 
872
723
                private void parseORG( String[] params, String value )
 
724
                        throws ParseException, SkipContactException
873
725
                {
 
726
                        // already got a better name?
 
727
                        if( _name_level >= NAMELEVEL_ORG ) return;
 
728
 
874
729
                        // get org parts
875
 
                        String[] org_parts = splitValueByCharacter( value, ';' );
876
 
                        if( org_parts == null || org_parts.length < 1 ) return;
877
 
 
878
 
                        // build organisation name
879
 
                        StringBuilder builder = new StringBuilder(
880
 
                                String.valueOf( org_parts[ 0 ] ) );
881
 
                        for( int a = 1; a < org_parts.length; a++ )
882
 
                                builder.append( ", " ).append( org_parts[ a ] );
883
 
                        String organisation = unescapeValue( builder.toString() );
884
 
 
885
 
                        // set organisation name (using a title we've previously found)
886
 
                        addOrganisation( organisation, _cached_title, true );
887
 
 
888
 
                        // if we've not previously found a title, store this organisation
889
 
                        // name (we'll need it when we find a title to update the
890
 
                        // organisation, by name), else if we *have* previously found a
891
 
                        // title, clear it (since we just used it)
892
 
                        if( _cached_title == null )
893
 
                                _cached_organisation = organisation;
894
 
                        else
895
 
                                _cached_title = null;
896
 
                }
897
 
 
898
 
                private void parseTITLE( String[] params, String value )
899
 
                {
900
 
                        value = unescapeValue( value );
901
 
 
902
 
                        // if we previously had an organisation, look it up and append this
903
 
                        // title to it
904
 
                        if( _cached_organisation != null && hasOrganisations() ) {
905
 
                                HashMap< String, ExtraDetail > datas = getOrganisations();
906
 
                                ExtraDetail detail = datas.get( _cached_organisation );
907
 
                                if( detail != null )
908
 
                                        detail.setExtra( value );
909
 
                        }
910
 
 
911
 
                        // same as when handling organisation, if we've not previously found
912
 
                        // an organisation we store this title, else we clear it (since we
913
 
                        // just appended this title to it)
914
 
                        if( _cached_organisation == null )
915
 
                                _cached_title = value;
916
 
                        else
917
 
                                _cached_organisation = null;
 
730
                        String[] org_parts = splitValueBySemicolon( value );
 
731
 
 
732
                        // build name
 
733
                        if( org_parts.length > 1 && org_parts[ 0 ].length() == 0 )
 
734
                                value = org_parts[ 1 ];
 
735
                        else if( org_parts.length > 1 && org_parts[ 1 ].length() > 0 )
 
736
                                value = org_parts[ 0 ] + ", " + org_parts[ 1 ];
 
737
                        else
 
738
                                value = org_parts[ 0 ];
 
739
 
 
740
                        // set name
 
741
                        setName( value );
 
742
                        _name_level = NAMELEVEL_ORG;
918
743
                }
919
744
 
920
745
                private void parseTEL( String[] params, String value )
 
746
                        throws ParseException
921
747
                {
922
748
                        if( value.length() == 0 ) return;
923
749
 
926
752
                                "PAGER", "BBS", "MODEM", "CAR", "ISDN", "VIDEO" ) );
927
753
 
928
754
                        // here's the logic...
929
 
                        boolean is_preferred = types.contains( "PREF" );
930
 
                        int type;
 
755
                        boolean preferred = types.contains( "PREF" );
 
756
                        int type = PhonesColumns.TYPE_MOBILE;
 
757
                        if( types.contains( "VOICE" ) )
 
758
                                if( types.contains( "WORK" ) )
 
759
                                        type = PhonesColumns.TYPE_WORK;
 
760
                                else
 
761
                                        type = PhonesColumns.TYPE_HOME;
 
762
                        else if( types.contains( "CELL" ) || types.contains( "VIDEO" ) )
 
763
                                type = PhonesColumns.TYPE_MOBILE;
931
764
                        if( types.contains( "FAX" ) )
932
765
                                if( types.contains( "HOME" ) )
933
 
                                        type = TYPE_FAX_HOME;
 
766
                                        type = PhonesColumns.TYPE_FAX_HOME;
934
767
                                else
935
 
                                        type = TYPE_FAX_WORK;
936
 
                        else if( types.contains( "CELL" ) || types.contains( "VIDEO" ) )
937
 
                                type = TYPE_MOBILE;
938
 
                        else if( types.contains( "PAGER" ) )
939
 
                                type = TYPE_PAGER;
940
 
                        else if( types.contains( "WORK" ) )
941
 
                                type = TYPE_WORK;
942
 
                        else
943
 
                                type = TYPE_HOME;
 
768
                                        type = PhonesColumns.TYPE_FAX_WORK;
 
769
                        if( types.contains( "PAGER" ) )
 
770
                                type = PhonesColumns.TYPE_PAGER;
944
771
 
945
772
                        // add phone number
946
 
                        addNumber( value, type, is_preferred );
 
773
                        addPhone( value, type, preferred );
947
774
                }
948
775
 
949
776
                public void parseEMAIL( String[] params, String value )
 
777
                        throws ParseException
950
778
                {
951
779
                        if( value.length() == 0 ) return;
952
780
 
954
782
                                "PREF", "WORK", "HOME", "INTERNET" ) );
955
783
 
956
784
                        // add email address
957
 
                        boolean is_preferred = types.contains( "PREF" );
958
 
                        int type;
 
785
                        boolean preferred = types.contains( "PREF" );
959
786
                        if( types.contains( "WORK" ) )
960
 
                                type = TYPE_WORK;
 
787
                                addEmail( value, Contacts.ContactMethods.TYPE_WORK, preferred );
961
788
                        else
962
 
                                type = TYPE_HOME;
963
 
 
964
 
                        addEmail( unescapeValue( value ), type, is_preferred );
 
789
                                addEmail( value, Contacts.ContactMethods.TYPE_HOME, preferred );
965
790
                }
966
791
 
967
792
                private void parseADR( String[] params, String value )
 
793
                        throws ParseException, SkipContactException
968
794
                {
969
795
                        // get address parts
970
 
                        String[] adr_parts = splitValueByCharacter( value, ';' );
 
796
                        String[] adr_parts = splitValueBySemicolon( value );
971
797
 
972
798
                        // build address
973
799
                        value = "";
974
 
                        for( int a = 0; a < adr_parts.length; a++ )
975
 
                                if( adr_parts[ a ].length() > 0 )
976
 
                                {
977
 
                                        // version 3.0 vCards allow further splitting by comma
978
 
                                        if( _version.equals( "3.0" ) )
979
 
                                        {
980
 
                                                // split this part in to it's comma-separated bits and
981
 
                                                // add them on individual lines
982
 
                                                String[] adr_part_parts =
983
 
                                                        splitValueByCharacter( adr_parts[ a ], ',' );
984
 
                                                for( int b = 0; b < adr_part_parts.length; b++ )
985
 
                                                        if( adr_part_parts[ b ].length() > 0 )
986
 
                                                        {
987
 
                                                                if( value.length() > 0 ) value += "\n";
988
 
                                                                value += adr_part_parts[ b ];
989
 
                                                        }
990
 
                                        }
991
 
                                        else
992
 
                                        {
993
 
                                                // add this part on an individual line
994
 
                                                if( value.length() > 0 ) value += "\n";
995
 
                                                value += adr_parts[ a ];
996
 
                                        }
997
 
                                }
998
 
 
999
 
                        Set< String > types = extractTypes( params, Arrays.asList(
1000
 
                                "PREF", "WORK", "HOME" ) );
1001
 
 
1002
 
                        // add address
1003
 
                        int type;
1004
 
                        if( types.contains( "WORK" ) )
1005
 
                                type = TYPE_WORK;
1006
 
                        else
1007
 
                                type = TYPE_HOME;
1008
 
 
1009
 
                        addAddress( unescapeValue( value ), type );
1010
 
                }
1011
 
 
1012
 
                private void parseLABEL( String[] params, String value )
1013
 
                {
1014
 
                        Set< String > types = extractTypes( params, Arrays.asList(
1015
 
                                "PREF", "WORK", "HOME" ) );
1016
 
 
1017
 
                        // add address
1018
 
                        int type;
1019
 
                        if( types.contains( "WORK" ) )
1020
 
                                type = TYPE_WORK;
1021
 
                        else
1022
 
                                type = TYPE_HOME;
1023
 
 
1024
 
                        addAddress( unescapeValue( value ), type );
1025
 
                }
1026
 
 
1027
 
                private void parseNOTE( String[] params, String value )
1028
 
                {
1029
 
                        addNote( unescapeValue( value ) );
1030
 
                }
1031
 
 
1032
 
                private void parseBDAY( String[] params, String value )
1033
 
                {
1034
 
                        setBirthday( value );
1035
 
                }
1036
 
 
1037
 
                public void finaliseVcard()
1038
 
                        throws ParseException, ContactNotIdentifiableException
 
800
                        for( int a = 0; a < adr_parts.length; a++ ) {
 
801
                                if( value.length() > 0 ) value += "\n";
 
802
                                value += adr_parts[ a ].trim();
 
803
                        }
 
804
 
 
805
                        Set< String > types = extractTypes( params, Arrays.asList(
 
806
                                "PREF", "WORK", "HOME", "INTERNET" ) );
 
807
 
 
808
                        // add address
 
809
                        if( types.contains( "WORK" ) )
 
810
                                addAddress( value, Contacts.ContactMethods.TYPE_WORK );
 
811
                        else
 
812
                                addAddress( value, Contacts.ContactMethods.TYPE_HOME);
 
813
                }
 
814
 
 
815
                public void finaliseParsing()
 
816
                        throws ParseException, SkipContactException,
 
817
                        AbortImportException
1039
818
                {
1040
819
                        // missing version (and data is present)
1041
 
                        if( _version == null && _content_lines != null )
 
820
                        if( _version == null && _buffers != null )
1042
821
                                throw new ParseException( R.string.error_vcf_malformed );
1043
822
 
1044
 
                        // finalise the parent class
1045
 
                        finalise();
 
823
                        //  missing name properties?
 
824
                        if( _name_level == NAMELEVEL_NONE )
 
825
                                throw new ParseException( R.string.error_vcf_noname );
 
826
 
 
827
                        // check if we should import this one? If we've already got an 'N'-
 
828
                        // type name, this will already have been done by parseN() so we
 
829
                        // mustn't do this here (or it could prompt twice!)
 
830
                        if( _name_level < NAMELEVEL_N && !isImportRequired( getName() ) )
 
831
                                throw new SkipContactException();
1046
832
                }
1047
833
 
1048
 
                /**
1049
 
                 * Amongst the params, find the value of the first, only, of any with
1050
 
                 * the specified name.
1051
 
                 *
1052
 
                 * @param params
1053
 
                 * @param name
1054
 
                 * @return a value, or null
1055
 
                 */
1056
834
                private String checkParam( String[] params, String name )
1057
835
                {
1058
 
                        String[] res = checkParams( params, name );
1059
 
                        return res.length > 0? res[ 0 ] : null;
1060
 
                }
1061
 
 
1062
 
                /**
1063
 
                 * Amongst the params, find the values of any with the specified name.
1064
 
                 *
1065
 
                 * @param params
1066
 
                 * @param name
1067
 
                 * @return an array of values, or null
1068
 
                 */
1069
 
                private String[] checkParams( String[] params, String name )
1070
 
                {
1071
 
                        HashSet< String > ret = new HashSet< String >();
1072
 
 
1073
836
                        Pattern p = Pattern.compile(
1074
 
                                "^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$",
1075
 
                                Pattern.CASE_INSENSITIVE );
 
837
                                "^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$" );
1076
838
                        for( int i = 0; i < params.length; i++ ) {
1077
839
                                Matcher m = p.matcher( params[ i ] );
1078
840
                                if( m.matches() )
1079
 
                                        ret.add( m.group( 2 ) );
 
841
                                        return m.group( 2 );
1080
842
                        }
1081
 
 
1082
 
                        return (String[]) ret.toArray( new String[ ret.size() ] );
 
843
                        return null;
1083
844
                }
1084
845
 
1085
 
                /**
1086
 
                 * Amongst the params, return any type values present.  For v2.1 vCards,
1087
 
                 * those types are just parameters.  For v3.0, they are prefixed with
1088
 
                 * "TYPE=".  There may also be multiple type parameters.
1089
 
                 *
1090
 
                 * @param params an array of params to look for types in
1091
 
                 * @param valid_types an list of upper-case type values to look for
1092
 
                 * @return a set of present type values
1093
 
                 */
1094
846
                private Set< String > extractTypes( String[] params,
1095
847
                        List< String > valid_types )
1096
848
                {
1097
849
                        HashSet< String > types = new HashSet< String >();
1098
850
 
1099
851
                        // get 3.0-style TYPE= param
1100
 
                        String type_params[] = checkParams( params, "TYPE" );
1101
 
                        for( int a = 0; a < type_params.length; a++ )
1102
 
                        {
1103
 
                                // check for a comma-separated list of types (why? I don't think
1104
 
                                // this is in the specs!)
1105
 
                                String[] parts = type_params[ a ].split( "," );
1106
 
                                for( int i = 0; i < parts.length; i++ ) {
1107
 
                                        String ucpart = parts[ i ].toUpperCase( Locale.ENGLISH );
1108
 
                                        if( valid_types.contains( ucpart ) )
1109
 
                                                types.add( ucpart );
1110
 
                                }
 
852
                        String type_param;
 
853
                        if( ( type_param = checkParam( params, "TYPE" ) ) != null ) {
 
854
                                String[] parts = type_param.split( "," );
 
855
                                for( int i = 0; i < parts.length; i++ )
 
856
                                        if( valid_types.contains( parts[ i ] ) )
 
857
                                                types.add( parts[ i ] );
1111
858
                        }
1112
859
 
1113
860
                        // get 2.1-style type param
1114
861
                        if( _version.equals( "2.1" ) ) {
1115
 
                                for( int i = 1; i < params.length; i++ ) {
1116
 
                                        String ucparam = params[ i ].toUpperCase( Locale.ENGLISH );
1117
 
                                        if( valid_types.contains( ucparam ) )
1118
 
                                                types.add( ucparam );
1119
 
                                }
 
862
                                for( int i = 1; i < params.length; i++ )
 
863
                                        if( valid_types.contains( params[ i ] ) )
 
864
                                                types.add( params[ i ] );
1120
865
                        }
1121
866
 
1122
867
                        return types;
1144
889
                                else if( ch == '=' && i == in.limit() - 1 )
1145
890
                                {
1146
891
                                        // we found a '=' at the end of a line signifying a multi-
1147
 
                                        // line string, so we don't add it
 
892
                                        // line string, so we don't add it.
1148
893
                                        another = true;
1149
894
                                        continue;
1150
895
                                }