(root)/android/import-contacts
» Revision
7
(compared to revision 68)
: 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: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: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' && _content[ _pos ] == ' ';
355
}
356
357
public int getLineNumber()
358
{
359
return _line;
360
}
361
}
362
363
private class Vcard extends ContactData
238
private class VCard extends ContactData
364
239
{
365
240
private final static int NAMELEVEL_NONE = 0;
366
private final static int NAMELEVEL_N = 1;
241
private final static int NAMELEVEL_ORG = 1;
367
242
private final static int NAMELEVEL_FN = 2;
368
369
private final static int MULTILINE_NONE = 0;
370
private final static int MULTILINE_ENCODED = 1; // v2.1 quoted-printable
371
private final static int MULTILINE_ESCAPED = 2; // v2.1 \\CRLF
372
private final static int MULTILINE_FOLDED = 3; // v3.0 folding
243
private final static int NAMELEVEL_N = 3;
373
244
374
245
private String _version = null;
375
private Vector< ByteBuffer > _buffers = null;
376
private int _name_level = NAMELEVEL_NONE;
377
private int _parser_multiline_state = MULTILINE_NONE;
378
private String _parser_current_name_and_params = null;
379
private String _parser_buffered_value_so_far = "";
380
private String _cached_organisation = null;
381
private String _cached_title = null;
382
383
protected class UnencodeResult
384
{
385
private boolean _another_line_required;
386
private ByteBuffer _buffer;
387
388
public UnencodeResult( boolean another_line_required,
389
ByteBuffer buffer )
390
{
391
_another_line_required = another_line_required;
392
_buffer = buffer;
393
}
394
395
public boolean isAnotherLineRequired()
396
{
397
return _another_line_required;
398
}
399
400
public ByteBuffer getBuffer()
401
{
402
return _buffer;
403
}
404
}
405
406
@SuppressWarnings("serial")
246
private Vector< String > _lines = null;
247
private int _nameLevel = NAMELEVEL_NONE;
248
407
249
protected class ParseException extends Exception
408
250
{
409
@SuppressWarnings("unused")
410
251
public ParseException( String error )
411
252
{
412
253
super( error );
414
255
415
256
public ParseException( int res )
416
257
{
417
super( VcardImporter.this.getText( res ).toString() );
418
}
419
}
420
421
@SuppressWarnings("serial")
422
protected class SkipImportException extends Exception { }
423
424
private String extractCollonPartFromLine( ByteBuffer buffer,
425
String line, boolean former )
426
{
427
String ret = null;
428
429
// get a US-ASCII version of the line for processing, unless we were
430
// supplied with one
431
if( line == null ) {
432
try {
433
line = new String( buffer.array(), buffer.position(),
434
buffer.limit() - buffer.position(), "US-ASCII" );
435
}
436
catch( UnsupportedEncodingException e ) {
437
// we know US-ASCII is supported, so appease the compiler...
438
line = "";
439
}
440
}
441
442
// split line into name and value parts and check to make sure we
443
// only got 2 parts and that the first part is not zero in length
444
String[] parts = line.split( ":", 2 );
445
if( parts.length == 2 && parts[ 0 ].length() > 0 )
446
ret = parts[ former? 0 : 1 ];
447
448
return ret;
449
}
450
451
private String extractNameAndParamsFromLine( ByteBuffer buffer,
452
String line )
453
{
454
return extractCollonPartFromLine( buffer, line, true );
455
}
456
457
private String extractValueFromLine( ByteBuffer buffer, String line )
458
{
459
return extractCollonPartFromLine( buffer, line, false );
460
}
461
462
public void parseLine( ByteBuffer buffer, String line,
463
boolean next_line_looks_folded )
464
throws ParseException, SkipImportException,
465
AbortImportException
466
{
467
// 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
468
276
if( _version == null )
469
277
{
470
// tentatively get name and params from line
471
String name_and_params =
472
extractNameAndParamsFromLine( buffer, line );
473
474
// is it a version line?
475
if( name_and_params != null &&
476
name_and_params.equals( "VERSION" ) )
278
if( props[ 0 ].equals( "VERSION" ) )
477
279
{
478
// yes, get it!
479
String value = extractValueFromLine( buffer, line );
480
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" ) )
481
283
throw new ParseException( R.string.error_vcf_version );
482
_version = value;
284
_version = props[ 1 ];
483
285
484
// parse any buffers we've been accumulating while we waited
485
// for a version
486
if( _buffers != null )
487
for( int i = 0; i < _buffers.size(); i++ )
488
parseLine( _buffers.get( i ), null,
489
i + 1 < _buffers.size() &&
490
_buffers.get( i + 1 ).hasRemaining() &&
491
_buffers.get( i + 1 ).get(
492
_buffers.get( i + 1 ).position() ) == ' ' );
493
_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;
494
291
}
495
292
else
496
293
{
497
// no, so stash this line till we get a version
498
if( _buffers == null )
499
_buffers = new Vector< ByteBuffer >();
500
_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 );
501
298
}
502
299
}
503
300
else
504
301
{
505
// name and params and the position in the buffer where the
506
// "value" part of the line start
507
String name_and_params;
508
int pos;
509
510
if( _parser_multiline_state != MULTILINE_NONE )
511
{
512
// if we're currently in a multi-line value, use the stored
513
// property name and parameters
514
name_and_params = _parser_current_name_and_params;
515
516
// skip some initial line characters, depending on the type
517
// of multi-line we're handling
518
pos = buffer.position();
519
switch( _parser_multiline_state )
520
{
521
case MULTILINE_FOLDED:
522
pos++;
523
break;
524
case MULTILINE_ENCODED:
525
while( pos < buffer.limit() && (
526
buffer.get( pos ) == ' ' ||
527
buffer.get( pos ) == '\t' ) )
528
{
529
pos++;
530
}
531
break;
532
default:
533
// do nothing
534
}
535
536
// take us out of multi-line so that we can re-detect that
537
// this line is a multi-line or not
538
_parser_multiline_state = MULTILINE_NONE;
539
}
540
else
541
{
542
// get name and params from line, and since we're not
543
// parsing a subsequent line in a multi-line, this should
544
// not fail, or it's an error
545
name_and_params =
546
extractNameAndParamsFromLine( buffer, line );
547
if( name_and_params == null )
548
throw new ParseException(
549
R.string.error_vcf_malformed );
550
551
// calculate how many chars to skip from beginning of line
552
// so we skip the property "name:" part
553
pos = buffer.position() + name_and_params.length() + 1;
554
555
// reset the saved multi-line state
556
_parser_current_name_and_params = name_and_params;
557
_parser_buffered_value_so_far = "";
558
}
559
560
// get value from buffer, as raw bytes
561
ByteBuffer value;
562
value = ByteBuffer.wrap( buffer.array(), pos,
563
buffer.limit() - pos );
564
565
302
// get parameter parts
566
String[] name_param_parts = name_and_params.split( ";", -1 );
567
for( int i = 0; i < name_param_parts.length; i++ )
568
name_param_parts[ i ] = name_param_parts[ i ].trim();
569
570
// determine whether we care about this entry
571
final HashSet< String > interesting_fields =
572
new HashSet< String >( Arrays.asList( new String[] { "N",
573
"FN", "ORG", "TITLE", "TEL", "EMAIL", "ADR", "LABEL" }
574
) );
575
boolean is_interesting_field =
576
interesting_fields.contains( name_param_parts[ 0 ] );
577
578
// parse encoding parameter
579
String encoding = checkParam( name_param_parts, "ENCODING" );
580
if( encoding != null )
581
encoding = encoding.toUpperCase( Locale.US );
582
if( is_interesting_field && encoding != null &&
583
!encoding.equals( "8BIT" ) &&
584
!encoding.equals( "QUOTED-PRINTABLE" ) )
585
//&& !encoding.equals( "BASE64" ) )
586
{
587
throw new ParseException( R.string.error_vcf_encoding );
588
}
589
590
// parse charset parameter
591
String charset = checkParam( name_param_parts, "CHARSET" );
592
if( charset != null )
593
charset = charset.toUpperCase( Locale.US );
594
if( charset != null &&
595
!charset.equals( "US-ASCII" ) &&
596
!charset.equals( "ASCII" ) &&
597
!charset.equals( "UTF-8" ) )
598
{
599
throw new ParseException( R.string.error_vcf_charset );
600
}
601
602
// do unencoding (or default to a fake unencoding result with
603
// the raw string)
604
UnencodeResult unencoding_result = null;
605
if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )
606
unencoding_result = unencodeQuotedPrintable( value );
607
// else if( encoding != null && encoding.equals( "BASE64" ) )
608
// unencoding_result = unencodeBase64( props[ 1 ], charset );
609
if( unencoding_result != null ) {
610
value = unencoding_result.getBuffer();
611
if( unencoding_result.isAnotherLineRequired() )
612
_parser_multiline_state = MULTILINE_ENCODED;
613
}
614
615
// convert 8-bit US-ASCII charset to UTF-8 (where no charset is
616
// specified for a v2.1 vcard entry, we assume it's US-ASCII)
617
if( ( charset == null && _version.equals( "2.1" ) ) ||
618
( charset != null && (
619
charset.equals( "ASCII" ) ||
620
charset.equals( "US-ASCII" ) ) ) )
621
{
622
value = transcodeAsciiToUtf8( value );
623
}
624
625
// process charset (value is now in UTF-8)
626
String string_value;
627
try {
628
string_value = new String( value.array(), value.position(),
629
value.limit() - value.position(), "UTF-8" );
630
} catch( UnsupportedEncodingException e ) {
631
throw new ParseException( R.string.error_vcf_charset );
632
}
633
634
// for some entries that have semicolon-separated value parts,
635
// check to see if the value ends in an escape character, which
636
// indicates that we have a multi-line value
637
if( ( name_param_parts[ 0 ].equals( "N" ) ||
638
name_param_parts[ 0 ].equals( "ORG" ) ||
639
name_param_parts[ 0 ].equals( "ADR" ) ) &&
640
doesStringEndInAnEscapeChar( string_value ) )
641
{
642
_parser_multiline_state = MULTILINE_ESCAPED;
643
string_value = string_value.substring( 0,
644
string_value.length() - 1 );
645
}
646
647
// now we know whether we're in an encoding multi-line,
648
// determine if we're in a v3 folded multi-line or not
649
if( _parser_multiline_state == MULTILINE_NONE &&
650
_version.equals( "3.0" ) && next_line_looks_folded )
651
{
652
_parser_multiline_state = MULTILINE_FOLDED;
653
}
654
655
// handle multi-lines by buffering them and parsing them when we
656
// are processing the last line in a multi-line sequence
657
if( _parser_multiline_state != MULTILINE_NONE ) {
658
_parser_buffered_value_so_far += string_value;
659
return;
660
}
661
String complete_value =
662
( _parser_buffered_value_so_far + string_value ).trim();
663
664
// ignore empty values
665
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();
666
306
667
307
// parse some properties
668
if( name_param_parts[ 0 ].equals( "N" ) )
669
parseN( name_param_parts, complete_value );
670
else if( name_param_parts[ 0 ].equals( "FN" ) )
671
parseFN( name_param_parts, complete_value );
672
else if( name_param_parts[ 0 ].equals( "ORG" ) )
673
parseORG( name_param_parts, complete_value );
674
else if( name_param_parts[ 0 ].equals( "TITLE" ) )
675
parseTITLE( name_param_parts, complete_value );
676
else if( name_param_parts[ 0 ].equals( "TEL" ) )
677
parseTEL( name_param_parts, complete_value );
678
else if( name_param_parts[ 0 ].equals( "EMAIL" ) )
679
parseEMAIL( name_param_parts, complete_value );
680
else if( name_param_parts[ 0 ].equals( "ADR" ) )
681
parseADR( name_param_parts, complete_value );
682
else if( name_param_parts[ 0 ].equals( "LABEL" ) )
683
parseLABEL( name_param_parts, complete_value );
684
else if( name_param_parts[ 0 ].equals( "NOTE" ) )
685
parseNOTE( name_param_parts, complete_value );
686
}
687
}
688
689
private boolean doesStringEndInAnEscapeChar( String string )
690
{
691
// count the number of backslashes at the end of the string
692
int count = 0;
693
for( int a = string.length() - 1; a >= 0; a-- )
694
if( string.charAt( a ) == '\\' )
695
count++;
696
else
697
break;
698
699
// if there are an even number of backslashes then the final one
700
// doesn't count
701
return ( count & 1 ) == 1;
702
}
703
704
private String[] splitValueByCharacter( String value, char character )
705
{
706
// split string in to parts by specified character
707
ArrayList< String > parts = new ArrayList< String >(
708
Arrays.asList( value.split( "" + character ) ) );
709
710
// go through parts
711
for( int a = 0; a < parts.size(); a++ )
712
{
713
String str = parts.get( a );
714
715
// look for parts that end in an escape character, but ignore
716
// the final part. We've already detected escape chars at the
717
// end of the final part in parseLine() and handled multi-lines
718
// accordingly.
719
if( a < parts.size() - 1 &&
720
doesStringEndInAnEscapeChar( str ) )
721
{
722
// append the escaped character, join the next part to this
723
// part and remove the next part
724
parts.set( a, str.substring( 0, str.length() - 1 ) +
725
character + parts.get( a + 1 ) );
726
parts.remove( a + 1 );
727
728
// re-visit this part
729
a--;
730
continue;
731
}
732
733
// trim and replace string
734
str = str.trim();
735
parts.set( a, str );
736
}
737
738
String[] ret = new String[ parts.size() ];
739
return parts.toArray( ret );
740
}
741
742
private String unescapeValue( String value )
743
{
744
StringBuilder ret = new StringBuilder( value.length() );
745
boolean in_escape = false;
746
for( int a = 0; a < value.length(); a++ )
747
{
748
int c = value.codePointAt( a );
749
750
// process a normal character
751
if( !in_escape ) {
752
if( c == '\\' )
753
in_escape = true;
754
else
755
ret.append( Character.toChars( c ) );
756
continue;
757
}
758
759
// process an escape sequence
760
in_escape = false;
761
switch( c )
762
{
763
case 'T':
764
case 't':
765
// add tab (invalid/non-standard, but accepted)
766
ret.append( '\t' );
767
break;
768
case 'N':
769
case 'n':
770
// add newline
771
ret.append( '\n' );
772
break;
773
case '\\':
774
case ',':
775
case ';':
776
// add escaped character
777
ret.append( Character.toChars( c ) );
778
break;
779
default:
780
// unknown escape sequence, so add it unescaped
781
// (invalid/non-standard, but accepted)
782
ret.append( "\\" );
783
ret.append( Character.toChars( c ) );
784
break;
785
}
786
}
787
788
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
}
789
319
}
790
320
791
321
private void parseN( String[] params, String value )
322
throws ParseException, SkipContactException,
323
AbortImportException
792
324
{
793
325
// already got a better name?
794
if( _name_level >= NAMELEVEL_N ) return;
326
if( _nameLevel >= NAMELEVEL_N ) return;
795
327
796
328
// get name parts
797
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();
798
332
799
333
// build name
800
334
value = "";
801
final int[] part_order = { 3, 1, 2, 0, 4 };
802
for( int a = 0; a < part_order.length; a++ )
803
if( name_parts.length > part_order[ a ] &&
804
name_parts[ part_order[ a ] ].length() > 0 )
805
{
806
// split this part in to it's comma-separated bits
807
String[] name_part_parts = splitValueByCharacter(
808
name_parts[ part_order[ a ] ], ',' );
809
for( int b = 0; b < name_part_parts.length; b++ )
810
if( name_part_parts[ b ].length() > 0 )
811
{
812
if( value.length() == 0 ) value += " ";
813
value += name_part_parts[ b ];
814
}
815
}
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 ];
816
339
817
340
// set name
818
setName( unescapeValue( value ) );
819
_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();
820
348
}
821
349
822
350
private void parseFN( String[] params, String value )
351
throws ParseException, SkipContactException
823
352
{
824
353
// already got a better name?
825
if( _name_level >= NAMELEVEL_FN ) return;
354
if( _nameLevel >= NAMELEVEL_FN ) return;
826
355
827
356
// set name
828
setName( unescapeValue( value ) );
829
_name_level = NAMELEVEL_FN;
357
setName( undoCharsetAndEncoding( params, value ) );
358
_nameLevel = NAMELEVEL_FN;
830
359
}
831
360
832
361
private void parseORG( String[] params, String value )
362
throws ParseException, SkipContactException
833
363
{
364
// already got a better name?
365
if( _nameLevel >= NAMELEVEL_ORG ) return;
366
834
367
// get org parts
835
String[] org_parts = splitValueByCharacter( value, ';' );
836
if( org_parts == null || org_parts.length < 1 ) return;
837
838
// build organisation name
839
StringBuilder builder = new StringBuilder(
840
String.valueOf( org_parts[ 0 ] ) );
841
for( int a = 1; a < org_parts.length; a++ )
842
builder.append( ", " ).append( org_parts[ a ] );
843
String organisation = unescapeValue( builder.toString() );
844
845
// set organisation name (using a title we've previously found)
846
addOrganisation( organisation, _cached_title, true );
847
848
// if we've not previously found a title, store this organisation
849
// name (we'll need it when we find a title to update the
850
// organisation, by name), else if we *have* previously found a
851
// title, clear it (since we just used it)
852
if( _cached_title == null )
853
_cached_organisation = organisation;
854
else
855
_cached_title = null;
856
}
857
858
private void parseTITLE( String[] params, String value )
859
{
860
value = unescapeValue( value );
861
862
// if we previously had an organisation, look it up and append this
863
// title to it
864
if( _cached_organisation != null && hasOrganisations() ) {
865
HashMap< String, ExtraDetail > datas = getOrganisations();
866
ExtraDetail detail = datas.get( _cached_organisation );
867
if( detail != null )
868
detail.setExtra( value );
869
}
870
871
// same as when handling organisation, if we've not previously found
872
// an organisation we store this title, else we clear it (since we
873
// just appended this title to it)
874
if( _cached_organisation == null )
875
_cached_title = value;
876
else
877
_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;
878
381
}
879
382
880
383
private void parseTEL( String[] params, String value )
384
throws ParseException
881
385
{
882
386
if( value.length() == 0 ) return;
883
387
884
388
Set< String > types = extractTypes( params, Arrays.asList(
885
"PREF", "HOME", "WORK", "VOICE", "FAX", "MSG", "CELL",
886
"PAGER", "BBS", "MODEM", "CAR", "ISDN", "VIDEO" ) );
389
"PREF", "HOME", "WORK", "VOICE", "FAX", "MSG", "CELL",
390
"PAGER", "BBS", "MODEM", "CAR", "ISDN", "VIDEO" ) );
887
391
888
392
// here's the logic...
889
boolean is_preferred = types.contains( "PREF" );
890
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 );
891
401
if( types.contains( "FAX" ) )
892
402
if( types.contains( "HOME" ) )
893
type = TYPE_FAX_HOME;
403
addPhone( value, PhonesColumns.TYPE_FAX_HOME, preferred );
894
404
else
895
type = TYPE_FAX_WORK;
896
else if( types.contains( "CELL" ) || types.contains( "VIDEO" ) )
897
type = TYPE_MOBILE;
898
else if( types.contains( "PAGER" ) )
899
type = TYPE_PAGER;
900
else if( types.contains( "WORK" ) )
901
type = TYPE_WORK;
902
else
903
type = TYPE_HOME;
904
905
// add phone number
906
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 );
907
408
}
908
409
909
410
public void parseEMAIL( String[] params, String value )
911
412
if( value.length() == 0 ) return;
912
413
913
414
Set< String > types = extractTypes( params, Arrays.asList(
914
"PREF", "WORK", "HOME", "INTERNET" ) );
915
916
// add email address
917
boolean is_preferred = types.contains( "PREF" );
918
int type;
919
if( types.contains( "WORK" ) )
920
type = TYPE_WORK;
921
else
922
type = TYPE_HOME;
923
924
addEmail( unescapeValue( value ), type, is_preferred );
925
}
926
927
private void parseADR( String[] params, String value )
928
{
929
// get address parts
930
String[] adr_parts = splitValueByCharacter( value, ';' );
931
932
// build address
933
value = "";
934
for( int a = 0; a < adr_parts.length; a++ )
935
if( adr_parts[ a ].length() > 0 )
936
{
937
// split this part in to it's comma-separated bits
938
String[] adr_part_parts =
939
splitValueByCharacter( adr_parts[ a ], ',' );
940
for( int b = 0; b < adr_part_parts.length; b++ )
941
if( adr_part_parts[ b ].length() > 0 )
942
{
943
if( value.length() > 0 ) value += "\n";
944
value += adr_part_parts[ b ];
945
}
946
}
947
948
Set< String > types = extractTypes( params, Arrays.asList(
949
"PREF", "WORK", "HOME" ) );
950
951
// add address
952
int type;
953
if( types.contains( "WORK" ) )
954
type = TYPE_WORK;
955
else
956
type = TYPE_HOME;
957
958
addAddress( unescapeValue( value ), type );
959
}
960
961
private void parseLABEL( String[] params, String value )
962
{
963
Set< String > types = extractTypes( params, Arrays.asList(
964
"PREF", "WORK", "HOME" ) );
965
966
// add address
967
int type;
968
if( types.contains( "WORK" ) )
969
type = TYPE_WORK;
970
else
971
type = TYPE_HOME;
972
973
addAddress( unescapeValue( value ), type );
974
}
975
976
private void parseNOTE( String[] params, String value )
977
{
978
addNote( unescapeValue( value ) );
979
}
980
981
public void finaliseVcard()
982
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
983
428
{
984
429
// missing version (and data is present)
985
if( _version == null && _buffers != null )
430
if( _version == null && _lines != null )
986
431
throw new ParseException( R.string.error_vcf_malformed );
987
432
988
// finalise the parent class
989
finalise();
990
}
991
992
/**
993
* Amongst the params, find the value of the first, only, of any with
994
* the specified name
995
* @param params
996
* @param name
997
* @return a value, or null
998
*/
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
999
464
private String checkParam( String[] params, String name )
1000
465
{
1001
String[] res = checkParams( params, name );
1002
return res.length > 0? res[ 0 ] : null;
1003
}
1004
1005
/**
1006
* Amongst the params, find the values of any with the specified name
1007
* @param params
1008
* @param name
1009
* @return an array of values, or null
1010
*/
1011
private String[] checkParams( String[] params, String name )
1012
{
1013
HashSet< String > ret = new HashSet< String >();
1014
1015
Pattern p = Pattern.compile(
1016
"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$",
1017
Pattern.CASE_INSENSITIVE );
466
Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
1018
467
for( int i = 0; i < params.length; i++ ) {
1019
468
Matcher m = p.matcher( params[ i ] );
1020
469
if( m.matches() )
1021
ret.add( m.group( 2 ) );
470
return m.group( 1 );
1022
471
}
1023
1024
return (String[]) ret.toArray( new String[ ret.size() ] );
472
return null;
1025
473
}
1026
474
1027
/**
1028
* Amongst the params, return any type values present. For v2.1 vCards,
1029
* those types are just parameters. For v3.0, they are prefixed with
1030
* "TYPE=". There may also be multiple type parameters.
1031
* @param params an array of params to look for types in
1032
* @param valid_types an list of upper-case type values to look for
1033
* @return a set of present type values
1034
*/
1035
475
private Set< String > extractTypes( String[] params,
1036
List< String > valid_types )
476
List< String > validTypes )
1037
477
{
1038
478
HashSet< String > types = new HashSet< String >();
1039
479
1040
480
// get 3.0-style TYPE= param
1041
String type_params[] = checkParams( params, "TYPE" );
1042
for( int a = 0; a < type_params.length; a++ )
1043
{
1044
// check for a comma-separated list of types (why? this isn't in
1045
// the specs!)
1046
String[] parts = type_params[ a ].split( "," );
1047
for( int i = 0; i < parts.length; i++ )
1048
parts[ i ] = parts[ i ].toUpperCase( Locale.US );
1049
for( int i = 0; i < parts.length; i++ )
1050
if( valid_types.contains( parts[ i ] ) )
1051
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 ] );
1052
487
}
1053
488
1054
489
// get 2.1-style type param
1055
490
if( _version.equals( "2.1" ) ) {
1056
491
for( int i = 1; i < params.length; i++ )
1057
if( valid_types.contains( params[ i ] ) )
492
if( validTypes.contains( params[ i ] ) )
1058
493
types.add( params[ i ] );
1059
494
}
1060
495
1061
496
return types;
1062
497
}
1063
498
1064
private UnencodeResult unencodeQuotedPrintable( ByteBuffer in )
499
private String unencodeQuotedPrintable( String str, String charset )
1065
500
{
1066
boolean another = false;
501
// default encoding scheme
502
if( charset == null ) charset = "UTF-8";
1067
503
1068
// unencode quoted-printable encoding, as per RFC1521 section 5.1
1069
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() ];
1070
506
int j = 0;
1071
for( int i = in.position(); i < in.limit(); i++ )
1072
{
1073
// get next char and process...
1074
byte ch = in.array()[ i ];
1075
if( ch == '=' && i < in.limit() - 2 )
1076
{
1077
// we found a =XX format byte, add it
1078
out[ j ] = (byte)(
1079
Character.digit( in.array()[ i + 1 ], 16 ) * 16 +
1080
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 ) );
1081
513
i += 2;
1082
514
}
1083
else if( ch == '=' && i == in.limit() - 1 )
1084
{
1085
// we found a '=' at the end of a line signifying a multi-
1086
// line string, so we don't add it.
1087
another = true;
1088
continue;
1089
}
1090
515
else
1091
// just a normal char...
1092
out[ j ] = (byte)ch;
1093
j++;
1094
}
1095
1096
return new UnencodeResult( another, ByteBuffer.wrap( out, 0, j ) );
1097
}
1098
1099
private ByteBuffer transcodeAsciiToUtf8( ByteBuffer in )
1100
{
1101
// transcode
1102
byte[] out = new byte[ ( in.limit() - in.position() ) * 2 ];
1103
int j = 0;
1104
for( int a = in.position(); a < in.limit(); a++ )
1105
{
1106
// if char is < 127, keep it as-is
1107
if( in.array()[ a ] >= 0 )
1108
out[ j++ ] = in.array()[ a ];
1109
1110
// else, convert it to UTF-8
1111
else {
1112
int b = 0xff & (int)in.array()[ a ];
1113
out[ j++ ] = (byte)( 0xc0 | ( b >> 6 ) );
1114
out[ j++ ] = (byte)( 0x80 | ( b & 0x3f ) );
1115
}
1116
}
1117
1118
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;
1119
522
}
1120
523
}
1121
524
}
Loggerhead is a web-based interface for Bazaar branches
Version: 1.18.2, Revision: 480