/android/import-contacts : revision 102

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

7

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

8

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

9

*

10

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

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

132

133

boolean in_vcard = false;

133

134

while( ( line = reader.readLine() ) != null )

134

135

{

135

if( !in_vcard ) {

136

if( !in_vcard )

137

{

136

138

// look for vcard beginning

137

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

139

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

138

140

in_vcard = true;

139

141

_vcard_count++;

140

142

}

143

// check for vMsg files

144

else if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VMSG.*" ) ) {

145

showError( getText( R.string.error_vcf_vmsgfile )

146

+ file.getName() );

147

}

141

148

}

142

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

149

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

143

150

in_vcard = false;

144

151

}

152

reader.close();

145

153

146

154

}

147

155

catch( FileNotFoundException e ) {

169

177

FileInputStream istream = new FileInputStream( file );

170

178

byte[] content = new byte[ (int)file.length() ];

171

179

istream.read( content );

172

istream = null;

180

istream.close();

173

181

174

182

// import

175

183

importVCardFileContent( content, file.getName() );

176

184

}

185

catch( OutOfMemoryError e ) {

186

showError( R.string.error_outofmemory );

187

}

177

188

catch( FileNotFoundException e ) {

178

189

showError( getText( R.string.error_filenotfound ) +

179

190

file.getName() );

192

203

ContentLineIterator cli = new ContentLineIterator( content );

193

204

while( cli.hasNext() )

194

205

{

195

ByteBuffer buffer = cli.next();

206

ContentLine content_line = cli.next();

196

207

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

}

208

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

209

String line = content_line.getUsAsciiLine();

207

210

208

211

if( vcard == null ) {

209

212

// look for vcard beginning

210

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

213

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

211

214

setProgress( _progress++ );

212

215

vcard = new Vcard();

213

216

vcard_start_line = cli.getLineNumber();

215

218

}

216

219

else {

217

220

// look for vcard content or ending

218

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

221

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

219

222

{

220

223

// finalise the vcard/contact

221

224

try {

258

261

{

259

262

// try giving the line to the vcard

260

263

try {

261

vcard.parseLine( buffer, line,

262

cli.doesNextLineLookFolded() );

264

vcard.parseLine( content_line );

263

265

}

264

266

catch( Vcard.ParseException e ) {

265

267

skipContact();

272

274

finish( ACTION_ABORT );

273

275

}

274

276

275

// although we're continuing, we still need to abort

276

// this vCard. Further lines will be ignored until we

277

// Although we're continuing, we still need to abort

278

// this vCard. Further lines will be ignored until we

277

279

// get to another BEGIN:VCARD line.

278

280

vcard = null;

279

281

}

280

282

catch( Vcard.SkipImportException e ) {

281

283

skipContact();

282

// abort this vCard. Further lines will be ignored until

284

// Abort this vCard. Further lines will be ignored until

283

285

// we get to another BEGIN:VCARD line.

284

286

vcard = null;

285

287

}

288

290

}

289

291

}

290

292

291

class ContentLineIterator implements Iterator< ByteBuffer >

293

class ContentLine

294

{

295

private ByteBuffer _buffer;

296

private boolean _folded_next;

297

private String _line;

298

299

public ContentLine( ByteBuffer buffer, boolean folded_next )

300

{

301

_buffer = buffer;

302

_folded_next = folded_next;

303

_line = null;

304

}

305

306

public ByteBuffer getBuffer()

307

{

308

return _buffer;

309

}

310

311

public boolean doesNextLineLookFolded()

312

{

313

return _folded_next;

314

}

315

316

public String getUsAsciiLine()

317

{

318

// generated line and cache it

319

if( _line == null ) {

320

try {

321

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

322

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

323

}

324

catch( UnsupportedEncodingException e ) {

325

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

326

// compiler...

327

}

328

}

329

330

// return cached line

331

return _line;

332

}

333

}

334

335

class ContentLineIterator implements Iterator< ContentLine >

292

336

{

293

337

protected byte[] _content = null;

294

338

protected int _pos = 0;

306

350

}

307

351

308

352

@Override

309

public ByteBuffer next()

353

public ContentLine next()

310

354

{

311

355

int initial_pos = _pos;

312

356

319

363

_pos > initial_pos )? _pos - 1 : _pos;

320

364

_pos++;

321

365

_line++;

322

return ByteBuffer.wrap( _content, initial_pos,

323

to - initial_pos );

366

return new ContentLine(

367

ByteBuffer.wrap( _content, initial_pos,

368

to - initial_pos ),

369

doesNextLineLookFolded() );

324

370

}

325

371

326

372

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

328

374

int to = _pos;

329

375

_pos++;

330

376

_line++;

331

return ByteBuffer.wrap( _content, initial_pos,

332

to - initial_pos );

377

return new ContentLine(

378

ByteBuffer.wrap( _content, initial_pos,

379

to - initial_pos ),

380

doesNextLineLookFolded() );

333

381

}

