java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java

   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.google.i18n.phonenumbers;
  18
  19 import com.google.i18n.phonenumbers.Phonemetadata.NumberFormat;
  20 import com.google.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 leadingThreeDigits) {
 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(leadingThreeDigits);
 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() > indexOfLeadingDigitsPattern) {
 203         Pattern leadingDigitsPattern =
 204             regexCache.getPatternForRegex(
 205                 format.getLeadingDigitsPattern(indexOfLeadingDigitsPattern));
 206         Matcher m = leadingDigitsPattern.matcher(leadingDigits);
 207         if (!m.lookingAt()) {
 208           it.remove();
 209         }
 210       } // else the particular format has no more specific leadingDigitsPattern, and it should be
 211         // retained.
 212     }
 213   }
 214
 215   private boolean createFormattingTemplate(NumberFormat format) {
 216     String numberPattern = format.getPattern();
 217
 218     // The formatter doesn't format numbers when numberPattern contains "|", e.g.
 219     // (20|3)\d{4}. In those cases we quickly return.
 220     if (numberPattern.indexOf('|') != -1) {
 221       return false;
 222     }
 223
 224     // Replace anything in the form of [..] with \d
 225     numberPattern = CHARACTER_CLASS_PATTERN.matcher(numberPattern).replaceAll("\\\\d");
 226
 227     // Replace any standalone digit (not the one in d{}) with \d
 228     numberPattern = STANDALONE_DIGIT_PATTERN.matcher(numberPattern).replaceAll("\\\\d");
 229     formattingTemplate.setLength(0);
 230     String tempTemplate = getFormattingTemplate(numberPattern, format.getFormat());
 231     if (tempTemplate.length() > 0) {
 232       formattingTemplate.append(tempTemplate);
 233       return true;
 234     }
 235     return false;
 236   }
 237
 238   // Gets a formatting template which can be used to efficiently format a partial number where
 239   // digits are added one by one.
 240   private String getFormattingTemplate(String numberPattern, String numberFormat) {
 241     // Creates a phone number consisting only of the digit 9 that matches the
 242     // numberPattern by applying the pattern to the longestPhoneNumber string.
 243     String longestPhoneNumber = "999999999999999";
 244     Matcher m = regexCache.getPatternForRegex(numberPattern).matcher(longestPhoneNumber);
 245     m.find();  // this will always succeed
 246     String aPhoneNumber = m.group();
 247     // No formatting template can be created if the number of digits entered so far is longer than
 248     // the maximum the current formatting rule can accommodate.
 249     if (aPhoneNumber.length() < nationalNumber.length()) {
 250       return "";
 251     }
 252     // Formats the number according to numberFormat
 253     String template = aPhoneNumber.replaceAll(numberPattern, numberFormat);
 254     // Replaces each digit with character DIGIT_PLACEHOLDER
 255     template = template.replaceAll("9", DIGIT_PLACEHOLDER);
 256     return template;
 257   }
 258
 259   /**
 260    * Clears the internal state of the formatter, so it can be reused.
 261    */
 262   public void clear() {
 263     currentOutput = "";
 264     accruedInput.setLength(0);
 265     accruedInputWithoutFormatting.setLength(0);
 266     formattingTemplate.setLength(0);
 267     lastMatchPosition = 0;
 268     currentFormattingPattern = "";
 269     prefixBeforeNationalNumber.setLength(0);
 270     extractedNationalPrefix = "";
 271     nationalNumber.setLength(0);
 272     ableToFormat = true;
 273     inputHasFormatting = false;
 274     positionToRemember = 0;
 275     originalPosition = 0;
 276     isCompleteNumber = false;
 277     isExpectingCountryCallingCode = false;
 278     possibleFormats.clear();
 279     shouldAddSpaceAfterNationalPrefix = false;
 280     if (!currentMetadata.equals(defaultMetadata)) {
 281       currentMetadata = getMetadataForRegion(defaultCountry);
 282     }
 283   }
 284
 285   /**
 286    * Formats a phone number on-the-fly as each digit is entered.
 287    *
 288    * @param nextChar  the most recently entered digit of a phone number. Formatting characters are
 289    *     allowed, but as soon as they are encountered this method formats the number as entered and
 290    *     not "as you type" anymore. Full width digits and Arabic-indic digits are allowed, and will
 291    *     be shown as they are.
 292    * @return  the partially formatted phone number.
 293    */
 294   public String inputDigit(char nextChar) {
 295     currentOutput = inputDigitWithOptionToRememberPosition(nextChar, false);
 296     return currentOutput;
 297   }
 298
 299   /**
 300    * Same as {@link #inputDigit}, but remembers the position where {@code nextChar} is inserted, so
 301    * that it can be retrieved later by using {@link #getRememberedPosition}. The remembered
 302    * position will be automatically adjusted if additional formatting characters are later
 303    * inserted/removed in front of {@code nextChar}.
 304    */
 305   public String inputDigitAndRememberPosition(char nextChar) {
 306     currentOutput = inputDigitWithOptionToRememberPosition(nextChar, true);
 307     return currentOutput;
 308   }
 309
 310   @SuppressWarnings("fallthrough")
 311   private String inputDigitWithOptionToRememberPosition(char nextChar, boolean rememberPosition) {
 312     accruedInput.append(nextChar);
 313     if (rememberPosition) {
 314       originalPosition = accruedInput.length();
 315     }
 316     // We do formatting on-the-fly only when each character entered is either a digit, or a plus
 317     // sign (accepted at the start of the number only).
 318     if (!isDigitOrLeadingPlusSign(nextChar)) {
 319       ableToFormat = false;
 320       inputHasFormatting = true;
 321     } else {
 322       nextChar = normalizeAndAccrueDigitsAndPlusSign(nextChar, rememberPosition);
 323     }
 324     if (!ableToFormat) {
 325       // When we are unable to format because of reasons other than that formatting chars have been
 326       // entered, it can be due to really long IDDs or NDDs. If that is the case, we might be able
 327       // to do formatting again after extracting them.
 328       if (inputHasFormatting) {
 329         return accruedInput.toString();
 330       } else if (attemptToExtractIdd()) {
 331         if (attemptToExtractCountryCallingCode()) {
 332           return attemptToChoosePatternWithPrefixExtracted();
 333         }
 334       } else if (ableToExtractLongerNdd()) {
 335         // Add an additional space to separate long NDD and national significant number for
 336         // readability. We don't set shouldAddSpaceAfterNationalPrefix to true, since we don't want
 337         // this to change later when we choose formatting templates.
 338         prefixBeforeNationalNumber.append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
 339         return attemptToChoosePatternWithPrefixExtracted();
 340       }
 341       return accruedInput.toString();
 342     }
 343
 344     // We start to attempt to format only when at least MIN_LEADING_DIGITS_LENGTH digits (the plus
 345     // sign is counted as a digit as well for this purpose) have been entered.
 346     switch (accruedInputWithoutFormatting.length()) {
 347       case 0:
 348       case 1:
 349       case 2:
 350         return accruedInput.toString();
 351       case 3:
 352         if (attemptToExtractIdd()) {
 353           isExpectingCountryCallingCode = true;
 354         } else {  // No IDD or plus sign is found, might be entering in national format.
 355           extractedNationalPrefix = removeNationalPrefixFromNationalNumber();
 356           return attemptToChooseFormattingPattern();
 357         }
 358       default:
 359         if (isExpectingCountryCallingCode) {
 360           if (attemptToExtractCountryCallingCode()) {
 361             isExpectingCountryCallingCode = false;
 362           }
 363           return prefixBeforeNationalNumber + nationalNumber.toString();
 364         }
 365         if (possibleFormats.size() > 0) {  // The formatting pattern is already chosen.
 366           String tempNationalNumber = inputDigitHelper(nextChar);
 367           // See if the accrued digits can be formatted properly already. If not, use the results
 368           // from inputDigitHelper, which does formatting based on the formatting pattern chosen.
 369           String formattedNumber = attemptToFormatAccruedDigits();
 370           if (formattedNumber.length() > 0) {
 371             return formattedNumber;
 372           }
 373           narrowDownPossibleFormats(nationalNumber.toString());
 374           if (maybeCreateNewTemplate()) {
 375             return inputAccruedNationalNumber();
 376           }
 377           return ableToFormat
 378              ? appendNationalNumber(tempNationalNumber)
 379              : accruedInput.toString();
 380         } else {
 381           return attemptToChooseFormattingPattern();
 382         }
 383     }
 384   }
 385
 386   private String attemptToChoosePatternWithPrefixExtracted() {
 387     ableToFormat = true;
 388     isExpectingCountryCallingCode = false;
 389     possibleFormats.clear();
 390     return attemptToChooseFormattingPattern();
 391   }
 392
 393   // @VisibleForTesting
 394   String getExtractedNationalPrefix() {
 395     return extractedNationalPrefix;
 396   }
 397
 398   // Some national prefixes are a substring of others. If extracting the shorter NDD doesn't result
 399   // in a number we can format, we try to see if we can extract a longer version here.
 400   private boolean ableToExtractLongerNdd() {
 401     if (extractedNationalPrefix.length() > 0) {
 402       // Put the extracted NDD back to the national number before attempting to extract a new NDD.
 403       nationalNumber.insert(0, extractedNationalPrefix);
 404       // Remove the previously extracted NDD from prefixBeforeNationalNumber. We cannot simply set
 405       // it to empty string because people sometimes incorrectly enter national prefix after the
 406       // country code, e.g. +44 (0)20-1234-5678.
 407       int indexOfPreviousNdd = prefixBeforeNationalNumber.lastIndexOf(extractedNationalPrefix);
 408       prefixBeforeNationalNumber.setLength(indexOfPreviousNdd);
 409     }
 410     return !extractedNationalPrefix.equals(removeNationalPrefixFromNationalNumber());
 411   }
 412
 413   private boolean isDigitOrLeadingPlusSign(char nextChar) {
 414     return Character.isDigit(nextChar) ||
 415         (accruedInput.length() == 1 &&
 416          PhoneNumberUtil.PLUS_CHARS_PATTERN.matcher(Character.toString(nextChar)).matches());
 417   }
 418
 419   /**
 420    * Check to see if there is an exact pattern match for these digits. If so, we should use this
 421    * instead of any other formatting template whose leadingDigitsPattern also matches the input.
 422    */
 423   String attemptToFormatAccruedDigits() {
 424     for (NumberFormat numberFormat : possibleFormats) {
 425       Matcher m = regexCache.getPatternForRegex(numberFormat.getPattern()).matcher(nationalNumber);
 426       if (m.matches()) {
 427         shouldAddSpaceAfterNationalPrefix =
 428             NATIONAL_PREFIX_SEPARATORS_PATTERN.matcher(
 429                 numberFormat.getNationalPrefixFormattingRule()).find();
 430         String formattedNumber = m.replaceAll(numberFormat.getFormat());
 431         return appendNationalNumber(formattedNumber);
 432       }
 433     }
 434     return "";
 435   }
 436
 437   /**
 438    * Returns the current position in the partially formatted phone number of the character which was
 439    * previously passed in as the parameter of {@link #inputDigitAndRememberPosition}.
 440    */
 441   public int getRememberedPosition() {
 442     if (!ableToFormat) {
 443       return originalPosition;
 444     }
 445     int accruedInputIndex = 0, currentOutputIndex = 0;
 446     while (accruedInputIndex < positionToRemember && currentOutputIndex < currentOutput.length()) {
 447       if (accruedInputWithoutFormatting.charAt(accruedInputIndex) ==
 448           currentOutput.charAt(currentOutputIndex)) {
 449         accruedInputIndex++;
 450       }
 451       currentOutputIndex++;
 452     }
 453     return currentOutputIndex;
 454   }
 455
 456   /**
 457    * Combines the national number with any prefix (IDD/+ and country code or national prefix) that
 458    * was collected. A space will be inserted between them if the current formatting template
 459    * indicates this to be suitable.
 460    */
 461   private String appendNationalNumber(String nationalNumber) {
 462     int prefixBeforeNationalNumberLength = prefixBeforeNationalNumber.length();
 463     if (shouldAddSpaceAfterNationalPrefix && prefixBeforeNationalNumberLength > 0 &&
 464         prefixBeforeNationalNumber.charAt(prefixBeforeNationalNumberLength - 1)
 465             != SEPARATOR_BEFORE_NATIONAL_NUMBER) {
 466       // We want to add a space after the national prefix if the national prefix formatting rule
 467       // indicates that this would normally be done, with the exception of the case where we already
 468       // appended a space because the NDD was surprisingly long.
 469       return new String(prefixBeforeNationalNumber) + SEPARATOR_BEFORE_NATIONAL_NUMBER
 470           + nationalNumber;
 471     } else {
 472       return prefixBeforeNationalNumber + nationalNumber;
 473     }
 474   }
 475
 476   /**
 477    * Attempts to set the formatting template and returns a string which contains the formatted
 478    * version of the digits entered so far.
 479    */
 480   private String attemptToChooseFormattingPattern() {
 481     // We start to attempt to format only when at least MIN_LEADING_DIGITS_LENGTH digits of national
 482     // number (excluding national prefix) have been entered.
 483     if (nationalNumber.length() >= MIN_LEADING_DIGITS_LENGTH) {
 484       getAvailableFormats(nationalNumber.substring(0, MIN_LEADING_DIGITS_LENGTH));
 485       // See if the accrued digits can be formatted properly already.
 486       String formattedNumber = attemptToFormatAccruedDigits();
 487       if (formattedNumber.length() > 0) {
 488         return formattedNumber;
 489       }
 490       return maybeCreateNewTemplate() ? inputAccruedNationalNumber() : accruedInput.toString();
 491     } else {
 492       return appendNationalNumber(nationalNumber.toString());
 493     }
 494   }
 495
 496   /**
 497    * Invokes inputDigitHelper on each digit of the national number accrued, and returns a formatted
 498    * string in the end.
 499    */
 500   private String inputAccruedNationalNumber() {
 501     int lengthOfNationalNumber = nationalNumber.length();
 502     if (lengthOfNationalNumber > 0) {
 503       String tempNationalNumber = "";
 504       for (int i = 0; i < lengthOfNationalNumber; i++) {
 505         tempNationalNumber = inputDigitHelper(nationalNumber.charAt(i));
 506       }
 507       return ableToFormat ? appendNationalNumber(tempNationalNumber) : accruedInput.toString();
 508     } else {
 509       return prefixBeforeNationalNumber.toString();
 510     }
 511   }
 512
 513   /**
 514    * Returns true if the current country is a NANPA country and the national number begins with
 515    * the national prefix.
 516    */
 517   private boolean isNanpaNumberWithNationalPrefix() {
 518     // For NANPA numbers beginning with 1[2-9], treat the 1 as the national prefix. The reason is
 519     // that national significant numbers in NANPA always start with [2-9] after the national prefix.
 520     // Numbers beginning with 1[01] can only be short/emergency numbers, which don't need the
 521     // national prefix.
 522     return (currentMetadata.getCountryCode() == 1) && (nationalNumber.charAt(0) == '1') &&
 523            (nationalNumber.charAt(1) != '0') && (nationalNumber.charAt(1) != '1');
 524   }
 525
 526   // Returns the national prefix extracted, or an empty string if it is not present.
 527   private String removeNationalPrefixFromNationalNumber() {
 528     int startOfNationalNumber = 0;
 529     if (isNanpaNumberWithNationalPrefix()) {
 530       startOfNationalNumber = 1;
 531       prefixBeforeNationalNumber.append('1').append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
 532       isCompleteNumber = true;
 533     } else if (currentMetadata.hasNationalPrefixForParsing()) {
 534       Pattern nationalPrefixForParsing =
 535           regexCache.getPatternForRegex(currentMetadata.getNationalPrefixForParsing());
 536       Matcher m = nationalPrefixForParsing.matcher(nationalNumber);
 537       // Since some national prefix patterns are entirely optional, check that a national prefix
 538       // could actually be extracted.
 539       if (m.lookingAt() && m.end() > 0) {
 540         // When the national prefix is detected, we use international formatting rules instead of
 541         // national ones, because national formatting rules could contain local formatting rules
 542         // for numbers entered without area code.
 543         isCompleteNumber = true;
 544         startOfNationalNumber = m.end();
 545         prefixBeforeNationalNumber.append(nationalNumber.substring(0, startOfNationalNumber));
 546       }
 547     }
 548     String nationalPrefix = nationalNumber.substring(0, startOfNationalNumber);
 549     nationalNumber.delete(0, startOfNationalNumber);
 550     return nationalPrefix;
 551   }
 552
 553   /**
 554    * Extracts IDD and plus sign to prefixBeforeNationalNumber when they are available, and places
 555    * the remaining input into nationalNumber.
 556    *
 557    * @return  true when accruedInputWithoutFormatting begins with the plus sign or valid IDD for
 558    *     defaultCountry.
 559    */
 560   private boolean attemptToExtractIdd() {
 561     Pattern internationalPrefix =
 562         regexCache.getPatternForRegex("\\" + PhoneNumberUtil.PLUS_SIGN + "|" +
 563             currentMetadata.getInternationalPrefix());
 564     Matcher iddMatcher = internationalPrefix.matcher(accruedInputWithoutFormatting);
 565     if (iddMatcher.lookingAt()) {
 566       isCompleteNumber = true;
 567       int startOfCountryCallingCode = iddMatcher.end();
 568       nationalNumber.setLength(0);
 569       nationalNumber.append(accruedInputWithoutFormatting.substring(startOfCountryCallingCode));
 570       prefixBeforeNationalNumber.setLength(0);
 571       prefixBeforeNationalNumber.append(
 572           accruedInputWithoutFormatting.substring(0, startOfCountryCallingCode));
 573       if (accruedInputWithoutFormatting.charAt(0) != PhoneNumberUtil.PLUS_SIGN) {
 574         prefixBeforeNationalNumber.append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
 575       }
 576       return true;
 577     }
 578     return false;
 579   }
 580
 581   /**
 582    * Extracts the country calling code from the beginning of nationalNumber to
 583    * prefixBeforeNationalNumber when they are available, and places the remaining input into
 584    * nationalNumber.
 585    *
 586    * @return  true when a valid country calling code can be found.
 587    */
 588   private boolean attemptToExtractCountryCallingCode() {
 589     if (nationalNumber.length() == 0) {
 590       return false;
 591     }
 592     StringBuilder numberWithoutCountryCallingCode = new StringBuilder();
 593     int countryCode = phoneUtil.extractCountryCode(nationalNumber, numberWithoutCountryCallingCode);
 594     if (countryCode == 0) {
 595       return false;
 596     }
 597     nationalNumber.setLength(0);
 598     nationalNumber.append(numberWithoutCountryCallingCode);
 599     String newRegionCode = phoneUtil.getRegionCodeForCountryCode(countryCode);
 600     if (PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY.equals(newRegionCode)) {
 601       currentMetadata = phoneUtil.getMetadataForNonGeographicalRegion(countryCode);
 602     } else if (!newRegionCode.equals(defaultCountry)) {
 603       currentMetadata = getMetadataForRegion(newRegionCode);
 604     }
 605     String countryCodeString = Integer.toString(countryCode);
 606     prefixBeforeNationalNumber.append(countryCodeString).append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
 607     // When we have successfully extracted the IDD, the previously extracted NDD should be cleared
 608     // because it is no longer valid.
 609     extractedNationalPrefix = "";
 610     return true;
 611   }
 612
 613   // Accrues digits and the plus sign to accruedInputWithoutFormatting for later use. If nextChar
 614   // contains a digit in non-ASCII format (e.g. the full-width version of digits), it is first
 615   // normalized to the ASCII version. The return value is nextChar itself, or its normalized
 616   // version, if nextChar is a digit in non-ASCII format. This method assumes its input is either a
 617   // digit or the plus sign.
 618   private char normalizeAndAccrueDigitsAndPlusSign(char nextChar, boolean rememberPosition) {
 619     char normalizedChar;
 620     if (nextChar == PhoneNumberUtil.PLUS_SIGN) {
 621       normalizedChar = nextChar;
 622       accruedInputWithoutFormatting.append(nextChar);
 623     } else {
 624       int radix = 10;
 625       normalizedChar = Character.forDigit(Character.digit(nextChar, radix), radix);
 626       accruedInputWithoutFormatting.append(normalizedChar);
 627       nationalNumber.append(normalizedChar);
 628     }
 629     if (rememberPosition) {
 630       positionToRemember = accruedInputWithoutFormatting.length();
 631     }
 632     return normalizedChar;
 633   }
 634
 635   private String inputDigitHelper(char nextChar) {
 636     Matcher digitMatcher = DIGIT_PATTERN.matcher(formattingTemplate);
 637     if (digitMatcher.find(lastMatchPosition)) {
 638       String tempTemplate = digitMatcher.replaceFirst(Character.toString(nextChar));
 639       formattingTemplate.replace(0, tempTemplate.length(), tempTemplate);
 640       lastMatchPosition = digitMatcher.start();
 641       return formattingTemplate.substring(0, lastMatchPosition + 1);
 642     } else {
 643       if (possibleFormats.size() == 1) {
 644         // More digits are entered than we could handle, and there are no other valid patterns to
 645         // try.
 646         ableToFormat = false;
 647       }  // else, we just reset the formatting pattern.
 648       currentFormattingPattern = "";
 649       return accruedInput.toString();
 650     }
 651   }
 652 }