/android/import-contacts : revision 50

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;

42

41

import java.util.NoSuchElementException;

43

42

import java.util.Set;

44

43

import java.util.Vector;

46

45

import java.util.regex.Pattern;

47

46

48

47

import android.content.SharedPreferences;

49

import android.os.Environment;

48

import android.provider.Contacts;

49

import android.provider.Contacts.PhonesColumns;

50

51

public class VcardImporter extends Importer

52

{

70

File[] files = null;

71

try

72

{

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

73

// open directory

82

File file = new File( Environment.getExternalStorageDirectory(),

83

prefs.getString( "location", "/" ) );

74

String path = "/sdcard" + prefs.getString( "location", "/" );

75

File file = new File( path );

84

76

if( !file.exists() )

85

77

showError( R.string.error_locationnotfound );

86

78

90

82

// get files

91

83

class VCardFilter implements FilenameFilter {

92

84

public boolean accept( File dir, String name ) {

93

return name.toLowerCase( Locale.ENGLISH )

94

.endsWith( ".vcf" );

85

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

95

86

}

96

87

}

97

88

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

141

132

boolean in_vcard = false;

142

133

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

143

134

{

144

if( !in_vcard )

145

{

135

if( !in_vcard ) {

146

136

// look for vcard beginning

147

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

137

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

148

138

in_vcard = true;

149

139

_vcard_count++;

150

140

}

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

155

}

156

141

}

157

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

142

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

158

143

in_vcard = false;

159

144

}

160

reader.close();

161

145

162

146

}

163

147

catch( FileNotFoundException e ) {

185

169

FileInputStream istream = new FileInputStream( file );

186

170

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

187

171

istream.read( content );

188

istream.close();

172

istream = null;

189

173

190

174

// import

191

175

importVCardFileContent( content, file.getName() );

192

176

}

193

catch( OutOfMemoryError e ) {

194

showError( R.string.error_outofmemory );

195

}

196

177

catch( FileNotFoundException e ) {

197

178

showError( getText( R.string.error_filenotfound ) +

198

179

file.getName() );

211

192

ContentLineIterator cli = new ContentLineIterator( content );

212

193

while( cli.hasNext() )

213

194

{

214

ContentLine content_line = cli.next();

195

ByteBuffer buffer = cli.next();

215

196

216

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

217

String line = content_line.getUsAsciiLine();

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

}

218

207

219

208

if( vcard == null ) {

220

209

// look for vcard beginning

221

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

210

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

222

211

setProgress( _progress++ );

223

212

vcard = new Vcard();

224

213

vcard_start_line = cli.getLineNumber();

226

215

}

227

216

else {

228

217

// look for vcard content or ending

229

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

218

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

230

219

{

231

220

// finalise the vcard/contact

232

221

try {

236

225

importContact( vcard );

237

226

}

238

227

catch( Vcard.ParseException e ) {

239

showContinueOrAbort(

228

if( !showContinue(

240

229

getText( R.string.error_vcf_parse ).toString()

241

230

+ fileName +

242

231

getText( R.string.error_vcf_parse_line ).toString()

243

+ cli.getLineNumber() + ":\n" + e.getMessage() );

244

skipContact();

232

+ cli.getLineNumber() + ":\n" + e.getMessage() ) )

233

{

234

finish( ACTION_ABORT );

235

}

236

else

237

skipContact();

245

238

}

246

239

catch( ContactData.ContactNotIdentifiableException e ) {

247

showContinueOrAbort(

240

if( !showContinue(

248

241

getText( R.string.error_vcf_parse ).toString()

249

242

+ fileName +

250

243

getText( R.string.error_vcf_parse_line ).toString()

251

244

+ vcard_start_line + ":\n" + getText(

252

R.string.error_vcf_notenoughinfo ).toString() );

253

skipContact();

245

R.string.error_vcf_notenoughinfo ).toString()

246

) )

247

{

248

finish( ACTION_ABORT );

249

}

250

else

251

skipContact();

254

252

}

255

253

256

254

// discard this vcard

260

258

{

261

259

// try giving the line to the vcard

262

260

try {

263

vcard.parseLine( content_line );

261

vcard.parseLine( buffer, line,

262

cli.doesNextLineLookFolded() );

264

263

}

265

264

catch( Vcard.ParseException e ) {

266

265

skipContact();

267

showContinueOrAbort(

266

if( !showContinue(

268

267

getText( R.string.error_vcf_parse ).toString()

269

268

+ fileName +

270

269

getText( R.string.error_vcf_parse_line ).toString()

271

+ cli.getLineNumber() + "\n" + e.getMessage() );

270

+ cli.getLineNumber() + "\n" + e.getMessage() ) )

271

{

272

finish( ACTION_ABORT );

273

}

272

274

273

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

274

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

275

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

276

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

275

277

// get to another BEGIN:VCARD line.

276

278

vcard = null;

277

279

}

278

280

catch( Vcard.SkipImportException e ) {

279

281

skipContact();

280

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

282

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

281

283

// we get to another BEGIN:VCARD line.

282

284

vcard = null;

283

285

}

286

288

}

287

289

}

288

290

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 >

291

class ContentLineIterator implements Iterator< ByteBuffer >

332

292

{

333

293

protected byte[] _content = null;

334

294

protected int _pos = 0;

346

306

}

347

307

348

308

@Override

349

public ContentLine next()

309

public ByteBuffer next()

350

310

{

351

311

int initial_pos = _pos;

352

312

359

319

_pos > initial_pos )? _pos - 1 : _pos;

360

320

_pos++;

361

321

_line++;

362

return new ContentLine(

363

ByteBuffer.wrap( _content, initial_pos,

364

to - initial_pos ),

365

doesNextLineLookFolded() );

322

return ByteBuffer.wrap( _content, initial_pos,

323

to - initial_pos );

366

324

}

