/android/import-contacts : revision 80

175

// import

176

importVCardFileContent( content, file.getName() );

177

}

178

catch( OutOfMemoryError e ) {

179

showError( R.string.error_outofmemory );

180

}

178

181

catch( FileNotFoundException e ) {

179

182

showError( getText( R.string.error_filenotfound ) +

180

183

file.getName() );

193

196

ContentLineIterator cli = new ContentLineIterator( content );

194

197

while( cli.hasNext() )

195

198

{

196

ByteBuffer buffer = cli.next();

199

ContentLine content_line = cli.next();

197

200

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

}

201

// get a US-ASCII version of the string, for processing

202

String line = content_line.getUsAsciiLine();

208

203

209

204

if( vcard == null ) {

210

205

// look for vcard beginning

211

if( line.matches( "^BEGIN:VCARD" ) ) {

206

if( line.matches( "^BEGIN[ \t]*:[ \t]*VCARD" ) ) {

212

207

setProgress( _progress++ );

213

208

vcard = new Vcard();

214

209

vcard_start_line = cli.getLineNumber();

216

211

}

217

212

else {

218

213

// look for vcard content or ending

219

if( line.matches( "^END:VCARD" ) )

214

if( line.matches( "^END[ \t]*:[ \t]*VCARD" ) )

220

215

{

221

216

// finalise the vcard/contact

222

217

try {

259

254

{

260

255

// try giving the line to the vcard

261

256

try {

262

vcard.parseLine( buffer, line,

263

cli.doesNextLineLookFolded() );

257

vcard.parseLine( content_line );

264

258

}

265

259

catch( Vcard.ParseException e ) {

266

260

skipContact();

289

283

}

290

284

}

291

285

292

class ContentLineIterator implements Iterator< ByteBuffer >

286

class ContentLine

287

{

288

private ByteBuffer _buffer;

289

private boolean _folded_next;

290

private String _line;

291

292

public ContentLine( ByteBuffer buffer, boolean folded_next )

293

{

294

_buffer = buffer;

295

_folded_next = folded_next;

296

_line = null;

297

}

298

299

public ByteBuffer getBuffer()

300

{

301

return _buffer;

302

}

303

304

public boolean doesNextLineLookFolded()

305

{

306

return _folded_next;

307

}

308

309

public String getUsAsciiLine()

310

{

311

// generated line and cache it

312

if( _line == null ) {

313

try {

314

_line = new String( _buffer.array(), _buffer.position(),

315

_buffer.limit() - _buffer.position(), "US-ASCII" );

316

}

317

catch( UnsupportedEncodingException e ) {

318

// we know US-ASCII *is* supported, so appease the

319

// compiler...

320

}

321

}

322

323

// return cached line

324

return _line;

325

}

326

}

327

328

class ContentLineIterator implements Iterator< ContentLine >

293

329

{

294

330

protected byte[] _content = null;

295

331

protected int _pos = 0;

307

343

}

308

344

309

345

@Override

310

public ByteBuffer next()

346

public ContentLine next()

311

347

{

312

348

int initial_pos = _pos;

313

349

320

356

_pos > initial_pos )? _pos - 1 : _pos;

321

357

_pos++;

322

358

_line++;

323

return ByteBuffer.wrap( _content, initial_pos,

324

to - initial_pos );

359

return new ContentLine(

360

ByteBuffer.wrap( _content, initial_pos,

361

to - initial_pos ),

362

doesNextLineLookFolded() );

325

363

}

326

364

327

365

// we didn't find one, but were there bytes left?

329

367

int to = _pos;

330

368

_pos++;

331

369

_line++;

332

return ByteBuffer.wrap( _content, initial_pos,

333

to - initial_pos );

370

return new ContentLine(

371

ByteBuffer.wrap( _content, initial_pos,

372

to - initial_pos ),

373

doesNextLineLookFolded() );

334

374

}

335

375

336

376

// no bytes left

348

388

* onto the end of this one?

349

389

* @return

350

390

*/

351

public boolean doesNextLineLookFolded()

391

private boolean doesNextLineLookFolded()

352

392

{

353

393

return _pos > 0 && _pos < _content.length &&

354

_content[ _pos - 1 ] == '\n' && _content[ _pos ] == ' ';

394

_content[ _pos - 1 ] == '\n' &&

395

( _content[ _pos ] == ' ' || _content[ _pos ] == '\t' );

355

396

}

356

397

357

398

public int getLineNumber()

369

410

private final static int MULTILINE_NONE = 0;

370

411

private final static int MULTILINE_ENCODED = 1; // v2.1 quoted-printable

371

412

private final static int MULTILINE_ESCAPED = 2; // v2.1 \\CRLF

372

private final static int MULTILINE_FOLDED = 3; // v3.0 folding

413

private final static int MULTILINE_FOLDED = 3; // MIME-DIR folding

373

414

374

415

private String _version = null;

375

private Vector< ByteBuffer > _buffers = null;

416

private Vector< ContentLine > _content_lines = null;

376

417

private int _name_level = NAMELEVEL_NONE;

377

418

private int _parser_multiline_state = MULTILINE_NONE;

378

419

private String _parser_current_name_and_params = null;

421

462

@SuppressWarnings("serial")

422

463

protected class SkipImportException extends Exception { }

423

464

424

private String extractCollonPartFromLine( ByteBuffer buffer,

425

String line, boolean former )

465

private String extractCollonPartFromLine( ContentLine content_line,

466

boolean former )

426

467

{

427

468

String ret = null;

428

469

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

470

// split line into name and value parts and check to make sure we

443

471

// only got 2 parts and that the first part is not zero in length

444

String[] parts = line.split( ":", 2 );

472

String[] parts = content_line.getUsAsciiLine().split( ":", 2 );

445

473

if( parts.length == 2 && parts[ 0 ].length() > 0 )

446

474

ret = parts[ former? 0 : 1 ];

447

475

448

476

return ret;

449

477

}

450

478

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 )

479

private String extractNameAndParamsFromLine( ContentLine content_line )

480

{

481

return extractCollonPartFromLine( content_line, true );

482

}

483

484

private String extractValueFromLine( ContentLine content_line )

485

{

486

return extractCollonPartFromLine( content_line, false );

487

}

488

489

public void parseLine( ContentLine content_line )

464

490

throws ParseException, SkipImportException,

465

491

AbortImportException

466

492

{

469

495

{

470

496

// tentatively get name and params from line

471

497

String name_and_params =

472

extractNameAndParamsFromLine( buffer, line );

498

extractNameAndParamsFromLine( content_line );

473

499

474

500

// is it a version line?

475

501

if( name_and_params != null &&

476

name_and_params.equals( "VERSION" ) )

502

name_and_params.equalsIgnoreCase( "VERSION" ) )

477

503

{

478

504

// yes, get it!

479

String value = extractValueFromLine( buffer, line );

505

String value = extractValueFromLine( content_line );

480

506

if( !value.equals( "2.1" ) && !value.equals( "3.0" ) )

481

507

throw new ParseException( R.string.error_vcf_version );

482

508

_version = value;

483

509

484

510

// parse any buffers we've been accumulating while we waited

485

511

// 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;

512

if( _content_lines != null )

513

for( int i = 0; i < _content_lines.size(); i++ )

514

parseLine( _content_lines.get( i ) );

515

_content_lines = null;

494

516

}

495

517

else

496

518

{

497

519

// no, so stash this line till we get a version

498

if( _buffers == null )

499

_buffers = new Vector< ByteBuffer >();

500

_buffers.add( buffer );

520

if( _content_lines == null )

521

_content_lines = new Vector< ContentLine >();

522

_content_lines.add( content_line );

501

523

}

502

524

}

503

525

else

504

526

{

505

527

// name and params and the position in the buffer where the

506

// "value" part of the line start

528

// "value" part of the line starts

507

529

String name_and_params;

508

530

int pos;

509

531

515

537

516

538

// skip some initial line characters, depending on the type

517

539

// of multi-line we're handling

518

pos = buffer.position();

540

pos = content_line.getBuffer().position();

519

541

switch( _parser_multiline_state )

520

542

{

521

543

case MULTILINE_FOLDED:

522

544

pos++;

523

545

break;

524

546

case MULTILINE_ENCODED:

525

while( pos < buffer.limit() && (

526

buffer.get( pos ) == ' ' ||

527

buffer.get( pos ) == '\t' ) )

547

while( pos < content_line.getBuffer().limit() && (

548

content_line.getBuffer().get( pos ) == ' ' ||

549

content_line.getBuffer().get( pos ) == '\t' ) )

528

550

{

529

551

pos++;

530

552

}

539

561

}

540

562

else

541

563

{

564

// skip empty lines

565

if( content_line.getUsAsciiLine().trim().length() == 0 )

566

return;

567

542

568

// get name and params from line, and since we're not

543

569

// parsing a subsequent line in a multi-line, this should

544

570

// not fail, or it's an error

545

571

name_and_params =

546

extractNameAndParamsFromLine( buffer, line );

572

extractNameAndParamsFromLine( content_line );

547

573

if( name_and_params == null )

548

574

throw new ParseException(

549

575

R.string.error_vcf_malformed );

550

576

551

577

// calculate how many chars to skip from beginning of line

552

578

// so we skip the property "name:" part

553

pos = buffer.position() + name_and_params.length() + 1;

579

pos = content_line.getBuffer().position() +

580

name_and_params.length() + 1;

554

581

555

582

// reset the saved multi-line state

556

583

_parser_current_name_and_params = name_and_params;

559

586

560

587

// get value from buffer, as raw bytes

561

588

ByteBuffer value;

562

value = ByteBuffer.wrap( buffer.array(), pos,

563

buffer.limit() - pos );

589

value = ByteBuffer.wrap( content_line.getBuffer().array(), pos,

590

content_line.getBuffer().limit() - pos );

564

591

565

592

// get parameter parts

566

593

String[] name_param_parts = name_and_params.split( ";", -1 );

573

600

"FN", "ORG", "TITLE", "TEL", "EMAIL", "ADR", "LABEL" }

574

601

) );

575

602

boolean is_interesting_field =

576

interesting_fields.contains( name_param_parts[ 0 ] );

603

interesting_fields.contains(

604

name_param_parts[ 0 ].toUpperCase( Locale.US ) );

577

605

578

606

// parse encoding parameter

579

607

String encoding = checkParam( name_param_parts, "ENCODING" );

580

608

if( encoding != null )

581

609

encoding = encoding.toUpperCase( Locale.US );

582

610

if( is_interesting_field && encoding != null &&

583

!encoding.equals( "8BIT" ) &&

584

!encoding.equals( "QUOTED-PRINTABLE" ) )

585

//&& !encoding.equals( "BASE64" ) )

611

!encoding.equalsIgnoreCase( "8BIT" ) &&

612

!encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

613

//&& !encoding.equalsIgnoreCase( "BASE64" ) )

586

614

{

587

615

throw new ParseException( R.string.error_vcf_encoding );

588

616

}

592

620

if( charset != null )

593

621

charset = charset.toUpperCase( Locale.US );

594

622

if( charset != null &&

595

!charset.equals( "US-ASCII" ) &&

596

!charset.equals( "ASCII" ) &&

597

!charset.equals( "UTF-8" ) )

623

!charset.equalsIgnoreCase( "US-ASCII" ) &&

624

!charset.equalsIgnoreCase( "ASCII" ) &&

625

!charset.equalsIgnoreCase( "UTF-8" ) )

598

626

{

599

627

throw new ParseException( R.string.error_vcf_charset );

600

628

}

602

630

// do unencoding (or default to a fake unencoding result with

603

631

// the raw string)

604

632

UnencodeResult unencoding_result = null;

605

if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )

