(root)/android/import-contacts
» Revision
7
(compared to revision 116)
: 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:
- TODO
- 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:
- .bzrignore
added
removed
src/org/waxworlds/importcontacts/VCFImporter.java
1
1
/*
2
2
* VCFImporter.java
3
3
*
4
* Copyright (C) 2009 to 2013 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
* to as "this program"). For more information, see
8
* http://ed.am/dev/android/import-contacts
7
* to as "this program"). For more information, see
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
41
import org.waxworlds.importcontacts.Importer.AbortImportException;
42
48
43
import android.content.SharedPreferences;
49
import android.os.Environment;
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
}
70
66
File[] files = null;
71
67
try
72
68
{
73
// check SD card is mounted
74
String state = Environment.getExternalStorageState();
75
if( !Environment.MEDIA_MOUNTED.equals( state ) &&
76
!Environment.MEDIA_MOUNTED_READ_ONLY.equals( state ) )
77
{
78
showError( R.string.error_nosdcard );
79
}
80
81
69
// open directory
82
File file = new File( Environment.getExternalStorageDirectory(),
83
prefs.getString( "location", "/" ) );
84
if( !file.exists() )
70
String location = prefs.getString( "location", "" );
71
File dir = new File( location );
72
if( !dir.exists() || !dir.isDirectory() )
85
73
showError( R.string.error_locationnotfound );
86
74
87
// directory, or file?
88
if( file.isDirectory() )
89
{
90
// get files
91
class VCardFilter implements FilenameFilter {
92
public boolean accept( File dir, String name ) {
93
return name.toLowerCase( Locale.ENGLISH )
94
.endsWith( ".vcf" );
95
}
96
}
97
files = file.listFiles( new VCardFilter() );
98
}
99
else
100
{
101
// use just this file
102
files = new File[ 1 ];
103
files[ 0 ] = file;
104
}
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() );
105
82
}
106
83
catch( SecurityException e ) {
107
84
showError( R.string.error_locationpermissions );
119
96
countVCardFile( files[ i ] );
120
97
setTmpProgress( i );
121
98
}
122
setProgressMax( _vcard_count ); // will also update tmp progress
99
setProgressMax( _vCardCount ); // will also update tmp progress
123
100
124
101
// import them
125
102
setProgress( 0 );
126
103
for( int i = 0; i < files.length; i++ )
127
104
importVCardFile( files[ i ] );
128
setProgress( _vcard_count );
129
105
}
130
106
131
107
private void countVCardFile( File file ) throws AbortImportException
134
110
{
135
111
// open file
136
112
BufferedReader reader = new BufferedReader(
137
new FileReader( file ) );
113
new FileReader( file ) );
138
114
139
115
// read
140
116
String line;
141
boolean in_vcard = false;
117
boolean inVCard = false;
142
118
while( ( line = reader.readLine() ) != null )
143
119
{
144
if( !in_vcard )
145
{
120
if( !inVCard ) {
146
121
// look for vcard beginning
147
if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {
148
in_vcard = true;
149
_vcard_count++;
150
}
151
// check for vMsg files
152
else if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VMSG.*" ) ) {
153
showError( getText( R.string.error_vcf_vmsgfile )
154
+ file.getName() );
122
if( line.matches( "^BEGIN[ \\t]*:[ \\t]*VCARD" ) ) {
123
inVCard = true;
124
_vCardCount++;
155
125
}
156
126
}
157
else if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )
158
in_vcard = false;
127
else if( line.matches( "^END[ \\t]*:[ \\t]*VCARD" ) )
128
inVCard = false;
159
129
}
160
reader.close();
161
130
162
131
}
163
132
catch( FileNotFoundException e ) {
164
showError( getText( R.string.error_filenotfound ) +
165
file.getName() );
133
showError( getText( R.string.error_filenotfound ) + file.getName() );
166
134
}
167
135
catch( IOException e ) {
168
136
showError( getText( R.string.error_ioerror ) + file.getName() );
171
139
172
140
private void importVCardFile( File file ) throws AbortImportException
173
141
{
174
// check file is good
175
if( !file.exists() )
176
showError( getText( R.string.error_filenotfound ) +
177
file.getName() );
178
if( file.length() == 0 )
179
showError( getText( R.string.error_fileisempty ) +
180
file.getName() );
181
182
142
try
183
143
{
184
// open/read file
185
FileInputStream istream = new FileInputStream( file );
186
byte[] content = new byte[ (int)file.length() ];
187
istream.read( content );
188
istream.close();
189
190
// import
191
importVCardFileContent( content, file.getName() );
192
}
193
catch( OutOfMemoryError e ) {
194
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() );
195
155
}
196
156
catch( FileNotFoundException e ) {
197
showError( getText( R.string.error_filenotfound ) +
198
file.getName() );
157
showError( getText( R.string.error_filenotfound ) + file.getName() );
199
158
}
200
159
catch( IOException e ) {
201
160
showError( getText( R.string.error_ioerror ) + file.getName() );
202
161
}
203
162
}
204
163
205
private void importVCardFileContent( byte[] content, String fileName )
206
throws AbortImportException
164
private void importVCardFileContent( String content, String fileName )
165
throws AbortImportException
207
166
{
208
// go through lines
209
Vcard vcard = null;
210
int vcard_start_line = 0;
211
ContentLineIterator cli = new ContentLineIterator( content );
212
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++ )
213
177
{
214
ContentLine content_line = cli.next();
215
216
// get a US-ASCII version of the string, for processing
217
String line = content_line.getUsAsciiLine();
218
219
if( vcard == null ) {
178
String line = lines[ i ];
179
180
if( vCard == null ) {
220
181
// look for vcard beginning
221
if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {
222
setProgress( _progress++ );
223
vcard = new Vcard();
224
vcard_start_line = cli.getLineNumber();
182
if( line.matches( "^BEGIN[ \\t]*:[ \\t]*VCARD" ) ) {
183
setProgress( ++_progress );
184
vCard = new VCard();
225
185
}
226
186
}
227
187
else {
228
188
// look for vcard content or ending
229
if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )
189
if( line.matches( "^END[ \\t]*:[ \\t]*VCARD" ) )
230
190
{
231
// finalise the vcard/contact
191
// store vcard and do away with it
232
192
try {
233
vcard.finaliseVcard();
234
235
// pass the finalised contact to the importer
236
importContact( vcard );
237
}
238
catch( Vcard.ParseException e ) {
239
showContinueOrAbort(
240
getText( R.string.error_vcf_parse ).toString()
241
+ fileName +
242
getText( R.string.error_vcf_parse_line ).toString()
243
+ cli.getLineNumber() + ":\n" + e.getMessage() );
244
skipContact();
245
}
246
catch( ContactData.ContactNotIdentifiableException e ) {
247
showContinueOrAbort(
248
getText( R.string.error_vcf_parse ).toString()
249
+ fileName +
250
getText( R.string.error_vcf_parse_line ).toString()
251
+ vcard_start_line + ":\n" + getText(
252
R.string.error_vcf_notenoughinfo ).toString() );
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
showContinueOrAbort(
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() );
217
if( !showContinue(
218
getText( R.string.error_vcf_parse ).toString()
219
+ fileName + "\n" + e.getMessage() ) )
220
finish( ACTION_ABORT );
272
221
273
// Although we're continuing, we still need to abort
274
// this vCard. Further lines will be ignored until we
222
// although we're continuing, we still need to abort
223
// this vCard. Further lines will be ignored until we
275
224
// get to another BEGIN:VCARD line.
276
vcard = null;
225
vCard = null;
277
226
}
278
catch( Vcard.SkipImportException e ) {
227
catch( VCard.SkipContactException e ) {
279
228
skipContact();
280
// Abort this vCard. Further lines will be ignored until
229
// abort this vCard. Further lines will be ignored until
281
230
// we get to another BEGIN:VCARD line.
282
vcard = null;
231
vCard = null;
283
232
}
284
233
}
285
234
}
286
235
}
287
236
}
288
237
289
class ContentLine
290
{
291
private ByteBuffer _buffer;
292
private boolean _folded_next;
293
private String _line;
294
295
public ContentLine( ByteBuffer buffer, boolean folded_next )
296
{
297
_buffer = buffer;
298
_folded_next = folded_next;
299
_line = null;
300
}
301
302
public ByteBuffer getBuffer()
303
{
304
return _buffer;
305
}
306
307
public boolean doesNextLineLookFolded()
308
{
309
return _folded_next;
310
}
311
312
public String getUsAsciiLine()
313
{
314
// generated line and cache it
315
if( _line == null ) {
316
try {
317
_line = new String( _buffer.array(), _buffer.position(),
318
_buffer.limit() - _buffer.position(), "US-ASCII" );
319
}
320
catch( UnsupportedEncodingException e ) {
321
// we know US-ASCII *is* supported, so appease the
322
// compiler...
323
}
324
}
325
326
// return cached line
327
return _line;
328
}
329
}
330
331
class ContentLineIterator implements Iterator< ContentLine >
332
{
333
protected byte[] _content = null;
334
protected int _pos = 0;
335
protected int _line = 0;
336
337
public ContentLineIterator( byte[] content )
338
{
339
_content = content;
340
}
341
342
@Override
343
public boolean hasNext()
344
{
345
return _pos < _content.length;
346
}
347
348
@Override
349
public ContentLine next()
350
{
351
int initial_pos = _pos;
352
353
// find newline
354
for( ; _pos < _content.length; _pos++ )
355
if( _content[ _pos ] == '\n' )
356
{
357
// adjust for a \r preceding the \n
358
int to = ( _pos > 0 && _content[ _pos - 1 ] == '\r' &&
359
_pos > initial_pos )? _pos - 1 : _pos;
360
_pos++;
361
_line++;
362
return new ContentLine(
363
ByteBuffer.wrap( _content, initial_pos,
364
to - initial_pos ),
365
doesNextLineLookFolded() );
366
}
367
368
// we didn't find one, but were there bytes left?
369
if( _pos != initial_pos ) {
370
int to = _pos;
371
_pos++;
372
_line++;
373
return new ContentLine(
374
ByteBuffer.wrap( _content, initial_pos,
375
to - initial_pos ),
376
doesNextLineLookFolded() );
377
}
378
379
// no bytes left
380
throw new NoSuchElementException();
381
}
382
383
@Override
384
public void remove()
385
{
386
throw new UnsupportedOperationException();
387
}
388
389
/**
390
* Does the next line, if there is one, look like it should be folded
391
* onto the end of this one?
392
* @return
393
*/
394
private boolean doesNextLineLookFolded()
395
{
396
return _pos > 0 && _pos < _content.length &&
397
_content[ _pos - 1 ] == '\n' &&
398
( _content[ _pos ] == ' ' || _content[ _pos ] == '\t' );
399
}
400
401
public int getLineNumber()
402
{
403
return _line;
404
}
405
}
406
407
private class Vcard extends ContactData
238
private class VCard extends ContactData
408
239
{
409
240
private final static int NAMELEVEL_NONE = 0;
410
private final static int NAMELEVEL_N = 1;
241
private final static int NAMELEVEL_ORG = 1;
411
242
private final static int NAMELEVEL_FN = 2;
412
413
private final static int MULTILINE_NONE = 0;
414
private final static int MULTILINE_ENCODED = 1; // v2.1 quoted-printable
415
private final static int MULTILINE_ESCAPED = 2; // v2.1 \\CRLF
416
private final static int MULTILINE_FOLDED = 3; // MIME-DIR folding
243
private final static int NAMELEVEL_N = 3;
417
244
418
245
private String _version = null;
419
private Vector< ContentLine > _content_lines = null;
420
private int _name_level = NAMELEVEL_NONE;
421
private int _parser_multiline_state = MULTILINE_NONE;
422
private String _parser_current_name_and_params = null;
423
private String _parser_buffered_value_so_far = "";
424
private String _cached_organisation = null;
425
private String _cached_title = null;
426
427
protected class UnencodeResult
428
{
429
private boolean _another_line_required;
430
private ByteBuffer _buffer;
431
432
public UnencodeResult( boolean another_line_required,
433
ByteBuffer buffer )
434
{
435
_another_line_required = another_line_required;
436
_buffer = buffer;
437
}
438
439
public boolean isAnotherLineRequired()
440
{
441
return _another_line_required;
442
}
443
444
public ByteBuffer getBuffer()
445
{
446
return _buffer;
447
}
448
}
449
450
@SuppressWarnings("serial")
246
private Vector< String > _lines = null;
247
private int _nameLevel = NAMELEVEL_NONE;
248
451
249
protected class ParseException extends Exception
452
250
{
453
@SuppressWarnings("unused")
454
251
public ParseException( String error )
455
252
{
456
253
super( error );
458
255
459
256
public ParseException( int res )
460
257
{
461
super( VcardImporter.this.getText( res ).toString() );
258
super( VCFImporter.this.getText( res ).toString() );
462
259
}
463
260
}
464
261
465
@SuppressWarnings("serial")
466
protected class SkipImportException extends Exception { }
467
468
private String extractCollonPartFromLine( ContentLine content_line,
469
boolean former )
470
{
471
// split line into name and value parts and check to make sure we
472
// only got 2 parts and that the first part is not zero in length
473
String[] parts = content_line.getUsAsciiLine().split( ":", 2 );
474
if( parts.length == 2 && parts[ 0 ].length() > 0 )
475
return parts[ former? 0 : 1 ].trim();
476
477
return null;
478
}
479
480
private String extractNameAndParamsFromLine( ContentLine content_line )
481
{
482
return extractCollonPartFromLine( content_line, true );
483
}
484
485
private String extractValueFromLine( ContentLine content_line )
486
{
487
return extractCollonPartFromLine( content_line, false );
488
}
489
490
public void parseLine( ContentLine content_line )
491
throws ParseException, SkipImportException,
492
AbortImportException
493
{
494
// 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
495
276
if( _version == null )
496
277
{
497
// tentatively get name and params from line
498
String name_and_params =
499
extractNameAndParamsFromLine( content_line );
500
501
// is it a version line?
502
if( name_and_params != null &&
503
name_and_params.equalsIgnoreCase( "VERSION" ) )
278
if( props[ 0 ].equals( "VERSION" ) )
504
279
{
505
// yes, get it!
506
String value = extractValueFromLine( content_line );
507
if( value == null || (
508
!value.equals( "2.1" ) && !value.equals( "3.0" ) ) )
509
{
280
// get version
281
if( !props[ 1 ].equals( "2.1" ) &&
282
!props[ 1 ].equals( "3.0" ) )
510
283
throw new ParseException( R.string.error_vcf_version );
511
}
512
_version = value;
284
_version = props[ 1 ];
513
285
514
// parse any buffers we've been accumulating while we waited
515
// for a version
516
if( _content_lines != null )
517
for( int i = 0; i < _content_lines.size(); i++ )
518
parseLine( _content_lines.get( i ) );
519
_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;
520
291
}
521
292
else
522
293
{
523
// no, so stash this line till we get a version
524
if( _content_lines == null )
525
_content_lines = new Vector< ContentLine >();
526
_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 );
527
298
}
528
299
}
529
300
else
530
301
{
531
// name and params and the position in the buffer where the
532
// "value" part of the line starts
533
String name_and_params;
534
int pos;
535
536
if( _parser_multiline_state != MULTILINE_NONE )
537
{
538
// if we're currently in a multi-line value, use the stored
539
// property name and parameters
540
name_and_params = _parser_current_name_and_params;
541
542
// skip some initial line characters, depending on the type
543
// of multi-line we're handling
544
pos = content_line.getBuffer().position();
545
switch( _parser_multiline_state )
546
{
547
case MULTILINE_FOLDED:
548
pos++;
549
break;
550
case MULTILINE_ENCODED:
551
while( pos < content_line.getBuffer().limit() && (
552
content_line.getBuffer().get( pos ) == ' ' ||
553
content_line.getBuffer().get( pos ) == '\t' ) )
554
{
555
pos++;
556
}
557
break;
558
default:
559
// do nothing
560
}
561
562
// take us out of multi-line so that we can re-detect that
563
// this line is a multi-line or not
564
_parser_multiline_state = MULTILINE_NONE;
565
}
566
else
567
{
568
// skip empty lines
569
if( content_line.getUsAsciiLine().trim().length() == 0 )
570
return;
571
572
// get name and params from line, and since we're not
573
// parsing a subsequent line in a multi-line, this should
574
// not fail, or it's an error
575
name_and_params =
576
extractNameAndParamsFromLine( content_line );
577
if( name_and_params == null )
578
throw new ParseException(
579
R.string.error_vcf_malformed );
580
581
// calculate how many chars to skip from beginning of line
582
// so we skip the property "name:" part
583
pos = content_line.getBuffer().position() +
584
name_and_params.length() + 1;
585
586
// reset the saved multi-line state
587
_parser_current_name_and_params = name_and_params;
588
_parser_buffered_value_so_far = "";
589
}
590
591
// get value from buffer, as raw bytes
592
ByteBuffer value;
593
value = ByteBuffer.wrap( content_line.getBuffer().array(), pos,
594
content_line.getBuffer().limit() - pos );
595
596
302
// get parameter parts
597
String[] name_param_parts = name_and_params.split( ";", -1 );
598
for( int i = 0; i < name_param_parts.length; i++ )
599
name_param_parts[ i ] = name_param_parts[ i ].trim();
600
601
// determine whether we care about this entry
602
final HashSet< String > interesting_fields =
603
new HashSet< String >( Arrays.asList( new String[] { "N",
604
"FN", "ORG", "TITLE", "TEL", "EMAIL", "ADR", "LABEL" }
605
) );
606
boolean is_interesting_field =
607
interesting_fields.contains(
608
name_param_parts[ 0 ].toUpperCase( Locale.ENGLISH ) );
609
610
// parse encoding parameter
611
String encoding = checkParam( name_param_parts, "ENCODING" );
612
if( encoding != null )
613
encoding = encoding.toUpperCase( Locale.ENGLISH );
614
if( is_interesting_field && encoding != null &&
615
!encoding.equalsIgnoreCase( "8BIT" ) &&
616
!encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )
617
//&& !encoding.equalsIgnoreCase( "BASE64" ) )
618
{
619
throw new ParseException( R.string.error_vcf_encoding );
620
}
621
622
// parse charset parameter
623
String charset = checkParam( name_param_parts, "CHARSET" );
624
if( charset != null )
625
charset = charset.toUpperCase( Locale.ENGLISH );
626
if( charset != null &&
627
!charset.equalsIgnoreCase( "US-ASCII" ) &&
628
!charset.equalsIgnoreCase( "ASCII" ) &&
629
!charset.equalsIgnoreCase( "UTF-8" ) )
630
{
631
throw new ParseException( R.string.error_vcf_charset );
632
}
633
634
// do unencoding (or default to a fake unencoding result with
635
// the raw string)
636
UnencodeResult unencoding_result = null;
637
if( encoding != null &&
638
encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )
639
{
640
unencoding_result = unencodeQuotedPrintable( value );
641
}
642
// else if( encoding != null &&
643
// encoding.equalsIgnoreCase( "BASE64" ) )
644
// {
645
// unencoding_result = unencodeBase64( props[ 1 ], charset );
646
// }
647
if( unencoding_result != null ) {
648
value = unencoding_result.getBuffer();
649
if( unencoding_result.isAnotherLineRequired() )
650
_parser_multiline_state = MULTILINE_ENCODED;
651
}
652
653
// convert 8-bit US-ASCII charset to UTF-8 (where no charset is
654
// specified for a v2.1 vcard entry, we assume it's US-ASCII)
655
if( ( charset == null && _version.equals( "2.1" ) ) ||
656
( charset != null && (
657
charset.equalsIgnoreCase( "ASCII" ) ||
658
charset.equalsIgnoreCase( "US-ASCII" ) ) ) )
659
{
660
value = transcodeAsciiToUtf8( value );
661
}
662
663
// process charset (value is now in UTF-8)
664
String string_value;
665
try {
666
string_value = new String( value.array(), value.position(),
667
value.limit() - value.position(), "UTF-8" );
668
} catch( UnsupportedEncodingException e ) {
669
throw new ParseException( R.string.error_vcf_charset );
670
}
671
672
// for some entries that have semicolon-separated value parts,
673
// check to see if the value ends in an escape character, which
674
// indicates that we have a multi-line value
675
if( ( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) ||
676
name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) ||
677
name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) ) &&
678
doesStringEndInAnEscapeChar( string_value ) )
679
{
680
_parser_multiline_state = MULTILINE_ESCAPED;
681
string_value = string_value.substring( 0,
682
string_value.length() - 1 );
683
}
684
685
// if we know we're not in an encoding-based multi-line, check
686
// to see if we're in a folded multi-line
687
if( _parser_multiline_state == MULTILINE_NONE &&
688
content_line.doesNextLineLookFolded() )
689
{
690
_parser_multiline_state = MULTILINE_FOLDED;
691
}
692
693
// handle multi-lines by buffering them and parsing them when we
694
// are processing the last line in a multi-line sequence
695
if( _parser_multiline_state != MULTILINE_NONE ) {
696
_parser_buffered_value_so_far += string_value;
697
return;
698
}
699
String complete_value =
700
( _parser_buffered_value_so_far + string_value ).trim();
701
702
// ignore empty values
703
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();
704
306
705
307
// parse some properties
706
if( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) )
707
parseN( name_param_parts, complete_value );
708
else if( name_param_parts[ 0 ].equalsIgnoreCase( "FN" ) )
709
parseFN( name_param_parts, complete_value );
710
else if( name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) )
711
parseORG( name_param_parts, complete_value );
712
else if( name_param_parts[ 0 ].equalsIgnoreCase( "TITLE" ) )
713
parseTITLE( name_param_parts, complete_value );
714
else if( name_param_parts[ 0 ].equalsIgnoreCase( "TEL" ) )
715
parseTEL( name_param_parts, complete_value );
716
else if( name_param_parts[ 0 ].equalsIgnoreCase( "EMAIL" ) )
717
parseEMAIL( name_param_parts, complete_value );
718
else if( name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) )
719
parseADR( name_param_parts, complete_value );
720
else if( name_param_parts[ 0 ].equalsIgnoreCase( "LABEL" ) )
721
parseLABEL( name_param_parts, complete_value );
722
else if( name_param_parts[ 0 ].equalsIgnoreCase( "NOTE" ) )
723
parseNOTE( name_param_parts, complete_value );
724
else if( name_param_parts[ 0 ].equalsIgnoreCase( "BDAY" ) )
725
parseBDAY( 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
private void parseBDAY( String[] params, String value )
1033
{
1034
setBirthday( value );
1035
}
1036
1037
public void finaliseVcard()
1038
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
1039
428
{
1040
429
// missing version (and data is present)
1041
if( _version == null && _content_lines != null )
430
if( _version == null && _lines != null )
1042
431
throw new ParseException( R.string.error_vcf_malformed );
1043
432
1044
// finalise the parent class
1045
finalise();
1046
}
1047
1048
/**
1049
* Amongst the params, find the value of the first, only, of any with
1050
* the specified name.
1051
*
1052
* @param params
1053
* @param name
1054
* @return a value, or null
1055
*/
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
1056
464
private String checkParam( String[] params, String name )
1057
465
{
1058
String[] res = checkParams( params, name );
1059
return res.length > 0? res[ 0 ] : null;
1060
}
1061
1062
/**
1063
* Amongst the params, find the values of any with the specified name.
1064
*
1065
* @param params
1066
* @param name
1067
* @return an array of values, or null
1068
*/
1069
private String[] checkParams( String[] params, String name )
1070
{
1071
HashSet< String > ret = new HashSet< String >();
1072
1073
Pattern p = Pattern.compile(
1074
"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$",
1075
Pattern.CASE_INSENSITIVE );
466
Pattern p = Pattern.compile( "^" + name + "[ \\t]*=[ \\t]*(.*)$" );
1076
467
for( int i = 0; i < params.length; i++ ) {
1077
468
Matcher m = p.matcher( params[ i ] );
1078
469
if( m.matches() )
1079
ret.add( m.group( 2 ) );
470
return m.group( 1 );
1080
471
}
1081
1082
return (String[]) ret.toArray( new String[ ret.size() ] );
472
return null;
1083
473
}
1084
474
1085
/**
1086
* Amongst the params, return any type values present. For v2.1 vCards,
1087
* those types are just parameters. For v3.0, they are prefixed with
1088
* "TYPE=". There may also be multiple type parameters.
1089
*
1090
* @param params an array of params to look for types in
1091
* @param valid_types an list of upper-case type values to look for
1092
* @return a set of present type values
1093
*/
1094
475
private Set< String > extractTypes( String[] params,
1095
List< String > valid_types )
476
List< String > validTypes )
1096
477
{
1097
478
HashSet< String > types = new HashSet< String >();
1098
479
1099
480
// get 3.0-style TYPE= param
1100
String type_params[] = checkParams( params, "TYPE" );
1101
for( int a = 0; a < type_params.length; a++ )
1102
{
1103
// check for a comma-separated list of types (why? I don't think
1104
// this is in the specs!)
1105
String[] parts = type_params[ a ].split( "," );
1106
for( int i = 0; i < parts.length; i++ ) {
1107
String ucpart = parts[ i ].toUpperCase( Locale.ENGLISH );
1108
if( valid_types.contains( ucpart ) )
1109
types.add( ucpart );
1110
}
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 ] );
1111
487
}
1112
488
1113
489
// get 2.1-style type param
1114
490
if( _version.equals( "2.1" ) ) {
1115
for( int i = 1; i < params.length; i++ ) {
1116
String ucparam = params[ i ].toUpperCase( Locale.ENGLISH );
1117
if( valid_types.contains( ucparam ) )
1118
types.add( ucparam );
1119
}
491
for( int i = 1; i < params.length; i++ )
492
if( validTypes.contains( params[ i ] ) )
493
types.add( params[ i ] );
1120
494
}
1121
495
1122
496
return types;
1123
497
}
1124
498
1125
private UnencodeResult unencodeQuotedPrintable( ByteBuffer in )
499
private String unencodeQuotedPrintable( String str, String charset )
1126
500
{
1127
boolean another = false;
501
// default encoding scheme
502
if( charset == null ) charset = "UTF-8";
1128
503
1129
// unencode quoted-printable encoding, as per RFC1521 section 5.1
1130
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() ];
1131
506
int j = 0;
1132
for( int i = in.position(); i < in.limit(); i++ )
1133
{
1134
// get next char and process...
1135
byte ch = in.array()[ i ];
1136
if( ch == '=' && i < in.limit() - 2 )
1137
{
1138
// we found a =XX format byte, add it
1139
out[ j ] = (byte)(
1140
Character.digit( in.array()[ i + 1 ], 16 ) * 16 +
1141
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 ) );
1142
513
i += 2;
1143
514
}
1144
else if( ch == '=' && i == in.limit() - 1 )
1145
{
1146
// we found a '=' at the end of a line signifying a multi-
1147
// line string, so we don't add it
1148
another = true;
1149
continue;
1150
}
1151
515
else
1152
// just a normal char...
1153
out[ j ] = (byte)ch;
1154
j++;
1155
}
1156
1157
return new UnencodeResult( another, ByteBuffer.wrap( out, 0, j ) );
1158
}
1159
1160
private ByteBuffer transcodeAsciiToUtf8( ByteBuffer in )
1161
{
1162
// transcode
1163
byte[] out = new byte[ ( in.limit() - in.position() ) * 2 ];
1164
int j = 0;
1165
for( int a = in.position(); a < in.limit(); a++ )
1166
{
1167
// if char is < 127, keep it as-is
1168
if( in.array()[ a ] >= 0 )
1169
out[ j++ ] = in.array()[ a ];
1170
1171
// else, convert it to UTF-8
1172
else {
1173
int b = 0xff & (int)in.array()[ a ];
1174
out[ j++ ] = (byte)( 0xc0 | ( b >> 6 ) );
1175
out[ j++ ] = (byte)( 0x80 | ( b & 0x3f ) );
1176
}
1177
}
1178
1179
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;
1180
522
}
1181
523
}
1182
524
}
Loggerhead is a web-based interface for Bazaar branches
Version: 1.18.2, Revision: 480