367

325

368

326

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

370

328

int to = _pos;

371

329

_pos++;

372

330

_line++;

373

return new ContentLine(

374

ByteBuffer.wrap( _content, initial_pos,

375

to - initial_pos ),

376

doesNextLineLookFolded() );

331

return ByteBuffer.wrap( _content, initial_pos,

332

to - initial_pos );

377

333

}

378

334

379

335

// no bytes left

391

347

* onto the end of this one?

392

348

* @return

393

349

*/

394

private boolean doesNextLineLookFolded()

350

public boolean doesNextLineLookFolded()

395

351

{

396

352

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

397

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

398

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

353

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

399

354

}

400

355

401

356

public int getLineNumber()

413

368

private final static int MULTILINE_NONE = 0;

414

369

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

415

370

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

416

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

371

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

417

372

418

373

private String _version = null;

419

private Vector< ContentLine > _content_lines = null;

374

private Vector< ByteBuffer > _buffers = null;

420

375

private int _name_level = NAMELEVEL_NONE;

421

376

private int _parser_multiline_state = MULTILINE_NONE;

422

377

private String _parser_current_name_and_params = null;

465

420

@SuppressWarnings("serial")

466

421

protected class SkipImportException extends Exception { }

467

422

468

private String extractCollonPartFromLine( ContentLine content_line,

469

boolean former )

423

private String extractCollonPartFromLine( ByteBuffer buffer,

424

String line, boolean former )

470

425

{

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

471

441

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

472

442

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

473

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

443

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

474

444

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 )

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 )

491

463

throws ParseException, SkipImportException,

492

464

AbortImportException

493

465

