com.google.i18n.phonenumbers.Phonenumber Java Examples

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();

    Phonenumber.PhoneNumber indianPhoneNumber = null;

    try {
        indianPhoneNumber = phoneNumberUtil.parse(phoneNumber, "IN");
        boolean val = phoneNumberUtil.isValidNumber(indianPhoneNumber);
        Log.d("Parzival", "Data: "+indianPhoneNumber.getCountryCode()+" >> "+indianPhoneNumber.getNationalNumber());
        Log.d("Parzival", "Val: "+val);
    } catch (NumberParseException e) {
        e.printStackTrace();
    }

}
 

private String formatPhoneNumber(Context context, String number) {
    if (TextUtils.isEmpty(number)) {
        return context.getString(R.string.no_known_number);
    }

    PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
    Locale locale = Locale.getDefault();
    String country = locale != null && locale.getCountry() != null && !TextUtils.isEmpty(locale.getCountry()) ? locale.getCountry() : "US";
    try {
        Phonenumber.PhoneNumber phoneNumber = phoneUtil.parse(number, country);
        return phoneUtil.format(phoneNumber, PhoneNumberUtil.PhoneNumberFormat.INTERNATIONAL);
    } catch (NumberParseException e) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            return PhoneNumberUtils.formatNumber(number, country);
        }
        return PhoneNumberUtils.formatNumber(number);
    }
}
 

public static boolean validatePhone(String phNumber, String countryCode) {
  PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
  String contryCode = countryCode;
  if (!StringUtils.isBlank(countryCode) && (countryCode.charAt(0) != '+')) {
    contryCode = "+" + countryCode;
  }
  Phonenumber.PhoneNumber phoneNumber = null;
  try {
    if (StringUtils.isBlank(countryCode)) {
      contryCode = PropertiesCache.getInstance().getProperty("sunbird_default_country_code");
    }
    String isoCode = phoneNumberUtil.getRegionCodeForCountryCode(Integer.parseInt(contryCode));
    phoneNumber = phoneNumberUtil.parse(phNumber, isoCode);
    return phoneNumberUtil.isValidNumber(phoneNumber);
  } catch (NumberParseException e) {
    ProjectLogger.log("Exception occurred while validating phone number : ", e);
    ProjectLogger.log(phNumber + "this phone no. is not a valid one.");
  }
  return false;
}
 

public static boolean validatePhone(String phone, String countryCode) {
  PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
  String code = countryCode;
  if (StringUtils.isNotBlank(countryCode) && (countryCode.charAt(0) != '+')) {
    code = "+" + countryCode;
  }
  Phonenumber.PhoneNumber phoneNumber = null;
  try {
    if (StringUtils.isBlank(countryCode)) {
      code = PropertiesCache.getInstance().getProperty("sunbird_default_country_code");
    }
    String isoCode = phoneNumberUtil.getRegionCodeForCountryCode(Integer.parseInt(code));
    phoneNumber = phoneNumberUtil.parse(phone, isoCode);
    return phoneNumberUtil.isValidNumber(phoneNumber);
  } catch (NumberParseException e) {
    ProjectLogger.log(
        "PhoneValidator:validatePhone: Exception occurred while validating phone number = ", e);
  }
  return false;
}
 

private void displayContactData(){
    List<PhoneInfo> phoneInfoList = MobileContactSingleton.getInstance().getMobileContact();

    PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
    for(PhoneInfo phoneInfo: phoneInfoList) {
        try {
            String phoneNum = phoneInfo.getPhoneNum();
            Phonenumber.PhoneNumber phoneNumProto = phoneUtil.parse(phoneNum, "CN");
            boolean isValid = phoneUtil.isValidNumber(phoneNumProto);
            Log.d("hyh", "ContactFragment: displayContactData: isValid="+isValid+" ,phoneNum="+phoneNum);
            if (isValid) {
                String formatPhoneNum = phoneUtil.format(phoneNumProto,
                    PhoneNumberUtil.PhoneNumberFormat.E164);
                Log.d("hyh", "ContactMgr: run: formatPhoneNum=" + formatPhoneNum);
            }
        } catch (NumberParseException e) {
            Log.d("hyh", "ContactFragment: displayContactData: phone="+phoneInfo.getPhoneNum());
            e.printStackTrace();
        }
    }

    ContactListAdapter contactListAdapter = new ContactListAdapter(getContext(),phoneInfoList);
    mRvContactList.setLayoutManager(new LinearLayoutManager(getContext()));
    mRvContactList.setAdapter(contactListAdapter);
}
 

