/android/import-contacts : revision 59

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;

45

44

import java.util.regex.Matcher;

46

45

import java.util.regex.Pattern;

47

46

48

import android.annotation.SuppressLint;

49

47

import android.content.SharedPreferences;

48

import android.provider.Contacts;

49

import android.provider.Contacts.PhonesColumns;

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

{

83

82

// get files

84

83

class VCardFilter implements FilenameFilter {

85

84

public boolean accept( File dir, String name ) {

86

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

85

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

87

86

}

88

87

}

89

88

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

175

174

// import

176

175

importVCardFileContent( content, file.getName() );

177

176

}

178

catch( OutOfMemoryError e ) {

179

showError( R.string.error_outofmemory );

180

}

181

177

catch( FileNotFoundException e ) {

182

178

showError( getText( R.string.error_filenotfound ) +

183

179

file.getName() );

196

192

ContentLineIterator cli = new ContentLineIterator( content );

197

193

while( cli.hasNext() )

198

194

{

199

ContentLine content_line = cli.next();

195

ByteBuffer buffer = cli.next();

200

196

201

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

202

String line = content_line.getUsAsciiLine();

197

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

198

String line;

199

try {

200

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

201

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

202

}

203

catch( UnsupportedEncodingException e ) {

204

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

205

line = "";

206

}

203

207

204

208

if( vcard == null ) {

205

209

// look for vcard beginning

206

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

210

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

207

211

setProgress( _progress++ );

208

212

vcard = new Vcard();

209

213

vcard_start_line = cli.getLineNumber();

211

215

}

212

216

else {

213

217

// look for vcard content or ending

214

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

218

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

215

219

{

216

220

// finalise the vcard/contact

217

221

try {

254

258

{

255

259

// try giving the line to the vcard

256

260

try {

257

vcard.parseLine( content_line );

261

vcard.parseLine( buffer, line,

262

cli.doesNextLineLookFolded() );

258

263

}

259

264

catch( Vcard.ParseException e ) {

260

265

skipContact();

283

288

}

284

289

}

285

290

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 >

291

class ContentLineIterator implements Iterator< ByteBuffer >

329

292

{

330

293

protected byte[] _content = null;

331

294

protected int _pos = 0;

343

306

}

344

307

345

308

@Override

346

public ContentLine next()

309

public ByteBuffer next()

347

310

{

348

311

int initial_pos = _pos;

349

312

356

319

_pos > initial_pos )? _pos - 1 : _pos;

357

320

_pos++;

358

321

_line++;

359

return new ContentLine(

360

ByteBuffer.wrap( _content, initial_pos,

361

to - initial_pos ),

362

doesNextLineLookFolded() );

322

return ByteBuffer.wrap( _content, initial_pos,

323

to - initial_pos );

363

324

}

364

325

365

326

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

367

328

int to = _pos;

368

329

_pos++;

369

330

_line++;

370

return new ContentLine(

371

ByteBuffer.wrap( _content, initial_pos,

372

to - initial_pos ),

373

doesNextLineLookFolded() );

331

return ByteBuffer.wrap( _content, initial_pos,

332

to - initial_pos );

374

333

}

375

334

376

335

// no bytes left

388

347

* onto the end of this one?

389

348

* @return

390

349

*/

391

private boolean doesNextLineLookFolded()

350

public boolean doesNextLineLookFolded()

392

351

{

393

352

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

394

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

395

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

353

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

396

354

}

397

355

398

356

public int getLineNumber()

410

368

private final static int MULTILINE_NONE = 0;

411

369

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

412

370

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

413

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

371

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

414

372

415

373

private String _version = null;

416

private Vector< ContentLine > _content_lines = null;

374

private Vector< ByteBuffer > _buffers = null;

417

375

private int _name_level = NAMELEVEL_NONE;

418

376

private int _parser_multiline_state = MULTILINE_NONE;

419

377

private String _parser_current_name_and_params = null;

462

420

@SuppressWarnings("serial")

463

421

protected class SkipImportException extends Exception { }

464

422

465

private String extractCollonPartFromLine( ContentLine content_line,

466

boolean former )

423

private String extractCollonPartFromLine( ByteBuffer buffer,

424

String line, boolean former )

467

425

{

468

426

String ret = null;

469

427

428

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

429

// supplied with one

430

if( line == null ) {

431

try {

432

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

433

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

434

}

435

catch( UnsupportedEncodingException e ) {

436

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

437

line = "";

438

}

439

}

440

470

441

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

471

442

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

472

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

443

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

473

444

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

474

445

ret = parts[ former? 0 : 1 ];

475

446

476

447

return ret;

477

448

}

478

449

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 )

450

private String extractNameAndParamsFromLine( ByteBuffer buffer,

451

String line )

452

{

453

return extractCollonPartFromLine( buffer, line, true );

454

}

455

456

private String extractValueFromLine( ByteBuffer buffer, String line )

457

{

458

return extractCollonPartFromLine( buffer, line, false );

459

}

460

461

public void parseLine( ByteBuffer buffer, String line,

462

boolean next_line_looks_folded )

490

463

throws ParseException, SkipImportException,

491

464

AbortImportException

492

465

{

495

468

{

496

469

// tentatively get name and params from line

497

470

String name_and_params =

498

extractNameAndParamsFromLine( content_line );

471

extractNameAndParamsFromLine( buffer, line );

499

472

500

473

// is it a version line?

501

474

if( name_and_params != null &&

502

name_and_params.equalsIgnoreCase( "VERSION" ) )

475

name_and_params.equals( "VERSION" ) )

503

476

{

504

477

// yes, get it!

505

String value = extractValueFromLine( content_line );

478

String value = extractValueFromLine( buffer, line );

506

479

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

507

480

throw new ParseException( R.string.error_vcf_version );

508

481

_version = value;

509

482

510

483

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

511

484

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

485

if( _buffers != null )

486

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

487

parseLine( _buffers.get( i ), null,

488

i + 1 < _buffers.size() &&

489

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

490

_buffers.get( i + 1 ).get(

491

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

492

_buffers = null;

516

493

}

517

494

else

518

495

{

519

496

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

497

if( _buffers == null )

498

_buffers = new Vector< ByteBuffer >();

499

_buffers.add( buffer );

523

500

}

524

501

}

525

502

else

526

503

{

527

504

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

528

// "value" part of the line starts

505

// "value" part of the line start

529

506

String name_and_params;

530

507

int pos;

531

508

537

514

538

515

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

539

516

// of multi-line we're handling

540

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

517

pos = buffer.position();

541

518

switch( _parser_multiline_state )

542

519

{

543

520

case MULTILINE_FOLDED:

544

521

pos++;

545

522

break;

546

523

case MULTILINE_ENCODED:

547

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

548

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

549

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

524

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

525

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

526

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

550

527

{

551

528

pos++;

552

529

}

561

538

}

562

539

else

563

540

{

564

// skip empty lines

565

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

566

return;

567

568

541

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

569

542

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

570

543

// not fail, or it's an error

571

544

name_and_params =

572

extractNameAndParamsFromLine( content_line );

545

extractNameAndParamsFromLine( buffer, line );

573

546

if( name_and_params == null )

574

547

throw new ParseException(

575

548

R.string.error_vcf_malformed );

576

549

577

550

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

578

551

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

579

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

580

name_and_params.length() + 1;

552

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

581

553

582

554

// reset the saved multi-line state

583

555

_parser_current_name_and_params = name_and_params;

586

558

587

559

// get value from buffer, as raw bytes

588

560

ByteBuffer value;

589

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

590

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

561

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

562

buffer.limit() - pos );

591

563

592

564

// get parameter parts

593

565

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

600

572

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

601

573

) );

602

574

boolean is_interesting_field =

603

interesting_fields.contains(

604

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

575

interesting_fields.contains( name_param_parts[ 0 ] );

605

576

606

577

// parse encoding parameter

607

578

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

608

if( encoding != null )

609

encoding = encoding.toUpperCase( Locale.US );

579

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

610

580

if( is_interesting_field && encoding != null &&

611

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

612

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

613

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

581

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

582

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

583

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

614

584

{

615

585

throw new ParseException( R.string.error_vcf_encoding );

616

586

}

617

587

618

588

// parse charset parameter

619

589

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

620

if( charset != null )

621

charset = charset.toUpperCase( Locale.US );

590

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

622

591

if( charset != null &&

623

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

624

!charset.equalsIgnoreCase( "ASCII" ) &&

625

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

592

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

593

!charset.equals( "ASCII" ) &&

594

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

626

595

{

627

596

throw new ParseException( R.string.error_vcf_charset );

628

597

}

630

599

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

631

600

// the raw string)

632

601

UnencodeResult unencoding_result = null;

633

if( encoding != null &&

634

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

635

{

602

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

636

603

unencoding_result = unencodeQuotedPrintable( value );

637

}

638

// else if( encoding != null &&

639

// encoding.equalsIgnoreCase( "BASE64" ) )

640

// {

604

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

641

605

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

642

// }

643

606

if( unencoding_result != null ) {

644

607

value = unencoding_result.getBuffer();

645

608

if( unencoding_result.isAnotherLineRequired() )

650

613

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

651

614

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

652

615

( charset != null && (

653

charset.equalsIgnoreCase( "ASCII" ) ||

654

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

616

charset.equals( "ASCII" ) ||

617

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

655

618

{

656

619

value = transcodeAsciiToUtf8( value );

657

620

}

668

631

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

669

632

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

670

633

// indicates that we have a multi-line value

671

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

672

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

673

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

634

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

635

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

636

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

674

637

doesStringEndInAnEscapeChar( string_value ) )

675

638

{

676

639

_parser_multiline_state = MULTILINE_ESCAPED;

678

641

string_value.length() - 1 );

679

642

}

680

643

681

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

682

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

644

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

645

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

683

646

if( _parser_multiline_state == MULTILINE_NONE &&

684

content_line.doesNextLineLookFolded() )

647

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

685

648

{

686

649

_parser_multiline_state = MULTILINE_FOLDED;

687

650

}

699

662

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

700

663

701

664

// parse some properties

702

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

665

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

703

666

parseN( name_param_parts, complete_value );

704

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

667

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

705

668

parseFN( name_param_parts, complete_value );

706

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

669

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

707

670

parseORG( name_param_parts, complete_value );

708

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

671

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

709

672

parseTITLE( name_param_parts, complete_value );

710

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

673

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

711

674

parseTEL( name_param_parts, complete_value );

712

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

675

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

713

676

parseEMAIL( name_param_parts, complete_value );

714

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

677

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

715

678

parseADR( name_param_parts, complete_value );

716

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

679

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

717

680

parseLABEL( name_param_parts, complete_value );

718

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

719

parseNOTE( name_param_parts, complete_value );

720

681

}

721

682

}

722

683

794

755

in_escape = false;

795

756

switch( c )

796

757

{

797

case 'T':

798

case 't':

799

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

800

ret.append( '\t' );

801

break;

802

758

case 'N':

803

759

case 'n':

804

760

// add newline

812

768

break;

813

769

default:

814

770

// unknown escape sequence, so add it unescaped

815

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

816

771

ret.append( "\\" );

817

772

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

818

773

break;

843

798

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

844

799

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

845

800

{

846

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

801

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

847

802

value += name_part_parts[ b ];

848

803

}

849

804

}

924

879

int type;

925

880

if( types.contains( "FAX" ) )

926

881

if( types.contains( "HOME" ) )

927

type = TYPE_FAX_HOME;

882

type = PhonesColumns.TYPE_FAX_HOME;

928

883

else

929

type = TYPE_FAX_WORK;

884

type = PhonesColumns.TYPE_FAX_WORK;

930

885

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

931

type = TYPE_MOBILE;

886

type = PhonesColumns.TYPE_MOBILE;

932

887

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

933

type = TYPE_PAGER;

888

type = PhonesColumns.TYPE_PAGER;

934

889

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

935

type = TYPE_WORK;

890

type = PhonesColumns.TYPE_WORK;

936

891

else

937

type = TYPE_HOME;

892

type = PhonesColumns.TYPE_HOME;

938

893

939

894

// add phone number

940

895

addNumber( value, type, is_preferred );

951

906

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

952

907

int type;

953

908

if( types.contains( "WORK" ) )

954

type = TYPE_WORK;

909

type = Contacts.ContactMethods.TYPE_WORK;

955

910

else

956

type = TYPE_HOME;

911

type = Contacts.ContactMethods.TYPE_HOME;

957

912

958

913

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

959

914

}

968

923

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

969

924

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

970

925

{

971

// version 3.0 vCards allow further splitting by comma

972

if( _version.equals( "3.0" ) )

973

{

974

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

975

// add them on individual lines

976

String[] adr_part_parts =

977

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

978

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

979

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

980

{

981

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

982

value += adr_part_parts[ b ];

983

}

984

}

985

else

986

{

987

// add this part on an individual line

988

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

989

value += adr_parts[ a ];

990

}

926

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

927

String[] adr_part_parts =

928

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

929

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

930

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

931

{

932

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

933

value += adr_part_parts[ b ];

934

}

991

935

}

992

936

993

937

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

996

940

// add address

997

941

int type;

998

942

if( types.contains( "WORK" ) )

999

type = TYPE_WORK;

943

type = Contacts.ContactMethods.TYPE_WORK;

1000

944

else

1001

type = TYPE_HOME;

945

type = Contacts.ContactMethods.TYPE_HOME;

1002

946

1003

947

addAddress( unescapeValue( value ), type );

1004

948

}

1011

955

// add address

1012

956

int type;

1013

957

if( types.contains( "WORK" ) )

1014

type = TYPE_WORK;

958

type = Contacts.ContactMethods.TYPE_WORK;

1015

959

else

1016

type = TYPE_HOME;

960

type = Contacts.ContactMethods.TYPE_HOME;

1017

961

1018

962

addAddress( unescapeValue( value ), type );

1019

963

}

1020

964

1021

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

1022

{

1023

addNote( unescapeValue( value ) );

1024

}

1025

1026

965

public void finaliseVcard()

1027

966

throws ParseException, ContactNotIdentifiableException

1028

967

{

1029

968

// missing version (and data is present)

1030

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

969

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

1031

970

throw new ParseException( R.string.error_vcf_malformed );

1032

971

1033

972

// finalise the parent class

1058

997

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

1059

998

1060

999

Pattern p = Pattern.compile(

1061

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

1062

Pattern.CASE_INSENSITIVE );

1000

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

1063

1001

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

1064

1002

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

1065

1003

if( m.matches() )

1073

1011

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

1074

1012

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

1075

1013

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

1076

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

1077

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

1014

* @param params

1015

* @param a list of type values to look for

1078

1016

* @return a set of present type values

1079

1017

*/

1080

1018

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

1086

1024

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

1087

1025

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

1088

1026

{

1089

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

1090

// this is in the specs!)

1027

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

1028

// the specs!)

1091

1029

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

1092

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

1093

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

1094

if( valid_types.contains( ucpart ) )

1095

types.add( ucpart );

1096

}

1030

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

1031

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

1032

types.add( parts[ i ] );

1097

1033

}

1098

1034

1099

1035

// get 2.1-style type param

1100

1036

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

1101

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

1102

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

1103

if( valid_types.contains( ucparam ) )

1104

types.add( ucparam );

1105

}

1037

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

1038

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

1039

types.add( params[ i ] );

1106

1040

}

1107

1041

1108

1042

return types;