1 /* 2 * Copyright (C) 2009 The Libphonenumber Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.i18n.phonenumbers; 18 19 import com.android.i18n.phonenumbers.Phonemetadata.NumberFormat; 20 import com.android.i18n.phonenumbers.Phonemetadata.PhoneMetadata; 21 22 import java.util.ArrayList; 23 import java.util.Iterator; 24 import java.util.List; 25 import java.util.regex.Matcher; 26 import java.util.regex.Pattern; 27 28 /** 29 * A formatter which formats phone numbers as they are entered. 30 * 31 * <p>An AsYouTypeFormatter can be created by invoking 32 * {@link PhoneNumberUtil#getAsYouTypeFormatter}. After that, digits can be added by invoking 33 * {@link #inputDigit} on the formatter instance, and the partially formatted phone number will be 34 * returned each time a digit is added. {@link #clear} can be invoked before formatting a new 35 * number. 36 * 37 * <p>See the unittests for more details on how the formatter is to be used. 38 * 39 * @author Shaopeng Jia 40 */ 41 public class AsYouTypeFormatter { 42 private String currentOutput = ""; 43 private StringBuilder formattingTemplate = new StringBuilder(); 44 // The pattern from numberFormat that is currently used to create formattingTemplate. 45 private String currentFormattingPattern = ""; 46 private StringBuilder accruedInput = new StringBuilder(); 47 private StringBuilder accruedInputWithoutFormatting = new StringBuilder(); 48 // This indicates whether AsYouTypeFormatter is currently doing the formatting. 49 private boolean ableToFormat = true; 50 // Set to true when users enter their own formatting. AsYouTypeFormatter will do no formatting at 51 // all when this is set to true. 52 private boolean inputHasFormatting = false; 53 // This is set to true when we know the user is entering a full national significant number, since 54 // we have either detected a national prefix or an international dialing prefix. When this is 55 // true, we will no longer use local number formatting patterns. 56 private boolean isCompleteNumber = false; 57 private boolean isExpectingCountryCallingCode = false; 58 private final PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance(); 59 private String defaultCountry; 60 61 // Character used when appropriate to separate a prefix, such as a long NDD or a country calling 62 // code, from the national number. 63 private static final char SEPARATOR_BEFORE_NATIONAL_NUMBER = ' '; 64 private static final PhoneMetadata EMPTY_METADATA = 65 new PhoneMetadata().setInternationalPrefix("NA"); 66 private PhoneMetadata defaultMetadata; 67 private PhoneMetadata currentMetadata; 68 69 // A pattern that is used to match character classes in regular expressions. An example of a 70 // character class is [1-4]. 71 private static final Pattern CHARACTER_CLASS_PATTERN = Pattern.compile("\\[([^\\[\\]])*\\]"); 72 // Any digit in a regular expression that actually denotes a digit. For example, in the regular 73 // expression 80[0-2]\d{6,10}, the first 2 digits (8 and 0) are standalone digits, but the rest 74 // are not. 75 // Two look-aheads are needed because the number following \\d could be a two-digit number, since 76 // the phone number can be as long as 15 digits. 77 private static final Pattern STANDALONE_DIGIT_PATTERN = Pattern.compile("\\d(?=[^,}][^,}])"); 78 79 // A pattern that is used to determine if a numberFormat under availableFormats is eligible to be 80 // used by the AYTF. It is eligible when the format element under numberFormat contains groups of 81 // the dollar sign followed by a single digit, separated by valid phone number punctuation. This 82 // prevents invalid punctuation (such as the star sign in Israeli star numbers) getting into the 83 // output of the AYTF. 84 private static final Pattern ELIGIBLE_FORMAT_PATTERN = 85 Pattern.compile("[" + PhoneNumberUtil.VALID_PUNCTUATION + "]*" + 86 "(\\$\\d" + "[" + PhoneNumberUtil.VALID_PUNCTUATION + "]*)+"); 87 // A set of characters that, if found in a national prefix formatting rules, are an indicator to 88 // us that we should separate the national prefix from the number when formatting. 89 private static final Pattern NATIONAL_PREFIX_SEPARATORS_PATTERN = Pattern.compile("[- ]"); 90 91 // This is the minimum length of national number accrued that is required to trigger the 92 // formatter. The first element of the leadingDigitsPattern of each numberFormat contains a 93 // regular expression that matches up to this number of digits. 94 private static final int MIN_LEADING_DIGITS_LENGTH = 3; 95 96 // The digits that have not been entered yet will be represented by a \u2008, the punctuation 97 // space. 98 private static final String DIGIT_PLACEHOLDER = "\u2008"; 99 private static final Pattern DIGIT_PATTERN = Pattern.compile(DIGIT_PLACEHOLDER); 100 private int lastMatchPosition = 0; 101 // The position of a digit upon which inputDigitAndRememberPosition is most recently invoked, as 102 // found in the original sequence of characters the user entered. 103 private int originalPosition = 0; 104 // The position of a digit upon which inputDigitAndRememberPosition is most recently invoked, as 105 // found in accruedInputWithoutFormatting. 106 private int positionToRemember = 0; 107 // This contains anything that has been entered so far preceding the national significant number, 108 // and it is formatted (e.g. with space inserted). For example, this can contain IDD, country 109 // code, and/or NDD, etc. 110 private StringBuilder prefixBeforeNationalNumber = new StringBuilder(); 111 private boolean shouldAddSpaceAfterNationalPrefix = false; 112 // This contains the national prefix that has been extracted. It contains only digits without 113 // formatting. 114 private String extractedNationalPrefix = ""; 115 private StringBuilder nationalNumber = new StringBuilder(); 116 private List<NumberFormat> possibleFormats = new ArrayList<NumberFormat>(); 117 118 // A cache for frequently used country-specific regular expressions. 119 private RegexCache regexCache = new RegexCache(64); 120 121 /** 122 * Constructs an as-you-type formatter. Should be obtained from {@link 123 * PhoneNumberUtil#getAsYouTypeFormatter}. 124 * 125 * @param regionCode the country/region where the phone number is being entered 126 */ 127 AsYouTypeFormatter(String regionCode) { 128 defaultCountry = regionCode; 129 currentMetadata = getMetadataForRegion(defaultCountry); 130 defaultMetadata = currentMetadata; 131 } 132 133 // The metadata needed by this class is the same for all regions sharing the same country calling 134 // code. Therefore, we return the metadata for "main" region for this country calling code. 135 private PhoneMetadata getMetadataForRegion(String regionCode) { 136 int countryCallingCode = phoneUtil.getCountryCodeForRegion(regionCode); 137 String mainCountry = phoneUtil.getRegionCodeForCountryCode(countryCallingCode); 138 PhoneMetadata metadata = phoneUtil.getMetadataForRegion(mainCountry); 139 if (metadata != null) { 140 return metadata; 141 } 142 // Set to a default instance of the metadata. This allows us to function with an incorrect 143 // region code, even if formatting only works for numbers specified with "+". 144 return EMPTY_METADATA; 145 } 146 147 // Returns true if a new template is created as opposed to reusing the existing template. 148 private boolean maybeCreateNewTemplate() { 149 // When there are multiple available formats, the formatter uses the first format where a 150 // formatting template could be created. 151 Iterator<NumberFormat> it = possibleFormats.iterator(); 152 while (it.hasNext()) { 153 NumberFormat numberFormat = it.next(); 154 String pattern = numberFormat.getPattern(); 155 if (currentFormattingPattern.equals(pattern)) { 156 return false; 157 } 158 if (createFormattingTemplate(numberFormat)) { 159 currentFormattingPattern = pattern; 160 shouldAddSpaceAfterNationalPrefix = 161 NATIONAL_PREFIX_SEPARATORS_PATTERN.matcher( 162 numberFormat.getNationalPrefixFormattingRule()).find(); 163 // With a new formatting template, the matched position using the old template needs to be 164 // reset. 165 lastMatchPosition = 0; 166 return true; 167 } else { // Remove the current number format from possibleFormats. 168 it.remove(); 169 } 170 } 171 ableToFormat = false; 172 return false; 173 } 174 175 private void getAvailableFormats(String leadingDigits) { 176 List<NumberFormat> formatList = 177 (isCompleteNumber && currentMetadata.intlNumberFormatSize() > 0) 178 ? currentMetadata.intlNumberFormats() 179 : currentMetadata.numberFormats(); 180 boolean nationalPrefixIsUsedByCountry = currentMetadata.hasNationalPrefix(); 181 for (NumberFormat format : formatList) { 182 if (!nationalPrefixIsUsedByCountry || isCompleteNumber || 183 format.isNationalPrefixOptionalWhenFormatting() || 184 phoneUtil.formattingRuleHasFirstGroupOnly(format.getNationalPrefixFormattingRule())) { 185 if (isFormatEligible(format.getFormat())) { 186 possibleFormats.add(format); 187 } 188 } 189 } 190 narrowDownPossibleFormats(leadingDigits); 191 } 192 193 private boolean isFormatEligible(String format) { 194 return ELIGIBLE_FORMAT_PATTERN.matcher(format).matches(); 195 } 196 197 private void narrowDownPossibleFormats(String leadingDigits) { 198 int indexOfLeadingDigitsPattern = leadingDigits.length() - MIN_LEADING_DIGITS_LENGTH; 199 Iterator<NumberFormat> it = possibleFormats.iterator(); 200 while (it.hasNext()) { 201 NumberFormat format = it.next(); 202 if (format.leadingDigitsPatternSize() == 0) { 203 // Keep everything that isn't restricted by leading digits. 204 continue; 205 } 206 int lastLeadingDigitsPattern = 207 Math.min(indexOfLeadingDigitsPattern, format.leadingDigitsPatternSize() - 1); 208 Pattern leadingDigitsPattern = regexCache.getPatternForRegex( 209 format.getLeadingDigitsPattern(lastLeadingDigitsPattern)); 210 Matcher m = leadingDigitsPattern.matcher(leadingDigits); 211 if (!m.lookingAt()) { 212 it.remove(); 213 } 214 } 215 } 216 217 private boolean createFormattingTemplate(NumberFormat format) { 218 String numberPattern = format.getPattern(); 219 220 // The formatter doesn't format numbers when numberPattern contains "|", e.g. 221 // (20|3)\d{4}. In those cases we quickly return. 222 if (numberPattern.indexOf('|') != -1) { 223 return false; 224 } 225 226 // Replace anything in the form of [..] with \d 227 numberPattern = CHARACTER_CLASS_PATTERN.matcher(numberPattern).replaceAll("\\\\d"); 228 229 // Replace any standalone digit (not the one in d{}) with \d 230 numberPattern = STANDALONE_DIGIT_PATTERN.matcher(numberPattern).replaceAll("\\\\d"); 231 formattingTemplate.setLength(0); 232 String tempTemplate = getFormattingTemplate(numberPattern, format.getFormat()); 233 if (tempTemplate.length() > 0) { 234 formattingTemplate.append(tempTemplate); 235 return true; 236 } 237 return false; 238 } 239 240 // Gets a formatting template which can be used to efficiently format a partial number where 241 // digits are added one by one. 242 private String getFormattingTemplate(String numberPattern, String numberFormat) { 243 // Creates a phone number consisting only of the digit 9 that matches the 244 // numberPattern by applying the pattern to the longestPhoneNumber string. 245 String longestPhoneNumber = "999999999999999"; 246 Matcher m = regexCache.getPatternForRegex(numberPattern).matcher(longestPhoneNumber); 247 m.find(); // this will always succeed 248 String aPhoneNumber = m.group(); 249 // No formatting template can be created if the number of digits entered so far is longer than 250 // the maximum the current formatting rule can accommodate. 251 if (aPhoneNumber.length() < nationalNumber.length()) { 252 return ""; 253 } 254 // Formats the number according to numberFormat 255 String template = aPhoneNumber.replaceAll(numberPattern, numberFormat); 256 // Replaces each digit with character DIGIT_PLACEHOLDER 257 template = template.replaceAll("9", DIGIT_PLACEHOLDER); 258 return template; 259 } 260 261 /** 262 * Clears the internal state of the formatter, so it can be reused. 263 */ 264 public void clear() { 265 currentOutput = ""; 266 accruedInput.setLength(0); 267 accruedInputWithoutFormatting.setLength(0); 268 formattingTemplate.setLength(0); 269 lastMatchPosition = 0; 270 currentFormattingPattern = ""; 271 prefixBeforeNationalNumber.setLength(0); 272 extractedNationalPrefix = ""; 273 nationalNumber.setLength(0); 274 ableToFormat = true; 275 inputHasFormatting = false; 276 positionToRemember = 0; 277 originalPosition = 0; 278 isCompleteNumber = false; 279 isExpectingCountryCallingCode = false; 280 possibleFormats.clear(); 281 shouldAddSpaceAfterNationalPrefix = false; 282 if (!currentMetadata.equals(defaultMetadata)) { 283 currentMetadata = getMetadataForRegion(defaultCountry); 284 } 285 } 286 287 /** 288 * Formats a phone number on-the-fly as each digit is entered. 289 * 290 * @param nextChar the most recently entered digit of a phone number. Formatting characters are 291 * allowed, but as soon as they are encountered this method formats the number as entered and 292 * not "as you type" anymore. Full width digits and Arabic-indic digits are allowed, and will 293 * be shown as they are. 294 * @return the partially formatted phone number. 295 */ 296 public String inputDigit(char nextChar) { 297 currentOutput = inputDigitWithOptionToRememberPosition(nextChar, false); 298 return currentOutput; 299 } 300 301 /** 302 * Same as {@link #inputDigit}, but remembers the position where {@code nextChar} is inserted, so 303 * that it can be retrieved later by using {@link #getRememberedPosition}. The remembered 304 * position will be automatically adjusted if additional formatting characters are later 305 * inserted/removed in front of {@code nextChar}. 306 */ 307 public String inputDigitAndRememberPosition(char nextChar) { 308 currentOutput = inputDigitWithOptionToRememberPosition(nextChar, true); 309 return currentOutput; 310 } 311 312 @SuppressWarnings("fallthrough") 313 private String inputDigitWithOptionToRememberPosition(char nextChar, boolean rememberPosition) { 314 accruedInput.append(nextChar); 315 if (rememberPosition) { 316 originalPosition = accruedInput.length(); 317 } 318 // We do formatting on-the-fly only when each character entered is either a digit, or a plus 319 // sign (accepted at the start of the number only). 320 if (!isDigitOrLeadingPlusSign(nextChar)) { 321 ableToFormat = false; 322 inputHasFormatting = true; 323 } else { 324 nextChar = normalizeAndAccrueDigitsAndPlusSign(nextChar, rememberPosition); 325 } 326 if (!ableToFormat) { 327 // When we are unable to format because of reasons other than that formatting chars have been 328 // entered, it can be due to really long IDDs or NDDs. If that is the case, we might be able 329 // to do formatting again after extracting them. 330 if (inputHasFormatting) { 331 return accruedInput.toString(); 332 } else if (attemptToExtractIdd()) { 333 if (attemptToExtractCountryCallingCode()) { 334 return attemptToChoosePatternWithPrefixExtracted(); 335 } 336 } else if (ableToExtractLongerNdd()) { 337 // Add an additional space to separate long NDD and national significant number for 338 // readability. We don't set shouldAddSpaceAfterNationalPrefix to true, since we don't want 339 // this to change later when we choose formatting templates. 340 prefixBeforeNationalNumber.append(SEPARATOR_BEFORE_NATIONAL_NUMBER); 341 return attemptToChoosePatternWithPrefixExtracted(); 342 } 343 return accruedInput.toString(); 344 } 345 346 // We start to attempt to format only when at least MIN_LEADING_DIGITS_LENGTH digits (the plus 347 // sign is counted as a digit as well for this purpose) have been entered. 348 switch (accruedInputWithoutFormatting.length()) { 349 case 0: 350 case 1: 351 case 2: 352 return accruedInput.toString(); 353 case 3: 354 if (attemptToExtractIdd()) { 355 isExpectingCountryCallingCode = true; 356 } else { // No IDD or plus sign is found, might be entering in national format. 357 extractedNationalPrefix = removeNationalPrefixFromNationalNumber(); 358 return attemptToChooseFormattingPattern(); 359 } 360 default: 361 if (isExpectingCountryCallingCode) { 362 if (attemptToExtractCountryCallingCode()) { 363 isExpectingCountryCallingCode = false; 364 } 365 return prefixBeforeNationalNumber + nationalNumber.toString(); 366 } 367 if (possibleFormats.size() > 0) { // The formatting patterns are already chosen. 368 String tempNationalNumber = inputDigitHelper(nextChar); 369 // See if the accrued digits can be formatted properly already. If not, use the results 370 // from inputDigitHelper, which does formatting based on the formatting pattern chosen. 371 String formattedNumber = attemptToFormatAccruedDigits(); 372 if (formattedNumber.length() > 0) { 373 return formattedNumber; 374 } 375 narrowDownPossibleFormats(nationalNumber.toString()); 376 if (maybeCreateNewTemplate()) { 377 return inputAccruedNationalNumber(); 378 } 379 return ableToFormat 380 ? appendNationalNumber(tempNationalNumber) 381 : accruedInput.toString(); 382 } else { 383 return attemptToChooseFormattingPattern(); 384 } 385 } 386 } 387 388 private String attemptToChoosePatternWithPrefixExtracted() { 389 ableToFormat = true; 390 isExpectingCountryCallingCode = false; 391 possibleFormats.clear(); 392 return attemptToChooseFormattingPattern(); 393 } 394 395 // @VisibleForTesting 396 String getExtractedNationalPrefix() { 397 return extractedNationalPrefix; 398 } 399 400 // Some national prefixes are a substring of others. If extracting the shorter NDD doesn't result 401 // in a number we can format, we try to see if we can extract a longer version here. 402 private boolean ableToExtractLongerNdd() { 403 if (extractedNationalPrefix.length() > 0) { 404 // Put the extracted NDD back to the national number before attempting to extract a new NDD. 405 nationalNumber.insert(0, extractedNationalPrefix); 406 // Remove the previously extracted NDD from prefixBeforeNationalNumber. We cannot simply set 407 // it to empty string because people sometimes incorrectly enter national prefix after the 408 // country code, e.g. +44 (0)20-1234-5678. 409 int indexOfPreviousNdd = prefixBeforeNationalNumber.lastIndexOf(extractedNationalPrefix); 410 prefixBeforeNationalNumber.setLength(indexOfPreviousNdd); 411 } 412 return !extractedNationalPrefix.equals(removeNationalPrefixFromNationalNumber()); 413 } 414 415 private boolean isDigitOrLeadingPlusSign(char nextChar) { 416 return Character.isDigit(nextChar) || 417 (accruedInput.length() == 1 && 418 PhoneNumberUtil.PLUS_CHARS_PATTERN.matcher(Character.toString(nextChar)).matches()); 419 } 420 421 /** 422 * Check to see if there is an exact pattern match for these digits. If so, we should use this 423 * instead of any other formatting template whose leadingDigitsPattern also matches the input. 424 */ 425 String attemptToFormatAccruedDigits() { 426 for (NumberFormat numberFormat : possibleFormats) { 427 Matcher m = regexCache.getPatternForRegex(numberFormat.getPattern()).matcher(nationalNumber); 428 if (m.matches()) { 429 shouldAddSpaceAfterNationalPrefix = 430 NATIONAL_PREFIX_SEPARATORS_PATTERN.matcher( 431 numberFormat.getNationalPrefixFormattingRule()).find(); 432 String formattedNumber = m.replaceAll(numberFormat.getFormat()); 433 return appendNationalNumber(formattedNumber); 434 } 435 } 436 return ""; 437 } 438 439 /** 440 * Returns the current position in the partially formatted phone number of the character which was 441 * previously passed in as the parameter of {@link #inputDigitAndRememberPosition}. 442 */ 443 public int getRememberedPosition() { 444 if (!ableToFormat) { 445 return originalPosition; 446 } 447 int accruedInputIndex = 0, currentOutputIndex = 0; 448 while (accruedInputIndex < positionToRemember && currentOutputIndex < currentOutput.length()) { 449 if (accruedInputWithoutFormatting.charAt(accruedInputIndex) == 450 currentOutput.charAt(currentOutputIndex)) { 451 accruedInputIndex++; 452 } 453 currentOutputIndex++; 454 } 455 return currentOutputIndex; 456 } 457 458 /** 459 * Combines the national number with any prefix (IDD/+ and country code or national prefix) that 460 * was collected. A space will be inserted between them if the current formatting template 461 * indicates this to be suitable. 462 */ 463 private String appendNationalNumber(String nationalNumber) { 464 int prefixBeforeNationalNumberLength = prefixBeforeNationalNumber.length(); 465 if (shouldAddSpaceAfterNationalPrefix && prefixBeforeNationalNumberLength > 0 && 466 prefixBeforeNationalNumber.charAt(prefixBeforeNationalNumberLength - 1) 467 != SEPARATOR_BEFORE_NATIONAL_NUMBER) { 468 // We want to add a space after the national prefix if the national prefix formatting rule 469 // indicates that this would normally be done, with the exception of the case where we already 470 // appended a space because the NDD was surprisingly long. 471 return new String(prefixBeforeNationalNumber) + SEPARATOR_BEFORE_NATIONAL_NUMBER 472 + nationalNumber; 473 } else { 474 return prefixBeforeNationalNumber + nationalNumber; 475 } 476 } 477 478 /** 479 * Attempts to set the formatting template and returns a string which contains the formatted 480 * version of the digits entered so far. 481 */ 482 private String attemptToChooseFormattingPattern() { 483 // We start to attempt to format only when at least MIN_LEADING_DIGITS_LENGTH digits of national 484 // number (excluding national prefix) have been entered. 485 if (nationalNumber.length() >= MIN_LEADING_DIGITS_LENGTH) { 486 487 getAvailableFormats(nationalNumber.toString()); 488 // See if the accrued digits can be formatted properly already. 489 String formattedNumber = attemptToFormatAccruedDigits(); 490 if (formattedNumber.length() > 0) { 491 return formattedNumber; 492 } 493 return maybeCreateNewTemplate() ? inputAccruedNationalNumber() : accruedInput.toString(); 494 } else { 495 return appendNationalNumber(nationalNumber.toString()); 496 } 497 } 498 499 /** 500 * Invokes inputDigitHelper on each digit of the national number accrued, and returns a formatted 501 * string in the end. 502 */ 503 private String inputAccruedNationalNumber() { 504 int lengthOfNationalNumber = nationalNumber.length(); 505 if (lengthOfNationalNumber > 0) { 506 String tempNationalNumber = ""; 507 for (int i = 0; i < lengthOfNationalNumber; i++) { 508 tempNationalNumber = inputDigitHelper(nationalNumber.charAt(i)); 509 } 510 return ableToFormat ? appendNationalNumber(tempNationalNumber) : accruedInput.toString(); 511 } else { 512 return prefixBeforeNationalNumber.toString(); 513 } 514 } 515 516 /** 517 * Returns true if the current country is a NANPA country and the national number begins with 518 * the national prefix. 519 */ 520 private boolean isNanpaNumberWithNationalPrefix() { 521 // For NANPA numbers beginning with 1[2-9], treat the 1 as the national prefix. The reason is 522 // that national significant numbers in NANPA always start with [2-9] after the national prefix. 523 // Numbers beginning with 1[01] can only be short/emergency numbers, which don't need the 524 // national prefix. 525 return (currentMetadata.getCountryCode() == 1) && (nationalNumber.charAt(0) == '1') && 526 (nationalNumber.charAt(1) != '0') && (nationalNumber.charAt(1) != '1'); 527 } 528 529 // Returns the national prefix extracted, or an empty string if it is not present. 530 private String removeNationalPrefixFromNationalNumber() { 531 int startOfNationalNumber = 0; 532 if (isNanpaNumberWithNationalPrefix()) { 533 startOfNationalNumber = 1; 534 prefixBeforeNationalNumber.append('1').append(SEPARATOR_BEFORE_NATIONAL_NUMBER); 535 isCompleteNumber = true; 536 } else if (currentMetadata.hasNationalPrefixForParsing()) { 537 Pattern nationalPrefixForParsing = 538 regexCache.getPatternForRegex(currentMetadata.getNationalPrefixForParsing()); 539 Matcher m = nationalPrefixForParsing.matcher(nationalNumber); 540 // Since some national prefix patterns are entirely optional, check that a national prefix 541 // could actually be extracted. 542 if (m.lookingAt() && m.end() > 0) { 543 // When the national prefix is detected, we use international formatting rules instead of 544 // national ones, because national formatting rules could contain local formatting rules 545 // for numbers entered without area code. 546 isCompleteNumber = true; 547 startOfNationalNumber = m.end(); 548 prefixBeforeNationalNumber.append(nationalNumber.substring(0, startOfNationalNumber)); 549 } 550 } 551 String nationalPrefix = nationalNumber.substring(0, startOfNationalNumber); 552 nationalNumber.delete(0, startOfNationalNumber); 553 return nationalPrefix; 554 } 555 556 /** 557 * Extracts IDD and plus sign to prefixBeforeNationalNumber when they are available, and places 558 * the remaining input into nationalNumber. 559 * 560 * @return true when accruedInputWithoutFormatting begins with the plus sign or valid IDD for 561 * defaultCountry. 562 */ 563 private boolean attemptToExtractIdd() { 564 Pattern internationalPrefix = 565 regexCache.getPatternForRegex("\\" + PhoneNumberUtil.PLUS_SIGN + "|" + 566 currentMetadata.getInternationalPrefix()); 567 Matcher iddMatcher = internationalPrefix.matcher(accruedInputWithoutFormatting); 568 if (iddMatcher.lookingAt()) { 569 isCompleteNumber = true; 570 int startOfCountryCallingCode = iddMatcher.end(); 571 nationalNumber.setLength(0); 572 nationalNumber.append(accruedInputWithoutFormatting.substring(startOfCountryCallingCode)); 573 prefixBeforeNationalNumber.setLength(0); 574 prefixBeforeNationalNumber.append( 575 accruedInputWithoutFormatting.substring(0, startOfCountryCallingCode)); 576 if (accruedInputWithoutFormatting.charAt(0) != PhoneNumberUtil.PLUS_SIGN) { 577 prefixBeforeNationalNumber.append(SEPARATOR_BEFORE_NATIONAL_NUMBER); 578 } 579 return true; 580 } 581 return false; 582 } 583 584 /** 585 * Extracts the country calling code from the beginning of nationalNumber to 586 * prefixBeforeNationalNumber when they are available, and places the remaining input into 587 * nationalNumber. 588 * 589 * @return true when a valid country calling code can be found. 590 */ 591 private boolean attemptToExtractCountryCallingCode() { 592 if (nationalNumber.length() == 0) { 593 return false; 594 } 595 StringBuilder numberWithoutCountryCallingCode = new StringBuilder(); 596 int countryCode = phoneUtil.extractCountryCode(nationalNumber, numberWithoutCountryCallingCode); 597 if (countryCode == 0) { 598 return false; 599 } 600 nationalNumber.setLength(0); 601 nationalNumber.append(numberWithoutCountryCallingCode); 602 String newRegionCode = phoneUtil.getRegionCodeForCountryCode(countryCode); 603 if (PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY.equals(newRegionCode)) { 604 currentMetadata = phoneUtil.getMetadataForNonGeographicalRegion(countryCode); 605 } else if (!newRegionCode.equals(defaultCountry)) { 606 currentMetadata = getMetadataForRegion(newRegionCode); 607 } 608 String countryCodeString = Integer.toString(countryCode); 609 prefixBeforeNationalNumber.append(countryCodeString).append(SEPARATOR_BEFORE_NATIONAL_NUMBER); 610 // When we have successfully extracted the IDD, the previously extracted NDD should be cleared 611 // because it is no longer valid. 612 extractedNationalPrefix = ""; 613 return true; 614 } 615 616 // Accrues digits and the plus sign to accruedInputWithoutFormatting for later use. If nextChar 617 // contains a digit in non-ASCII format (e.g. the full-width version of digits), it is first 618 // normalized to the ASCII version. The return value is nextChar itself, or its normalized 619 // version, if nextChar is a digit in non-ASCII format. This method assumes its input is either a 620 // digit or the plus sign. 621 private char normalizeAndAccrueDigitsAndPlusSign(char nextChar, boolean rememberPosition) { 622 char normalizedChar; 623 if (nextChar == PhoneNumberUtil.PLUS_SIGN) { 624 normalizedChar = nextChar; 625 accruedInputWithoutFormatting.append(nextChar); 626 } else { 627 int radix = 10; 628 normalizedChar = Character.forDigit(Character.digit(nextChar, radix), radix); 629 accruedInputWithoutFormatting.append(normalizedChar); 630 nationalNumber.append(normalizedChar); 631 } 632 if (rememberPosition) { 633 positionToRemember = accruedInputWithoutFormatting.length(); 634 } 635 return normalizedChar; 636 } 637 638 private String inputDigitHelper(char nextChar) { 639 Matcher digitMatcher = DIGIT_PATTERN.matcher(formattingTemplate); 640 if (digitMatcher.find(lastMatchPosition)) { 641 String tempTemplate = digitMatcher.replaceFirst(Character.toString(nextChar)); 642 formattingTemplate.replace(0, tempTemplate.length(), tempTemplate); 643 lastMatchPosition = digitMatcher.start(); 644 return formattingTemplate.substring(0, lastMatchPosition + 1); 645 } else { 646 if (possibleFormats.size() == 1) { 647 // More digits are entered than we could handle, and there are no other valid patterns to 648 // try. 649 ableToFormat = false; 650 } // else, we just reset the formatting pattern. 651 currentFormattingPattern = ""; 652 return accruedInput.toString(); 653 } 654 } 655 } 656