633

if( encoding != null &&

634

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

635

{

606

636

unencoding_result = unencodeQuotedPrintable( value );

607

// else if( encoding != null && encoding.equals( "BASE64" ) )

637

}

638

// else if( encoding != null &&

639

// encoding.equalsIgnoreCase( "BASE64" ) )

640

// {

608

641

// unencoding_result = unencodeBase64( props[ 1 ], charset );

642

// }

609

643

if( unencoding_result != null ) {

610

644

value = unencoding_result.getBuffer();

611

645

if( unencoding_result.isAnotherLineRequired() )

616

650

// specified for a v2.1 vcard entry, we assume it's US-ASCII)

617

651

if( ( charset == null && _version.equals( "2.1" ) ) ||

618

652

( charset != null && (

619

charset.equals( "ASCII" ) ||

620

charset.equals( "US-ASCII" ) ) ) )

653

charset.equalsIgnoreCase( "ASCII" ) ||

654

charset.equalsIgnoreCase( "US-ASCII" ) ) ) )

621

655

{

622

656

value = transcodeAsciiToUtf8( value );

623

657

}

634

668

// for some entries that have semicolon-separated value parts,

635

669

// check to see if the value ends in an escape character, which

636

670

// 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" ) ) &&

671

if( ( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) ||

672

name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) ||