public static String parseHandleId(String handleID){
    PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
    String locale = Resources.getSystem().getConfiguration().locale.getCountry();
    String returnHandle;

    if (phoneNumberUtil.isPossibleNumber(handleID, locale)){
        try {
            Phonenumber.PhoneNumber phoneNumber = phoneNumberUtil.parse(handleID, locale);
            returnHandle = phoneNumberUtil.format(phoneNumber, PhoneNumberUtil.PhoneNumberFormat.E164);
        }catch (Exception ex){
            returnHandle = handleID;
        }
    } else {
        returnHandle = handleID.trim().toLowerCase();
    }

    return returnHandle;
}
 

private String validateThenFormatMobileNumber(String phone) {
    try {
        PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
        Phonenumber.PhoneNumber phoneNumber = phoneNumberUtil.parse(phone, "+86");
        if (phoneNumberUtil.isValidNumber(phoneNumber) && (
                phoneNumberUtil.getNumberType(phoneNumber)
                == PhoneNumberUtil.PhoneNumberType.MOBILE
                || phoneNumberUtil.getNumberType(phoneNumber)
                   == PhoneNumberUtil.PhoneNumberType.FIXED_LINE_OR_MOBILE)) {
            return phoneNumberUtil.format(phoneNumber, PhoneNumberUtil.PhoneNumberFormat.E164);
        } else {
            return "";
        }
    } catch (NumberParseException e) {
        return "";
    }
}
 

public Handle getHandleByAccount(String account) throws SQLException {
    try {
        PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
        Phonenumber.PhoneNumber numberOne = phoneNumberUtil.parse(account, Locale.getDefault().getCountry());
        String numberStringOne = phoneNumberUtil.format(numberOne, PhoneNumberUtil.PhoneNumberFormat.E164);

        Handle handle = getHandleById(numberStringOne);

        if (handle == null){
            Phonenumber.PhoneNumber numberTwo = numberOne.clearCountryCode();
            String numberStringTwo = phoneNumberUtil.format(numberTwo, PhoneNumberUtil.PhoneNumberFormat.E164).substring(2);

            return getHandleById(numberStringTwo);
        }else {
            return handle;
        }
    }catch(Exception ex){
        return getHandleById(account);
    }
}
 

/**
 * Format a given phone number to a readable string for the user
 *
 * @param phoneNumber the number to format
 * @return the formatted number
 */
public static String formatPhoneNumber(String phoneNumber) {
    if (phoneNumber == null) return null;
    phoneNumber = normalizePhoneNumber(phoneNumber);
    Phonenumber.PhoneNumber formattedNumber = null;
    PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();

    try {
        formattedNumber = phoneUtil.parse(phoneNumber, sLocale.getCountry());
    } catch (NumberParseException e) {
        Timber.w(e);
        return phoneNumber;
    }

    PhoneNumberUtil.PhoneNumberFormat format;
    if (phoneUtil.getRegionCodeForCountryCode(formattedNumber.getCountryCode()).equals(sLocale.getCountry()))
        format = PhoneNumberUtil.PhoneNumberFormat.NATIONAL;
    else
        format = PhoneNumberUtil.PhoneNumberFormat.INTERNATIONAL;

    return phoneUtil.format(formattedNumber, format);
}
 

static boolean isPhoneNumberValid(String phoneNumber) {

        String formattedPhoneNumber = convertInternationalPrefix(phoneNumber);

        String region;
        if (isPossibleNationalNumber(formattedPhoneNumber)) {
            region = "DE";
        } else if (isInternationalNumber(formattedPhoneNumber)) {
            region = null;
        } else {
            return true; // If the number cannot be interpreted as an international or possible DE phone number, do not attempt to validate it.
        }

        try {
            Phonenumber.PhoneNumber parsedPhoneNumber = PhoneNumberUtil.getInstance().parse(formattedPhoneNumber, region);
            return PhoneNumberUtil.getInstance().isValidNumber(parsedPhoneNumber);
        } catch (NumberParseException e) {
            return false;
        }
    }
 

