If you use this library, and want to be notified about important changes, please sign up to our mailing list. 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
public function testDenormalize()
{
$obj = $this->numberUtil->parse('+31508100210', PhoneNumberUtil::UNKNOWN_REGION);
$str = '+31508100210';
self::assertEquals($obj, $this->normalizer->denormalize($str, 'json'));
self::assertEquals($obj, $this->normalizer->denormalize($str, 'xml'));
}
public function testChineseCarrierLookup()
{
$number = $this->phoneUtil->parse("+86 150 3657 7264", "CN");
$carrier = PhoneNumberToCarrierMapper::getInstance();
$location = $carrier->getNameForNumber($number, "en");
$this->assertEquals("China Mobile", $location);
}
public function testIsValidNumberForRegion()
{
$number = "+33 6 76 83 51 85";
$region = "DE";
$phoneNumber = $this->phoneUtil->parse($number, $region);
$this->assertFalse($this->phoneUtil->isValidNumberForRegion($phoneNumber, "DE"));
}
public function testKWMobileNumber()
{
$number = "51440519";
$phoneNumber = $this->phoneUtil->parse($number, "KW");
$this->assertTrue($this->phoneUtil->isValidNumber($phoneNumber));
$this->assertEquals(PhoneNumberType::MOBILE, $this->phoneUtil->getNumberType($phoneNumber));
}
public function filter($value)
{
try {
$NumberProto = $this->libPhoneNumber->parse($value, $this->getCountry());
} catch (NumberParseException $e) {
return $value;
}
return $this->libPhoneNumber->format($NumberProto, PhoneNumberFormat::E164);
}
public function testSerializingPhoneNumber()
{
$number = "+441174900000";
$region = "GB";
$phoneNumber = $this->phoneUtil->parse($number, $region);
$serializedString = serialize($phoneNumber);
$phoneObject2 = unserialize($serializedString);
$this->assertTrue($phoneObject2->equals($phoneNumber));
}
/**
* @dataProvider localeList
* @param string $regionCode
* @param string $countryName
*/
public function testLocales($regionCode, $countryName)
{
if (!in_array($regionCode, $this->phoneUtil->getSupportedRegions())) {
$this->markTestSkipped("{$regionCode} is not supported");
}
$phoneNumber = $this->phoneUtil->getExampleNumberForType($regionCode, PhoneNumberType::FIXED_LINE_OR_MOBILE);
$this->assertContains($regionCode, CountryCodeToRegionCodeMap::$countryCodeToRegionCodeMap[$phoneNumber->getCountryCode()]);
$this->assertEquals($regionCode, $this->phoneUtil->getRegionCodeForNumber($phoneNumber));
$this->assertEquals($countryName, $this->geocoder->getDescriptionForValidNumber($phoneNumber, 'en', 'ZZ'), "Checking {$phoneNumber} is part of {$countryName}");
}
/**
* As per {@link #getTimeZonesForGeographicalNumber(PhoneNumber)} but explicitly checks
* the validity of the number passed in.
*
* @param $number PhoneNumber the phone number for which we want to get the time zones to which it belongs
* @return array a list of the corresponding time zones or a single element list with the default
* unknown time zone if no other time zone was found or if the number was invalid
*/
public function getTimeZonesForNumber(PhoneNumber $number)
{
$numberType = $this->phoneUtil->getNumberType($number);
if ($numberType === PhoneNumberType::UNKNOWN) {
return $this->unknownTimeZoneList;
} elseif (!$this->canBeGeocoded($numberType)) {
return $this->getCountryLevelTimeZonesforNumber($number);
}
return $this->getTimeZonesForGeographicalNumber($number);
}
/**
* Returns a plain phonenumber readable for mobile devices
*
* @param string $phoneNumber Formatted Phone Number
* @return string
*/
public function render($phoneNumber)
{
$plainPhoneNumber = '';
if ($phoneNumber) {
/** @var \libphonenumber\PhoneNumber $plainPhoneNumberPrototype */
$plainPhoneNumberPrototype = $this->phoneNumberUtility->parse($phoneNumber, 'DE');
$plainPhoneNumber = $this->phoneNumberUtility->format($plainPhoneNumberPrototype, \libphonenumber\PhoneNumberFormat::RFC3966);
}
return $plainPhoneNumber;
}
/**
* As per {@link #getTimeZonesForGeographicalNumber(PhoneNumber)} but explicitly checks
* the validity of the number passed in.
*
* @param $number PhoneNumber the phone number for which we want to get the time zones to which it belongs
* @return array a list of the corresponding time zones or a single element list with the default
* unknown time zone if no other time zone was found or if the number was invalid
*/
public function getTimeZonesForNumber(PhoneNumber $number)
{
$numberType = $this->phoneUtil->getNumberType($number);
if ($numberType === PhoneNumberType::UNKNOWN) {
return $this->unknownTimeZoneList;
} elseif (!!PhoneNumberUtil::getInstance()->isNumberGeographical($numberType, $number->getCountryCode())) {
return $this->getCountryLevelTimeZonesforNumber($number);
}
return $this->getTimeZonesForGeographicalNumber($number);
}
/**
* Format a phone number.
*
* @param PhoneNumber $phoneNumber Phone number.
* @param int|string $format Format, or format constant name.
*
* @return string Formatted phone number.
*
* @throws InvalidArgumentException If an argument is invalid.
*/
public function format(PhoneNumber $phoneNumber, $format = PhoneNumberFormat::INTERNATIONAL)
{
if (true === is_string($format)) {
$constant = '\\libphonenumber\\PhoneNumberFormat::' . $format;
if (false === defined($constant)) {
throw new InvalidArgumentException('The format must be either a constant value or name in libphonenumber\\PhoneNumberFormat');
}
$format = constant('\\libphonenumber\\PhoneNumberFormat::' . $format);
}
return $this->phoneNumberUtil->format($phoneNumber, $format);
}
public function testTooShortNumber()
{
try {
$this->phoneUtil->parse("+441", "GB");
} catch (\Exception $e) {
$this->assertEquals("libphonenumber\\NumberParseException", get_class($e));
$this->assertEquals("The string supplied is too short to be a phone number.", $e->getMessage());
$this->assertEquals(3, $e->getCode());
$this->assertEquals("Error type: 3. The string supplied is too short to be a phone number.", (string) $e);
}
}
/**
* @dataProvider reverseTransformProvider
*/
public function testReverseTransform($defaultRegion, $actual, $expected)
{
$transformer = new PhoneNumberToStringTransformer($defaultRegion);
try {
$transformed = $transformer->reverseTransform($actual);
} catch (TransformationFailedException $e) {
$transformed = self::TRANSFORMATION_FAILED;
}
if ($transformed instanceof PhoneNumber) {
$transformed = $this->phoneNumberUtil->format($transformed, PhoneNumberFormat::E164);
}
$this->assertSame($expected, $transformed);
}
/**
* Returns the description of the geographical area the {@code 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.
*
* @internal param \libphonenumber\PhoneNumber $number the phone number to look up
* @param \libphonenumber\PhoneNumber $phoneNumber
* @return string|null bla the description of the geographical area
*/
public function lookup(PhoneNumber $phoneNumber)
{
if (count($this->areaCodeMapStorage) == 0) {
return null;
}
$phonePrefix = $phoneNumber->getCountryCode() . $this->phoneUtil->getNationalSignificantNumber($phoneNumber);
while (strlen($phonePrefix) > 0) {
if (array_key_exists($phonePrefix, $this->areaCodeMapStorage)) {
return $this->areaCodeMapStorage[$phonePrefix];
}
$phonePrefix = substr($phonePrefix, 0, -1);
}
return null;
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (self::WIDGET_COUNTRY_CHOICE === $options['widget']) {
$util = PhoneNumberUtil::getInstance();
$countries = array();
if (is_array($options['country_choices'])) {
foreach ($options['country_choices'] as $country) {
$code = $util->getCountryCodeForRegion($country);
if ($code) {
$countries[$country] = $code;
}
}
}
if (empty($countries)) {
foreach ($util->getSupportedRegions() as $country) {
$countries[$country] = $util->getCountryCodeForRegion($country);
}
}
$countryChoices = array();
foreach (Intl::getRegionBundle()->getCountryNames() as $region => $name) {
if (false === isset($countries[$region])) {
continue;
}
$countryChoices[$region] = sprintf('%s (+%s)', $name, $countries[$region]);
}
$countryOptions = $numberOptions = array('error_bubbling' => true, 'required' => $options['required'], 'disabled' => $options['disabled'], 'translation_domain' => $options['translation_domain']);
$countryOptions['required'] = true;
$countryOptions['choices'] = $countryChoices;
$countryOptions['preferred_choices'] = $options['preferred_country_choices'];
$countryOptions['choice_translation_domain'] = false;
$builder->add('country', 'choice', $countryOptions)->add('number', 'text', $numberOptions)->addViewTransformer(new PhoneNumberToArrayTransformer(array_keys($countryChoices)));
} else {
$builder->addViewTransformer(new PhoneNumberToStringTransformer($options['default_region'], $options['format']));
}
}
public static function setUpBeforeClass()
{
PhoneNumberUtil::resetInstance();
self::$AO_MOBILE1 = new PhoneNumber();
self::$AO_MOBILE1->setCountryCode(244)->setNationalNumber(917654321);
self::$AO_MOBILE2 = new PhoneNumber();
self::$AO_MOBILE2->setCountryCode(244)->setNationalNumber(927654321);
self::$AO_FIXED1 = new PhoneNumber();
self::$AO_FIXED1->setCountryCode(244)->setNationalNumber(22254321);
self::$AO_FIXED2 = new PhoneNumber();
self::$AO_FIXED2->setCountryCode(244)->setNationalNumber(26254321);
self::$AO_INVALID_NUMBER = new PhoneNumber();
self::$AO_INVALID_NUMBER->setCountryCode(244)->setNationalNumber(101234);
self::$UK_MOBILE1 = new PhoneNumber();
self::$UK_MOBILE1->setCountryCode(44)->setNationalNumber(7387654321);
self::$UK_MOBILE2 = new PhoneNumber();
self::$UK_MOBILE2->setCountryCode(44)->setNationalNumber(7487654321);
self::$UK_FIXED1 = new PhoneNumber();
self::$UK_FIXED1->setCountryCode(44)->setNationalNumber(1123456789);
self::$UK_FIXED2 = new PhoneNumber();
self::$UK_FIXED2->setCountryCode(44)->setNationalNumber(2987654321);
self::$UK_INVALID_NUMBER = new PhoneNumber();
self::$UK_INVALID_NUMBER->setCountryCode(44)->setNationalNumber(7301234);
self::$UK_PAGER = new PhoneNumber();
self::$UK_PAGER->setCountryCode(44)->setNationalNumber(7601234567);
self::$US_FIXED_OR_MOBILE = new PhoneNumber();
self::$US_FIXED_OR_MOBILE->setCountryCode(1)->setNationalNumber(6502123456);
self::$NUMBER_WITH_INVALID_COUNTRY_CODE = new PhoneNumber();
self::$NUMBER_WITH_INVALID_COUNTRY_CODE->setCountryCode(999)->setNationalNumber(2423651234);
self::$INTERNATIONAL_TOLL_FREE = new PhoneNumber();
self::$INTERNATIONAL_TOLL_FREE->setCountryCode(800)->setNationalNumber(12345678);
}
/**
* Validates a phone number.
*/
public function validatePhone($attribute, $value, $parameters, $validator)
{
$this->attribute = $attribute;
$this->data = $validator->getData();
$this->parameters = array_map('strtoupper', $parameters);
$this->determineCountries();
$this->determineTypes();
$this->checkLeftoverParameters();
$phoneUtil = PhoneNumberUtil::getInstance();
// Perform validation.
foreach ($this->allowedCountries as $country) {
try {
// For default countries or country field, the following throws NumberParseException if
// not parsed correctly against the supplied country.
// For automatic detection: tries to discover the country code using from the number itself.
$phoneProto = $phoneUtil->parse($value, $country);
// For automatic detection, the number should have a country code.
// Check if type is allowed.
if ($phoneProto->hasCountryCode() && empty($this->allowedTypes) || in_array($phoneUtil->getNumberType($phoneProto), $this->allowedTypes)) {
// Automatic detection:
if ($country == 'ZZ') {
// Validate if the international phone number is valid for its contained country.
return $phoneUtil->isValidNumber($phoneProto);
}
// Force validation of number against the specified country.
return $phoneUtil->isValidNumberForRegion($phoneProto, $country);
}
} catch (NumberParseException $e) {
// Proceed to default validation error.
}
}
return false;
}
/**
* Gets the name of the carrier for the given phone number only when it is 'safe' to display to
* users. A carrier name is considered safe if the number is valid and for a region that doesn't
* support
* {@linkplain http://en.wikipedia.org/wiki/Mobile_number_portability mobile number portability}.
*
* @param $number PhoneNumber the phone number for which we want to get a carrier name
* @param $languageCode String the language code in which the name should be written
* @return string a carrier name that is safe to display to users, or the empty string
*/
public function getSafeDisplayName(PhoneNumber $number, $languageCode)
{
if ($this->phoneUtil->isMobileNumberPortableRegion($this->phoneUtil->getRegionCodeForNumber($number))) {
return "";
}
return $this->getNameForNumber($number, $languageCode);
}
/**
* @expectedException \libphonenumber\NumberParseException
* @expectedExceptionCode 1
* @expectedExceptionMessage The string supplied did not seem to be a phone number.
*/
public function testIssue76()
{
$number = '*****@*****.**';
$region = 'DE';
$util = PhoneNumberUtil::getInstance();
$util->parse($number, $region);
}
public function getTargetPhoneNumber($defaultRegion)
{
if ($this->getTargetUri() === null || !preg_match('/^sip:(\\d+)@/', $this->getTargetUri(), $matches)) {
return null;
}
return PhoneNumberUtil::getInstance()->parse($matches[1], $defaultRegion);
}
/**
* Performs the actual validation of the phone number.
*
* @param mixed $number
* @param null $country
* @return bool
*/
protected function isValidNumber($number, $country = null)
{
try {
// Throws NumberParseException if not parsed correctly against the supplied country.
// If no country was given, tries to discover the country code from the number itself.
$phoneNumber = $this->lib->parse($number, $country);
// Lenient validation; doesn't need a country code.
if ($this->lenient) {
return $this->lib->isPossibleNumber($phoneNumber);
}
// For automatic detection, the number should have a country code.
// Check if type is allowed.
if ($phoneNumber->hasCountryCode() && (empty($this->types) || in_array($this->lib->getNumberType($phoneNumber), $this->types))) {
// Automatic detection:
if ($this->autodetect) {
// Validate if the international phone number is valid for its contained country.
return $this->lib->isValidNumber($phoneNumber);
}
// Validate number against the specified country.
return $this->lib->isValidNumberForRegion($phoneNumber, $country);
}
} catch (NumberParseException $e) {
// Proceed to default validation error.
}
return false;
}
/**
* Clean phone number for Twilio
* @param string $phone
* @return string
*/
protected function cleanPhone($phone, $useTimezone = true)
{
// if Phone number is not in E164 try to parse it
if (!preg_match('/^\\+.\\d+$/', $phone)) {
if ($useTimezone) {
$phoneUtil = PhoneNumberUtil::getInstance();
try {
// Get country code using configure timezone
$tz = Carbon::now()->getTimezone();
$country_code = array_get($tz->getLocation(), 'country_code', 'US');
// Parse phone number
$numberProto = $phoneUtil->parse($phone, $country_code);
// Return phone
return $phoneUtil->format($numberProto, PhoneNumberFormat::E164);
} catch (\libphonenumber\NumberParseException $e) {
// Invalid phone let twilio complain :D
return '';
}
}
// Just add missing plus sing
return '+' . $phone;
} else {
return $phone;
}
}
/**
* @return mixed
*/
public function getPhoneNumberService()
{
if ($this->phoneNumberService === null) {
$this->phoneNumberService = PhoneNumberUtil::getInstance();
}
return $this->phoneNumberService;
}
public function testInvalidNumber()
{
$number = '123401234512345';
$phoneObject = $this->phoneUtil->parse($number, 'GB');
$valid = $this->phoneUtil->isValidNumber($phoneObject);
$this->assertFalse($valid, "Checking phone number is invalid");
}
public function testIsMobileNumberPortableRegion()
{
$this->assertTrue($this->phoneUtil->isMobileNumberPortableRegion(RegionCode::US));
$this->assertTrue($this->phoneUtil->isMobileNumberPortableRegion(RegionCode::GB));
$this->assertFalse($this->phoneUtil->isMobileNumberPortableRegion(RegionCode::AE));
$this->assertFalse($this->phoneUtil->isMobileNumberPortableRegion(RegionCode::BS));
}
/**
* 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.
*
* <p>This method assumes the validity of the number passed in has already been checked, and that
* the number is suitable for geocoding. We consider fixed-line and mobile numbers possible
* candidates for geocoding.
*
* <p>If $userRegion is set, we also consider the region of the user. If the phone number is from
* the same region as the user, only a lower-level description will be returned, if one exists.
* Otherwise, the phone number's region will be returned, with optionally some more detailed
* information.
*
* <p>For example, for a user from the region "US" (United States), we would show "Mountain View,
* CA" for a particular number, omitting the United States from the description. For a user from
* the United Kingdom (region "GB"), for the same number we may show "Mountain View, CA, United
* States" or even just "United States".
*
* @param PhoneNumber $number a valid phone number for which we want to get a text description
* @param string $locale the language code for which the description should be written
* @param string $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 string a text description for the given language code for the given phone number
*/
public function getDescriptionForValidNumber(PhoneNumber $number, $locale, $userRegion = null)
{
// If the user region matches the number's region, then we just show the lower-level
// description, if one exists - if no description exists, we will show the region(country) name
// for the number.
$regionCode = $this->phoneUtil->getRegionCodeForNumber($number);
if ($userRegion == null || $userRegion == $regionCode) {
$languageStr = Locale::getPrimaryLanguage($locale);
$scriptStr = "";
$regionStr = Locale::getRegion($locale);
$mobileToken = PhoneNumberUtil::getCountryMobileToken($number->getCountryCode());
$nationalNumber = $this->phoneUtil->getNationalSignificantNumber($number);
if ($mobileToken !== "" && !strncmp($nationalNumber, $mobileToken, strlen($mobileToken))) {
// In some countries, eg. Argentina, mobile numbers have a mobile token before the national
// destination code, this should be removed before geocoding.
$nationalNumber = substr($nationalNumber, strlen($mobileToken));
$region = $this->phoneUtil->getRegionCodeForCountryCode($number->getCountryCode());
try {
$copiedNumber = $this->phoneUtil->parse($nationalNumber, $region);
} catch (NumberParseException $e) {
// If this happens, just reuse what we had.
$copiedNumber = $number;
}
$areaDescription = $this->prefixFileReader->getDescriptionForNumber($copiedNumber, $languageStr, $scriptStr, $regionStr);
} else {
$areaDescription = $this->prefixFileReader->getDescriptionForNumber($number, $languageStr, $scriptStr, $regionStr);
}
return strlen($areaDescription) > 0 ? $areaDescription : $this->getCountryNameForNumber($number, $locale);
}
// Otherwise, we just show the region(country) name for now.
return $this->getRegionDisplayName($regionCode, $locale);
// TODO: Concatenate the lower-level and country-name information in an appropriate
// way for each language.
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->app->singleton('libphonenumber', function ($app) {
return PhoneNumberUtil::getInstance();
});
$this->app->alias('libphonenumber', 'libphonenumber\\PhoneNumberUtil');
}
public function isValid($value)
{
if (!is_scalar($value)) {
$this->error(self::INVALID);
return false;
}
$country = $this->getCountry();
$supportedCountries = $this->libPhoneNumber->getSupportedRegions();
if (!in_array($country, $supportedCountries)) {
$this->error(self::UNSUPPORTED);
return false;
}
try {
$numberProto = $this->libPhoneNumber->parse($value, $country);
} catch (NumberParseException $e) {
$this->error(self::INVALID_NUMBER);
return false;
}
if (!$this->libPhoneNumber->isValidNumber($numberProto)) {
$this->error(self::INVALID_NUMBER);
return false;
}
$region = $this->libPhoneNumber->getRegionCodeForNumber($numberProto);
if ($this->libPhoneNumber->isValidNumberForRegion($numberProto, $region)) {
return true;
}
$this->error(self::NO_MATCH);
return false;
}
public function testTKGeoLocation()
{
$number = '+6903010';
$phoneNumber = $this->phoneUtil->parse($number, RegionCode::ZZ);
$this->assertEquals('TK', $this->phoneUtil->getRegionCodeForNumber($phoneNumber));
$this->assertEquals('Tokelau', $this->geocoder->getDescriptionForNumber($phoneNumber, 'en'));
}
/**
* Deserialize a phone number from XML.
*
* @param XmlDeserializationVisitor $visitor Deserialization visitor.
* @param SimpleXMLElement $data Data.
* @param array $type Type.
*
* @return PhoneNumber|null Phone number.
*/
public function deserializePhoneNumberFromXml(XmlDeserializationVisitor $visitor, $data, array $type)
{
$attributes = $data->attributes();
if (isset($attributes['nil'][0]) && (string) $attributes['nil'][0] === 'true' || isset($attributes['xsi:nil'][0]) && (string) $attributes['xsi:nil'][0] === 'true') {
return null;
}
return $this->phoneNumberUtil->parse($data, PhoneNumberUtil::UNKNOWN_REGION);
}
