/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/am/ed/importcontacts/VcardImporter.java

  • Committer: edam
  • Date: 2012-12-21 14:51:26 UTC
  • Revision ID: tim@ed.am-20121221145126-l30l0yii8xkqs1m2
added a new class to VcardImporter, a ContentLine, which represents the data returned by the ContentLineIterator (including whether the next line looks folded, and the ability to generate/cache a US-ASCII String of the line)

Show diffs side-by-side

added added

removed removed

Lines of Context:
175
175
                        // import
176
176
                        importVCardFileContent( content, file.getName() );
177
177
                }
 
178
                catch( OutOfMemoryError e ) {
 
179
                        showError( R.string.error_outofmemory );
 
180
                }
178
181
                catch( FileNotFoundException e ) {
179
182
                        showError( getText( R.string.error_filenotfound ) +
180
183
                                file.getName() );
193
196
                ContentLineIterator cli = new ContentLineIterator( content );
194
197
                while( cli.hasNext() )
195
198
                {
196
 
                        ByteBuffer buffer = cli.next();
 
199
                        ContentLine content_line = cli.next();
197
200
 
198
 
                        // get a US-ASCII version of the line for processing
199
 
                        String line;
200
 
                        try {
201
 
                                line = new String( buffer.array(), buffer.position(),
202
 
                                        buffer.limit() - buffer.position(), "US-ASCII" );
203
 
                        }
204
 
                        catch( UnsupportedEncodingException e ) {
205
 
                                // we know US-ASCII *is* supported, so appease the compiler...
206
 
                                line = "";
207
 
                        }
 
201
                        // get a US-ASCII version of the string, for processing
 
202
                        String line = content_line.getUsAsciiLine();
208
203
 
209
204
                        if( vcard == null ) {
210
205
                                // look for vcard beginning
259
254
                                {
260
255
                                        // try giving the line to the vcard
261
256
                                        try {
262
 
                                                vcard.parseLine( buffer, line,
263
 
                                                        cli.doesNextLineLookFolded() );
 
257
                                                vcard.parseLine( content_line );
264
258
                                        }
265
259
                                        catch( Vcard.ParseException e ) {
266
260
                                                skipContact();
289
283
                }
290
284
        }
291
285
 
292
 
        class ContentLineIterator implements Iterator< ByteBuffer >
 
286
        class ContentLine
 
287
        {
 
288
                private ByteBuffer _buffer;
 
289
                private boolean _folded_next;
 
290
                private String _line;
 
291
 
 
292
                public ContentLine( ByteBuffer buffer, boolean folded_next )
 
293
                {
 
294
                        _buffer = buffer;
 
295
                        _folded_next = folded_next;
 
296
                        _line = null;
 
297
                }
 
298
 
 
299
                public ByteBuffer getBuffer()
 
300
                {
 
301
                        return _buffer;
 
302
                }
 
303
 
 
304
                public boolean doesNextLineLookFolded()
 
305
                {
 
306
                        return _folded_next;
 
307
                }
 
308
 
 
309
                public String getUsAsciiLine()
 
310
                {
 
311
                        // generated line and cache it
 
312
                        if( _line == null ) {
 
313
                                try {
 
314
                                        _line = new String( _buffer.array(), _buffer.position(),
 
315
                                                _buffer.limit() - _buffer.position(), "US-ASCII" );
 
316
                                }
 
317
                                catch( UnsupportedEncodingException e ) {
 
318
                                        // we know US-ASCII *is* supported, so appease the
 
319
                                        // compiler...
 
320
                                }
 
321
                        }
 
322
 
 
323
                        // return cached line
 
324
                        return _line;
 
325
                }
 
326
        }
 
327
 
 
328
        class ContentLineIterator implements Iterator< ContentLine >
293
329
        {
294
330
                protected byte[] _content = null;
295
331
                protected int _pos = 0;
307
343
                }
308
344
 
309
345
                @Override
310
 
                public ByteBuffer next()
 
346
                public ContentLine next()
311
347
                {
312
348
                        int initial_pos = _pos;
313
349
 
320
356
                                                _pos > initial_pos )? _pos - 1 : _pos;
321
357
                                        _pos++;
322
358
                                        _line++;
323
 
                                        return ByteBuffer.wrap( _content, initial_pos,
324
 
                                                to - initial_pos );
 
359
                                        return new ContentLine(
 
360
                                                ByteBuffer.wrap( _content, initial_pos,
 
361
                                                        to - initial_pos ),
 
362
                                                doesNextLineLookFolded() );
325
363
                                }
326
364
 
327
365
                        // we didn't find one, but were there bytes left?
329
367
                                int to = _pos;
330
368
                                _pos++;
331
369
                                _line++;
332
 
                                return ByteBuffer.wrap( _content, initial_pos,
333
 
                                        to - initial_pos );
 
370
                                return new ContentLine(
 
371
                                        ByteBuffer.wrap( _content, initial_pos,
 
372
                                                to - initial_pos ),
 
373
                                        doesNextLineLookFolded() );
334
374
                        }
335
375
 
336
376
                        // no bytes left
348
388
                 * onto the end of this one?
349
389
                 * @return
350
390
                 */
351
 
                public boolean doesNextLineLookFolded()
 
391
                private boolean doesNextLineLookFolded()
352
392
                {
353
393
                        return _pos > 0 && _pos < _content.length &&
354
394
                                _content[ _pos - 1 ] == '\n' &&
373
413
                private final static int MULTILINE_FOLDED = 3;  // MIME-DIR folding
374
414
 
375
415
                private String _version = null;
376
 
                private Vector< ByteBuffer > _buffers = null;
 
416
                private Vector< ContentLine > _content_lines = null;
377
417
                private int _name_level = NAMELEVEL_NONE;
378
418
                private int _parser_multiline_state = MULTILINE_NONE;
379
419
                private String _parser_current_name_and_params = null;
422
462
                @SuppressWarnings("serial")
423
463
                protected class SkipImportException extends Exception { }
424
464
 
425
 
                private String extractCollonPartFromLine( ByteBuffer buffer,
426
 
                        String line, boolean former )
 
465
                private String extractCollonPartFromLine( ContentLine content_line,
 
466
                        boolean former )
427
467
                {
428
468
                        String ret = null;
429
469
 
430
 
                        // get a US-ASCII version of the line for processing, unless we were
431
 
                        // supplied with one
432
 
                        if( line == null ) {
433
 
                                try {
434
 
                                        line = new String( buffer.array(), buffer.position(),
435
 
                                                buffer.limit() - buffer.position(), "US-ASCII" );
436
 
                                }
437
 
                                catch( UnsupportedEncodingException e ) {
438
 
                                        // we know US-ASCII is supported, so appease the compiler...
439
 
                                        line = "";
440
 
                                }
441
 
                        }
442
 
 
443
470
                        // split line into name and value parts and check to make sure we
444
471
                        // only got 2 parts and that the first part is not zero in length
445
 
                        String[] parts = line.split( ":", 2 );
 
472
                        String[] parts = content_line.getUsAsciiLine().split( ":", 2 );
446
473
                        if( parts.length == 2 && parts[ 0 ].length() > 0 )
447
474
                                ret = parts[ former? 0 : 1 ];
448
475
 
449
476
                        return ret;
450
477
                }
451
478
 
452
 
                private String extractNameAndParamsFromLine( ByteBuffer buffer,
453
 
                        String line )
454
 
                {
455
 
                        return extractCollonPartFromLine( buffer, line, true );
456
 
                }
457
 
 
458
 
                private String extractValueFromLine( ByteBuffer buffer, String line )
459
 
                {
460
 
                        return extractCollonPartFromLine( buffer, line, false );
461
 
                }
462
 
 
463
 
                public void parseLine( ByteBuffer buffer, String line,
464
 
                        boolean next_line_looks_folded )
 
479
                private String extractNameAndParamsFromLine( ContentLine content_line )
 
480
                {
 
481
                        return extractCollonPartFromLine( content_line, true );
 
482
                }
 
483
 
 
484
                private String extractValueFromLine( ContentLine content_line )
 
485
                {
 
486
                        return extractCollonPartFromLine( content_line, false );
 
487
                }
 
488
 
 
489
                public void parseLine( ContentLine content_line )
465
490
                        throws ParseException, SkipImportException,
466
491
                        AbortImportException
467
492
                {
470
495
                        {
471
496
                                // tentatively get name and params from line
472
497
                                String name_and_params =
473
 
                                        extractNameAndParamsFromLine( buffer, line );
 
498
                                        extractNameAndParamsFromLine( content_line );
474
499
 
475
500
                                // is it a version line?
476
501
                                if( name_and_params != null &&
477
502
                                        name_and_params.equalsIgnoreCase( "VERSION" ) )
478
503
                                {
479
504
                                        // yes, get it!
480
 
                                        String value = extractValueFromLine( buffer, line );
 
505
                                        String value = extractValueFromLine( content_line );
481
506
                                        if( !value.equals( "2.1" ) && !value.equals( "3.0" ) )
482
507
                                                throw new ParseException( R.string.error_vcf_version );
483
508
                                        _version = value;
484
509
 
485
510
                                        // parse any buffers we've been accumulating while we waited
486
511
                                        // for a version
487
 
                                        if( _buffers != null )
488
 
                                                for( int i = 0; i < _buffers.size(); i++ )
489
 
                                                        parseLine( _buffers.get( i ), null,
490
 
                                                                i + 1 < _buffers.size() &&
491
 
                                                                _buffers.get( i + 1 ).hasRemaining() &&
492
 
                                                                _buffers.get( i + 1 ).get(
493
 
                                                                        _buffers.get( i + 1 ).position() ) == ' ' );
494
 
                                        _buffers = null;
 
512
                                        if( _content_lines != null )
 
513
                                                for( int i = 0; i < _content_lines.size(); i++ )
 
514
                                                        parseLine( _content_lines.get( i ) );
 
515
                                        _content_lines = null;
495
516
                                }
496
517
                                else
497
518
                                {
498
519
                                        // no, so stash this line till we get a version
499
 
                                        if( _buffers == null )
500
 
                                                _buffers = new Vector< ByteBuffer >();
501
 
                                        _buffers.add( buffer );
 
520
                                        if( _content_lines == null )
 
521
                                                _content_lines = new Vector< ContentLine >();
 
522
                                        _content_lines.add( content_line );
502
523
                                }
503
524
                        }
504
525
                        else
516
537
 
517
538
                                        // skip some initial line characters, depending on the type
518
539
                                        // of multi-line we're handling
519
 
                                        pos = buffer.position();
 
540
                                        pos = content_line.getBuffer().position();
520
541
                                        switch( _parser_multiline_state )
521
542
                                        {
522
543
                                        case MULTILINE_FOLDED:
523
544
                                                pos++;
524
545
                                                break;
525
546
                                        case MULTILINE_ENCODED:
526
 
                                                while( pos < buffer.limit() && (
527
 
                                                        buffer.get( pos ) == ' ' ||
528
 
                                                        buffer.get( pos ) == '\t' ) )
 
547
                                                while( pos < content_line.getBuffer().limit() && (
 
548
                                                        content_line.getBuffer().get( pos ) == ' ' ||
 
549
                                                        content_line.getBuffer().get( pos ) == '\t' ) )
529
550
                                                {
530
551
                                                        pos++;
531
552
                                                }
541
562
                                else
542
563
                                {
543
564
                                        // skip empty lines
544
 
                                        if( line.trim().length() == 0 ) return;
 
565
                                        if( content_line.getUsAsciiLine().trim().length() == 0 )
 
566
                                                return;
545
567
 
546
568
                                        // get name and params from line, and since we're not
547
569
                                        // parsing a subsequent line in a multi-line, this should
548
570
                                        // not fail, or it's an error
549
571
                                        name_and_params =
550
 
                                                extractNameAndParamsFromLine( buffer, line );
 
572
                                                extractNameAndParamsFromLine( content_line );
551
573
                                        if( name_and_params == null )
552
574
                                                throw new ParseException(
553
575
                                                        R.string.error_vcf_malformed );
554
576
 
555
577
                                        // calculate how many chars to skip from beginning of line
556
578
                                        // so we skip the property "name:" part
557
 
                                        pos = buffer.position() + name_and_params.length() + 1;
 
579
                                        pos = content_line.getBuffer().position() +
 
580
                                                name_and_params.length() + 1;
558
581
 
559
582
                                        // reset the saved multi-line state
560
583
                                        _parser_current_name_and_params = name_and_params;
563
586
 
564
587
                                // get value from buffer, as raw bytes
565
588
                                ByteBuffer value;
566
 
                                value = ByteBuffer.wrap( buffer.array(), pos,
567
 
                                        buffer.limit() - pos );
 
589
                                value = ByteBuffer.wrap( content_line.getBuffer().array(), pos,
 
590
                                        content_line.getBuffer().limit() - pos );
568
591
 
569
592
                                // get parameter parts
570
593
                                String[] name_param_parts = name_and_params.split( ";", -1 );
658
681
                                // if we know we're not in an encoding-based multi-line, check
659
682
                                // to see if we're in a folded multi-line
660
683
                                if( _parser_multiline_state == MULTILINE_NONE &&
661
 
                                        next_line_looks_folded )
 
684
                                        content_line.doesNextLineLookFolded() )
662
685
                                {
663
686
                                        _parser_multiline_state = MULTILINE_FOLDED;
664
687
                                }
1004
1027
                        throws ParseException, ContactNotIdentifiableException
1005
1028
                {
1006
1029
                        // missing version (and data is present)
1007
 
                        if( _version == null && _buffers != null )
 
1030
                        if( _version == null && _content_lines != null )
1008
1031
                                throw new ParseException( R.string.error_vcf_malformed );
1009
1032
 
1010
1033
                        // finalise the parent class