/android/import-contacts : revision 19

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/org/waxworlds/edam/importcontacts/VCFImporter.java

Committer: edam
Date: 2010-10-28 15:49:21 UTC
Revision ID: edam@waxworlds.org-20101028154921-98svlxlpno3cpzb8

- added file chooser
- changed file/dir entry box for a button that opens the file chooser
- added dialog to ask if you want to select a dir to scan or a file
- fixed bug where you could abort as dialog opened and the dialog wasn't cancelled
- fixed crash where you could abort as the merge prompt opened and it would try to use the just-destroyed importer
- fixed bug where closing the application at the end would show "aborted!" erroniously

files modified:
AndroidManifest.xml

TODO

gen/org/waxworlds/edam/importcontacts/R.java

res/values/strings.xml

src/org/waxworlds/edam/importcontacts/ConfigureVCF.java

src/org/waxworlds/edam/importcontacts/FileChooser.java

src/org/waxworlds/edam/importcontacts/Importer.java

src/org/waxworlds/edam/importcontacts/VCFImporter.java

src/org/waxworlds/edam/importcontacts/WizardActivity.java

Show diffs side-by-side

added added

removed removed

src/org/waxworlds/edam/importcontacts/VCFImporter.java

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.nio.ByteBuffer;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

150

148

151

149

private void importVCardFile( File file ) throws AbortImportException

152

150

