/android/import-contacts : revision 41

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

51

public class VCFImporter extends Importer

52

{

53

private int _vcard_count = 0;

54

private int _progress = 0;

55

56

public VcardImporter( Doit doit )

56

public VCFImporter( Doit doit )

57

{

58

super( doit );

59

}

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

125

116

setProgress( 0 );

126

117

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

127

118

importVCardFile( files[ i ] );

128

setProgress( _vcard_count );

129

119

}

130

120

131

121

private void countVCardFile( File file ) throws AbortImportException

141

131

boolean in_vcard = false;

142

132

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

143

133

{

144

if( !in_vcard )

145

{

134

if( !in_vcard ) {

146

135

// look for vcard beginning

147

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

136

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

148

137

in_vcard = true;

149

138

_vcard_count++;

150

139

}

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

140

}

157

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

141

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

158

142

in_vcard = false;

159

143

}

160

reader.close();

161

144

162

145

}

163

146

catch( FileNotFoundException e ) {

185

168

FileInputStream istream = new FileInputStream( file );

186

169

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

187

170

istream.read( content );

188

istream.close();

189

171

190

172

// import

191

173

importVCardFileContent( content, file.getName() );

192

174

}

193

catch( OutOfMemoryError e ) {

194

showError( R.string.error_outofmemory );

195

}

196

175