334

382

335

383

// no bytes left

347

395

* onto the end of this one?

348

396

* @return

349

397

*/

350

public boolean doesNextLineLookFolded()

398

private boolean doesNextLineLookFolded()

351

399

{

352

400

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

353

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

401

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

402

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

354

403

}

355

404

356

405

public int getLineNumber()

368

417

private final static int MULTILINE_NONE = 0;

369

418

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

370

419

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

371

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

420

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

372

421

373

422

private String _version = null;

374

private Vector< ByteBuffer > _buffers = null;

423

private Vector< ContentLine > _content_lines = null;

375

424

private int _name_level = NAMELEVEL_NONE;

376

425

private int _parser_multiline_state = MULTILINE_NONE;

377

426

private String _parser_current_name_and_params = null;

420

469

@SuppressWarnings("serial")

421

470

protected class SkipImportException extends Exception { }

422

471

423

private String extractCollonPartFromLine( ByteBuffer buffer,

424

String line, boolean former )

472

private String extractCollonPartFromLine( ContentLine content_line,

473

boolean former )

425

474

{

426

String ret = null;

427

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

475

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

442

476

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

443

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

477

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

444

478

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

445

ret = parts[ former? 0 : 1 ];

446

447

return ret;

448

}

449

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

return parts[ former? 0 : 1 ].trim();

480

481

return null;

482

}

483

484

private String extractNameAndParamsFromLine( ContentLine content_line )

485

{

486

return extractCollonPartFromLine( content_line, true );

487

}

488

489

private String extractValueFromLine( ContentLine content_line )

490

{

491

return extractCollonPartFromLine( content_line, false );

492

}

493

494

public void parseLine( ContentLine content_line )

463

495

throws ParseException, SkipImportException,

464

496

AbortImportException

465

497

