Blame - core/java/android/util/Patterns.java - platform/frameworks/base

2014-02-13 00:01:32 +0100

[diff] [blame]

246

public static final Pattern IP_ADDRESS

247

= Pattern.compile(

248

"((25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9])\\.(25[0-5]|2[0-4]"

249

+ "[0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9]|0)\\.(25[0-5]|2[0-4][0-9]|[0-1]"

250

+ "[0-9]{2}|[1-9][0-9]|[1-9]|0)\\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}"

251

+ "|[1-9][0-9]|[0-9]))");

252

253

/**

Siyamed Sinir

2015-11-18 15:02:57 -0800

[diff] [blame]

254

* Valid UCS characters defined in RFC 3987.

255

*/

256

private static final String UCS_CHAR =

"\u00A0-\uD7FF" +

"\uF900-\uFDCF" +

"\uFDF0-\uFFEF" +

"\uD800\uDC00-\uD83F\uDFFD" +

261

"\uD840\uDC00-\uD87F\uDFFD" +

262

"\uD880\uDC00-\uD8BF\uDFFD" +

263

"\uD8C0\uDC00-\uD8FF\uDFFD" +

264

"\uD900\uDC00-\uD93F\uDFFD" +

265

"\uD940\uDC00-\uD97F\uDFFD" +

266

"\uD980\uDC00-\uD9BF\uDFFD" +

267

"\uD9C0\uDC00-\uD9FF\uDFFD" +

268

"\uDA00\uDC00-\uDA3F\uDFFD" +

269

"\uDA40\uDC00-\uDA7F\uDFFD" +

270

"\uDA80\uDC00-\uDABF\uDFFD" +

271

"\uDAC0\uDC00-\uDAFF\uDFFD" +

272

"\uDB00\uDC00-\uDB3F\uDFFD" +

273

"\uDB44\uDC00-\uDB7F\uDFFD";

274

275

/**

276

* Valid characters for IRI label defined in RFC 3987.

277

*/

278

private static final String LABEL_CHAR = "a-zA-Z0-9" + UCS_CHAR;

279

280

/**

281

* Valid characters for IRI TLD defined in RFC 3987.

282

*/

283

private static final String TLD_CHAR = "a-zA-Z" + UCS_CHAR;

284

285

/**

Selim Gurun

2014-02-13 00:01:32 +0100

[diff] [blame]

286

* RFC 1035 Section 2.3.4 limits the labels to a maximum 63 octets.

287

*/

Siyamed Sinir

2015-11-18 15:02:57 -0800

[diff] [blame]

288

private static final String IRI_LABEL =

289

"[" + LABEL_CHAR + "](?:[" + LABEL_CHAR + "\\-]{0,61}[" + LABEL_CHAR + "]){0,1}";

Selim Gurun

2014-02-13 00:01:32 +0100

[diff] [blame]

290

Siyamed Sinir

2015-11-18 15:02:57 -0800

[diff] [blame]

291

/**

292

* RFC 3492 references RFC 1034 and limits Punycode algorithm output to 63 characters.

293

*/

294

private static final String PUNYCODE_TLD = "xn\\-\\-[\\w\\-]{0,58}\\w";

295

296

private static final String TLD = "(" + PUNYCODE_TLD + "|" + "[" + TLD_CHAR + "]{2,63}" +")";

297

298

private static final String HOST_NAME = "(" + IRI_LABEL + "\\.)+" + TLD;

Selim Gurun

2014-02-13 00:01:32 +0100

[diff] [blame]

299

300

public static final Pattern DOMAIN_NAME

301

= Pattern.compile("(" + HOST_NAME + "|" + IP_ADDRESS + ")");

302

Siyamed Sinir

2015-11-18 15:02:57 -0800

[diff] [blame]

303

private static final String PROTOCOL = "(?i:http|https|rtsp):\\/\\/";

304

305

/* A word boundary or end of input. This is to stop foo.sure from matching as foo.su */

306

private static final String WORD_BOUNDARY = "(?:\\b|$|^)";

307

308

private static final String USER_INFO = "(?:[a-zA-Z0-9\\$\\-\\_\\.\\+\\!\\*\\'\$\$"

309

+ "\\,\\;\\?\\&\\=]|(?:\\%[a-fA-F0-9]{2})){1,64}(?:\\:(?:[a-zA-Z0-9\\$\\-\\_"

310

+ "\\.\\+\\!\\*\\'\$\$\\,\\;\\?\\&\\=]|(?:\\%[a-fA-F0-9]{2})){1,25})?\\@";

311

312

private static final String PORT_NUMBER = "\\:\\d{1,5}";

313

314

private static final String PATH_AND_QUERY = "\\/(?:(?:[" + LABEL_CHAR