catch( FileNotFoundException e ) {

197

176

showError( getText( R.string.error_filenotfound ) +

198

177

file.getName() );

206

185

throws AbortImportException

207

186

{

208

187

// go through lines

209

Vcard vcard = null;

210

int vcard_start_line = 0;

188

VCard vcard = null;

211

189

ContentLineIterator cli = new ContentLineIterator( content );

212

190

while( cli.hasNext() )

213

191

{

214

ContentLine content_line = cli.next();

192

ByteBuffer buffer = cli.next();

215

193

216

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

217

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

}

218

204

219

205

if( vcard == null ) {

220

206

// look for vcard beginning

221

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

222

setProgress( _progress++ );

223

vcard = new Vcard();

224

vcard_start_line = cli.getLineNumber();

207

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

208

setProgress( ++_progress );

209

vcard = new VCard();

225

210

}

226

211

}

227

212

else {

228

213

// look for vcard content or ending

229

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

214

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

230

215

{

231

// finalise the vcard/contact

216

// store vcard and do away with it

232

217

try {

233

vcard.finaliseVcard();

234

235

// pass the finalised contact to the importer

218

vcard.finaliseParsing();

236

219

importContact( vcard );

237

220

}

238

catch( Vcard.ParseException e ) {

239

showContinueOrAbort(

240

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

241

+ fileName +

242

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

243

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

244

skipContact();

245

}

246

catch( ContactData.ContactNotIdentifiableException e ) {

247

showContinueOrAbort(

248

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

249

+ fileName +

250

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

251

+ vcard_start_line + ":\n" + getText(

252

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

253

skipContact();

254

}

255

256

// discard this vcard

221

catch( VCard.ParseException e ) {

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

}

257

234

vcard = null;

258

235

}

259

236

else

260

237

{

261

238

// try giving the line to the vcard

262

239

try {

263

vcard.parseLine( content_line );

240

vcard.parseLine( buffer, line,

241

cli.doesNextLineLookFolded() );

264

242

}

265

catch( Vcard.ParseException e ) {

243

catch( VCard.ParseException e ) {

266

244

skipContact();

267

showContinueOrAbort(

245

if( !showContinue(

268

246

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

269

+ fileName +

270

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

271

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

247

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

248

{

249

finish( ACTION_ABORT );

250

}

272

251

273

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

274

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

275

254

// get to another BEGIN:VCARD line.

276

255

vcard = null;

277

256

}

278

catch( Vcard.SkipImportException e ) {

257

catch( VCard.SkipContactException e ) {

279

258

skipContact();

280

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

259

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

281

260

// we get to another BEGIN:VCARD line.

282

261

vcard = null;

283

262

}

286

265

}

287

266

}

288

267

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 >

268

class ContentLineIterator implements Iterator< ByteBuffer >

332

269

{

333

270

protected byte[] _content = null;

334

271

protected int _pos = 0;

335

protected int _line = 0;

336

272

337

273

public ContentLineIterator( byte[] content )

338

274

{

346

282

}

347

283

348

284

@Override

349

public ContentLine next()

285

public ByteBuffer next()

350

286

{

351

287

int initial_pos = _pos;

352

288

358

294

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

359

295

_pos > initial_pos )? _pos - 1 : _pos;

360

296

_pos++;

361

_line++;

362

return new ContentLine(

363

ByteBuffer.wrap( _content, initial_pos,

364

to - initial_pos ),

365

doesNextLineLookFolded() );

297

return ByteBuffer.wrap( _content, initial_pos,

298

to - initial_pos );

366

299

}

367

300

368

301

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

369

302

if( _pos != initial_pos ) {

370

303

int to = _pos;

371

304

_pos++;

372

_line++;

373

return new ContentLine(

374

ByteBuffer.wrap( _content, initial_pos,

375

to - initial_pos ),

376

doesNextLineLookFolded() );

305

return ByteBuffer.wrap( _content, initial_pos,

306

to - initial_pos );

377

307

}

378

308

379

309

// no bytes left

391

321

* onto the end of this one?

392

322

* @return

393

323

*/

394

private boolean doesNextLineLookFolded()

324

public boolean doesNextLineLookFolded()

395

325

{

396

326

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

397

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

398

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

399

}

400

401

public int getLineNumber()

402

{

403

return _line;

327

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

404

328

}

405

329

}

406

330

407

private class Vcard extends ContactData

331

private class VCard extends ContactData

408

332

{

409

333

private final static int NAMELEVEL_NONE = 0;

410

private final static int NAMELEVEL_N = 1;

411

private final static int NAMELEVEL_FN = 2;

334

private final static int NAMELEVEL_FN = 1;

335

private final static int NAMELEVEL_N = 2;

412

336

413

337

private final static int MULTILINE_NONE = 0;

414

338

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

415

339

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

416

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

340

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

417

341

418

342

private String _version = null;

419

private Vector< ContentLine > _content_lines = null;

343

private Vector< ByteBuffer > _buffers = null;

420

344

private int _name_level = NAMELEVEL_NONE;

421

345

private int _parser_multiline_state = MULTILINE_NONE;

422

346

private String _parser_current_name_and_params = null;

458

382

459

383

public ParseException( int res )

460

384

{

461

super( VcardImporter.this.getText( res ).toString() );

385

super( VCFImporter.this.getText( res ).toString() );

462

386

}

463

387

}

464

388

465

389

@SuppressWarnings("serial")

466

protected class SkipImportException extends Exception { }

390

protected class SkipContactException extends Exception { }

467

391

468

private String extractCollonPartFromLine( ContentLine content_line,

469

boolean former )

392

private String extractCollonPartFromLine( ByteBuffer buffer,

393

String line, boolean former )

470

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

471

410

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

472

411

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

473

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

412

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

474

413

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 )

491

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,

492

433

AbortImportException

493

434

{

494

435

// do we have a version yet?

496

437

{

497

438

// tentatively get name and params from line

498

439

String name_and_params =

499

extractNameAndParamsFromLine( content_line );

440

extractNameAndParamsFromLine( buffer, line );

500

441

501

442

// is it a version line?

502

443

if( name_and_params != null &&

503

name_and_params.equalsIgnoreCase( "VERSION" ) )

444

name_and_params.equals( "VERSION" ) )

504

445

{

505

446

// yes, get it!

506

String value = extractValueFromLine( content_line );

507

if( value == null || (

508

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

509

{

447

String value = extractValueFromLine( buffer, line );

448

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

510

449

throw new ParseException( R.string.error_vcf_version );

511

}

512

450

_version = value;

513

451

514

452

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

515

453

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

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;

520

462

}

521

463

else

522

464

{

523

465

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

466

if( _buffers == null )

467

_buffers = new Vector< ByteBuffer >();

468

_buffers.add( buffer );

527

469

}

528

470

}

529

471

else

530

472

{

531

473

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

532

// "value" part of the line starts

474

// "value" part of the line start

533

475

String name_and_params;

534

476

int pos;

535

477

541

483

542

484

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

543

485

// of multi-line we're handling

544

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

486

pos = buffer.position();

545

487

switch( _parser_multiline_state )

546

488

{

547

489

case MULTILINE_FOLDED:

548

490

pos++;

549

491

break;

550

492

case MULTILINE_ENCODED:

551

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

552

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

553

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

493

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

494

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

495

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

554

496

{

555

497

pos++;

556

498

}

565

507

}

566

508

else

567

509

{

568

// skip empty lines

569

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

570

return;

571

572

510

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

573

511

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

574

512

// not fail, or it's an error

575

513

name_and_params =

576

extractNameAndParamsFromLine( content_line );

514

extractNameAndParamsFromLine( buffer, line );

577

515

if( name_and_params == null )

578

516

throw new ParseException(

579

517

R.string.error_vcf_malformed );

580

518

581

519

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

582

520

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

583

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

584

name_and_params.length() + 1;

521

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

585

522

586

523

// reset the saved multi-line state

587

524

_parser_current_name_and_params = name_and_params;

590

527

591

528

// get value from buffer, as raw bytes

592

529

ByteBuffer value;

593

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

594

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

530

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

531

buffer.limit() - pos );

595

532

596

533

// get parameter parts

597

534

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

598

535

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

599

536

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

600

537

601

// determine whether we care about this entry

602

final HashSet< String > interesting_fields =

603

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

604

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

605

) );

606

boolean is_interesting_field =

607

interesting_fields.contains(

608

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

609

610

538

// parse encoding parameter

611

539

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

612

if( encoding != null )

613

encoding = encoding.toUpperCase( Locale.ENGLISH );

614

if( is_interesting_field && encoding != null &&

615

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

616

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

617

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

618

544

{

619

545

throw new ParseException( R.string.error_vcf_encoding );

620

546

}

621

547

622

548

// parse charset parameter

623

549

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

624

if( charset != null )

625

charset = charset.toUpperCase( Locale.ENGLISH );

626

if( charset != null &&

627

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

628

!charset.equalsIgnoreCase( "ASCII" ) &&

629

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

630

554

{

631

555

throw new ParseException( R.string.error_vcf_charset );

632

556

}

634

558

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

635

559

// the raw string)

636

560

UnencodeResult unencoding_result = null;

637

if( encoding != null &&

638

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

639

{

561

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

640

562

unencoding_result = unencodeQuotedPrintable( value );

641

}

642

// else if( encoding != null &&

643

// encoding.equalsIgnoreCase( "BASE64" ) )

644

// {

563

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

645

564

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

646

// }

647

565

if( unencoding_result != null ) {

648

566

value = unencoding_result.getBuffer();

649

567

if( unencoding_result.isAnotherLineRequired() )

650

568

_parser_multiline_state = MULTILINE_ENCODED;

651

569

}

652

570

653

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

654

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

655

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

656

( charset != null && (

657

charset.equalsIgnoreCase( "ASCII" ) ||

658

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

659

{

571

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

572

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

660

573

value = transcodeAsciiToUtf8( value );

574

charset = "UTF-8";

661

575

}

662

576

663

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

577

// process charset

664

578

String string_value;

665

579

try {

666

580

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

667

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

581

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

668

582

} catch( UnsupportedEncodingException e ) {

669

583

throw new ParseException( R.string.error_vcf_charset );

670

584

}

672

586

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

673

587

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

674

588

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

589

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

590

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

591

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

678

592

doesStringEndInAnEscapeChar( string_value ) )

679

593

{

680

594

_parser_multiline_state = MULTILINE_ESCAPED;

682

596

string_value.length() - 1 );

683

597

}

684

598

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

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

687

601

if( _parser_multiline_state == MULTILINE_NONE &&

688

content_line.doesNextLineLookFolded() )

602

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

689

603

{

690

604

_parser_multiline_state = MULTILINE_FOLDED;

691

605

}

703

617

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

704

618

705

619

// parse some properties

706

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

620

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

707

621

parseN( name_param_parts, complete_value );

708

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

622

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

709

623

parseFN( name_param_parts, complete_value );

710

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

624

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

711

625

parseORG( name_param_parts, complete_value );

712

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

626

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

713

627

parseTITLE( name_param_parts, complete_value );

714

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

628

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

715

629

parseTEL( name_param_parts, complete_value );

716

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

630

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

717

631

parseEMAIL( name_param_parts, complete_value );

718

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

632

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

719

633

parseADR( name_param_parts, complete_value );

720

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

721

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

634

}

727

635

}

728

636

741

649

return ( count & 1 ) == 1;

742

650

}

743

651

744

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

652

private String[] splitValueBySemicolon( String value )

745

653

{

746

// split string in to parts by specified character

654

// split string in to parts by semicolon

747

655

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

748

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

656

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

749

657

750

658

// go through parts

751

659

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

752

660

{

753

661

String str = parts.get( a );

754

662

755

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

756

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

757

665

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

758

666

// accordingly.

759

667

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

760

668

doesStringEndInAnEscapeChar( str ) )

761

669

{

762

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

763

// part and remove the next part

670

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

764

671

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

765

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

672

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

766

673

parts.remove( a + 1 );

767

674

768

675

// re-visit this part

779

686

return parts.toArray( ret );

780

687

}

781

688

782

private String unescapeValue( String value )

783

{

784

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

785

boolean in_escape = false;

786

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

787

{

788

int c = value.codePointAt( a );

789

790

// process a normal character

791

if( !in_escape ) {

792

if( c == '\\' )

793

in_escape = true;

794

else

795

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

796

continue;

797

}

798

799

// process an escape sequence

800

in_escape = false;

801

switch( c )

802

{

803

case 'T':

804

case 't':

805

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

806

ret.append( '\t' );

807

break;

808

case 'N':

809

case 'n':

810

// add newline

811

ret.append( '\n' );

812

break;

813

case '\\':

814

case ',':

815

case ';':

816

// add escaped character

817

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

818

break;

819

default:

820

// unknown escape sequence, so add it unescaped

821

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

822

ret.append( "\\" );

823

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

824

break;

825

}

826

}

827

828

return ret.toString();

829

}

830

831

689

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

832

690

{

833

691

// already got a better name?

834

692

if( _name_level >= NAMELEVEL_N ) return;

835

693

836

694

// get name parts

837

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

695

String[] name_parts = splitValueBySemicolon( value );

838

696

839

697

// build name

840

698

value = "";

841

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

842

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

843

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

844

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

845

{

846

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

847

String[] name_part_parts = splitValueByCharacter(

848

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

849

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

850

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

851

{

852

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

853

value += name_part_parts[ b ];

854

}

855

}

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

856

703

857

704

// set name

858

setName( unescapeValue( value ) );

705

setName( value );

859

706

_name_level = NAMELEVEL_N;

860

707

}

861

708

865

712

if( _name_level >= NAMELEVEL_FN ) return;

866

713

867

714

// set name

868

setName( unescapeValue( value ) );

715

setName( value );

869

716

_name_level = NAMELEVEL_FN;

870

717

}

871

718

872

719

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

873

720

{

874

721

// get org parts

875

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

722

String[] org_parts = splitValueBySemicolon( value );

876

723

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

877

724

878

725

// build organisation name

880

727

String.valueOf( org_parts[ 0 ] ) );

881

728

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

882

729

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

883

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

730

String organisation = builder.toString();

884

731

885

732

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

886

733

addOrganisation( organisation, _cached_title, true );

897

744

898

745

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

899

746

{

900

value = unescapeValue( value );

901

902

747

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

903

748

// title to it

904

749

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

930

775

int type;

931

776

if( types.contains( "FAX" ) )

932

777

if( types.contains( "HOME" ) )

933

type = TYPE_FAX_HOME;

778

type = PhonesColumns.TYPE_FAX_HOME;

934

779

else

935

type = TYPE_FAX_WORK;

780

type = PhonesColumns.TYPE_FAX_WORK;

936

781

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

937

type = TYPE_MOBILE;

782

type = PhonesColumns.TYPE_MOBILE;

938

783

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

939

type = TYPE_PAGER;

784

type = PhonesColumns.TYPE_PAGER;

940

785

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

941

type = TYPE_WORK;

786

type = PhonesColumns.TYPE_WORK;

942

787

else

943

type = TYPE_HOME;

788

type = PhonesColumns.TYPE_HOME;

944

789

945

790

// add phone number

946

791

addNumber( value, type, is_preferred );

957

802

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

958

803

int type;

959

804

if( types.contains( "WORK" ) )

960

type = TYPE_WORK;

805

type = Contacts.ContactMethods.TYPE_WORK;

961

806

else

962

type = TYPE_HOME;

807

type = Contacts.ContactMethods.TYPE_HOME;

963

808

964

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

809

addEmail( value, type, is_preferred );

965

810

}

966

811

967

812

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

968

813

{

969

814

// get address parts

970

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

815

String[] adr_parts = splitValueBySemicolon( value );

971

816

972

817

// build address

973

818

value = "";

974

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

975

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

976

{

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

}

997

}

998

999

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

1000

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

1001

1002

// add address

1003

int type;

1004

if( types.contains( "WORK" ) )

1005

type = TYPE_WORK;

1006

else

1007

type = TYPE_HOME;

1008

1009

addAddress( unescapeValue( value ), type );

1010

}

1011

1012

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

1013

{

1014

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

1015

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

1016

1017

// add address

1018

int type;

1019

if( types.contains( "WORK" ) )

1020

type = TYPE_WORK;

1021

else

1022

type = TYPE_HOME;

1023

1024

addAddress( unescapeValue( value ), type );

1025

}

1026

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

public void finaliseVcard()

1038

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

1039

840

{

1040

841

// missing version (and data is present)

1041

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

842

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

1042

843

throw new ParseException( R.string.error_vcf_malformed );

1043

844

1044

// finalise the parent class

1045

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

}

1046

853

}

1047

854

1048

/**

1049

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

1050

* the specified name.

1051

*

1052

* @param params

1053

* @param name

1054

* @return a value, or null

1055

*/

1056

855

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

1057

856

{

1058

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

1059

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

1060

}

1061

1062

/**

1063

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

1064

*

1065

* @param params

1066

* @param name

1067

* @return an array of values, or null

1068

*/

1069

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

1070

{

1071

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

1072

1073

857

Pattern p = Pattern.compile(

1074

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

1075

Pattern.CASE_INSENSITIVE );

858

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

1076

859

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

1077

860

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

1078

861

if( m.matches() )

1079

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

862

return m.group( 2 );

1080

863

}

1081

1082

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

864

return null;

1083

865

}

1084

866

1085

/**

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

1092

* @return a set of present type values

1093

*/

1094

867

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

1095

868

List< String > valid_types )

1096

869

{

1097

870

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

1098

871

1099

872

// get 3.0-style TYPE= param

1100

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

1101

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

1102

{

1103

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

1104

// this is in the specs!)

1105

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

}

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

1111

879

}

1112

880

1113

881

// get 2.1-style type param

1114

882

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

}

883

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

884

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

885

types.add( params[ i ] );

1120

886

}

1121

887

1122

888

return types;

1144

910

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

1145

911

{

1146

912

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

1147

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

913

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

1148

914

another = true;

1149

915

continue;

1150

916

}