PhoneNumbers A utility that maps phone number prefixes to a string describing the geographical area the prefix covers. Creates an empty {@link AreaCodeMap}. The default constructor is necessary for implementing {@link Externalizable}. The empty map could later be populated by {@link #readAreaCodeMap(java.util.SortedMap)} or {@link #readExternal(java.io.ObjectInput)}. Gets the size of the provided area code map storage. The map storage passed-in will be filled as a result. Gets the smaller area code map storage strategy according to the provided area code map. It actually uses (outputs the data to a stream) both strategies and retains the best one which make this method quite expensive. Creates an initialized with sortedAreaCodeMap. Note that the underlying implementation of this method is expensive thus should not be called by time-critical applications. A map from phone number prefixes to descriptions of corresponding geographical areas, sorted in ascending order of the phone number prefixes as integers. Returns the description of the geographical area the number corresponds to. This method distinguishes the case of an invalid prefix and a prefix for which the name is not available in the current language. If the description is not available in the current language an empty string is returned. If no description was found for the provided number, null is returned. The phone number to look up. The description of the geographical area. Does a binary search for value in the provided array from start to end (inclusive). Returns the position if value is found; otherwise, returns the position which has the largest value that is less than value. This means if value is the smallest, -1 will be returned. Dumps the mappings contained in the area code map. Abstracts the way area code data is stored into memory and serialized to a stream. It is used by to support the most space-efficient storage strategy according to the provided data. Gets the phone number prefix located at the provided index. The index of the prefix that needs to be returned. The phone number prefix at the provided index. Gets the description corresponding to the phone number prefix located at the provided index. If the description is not available in the current language an empty string is returned. The index of the phone number prefix that needs to be returned. The description corresponding to the phone number prefix at the provided index. Sets the internal state of the underlying storage implementation from the provided sortedAreaCodeMap that maps phone number prefixes to description strings. A sorted map that maps phone number prefixes including country calling code to description strings. The number of entries contained in the area code map. The number of entries contained in the area code map. The set containing the possible lengths of prefixes. The set containing the possible lengths of prefixes. A utility that generates the binary serialization of the area code/location mappings from human-readable text files. It also generates a configuration file which contains information on data files available for use. The text files must be located in sub-directories of the provided input path. For each input file inputPath/lang/countryCallingCode.txt the corresponding binary file is generated as outputPath/countryCallingCode_lang. A formatter which formats phone numbers as they are entered. An AsYouTypeFormatter can be created by invoking . After that, digits can be added by invoking on the formatter instance, and the partially formatted phone number will be returned each time a digit is added. {@link #clear} can be invoked before formatting a new number. See the unittests for more details on how the formatter is to be used. Constructs an as-you-type formatter. Should be obtained from . The country/region where the phone number is being entered. Clears the internal state of the formatter, so it can be reused. Formats a phone number on-the-fly as each digit is entered. The most recently entered digit of a phone number. Formatting characters are allowed, but as soon as they are encountered this method formats the number as entered and not "as you type" anymore. Full width digits and Arabic-indic digits are allowed, and will be shown as they are. The partially formatted phone number. Same as , but remembers the position where nextChar is inserted, so that it can be retrieved later by using . The remembered position will be automatically adjusted if additional formatting characters are later inserted/removed in front of nextChar. Checks to see if there is an exact pattern match for these digits. If so, we should use this instead of any other formatting template whose leadingDigitsPattern also matches the input. Returns the current position in the partially formatted phone number of the character which was previously passed in as the parameter of {@link #inputDigitAndRememberPosition}. Combines the national number with any prefix (IDD/+ and country code or national prefix) that was collected. A space will be inserted between them if the current formatting template indicates this to be suitable. Returns true if the current country is a NANPA country and the national number begins with the national prefix. Extracts IDD and plus sign to prefixBeforeNationalNumber when they are available, and places the remaining input into nationalNumber. True when accruedInputWithoutFormatting begins with the plus sign or valid IDD for defaultCountry. Extracts the country calling code from the beginning of nationalNumber to prefixBeforeNationalNumber when they are available, and places the remaining input into nationalNumber. True when a valid country calling code can be found. Returns the national prefix of the provided country element. Extracts the pattern for international format. If there is no intlFormat, default to using the national format. If the intlFormat is set to "NA" the intlFormat should be ignored. @throws RuntimeException if multiple intlFormats have been encountered. @return whether an international number format is defined. Extracts the pattern for the national format. @throws RuntimeException if multiple or no formats have been encountered. @return the national format string. Extracts the available formats from the provided DOM element. If it does not contain any nationalPrefixFormattingRule, the one passed-in is retained. The nationalPrefix, nationalPrefixFormattingRule and nationalPrefixOptionalWhenFormatting values are provided from the parent (territory) element. Checks if the possible lengths provided as a sorted set are equal to the possible lengths stored already in the description pattern. Note that possibleLengths may be empty but must not be null, and the PhoneNumberDesc passed in should also not be null. Processes a phone number description element from the XML file and returns it as a PhoneNumberDesc. If the description element is a fixed line or mobile number, the parent description will be used to fill in the whole element if necessary, or any components that are missing. For all other types, the parent description will only be used to fill in missing components if the type has a partial definition. For example, if no "tollFree" element exists, we assume there are no toll free numbers for that locale, and return a phone number description with no national number data and [-1] for the possible lengths. Note that the parent description must therefore already be processed before this method is called on any child elements. @param generalDesc a generic phone number description that will be used to fill in missing parts of the description @param countryElement the XML element representing all the country information @param numberType the name of the number type, corresponding to the appropriate tag in the XML file with information about that type @return complete description of that phone number type Reads the possible lengths present in the metadata and splits them into two sets: one for full-length numbers, one for local numbers. @param data one or more phone number descriptions, represented as XML nodes @param lengths a set to which to add possible lengths of full phone numbers @param localOnlyLengths a set to which to add possible lengths of phone numbers only diallable locally (e.g. within a province) Sets possible lengths in the general description, derived from certain child elements. Sets the possible length fields in the metadata from the sets of data passed in. Checks that the length is covered by the "parent" phone number description element if one is present, and if the lengths are exactly the same as this, they are not filled in for efficiency reasons. @param parentDesc the "general description" element or null if desc is the generalDesc itself @param desc the PhoneNumberDesc object that we are going to set lengths for * Processes the custom build flags and gets a {@code MetadataFilter} which may be used to * filter {@code PhoneMetadata} objects. Incompatible flag combinations throw RuntimeException. * * @param liteBuild The liteBuild flag value as given by the command-line * @param specialBuild The specialBuild flag value as given by the command-line Default area code map storage strategy that is used for data not containing description duplications. It is mainly intended to avoid the overhead of the string table management when it is actually unnecessary (i.e no string duplication). @author Shaopeng Jia Flyweight area code map storage strategy that uses a table to store unique strings and shorts to store the prefix and description indexes when possible. It is particularly space-efficient when the provided area code map contains a lot of description redundant descriptions. @author Philippe Liard This implementation returns the same string (same identity) when called for multiple indexes corresponding to prefixes that have the same description. Creates the description pool from the provided set of string descriptions and area code map. Gets the minimum number of bytes that can be used to store the provided {@code value}. Stores the provided {@code value} to the provided byte {@code buffer} at the specified {@code index} using the provided {@code wordSize} in bytes. Note that only integer and short sizes are supported. @param buffer the byte buffer to which the value is stored @param wordSize the number of bytes used to store the provided value @param index the index to which the value is stored @param value the value that is stored assuming it does not require more than the specified number of bytes. Reads the {@code value} at the specified {@code index} from the provided byte {@code buffer}. Note that only integer and short sizes are supported. @param buffer the byte buffer from which the value is read @param wordSize the number of bytes used to store the value @param index the index where the value is read from @return the value read from the buffer This utility class determines the correct set of to specify when creating instances at runtime within this library. Internal phonenumber matching API used to isolate the underlying implementation of the matcher and allow different implementations to be swapped in easily. Returns whether the given national number (a string containing only decimal digits) matches the national number pattern defined in the given {@code PhoneNumberDesc} message. A utility which knows the data files that are available for the geocoder to use. The data files contain mappings from phone number prefixes to text descriptions, and are organized by country calling code and language that the text descriptions are in. @author Shaopeng Jia Creates an empty {@link MappingFileProvider}. The default constructor is necessary for implementing {@link Externalizable}. The empty provider could later be populated by {@link #readFileConfigs(java.util.SortedMap)} or {@link #readExternal(java.io.ObjectInput)}. Initializes an {@link MappingFileProvider} with {@code availableDataFiles}. @param availableDataFiles a map from country calling codes to sets of languages in which data files are available for the specific country calling code. The map is sorted in ascending order of the country calling codes as integers. Returns a string representing the data in this class. The string contains one line for each country calling code. The country calling code is followed by a '|' and then a list of comma-separated languages sorted in ascending order. Gets the name of the file that contains the mapping data for the {@code countryCallingCode} in the language specified. @param countryCallingCode the country calling code of phone numbers which the data file contains @param language two-letter lowercase ISO language codes as defined by ISO 639-1 @param script four-letter titlecase (the first letter is uppercase and the rest of the letters are lowercase) ISO script codes as defined in ISO 15924 @param region two-letter uppercase ISO country codes as defined by ISO 3166-1 @return the name of the file, or empty string if no such file can be found Class to encapsulate the metadata filtering logic and restrict visibility into raw data structures.

WARNING: This is an internal API which is under development and subject to backwards-incompatible changes without notice. Any changes are not guaranteed to be reflected in the versioning scheme of the public API, nor in release notes. Clears certain fields in {@code metadata} as defined by the {@code MetadataFilter} instance. Note that this changes the mutable {@code metadata} object, and is not thread-safe. If this method does not return successfully, do not assume {@code metadata} has not changed. @param metadata The {@code PhoneMetadata} object to be filtered The input blacklist or whitelist string is expected to be of the form "a(b,c):d(e):f", where b and c are children of a, e is a child of d, and f is either a parent field, a child field, or a childless field. Order and whitespace don't matter. We throw Exception for any duplicates, malformed strings, or strings where field tokens do not correspond to strings in the sets of excludable fields. We also throw Exception for empty strings since such strings should be treated as a special case by the flag checking code and not passed here. Class encapsulating loading of PhoneNumber Metadata information. Currently this is used only for additional data files such as PhoneNumberAlternateFormats, but in the future it is envisaged it would handle the main metadata file (PhoneNumberMetaData.xml) as well. @author Lara Rennie INTERNATIONAL and NATIONAL formats are consistent with the definition in ITU-T Recommendation E123. For example, the number of the Google Switzerland office will be written as "+41 44 668 1800" in INTERNATIONAL format, and as "044 668 1800" in NATIONAL format. E164 format is as per INTERNATIONAL format but with no formatting applied, e.g. "+41446681800". RFC3966 is as per INTERNATIONAL format, but with all spaces and other separating symbols replaced with a hyphen, and with any phone number extension appended with ";ext=". It also will have a prefix of "tel:" added, e.g. "tel:+41-44-668-1800". Note: If you are considering storing the number in a neutral format, you are highly advised to use the PhoneNumber class.

The phone number pattern used by {@link #find}, similar to PhoneNumberUtil.VALID_PHONE_NUMBER, but with the following differences:
  • All captures are limited in order to place an upper bound to the text matched by the pattern.
  • Leading punctuation / plus signs are limited.
  • Consecutive occurrences of punctuation are limited.
  • Number of digits is limited.
  • No whitespace is allowed at the start or end.
  • No alpha digits (vanity numbers such as 1-800-SIX-FLAGS) are currently supported.
Matches strings that look like publication pages. Example: 
Computing Complete Answers to Queries in the Presence of Limited Access Patterns.
             Chen Li. VLDB J. 12(3): 211-227 (2003).
The string "211-227 (2003)" is not a telephone number. Matches strings that look like dates using "/" as a separator. Examples: 3/10/2011, 31/10/96 or 08/31/95. Matches timestamps. Examples: "2012-01-02 08:00". Note that the reg-ex does not include the trailing ":\d\d" -- that is covered by TIME_STAMPS_SUFFIX. Pattern to check that brackets match. Opening brackets should be closed within a phone number. This also checks that there is something inside the brackets. Having no brackets at all is also fine. Punctuation that may be at the start of a phone number - brackets and plus signs. Matches white-space, which may indicate the end of a phone number and the start of something else (such as a neighbouring zip-code). If white-space is found, continues to match all characters that are not typically used to start a phone number. Builds the MATCHING_BRACKETS and PATTERN regular expressions. The building blocks below exist to make the pattern more easily understood. Returns a regular expression quantifier with an upper and lower limit. The phone number utility. The text searched for phone numbers. The region (country) to assume for phone numbers without an international prefix, possibly null. The degree of validation requested. The maximum number of retries after matching an invalid number. The last successful match, null unless in {@link State#READY}. The next index to start searching at. Undefined in . Creates a new instance. See the factory methods in {@link PhoneNumberUtil} on how to obtain a new instance. the phone number util to use the character sequence that we will search, null for no text the country to assume for phone numbers not written in international format (with a leading plus, or with the international dialing prefix of the specified region). May be null or "ZZ" if only numbers with a leading plus should be considered. the leniency to use when evaluating candidate phone numbers the maximum number of invalid numbers to try before giving up on the text. This is to cover degenerate cases where the text has a lot of false positives in it. Must be >= 0. Attempts to find the next subsequence in the searched sequence on or after searchIndex that represents a phone number. Returns the next match, null if none was found. the search index to start searching at the phone number match found, null if none can be found Trims away any characters after the first match of pattern in candidate, returning the trimmed version. Helper method to determine if a character is a Latin-script letter or not. For our purposes, combining marks should also return true since we assume they have been added to a preceding Latin character. Attempts to extract a match from a candidate character sequence. the candidate text that might contain a phone number the offset of candidate within the match found, null if none can be found Attempts to extract a match from {@code candidate} if the whole candidate does not qualify as a match. the candidate text that might contain a phone number the current offset of candidate within the match found, null if none can be found Parses a phone number from the {@code candidate} using {@link PhoneNumberUtil#parse} and verifies it matches the requested {@link #leniency}. If parsing and verification succeed, a corresponding is returned, otherwise this method returns null. the candidate match the offset of candidate within the parsed and validated phone number match, or null Returns true if the groups of digits found in our candidate phone number match our expectations. the original number we found when parsing the candidate number, normalized to only contain ASCII digits, but with non-digits (spaces etc) retained the groups of digits that we would expect to see if we formatted this number Helper method to get the national-number part of a number, formatted without any national prefix, and return it as a set of digit blocks that would be formatted together following standard formatting rules. Helper method to get the national-number part of a number, formatted without any national prefix, and return it as a set of digit blocks that should be formatted together according to the formatting pattern passed in. An offline geocoder which provides geographical information related to a phone number. @author Shaopeng Jia Gets a {@link PhoneNumberOfflineGeocoder} instance to carry out international phone number geocoding.

The {@link PhoneNumberOfflineGeocoder} is implemented as a singleton. Therefore, calling this method multiple times will only result in one instance being created. @return a {@link PhoneNumberOfflineGeocoder} instance Preload the data file for the given language and country calling code, so that a future lookup for this language and country calling code will not incur any file loading. @param locale specifies the language of the data file to load @param countryCallingCode specifies the country calling code of phone numbers that are contained by the file to be loaded Returns the customary display name in the given language for the given territory the phone number is from. Returns the customary display name in the given language for the given region. Returns a text description for the given phone number, in the language provided. The description might consist of the name of the country where the phone number is from, or the name of the geographical area the phone number is from if more detailed information is available.

This method assumes the validity of the number passed in has already been checked. @param number a valid phone number for which we want to get a text description @param languageCode the language code for which the description should be written @return a text description for the given language code for the given phone number As per {@link #getDescriptionForValidNumber(PhoneNumber, Locale)} but explicitly checks the validity of the number passed in. @param number the phone number for which we want to get a text description @param languageCode the language code for which the description should be written @return a text description for the given language code for the given phone number, or empty string if the number passed in is invalid As per {@link #getDescriptionForValidNumber(PhoneNumber, Locale, String)} but explicitly checks the validity of the number passed in. @param number the phone number for which we want to get a text description @param languageCode the language code for which the description should be written @param userRegion the region code for a given user. This region will be omitted from the description if the phone number comes from this region. It is a two-letter uppercase ISO country code as defined by ISO 3166-1. @return a text description for the given language code for the given phone number, or empty string if the number passed in is invalid

Utility for international phone numbers. Functionality includes formatting, parsing and validation. If you use this library, and want to be notified about important changes, please sign up to our mailing list: http://groups.google.com/group/libphonenumber-discuss/about NOTE: A lot of methods in this class require Region Code strings.These must be provided using ISO 3166-1 two-letter country-code format.These should be in upper-case. The list of the codes can be found here: http://www.iso.org/iso/country_codes/iso_3166_code_lists/country_names_and_code_elements.htm Regular expression of acceptable characters that may start a phone number for the purposes of parsing. This allows us to strip away meaningless prefixes to phone numbers that may be mistakenly given to us. This consists of digits, the plus symbol and arabic-indic digits. This does not contain alpha characters, although they may be used later in the number. It also does not include other punctuation, as this will be stripped later during parsing and is of no information value when parsing a number. Helper initializer method to create the regular-expression pattern to match extensions, allowing the one-char extension symbols provided by singleExtnSymbols. Types of phone number matches. See detailed description beside the isNumberMatch() method. Possible outcomes when testing if a PhoneNumber is possible. The number length matches that of valid numbers for this region. The number length matches that of local numbers for this region only (i.e. numbers that may be able to be dialled within an area, but do not have all the information to be dialled from anywhere inside or outside the country). The number has an invalid country calling code. The number is shorter than all valid numbers for this region. The number is longer than the shortest valid numbers for this region, shorter than the longest valid numbers for this region, and does not itself have a number length that matches valid numbers for this region. This can also be returned in the case where isPossibleNumberForTypeWithReason was called, and there are no numbers of this type at all for this region. The number is longer than all valid numbers for this region. Leniency when finding potential phone numbers in text segments. The levels here are ordered in increasing strictness. Phone numbers accepted are possible, but not necessarily valid. Phone numbers accepted are possible and valid. Numbers written in national format must have their national-prefix present if it is usually written for a number of this type. Phone numbers accepted are valid and are grouped in a possible way for this locale. For example, a US number written as "65 02 53 00 00" and "650253 0000" are not accepted at this leniency level, whereas "650 253 0000", "650 2530000" or "6502530000" are. Numbers with more than one '/' symbol are also dropped at this level. Warning: This level might result in lower coverage especially for regions outside of country code "+1". If you are not sure about which level to use, email the discussion group libphonenumber-discuss@googlegroups.com. Phone numbers accepted are valid and are grouped in the same way that we would have formatted it, or as a single block. For example, a US number written as "650 2530000" is not accepted at this leniency level, whereas "650 253 0000" or "6502530000" are. Numbers with more than one '/' symbol are also dropped at this level. Warning: This level might result in lower coverage especially for regions outside of country code "+1". If you are not sure about which level to use, email the discussion group libphonenumber-discuss@googlegroups.com. Attempts to extract a possible number from the string passed in. This currently strips all leading characters that cannot be used to start a phone number. Characters that can be used to start a phone number are defined in the VALID_START_CHAR_PATTERN. If none of these characters are found in the number passed in, an empty string is returned. This function also attempts to strip off any alternative extensions or endings if two or more are present, such as in the case of: (530) 583-6985 x302/x2303. The second extension here makes this actually two phone numbers, (530) 583-6985 x302 and (530) 583-6985 x2303. We remove the second extension so that the first number is parsed correctly. The string that might contain a phone number. The number, stripped of any non-phone-number prefix (such as "Tel:") or an empty string if no character used to start phone numbers (such as + or any digit) is found in the number. Checks to see if the string of characters could possibly be a phone number at all. At the moment, checks to see that the string begins with at least 2 digits, ignoring any punctuation commonly found in phone numbers. This method does not require the number to be normalized in advance - but does assume that leading non-number symbols have been removed, such as by the method extractPossibleNumber. String to be checked for viability as a phone number. True if the number could be a phone number of some sort, otherwise false. Normalizes a string of characters representing a phone number. This performs the following conversions: Punctuation is stripped. For ALPHA/VANITY numbers: Letters are converted to their numeric representation on a telephone keypad. The keypad used here is the one defined in ITU Recommendation E.161. This is only done if there are 3 or more letters in the number, to lessen the risk that such letters are typos. For other numbers: Wide-ascii digits are converted to normal ASCII (European) digits. Arabic-Indic numerals are converted to European numerals. Spurious alpha characters are stripped. Arabic-Indic numerals are converted to European numerals. A string of characters representing a phone number. The normalized string version of the phone number. Normalizes a string of characters representing a phone number. This converts wide-ascii and arabic-indic numerals to European numerals, and strips punctuation and alpha characters. A string of characters representing a phone number. The normalized string version of the phone number. Normalizes a string of characters representing a phone number. This strips all characters which are not diallable on a mobile phone keypad (including all non-ASCII digits). a string of characters representing a phone number the normalized string version of the phone number Converts all alpha characters in a number to their respective digits on a keypad, but retains existing formatting. Gets the length of the geographical area code from the PhoneNumber object passed in, so that clients could use it to split a national significant number into geographical area code and subscriber number. It works in such a way that the resultant subscriber number should be diallable, at least on some devices. An example of how this could be used: var phoneUtil = PhoneNumberUtil.getInstance(); var number = phoneUtil.parse("16502530000", "US"); var nationalSignificantNumber = phoneUtil.getNationalSignificantNumber(number); string areaCode; string subscriberNumber; var areaCodeLength = phoneUtil.getLengthOfGeographicalAreaCode(number); if (areaCodeLength > 0) { areaCode = nationalSignificantNumber.substring(0, areaCodeLength); subscriberNumber = nationalSignificantNumber.substring(areaCodeLength); } else { areaCode = ""; subscriberNumber = nationalSignificantNumber; } N.B.: area code is a very ambiguous concept, so the I18N team generally recommends against using it for most purposes, but recommends using the more general NationalNumber instead. Read the following carefully before deciding to use this method:
  • geographical area codes change over time, and this method honors those changes; therefore, it doesn't guarantee the stability of the result it produces.
  • subscriber numbers may not be diallable from all devices (notably mobile devices, which typically requires the full NationalNumber to be dialled in most regions).
  • most non-geographical numbers have no area codes, including numbers from non-geographical entities
  • some geographical numbers have no area codes.
 the PhoneNumber object for which clients want to know the length of the area code the length of area code of the PhoneNumber object passed in Gets the length of the national destination code (NDC) from the PhoneNumber object passed in, so that clients could use it to split a national significant number into NDC and subscriber number. The NDC of a phone number is normally the first group of digit(s) right after the country calling code when the number is formatted in the international format, if there is a subscriber number part that follows. N.B.: similar to an area code, not all numbers have an NDC! An example of how this could be used: var phoneUtil = PhoneNumberUtil.getInstance(); var number = phoneUtil.parse("18002530000", "US"); var nationalSignificantNumber = phoneUtil.getNationalSignificantNumber(number); string nationalDestinationCode; string subscriberNumber; var nationalDestinationCodeLength = phoneUtil.getLengthOfNationalDestinationCode(number); if (nationalDestinationCodeLength > 0) { nationalDestinationCode = nationalSignificantNumber.substring(0, nationalDestinationCodeLength); subscriberNumber = nationalSignificantNumber.substring(nationalDestinationCodeLength); } else { nationalDestinationCode = ""; subscriberNumber = nationalSignificantNumber; } Refer to the unit tests to see the difference between this function and . the PhoneNumber object for which clients want to know the length of the NDC. the length of NDC of the PhoneNumber object passed in, which could be zero Returns the mobile token for the provided country calling code if it has one, otherwise returns an empty string. A mobile token is a number inserted before the area code when dialing a mobile number from that country from abroad. The country calling code for which we want the mobile token. The mobile token, as a string, for the given country calling code. Normalizes a string of characters representing a phone number by replacing all characters found in the accompanying map with the values therein, and stripping all other characters if removeNonMatches is true. A string of characters representing a phone number. A mapping of characters to what they should be replaced by in the normalized version of the phone number. indicates whether characters that are not able to be replaced should be stripped from the number. If this is false, they will be left unchanged in the number. The normalized string version of the phone number. Gets a {@link PhoneNumberUtil} instance to carry out international phone number formatting, parsing, or validation. The instance is loaded with all phone number metadata. The is implemented as a singleton.Therefore, calling getInstance multiple times will only result in one instance being created. a PhoneNumberUtil instance Used for testing purposes only to reset the PhoneNumberUtil singleton to null. Returns all regions the library has metadata for. An unordered set of the two-letter region codes for every geographical region the library supports. Returns all global network calling codes the library has metadata for. An unordered set of the country calling codes for every non-geographical entity the library supports. Returns all country calling codes the library has metadata for, covering both non-geographical entities (global network calling codes) and those used for geographical entities. This could be used to populate a drop-down box of country calling codes for a phone-number widget, for instance. An unordered set of the country calling codes for every geographical and non-geographical entity the library supports. Returns true if there is any possible number data set for a particular PhoneNumberDesc. Returns true if there is any data set for a particular PhoneNumberDesc. Returns the types we have metadata for based on the PhoneMetadata object passed in, which must be non-null. Returns the types for a given region which the library has metadata for. Will not include FIXED_LINE_OR_MOBILE (if numbers in this region could be classified as FIXED_LINE_OR_MOBILE, both FIXED_LINE and MOBILE would be present) and UNKNOWN. No types will be returned for invalid or unknown region codes. Returns the types for a country-code belonging to a non-geographical entity which the library has metadata for. Will not include FIXED_LINE_OR_MOBILE (if numbers for this non-geographical entity could be classified as FIXED_LINE_OR_MOBILE, both FIXED_LINE and MOBILE would be present) and UNKNOWN. No types will be returned for country calling codes that do not map to a known non-geographical entity. Gets a instance to carry out international phone number formatting, parsing, or validation. The instance is loaded with phone number metadata for a number of most commonly used regions. The is implemented as a singleton. Therefore, calling getInstance multiple times will only result in one instance being created. A instance. Helper function to check if the national prefix formatting rule has the first group only, i.e., does not start with the national prefix. Tests whether a phone number has a geographical association. It checks if the number is associated with a certain region in the country to which it belongs. Note that this doesn't verify if the number is actually in use. Overload of isNumberGeographical(PhoneNumber), since calculating the phone number type is expensive; if we have already done this, we don't want to do it again. Helper function to check region code is not unknown or null. Helper function to check the country calling code is valid. Formats a phone number in the specified format using default rules. Note that this does not promise to produce a phone number that the user can dial from where they are - although we do format in either 'national' or 'international' format depending on what the client asks for, we do not currently support a more abbreviated format, such as for users in the same "area" who could potentially dial the number without area code. Note that if the phone number has a country calling code of 0 or an otherwise invalid country calling code, we cannot work out which formatting rules to apply so we return the national significant number with no formatting applied. The phone number to be formatted. The format the phone number should be formatted into. The formatted phone number. Same as , but accepts a mutable StringBuilder as a parameter to decrease object creation when invoked many times. Formats a phone number in the specified format using client-defined formatting rules. Note that if the phone number has a country calling code of zero or an otherwise invalid country calling code, we cannot work out things like whether there should be a national prefix applied, or how to format extensions, so we return the national significant number with no formatting applied. The phone number to be formatted. The format the phone number should be formatted into. Formatting rules specified by clients. The formatted phone number. Formats a phone number in national format for dialing using the carrier as specified in the carrierCode. The carrierCode will always be used regardless of whether the phone number already has a preferred domestic carrier code stored. If carrierCode contains an empty string, returns the number in national format without any carrier code. The phone number to be formatted. The carrier selection code to be used. The formatted phone number in national format for dialing using the carrier as specified in the carrierCode. Formats a phone number in national format for dialing using the carrier as specified in the preferredDomesticCarrierCode field of the PhoneNumber object passed in. If that is missing, use the fallbackCarrierCode passed in instead. If there is no preferredDomesticCarrierCode, and the fallbackCarrierCode contains an empty string, return the number in national format without any carrier code. Use instead if the carrier code passed in should take precedence over the number's preferredDomesticCarrierCode when formatting. The phone number to be formatted. The carrier selection code to be used, if none is found in the phone number itself. The formatted phone number in national format for dialing using the number's preferredDomesticCarrierCode, or the fallbackCarrierCode passed in if none is found. Returns a number formatted in such a way that it can be dialed from a mobile phone in a specific region.If the number cannot be reached from the region(e.g.some countries block toll-free numbers from being called outside of the country), the method returns an empty string. The phone number to be formatted. The region where the call is being placed. Whether the number should be returned with formatting symbols, such as spaces and dashes. The formatted phone number. Formats a phone number for out-of-country dialing purposes.If no regionCallingFrom is supplied, we format the number in its INTERNATIONAL format.If the country calling code is the same as that of the region where the number is from, then NATIONAL formatting will be applied. If the number itself has a country calling code of zero or an otherwise invalid country calling code, then we return the number with no formatting applied. Note this function takes care of the case for calling inside of NANPA and between Russia and Kazakhstan (who share the same country calling code). In those cases, no international prefix is used.For regions which have multiple international prefixes, the number in its INTERNATIONAL format will be returned instead. The phone number to be formatted. The region where the call is being placed. The formatted phone number. Formats a phone number using the original phone number format that the number is parsed from. The original format is embedded in the country_code_source field of the PhoneNumber object passed in. If such information is missing, the number will be formatted into the NATIONAL format by default. When we don't have a formatting pattern for the number, the method returns the raw input when it is available. Note this method guarantees no digit will be inserted, removed or modified as a result of formatting. The phone number that needs to be formatted in its original number format. The region whose IDD needs to be prefixed if the original number has one. The formatted phone number in its original number format. Formats a phone number for out-of-country dialing purposes. Note that in this version, if the number was entered originally using alpha characters and this version of the number is stored in raw_input, this representation of the number will be used rather than the digit representation. Grouping information, as specified by characters such as "-" and " ", will be retained.

Caveats:

  • This will not produce good results if the country calling code is both present in the raw input _and_ is the start of the national number. This is not a problem in the regions which typically use alpha numbers.
  • This will also not produce good results if the raw input has any grouping information within the first three digits of the national number, and if the function needs to strip preceding digits/words in the raw input before these digits. Normally people group the first three digits together so this is not a huge problem - and will be fixed if it proves to be so.
the phone number that needs to be formatted the region where the call is being placed the formatted phone number Gets the national significant number of the a phone number. Note a national significant number doesn't contain a national prefix or any formatting. The PhoneNumber object for which the national significant number is needed. The national significant number of the PhoneNumber object passed in. A helper function that is used by format and formatByPattern. Gets a valid number for the specified region. Region for which an example number is needed. A valid fixed-line number for the specified region.Returns null when the metadata does not contain such information, or the region 001 is passed in. For 001 (representing non - geographical numbers), call instead. Gets a valid number for the specified region and number type. Region for which an example number is needed. The type of number that is needed. A valid number for the specified region and type. Returns null when the metadata does not contain such information or if an invalid region or region 001 was entered. For 001 (representing non-geographical numbers), call instead. Gets a valid number for the specified country calling code for a non-geographical entity. The country calling code for a non-geographical entity A valid number for the non-geographical entity. Returns null when the metadata does not contain such information, or the country calling code passed in does not belong to a non-geographical entity. Appends the formatted extension of a phone number to formattedNumber, if the phone number had an extension specified. Gets the type of a phone number. The phone number that we want to know the type. The type of the phone number. Tests whether a phone number matches a valid pattern. Note this doesn't verify the number is actually in use, which is impossible to tell by just looking at a number itself. The phone number that we want to validate. A bool that indicates whether the number is of a valid pattern. Tests whether a phone number is valid for a certain region. Note this doesn't verify the number is actually in use, which is impossible to tell by just looking at a number itself. If the country calling code is not the same as the country calling code for the region, this immediately exits with false. After this, the specific number pattern rules for the region are examined. This is useful for determining for example whether a particular number is valid for Canada, rather than just a valid NANPA number. The phone number that we want to validate. The region that we want to validate the phone number for. A bool that indicates whether the number is of a valid pattern. Returns the region where a phone number is from. This could be used for geocoding at the region level. The phone number whose origin we want to know. The region where the phone number is from, or null if no region matches this calling code. Returns the region code that matches the specific country calling code. In the case of no region code being found, ZZ will be returned. In the case of multiple regions, the one designated in the metadata as the "main" region for this calling code will be returned. Returns the country calling code for a specific region. For example, this would be 1 for the United States, and 64 for New Zealand. Region that we want to get the country calling code for. The country calling code for the region denoted by regionCode. Returns the country calling code for a specific region. For example, this would be 1 for the United States, and 64 for New Zealand. Assumes the region is already valid. The region that we want to get the country calling code for. The country calling code for the region denoted by regionCode. Returns the national dialling prefix for a specific region. For example, this would be 1 for the United States, and 0 for New Zealand. Set stripNonDigits to true to strip symbols like "~" (which indicates a wait for a dialling tone) from the prefix returned. If no national prefix is present, we return null. Warning: Do not use this method for do-your-own formatting - for some regions, the national dialling prefix is used only for certain types of numbers. Use the library's formatting functions to prefix the national prefix when required. The region that we want to get the dialling prefix for. True to strip non-digits from the national dialling prefix. The dialling prefix for the region denoted by regionCode. Checks if this is a region under the North American Numbering Plan Administration (NANPA). True if regionCode is one of the regions under NANPA. Checks if the number is a valid vanity (alpha) number such as 800 MICROSOFT. A valid vanity number will start with at least 3 digits and will have three or more alpha characters. This does not do region-specific checks - to work out if this number is actually valid for a region, it should be parsed and methods such as and should be used. The number that needs to be checked. True if the number is a valid vanity number. Convenience wrapper around . Instead of returning the reason for failure, this method returns true if the number is either a possible fully-qualified number (containing the area code and country code), or if the number could be a possible local number (with a country code, but missing an area code). Local numbers are considered possible if they could be possibly dialled in this format: if the area code is needed for a call to connect, the number is not considered possible without it. The number that needs to be checked. True if the number is possible. Convenience wrapper around {@link #isPossibleNumberForTypeWithReason}. Instead of returning the reason for failure, this method returns true if the number is either a possible fully-qualified number (containing the area code and country code), or if the number could be a possible local number (with a country code, but missing an area code). Local numbers are considered possible if they could be possibly dialled in this format: if the area code is needed for a call to connect, the number is not considered possible without it. the number that needs to be checked the type we are interested in if the number is possible for this particular type Helper method to check a number against possible lengths for this number, and determine whether it matches, or is too short or too long. Check whether a phone number is a possible number. It provides a more lenient check than in the following sense:
  1. It only checks the length of phone numbers. In particular, it doesn't check starting digits of the number.
  2. It doesn't attempt to figure out the type of the number, but uses general rules which applies to all types of phone numbers in a region. Therefore, it is much faster than isValidNumber.
  3. For some numbers (particularly fixed-line), many regions have the concept of area code, which together with subscriber number constitute the national significant number. It is sometimes okay to dial only the subscriber number when dialing in the same area. This function will return IS_POSSIBLE_LOCAL_ONLY if the subscriber-number-only version is passed in. On the other hand, because isValidNumber validates using information on both starting digits (for fixed line numbers, that would most likely be area codes) and length (obviously includes the length of area codes for fixed line numbers), it will return false for the subscriber-number-only version.
the number that needs to be checked a ValidationResult object which indicates whether the number is possible Check whether a phone number is a possible number of a particular type. For types that don't exist in a particular region, this will return a result that isn't so useful; it is recommended that you use {@link #getSupportedTypesForRegion} or {@link #getSupportedTypesForNonGeoEntity} respectively before calling this method to determine whether you should call it for this number at all. This provides a more lenient check than {@link #isValidNumber} in the following sense:
  1. It only checks the length of phone numbers. In particular, it doesn't check starting digits of the number.
  2. For some numbers (particularly fixed-line), many regions have the concept of area code, which together with subscriber number constitute the national significant number. It is sometimes okay to dial only the subscriber number when dialing in the same area. This function will return IS_POSSIBLE_LOCAL_ONLY if the subscriber-number-only version is passed in. On the other hand, because isValidNumber validates using information on both starting digits (for fixed line numbers, that would most likely be area codes) and length (obviously includes the length of area codes for fixed line numbers), it will return false for the subscriber-number-only version.
 the number that needs to be checked the type we are interested in A ValidationResult object which indicates whether the number is possible Check whether a phone number is a possible number given a number in the form of a string, and the region where the number could be dialed from. It provides a more lenient check than . See for details. This method first parses the number, then invokes with the resultant PhoneNumber object. The number that needs to be checked, in the form of a string. The region that we are expecting the number to be dialed from. Note this is different from the region where the number belongs. For example, the number +1 650 253 0000 is a number that belongs to US. When written in this form, it can be dialed from any region. When it is written as 00 1 650 253 0000, it can be dialed from any region which uses an international dialling prefix of 00. When it is written as 650 253 0000, it can only be dialed from within the US, and when written as 253 0000, it can only be dialed from within a smaller area in the US (Mountain View, CA, to be more specific). True if the number is possible. Attempts to extract a valid number from a phone number that is too long to be valid, and resets the PhoneNumber object passed in to that valid version. If no valid number could be extracted, the PhoneNumber object passed in will not be modified. A PhoneNumber object which contains a number that is too long to be valid. True if a valid phone number can be successfully extracted. Gets an for the specific region. Region where the phone number is being entered. An object, which can be used to format phone numbers in the specific region "as you type". Tries to extract a country calling code from a number. This method will return zero if no country calling code is considered to be present. Country calling codes are extracted in the following ways:
  • by stripping the international dialing prefix of the region the person is dialing from, if this is present in the number, and looking at the next digits
  • by stripping the '+' sign if present and then looking at the next digits
  • by comparing the start of the number and the country calling code of the default region. If the number is not considered possible for the numbering plan of the default region initially, but starts with the country calling code of this region, validation will be reattempted after stripping this country calling code. If this number is considered a possible number, then the first digits will be considered the country calling code and removed as such.
It will throw a NumberParseException if the number starts with a '+' but the country calling code supplied after this does not match that of any known region. non-normalized telephone number that we wish to extract a country calling code from - may begin with '+' metadata about the region this number may be from a string buffer to store the national significant number in, in the case that a country calling code was extracted. The number is appended to any existing contents. If no country calling code was extracted, this will be left unchanged. true if the country_code_source and preferred_carrier_code fields of phoneNumber should be populated. the PhoneNumber object where the country_code and country_code_source need to be populated. Note the country_code is always populated, whereas country_code_source is only populated when keepCountryCodeSource is true. the country calling code extracted or 0 if none could be extracted Strips the IDD from the start of the number if present. Helper function used by . Strips any international prefix (such as +, 00, 011) present in the number provided, normalizes the resulting number, and indicates if an international prefix was present. The non-normalized telephone number that we wish to strip any international dialing prefix from. The international direct dialing prefix from the region we think this number may be dialed in. The corresponding CountryCodeSource if an international dialing prefix could be removed from the number, otherwise CountryCodeSource.FROM_DEFAULT_COUNTRY if the number did not seem to be in international format. Strips any national prefix (such as 0, 1) present in the number provided. The normalized telephone number that we wish to strip any national dialing prefix from. The metadata for the region that we think this number is from. A place to insert the carrier code if one is extracted. True if a national prefix or carrier code (or both) could be extracted. Strips any extension (as in, the part of the number dialled after the call is connected, usually indicated with extn, ext, x or similar) from the end of the number, and returns it. The non-normalized telephone number that we wish to strip the extension from. The phone extension. Checks to see that the region code used is valid, or if it is not valid, that the number to parse starts with a + symbol so that we can attempt to infer the region from the number. if it can use the region provided or the region can be inferred. Parses a string and returns it in proto buffer format. This method will throw a if the number is not considered to be a possible number. Note that validation of whether the number is actually a valid number for a particular region is not performed. This can be done separately with . Number that we are attempting to parse. This can contain formatting such as +, ( and -, as well as a phone number extension. It can also be provided in RFC3966 format. Region that we are expecting the number to be from. This is only used if the number being parsed is not written in international format. The country_code for the number in this case would be stored as that of the default region supplied. If the number is guaranteed to start with a '+' followed by the country calling code, then "ZZ" or null can be supplied. A phone number proto buffer filled with the parsed number If the string is not considered to be a viable phone number or if no default region was supplied and the number is not in international format (does not start with +). Same as , but accepts mutable PhoneNumber as a parameter to decrease object creation when invoked many times. Parses a string and returns it in proto buffer format. This method differs from {@link #parse} in that it always populates the raw_input field of the protocol buffer with numberToParse as well as the country_code_source field. Number that we are attempting to parse. This can contain formatting such as +, ( and -, as well as a phone number extension. Region that we are expecting the number to be from. This is only used if the number being parsed is not written in international format. The country calling code for the number in this case would be stored as that of the default region supplied. A phone number proto buffer filled with the parsed number. If the string is not considered to be a viable phone number or if no default region was supplied. Same as , but accepts a mutable PhoneNumber as a parameter to decrease object creation when invoked many times. Returns an iterable over all PhoneNumberMatches in text. This is a shortcut for getMatcher(text, defaultRegion, Leniency.VALID, Long.MAX_VALUE)}. The text to search for phone numbers, null for no text. Region that we are expecting the number to be from. This is only used if the number being parsed is not written in international format. The country_code for the number in this case would be stored as that of the default region supplied. May be null if only international numbers are expected. Returns an iterable over all PhoneNumberMatches in text. The text to search for phone numbers, null for no text. Tegion that we are expecting the number to be from. This is only used if the number being parsed is not written in international format. The country_code for the number in this case would be stored as that of the default region supplied. May be null if only international numbers are expected. The leniency to use when evaluating candidate phone numbers. The maximum number of invalid numbers to try before giving up on the text. This is to cover degenerate cases where the text has a lot of false positives in it. Must be {@code >= 0}. A helper function to set the values related to leading zeros in a PhoneNumber. Parses a string and fills up the phoneNumber. This method is the same as the public Parse() method, with the exception that it allows the default region to be null, for use by IsNumberMatch(). checkRegion should be set to false if it is permitted for the default region to be null or unknown ("ZZ"). Converts numberToParse to a form that we can parse and write it to nationalNumber if it is written in RFC3966; otherwise extract a possible number out of it and write to nationalNumber. Takes two phone numbers and compares them for equality. Returns EXACT_MATCH if the country_code, NSN, presence of a leading zero for Italian numbers and any extension present are the same. Returns NSN_MATCH if either or both has no region specified, and the NSNs and extensions are the same. Returns SHORT_NSN_MATCH if either or both has no region specified, or the region specified is the same, and one NSN could be a shorter version of the other number. This includes the case where one has an extension specified, and the other does not. Returns NO_MATCH otherwise. For example, the numbers +1 345 657 1234 and 657 1234 are a SHORT_NSN_MATCH. The numbers +1 345 657 1234 and 345 657 are a NO_MATCH. First number to compare. Second number to compare. NO_MATCH, SHORT_NSN_MATCH, NSN_MATCH or EXACT_MATCH depending on the level of equality of the two numbers, described in the method definition. Takes two phone numbers as strings and compares them for equality. This is a convenience wrapper for . No default region is known. First number to compare. Can contain formatting, and can have country calling code specified with + at the start. Second number to compare. Can contain formatting, and can have country calling code specified with + at the start. NOT_A_NUMBER, NO_MATCH, SHORT_NSN_MATCH, NSN_MATCH, EXACT_MATCH. See for more details. Takes two phone numbers and compares them for equality. This is a convenience wrapper for . No default region is known. First number to compare in proto buffer format. Second number to compare. Can contain formatting, and can have country calling code specified with + at the start. NOT_A_NUMBER, NO_MATCH, SHORT_NSN_MATCH, NSN_MATCH, EXACT_MATCH. See for more details. Returns true if the number can be dialled from outside the region, or unknown. If the number can only be dialled from within the region, returns false. Does not check the number is a valid number. TODO: Make this method public when we have enough metadata to make it worthwhile. the phone-number for which we want to know whether it is only diallable from outside the region Methods for getting information about short phone numbers, such as short codes and emergency numbers. Note that most commercial short numbers are not handled here, but by the . @author Shaopeng Jia @author David Yonge-Mallo Cost categories of short numbers. Returns the singleton instance of the ShortNumberInfo. IMatcherApi supports the basic matching method for checking if a given national number matches a national number pattern defined in the given . A mapping from a country calling code to the region codes which denote the region represented by that country calling code. In the case of multiple regions sharing a calling code, such as the NANPA regions, the one indicated with "isMainCountryForCode" in the metadata should be first. Returns a list with the region codes that match the specific country calling code. For non-geographical country calling codes, the region code 001 is returned. Also, in the case of no region code being found, an empty list is returned. Helper method to check that the country calling code of the number matches the region it's being dialed from. Check whether a short number is a possible number when dialed from the given region. This provides a more lenient check than . the short number to check the region from which the number is dialed whether the number is a possible short number Check whether a short number is a possible number. If a country calling code is shared by multiple regions, this returns true if it's possible in any of them. This provides a more lenient check than . See for details. the short number to check whether the number is a possible short number Tests whether a short number matches a valid pattern in a region. Note that this doesn't verify the number is actually in use, which is impossible to tell by just looking at the number itself. the short number for which we want to test the validity the region from which the number is dialed whether the short number matches a valid pattern Tests whether a short number matches a valid pattern. If a country calling code is shared by multiple regions, this returns true if it's valid in any of them. Note that this doesn't verify the number is actually in use, which is impossible to tell by just looking at the number itself. See for details. the short number for which we want to test the validity whether the short number matches a valid pattern Gets the expected cost category of a short number when dialed from a region (however, nothing is implied about its validity). If it is important that the number is valid, then its validity must first be checked using . Note that emergency numbers are always considered toll-free. Example usage: // The region for which the number was parsed and the region we subsequently check against // need not be the same. Here we parse the number in the US and check it for Canada. PhoneNumber number = phoneUtil.parse("110", "US"); ... string regionCode = "CA"; ShortNumberInfo shortInfo = ShortNumberInfo.getInstance(); if (shortInfo.isValidShortNumberForRegion(shortNumber, regionCode)) { ShortNumberCost cost = shortInfo.getExpectedCostForRegion(number, regionCode); // Do something with the cost information here. }} the short number for which we want to know the expected cost category the region from which the number is dialed the expected cost category for that region of the short number. Returns UNKNOWN_COST if the number does not match a cost category. Note that an invalid number may match any cost category. Gets the expected cost category of a short number (however, nothing is implied about its validity). If the country calling code is unique to a region, this method behaves exactly the same as . However, if the country calling code is shared by multiple regions, then it returns the highest cost in the sequence PREMIUM_RATE, UNKNOWN_COST, STANDARD_RATE, TOLL_FREE. The reason for the position of UNKNOWN_COST in this order is that if a number is UNKNOWN_COST in one region but STANDARD_RATE or TOLL_FREE in another, its expected cost cannot be estimated as one of the latter since it might be a PREMIUM_RATE number.

For example, if a number is STANDARD_RATE in the US, but TOLL_FREE in Canada, the expected cost returned by this method will be STANDARD_RATE, since the NANPA countries share the same country calling code.

Note: If the region from which the number is dialed is known, it is highly preferable to call instead.

the short number for which we want to know the expected cost category the highest expected cost category of the short number in the region(s) with the given country calling code Helper method to get the region code for a given phone number, from a list of possible region codes. If the list Contains more than one region, the first region for which the number is valid is returned. Convenience method to get a list of what regions the library has metadata for. Gets a valid short number for the specified region. the region for which an example short number is needed a valid short number for the specified region. Returns an empty string when the metadata does not contain such information. Gets a valid short number for the specified cost category. the region for which an example short number is needed the cost category of number that is needed a valid short number for the specified region and cost category. Returns an empty string when the metadata does not contain such information, or the cost is UNKNOWN_COST. Returns true if the given number, exactly as dialed, might be used to connect to an emergency service in the given region.

This method accepts a string, rather than a PhoneNumber, because it needs to distinguish cases such as "+1 911" and "911", where the former may not connect to an emergency service in all cases but the latter would. This method takes into account cases where the number might contain formatting, or might have additional digits appended (when it is okay to do that in the specified region).

the phone number to test the region where the phone number is being dialed whether the number might be used to connect to an emergency service in the given region Returns true if the given number exactly matches an emergency service number in the given region.

This method takes into account cases where the number might contain formatting, but doesn't allow additional digits to be appended. Note that implies .

the phone number to test the region where the phone number is being dialed whether the number exactly matches an emergency services number in the given region Given a valid short number, determines whether it is carrier-specific (however, nothing is implied about its validity). Carrier-specific numbers may connect to a different end-point, or not connect at all, depending on the user's carrier. If it is important that the number is valid, then its validity must first be checked using or . the valid short number to check whether the short number is carrier-specific, assuming the input was a valid short number Given a valid short number, determines whether it is carrier-specific when dialed from the given region (however, nothing is implied about its validity). Carrier-specific numbers may connect to a different end-point, or not connect at all, depending on the user's carrier. If it is important that the number is valid, then its validity must first be checked using or . Returns false if the number doesn't match the region provided. the valid short number to check the region from which the number is dialed whether the short number is carrier-specific in the provided region, assuming the input was a valid short number Given a valid short number, determines whether it is an SMS service (however, nothing is implied about its validity). An SMS service is where the primary or only intended usage is to receive and/or send text messages (SMSs). This includes MMS as MMS numbers downgrade to SMS if the other party isn't MMS-capable. If it is important that the number is valid, then its validity must first be checked using or . Returns false if the number doesn't match the region provided. the valid short number to check the region from which the number is dialed whether the short number is an SMS service in the provided region, assuming the input was a valid short number Gets the national significant number of the a phone number. Note a national significant number doesn't contain a national prefix or any formatting.

This is a temporary duplicate of the method from . Ultimately a canonical static version should exist in a separate

the phone number for which the national significant number is needed utility class (to prevent needing to depend on PhoneNumberUtil). the national significant number of the PhoneNumber object passed in