/android/import-contacts : revision 42

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://ed.am/dev/android/import-contacts

7

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

8

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

9

*

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 am.ed.importcontacts;

24

package org.waxworlds.edam.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;

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.US ).endsWith( ".vcf" );

85

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

94

86

}

95

87

}

96

88

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

124

116

setProgress( 0 );

125

117

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

126

118

importVCardFile( files[ i ] );

127

setProgress( _vcard_count );

128

119

}

129

120

130

121

private void countVCardFile( File file ) throws AbortImportException

140

131

boolean in_vcard = false;

141

132

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

142

133

{

143

if( !in_vcard )

144

{

134

if( !in_vcard ) {

145

135

// look for vcard beginning

146

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

136

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

147

137

in_vcard = true;

148

138

_vcard_count++;

149

139

}

150

// check for vMsg files

151

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

152

showError( getText( R.string.error_vcf_vmsgfile )

153

+ file.getName() );

154

}

155

140

}

156

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

141

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

157

142

in_vcard = false;

158

143

}

159

reader.close();

160

144

161

145

}

162

146

catch( FileNotFoundException e ) {

184

168

FileInputStream istream = new FileInputStream( file );

185

169

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

186

170

istream.read( content );

187

istream.close();

188

171

189

172

// import

190

173

importVCardFileContent( content, file.getName() );

191

174

}

192

catch( OutOfMemoryError e ) {

193

showError( R.string.error_outofmemory );

194

}

195

175

