/android/import-contacts : revision 85

1

/*

2

* VCFImporter.java

3

*

4

5

*

6

* This file is part of the Import Contacts program (hereafter referred

7

* to as "this program"). For more information, see

8

* http://www.waxworlds.org/edam/software/android/import-contacts

8

* http://ed.am/dev/android/import-contacts

9

*

10

* This program is free software: you can redistribute it and/or modify

11

* it under the terms of the GNU General Public License as published by

21

* along with this program. If not, see <http://www.gnu.org/licenses/>.

22

*/

23

24

package org.waxworlds.edam.importcontacts;

24

package am.ed.importcontacts;

25

26

import java.io.BufferedReader;

27

import java.io.File;

38

import java.util.HashSet;

39

import java.util.Iterator;

40

import java.util.List;

41

import java.util.Locale;

41

42

import java.util.NoSuchElementException;

42

43

import java.util.Set;

43

44

import java.util.Vector;

44

45

import java.util.regex.Matcher;

45

46

import java.util.regex.Pattern;

46

47

48

import android.annotation.SuppressLint;

47

49

import android.content.SharedPreferences;

48

import android.provider.Contacts;

49

import android.provider.Contacts.PhonesColumns;

50

51

public class VcardImporter extends Importer

52

{

58

super( doit );

59

}

60

61

@SuppressLint( "SdCardPath" )

61

62

@Override

62

63

protected void onImport() throws AbortImportException

63

64

{

82

83

// get files

83

84

class VCardFilter implements FilenameFilter {

84

85

public boolean accept( File dir, String name ) {

85

return name.toLowerCase().endsWith( ".vcf" );

86

return name.toLowerCase( Locale.US ).endsWith( ".vcf" );

86

87

}

87

88

}

88

89

files = file.listFiles( new VCardFilter() );

134

135

{

135

136

if( !in_vcard ) {

136

137

// look for vcard beginning

137

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

138

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

138

139

in_vcard = true;

139

140

_vcard_count++;

140

141

}

141

142

}

142

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

143

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

143

144

in_vcard = false;

144

145

}

145

146

174

175

// import

175

176

importVCardFileContent( content, file.getName() );

176

177

}

178

catch( OutOfMemoryError e ) {

179

showError( R.string.error_outofmemory );

180

}

177

181