{

496

468

{

497

469

// tentatively get name and params from line

498

470

String name_and_params =

499

extractNameAndParamsFromLine( content_line );

471

extractNameAndParamsFromLine( buffer, line );

500

472

501

473

// is it a version line?

502

474

if( name_and_params != null &&

503

name_and_params.equalsIgnoreCase( "VERSION" ) )

475

name_and_params.equals( "VERSION" ) )

504

476

{

505

477

// yes, get it!

506

String value = extractValueFromLine( content_line );

507

if( value == null || (

508

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

509

{

478

String value = extractValueFromLine( buffer, line );

479

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

510

480

throw new ParseException( R.string.error_vcf_version );

511

}

512

481

_version = value;

513

482

514

483

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

515

484

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

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

493

}

521

494

else

522

495

{

523

496

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

497

if( _buffers == null )

498

_buffers = new Vector< ByteBuffer >();

499

_buffers.add( buffer );

527

500

}

528

501

}

529

502

else

530

503

{

531

504

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

532

// "value" part of the line starts

505

// "value" part of the line start

533

506

String name_and_params;

534

507

int pos;

535

508

541

514

542

515

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

543

516

// of multi-line we're handling

544

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

517

pos = buffer.position();

545

518

switch( _parser_multiline_state )

546

519

{

547

520

case MULTILINE_FOLDED:

548

521

pos++;

549

522

break;

550

523

case MULTILINE_ENCODED:

551

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

552

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

553

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

524

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

525

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

526

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

554

527

{

555

528

pos++;

556

529

}

565

538

}

566

539

else

567

540

{

568

// skip empty lines

569

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

570

return;

571

572

541

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

573

542

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

574

543

// not fail, or it's an error

575

544

name_and_params =

576

extractNameAndParamsFromLine( content_line );

545

extractNameAndParamsFromLine( buffer, line );

577

546

if( name_and_params == null )

578

547

throw new ParseException(

579

548

R.string.error_vcf_malformed );

580

549

581

550

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

582

551

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

583

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

584

name_and_params.length() + 1;

552

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

585

553

586

554

// reset the saved multi-line state

587

555

_parser_current_name_and_params = name_and_params;

590

558

591

559

// get value from buffer, as raw bytes

592

560

ByteBuffer value;

593

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

594

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

561

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

562

buffer.limit() - pos );

595

563

596

564

// get parameter parts

597

565

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

604

572

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

605

573

) );

606

574

boolean is_interesting_field =

607

interesting_fields.contains(

608

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

575

interesting_fields.contains( name_param_parts[ 0 ] );

609

576

610

577

// parse encoding parameter

611

578

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

612

if( encoding != null )

613

encoding = encoding.toUpperCase( Locale.ENGLISH );

579

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

614

580

if( is_interesting_field && encoding != null &&

615

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

616

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

617

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

581

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

582

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

583

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

618

584

{

619

585

throw new ParseException( R.string.error_vcf_encoding );

620

586

}

621

587

622

588

// parse charset parameter

623

589

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

624

if( charset != null )

625

charset = charset.toUpperCase( Locale.ENGLISH );

590

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

626

591

if( charset != null &&

627

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

628

!charset.equalsIgnoreCase( "ASCII" ) &&

629

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

592

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

593

!charset.equals( "ASCII" ) &&

594

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

630

595

{

631

596

throw new ParseException( R.string.error_vcf_charset );

632

597

}

634

599

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

635

600

// the raw string)

636

601

UnencodeResult unencoding_result = null;

637

if( encoding != null &&

638

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

639

{

602

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

640

603

unencoding_result = unencodeQuotedPrintable( value );

641

}

642

// else if( encoding != null &&

643

// encoding.equalsIgnoreCase( "BASE64" ) )

644

// {

604

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

645

605

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

646

// }

647

606

if( unencoding_result != null ) {

648

607

value = unencoding_result.getBuffer();

649

608

if( unencoding_result.isAnotherLineRequired() )

654

613

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

655

614

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

656

615

( charset != null && (

657

charset.equalsIgnoreCase( "ASCII" ) ||

658

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

616

charset.equals( "ASCII" ) ||

617

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

659

618

{

660

619

value = transcodeAsciiToUtf8( value );

661

620

}

672

631

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

673

632

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

674

633

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

634

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

635

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

636

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

678

637

doesStringEndInAnEscapeChar( string_value ) )

679

638

{

680

639

_parser_multiline_state = MULTILINE_ESCAPED;

682

641

string_value.length() - 1 );

683

642

}

684

643

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

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

687

646

if( _parser_multiline_state == MULTILINE_NONE &&

688

content_line.doesNextLineLookFolded() )

647

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

689

648

{

690

649

_parser_multiline_state = MULTILINE_FOLDED;

691

650

}

703

662

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

704

663

705

664

// parse some properties

706

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

665

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

707

666

parseN( name_param_parts, complete_value );

708

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

667

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

709

668

parseFN( name_param_parts, complete_value );

710

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

669

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

711

670

parseORG( name_param_parts, complete_value );

712

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

671

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

713

672

parseTITLE( name_param_parts, complete_value );

714

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

673

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

715

674

parseTEL( name_param_parts, complete_value );

716

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

675

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

717

676

parseEMAIL( name_param_parts, complete_value );

718

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

677

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

719

678

parseADR( name_param_parts, complete_value );

720

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

679

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

721

680

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

681

}

727

682

}

728

683

752

707

{

753

708

String str = parts.get( a );

754

709

755

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

756

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

710

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

711

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

757

712

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

758

713

// accordingly.

759

714

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

800

755

in_escape = false;

801

756

switch( c )

802

757

{

803

case 'T':

804

case 't':

805

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

806

ret.append( '\t' );

807

break;

808

758

case 'N':

809

759

case 'n':

810

760

// add newline

818

768

break;

819

769

default:

820

770

// unknown escape sequence, so add it unescaped

821

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

822

771

ret.append( "\\" );

823

772

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

824

773

break;

849

798

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

850

799

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

851

800

{

852

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

801

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

853

802

value += name_part_parts[ b ];

854

803

}

855

804

}

930

879

int type;

931

880

if( types.contains( "FAX" ) )

932

881

if( types.contains( "HOME" ) )

933

type = TYPE_FAX_HOME;

882

type = PhonesColumns.TYPE_FAX_HOME;

934

883

else

935

type = TYPE_FAX_WORK;

884

type = PhonesColumns.TYPE_FAX_WORK;

936

885

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

937

type = TYPE_MOBILE;

886

type = PhonesColumns.TYPE_MOBILE;

938

887

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

939

type = TYPE_PAGER;

888

type = PhonesColumns.TYPE_PAGER;

940

889

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

941

type = TYPE_WORK;

890

type = PhonesColumns.TYPE_WORK;

942

891

else

943

type = TYPE_HOME;

892

type = PhonesColumns.TYPE_HOME;

944

893

945

894

// add phone number

946

895

addNumber( value, type, is_preferred );

957

906

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

958

907

int type;

959

908

if( types.contains( "WORK" ) )

960

type = TYPE_WORK;

909

type = Contacts.ContactMethods.TYPE_WORK;

961

910

else

962

type = TYPE_HOME;

911

type = Contacts.ContactMethods.TYPE_HOME;

963

912

964

913

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

965

914

}

974

923

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

975

924

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

976

925

{

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

}

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

}

997

935

}

998

936

999

937

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

1002

940

// add address

1003

941

int type;

1004

942

if( types.contains( "WORK" ) )

1005

type = TYPE_WORK;

943

type = Contacts.ContactMethods.TYPE_WORK;

1006

944

else

1007

type = TYPE_HOME;

945

type = Contacts.ContactMethods.TYPE_HOME;

1008

946

1009

947

addAddress( unescapeValue( value ), type );

1010

948

}

1017

955

// add address

1018

956

int type;

1019

957

if( types.contains( "WORK" ) )

1020

type = TYPE_WORK;

958

type = Contacts.ContactMethods.TYPE_WORK;

1021

959

else

1022

type = TYPE_HOME;

960

type = Contacts.ContactMethods.TYPE_HOME;

1023

961

1024

962

addAddress( unescapeValue( value ), type );

1025

963

}