@RequiresPermission(anyOf = {
    android.Manifest.permission.READ_PHONE_STATE,
    android.Manifest.permission.READ_SMS,
    android.Manifest.permission.READ_PHONE_NUMBERS
})
@SuppressLint("MissingPermission")
public static Optional<Phonenumber.PhoneNumber> getDeviceNumber(Context context) {
  try {
    final String           localNumber = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).getLine1Number();
    final Optional<String> countryIso  = getSimCountryIso(context);

    if (TextUtils.isEmpty(localNumber)) return Optional.absent();
    if (!countryIso.isPresent())        return Optional.absent();

    return Optional.fromNullable(PhoneNumberUtil.getInstance().parse(localNumber, countryIso.get()));
  } catch (NumberParseException e) {
    Log.w(TAG, e);
    return Optional.absent();
  }
}
 

public static boolean isShortCode(@NonNull String localNumber, @NonNull String number) {
  try {
    PhoneNumberUtil         util              = PhoneNumberUtil.getInstance();
    Phonenumber.PhoneNumber localNumberObject = util.parse(localNumber, null);
    String                  localCountryCode  = util.getRegionCodeForNumber(localNumberObject);
    String                  bareNumber        = number.replaceAll("[^0-9+]", "");

    // libphonenumber seems incorrect for Russia and a few other countries with 4 digit short codes.
    if (bareNumber.length() <= 4 && !SHORT_COUNTRIES.contains(localCountryCode)) {
      return true;
    }

    Phonenumber.PhoneNumber shortCode = util.parse(number, localCountryCode);
    return ShortNumberInfo.getInstance().isPossibleShortNumberForRegion(shortCode, localCountryCode);
  } catch (NumberParseException e) {
    Log.w(TAG, e);
    return false;
  }
}
 

public static boolean isShortCode(@NonNull String localNumber, @NonNull String number) {
  try {
    PhoneNumberUtil         util              = PhoneNumberUtil.getInstance();
    Phonenumber.PhoneNumber localNumberObject = util.parse(localNumber, null);
    String                  localCountryCode  = util.getRegionCodeForNumber(localNumberObject);
    String                  bareNumber        = number.replaceAll("[^0-9+]", "");

    // libphonenumber doesn't seem to be correct for Germany and Finland
    if (bareNumber.length() <= 6 && ("DE".equals(localCountryCode) || "FI".equals(localCountryCode) || "SK".equals(localCountryCode))) {
      return true;
    }

    // libphonenumber seems incorrect for Russia and a few other countries with 4 digit short codes.
    if (bareNumber.length() <= 4 && !SHORT_COUNTRIES.contains(localCountryCode)) {
      return true;
    }

    Phonenumber.PhoneNumber shortCode = util.parse(number, localCountryCode);
    return ShortNumberInfo.getInstance().isPossibleShortNumberForRegion(shortCode, localCountryCode);
  } catch (NumberParseException e) {
    Log.w(TAG, e);
    return false;
  }
}
 

private static String parseNumber(String paramString) {
    if (paramString == null) {
        return null;
    }
    PhoneNumberUtil numberUtil = PhoneNumberUtil.getInstance();
    String result;
    try {
        Phonenumber.PhoneNumber localPhoneNumber = numberUtil.parse(paramString, null);
        result = numberUtil.getRegionCodeForNumber(localPhoneNumber);
        if (result == null) {
            return null;
        }
    } catch (NumberParseException localNumberParseException) {
        return null;
    }
    return result;
}
 

protected String validate() {
    String region = null;
    String phone = null;
    if (mLastEnteredPhone != null) {
        try {
            Phonenumber.PhoneNumber p = mPhoneNumberUtil.parse(mLastEnteredPhone, null);
            StringBuilder sb = new StringBuilder(16);
            sb.append('+').append(p.getCountryCode()).append(p.getNationalNumber());
            phone = sb.toString();
            region = mPhoneNumberUtil.getRegionCodeForNumber(p);
        } catch (NumberParseException ignore) {
        }
    }
    if (region != null) {
        return phone;
    } else {
        return null;
    }
}
 

