/android/import-contacts : revision 110

1

/*

2

* VCFImporter.java

3

*

4

5

*

6

* This file is part of the Import Contacts program (hereafter referred

7

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

7

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

8

* http://ed.am/dev/android/import-contacts

9

*

10

* This program is free software: you can redistribute it and/or modify

45

import java.util.regex.Matcher;

46

import java.util.regex.Pattern;

47

48

import android.annotation.SuppressLint;

49

48

import android.content.SharedPreferences;

49

import android.os.Environment;

50

51

public class VcardImporter extends Importer

52

{

58

super( doit );

59

}

60

61

@SuppressLint( "SdCardPath" )

62

61

@Override

63

62

protected void onImport() throws AbortImportException

64

63

{

71

70

File[] files = null;

72

71

try

73

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

74

81

// open directory

75

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

76

File file = new File( path );

82

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

83

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

77

84

if( !file.exists() )

78

85

showError( R.string.error_locationnotfound );

79

86

133

140

boolean in_vcard = false;

134

141

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

135

142

{

136

if( !in_vcard ) {

143

if( !in_vcard )

144

{

137

145

// look for vcard beginning

138

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

146

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

139

147

in_vcard = true;

140

148

_vcard_count++;

141

149

}

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

}

142

155

}

143

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

156

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

144

157

in_vcard = false;

145

158

}

159

reader.close();

146

160

147

161

}

148

162

catch( FileNotFoundException e ) {

170

184

FileInputStream istream = new FileInputStream( file );

171

185

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

172

186

istream.read( content );

173

istream = null;

187

istream.close();

174

188

175

189

// import

176

190

importVCardFileContent( content, file.getName() );

177

191

}

192

catch( OutOfMemoryError e ) {

193

showError( R.string.error_outofmemory );

194

}

178

195

catch( FileNotFoundException e ) {

179

196

showError( getText( R.string.error_filenotfound ) +

180

197

file.getName() );

193

210

ContentLineIterator cli = new ContentLineIterator( content );

194

211

while( cli.hasNext() )

195

212

{

196

ByteBuffer buffer = cli.next();

213

ContentLine content_line = cli.next();

197

214

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

}

215

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

216

String line = content_line.getUsAsciiLine();

208

217

209

218

if( vcard == null ) {

210

219

// look for vcard beginning

211

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

220

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

212

221

setProgress( _progress++ );

213

222

vcard = new Vcard();

214

223

vcard_start_line = cli.getLineNumber();

216

225

}

217

226

else {

218

227

// look for vcard content or ending

219

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

228

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

220

229

{

221

230

// finalise the vcard/contact

222

231

try {

259

268

{

260

269

// try giving the line to the vcard

261

270

try {

262

vcard.parseLine( buffer, line,

263

cli.doesNextLineLookFolded() );

271

vcard.parseLine( content_line );

264

272

}

265

273

catch( Vcard.ParseException e ) {

266

274

skipContact();

273

281

finish( ACTION_ABORT );

274

282

}

275

283

276

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

277

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

284

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

285

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

278

286

// get to another BEGIN:VCARD line.

279

287

vcard = null;

280

288

}

281

289

catch( Vcard.SkipImportException e ) {

282

290

skipContact();

283

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

291

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

284

292

// we get to another BEGIN:VCARD line.

285

293

vcard = null;

286

294

}

289

297

}

290

298

}

291

299

292

class ContentLineIterator implements Iterator< ByteBuffer >

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 >

293

343

{

294

344

protected byte[] _content = null;

295

345

protected int _pos = 0;

307

357

}

308

358

309

359

@Override

310

public ByteBuffer next()

360

public ContentLine next()

311

361

{

312

362

int initial_pos = _pos;

313

363

320

370

_pos > initial_pos )? _pos - 1 : _pos;

321

371

_pos++;

322

372

_line++;

323

return ByteBuffer.wrap( _content, initial_pos,

324

to - initial_pos );

373

return new ContentLine(

374

ByteBuffer.wrap( _content, initial_pos,

375

to - initial_pos ),

376

doesNextLineLookFolded() );

325

377

}

326

378

327

379

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

329

381

int to = _pos;

330

382

_pos++;

331

383

_line++;

332

return ByteBuffer.wrap( _content, initial_pos,

333

to - initial_pos );

384

return new ContentLine(

385

ByteBuffer.wrap( _content, initial_pos,

386

to - initial_pos ),

387

doesNextLineLookFolded() );

334

388

}

335

389

336

390

// no bytes left

348

402

* onto the end of this one?

349

403

* @return

350

404

*/

351

public boolean doesNextLineLookFolded()

405

private boolean doesNextLineLookFolded()

352

406

{

353

407

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

354

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

408

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

409

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

355

410

}

356

411

357

412

public int getLineNumber()

369

424

private final static int MULTILINE_NONE = 0;

370

425

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

371

426

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

372

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

427

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

373

428

374

429

private String _version = null;

375

private Vector< ByteBuffer > _buffers = null;

430

private Vector< ContentLine > _content_lines = null;