catch( FileNotFoundException e ) {

178

182

showError( getText( R.string.error_filenotfound ) +

179

183

file.getName() );

192

196

ContentLineIterator cli = new ContentLineIterator( content );

193

197

while( cli.hasNext() )

194

198

{

195

ByteBuffer buffer = cli.next();

199

ContentLine content_line = cli.next();

196

200

197

// get a US-ASCII version of the line for processing

198

String line;

199

try {

200

line = new String( buffer.array(), buffer.position(),

201

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

202

}

203

catch( UnsupportedEncodingException e ) {

204

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

205

line = "";

206

}

201

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

202

String line = content_line.getUsAsciiLine();

207

203

208

204

if( vcard == null ) {

209

205

// look for vcard beginning

210

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

206

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

211

207

setProgress( _progress++ );

212

208

vcard = new Vcard();

213

209

vcard_start_line = cli.getLineNumber();

215

211

}

216

212

else {

217

213

// look for vcard content or ending

218

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

214

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

219

215

{

220

216

// finalise the vcard/contact

221

217

try {

258

254

{

259

255

// try giving the line to the vcard

260

256

try {

261

vcard.parseLine( buffer, line,

262

cli.doesNextLineLookFolded() );

257

vcard.parseLine( content_line );

263

258

}

264

259

catch( Vcard.ParseException e ) {

265

260

skipContact();

288

283

}

289

284

}

290

285

291

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 >

292

329

{

293

330

protected byte[] _content = null;

294

331

protected int _pos = 0;

306

343

}

307

344

308

345

@Override

309

public ByteBuffer next()

346

public ContentLine next()

310

347

{

311

348

int initial_pos = _pos;

312

349

319

356

_pos > initial_pos )? _pos - 1 : _pos;

320

357

_pos++;

321

358

_line++;

322

return ByteBuffer.wrap( _content, initial_pos,

323

to - initial_pos );

359

return new ContentLine(

360

ByteBuffer.wrap( _content, initial_pos,

361

to - initial_pos ),

362

doesNextLineLookFolded() );

324

363

}

325

364

326

365

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

328

367

int to = _pos;

329

368

_pos++;

330

369

_line++;

331

return ByteBuffer.wrap( _content, initial_pos,

332

to - initial_pos );

370

return new ContentLine(

371

ByteBuffer.wrap( _content, initial_pos,

372

to - initial_pos ),

373

doesNextLineLookFolded() );

333

374

}

334

375

335

376

// no bytes left

347

388

* onto the end of this one?

348

389

* @return

349

390

*/

350

public boolean doesNextLineLookFolded()

391

private boolean doesNextLineLookFolded()

351

392

{

352

393

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

353

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

394

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

395

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

354

396

}

355

397

356

398

public int getLineNumber()

362

404

private class Vcard extends ContactData

363

405

{

364

406

private final static int NAMELEVEL_NONE = 0;

365

private final static int NAMELEVEL_FN = 1;

366

private final static int NAMELEVEL_N = 2;

407

private final static int NAMELEVEL_N = 1;

408

private final static int NAMELEVEL_FN = 2;

367

409

368

410

private final static int MULTILINE_NONE = 0;

369

411

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

370

412

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

371

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

413

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

372

414

373

415

private String _version = null;

374

private Vector< ByteBuffer > _buffers = null;

416

private Vector< ContentLine > _content_lines = null;

375

417

private int _name_level = NAMELEVEL_NONE;

376

418

private int _parser_multiline_state = MULTILINE_NONE;

377

419

private String _parser_current_name_and_params = null;

420

462

@SuppressWarnings("serial")

421

463

protected class SkipImportException extends Exception { }

422

464

423

private String extractCollonPartFromLine( ByteBuffer buffer,

424

String line, boolean former )

465

private String extractCollonPartFromLine( ContentLine content_line,

466

boolean former )

425

467

{

426

468

String ret = null;

427

469

428

// get a US-ASCII version of the line for processing, unless we were

429

// supplied with one

430

if( line == null ) {

431

try {

432

line = new String( buffer.array(), buffer.position(),

433

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

434

}

435

catch( UnsupportedEncodingException e ) {

436

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

437

line = "";

438

}

439

}

440

441

470

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

442

471

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

443

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

472

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

444

473

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

445

474

ret = parts[ former? 0 : 1 ];

446

475

447

476

return ret;

448

477

}

449

478

450

private String extractNameAndParamsFromLine( ByteBuffer buffer,

451

String line )

452

{

453

return extractCollonPartFromLine( buffer, line, true );

454

}

455

456

private String extractValueFromLine( ByteBuffer buffer, String line )

457

{

458

return extractCollonPartFromLine( buffer, line, false );

459

}

460

461

public void parseLine( ByteBuffer buffer, String line,

462

boolean next_line_looks_folded )

479

private String extractNameAndParamsFromLine( ContentLine content_line )

480

{

481

return extractCollonPartFromLine( content_line, true ).trim();

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 )

463

490

throws ParseException, SkipImportException,

464

491

AbortImportException

465

492

{

468

495

{

469

496

// tentatively get name and params from line

470

497

String name_and_params =

471

extractNameAndParamsFromLine( buffer, line );

498

extractNameAndParamsFromLine( content_line );

472

499

473

500

// is it a version line?

474

501

if( name_and_params != null &&

475

name_and_params.equals( "VERSION" ) )

502

name_and_params.equalsIgnoreCase( "VERSION" ) )

476

503

{

477

504

// yes, get it!

478

String value = extractValueFromLine( buffer, line );

505

String value = extractValueFromLine( content_line ).trim();

479

506

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

480

507

throw new ParseException( R.string.error_vcf_version );

481

508

_version = value;

482

509

483

510

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

484

511

// for a version

485

if( _buffers != null )

486

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

487

parseLine( _buffers.get( i ), null,

488

i + 1 < _buffers.size() &&

489

_buffers.get( i + 1 ).hasRemaining() &&

490

_buffers.get( i + 1 ).get(

491

_buffers.get( i + 1 ).position() ) == ' ' );

492

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

493

516

}

494

517

else

495

518

{

496

519

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

497

if( _buffers == null )

498

_buffers = new Vector< ByteBuffer >();

499

_buffers.add( buffer );

520

if( _content_lines == null )

521

_content_lines = new Vector< ContentLine >();

522

_content_lines.add( content_line );

500

523

}

501

524

}

502

525

else

503

526

{

504

527

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

505

// "value" part of the line start

528

// "value" part of the line starts

506

529

String name_and_params;

507

530

int pos;

508

531

514

537

515

538

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

516

539

// of multi-line we're handling

517

pos = buffer.position();

540

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

518

541

switch( _parser_multiline_state )

519

542

{

520

543

case MULTILINE_FOLDED:

521

544

pos++;

522

545

break;

523

546

case MULTILINE_ENCODED:

524

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

525

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

526

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

547

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

548

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

549

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

527

550

{

528

551

pos++;

529

552

}

538

561

}

539

562

else

540

563

{

564

// skip empty lines

565

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

566

return;

567

541

568

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

542

569

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

543

570

// not fail, or it's an error

544

571

name_and_params =

545

extractNameAndParamsFromLine( buffer, line );

572

extractNameAndParamsFromLine( content_line );

546

573

if( name_and_params == null )

547

574

throw new ParseException(

548

575

R.string.error_vcf_malformed );

549

576

550

577

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

551

578

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

552

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

579

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

580

name_and_params.length() + 1;

553

581

554

582

// reset the saved multi-line state

555

583

_parser_current_name_and_params = name_and_params;

558

586

559

587

// get value from buffer, as raw bytes

560

588

ByteBuffer value;

561

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

562

buffer.limit() - pos );

589

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

590

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

563

591

564

592

// get parameter parts

565

593

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

568

596

569

597

// determine whether we care about this entry

570

598

final HashSet< String > interesting_fields =

571

new HashSet< String >( Arrays.asList( new String[]

572

{ "N", "FN", "ORG", "TITLE", "TEL", "EMAIL", "ADR" }

599

new HashSet< String >( Arrays.asList( new String[] { "N",

600

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

573

601

) );

574

602

boolean is_interesting_field =

575

interesting_fields.contains( name_param_parts[ 0 ] );

603

interesting_fields.contains(

604

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

576

605

577

606

// parse encoding parameter

578

607

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

579

if( encoding != null ) encoding = encoding.toUpperCase();

608

if( encoding != null )

609

encoding = encoding.toUpperCase( Locale.US );

580

610

if( is_interesting_field && encoding != null &&

581

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

582

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

583

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

611

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

612

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

613

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

584

614

{

585

615

throw new ParseException( R.string.error_vcf_encoding );

586

616

}

587

617

588

618

// parse charset parameter

589

619

String charset = checkParam( name_param_parts, "CHARSET" );

590

if( charset != null ) charset = charset.toUpperCase();

620

if( charset != null )

621

charset = charset.toUpperCase( Locale.US );

591

622

if( charset != null &&

592

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

593

!charset.equals( "ASCII" ) &&

594

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

623

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

624

!charset.equalsIgnoreCase( "ASCII" ) &&

625

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

595

626

{

596

627

throw new ParseException( R.string.error_vcf_charset );

597

628

}

599

630

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

600

631

// the raw string)

601

632

UnencodeResult unencoding_result = null;

602

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

633

if( encoding != null &&

634

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

635

{

603

636

unencoding_result = unencodeQuotedPrintable( value );

604

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

637

}

638

// else if( encoding != null &&

639

// encoding.equalsIgnoreCase( "BASE64" ) )

640

// {

605

641

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

642

// }

606

643

if( unencoding_result != null ) {

607

644

value = unencoding_result.getBuffer();

608

645

if( unencoding_result.isAnotherLineRequired() )

609

646

_parser_multiline_state = MULTILINE_ENCODED;

610

647

}

611

648

612

// convert 8-bit ASCII charset to US-ASCII

613

if( charset == null || charset.equals( "ASCII" ) ) {

649

// convert 8-bit US-ASCII charset to UTF-8 (where no charset is

650

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

651

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

652

( charset != null && (

653

charset.equalsIgnoreCase( "ASCII" ) ||

654

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

655

{

614

656

value = transcodeAsciiToUtf8( value );

615

charset = "UTF-8";

616

657

}

617

658

618

// process charset

659

// process charset (value is now in UTF-8)

619

660

String string_value;

620

661

try {

621

662

string_value = new String( value.array(), value.position(),

622

value.limit() - value.position(), charset );

663

value.limit() - value.position(), "UTF-8" );

623

664

} catch( UnsupportedEncodingException e ) {

624

665

throw new ParseException( R.string.error_vcf_charset );

625

666

}

627

668

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

628

669

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

629

670

// indicates that we have a multi-line value

630

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

631

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

632

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

633

674

doesStringEndInAnEscapeChar( string_value ) )

634

675

{

635

676

_parser_multiline_state = MULTILINE_ESCAPED;

637

678

string_value.length() - 1 );

638

679

}

639

680

640

// now we know whether we're in an encoding multi-line,

641

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

642

683

if( _parser_multiline_state == MULTILINE_NONE &&

643

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

684

content_line.doesNextLineLookFolded() )

644

685

{

645

686

_parser_multiline_state = MULTILINE_FOLDED;

646

687

}

658

699

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

659

700

660

701

// parse some properties

661

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

702

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

662

703

parseN( name_param_parts, complete_value );

663

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

704

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

664

705

parseFN( name_param_parts, complete_value );

665

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

706

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

666

707

parseORG( name_param_parts, complete_value );

667

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

708

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

668

709

parseTITLE( name_param_parts, complete_value );

669

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

710

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

670

711

parseTEL( name_param_parts, complete_value );

671

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

712

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

672

713

parseEMAIL( name_param_parts, complete_value );

673

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

714

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

674

715

parseADR( name_param_parts, complete_value );

716

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

717

parseLABEL( name_param_parts, complete_value );

718

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

719

parseNOTE( name_param_parts, complete_value );

675

720

}

676

721

}

677

722

690

735

return ( count & 1 ) == 1;

691

736

}

692

737

693

private String[] splitValueBySemicolon( String value )

738

private String[] splitValueByCharacter( String value, char character )

694

739

{

695

// split string in to parts by semicolon

740

// split string in to parts by specified character

696

741

ArrayList< String > parts = new ArrayList< String >(

697

Arrays.asList( value.split( ";" ) ) );

742

Arrays.asList( value.split( "" + character ) ) );

698

743

699

744

// go through parts

700

745

for( int a = 0; a < parts.size(); a++ )

708

753

if( a < parts.size() - 1 &&

709

754

doesStringEndInAnEscapeChar( str ) )

710

755

{

711

// join the next part to this part and remove the next part

756

// append the escaped character, join the next part to this

757

// part and remove the next part

712

758

parts.set( a, str.substring( 0, str.length() - 1 ) +

713

';' + parts.get( a + 1 ) );

759

character + parts.get( a + 1 ) );

714

760

parts.remove( a + 1 );

715

761

716

762

// re-visit this part

727

773

return parts.toArray( ret );

728

774

}

729

775

776

private String unescapeValue( String value )

777

{

778

StringBuilder ret = new StringBuilder( value.length() );

779

boolean in_escape = false;

780

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

781

{

782

int c = value.codePointAt( a );

783

784

// process a normal character

785

if( !in_escape ) {

786

if( c == '\\' )

787

in_escape = true;

788

else

789

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

790

continue;

791

}

792

793

// process an escape sequence

794

in_escape = false;

795

switch( c )

796

{

797

case 'T':

798

case 't':

799

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

800

ret.append( '\t' );

801

break;

802

case 'N':

803

case 'n':

804

// add newline

805

ret.append( '\n' );

806

break;

807

case '\\':

808

case ',':

809

case ';':

810

// add escaped character

811

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

812

break;

813

default:

814

// unknown escape sequence, so add it unescaped

815

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

816

ret.append( "\\" );

817

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

818

break;

819

}

820

}

821

822

return ret.toString();

823

}

824

730

825

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

731

826

{

732

827

// already got a better name?

733

828

if( _name_level >= NAMELEVEL_N ) return;

734

829

735

830

// get name parts

736

String[] name_parts = splitValueBySemicolon( value );

831

String[] name_parts = splitValueByCharacter( value, ';' );

737

832

738

833

// build name

739

834

value = "";

740

if( name_parts.length > 1 && name_parts[ 1 ].length() > 0 )

741

value += name_parts[ 1 ];

742

if( name_parts.length > 0 && name_parts[ 0 ].length() > 0 )

743

value += ( value.length() == 0? "" : " " ) + name_parts[ 0 ];

835

final int[] part_order = { 3, 1, 2, 0, 4 };

836

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

837

if( name_parts.length > part_order[ a ] &&

838

name_parts[ part_order[ a ] ].length() > 0 )

839

{

840

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

841

String[] name_part_parts = splitValueByCharacter(

842

name_parts[ part_order[ a ] ], ',' );

843

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

844

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

845

{

846

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

847

value += name_part_parts[ b ];

848

}

849

}

744

850

745

851

// set name

746

setName( value );

852

setName( unescapeValue( value ) );

747

853

_name_level = NAMELEVEL_N;

748

854

}

749

855

753

859

if( _name_level >= NAMELEVEL_FN ) return;

754

860

755

861

// set name

756

setName( value );

862

setName( unescapeValue( value ) );

757

863

_name_level = NAMELEVEL_FN;

758

864

}

759

865

760

866

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

761

867

{

762

868

// get org parts

763

String[] org_parts = splitValueBySemicolon( value );

869

String[] org_parts = splitValueByCharacter( value, ';' );

764

870

if( org_parts == null || org_parts.length < 1 ) return;

765

871

766

872

// build organisation name

768

874

String.valueOf( org_parts[ 0 ] ) );

769

875

for( int a = 1; a < org_parts.length; a++ )

770

876

builder.append( ", " ).append( org_parts[ a ] );

771

String organisation = builder.toString();

877

String organisation = unescapeValue( builder.toString() );

772

878

773

879

// set organisation name (using a title we've previously found)

774

880

addOrganisation( organisation, _cached_title, true );

785

891

786

892

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

787

893

{

894

value = unescapeValue( value );

895

788

896

// if we previously had an organisation, look it up and append this

789

897

// title to it

790

898

if( _cached_organisation != null && hasOrganisations() ) {

816

924

int type;

817

925

if( types.contains( "FAX" ) )

818

926

if( types.contains( "HOME" ) )

819

type = PhonesColumns.TYPE_FAX_HOME;

927

type = TYPE_FAX_HOME;

820

928

else

821

type = PhonesColumns.TYPE_FAX_WORK;

929

type = TYPE_FAX_WORK;

822

930

else if( types.contains( "CELL" ) || types.contains( "VIDEO" ) )

823

type = PhonesColumns.TYPE_MOBILE;

931

type = TYPE_MOBILE;

824

932

else if( types.contains( "PAGER" ) )

825

type = PhonesColumns.TYPE_PAGER;

933

type = TYPE_PAGER;

826

934

else if( types.contains( "WORK" ) )

827

type = PhonesColumns.TYPE_WORK;

935

type = TYPE_WORK;

828

936

else

829

type = PhonesColumns.TYPE_HOME;

937

type = TYPE_HOME;

830

938

831

939

// add phone number

832

940

addNumber( value, type, is_preferred );

843

951

boolean is_preferred = types.contains( "PREF" );

844

952

int type;

845

953

if( types.contains( "WORK" ) )

846

type = Contacts.ContactMethods.TYPE_WORK;

954

type = TYPE_WORK;

847

955

else

848

type = Contacts.ContactMethods.TYPE_HOME;

956

type = TYPE_HOME;

849

957

850

addEmail( value, type, is_preferred );

958

addEmail( unescapeValue( value ), type, is_preferred );

851

959

}

852

960

853

961

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

854

962

{

855

963

// get address parts

856

String[] adr_parts = splitValueBySemicolon( value );

964

String[] adr_parts = splitValueByCharacter( value, ';' );

857

965

858

966

// build address

859

967

value = "";

860

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

861

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

862

value += adr_parts[ a ].trim();

863

}

864

865

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

866

"PREF", "WORK", "HOME", "INTERNET" ) );

867

868

// add address

869

int type;

870

if( types.contains( "WORK" ) )

871

type = Contacts.ContactMethods.TYPE_WORK;

872

else

873

type = Contacts.ContactMethods.TYPE_HOME;

874

875

addAddress( value, type );

968

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

969

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

970

{

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

}

991

}

992

993

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

994

"PREF", "WORK", "HOME" ) );

995

996

// add address

997

int type;

998

if( types.contains( "WORK" ) )

999

type = TYPE_WORK;

1000

else

1001

type = TYPE_HOME;

1002

1003

addAddress( unescapeValue( value ), type );

1004

}

1005

1006

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

1007

{

1008

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

1009

"PREF", "WORK", "HOME" ) );

1010

1011

// add address

1012

int type;

1013

if( types.contains( "WORK" ) )

1014

type = TYPE_WORK;

1015

else

1016

type = TYPE_HOME;

1017

1018

addAddress( unescapeValue( value ), type );

1019

}

1020

1021

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

1022

{

1023

addNote( unescapeValue( value ) );

876

1024

}

877

1025

878

1026

public void finaliseVcard()

879

1027

throws ParseException, ContactNotIdentifiableException

880

1028

{

881

1029

// missing version (and data is present)

882

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

1030

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

883

1031

throw new ParseException( R.string.error_vcf_malformed );

884

1032

885

1033

// finalise the parent class

886

1034

finalise();

887

1035

}

888

1036

1037

/**

1038

* Amongst the params, find the value of the first, only, of any with

1039

* the specified name

1040

* @param params

1041

* @param name

1042

* @return a value, or null

1043

*/

889

1044

private String checkParam( String[] params, String name )

890

1045

{

1046

String[] res = checkParams( params, name );

1047

return res.length > 0? res[ 0 ] : null;

1048

}

1049

1050

/**

1051

* Amongst the params, find the values of any with the specified name

1052

* @param params

1053

* @param name

1054

* @return an array of values, or null

1055

*/

1056

private String[] checkParams( String[] params, String name )

1057

{

1058

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

1059

891

1060

Pattern p = Pattern.compile(

892

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

1061

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

1062

Pattern.CASE_INSENSITIVE );

893

1063

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

894

1064

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

895

1065

if( m.matches() )

896

return m.group( 2 );

1066

ret.add( m.group( 2 ) );

897

1067

}

898

return null;

1068

1069

return (String[]) ret.toArray( new String[ ret.size() ] );

899

1070

}

900

1071

1072

/**

1073

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

1074

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

1075

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

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

1078

* @return a set of present type values

1079

*/

901

1080

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

902

1081

List< String > valid_types )

903

1082

{

904

1083

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

905

1084

906

1085

// get 3.0-style TYPE= param

907

String type_param;

908

if( ( type_param = checkParam( params, "TYPE" ) ) != null ) {

909

String[] parts = type_param.split( "," );

910

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

911

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

912

types.add( parts[ i ] );

1086

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

1087

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

1088

{

1089

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

1090

// this is in the specs!)

1091

String[] parts = type_params[ a ].split( "," );

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

}

913

1097

}

914

1098

915

1099

// get 2.1-style type param

916

1100

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

917

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

918

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

919

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

}

920

1106

}

921

1107

922

1108

return types;