@SuppressLint("MissingPermission")
private void initializeNumber() {
  Optional<Phonenumber.PhoneNumber> localNumber = Optional.absent();

  if (Permissions.hasAll(requireContext(), Manifest.permission.READ_PHONE_STATE)) {
    localNumber = Util.getDeviceNumber(requireContext());
  }

  if (localNumber.isPresent()) {
    getModel().onNumberDetected(localNumber.get().getCountryCode(), localNumber.get().getNationalNumber());
  } else {
    Optional<String> simCountryIso = Util.getSimCountryIso(requireContext());

    if (simCountryIso.isPresent() && !TextUtils.isEmpty(simCountryIso.get())) {
      getModel().onNumberDetected(PhoneNumberUtil.getInstance().getCountryCodeForRegion(simCountryIso.get()), 0);
    }
  }
}
 

/**
 * Creates a instance from the given PhoneNumber
 * @param prototype The PhoneNumber to construct the instance from
 */
public E164PhoneNumberWithExtension(Phonenumber.PhoneNumber prototype) {

    StringBuilder e164Builder = new StringBuilder();
    PHONE_NUMBER_UTIL.format(prototype, PhoneNumberFormat.E164, e164Builder);
    
	try {
        this.number = PHONE_NUMBER_UTIL.parse(e164Builder.toString(), "GB");
    } catch (NumberParseException e) {
        throw new PhoneNumberParseException(
                EX_PARSE_MSG_PREFIX + prototype.getNationalNumber() +"}", e);
    }
	
	if (prototype.hasExtension()) {
		this.number.setExtension(prototype.getExtension());
	}
}
 

/**
 * Returns the underlying LibPhoneNumber {@link Phonenumber.PhoneNumber} instance. 
 * To preserve the immutability of E164PhoneNumber, a copy is made.
 * @return The underlying PhoneNumber instance
 */
public Phonenumber.PhoneNumber getUnderlyingPhoneNumber() {
    
	Phonenumber.PhoneNumber copy;
	
    StringBuilder e164Builder = new StringBuilder();
    PHONE_NUMBER_UTIL.format(number, PhoneNumberFormat.E164, e164Builder);
    
	try {
        copy = PHONE_NUMBER_UTIL.parse(e164Builder.toString(), "GB");
    } catch (NumberParseException e) {
        throw new PhoneNumberParseException(
                EX_PARSE_MSG_PREFIX + number.getNationalNumber() +"}", e);
    }
	
	if (number.hasExtension()) {
		copy.setExtension(number.getExtension());
	}
	return copy;
}
 

@Override
public void afterTextChanged(Editable s) {
    try {
        PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
        Phonenumber.PhoneNumber swissNumberProto = phoneUtil.parse(s.toString(), countryBean.getCountryCode());
        if(phoneUtil.isValidNumberForRegion(swissNumberProto, countryBean.getCountryCode())){
            nextBtn.setEnabled(true);
        }else{
            nextBtn.setEnabled(false);
        }
    } catch (NumberParseException e) {
        e.printStackTrace();
        nextBtn.setEnabled(false);
    }
}
 

/**
 * Sets phone number.
 *
 * @param rawNumber the raw number
 */
public void setPhoneNumber(String rawNumber) {
  try {
    Phonenumber.PhoneNumber number = parsePhoneNumber(rawNumber);
    if (mCountry == null || mCountry.getDialCode() != number.getCountryCode()) {
      selectCountry(number.getCountryCode());
    }
    mEditText.setText(mPhoneUtil.format(number, PhoneNumberUtil.PhoneNumberFormat.NATIONAL));
  } catch (NumberParseException ignored) {
  }
}
 

/**
 * Gets phone number.
 *
 * @return the phone number
 */
public String getPhoneNumber() {
  try {
    Phonenumber.PhoneNumber number = parsePhoneNumber(getRawInput());
    return mPhoneUtil.format(number, PhoneNumberUtil.PhoneNumberFormat.E164);
  } catch (NumberParseException ignored) {
  }
  return getRawInput();
}
 

public String getValue() {
    try {
        Phonenumber.PhoneNumber num = phoneUtil.parse(phone_number, country);
        return phoneUtil.format(num, PhoneNumberUtil.PhoneNumberFormat.E164).replace("+", "");
    } catch (NumberParseException e) {
        throw new IllegalArgumentException("Invalid phone number");
    }
}
 