{

153

// check file is good

154

if( !file.exists() )

155

showError( getText( R.string.error_filenotfound ) +

156

file.getName() );

157

if( file.length() == 0 )

158

showError( getText( R.string.error_fileisempty ) +

159

file.getName() );

160

161

151

try

162

152

{

163

// open/read file

164

FileInputStream istream = new FileInputStream( file );

165

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

166

istream.read( content );

167

168

// import

169

importVCardFileContent( content, file.getName() );

153

// open file

154

BufferedReader reader = new BufferedReader(

155

new FileReader( file ) );

156

157

// read

158

StringBuffer content = new StringBuffer();

159

String line;

160

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

161

content.append( line ).append( "\n" );

162

163

importVCardFileContent( content.toString(), file.getName() );

170

164

}

171

165

catch( FileNotFoundException e ) {

172

166

showError( getText( R.string.error_filenotfound ) +

177

171

}

178

172

}

179

173

180

private void importVCardFileContent( byte[] content, String fileName )

174

private void importVCardFileContent( String content, String fileName )

181

175

throws AbortImportException

182

176

{

183

ByteBuffer buffers[] = getLinesFromContent( content );

184

185

// go through lines

177

// get lines and parse them

178

String[] lines = content.split( "\n" );

186

179

VCard vCard = null;

187

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

180

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

188

181

{

189

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

190

String line;

191

try {

192

line = new String( buffers[ i ].array(), buffers[ i ].position(),

193

buffers[ i ].limit() - buffers[ i ].position(), "US-ASCII" );

194

}

195

catch( UnsupportedEncodingException e ) {

196

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

197

line = "";

198

}

182

String line = lines[ i ];

199

183

200

184

if( vCard == null ) {

201

185

// look for vcard beginning

230

214

{

231

215

// try giving the line to the vcard

232

216

try {

233

vCard.parseLine( buffers[ i ] );

217

vCard.parseLine( line );

234

218

}

235

219

catch( VCard.ParseException e ) {

236

220

skipContact();

255

239

}

256

240

}

257

241

258

private ByteBuffer[] getLinesFromContent( byte[] content )

259

{

260

// count lines in data

261

int num_lines = 1;

262

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

263

if( content[ a ] == '\n' )

264

num_lines++;

265

266

// get lines, removing \r's and \n's as we go

267

ByteBuffer lines[] = new ByteBuffer[ num_lines ];

268

int last = 0;

269

for( int a = 0, b = 0; a < content.length; a++ )

270

if( content[ a ] == '\n' ) {

271

int to = ( a > 0 && content[ a - 1 ] == '\r' &&

272

a - 1 >= last )? a - 1 : a;

273

lines[ b++ ] = ByteBuffer.wrap( content, last, to - last );

274

last = a + 1;

275

}

276

lines[ lines.length - 1 ] = ByteBuffer.wrap( content, last,

277

content.length - last );

278

279

return lines;

280

}

281

282

242

private class VCard extends ContactData

283

243

{

284

244

private final static int NAMELEVEL_NONE = 0;

287

247

private final static int NAMELEVEL_N = 3;

288

248

289

249

private String _version = null;

290

private Vector< ByteBuffer > _buffers = null;

250

private Vector< String > _lines = null;

291

251

private int _name_level = NAMELEVEL_NONE;

292

252

private boolean _parser_in_multiline = false;

293

253

private String _parser_current_name_and_params = null;

296

256

protected class UnencodeResult

297

257

{

298

258

private boolean _another_line_required;

299

private ByteBuffer _buffer;

259

private byte[] _bytes;

260

private int _num_bytes;

300

261

301

public UnencodeResult( boolean another_line_required,

302

ByteBuffer buffer )

262

public UnencodeResult( boolean another_line_required, byte[] bytes,

263

int num_bytes )

303

264

{

304

265

_another_line_required = another_line_required;

305

_buffer = buffer;

266

_bytes = bytes;

267

_num_bytes = num_bytes;

306

268

}

307

269

308

270

public boolean isAnotherLineRequired()

310

272

return _another_line_required;

311

273

}

312

274

313

public ByteBuffer getBuffer()

314

{

315

return _buffer;

275

public byte[] getBytes()

276

{

277

return _bytes;

278

}

279

280

public int getNumBytes()

281

{

282

return _num_bytes;

316

283

}

317

284

}

318

285

334

301

@SuppressWarnings("serial")

335

302

protected class SkipContactException extends Exception { }

336

303

337

public void parseLine( ByteBuffer buffer )

304

public void parseLine( String line )

338

305

throws ParseException, SkipContactException,

339

306

AbortImportException

340

307

{

341

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

342

String line;

343

try {

344

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

345

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

346

}

347

catch( UnsupportedEncodingException e ) {

348

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

349

line = "";

350

}

351

352

308

// ignore empty lines

353

309

if( line.trim() == "" ) return;

354

310

355

311

// split line into name and value parts (this may turn out to be

356

312

// unwanted if the line is a subsequent line in a multi-line

357

313

// value, but we have to do this now to check for and handle VCF

358

// versions first). Also, the value part is only created tentatively

359

// because it may have an encoding/charset. Since we're treating it

360

// as UTF-8 (which is compatible with 7-bit US-ASCII) this is ok

361

// though so long as we later use the raw bytes. ALso we check for

362

// malformed property:name pairs.

363

String name_and_params, string_value;

364

{

365

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

366

if( parts.length == 2 ) {

367

name_and_params = parts[ 0 ].trim();

368

string_value = parts[ 1 ].trim();

369

if( name_and_params.length() == 0 )

370

throw new ParseException( R.string.error_vcf_malformed );

371

}

372

else

373

{

374

if( !_parser_in_multiline )

375

throw new ParseException( R.string.error_vcf_malformed );

376

name_and_params = null;

377

string_value = null;

378

}

379

}

314

// versions first)

315

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

316

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

317

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

380

318

381

319

// if we haven't yet got a version, we won't be paring anything!

382

320

if( _version == null )

383

321

{

384

322

// is this a version?

385

if( name_and_params.equals( "VERSION" ) )

323

if( props.length == 2 && props[ 0 ].equals( "VERSION" ) )

386

324

{

387

325

// yes, check/store it

388

if( !string_value.equals( "2.1" ) &&

389

!string_value.equals( "3.0" ) )

326

if( !props[ 1 ].equals( "2.1" ) &&

327

!props[ 1 ].equals( "3.0" ) )

390

328

throw new ParseException( R.string.error_vcf_version );

391

_version = string_value;

329

_version = props[ 1 ];

392

330

393

// parse any other buffers we've accumulated so far

394

if( _buffers != null )

395

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

396

parseLine( _buffers.get( i ) );

397

_buffers = null;

331

// parse any other lines we've accumulated so far

332

if( _lines != null )

333

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

334

parseLine( _lines.get( i ) );

335

_lines = null;

398

336

}

399

337

else

400

338

{

401

// no, so stash this buffer till we have a version

402

if( _buffers == null )

403

_buffers = new Vector< ByteBuffer >();

404

_buffers.add( buffer );

339

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

340

if( _lines == null )

341

_lines = new Vector< String >();

342

_lines.add( line );

405

343

}

406

344

}

407

345

else

408

346

{

409

// value bytes, for processing

410

ByteBuffer value;

411

412

347

if( _parser_in_multiline )

413

348

{

414

349

// if we're currently in a multi-line value, use the stored

415

350

// property name and parameters

416

name_and_params = _parser_current_name_and_params;

417

418

// find start of string (skip spaces/tabs)

419

int pos = buffer.position();

420

byte[] buffer_array = buffer.array();

421

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

422

buffer_array[ pos ] == ' ' ||

423

buffer_array[ pos ] == '\t' ) )

424

{

425

pos++;

426

}

427

428

// get value from buffer

429

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

430

buffer.limit() - pos );

351

props = new String[ 2 ];

352

props[ 0 ] = _parser_current_name_and_params;

353

props[ 1 ] = line.trim();

431

354

}

432

355

else

433

356

{

434

// ignore empty values

435

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

436

437

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

438

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

439

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

440

441

// get value from buffer

442

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

443

buffer.limit() - pos );

357

// for normal lines, check the property name/value bits

358

if( props.length < 2 || props[ 0 ].length() == 0 )

359

throw new ParseException(

360

R.string.error_vcf_malformed );

361

362

// ignore empty properties

363

if( props[ 1 ].length() < 1 )

364

return;

444

365

445

366

// reset the saved multi-line state

446

_parser_current_name_and_params = name_and_params;

367

_parser_current_name_and_params = props[ 0 ];

447

368

_parser_buffered_value_so_far = "";

448

369

}

449

370

450

371

// get parameter parts

451

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

452

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

453

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

372

String[] params = props[ 0 ].split( ";" );

373

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

374

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

454

375

455

// parse encoding parameter

456

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

457

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

458

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

459

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

376

// parse charset and encoding parameters

377

String charset, encoding;

378

if( ( charset = checkParam( params, "CHARSET" ) ) != null &&

379

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

380

{

381

throw new ParseException( R.string.error_vcf_charset );

382

}

383

if( ( encoding = checkParam( params, "ENCODING" ) ) != null &&

384

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

385

!encoding.equals( "8BIT" ) )

460

386

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

461

387

{

462

388

throw new ParseException( R.string.error_vcf_encoding );

463

389

}

464

390

465

// parse charset parameter

466

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

467

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

468

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

469

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

470

{

471

throw new ParseException( R.string.error_vcf_charset );

472

}

473

474

391

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

475

392

// the raw string)

476

UnencodeResult unencoding_result = null;

393

UnencodeResult result;

477

394

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

478

unencoding_result = unencodeQuotedPrintable( value );

395

result = unencodeQuotedPrintable( props[ 1 ], charset );

479

396

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

480

397

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

481

if( unencoding_result != null ) {

482

value = unencoding_result.getBuffer();

483

_parser_in_multiline =

484

unencoding_result.isAnotherLineRequired();

485

}

486

487

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

488

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

489

value = transcodeAsciiToUtf8( value );

490

charset = "UTF-8";

491

}

398

else

399

result = new UnencodeResult( false, props[ 1 ].getBytes(),

400

props[ 1 ].getBytes().length );

492

401

493

402

// process charset

494

403

try {

495

string_value =

496

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

497

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

404

props[ 1 ] = new String( result.getBytes(), 0,

405

result.getNumBytes(),

406

charset == null? "UTF-8" : charset );

498

407

} catch( UnsupportedEncodingException e ) {

499

408

throw new ParseException( R.string.error_vcf_charset );

500

409

}

501

410

502

411

// handle multi-line requests

412

_parser_in_multiline = result.isAnotherLineRequired();

503

413

if( _parser_in_multiline ) {

504

_parser_buffered_value_so_far += string_value;

414

_parser_buffered_value_so_far += props[ 1 ];

505

415

return;

506

416

}

507

417

508

418

// add on buffered multi-line content

509

String complete_value =

510

_parser_buffered_value_so_far + string_value;

419

String value = _parser_buffered_value_so_far + props[ 1 ];

511

420

512

421

// parse some properties

513

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

514

parseN( name_param_parts, complete_value );

515

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

516

parseFN( name_param_parts, complete_value );

517

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

518

parseORG( name_param_parts, complete_value );

519

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

520

parseTEL( name_param_parts, complete_value );

521

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

522

parseEMAIL( name_param_parts, complete_value );

422

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

423

parseN( params, value );

424

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

425

parseFN( params, value );

426

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

427

parseORG( params, value );

428

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

429

parseTEL( params, value );

430

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

431

parseEMAIL( params, value );

523

432

}

524

433

}

525

434

531

440

if( _name_level >= NAMELEVEL_N ) return;

532

441

533

442

// get name parts

534

String[] name_parts = value.split( ";" );

535

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

536

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

443

String[] nameparts = value.split( ";" );

444

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

445

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

537

446

538

447

// build name

539

448

value = "";

540

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

541

value += name_parts[ 1 ];

542

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

543

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

449

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

450

value += nameparts[ 1 ];

451

if( nameparts[ 0 ].length() > 0 )

452

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

544

453

545

454

// set name

546

455

setName( value );

570

479

if( _name_level >= NAMELEVEL_ORG ) return;

571

480

572

481

// get org parts

573

String[] org_parts = value.split( ";" );

574

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

575

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

482

String[] orgparts = value.split( ";" );

483

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

484

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

576

485

577

486

// build name

578

if( org_parts.length > 1 && org_parts[ 0 ].length() == 0 )

579

value = org_parts[ 1 ];

487

if( orgparts[ 0 ].length() == 0 && orgparts.length > 1 )

488

value = orgparts[ 1 ];

580

489

else

581

value = org_parts[ 0 ];

490

value = orgparts[ 0 ];

582

491

583

492

// set name

584

493

setName( value );

596

505

597

506

// here's the logic...

598

507

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

599

int type = PhonesColumns.TYPE_MOBILE;

600

508

if( types.contains( "VOICE" ) )

601

509

if( types.contains( "WORK" ) )

602

type = PhonesColumns.TYPE_WORK;

510

addPhone( value, PhonesColumns.TYPE_WORK, preferred );

603

511

else

604

type = PhonesColumns.TYPE_HOME;

512

addPhone( value, PhonesColumns.TYPE_HOME, preferred );

605

513

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

606

type = PhonesColumns.TYPE_MOBILE;

514

addPhone( value, PhonesColumns.TYPE_MOBILE, preferred );

607

515

if( types.contains( "FAX" ) )

608

516

if( types.contains( "HOME" ) )

609

type = PhonesColumns.TYPE_FAX_HOME;

517

addPhone( value, PhonesColumns.TYPE_FAX_HOME, preferred );

610

518

else

611

type = PhonesColumns.TYPE_FAX_WORK;

519

addPhone( value, PhonesColumns.TYPE_FAX_WORK, preferred );

612

520

if( types.contains( "PAGER" ) )

613

type = PhonesColumns.TYPE_PAGER;

614

615

// add phone number

616

addPhone( value, type, preferred );

521

addPhone( value, PhonesColumns.TYPE_PAGER, preferred );

617

522

}