376

431

private int _name_level = NAMELEVEL_NONE;

377

432

private int _parser_multiline_state = MULTILINE_NONE;

378

433

private String _parser_current_name_and_params = null;

421

476

@SuppressWarnings("serial")

422

477

protected class SkipImportException extends Exception { }

423

478

424

private String extractCollonPartFromLine( ByteBuffer buffer,

425

String line, boolean former )

479

private String extractCollonPartFromLine( ContentLine content_line,

480

boolean former )

426

481

{

427

String ret = null;

428

429

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

430

// supplied with one

431

if( line == null ) {

432

try {

433

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

434

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

435

}

436

catch( UnsupportedEncodingException e ) {

437

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

438

line = "";

439

}

440

}

441

442

482

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

443

483

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

444

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

484

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

445

485

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

446

ret = parts[ former? 0 : 1 ];

447

448

return ret;

449

}

450

451

private String extractNameAndParamsFromLine( ByteBuffer buffer,

452

String line )

453

{

454

return extractCollonPartFromLine( buffer, line, true );

455

}

456

457

private String extractValueFromLine( ByteBuffer buffer, String line )

458

{

459

return extractCollonPartFromLine( buffer, line, false );

460

}

461

462

public void parseLine( ByteBuffer buffer, String line,

463

boolean next_line_looks_folded )

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 )

464

502

throws ParseException, SkipImportException,

465

503

AbortImportException

466

504

