(root)/android/import-contacts
» Revision
7
(compared to revision 62)
: 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
}
685
}
686
687
private boolean doesStringEndInAnEscapeChar( String string )
688
{
689
// count the number of backslashes at the end of the string
690
int count = 0;
691
for( int a = string.length() - 1; a >= 0; a-- )
692
if( string.charAt( a ) == '\\' )
693
count++;
694
else
695
break;
696
697
// if there are an even number of backslashes then the final one
698
// doesn't count
699
return ( count & 1 ) == 1;
700
}
701
702
private String[] splitValueByCharacter( String value, char character )
703
{
704
// split string in to parts by specified character
705
ArrayList< String > parts = new ArrayList< String >(
706
Arrays.asList( value.split( "" + character ) ) );
707
708
// go through parts
709
for( int a = 0; a < parts.size(); a++ )
710
{
711
String str = parts.get( a );
712
713
// look for parts that end in an escape character, but ignore
714
// the final part. We've already detected escape chars at the
715
// end of the final part in parseLine() and handled multi-lines
716
// accordingly.
717
if( a < parts.size() - 1 &&
718
doesStringEndInAnEscapeChar( str ) )
719
{
720
// append the escaped character, join the next part to this
721
// part and remove the next part
722
parts.set( a, str.substring( 0, str.length() - 1 ) +
723
character + parts.get( a + 1 ) );
724
parts.remove( a + 1 );
725
726
// re-visit this part
727
a--;
728
continue;
729
}
730
731
// trim and replace string
732
str = str.trim();
733
parts.set( a, str );
734
}
735
736
String[] ret = new String[ parts.size() ];
737
return parts.toArray( ret );
738
}
739
740
private String unescapeValue( String value )
741
{
742
StringBuilder ret = new StringBuilder( value.length() );
743
boolean in_escape = false;
744
for( int a = 0; a < value.length(); a++ )
745
{
746
int c = value.codePointAt( a );
747
748
// process a normal character
749
if( !in_escape ) {
750
if( c == '\\' )
751
in_escape = true;
752
else
753
ret.append( Character.toChars( c ) );
754
continue;
755
}
756
757
// process an escape sequence
758
in_escape = false;
759
switch( c )
760
{
761
case 'N':
762
case 'n':
763
// add newline
764
ret.append( '\n' );
765
break;
766
case '\\':
767
case ',':
768
case ';':
769
// add escaped character
770
ret.append( Character.toChars( c ) );
771
break;
772
default:
773
// unknown escape sequence, so add it unescaped
774
ret.append( "\\" );
775
ret.append( Character.toChars( c ) );
776
break;
777
}
778
}
779
780
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
}
781
319
}
782
320
783
321
private void parseN( String[] params, String value )
322
throws ParseException, SkipContactException,
323
AbortImportException
784
324
{
785
325
// already got a better name?
786
if( _name_level >= NAMELEVEL_N ) return;
326
if( _nameLevel >= NAMELEVEL_N ) return;
787
327
788
328
// get name parts
789
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();
790
332
791
333
// build name
792
334
value = "";
793
final int[] part_order = { 3, 1, 2, 0, 4 };
794
for( int a = 0; a < part_order.length; a++ )
795
if( name_parts.length > part_order[ a ] &&
796
name_parts[ part_order[ a ] ].length() > 0 )
797
{
798
// split this part in to it's comma-separated bits
799
String[] name_part_parts = splitValueByCharacter(
800
name_parts[ part_order[ a ] ], ',' );
801
for( int b = 0; b < name_part_parts.length; b++ )
802
if( name_part_parts[ b ].length() > 0 )
803
{
804
if( value.length() == 0 ) value += " ";
805
value += name_part_parts[ b ];
806
}
807
}
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 ];
808
339
809
340
// set name
810
setName( unescapeValue( value ) );
811
_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();
812
348
}
813
349
814
350
private void parseFN( String[] params, String value )
351
throws ParseException, SkipContactException
815
352
{
816
353
// already got a better name?
817
if( _name_level >= NAMELEVEL_FN ) return;
354
if( _nameLevel >= NAMELEVEL_FN ) return;
818
355
819
356
// set name
820
setName( unescapeValue( value ) );
821
_name_level = NAMELEVEL_FN;
357
setName( undoCharsetAndEncoding( params, value ) );
358
_nameLevel = NAMELEVEL_FN;
822
359
}
823
360
824
361
private void parseORG( String[] params, String value )
362
throws ParseException, SkipContactException
825
363
{
364
// already got a better name?
365
if( _nameLevel >= NAMELEVEL_ORG ) return;
366
826
367
// get org parts
827
String[] org_parts = splitValueByCharacter( value, ';' );
828
if( org_parts == null || org_parts.length < 1 ) return;
829
830
// build organisation name
831
StringBuilder builder = new StringBuilder(
832
String.valueOf( org_parts[ 0 ] ) );
833
for( int a = 1; a < org_parts.length; a++ )
834
builder.append( ", " ).append( org_parts[ a ] );
835
String organisation = unescapeValue( builder.toString() );
836
837
// set organisation name (using a title we've previously found)
838
addOrganisation( organisation, _cached_title, true );
839
840
// if we've not previously found a title, store this organisation
841
// name (we'll need it when we find a title to update the
842
// organisation, by name), else if we *have* previously found a
843
// title, clear it (since we just used it)
844
if( _cached_title == null )
845
_cached_organisation = organisation;
846
else
847
_cached_title = null;
848
}
849
850
private void parseTITLE( String[] params, String value )
851
{
852
value = unescapeValue( value );
853
854
// if we previously had an organisation, look it up and append this
855
// title to it
856
if( _cached_organisation != null && hasOrganisations() ) {
857
HashMap< String, ExtraDetail > datas = getOrganisations();
858
ExtraDetail detail = datas.get( _cached_organisation );
859
if( detail != null )
860
detail.setExtra( value );
861
}
862
863
// same as when handling organisation, if we've not previously found
864
// an organisation we store this title, else we clear it (since we
865
// just appended this title to it)
866
if( _cached_organisation == null )
867
_cached_title = value;
868
else
869
_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;
870
381
}
871
382
872
383
private void parseTEL( String[] params, String value )
384
throws ParseException
873
385
{
874
386
if( value.length() == 0 ) return;
875
387
876
388
Set< String > types = extractTypes( params, Arrays.asList(
877
"PREF", "HOME", "WORK", "VOICE", "FAX", "MSG", "CELL",
878
"PAGER", "BBS", "MODEM", "CAR", "ISDN", "VIDEO" ) );
389
"PREF", "HOME", "WORK", "VOICE", "FAX", "MSG", "CELL",
390
"PAGER", "BBS", "MODEM", "CAR", "ISDN", "VIDEO" ) );
879
391
880
392
// here's the logic...
881
boolean is_preferred = types.contains( "PREF" );
882
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 );
883
401
if( types.contains( "FAX" ) )
884
402
if( types.contains( "HOME" ) )
885
type = TYPE_FAX_HOME;
403
addPhone( value, PhonesColumns.TYPE_FAX_HOME, preferred );
886
404
else
887
type = TYPE_FAX_WORK;
888
else if( types.contains( "CELL" ) || types.contains( "VIDEO" ) )
889
type = TYPE_MOBILE;
890
else if( types.contains( "PAGER" ) )
891
type = TYPE_PAGER;
892
else if( types.contains( "WORK" ) )
893
type = TYPE_WORK;
894
else
895
type = TYPE_HOME;
896
897
// add phone number
898
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 );
899
408
}
900
409
901
410
public void parseEMAIL( String[] params, String value )
903
412
if( value.length() == 0 ) return;
904
413
905
414
Set< String > types = extractTypes( params, Arrays.asList(
906
"PREF", "WORK", "HOME", "INTERNET" ) );
907
908
// add email address
909
boolean is_preferred = types.contains( "PREF" );
910
int type;
911
if( types.contains( "WORK" ) )
912
type = TYPE_WORK;
913
else
914
type = TYPE_HOME;
915
916
addEmail( unescapeValue( value ), type, is_preferred );
917
}
918
919
private void parseADR( String[] params, String value )
920
{
921
// get address parts
922
String[] adr_parts = splitValueByCharacter( value, ';' );
923
924
// build address
925
value = "";
926
for( int a = 0; a < adr_parts.length; a++ )
927
if( adr_parts[ a ].length() > 0 )
928
{
929
// split this part in to it's comma-separated bits
930
String[] adr_part_parts =
931
splitValueByCharacter( adr_parts[ a ], ',' );
932
for( int b = 0; b < adr_part_parts.length; b++ )
933
if( adr_part_parts[ b ].length() > 0 )
934
{
935
if( value.length() > 0 ) value += "\n";
936
value += adr_part_parts[ b ];
937
}
938
}
939
940
Set< String > types = extractTypes( params, Arrays.asList(
941
"PREF", "WORK", "HOME" ) );
942
943
// add address
944
int type;
945
if( types.contains( "WORK" ) )
946
type = TYPE_WORK;
947
else
948
type = TYPE_HOME;
949
950
addAddress( unescapeValue( value ), type );
951
}
952
953
private void parseLABEL( String[] params, String value )
954
{
955
Set< String > types = extractTypes( params, Arrays.asList(
956
"PREF", "WORK", "HOME" ) );
957
958
// add address
959
int type;
960
if( types.contains( "WORK" ) )
961
type = TYPE_WORK;
962
else
963
type = TYPE_HOME;
964
965
addAddress( unescapeValue( value ), type );
966
}
967
968
public void finaliseVcard()
969
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
970
428
{
971
429
// missing version (and data is present)
972
if( _version == null && _buffers != null )
430
if( _version == null && _lines != null )
973
431
throw new ParseException( R.string.error_vcf_malformed );
974
432
975
// finalise the parent class
976
finalise();
977
}
978
979
/**
980
* Amongst the params, find the value of the first, only, of any with
981
* the specified name
982
* @param params
983
* @param name
984
* @return a value, or null
985
*/
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
986
464
private String checkParam( String[] params, String name )
987
465
{
988
String[] res = checkParams( params, name );
989
return res.length > 0? res[ 0 ] : null;
990
}
991
992
/**
993
* Amongst the params, find the values of any with the specified name
994
* @param params
995
* @param name
996
* @return an array of values, or null
997
*/
998
private String[] checkParams( String[] params, String name )
999
{
1000
HashSet< String > ret = new HashSet< String >();
1001
1002
Pattern p = Pattern.compile(
1003
"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$" );
466
Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
1004
467
for( int i = 0; i < params.length; i++ ) {
1005
468
Matcher m = p.matcher( params[ i ] );
1006
469
if( m.matches() )
1007
ret.add( m.group( 2 ) );
470
return m.group( 1 );
1008
471
}
1009
1010
return (String[]) ret.toArray( new String[ ret.size() ] );
472
return null;
1011
473
}
1012
474
1013
/**
1014
* Amongst the params, return any type values present. For v2.1 vCards,
1015
* those types are just parameters. For v3.0, they are prefixed with
1016
* "TYPE=". There may also be multiple type parameters.
1017
* @param params
1018
* @param a list of type values to look for
1019
* @return a set of present type values
1020
*/
1021
475
private Set< String > extractTypes( String[] params,
1022
List< String > valid_types )
476
List< String > validTypes )
1023
477
{
1024
478
HashSet< String > types = new HashSet< String >();
1025
479
1026
480
// get 3.0-style TYPE= param
1027
String type_params[] = checkParams( params, "TYPE" );
1028
for( int a = 0; a < type_params.length; a++ )
1029
{
1030
// check for a comma-separated list of types (why? this isn't in
1031
// the specs!)
1032
String[] parts = type_params[ a ].split( "," );
1033
for( int i = 0; i < parts.length; i++ )
1034
if( valid_types.contains( parts[ i ] ) )
1035
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 ] );
1036
487
}
1037
488
1038
489
// get 2.1-style type param
1039
490
if( _version.equals( "2.1" ) ) {
1040
491
for( int i = 1; i < params.length; i++ )
1041
if( valid_types.contains( params[ i ] ) )
492
if( validTypes.contains( params[ i ] ) )
1042
493
types.add( params[ i ] );
1043
494
}
1044
495
1045
496
return types;
1046
497
}
1047
498
1048
private UnencodeResult unencodeQuotedPrintable( ByteBuffer in )
499
private String unencodeQuotedPrintable( String str, String charset )
1049
500
{
1050
boolean another = false;
501
// default encoding scheme
502
if( charset == null ) charset = "UTF-8";
1051
503
1052
// unencode quoted-printable encoding, as per RFC1521 section 5.1
1053
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() ];
1054
506
int j = 0;
1055
for( int i = in.position(); i < in.limit(); i++ )
1056
{
1057
// get next char and process...
1058
byte ch = in.array()[ i ];
1059
if( ch == '=' && i < in.limit() - 2 )
1060
{
1061
// we found a =XX format byte, add it
1062
out[ j ] = (byte)(
1063
Character.digit( in.array()[ i + 1 ], 16 ) * 16 +
1064
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 ) );
1065
513
i += 2;
1066
514
}
1067
else if( ch == '=' && i == in.limit() - 1 )
1068
{
1069
// we found a '=' at the end of a line signifying a multi-
1070
// line string, so we don't add it.
1071
another = true;
1072
continue;
1073
}
1074
515
else
1075
// just a normal char...
1076
out[ j ] = (byte)ch;
1077
j++;
1078
}
1079
1080
return new UnencodeResult( another, ByteBuffer.wrap( out, 0, j ) );
1081
}
1082
1083
private ByteBuffer transcodeAsciiToUtf8( ByteBuffer in )
1084
{
1085
// transcode
1086
byte[] out = new byte[ ( in.limit() - in.position() ) * 2 ];
1087
int j = 0;
1088
for( int a = in.position(); a < in.limit(); a++ )
1089
{
1090
// if char is < 127, keep it as-is
1091
if( in.array()[ a ] >= 0 )
1092
out[ j++ ] = in.array()[ a ];
1093
1094
// else, convert it to UTF-8
1095
else {
1096
int b = 0xff & (int)in.array()[ a ];
1097
out[ j++ ] = (byte)( 0xc0 | ( b >> 6 ) );
1098
out[ j++ ] = (byte)( 0x80 | ( b & 0x3f ) );
1099
}
1100
}
1101
1102
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;
1103
522
}
1104
523
}
1105
524
}
Loggerhead is a web-based interface for Bazaar branches
Version: 1.18.2, Revision: 480