315

+ "\\;\\/\\?\\:\\@\\&\\=\\#\\~" // plus optional query params

316

+ "\\-\\.\\+\\!\\*\\'\$\$\\,\\_])|(?:\\%[a-fA-F0-9]{2}))*";

317

Shimeng (Simon) Wang

51c02db

2010-02-11 14:07:44 -0800

[diff] [blame]

318

/**

319

* Regular expression pattern to match most part of RFC 3987

Siyamed Sinir

2015-11-18 15:02:57 -0800

[diff] [blame]

320

* Internationalized URLs, aka IRIs.

Shimeng (Simon) Wang

51c02db

2010-02-11 14:07:44 -0800

[diff] [blame]

321

*/

Siyamed Sinir

2015-11-18 15:02:57 -0800

[diff] [blame]

322

public static final Pattern WEB_URL = Pattern.compile("("

323

+ "("

324

+ "(?:" + PROTOCOL + "(?:" + USER_INFO + ")?" + ")?"

325

+ "(?:" + DOMAIN_NAME + ")"

326

+ "(?:" + PORT_NUMBER + ")?"

327

+ ")"

328

+ "(" + PATH_AND_QUERY + ")?"

+ WORD_BOUNDARY

+ ")");

/**

* Regular expression that matches known TLDs and punycode TLDs

334

*/

335

private static final String STRICT_TLD = "(?:" +

336

IANA_TOP_LEVEL_DOMAINS + "|" + PUNYCODE_TLD + ")";

337

338

/**

339

* Regular expression that matches host names using {@link #STRICT_TLD}

340

*/

341

private static final String STRICT_HOST_NAME = "(?:(?:" + IRI_LABEL + "\\.)+"

+ STRICT_TLD + ")";

/**

* Regular expression that matches domain names using either {@link #STRICT_HOST_NAME} or

346

* {@link #IP_ADDRESS}

347

*/

348

private static final Pattern STRICT_DOMAIN_NAME

349

= Pattern.compile("(?:" + STRICT_HOST_NAME + "|" + IP_ADDRESS + ")");

350

351

/**

352

* Regular expression that matches domain names without a TLD

353

*/

354

private static final String RELAXED_DOMAIN_NAME =

355

"(?:" + "(?:" + IRI_LABEL + "(?:\\.(?=\\S))" +"?)+" + "|" + IP_ADDRESS + ")";

356

357

/**

358

* Regular expression to match strings that do not start with a supported protocol. The TLDs

359

* are expected to be one of the known TLDs.

360

*/

361

private static final String WEB_URL_WITHOUT_PROTOCOL = "("

+ WORD_BOUNDARY

+ "(?<!:\\/\\/)"

+ "("

+ "(?:" + STRICT_DOMAIN_NAME + ")"

366

+ "(?:" + PORT_NUMBER + ")?"

367

+ ")"

368

+ "(?:" + PATH_AND_QUERY + ")?"

+ WORD_BOUNDARY

+ ")";

/**

* Regular expression to match strings that start with a supported protocol. Rules for domain

374

* names and TLDs are more relaxed. TLDs are optional.

375

*/

376

private static final String WEB_URL_WITH_PROTOCOL = "("

377

+ WORD_BOUNDARY

378

+ "(?:"

379

+ "(?:" + PROTOCOL + "(?:" + USER_INFO + ")?" + ")"

380

+ "(?:" + RELAXED_DOMAIN_NAME + ")?"

381

+ "(?:" + PORT_NUMBER + ")?"

382

+ ")"

383

+ "(?:" + PATH_AND_QUERY + ")?"

+ WORD_BOUNDARY

+ ")";

/**

* Regular expression pattern to match IRIs. If a string starts with http(s):// the expression

389

* tries to match the URL structure with a relaxed rule for TLDs. If the string does not start

390

* with http(s):// the TLDs are expected to be one of the known TLDs.

*

* @hide

*/

public static final Pattern AUTOLINK_WEB_URL = Pattern.compile(

395

"(" + WEB_URL_WITH_PROTOCOL + "|" + WEB_URL_WITHOUT_PROTOCOL + ")");

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

396

Siyamed Sinir

0716d5f

2016-02-25 15:54:35 -0800

[diff] [blame]

397

/**

398

* Regular expression for valid email characters. Does not include some of the valid characters

399

* defined in RFC5321: #&~!^`{}/=$*?|

400

*/

401

private static final String EMAIL_CHAR = LABEL_CHAR + "\\+\\-_%'";

402

403

/**

404

* Regular expression for local part of an email address. RFC5321 section 4.5.3.1.1 limits

405

* the local part to be at most 64 octets.

406

*/

