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