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