/android/import-contacts : revision 75

To get this branch, use:

bzr branch
http://bzr.ed.am/android/import-contacts

« back to all changes in this revision

Viewing changes to src/am/ed/importcontacts/VcardImporter.java

Committer: edam
Date: 2012-12-21 14:48:44 UTC
Revision ID: tim@ed.am-20121221144844-licgvkppbjq4th4m

updated copyright dates and improved an error message

files modified:
AndroidManifest.xml

NEWS

gen/am/ed/importcontacts/R.java

res/layout/configure_vcf.xml

res/layout/doit.xml

res/layout/intro.xml

res/layout/merge.xml

res/layout/mergeprompt.xml

res/values/strings.xml

src/am/ed/importcontacts/ContactsBackend.java

src/am/ed/importcontacts/VcardImporter.java

Show diffs side-by-side

added added

removed removed

src/am/ed/importcontacts/VcardImporter.java

175

// import

176

importVCardFileContent( content, file.getName() );

177

}

178

catch( OutOfMemoryError e ) {

179

showError( R.string.error_outofmemory );

180

}

181

178

catch( FileNotFoundException e ) {

182

179

showError( getText( R.string.error_filenotfound ) +

183

180

file.getName() );

196

193

ContentLineIterator cli = new ContentLineIterator( content );

197

194

while( cli.hasNext() )

198

195

{

199

ContentLine content_line = cli.next();

196

ByteBuffer buffer = cli.next();

200

197

201

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

202

String line = content_line.getUsAsciiLine();

198

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

199

String line;

200

try {

201

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

202

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

203

}

204

catch( UnsupportedEncodingException e ) {

205

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

206

line = "";

207

}

203

208

204

209

if( vcard == null ) {

205

210

// look for vcard beginning

254

259

{

255

260

// try giving the line to the vcard

256

261

try {

257

vcard.parseLine( content_line );

262

vcard.parseLine( buffer, line,

263

cli.doesNextLineLookFolded() );

258

264

}

259

265

catch( Vcard.ParseException e ) {

260

266

skipContact();

283

289

}

284

290

}

285

291

286

class ContentLine

287

{

288

private ByteBuffer _buffer;

289

private boolean _folded_next;

290

private String _line;

291

292

public ContentLine( ByteBuffer buffer, boolean folded_next )

293

{

294

_buffer = buffer;

295

_folded_next = folded_next;

296

_line = null;

297

}

298

299

public ByteBuffer getBuffer()

300

{

301

return _buffer;

302

}

303

304

public boolean doesNextLineLookFolded()

305

{

306

return _folded_next;

307

}

308

309

public String getUsAsciiLine()

310

{

311

// generated line and cache it

312

if( _line == null ) {

313

try {

314

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

315

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

316

}

317

catch( UnsupportedEncodingException e ) {

318

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

319

// compiler...

320

}

321

}

322

323

// return cached line

324

return _line;

325

}

326

}

327

328

class ContentLineIterator implements Iterator< ContentLine >

292

class ContentLineIterator implements Iterator< ByteBuffer >

329

293

{

330

294

protected byte[] _content = null;

331

295

protected int _pos = 0;

343

307

}

344

308

345

309

@Override

346

public ContentLine next()

310

public ByteBuffer next()

347

311

{

348

312

int initial_pos = _pos;

349

313

356

320

_pos > initial_pos )? _pos - 1 : _pos;

357

321

_pos++;

358

322

_line++;

359

return new ContentLine(

360

ByteBuffer.wrap( _content, initial_pos,

361

to - initial_pos ),

362

doesNextLineLookFolded() );

323

return ByteBuffer.wrap( _content, initial_pos,

324

to - initial_pos );

363

325

}

364

326

365

327

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

367

329

int to = _pos;

368

330

_pos++;

369

331

_line++;

370

return new ContentLine(

371

ByteBuffer.wrap( _content, initial_pos,

372

to - initial_pos ),

373

doesNextLineLookFolded() );

332

return ByteBuffer.wrap( _content, initial_pos,

333

to - initial_pos );

374

334

}

375

335

376

336

// no bytes left

388

348

* onto the end of this one?

389

349

* @return

390

350

391

private boolean doesNextLineLookFolded()

351

public boolean doesNextLineLookFolded()

392

352

{

393

353

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

394

354

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

413

373

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

414

374

415

375

private String _version = null;

416

private Vector< ContentLine > _content_lines = null;

376

private Vector< ByteBuffer > _buffers = null;

417

377

private int _name_level = NAMELEVEL_NONE;

418

378

private int _parser_multiline_state = MULTILINE_NONE;

419

379

private String _parser_current_name_and_params = null;

462

422

@SuppressWarnings("serial")

463

423

protected class SkipImportException extends Exception { }

464

424

465

private String extractCollonPartFromLine( ContentLine content_line,

466

boolean former )

425

private String extractCollonPartFromLine( ByteBuffer buffer,

426

String line, boolean former )

467

427

{

468

428

String ret = null;

469

429

430

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

431

// supplied with one

432

if( line == null ) {

433

try {

434

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

435

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

436

}

437

catch( UnsupportedEncodingException e ) {

438

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

439

line = "";

440

}

441

}

442

470

443

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

471

444

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

472

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

445

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

473

446

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

474

447

ret = parts[ former? 0 : 1 ];

475

448

476

449

return ret;

477

450

}

478

451

479

private String extractNameAndParamsFromLine( ContentLine content_line )

480

{

481

return extractCollonPartFromLine( content_line, true );

482

}

483

484

private String extractValueFromLine( ContentLine content_line )

485

{

486

return extractCollonPartFromLine( content_line, false );

487

}

488

489

public void parseLine( ContentLine content_line )

452

private String extractNameAndParamsFromLine( ByteBuffer buffer,

453

String line )

454

{

455

return extractCollonPartFromLine( buffer, line, true );

456

}

457

458

private String extractValueFromLine( ByteBuffer buffer, String line )

459

{

460

return extractCollonPartFromLine( buffer, line, false );

461

}

462

463

public void parseLine( ByteBuffer buffer, String line,

464

boolean next_line_looks_folded )

490

465

throws ParseException, SkipImportException,

491

466

AbortImportException

492

467

{

495

470

{

496

471

// tentatively get name and params from line

497

472

String name_and_params =

498

extractNameAndParamsFromLine( content_line );

473

extractNameAndParamsFromLine( buffer, line );

499

474

500

475

// is it a version line?

501

476

if( name_and_params != null &&

502

477

name_and_params.equalsIgnoreCase( "VERSION" ) )

503

478

{

504

479

// yes, get it!

505

String value = extractValueFromLine( content_line );

480

String value = extractValueFromLine( buffer, line );

506

481

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

507

482

throw new ParseException( R.string.error_vcf_version );

508

483

_version = value;

509

484

510

485

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

511

486

// for a version

512

if( _content_lines != null )

513

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

514

parseLine( _content_lines.get( i ) );

515

_content_lines = null;

487

if( _buffers != null )

488

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

489

parseLine( _buffers.get( i ), null,

490

i + 1 < _buffers.size() &&

491

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

492

_buffers.get( i + 1 ).get(

493

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

494

_buffers = null;

516

495

}

517

496

else

518

497

{

519

498

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

520

if( _content_lines == null )

521

_content_lines = new Vector< ContentLine >();

522

_content_lines.add( content_line );

499

if( _buffers == null )

500

_buffers = new Vector< ByteBuffer >();

501

_buffers.add( buffer );

523

502

}

524

503

}

525

504

else

537

516

538

517

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

539

518

// of multi-line we're handling

540

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

519

pos = buffer.position();

541

520

switch( _parser_multiline_state )

542

521

{

543

522

case MULTILINE_FOLDED:

544

523

pos++;

545

524

break;

546

525

case MULTILINE_ENCODED:

547

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

548

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

549

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

526

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

527

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

528

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

550

529

{

551

530

pos++;

552

531

}

562

541

else

563

542

{

564

543

// skip empty lines

565

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

566

return;

544

if( line.trim().length() == 0 ) return;

567

545

568

546

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

569

547

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

570

548

// not fail, or it's an error

571

549

name_and_params =

572

extractNameAndParamsFromLine( content_line );

550

extractNameAndParamsFromLine( buffer, line );

573

551

if( name_and_params == null )

574

552

throw new ParseException(

575

553

R.string.error_vcf_malformed );

576

554

577

555

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

578

556

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

579

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

580

name_and_params.length() + 1;

557

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

581

558

582

559

// reset the saved multi-line state

583

560

_parser_current_name_and_params = name_and_params;

586

563

587

564

// get value from buffer, as raw bytes

588

565

ByteBuffer value;

589

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

590

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

566

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

567

buffer.limit() - pos );

591

568

592

569

// get parameter parts

593

570

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

681

658

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

682

659

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

683

660

if( _parser_multiline_state == MULTILINE_NONE &&

684

content_line.doesNextLineLookFolded() )

661

next_line_looks_folded )

685

662

{

686

663

_parser_multiline_state = MULTILINE_FOLDED;

687

664

}

843

820

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

844

821

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

845

822

{

846

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

823

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

847

824

value += name_part_parts[ b ];

848

825

}

849

826

}

1027

1004

throws ParseException, ContactNotIdentifiableException

1028

1005

{

1029

1006

// missing version (and data is present)

1030

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

1007

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

1031

1008

throw new ParseException( R.string.error_vcf_malformed );

1032

1009

1033

1010

// finalise the parent class