673

name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) ) &&

640

674

doesStringEndInAnEscapeChar( string_value ) )

641

675

{

642

676

_parser_multiline_state = MULTILINE_ESCAPED;

644

678

string_value.length() - 1 );

645

679

}

646

680

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

681

// if we know we're not in an encoding-based multi-line, check

682

// to see if we're in a folded multi-line

649

683

if( _parser_multiline_state == MULTILINE_NONE &&

650

_version.equals( "3.0" ) && next_line_looks_folded )

684

content_line.doesNextLineLookFolded() )

651

685

{

652

686

_parser_multiline_state = MULTILINE_FOLDED;

653

687

}

665

699

if( complete_value.length() < 1 ) return;

666

700

667

701

// parse some properties

668

if( name_param_parts[ 0 ].equals( "N" ) )

702

if( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) )

669

703

parseN( name_param_parts, complete_value );

670

else if( name_param_parts[ 0 ].equals( "FN" ) )

704

else if( name_param_parts[ 0 ].equalsIgnoreCase( "FN" ) )

671

705

parseFN( name_param_parts, complete_value );

672

else if( name_param_parts[ 0 ].equals( "ORG" ) )

706

else if( name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) )

673

707

parseORG( name_param_parts, complete_value );

674

else if( name_param_parts[ 0 ].equals( "TITLE" ) )