catch( FileNotFoundException e ) {

196

176

showError( getText( R.string.error_filenotfound ) +

197

177

file.getName() );

206

186

{

207

187

// go through lines

208

188

Vcard vcard = null;

209

int vcard_start_line = 0;

210

189

ContentLineIterator cli = new ContentLineIterator( content );

211

190

while( cli.hasNext() )

212

191

{

213

ContentLine content_line = cli.next();

192

ByteBuffer buffer = cli.next();

214

193

215

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

216

String line = content_line.getUsAsciiLine();

194

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

195

String line;

196

try {

197

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

198

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

199

}

200

catch( UnsupportedEncodingException e ) {

201

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

202

line = "";

203

}

217

204

218

205

if( vcard == null ) {

219

206

// look for vcard beginning

220

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

221

setProgress( _progress++ );

207

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

208

setProgress( ++_progress );

222

209

vcard = new Vcard();

223

vcard_start_line = cli.getLineNumber();

224

210

}

225

211

}

226

212

else {

227

213

// look for vcard content or ending

228

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

214

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

229

215

{

230

// finalise the vcard/contact

216

// store vcard and do away with it

231

217

try {

232

vcard.finaliseVcard();

233

234

// pass the finalised contact to the importer

218

vcard.finaliseParsing();

235

219

importContact( vcard );

236

220

}

237

221

catch( Vcard.ParseException e ) {

238

if( !showContinue(

239

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

240

+ fileName +

241

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

242

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

243

{

244

finish( ACTION_ABORT );

245

}

246

else

247

skipContact();

248

}

249

catch( ContactData.ContactNotIdentifiableException e ) {

250

if( !showContinue(

251

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

252

+ fileName +

253

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

254

+ vcard_start_line + ":\n" + getText(

255

R.string.error_vcf_notenoughinfo ).toString()

256

) )

257

{

258

finish( ACTION_ABORT );

259

}

260

else

261

skipContact();

262

}

263

264

// discard this vcard

222

skipContact();

223

if( !showContinue(

224

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

225

+ fileName + "\n" + e.getMessage() ) )

226

{

227

finish( ACTION_ABORT );

228

}

229

}

230

catch( Vcard.SkipContactException e ) {

231

skipContact();

232

// do nothing

233

}

265

234

vcard = null;

266

235

}

267

236

else

268

237

{

269

238

// try giving the line to the vcard

270

239

try {

271

vcard.parseLine( content_line );

240

vcard.parseLine( buffer, line,

241

cli.doesNextLineLookFolded() );

272

242

}

273

243

catch( Vcard.ParseException e ) {

274

244

skipContact();

275

245

if( !showContinue(

276

246

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

277

+ fileName +

278

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

279

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

247

+ fileName + "\n" + e.getMessage() ) )

280

248

{

281

249

finish( ACTION_ABORT );

282

250

}

283

251

284

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

285

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

252

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

253

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

286

254

// get to another BEGIN:VCARD line.

287

255

vcard = null;

288

256

}

289

catch( Vcard.SkipImportException e ) {

257

catch( Vcard.SkipContactException e ) {

290

258

skipContact();

291

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

259

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

292

260

// we get to another BEGIN:VCARD line.

293

261

vcard = null;

294

262

}

297

265

}

298

266

}

299

267

300

class ContentLine

301

{

302

private ByteBuffer _buffer;

303

private boolean _folded_next;

304

private String _line;

305

306

public ContentLine( ByteBuffer buffer, boolean folded_next )

307

{

308

_buffer = buffer;

309

_folded_next = folded_next;

310

_line = null;

311

}

312

313

public ByteBuffer getBuffer()

314

{

315

return _buffer;

316

}

317

318

public boolean doesNextLineLookFolded()

319

{

320

return _folded_next;

321

}

322

323

public String getUsAsciiLine()

324

{

325

// generated line and cache it

326

if( _line == null ) {

327

try {

328

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

329

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

330

}

331

catch( UnsupportedEncodingException e ) {

332

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

333

// compiler...

334

}

335

}

336

337

// return cached line

338

return _line;

339

}

340

}

341

342

class ContentLineIterator implements Iterator< ContentLine >

268

class ContentLineIterator implements Iterator< ByteBuffer >

343

269

{

344

270

protected byte[] _content = null;

345

271

protected int _pos = 0;

346

protected int _line = 0;

347

272

348

273

public ContentLineIterator( byte[] content )

349

274

{

357

282

}

358

283

359

284

@Override

360

public ContentLine next()

285

public ByteBuffer next()

361

286

{

362

287

int initial_pos = _pos;

363

288

369

294

int to = ( _pos > 0 && _content[ _pos - 1 ] == '\r' &&

370

295

_pos > initial_pos )? _pos - 1 : _pos;

371

296

_pos++;

372

_line++;

373

return new ContentLine(

374

ByteBuffer.wrap( _content, initial_pos,

375

to - initial_pos ),

376

doesNextLineLookFolded() );

297

return ByteBuffer.wrap( _content, initial_pos,

298

to - initial_pos );

377

299

}

378

300

379

301

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

380

302

if( _pos != initial_pos ) {

381

303

int to = _pos;

382

304

_pos++;

383

_line++;

384

return new ContentLine(

385

ByteBuffer.wrap( _content, initial_pos,

386

to - initial_pos ),

387

doesNextLineLookFolded() );

305

return ByteBuffer.wrap( _content, initial_pos,

306

to - initial_pos );

388

307

}

389

308

390

309

// no bytes left

402

321

* onto the end of this one?

403

322

* @return

404

323

*/

405

private boolean doesNextLineLookFolded()

324

public boolean doesNextLineLookFolded()

406

325

{

407

326

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

408

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

409

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

410

}

411

412

public int getLineNumber()

413

{

414

return _line;

327

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

415

328

}

416

329

}

417

330

418

331

private class Vcard extends ContactData

419

332

{

420

333

private final static int NAMELEVEL_NONE = 0;

421

private final static int NAMELEVEL_N = 1;

422

private final static int NAMELEVEL_FN = 2;

334

private final static int NAMELEVEL_FN = 1;

335

private final static int NAMELEVEL_N = 2;

423

336

424

337

private final static int MULTILINE_NONE = 0;

425

338

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

426

339

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

427

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

340

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

428

341

429

342

private String _version = null;

430

private Vector< ContentLine > _content_lines = null;

343

private Vector< ByteBuffer > _buffers = null;

431

344

private int _name_level = NAMELEVEL_NONE;

432

345

private int _parser_multiline_state = MULTILINE_NONE;

433

346

private String _parser_current_name_and_params = null;

474

387

}

475

388

476

389

@SuppressWarnings("serial")

477

protected class SkipImportException extends Exception { }

390

protected class SkipContactException extends Exception { }

478

391

479

private String extractCollonPartFromLine( ContentLine content_line,

480

boolean former )

392

private String extractCollonPartFromLine( ByteBuffer buffer,

393

String line, boolean former )

481

394

{

395

String ret = null;

396

397

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

398

// supplied with one

399

if( line == null ) {

400

try {

401

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

402

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

403

}

404

catch( UnsupportedEncodingException e ) {

405

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

406

line = "";

407

}

408

}

409

482

410

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

483

411

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

484

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

412

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

485

413

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

486

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

487

488

return null;

489

}

490

491

private String extractNameAndParamsFromLine( ContentLine content_line )

492

{

493

return extractCollonPartFromLine( content_line, true );

494

}

495

496

private String extractValueFromLine( ContentLine content_line )

497

{

498

return extractCollonPartFromLine( content_line, false );

499

}

500

501

public void parseLine( ContentLine content_line )

502

throws ParseException, SkipImportException,

414

ret = parts[ former? 0 : 1 ];

415

416

return ret;

417

}

418

419

private String extractNameAndParamsFromLine( ByteBuffer buffer,

420

String line )

421

{

422

return extractCollonPartFromLine( buffer, line, true );

423

}

424

425

private String extractValueFromLine( ByteBuffer buffer, String line )

426

{

427

return extractCollonPartFromLine( buffer, line, false );

428

}

429

430

public void parseLine( ByteBuffer buffer, String line,

431

boolean next_line_looks_folded )

432

throws ParseException, SkipContactException,

503

433

AbortImportException

504

434

{

505

435

// do we have a version yet?

507

437

{

508

438

// tentatively get name and params from line

509

439

String name_and_params =

510

extractNameAndParamsFromLine( content_line );

440

extractNameAndParamsFromLine( buffer, line );

511

441

512

442

// is it a version line?

513

443

if( name_and_params != null &&

514

name_and_params.equalsIgnoreCase( "VERSION" ) )

444

name_and_params.equals( "VERSION" ) )

515

445

{

516

446

// yes, get it!

517

String value = extractValueFromLine( content_line );

518

if( value == null || (

519

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

520

{

447

String value = extractValueFromLine( buffer, line );

448

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

521

449

throw new ParseException( R.string.error_vcf_version );

522

}

523

450

_version = value;

524

451

525

452

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

526

453

// for a version

527

if( _content_lines != null )

528

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

529

parseLine( _content_lines.get( i ) );

530

_content_lines = null;

454

if( _buffers != null )

455

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

456

parseLine( _buffers.get( i ), null,

457

i + 1 < _buffers.size() &&

458

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

459

_buffers.get( i + 1 ).get(

460

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

461

_buffers = null;

531

462

}

532

463

else

533

464

{

534

465

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

535

if( _content_lines == null )

536

_content_lines = new Vector< ContentLine >();

537

_content_lines.add( content_line );

466

if( _buffers == null )

467

_buffers = new Vector< ByteBuffer >();

468

_buffers.add( buffer );

538

469

}

539

470

}

540

471

else

541

472

{

542

473

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

543

// "value" part of the line starts

474

// "value" part of the line start

544

475

String name_and_params;

545

476

int pos;

546

477

552

483

553

484

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

554

485

// of multi-line we're handling

555

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

486

pos = buffer.position();

556

487

switch( _parser_multiline_state )

557

488

{

558

489

case MULTILINE_FOLDED:

559

490

pos++;

560

491

break;

561

492

case MULTILINE_ENCODED:

562

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

563

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

564

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

493

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

494

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

495

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

565

496

{

566

497

pos++;

567

498

}

576

507

}

577

508

else

578

509

{

579

// skip empty lines

580

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

581

return;

582

583

510

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

584

511

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

585

512

// not fail, or it's an error

586

513

name_and_params =

587

extractNameAndParamsFromLine( content_line );

514

extractNameAndParamsFromLine( buffer, line );

588

515

if( name_and_params == null )

589

516

throw new ParseException(

590

517

R.string.error_vcf_malformed );

591

518

592

519

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

593

520

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

594

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

595

name_and_params.length() + 1;

521

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

596

522

597

523

// reset the saved multi-line state

598

524

_parser_current_name_and_params = name_and_params;

601

527

602

528

// get value from buffer, as raw bytes

603

529

ByteBuffer value;

604

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

605

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

530

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

531

buffer.limit() - pos );

606

532

607

533

// get parameter parts

608

534

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

609

535

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

610

536

name_param_parts[ i ] = name_param_parts[ i ].trim();

611

537

612

// determine whether we care about this entry

613

final HashSet< String > interesting_fields =

614

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

615

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

616

) );

617

boolean is_interesting_field =

618

interesting_fields.contains(

619

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

620

621

538

// parse encoding parameter

622

539

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

623

if( encoding != null )

624

encoding = encoding.toUpperCase( Locale.US );

625

if( is_interesting_field && encoding != null &&

626

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

627

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

628

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

540

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

541

if( encoding != null && !encoding.equals( "8BIT" ) &&

542

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

543

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

629

544

{

630

545

throw new ParseException( R.string.error_vcf_encoding );

631

546

}

632

547

633

548

// parse charset parameter

634

549

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

635

if( charset != null )

636

charset = charset.toUpperCase( Locale.US );

637

if( charset != null &&

638

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

639

!charset.equalsIgnoreCase( "ASCII" ) &&

640

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

550

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

551

if( charset != null && !charset.equals( "US-ASCII" ) &&

552

!charset.equals( "ASCII" ) &&

553

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

641

554

{

642

555

throw new ParseException( R.string.error_vcf_charset );

643

556

}

645

558

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

646

559

// the raw string)

647

560

UnencodeResult unencoding_result = null;

648

if( encoding != null &&

649

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

650

{

561

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

651

562

unencoding_result = unencodeQuotedPrintable( value );

652

}

653

// else if( encoding != null &&

654

// encoding.equalsIgnoreCase( "BASE64" ) )

655

// {

563

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

656

564

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

657

// }

658

565

if( unencoding_result != null ) {

659

566

value = unencoding_result.getBuffer();

660

567

if( unencoding_result.isAnotherLineRequired() )

661

568

_parser_multiline_state = MULTILINE_ENCODED;

662

569

}

663

570

664

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

665

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

666

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

667

( charset != null && (

668

charset.equalsIgnoreCase( "ASCII" ) ||

669

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

670

{

571

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

572

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

671

573

value = transcodeAsciiToUtf8( value );

574

charset = "UTF-8";

672

575

}

673

576

674

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

577

// process charset

675

578

String string_value;

676

579

try {

677

580

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

678

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

581

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

679

582

} catch( UnsupportedEncodingException e ) {

680

583

throw new ParseException( R.string.error_vcf_charset );

681

584

}

683

586

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

684

587

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

685

588

// indicates that we have a multi-line value

686

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

687

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

688

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

589

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

590

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

591

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

689

592

doesStringEndInAnEscapeChar( string_value ) )

690

593

{

691

594

_parser_multiline_state = MULTILINE_ESCAPED;

693

596

string_value.length() - 1 );

694

597

}

695

598

696

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

697

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

599

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

600

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

698

601

if( _parser_multiline_state == MULTILINE_NONE &&

699

content_line.doesNextLineLookFolded() )

602

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

700

603

{

701

604

_parser_multiline_state = MULTILINE_FOLDED;

702

605

}

714

617

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

715

618

716

619

// parse some properties

717

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

620

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

718

621

parseN( name_param_parts, complete_value );

719

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

622

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

720

623

parseFN( name_param_parts, complete_value );

721

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

624

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

722

625

parseORG( name_param_parts, complete_value );

723

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

626

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

724

627

parseTITLE( name_param_parts, complete_value );

725

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

628

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

726

629

parseTEL( name_param_parts, complete_value );

727

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

630

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

728

631

parseEMAIL( name_param_parts, complete_value );

729

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

632

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

730

633

parseADR( name_param_parts, complete_value );

731

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

732

parseLABEL( name_param_parts, complete_value );

733

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

734

parseNOTE( name_param_parts, complete_value );

735

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

736

parseBDAY( name_param_parts, complete_value );

737

634

}

738

635

}

739

636

752

649

return ( count & 1 ) == 1;

753

650

}

754

651

755

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

652

private String[] splitValueBySemicolon( String value )

756

653

{

757

// split string in to parts by specified character

654

// split string in to parts by semicolon

758

655

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

759

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

656

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

760

657

761

658

// go through parts

762

659

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

763

660

{

764

661

String str = parts.get( a );

765

662

766

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

767

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

663

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

664

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

768

665

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

769

666

// accordingly.

770

667

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

771

668

doesStringEndInAnEscapeChar( str ) )

772

669

{

773

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

774

// part and remove the next part

670

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

775

671

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

776

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

672

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

777

673

parts.remove( a + 1 );

778

674

779

675

// re-visit this part

790

686

return parts.toArray( ret );

791

687

}

792

688

793

private String unescapeValue( String value )

794

{

795

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

796

boolean in_escape = false;

797

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

798

{

799

int c = value.codePointAt( a );

800

801

// process a normal character

802

if( !in_escape ) {

803

if( c == '\\' )

804

in_escape = true;

805

else

806

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

807

continue;

808

}

809

810

// process an escape sequence

811

in_escape = false;

812

switch( c )

813

{

814

case 'T':

815

case 't':

816

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

817

ret.append( '\t' );

818

break;

819

case 'N':

820

case 'n':

821

// add newline

822

ret.append( '\n' );

823

break;

824

case '\\':

825

case ',':

826

case ';':

827

// add escaped character

828

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

829

break;

830

default:

831

// unknown escape sequence, so add it unescaped

832

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

833

ret.append( "\\" );

834

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

835

break;

836

}

837

}

838

839

return ret.toString();

840

}

841

842

689

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

843

690

{

844

691

// already got a better name?

845

692

if( _name_level >= NAMELEVEL_N ) return;

846

693

847

694

// get name parts

848

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

695

String[] name_parts = splitValueBySemicolon( value );

849

696

850

697

// build name

851

698

value = "";

852

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

853

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

854

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

855

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

856

{

857

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

858

String[] name_part_parts = splitValueByCharacter(

859

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

860

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

861

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

862

{

863

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

864

value += name_part_parts[ b ];

865

}

866

}

699

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

700

value += name_parts[ 1 ];

701

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

702

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

867

703

868

704

// set name

869

setName( unescapeValue( value ) );

705

setName( value );

870

706

_name_level = NAMELEVEL_N;

871

707

}

872

708

876

712

if( _name_level >= NAMELEVEL_FN ) return;

877

713

878

714

// set name

879

setName( unescapeValue( value ) );

715

setName( value );

880

716

_name_level = NAMELEVEL_FN;

881

717

}

882

718

883

719

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

884

720

{

885

721

// get org parts

886

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

722

String[] org_parts = splitValueBySemicolon( value );

887

723

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

888

724

889

725

// build organisation name

891

727

String.valueOf( org_parts[ 0 ] ) );

892

728

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

893

729

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

894

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

730

String organisation = builder.toString();

895

731

896

732

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

897

733

addOrganisation( organisation, _cached_title, true );

908

744

909

745

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

910

746

{

911

value = unescapeValue( value );

912

913

747

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

914

748

// title to it

915

749

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

941

775

int type;

942

776

if( types.contains( "FAX" ) )

943

777

if( types.contains( "HOME" ) )

944

type = TYPE_FAX_HOME;

778

type = PhonesColumns.TYPE_FAX_HOME;

945

779

else

946

type = TYPE_FAX_WORK;

780

type = PhonesColumns.TYPE_FAX_WORK;

947

781

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

948

type = TYPE_MOBILE;

782

type = PhonesColumns.TYPE_MOBILE;

949

783

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

950

type = TYPE_PAGER;

784

type = PhonesColumns.TYPE_PAGER;

951

785

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

952

type = TYPE_WORK;

786

type = PhonesColumns.TYPE_WORK;

953

787

else

954

type = TYPE_HOME;

788

type = PhonesColumns.TYPE_HOME;

955

789

956

790

// add phone number

957

791

addNumber( value, type, is_preferred );

968

802

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

969

803

int type;

970

804

if( types.contains( "WORK" ) )

971

type = TYPE_WORK;

805

type = Contacts.ContactMethods.TYPE_WORK;

972

806

else

973

type = TYPE_HOME;

807

type = Contacts.ContactMethods.TYPE_HOME;

974

808

975

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

809

addEmail( value, type, is_preferred );

976

810

}

977

811

978

812

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

979

813

{

980

814

// get address parts

981

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

815

String[] adr_parts = splitValueBySemicolon( value );

982

816

983

817

// build address

984

818

value = "";

985

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

986

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

987

{

988

// version 3.0 vCards allow further splitting by comma

989

if( _version.equals( "3.0" ) )

990

{

991

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

992

// add them on individual lines

993

String[] adr_part_parts =

994

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

995

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

996

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

997

{

998

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

999

value += adr_part_parts[ b ];

1000

}

1001

}

1002

else

1003

{

1004

// add this part on an individual line

1005

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

1006

value += adr_parts[ a ];

1007

}

1008

}

1009

1010

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

1011

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

1012

1013

// add address

1014

int type;

1015

if( types.contains( "WORK" ) )

1016

type = TYPE_WORK;

1017

else

1018

type = TYPE_HOME;

1019

1020

addAddress( unescapeValue( value ), type );

1021

}

1022

1023

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

1024

{

1025

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

1026

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

1027

1028

// add address

1029

int type;

1030

if( types.contains( "WORK" ) )

1031

type = TYPE_WORK;

1032

else

1033

type = TYPE_HOME;

1034

1035

addAddress( unescapeValue( value ), type );

1036

}

1037

1038

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

1039

{

1040

addNote( unescapeValue( value ) );

1041

}

1042

1043

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

1044

{

1045

setBirthday( value );

1046

}

1047

1048

public void finaliseVcard()

1049

throws ParseException, ContactNotIdentifiableException

819

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

820

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

821

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

822

}

823

824

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

825

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

826

827

// add address

828

int type;

829

if( types.contains( "WORK" ) )

830

type = Contacts.ContactMethods.TYPE_WORK;

831

else

832

type = Contacts.ContactMethods.TYPE_HOME;

833

834

addAddress( value, type );

835

}

836

837

public void finaliseParsing()

838

throws ParseException, SkipContactException,

839

AbortImportException

1050

840

{

1051

841

// missing version (and data is present)

1052

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

842

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

1053

843

throw new ParseException( R.string.error_vcf_malformed );

1054

844

1055

// finalise the parent class

1056

finalise();

845

// check if we should import this contact

846

try {

847

if( !isImportRequired( this ) )

848

throw new SkipContactException();

849

}

850

catch( ContactNeedsMoreInfoException e ) {

851

throw new ParseException( R.string.error_vcf_notenoughinfo );

852

}

1057

853

}

1058

854

1059

/**

1060

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

1061

* the specified name.

1062

*

1063

* @param params

1064

* @param name

1065

* @return a value, or null

1066

*/

1067

855

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

1068

856

{

1069

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

1070

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

1071

}

1072

1073

/**

1074

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

1075

*

1076

* @param params

1077

* @param name

1078

* @return an array of values, or null

1079

*/

1080

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

1081

{

1082

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

1083

1084

857

Pattern p = Pattern.compile(

1085

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

1086

Pattern.CASE_INSENSITIVE );

858

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

1087

859

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

1088

860

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

1089

861

if( m.matches() )

1090

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

862

return m.group( 2 );

1091

863

}

1092

1093

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

864

return null;

1094

865

}

1095

866

1096

/**

1097

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

1098

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

1099

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

1100

*

1101

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

1102

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

1103

* @return a set of present type values

1104

*/

1105

867

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

1106

868

List< String > valid_types )

1107

869

{

1108

870

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

1109

871

1110

872

// get 3.0-style TYPE= param

1111

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

1112

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

1113

{

1114

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

1115

// this is in the specs!)

1116

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

1117

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

1118

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

1119

if( valid_types.contains( ucpart ) )

1120

types.add( ucpart );

1121

}

873

String type_param;

874

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

875

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

876

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

877

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

878

types.add( parts[ i ] );

1122

879

}

1123

880

1124

881

// get 2.1-style type param

1125

882

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

1126

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

1127

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

1128

if( valid_types.contains( ucparam ) )

1129

types.add( ucparam );

1130

}

883

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

884

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

885

types.add( params[ i ] );

1131

886

}

1132

887

1133

888

return types;

1155

910

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

1156

911

{

1157

912

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

1158

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

913

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

1159

914

another = true;

1160

915

continue;

1161

916

}