@Override
public void afterTextChanged(Editable s) {
    try {
        PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
        Phonenumber.PhoneNumber swissNumberProto = phoneUtil.parse(s.toString(), countryBean.getCountryCode());
        if(phoneUtil.isValidNumberForRegion(swissNumberProto, countryBean.getCountryCode())){
            setBtnEnabled(true);
        }else{
            setBtnEnabled(false);
        }
    } catch (Exception e) {
        e.printStackTrace();
        setBtnEnabled(false);
    }
}
 

PhoneNumberFormatter(@NonNull String localNumberString) {
  try {
    Phonenumber.PhoneNumber libNumber   = phoneNumberUtil.parse(localNumberString, null);
    int                     countryCode = libNumber.getCountryCode();

    this.localNumber       = Optional.of(new PhoneNumber(localNumberString, countryCode, parseAreaCode(localNumberString, countryCode)));
    this.localCountryCode  = phoneNumberUtil.getRegionCodeForNumber(libNumber);
  } catch (NumberParseException e) {
    throw new AssertionError(e);
  }
}
 

public PeerChat getChatByAccount(String handle) throws SQLException {
    ChatBase chatBase;

    try {
        PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
        Phonenumber.PhoneNumber phoneNumberOne = phoneNumberUtil.parse(handle, Locale.getDefault().getCountry());

        String phoneNumberString = phoneNumberUtil.format(phoneNumberOne, PhoneNumberUtil.PhoneNumberFormat.E164);
        ChatBase attemptOne = getChatByIdentifier(phoneNumberString);

        if (attemptOne == null){
            Phonenumber.PhoneNumber phoneNumberTwo = phoneNumberOne.clearCountryCode();
            String phoneNumberStringTwo = phoneNumberUtil.format(phoneNumberTwo, PhoneNumberUtil.PhoneNumberFormat.E164).substring(2);
            ChatBase attemptTwo = getChatByIdentifier(phoneNumberStringTwo);

            if (attemptTwo == null){
                return null;
            }else {
                chatBase = attemptTwo;
            }
        }else {
            chatBase = attemptOne;
        }
    }catch(Exception ex){
        chatBase = getChatByIdentifier(handle);
    }

    if (chatBase == null) return null;
    if (chatBase instanceof GroupChat) return null;

    return (PeerChat) chatBase;
}
 

private static String formatNumber(@NonNull PhoneNumberUtil util, @NonNull String e164Number) {
  try {
    Phonenumber.PhoneNumber number = getPhoneNumber(util, e164Number);
    return util.format(number, PhoneNumberUtil.PhoneNumberFormat.INTERNATIONAL);
  } catch (NumberParseException e) {
    return e164Number;
  }
}
 

/**
 * Finds actual name of region from a valid number. So for example +1 might map to US or Canada or other territories.
 */
private static @Nullable String getActualCountry(@NonNull PhoneNumberUtil util, @NonNull String e164Number) {
  try {
    Phonenumber.PhoneNumber phoneNumber = getPhoneNumber(util, e164Number);
    String                  regionCode  = util.getRegionCodeForNumber(phoneNumber);

    if (regionCode != null) {
      return PhoneNumberFormatter.getRegionDisplayName(regionCode);
    }

  } catch (NumberParseException e) {
    return null;
  }
  return null;
}
 

private boolean isShortCode(@NonNull String bareNumber, String localCountryCode) {
  try {
    Phonenumber.PhoneNumber parsedNumber = phoneNumberUtil.parse(bareNumber, localCountryCode);
    return ShortNumberInfo.getInstance().isPossibleShortNumberForRegion(parsedNumber, localCountryCode);
  } catch (NumberParseException e) {
    return false;
  }
}
 

private Phonenumber.PhoneNumber parsePhoneNumber(String number) throws NumberParseException {
  String defaultRegion = mCountry != null ? mCountry.getCode().toUpperCase() : "";
  return mPhoneUtil.parseAndKeepRawInput(number, defaultRegion);
}
 

private static Phonenumber.PhoneNumber getPhoneNumber(@NonNull PhoneNumberUtil util, @NonNull String e164Number)
  throws NumberParseException
{
  return util.parse(e164Number, null);
}