708

else if( name_param_parts[ 0 ].equalsIgnoreCase( "TITLE" ) )

675

709

parseTITLE( name_param_parts, complete_value );

676

else if( name_param_parts[ 0 ].equals( "TEL" ) )

710

else if( name_param_parts[ 0 ].equalsIgnoreCase( "TEL" ) )

677

711

parseTEL( name_param_parts, complete_value );

678

else if( name_param_parts[ 0 ].equals( "EMAIL" ) )

712

else if( name_param_parts[ 0 ].equalsIgnoreCase( "EMAIL" ) )

679

713

parseEMAIL( name_param_parts, complete_value );

680

else if( name_param_parts[ 0 ].equals( "ADR" ) )

714

else if( name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) )

681

715

parseADR( name_param_parts, complete_value );

682

else if( name_param_parts[ 0 ].equals( "LABEL" ) )

716

else if( name_param_parts[ 0 ].equalsIgnoreCase( "LABEL" ) )

683

717

parseLABEL( name_param_parts, complete_value );

718

else if( name_param_parts[ 0 ].equalsIgnoreCase( "NOTE" ) )

719

parseNOTE( name_param_parts, complete_value );

684

720

}

685

721

}

686

722

758

794

in_escape = false;

759

795

switch( c )

760

796

{

797

case 'T':

798

case 't':

799

// add tab (invalid/non-standard, but accepted)

800

ret.append( '\t' );

801

break;

761

802

case 'N':

762

803

case 'n':

763

804

// add newline

771

812

break;

772

813

default:

773

814

// unknown escape sequence, so add it unescaped

815

// (invalid/non-standard, but accepted)

774

816

ret.append( "\\" );

775

817

ret.append( Character.toChars( c ) );

776

818

break;

801

843

for( int b = 0; b < name_part_parts.length; b++ )

802

844

if( name_part_parts[ b ].length() > 0 )

803

845

{

804

if( value.length() == 0 ) value += " ";

846

if( value.length() > 0 ) value += " ";

805

847

value += name_part_parts[ b ];

806

848

}

807

849

}