407

private static final String EMAIL_ADDRESS_LOCAL_PART =

408

"[" + EMAIL_CHAR + "]" + "(?:[" + EMAIL_CHAR + "\\.]{1,62}[" + EMAIL_CHAR + "])?";

409

410

/**

411

* Regular expression for the domain part of an email address. RFC5321 section 4.5.3.1.2 limits

412

* the domain to be at most 255 octets.

413

*/

414

private static final String EMAIL_ADDRESS_DOMAIN =

415

"(?=.{1,255}(?:\\s|$|^))" + HOST_NAME;

416

417

/**

418

* Regular expression pattern to match email addresses. It excludes double quoted local parts

419

* and the special characters #&~!^`{}/=$*?| that are included in RFC5321.

420

* @hide

421

*/

422

public static final Pattern AUTOLINK_EMAIL_ADDRESS = Pattern.compile("(" + WORD_BOUNDARY +

423

"(?:" + EMAIL_ADDRESS_LOCAL_PART + "@" + EMAIL_ADDRESS_DOMAIN + ")" +

WORD_BOUNDARY + ")"

);

Dan Egnor

2009-11-18 11:23:45 -0800

[diff] [blame]

427

public static final Pattern EMAIL_ADDRESS

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

428

= Pattern.compile(

Fred Quintana

30d2030

2010-01-14 12:16:20 -0800

[diff] [blame]

429

"[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

430

"\\@" +

The Android Open Source Project

ba87e3e

2009-03-13 13:04:22 -0700

[diff] [blame]

431

"[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

432

"(" +

433

"\\." +

The Android Open Source Project

ba87e3e

2009-03-13 13:04:22 -0700

[diff] [blame]

434

"[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

")+"

);

/**

* This pattern is intended for searching for things that look like they

440

* might be phone numbers in arbitrary text, not for validating whether

441

* something is in fact a phone number. It will miss many things that

442

* are legitimate phone numbers.

Selim Gurun

2014-02-13 00:01:32 +0100

[diff] [blame]

443

*

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

444

* <p> The pattern matches the following:

445

* <ul>

446

* <li>Optionally, a + sign followed immediately by one or more digits. Spaces, dots, or dashes

447

* may follow.

448

* <li>Optionally, sets of digits in parentheses, separated by spaces, dots, or dashes.

449

* <li>A string starting and ending with a digit, containing digits, spaces, dots, and/or dashes.

450

* </ul>

451

*/

Dan Egnor

ded0e64

2009-11-18 11:23:45 -0800

[diff] [blame]

452

public static final Pattern PHONE

Bin Zhu

a37fc57

2012-09-19 15:00:49 +0200

[diff] [blame]

453

= Pattern.compile( // sdd = space, dot, or dash

454

"(\\+[0-9]+[\\- \\.]*)?" // +<digits><sdd>*

455

+ "(\$[0-9]+\$[\\- \\.]*)?" // (<digits>)<sdd>*

456

+ "([0-9][0-9\\- \\.]+[0-9])"); // <digit><digit|sdd>+<digit>

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

457

458

/**

459

* Convenience method to take all of the non-null matching groups in a

460

* regex Matcher and return them as a concatenated string.

461

*

462

* @param matcher The Matcher object from which grouped text will

463

* be extracted

464

*

465

* @return A String comprising all of the non-null matched

466

* groups concatenated together

467

*/

468

public static final String concatGroups(Matcher matcher) {

469

StringBuilder b = new StringBuilder();

470

final int numGroups = matcher.groupCount();

471

472

for (int i = 1; i <= numGroups; i++) {

473

String s = matcher.group(i);

474

The Android Open Source Project

2009-03-03 19:31:44 -0800

[diff] [blame]

if (s != null) {

b.append(s);

}

}

return b.toString();

}

/**

* Convenience method to return only the digits and plus signs

485

* in the matching string.

486

*

487

* @param matcher The Matcher object from which digits and plus will

488

* be extracted

489

*

490

* @return A String comprising all of the digits and plus in

491

* the match

492

*/

493

public static final String digitsAndPlusOnly(Matcher matcher) {

494

StringBuilder buffer = new StringBuilder();

495

String matchingRegion = matcher.group();

496

497

for (int i = 0, size = matchingRegion.length(); i < size; i++) {

498

char character = matchingRegion.charAt(i);

499

500

if (character == '+' || Character.isDigit(character)) {

501

buffer.append(character);

502

}

503

}

504

return buffer.toString();

505

}

Dan Egnor

ded0e64

2009-11-18 11:23:45 -0800

[diff] [blame]

506

507

/**

508

* Do not create this static utility class.

509

*/

510

private Patterns() {}

The Android Open Source Project