1026

964

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

965

public void finaliseVcard()

1038

966

throws ParseException, ContactNotIdentifiableException

1039

967

{

1040

968

// missing version (and data is present)

1041

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

969

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

1042

970

throw new ParseException( R.string.error_vcf_malformed );

1043

971

1044

972

// finalise the parent class

1047

975

1048

976

/**

1049

977

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

1050

* the specified name.

1051

*

978

* the specified name

1052

979

* @param params

1053

980

* @param name

1054

981

* @return a value, or null

1060

987

}

1061

988

1062

989

/**

1063

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

1064

*

990

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

1065

991

* @param params

1066

992

* @param name

1067

993

* @return an array of values, or null

1071

997

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

1072

998

1073

999

Pattern p = Pattern.compile(

1074

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

1075

Pattern.CASE_INSENSITIVE );

1000

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

1076

1001

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

1077

1002

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

1078

1003

if( m.matches() )

1083

1008

}

1084

1009

1085

1010

/**

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

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

1092

1016

* @return a set of present type values

1093

1017

*/

1094

1018

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

1100

1024

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

1101

1025

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

1102

1026

{

1103

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

1104

// this is in the specs!)

1027

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

1028

// the specs!)

1105

1029

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

}

1030

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

1031

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

1032

types.add( parts[ i ] );

1111

1033

}

1112

1034

1113

1035

// get 2.1-style type param

1114

1036

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

}

1037

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

1038

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

1039

types.add( params[ i ] );

1120

1040

}

1121

1041

1122

1042

return types;

1144

1064

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

1145

1065

{

1146

1066

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

1147

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

1067

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

1148

1068

another = true;

1149

1069

continue;

1150

1070

}