926

968

for( int a = 0; a < adr_parts.length; a++ )

927

969

if( adr_parts[ a ].length() > 0 )

928

970

{

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

}

971

// version 3.0 vCards allow further splitting by comma

972

if( _version.equals( "3.0" ) )

973

{

974

// split this part in to it's comma-separated bits and

975

// add them on individual lines

976

String[] adr_part_parts =

977

splitValueByCharacter( adr_parts[ a ], ',' );

978

for( int b = 0; b < adr_part_parts.length; b++ )

979

if( adr_part_parts[ b ].length() > 0 )

980

{

981

if( value.length() > 0 ) value += "\n";

982

value += adr_part_parts[ b ];

983

}

984

}

985

else

986

{

987

// add this part on an individual line

988

if( value.length() > 0 ) value += "\n";

989

value += adr_parts[ a ];

990

}

938

991

}

939

992

940

993

Set< String > types = extractTypes( params, Arrays.asList(

965

1018

addAddress( unescapeValue( value ), type );

966

1019

}

967

1020

1021

private void parseNOTE( String[] params, String value )

1022

{

1023

addNote( unescapeValue( value ) );

1024

}

1025

968

1026

public void finaliseVcard()

969

1027

throws ParseException, ContactNotIdentifiableException

970

1028

{

971

1029

// missing version (and data is present)

972

if( _version == null && _buffers != null )

1030

if( _version == null && _content_lines != null )

973

1031

throw new ParseException( R.string.error_vcf_malformed );

974

1032

975

1033

// finalise the parent class

1000

1058

HashSet< String > ret = new HashSet< String >();

1001

1059

1002

1060

Pattern p = Pattern.compile(

1003

"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$" );

1061

"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$",

1062

Pattern.CASE_INSENSITIVE );

1004

1063

for( int i = 0; i < params.length; i++ ) {

1005

1064

Matcher m = p.matcher( params[ i ] );

1006

1065

if( m.matches() )

1014

1073

* Amongst the params, return any type values present. For v2.1 vCards,

1015

1074

* those types are just parameters. For v3.0, they are prefixed with

1016

1075

* "TYPE=". There may also be multiple type parameters.

1017

* @param params

1018

* @param a list of type values to look for

1076

* @param params an array of params to look for types in

1077

* @param valid_types an list of upper-case type values to look for

1019

1078

* @return a set of present type values

1020

1079

*/

1021

1080

private Set< String > extractTypes( String[] params,

1027

1086

String type_params[] = checkParams( params, "TYPE" );

1028

1087

for( int a = 0; a < type_params.length; a++ )

1029

1088

{

1030

// check for a comma-separated list of types (why? this isn't in

1031

// the specs!)

1089

// check for a comma-separated list of types (why? I don't think

1090

// this is in the specs!)

1032

1091

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 ] );

1092

for( int i = 0; i < parts.length; i++ ) {

1093

String ucpart = parts[ i ].toUpperCase( Locale.US );

1094

if( valid_types.contains( ucpart ) )

1095

types.add( ucpart );

1096

}

1036

1097

}

1037

1098

1038

1099

// get 2.1-style type param

1039

1100

if( _version.equals( "2.1" ) ) {

1040

for( int i = 1; i < params.length; i++ )

1041

if( valid_types.contains( params[ i ] ) )

1042

types.add( params[ i ] );

1101

for( int i = 1; i < params.length; i++ ) {

1102

String ucparam = params[ i ].toUpperCase( Locale.US );

1103

if( valid_types.contains( ucparam ) )

1104

types.add( ucparam );

1105

}

1043

1106

}

1044

1107

1045

1108

return types;