{

468

500

{

469

501

// tentatively get name and params from line

470

502

String name_and_params =

471

extractNameAndParamsFromLine( buffer, line );

503

extractNameAndParamsFromLine( content_line );

472

504

473

505

// is it a version line?

474

506

if( name_and_params != null &&

475

name_and_params.equals( "VERSION" ) )

507

name_and_params.equalsIgnoreCase( "VERSION" ) )

476

508

{

477

509

// yes, get it!

478

String value = extractValueFromLine( buffer, line );

479

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

510

String value = extractValueFromLine( content_line );

511

if( value == null || (

512

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

513

{

480

514

throw new ParseException( R.string.error_vcf_version );

515

}

481

516

_version = value;

482

517

483

518

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

484

519

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

520

if( _content_lines != null )

521

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

522

parseLine( _content_lines.get( i ) );

523

_content_lines = null;

493

524

}

494

525

else

495

526

{

496

527

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

497

if( _buffers == null )

498

_buffers = new Vector< ByteBuffer >();

499

_buffers.add( buffer );

528

if( _content_lines == null )

529

_content_lines = new Vector< ContentLine >();

530

_content_lines.add( content_line );

500

531

}

501

532

}

502

533

else

503

534

{

504

535

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

505

// "value" part of the line start

536

// "value" part of the line starts

506

537

String name_and_params;

507

538

int pos;

508

539

514

545

515

546

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

516

547

// of multi-line we're handling

517

pos = buffer.position();

548

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

518

549

switch( _parser_multiline_state )

519

550

{

520

551

case MULTILINE_FOLDED:

521

552

pos++;

522

553

break;

523

554

case MULTILINE_ENCODED:

524

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

525

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

526

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

555

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

556

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

557

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

527

558

{

528

559

pos++;

529

560

}

538

569

}

539

570

else

540

571

{

572

// skip empty lines

573

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

574

return;

575

541

576

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

542

577

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

543

578

// not fail, or it's an error

544

579

name_and_params =

545

extractNameAndParamsFromLine( buffer, line );

580

extractNameAndParamsFromLine( content_line );

546

581

if( name_and_params == null )

547

582

throw new ParseException(

548

583

R.string.error_vcf_malformed );

549

584

550

585

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

551

586

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

552

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

587

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

588

name_and_params.length() + 1;

553

589

554

590

// reset the saved multi-line state

555

591

_parser_current_name_and_params = name_and_params;

558

594

559

595

// get value from buffer, as raw bytes

560

596

ByteBuffer value;

561

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

562

buffer.limit() - pos );

597

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

598

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

563

599

564

600

// get parameter parts

565

601

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

572

608

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

573

609

) );

574

610

boolean is_interesting_field =

575

interesting_fields.contains( name_param_parts[ 0 ] );

611

interesting_fields.contains(

612

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

576

613

577

614

// parse encoding parameter

578

615

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

579

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

616

if( encoding != null )

617

encoding = encoding.toUpperCase( Locale.US );

580

618

if( is_interesting_field && encoding != null &&

581

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

582

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

583

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

619

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

620

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

621

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

584

622

{

585

623

throw new ParseException( R.string.error_vcf_encoding );

586

624

}

587

625

588

626

// parse charset parameter

589

627

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

590

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

628

if( charset != null )

629

charset = charset.toUpperCase( Locale.US );

591

630

if( charset != null &&

592

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

593

!charset.equals( "ASCII" ) &&

594

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

631

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

632

!charset.equalsIgnoreCase( "ASCII" ) &&

633

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

595

634

{

596

635

throw new ParseException( R.string.error_vcf_charset );

597

636

}

599

638

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

600

639

// the raw string)

601

640

UnencodeResult unencoding_result = null;

602

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

641

if( encoding != null &&

642

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

643

{

603

644

unencoding_result = unencodeQuotedPrintable( value );

604

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

645

}

646

// else if( encoding != null &&

647

// encoding.equalsIgnoreCase( "BASE64" ) )

648

// {

605

649

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

650

// }

606

651

if( unencoding_result != null ) {

607

652

value = unencoding_result.getBuffer();

608

653

if( unencoding_result.isAnotherLineRequired() )

613

658

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

614

659

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

615

660

( charset != null && (

616

charset.equals( "ASCII" ) ||

617

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

661

charset.equalsIgnoreCase( "ASCII" ) ||

662

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

618

663

{

619

664

value = transcodeAsciiToUtf8( value );

620

665

}

631

676

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

632

677

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

633

678

// indicates that we have a multi-line value

634

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

635

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

636

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

679

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

680

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

681

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

637

682

doesStringEndInAnEscapeChar( string_value ) )

638

683

{

639

684

_parser_multiline_state = MULTILINE_ESCAPED;

641

686

string_value.length() - 1 );

642

687

}

643

688

644

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

645

// determine if we're in a v3 folded multi-line or not

689

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

690

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

646

691

if( _parser_multiline_state == MULTILINE_NONE &&

647

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

692

content_line.doesNextLineLookFolded() )

648

693

{

649

694

_parser_multiline_state = MULTILINE_FOLDED;

650

695

}

662

707

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

663

708

664

709

// parse some properties

665

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

710

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

666

711

parseN( name_param_parts, complete_value );

667

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

712

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

668

713

parseFN( name_param_parts, complete_value );

669

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

714

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

670

715

parseORG( name_param_parts, complete_value );

671

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

716

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

672

717

parseTITLE( name_param_parts, complete_value );

673

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

718

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

674

719

parseTEL( name_param_parts, complete_value );

675

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

720

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

676

721

parseEMAIL( name_param_parts, complete_value );

677

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

722

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

678

723

parseADR( name_param_parts, complete_value );

679

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

724

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

680

725

parseLABEL( name_param_parts, complete_value );

726

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

727

parseNOTE( name_param_parts, complete_value );

728

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

729

parseBDAY( name_param_parts, complete_value );

681

730

}

682

731

}

683

732

707

756

{

708

757

String str = parts.get( a );

709

758

710

// look for parts that end in an escape character, but ignore

711

// the final part. We've already detected escape chars at the

759

// Look for parts that end in an escape character, but ignore

760

// the final part. We've already detected escape chars at the

712

761

// end of the final part in parseLine() and handled multi-lines

713

762

// accordingly.

714

763

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

755

804

in_escape = false;

756

805

switch( c )

757

806

{

807

case 'T':

808

case 't':

809

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

810

ret.append( '\t' );

811

break;

758

812

case 'N':

759

813

case 'n':

760

814

// add newline

768

822

break;

769

823

default:

770

824

// unknown escape sequence, so add it unescaped

825

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

771

826

ret.append( "\\" );

772

827

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

773

828

break;

798

853

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

799

854

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

800

855

{

801

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

856

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

802

857

value += name_part_parts[ b ];

803

858

}

804

859

}

879

934

int type;

880

935

if( types.contains( "FAX" ) )

881

936

if( types.contains( "HOME" ) )

882

type = PhonesColumns.TYPE_FAX_HOME;

937

type = TYPE_FAX_HOME;

883

938

else

884

type = PhonesColumns.TYPE_FAX_WORK;

939

type = TYPE_FAX_WORK;

885

940

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

886

type = PhonesColumns.TYPE_MOBILE;

941

type = TYPE_MOBILE;

887

942

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

888

type = PhonesColumns.TYPE_PAGER;

943

type = TYPE_PAGER;

889

944

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

890

type = PhonesColumns.TYPE_WORK;

945

type = TYPE_WORK;

891

946

else

892

type = PhonesColumns.TYPE_HOME;

947

type = TYPE_HOME;

893

948

894

949

// add phone number

895

950

addNumber( value, type, is_preferred );

906

961

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

907

962

int type;

908

963

if( types.contains( "WORK" ) )

909

type = Contacts.ContactMethods.TYPE_WORK;

964

type = TYPE_WORK;

910

965

else

911

type = Contacts.ContactMethods.TYPE_HOME;

966

type = TYPE_HOME;

912

967

913

968

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

914

969

}

923

978

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

924

979

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

925

980

{

926

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

927

String[] adr_part_parts =

928

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

929

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

930

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

931

{

932

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

933

value += adr_part_parts[ b ];

934

}

981

// version 3.0 vCards allow further splitting by comma

982

if( _version.equals( "3.0" ) )

983

{

984

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

985

// add them on individual lines

986

String[] adr_part_parts =

987

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

988

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

989

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

990

{

991

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

992

value += adr_part_parts[ b ];

993

}

994

}

995

else

996

{

997

// add this part on an individual line

998

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

999

value += adr_parts[ a ];

1000

}

935

1001

}

936

1002

937

1003

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

940

1006

// add address

941

1007

int type;

942

1008

if( types.contains( "WORK" ) )

943

type = Contacts.ContactMethods.TYPE_WORK;

1009

type = TYPE_WORK;

944

1010

else

945

type = Contacts.ContactMethods.TYPE_HOME;

1011

type = TYPE_HOME;

946

1012

947

1013

addAddress( unescapeValue( value ), type );

948

1014

}

955

1021

// add address

956

1022

int type;

957

1023

if( types.contains( "WORK" ) )

958

type = Contacts.ContactMethods.TYPE_WORK;

1024

type = TYPE_WORK;

959

1025

else

960

type = Contacts.ContactMethods.TYPE_HOME;

1026

type = TYPE_HOME;

961

1027

962

1028

addAddress( unescapeValue( value ), type );

963

1029

}

964

1030

1031

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

1032

{

1033

addNote( unescapeValue( value ) );

1034

}

1035

1036

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

1037

{

1038

setBirthday( value );

1039

}

1040

965

1041

public void finaliseVcard()

966

1042

throws ParseException, ContactNotIdentifiableException

967

1043

{

968

1044

// missing version (and data is present)

969

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

1045

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

970

1046

throw new ParseException( R.string.error_vcf_malformed );

971

1047

972

1048

// finalise the parent class

975

1051

976

1052

/**

977

1053

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

978

* the specified name

1054

* the specified name.

1055

*

979

1056

* @param params

980

1057

* @param name

981

1058

* @return a value, or null

987

1064

}

988

1065

989

1066

/**

990

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

1067

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

1068

*

991

1069

* @param params

992

1070

* @param name

993

1071

* @return an array of values, or null

997

1075

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

998

1076

999

1077

Pattern p = Pattern.compile(

1000

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

1078

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

1079

Pattern.CASE_INSENSITIVE );

1001

1080

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

1002

1081

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

1003

1082

if( m.matches() )

1008

1087

}

1009

1088

1010

1089

/**

1011

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

1012

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

1013

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

1014

* @param params

1015

* @param a list of type values to look for

1090

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

1091

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

1092

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

1093

*

1094

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

1095

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

1016

1096

* @return a set of present type values

1017

1097

*/

1018

1098

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

1024

1104

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

1025

1105

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

1026

1106

{

1027

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

1028

// the specs!)

1107

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

1108

// this is in the specs!)

1029

1109

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

1030

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

1031

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

1032

types.add( parts[ i ] );

1110

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

1111

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

1112

if( valid_types.contains( ucpart ) )

1113

types.add( ucpart );

1114

}

1033

1115

}

1034

1116

1035

1117

// get 2.1-style type param

1036

1118

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

1037

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

1038

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

1039

types.add( params[ i ] );

1119

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

1120

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

1121

if( valid_types.contains( ucparam ) )

1122

types.add( ucparam );

1123

}

1040

1124

}

1041

1125

1042

1126

return types;

1064

1148

else if( ch == '=' && i == in.limit() - 1 )

1065

1149

{

1066

1150

// we found a '=' at the end of a line signifying a multi-

1067

// line string, so we don't add it.

1151

// line string, so we don't add it

1068

1152

another = true;

1069

1153

continue;

1070

1154

}