618

523

619

524

public void parseEMAIL( String[] params, String value )

637

542

AbortImportException

638

543

{

639

544

// missing version (and data is present)

640

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

545

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

641

546

throw new ParseException( R.string.error_vcf_malformed );

642

547

643

548

// missing name properties?

663

568

}

664

569

665

570

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

666

List< String > valid_types )

571

List< String > validTypes )

667

572

{

668

573

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

669

574

670

575

// get 3.0-style TYPE= param

671

String type_param;

672

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

673

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

674

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

675

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

676

types.add( parts[ i ] );

576

String typeParam;

577

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

578

String[] bits = typeParam.split( "," );

579

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

580

if( validTypes.contains( bits[ i ] ) )

581

types.add( bits[ i ] );

677

582

}

678

583

679

584

// get 2.1-style type param

680

585

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

681

586

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

682

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

587

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

683

588

types.add( params[ i ] );

684

589

}

685

590

686

591

return types;

687

592

}

688

593

689

private UnencodeResult unencodeQuotedPrintable( ByteBuffer in )

594

private UnencodeResult unencodeQuotedPrintable( String str, String charset )

690

595

{

691

596

boolean another = false;

692

597

598

// default encoding scheme

599

if( charset == null ) charset = "UTF-8";

600

693

601

// unencode quoted-pritable encoding, as per RFC1521 section 5.1

694

byte[] out = new byte[ in.limit() - in.position() ];

602

byte[] bytes = new byte[ str.length() ];

695

603

int j = 0;

696

for( int i = in.position(); i < in.limit(); i++ )

604

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

697

605

{

698

606

// get next char and process...

699

byte ch = in.array()[ i ];

700

if( ch == '=' && i < in.limit() - 2 )

607

char ch = str.charAt( i );

608

if( ch == '=' && i < str.length() - 2 )

701

609

{

702

610

// we found a =XX format byte, add it

703

out[ j ] = (byte)(

704

Character.digit( in.array()[ i + 1 ], 16 ) * 16 +

705

Character.digit( in.array()[ i + 2 ], 16 ) );

611

bytes[ j ] = (byte)(

612

Character.digit( str.charAt( i + 1 ), 16 ) * 16 +

613

Character.digit( str.charAt( i + 2 ), 16 ) );

706

614

i += 2;

707

615

}

708

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

616

else if( ch == '=' && i == str.length() - 1 )

709

617

{

710

618

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

711

619

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

714

622

}

715

623

else

716

624

// just a normal char...

717

out[ j ] = (byte)ch;

625

bytes[ j ] = (byte)ch;

718

626

j++;

719

627

}

720

628

721

return new UnencodeResult( another, ByteBuffer.wrap( out, 0, j ) );

722

}

723

724

private ByteBuffer transcodeAsciiToUtf8( ByteBuffer in )

725

{

726

// transcode

727

byte[] out = new byte[ ( in.limit() - in.position() ) * 2 ];

728

int j = 0;

729

for( int a = in.position(); a < in.limit(); a++ )

730

{

731

// if char is < 127, keep it as-is

732

if( in.array()[ a ] >= 0 )

733

out[ j++ ] = in.array()[ a ];

734

735

// else, convert it to UTF-8

736

else {

737

int b = 0xff & (int)in.array()[ a ];

738

out[ j++ ] = (byte)( 0xc0 | ( b >> 6 ) );

739

out[ j++ ] = (byte)( 0x80 | ( b & 0x3f ) );

740

}

741

}

742

743

return ByteBuffer.wrap( out, 0, j );

629

return new UnencodeResult( another, bytes, j );

744

630

}

745

631

}

746

632

}