{

469

507

{

470

508

// tentatively get name and params from line

471

509

String name_and_params =

472

extractNameAndParamsFromLine( buffer, line );

510

extractNameAndParamsFromLine( content_line );

473

511

474

512

// is it a version line?

475

513

if( name_and_params != null &&

476

name_and_params.equals( "VERSION" ) )

514

name_and_params.equalsIgnoreCase( "VERSION" ) )

477

515

{

478

516

// yes, get it!

479

String value = extractValueFromLine( buffer, line );

480

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

517

String value = extractValueFromLine( content_line );

518

if( value == null || (

519

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

520

{

481

521

throw new ParseException( R.string.error_vcf_version );

522

}

482

523

_version = value;

483

524

484

525

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

485

526

// for a version

486

if( _buffers != null )

487

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

488

parseLine( _buffers.get( i ), null,

489

i + 1 < _buffers.size() &&

490

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

491

_buffers.get( i + 1 ).get(

492

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

493

_buffers = null;

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;

494

531

}

495

532

else

496

533

{

497

534

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

498

if( _buffers == null )

499

_buffers = new Vector< ByteBuffer >();

500

_buffers.add( buffer );

535

if( _content_lines == null )

536

_content_lines = new Vector< ContentLine >();

537

_content_lines.add( content_line );

501

538

}

502

539

}

503

540

else

504

541

{

505

542

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

506

// "value" part of the line start

543

// "value" part of the line starts

507

544

String name_and_params;

508

545

int pos;

509

546

515

552

516

553

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

517

554

// of multi-line we're handling

518

pos = buffer.position();

555

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

519

556

switch( _parser_multiline_state )

520

557

{

521

558

case MULTILINE_FOLDED:

522

559

pos++;

523

560

break;

524

561

case MULTILINE_ENCODED:

525

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

526

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

527

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

562

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

563

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

564

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

528

565

{

529

566

pos++;

530

567

}

539

576

}

540

577

else

541

578

{

579

// skip empty lines

580

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

581

return;

582

542

583

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

543

584

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

544

585

// not fail, or it's an error

545

586

name_and_params =

546

extractNameAndParamsFromLine( buffer, line );

587

extractNameAndParamsFromLine( content_line );

547

588

if( name_and_params == null )

548

589

throw new ParseException(

549

590

R.string.error_vcf_malformed );

550

591

551

592

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

552

593

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

553

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

594

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

595

name_and_params.length() + 1;

554

596

555

597

// reset the saved multi-line state

556

598

_parser_current_name_and_params = name_and_params;

559

601

560

602

// get value from buffer, as raw bytes

561

603

ByteBuffer value;

562

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

563

buffer.limit() - pos );

604

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

605

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

564

606

565

607

// get parameter parts

566

608

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

573

615

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

574

616

) );

575

617

boolean is_interesting_field =

576

interesting_fields.contains( name_param_parts[ 0 ] );

618

interesting_fields.contains(

619

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

577

620

578

621

// parse encoding parameter

579

622

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

580

623

if( encoding != null )

581

624

encoding = encoding.toUpperCase( Locale.US );

582

625

if( is_interesting_field && encoding != null &&

583

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

584

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

585

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

626

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

627

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

628

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

586

629

{

587

630

throw new ParseException( R.string.error_vcf_encoding );

588

631

}

592

635

if( charset != null )

593

636

charset = charset.toUpperCase( Locale.US );

594

637

if( charset != null &&

595

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

596

!charset.equals( "ASCII" ) &&

597

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

638

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

639

!charset.equalsIgnoreCase( "ASCII" ) &&

640

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

598

641

{

599

642

throw new ParseException( R.string.error_vcf_charset );

600

643

}

602

645

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

603

646

// the raw string)

604

647

UnencodeResult unencoding_result = null;

605

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

648

if( encoding != null &&

649

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

650

{

606

651

unencoding_result = unencodeQuotedPrintable( value );

607

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

652

}

653

// else if( encoding != null &&

654

// encoding.equalsIgnoreCase( "BASE64" ) )

655

// {

608

656

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

657

// }

609

658

if( unencoding_result != null ) {

610

659

value = unencoding_result.getBuffer();

611

660

if( unencoding_result.isAnotherLineRequired() )

616

665

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

617

666

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

618

667

( charset != null && (

619

charset.equals( "ASCII" ) ||

620

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

668

charset.equalsIgnoreCase( "ASCII" ) ||

669

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

621

670

{

622

671

value = transcodeAsciiToUtf8( value );

623

672

}

634

683

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

635

684

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

636

685

// indicates that we have a multi-line value

637

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

638

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

639

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

686

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

687

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

688

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

640

689

doesStringEndInAnEscapeChar( string_value ) )

641

690

{

642

691

_parser_multiline_state = MULTILINE_ESCAPED;

644

693

string_value.length() - 1 );

645

694

}

646

695

647

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

648

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

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

649

698

if( _parser_multiline_state == MULTILINE_NONE &&

650

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

699

content_line.doesNextLineLookFolded() )

651

700

{

652

701

_parser_multiline_state = MULTILINE_FOLDED;

653

702

}

665

714

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

666

715

667

716

// parse some properties

668

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

717

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

669

718

parseN( name_param_parts, complete_value );

670

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

719

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

671

720

parseFN( name_param_parts, complete_value );

672

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

721

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

673

722

parseORG( name_param_parts, complete_value );

674

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

723

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

675

724

parseTITLE( name_param_parts, complete_value );

676

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

725

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

677

726

parseTEL( name_param_parts, complete_value );

678

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

727

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

679

728

parseEMAIL( name_param_parts, complete_value );

680

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

729

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

681

730

parseADR( name_param_parts, complete_value );

682

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

731

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

683

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

684

737

}

685

738

}

686

739

710

763

{

711

764

String str = parts.get( a );

712

765

713

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

714

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

766

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

767

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

715

768

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

716

769

// accordingly.

717

770

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

758

811

in_escape = false;

759

812

switch( c )

760

813

{

814

case 'T':

815

case 't':

816

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

817

ret.append( '\t' );

818

break;

761

819

case 'N':

762

820

case 'n':

763

821

// add newline

771

829

break;

772

830

default:

773

831

// unknown escape sequence, so add it unescaped

832

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

774

833

ret.append( "\\" );

775

834

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

776

835

break;

801

860

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

802

861

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

803

862

{

804

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

863

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

805

864

value += name_part_parts[ b ];

806

865

}

807

866

}

926

985

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

927

986

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

928

987

{

929

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

930

String[] adr_part_parts =

931

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

932

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

933

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

934

{

935

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

936

value += adr_part_parts[ b ];

937

}

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

}

938

1008

}

939

1009

940

1010

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

965

1035

addAddress( unescapeValue( value ), type );

966

1036

}

967

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

968

1048

public void finaliseVcard()

969

1049

throws ParseException, ContactNotIdentifiableException

970

1050

{

971

1051

// missing version (and data is present)

972

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

1052

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

973

1053

throw new ParseException( R.string.error_vcf_malformed );

974

1054

975

1055

// finalise the parent class

978

1058

979

1059

/**

980

1060

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

981

* the specified name

1061

* the specified name.

1062

*

982

1063

* @param params

983

1064

* @param name

984

1065

* @return a value, or null

990

1071

}

991

1072

992

1073

/**

993

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

1074

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

1075

*

994

1076

* @param params

995

1077

* @param name

996

1078

* @return an array of values, or null

1000

1082

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

1001

1083

1002

1084

Pattern p = Pattern.compile(

1003

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

1085

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

1086

Pattern.CASE_INSENSITIVE );

1004

1087

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

1005

1088

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

1006

1089

if( m.matches() )

1011

1094

}

1012

1095

1013

1096

/**

1014

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

1015

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

1016

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

1017

* @param params

1018

* @param a list of type values to look for

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

1019

1103

* @return a set of present type values

1020

1104

*/

1021

1105

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

1027

1111

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

1028

1112

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

1029

1113

{

1030

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

1031

// the specs!)

1114

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

1115

// this is in the specs!)

1032

1116

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

1033

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

1034

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

1035

types.add( parts[ i ] );

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

}

1036

1122

}

1037

1123

1038

1124

// get 2.1-style type param

1039

1125

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

1040

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

1041

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

1042

types.add( params[ i ] );

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

}

1043

1131

}

1044

1132

1045

1133

return types;

1067

1155

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

1068

1156

{

1069

1157

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

1070

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

1158

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

1071

1159

another = true;

1072

1160

continue;

1073

1161

}