android.telephony.PhoneNumberUtils Java Examples

private static String bestPhoneNumberFormatter(final String number) {
    if (number == null) return null;
    final String formatted = PhoneNumberUtils.formatNumber(number);
    if (formatted.contains(" ")) {
        return formatted;
    } else {
        final StringBuilder spaced = new StringBuilder();
        final char[] array = number.toCharArray();
        boolean first = true;
        int counter = 0;
        for (char c : array) {
            spaced.append(c);
            first = false;
            counter++;
            if (counter == 5) {
                spaced.append(" ");
            }
        }
        return spaced.toString();
    }
}
 

private static String bestPhoneNumberFormatter(final String number) {
    if (number == null) return null;
    final String formatted = PhoneNumberUtils.formatNumber(number);
    if (formatted.contains(" ")) {
        return formatted;
    } else {
        final StringBuilder spaced = new StringBuilder();
        final char[] array = number.toCharArray();
        boolean first = true;
        int counter = 0;
        for (char c : array) {
            spaced.append(c);
            first = false;
            counter++;
            if (counter == 5) {
                spaced.append(" ");
            }
        }
        return spaced.toString();
    }
}
 

/**
 * Normalizes the specified phone number to its E.164 representation, if supported by the platform
 *
 * @param context a context reference
 * @param phoneNumber the phone number to normalize
 * @return the normalized phone number
 */
@SuppressLint("NewApi")
public static String normalizePhoneNumber(final Context context, final String phoneNumber) {
	if (Build.VERSION.SDK_INT >= 21) {
		final String countryIso2 = DeviceInfo.getCountryISO2(context);

		if (countryIso2 != null) {
			final String formatted = PhoneNumberUtils.formatNumberToE164(phoneNumber, countryIso2.toUpperCase(Locale.US));

			if (formatted != null) {
				return formatted;
			}
		}
	}

	return phoneNumber;
}
 

public void whatsappShare(String lookupKey) {
    final Contact contact;
    try {
        contact = Contact.fromLookupKey(lookupKey, contentResolver);
    } catch (Contact.ContactNotFoundException e) {
        Log.e(TAG, S.str(e.getMessage()));
        e.printStackTrace();
        BaldToast.error(this);
        finish();
        return;
    }
    shareIntent.setPackage(D.WHATSAPP_PACKAGE_NAME);
    String smsNumber = PhoneNumberUtils.stripSeparators(contact.getWhatsappNumbers().get(0)).replace("+", "").replace(" ", "");
    shareIntent.putExtra("jid", smsNumber + "@s.whatsapp.net"); //phone number without "+" prefix
    startActivity(shareIntent);
    finish();
}
 

private void inflateWhatsapp() {
    final List<String> whatappNumbers = contact.getWhatsappNumbers();
    for (String whatappNumber : whatappNumbers) {
        final View layout = layoutInflater.inflate(R.layout.contact_whatsapp, ll, false);
        layout.findViewById(R.id.whatsapp).setOnClickListener((v) ->
                startActivity(
                        new Intent("android.intent.activate.MAIN")
                                .setComponent(new ComponentName("com.whatsapp", "com.whatsapp.Conversation"))
                                .putExtra("jid",
                                        PhoneNumberUtils.stripSeparators(
                                                whatappNumber
                                                        .replaceAll(
                                                                "[^0123456789]",
                                                                "")
                                        ) + "@s.whatsapp.net")
                )
        );
        ll.addView(layout);
    }
}
 

private static void updateNormalizedNumber(Context context, ContentResolver resolver,
        String dataId, String number) {
    if (TextUtils.isEmpty(number) || TextUtils.isEmpty(dataId)) {
        return;
    }
    final String countryIso = getCurrentCountryIso(context);
    if (TextUtils.isEmpty(countryIso)) {
        return;
    }
    final String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number,
            getCurrentCountryIso(context));
    if (TextUtils.isEmpty(normalizedNumber)) {
        return;
    }
    final ContentValues values = new ContentValues();
    values.put(Phone.NORMALIZED_NUMBER, normalizedNumber);
    resolver.update(Data.CONTENT_URI, values, Data._ID + "=?", new String[] {dataId});
}
 

private static void gatherTelLinks(ArrayList<LinkSpec> links, Spannable s,
        @Nullable Context context) {
    PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
    final TelephonyManager tm = (context == null)
            ? TelephonyManager.getDefault()
            : TelephonyManager.from(context);
    Iterable<PhoneNumberMatch> matches = phoneUtil.findNumbers(s.toString(),
            tm.getSimCountryIso().toUpperCase(Locale.US),
            Leniency.POSSIBLE, Long.MAX_VALUE);
    for (PhoneNumberMatch match : matches) {
        LinkSpec spec = new LinkSpec();
        spec.url = "tel:" + PhoneNumberUtils.normalizeNumber(match.rawString());
        spec.start = match.start();
        spec.end = match.end();
        links.add(spec);
    }
}
 

@Override
public String[] encode(Iterable<String> names, String organization, Iterable<String> addresses,
        Iterable<String> phones, Iterable<String> emails, Iterable<String> urls, String note) {
    StringBuilder newContents = new StringBuilder(100);
    newContents.append("BEGIN:VCARD").append(TERMINATOR);
    newContents.append("VERSION:3.0").append(TERMINATOR);
    StringBuilder newDisplayContents = new StringBuilder(100);
    appendUpToUnique(newContents, newDisplayContents, "N", names, 1, null);
    append(newContents, newDisplayContents, "ORG", organization);
    appendUpToUnique(newContents, newDisplayContents, "ADR", addresses, 1, null);
    appendUpToUnique(newContents, newDisplayContents, "TEL", phones, Integer.MAX_VALUE,
            new Formatter() {
                @Override
                public String format(String source) {
                    return PhoneNumberUtils.formatNumber(source);
                }
            });
    appendUpToUnique(newContents, newDisplayContents, "EMAIL", emails, Integer.MAX_VALUE, null);
    appendUpToUnique(newContents, newDisplayContents, "URL", urls, Integer.MAX_VALUE, null);
    append(newContents, newDisplayContents, "NOTE", note);
    newContents.append("END:VCARD").append(TERMINATOR);
    return new String[] { newContents.toString(), newDisplayContents.toString() };
}
 

@Override
public String[] encode(Iterable<String> names,
                       String organization,
                       Iterable<String> addresses,
                       Iterable<String> phones,
                       Iterable<String> emails,
                       String url,
                       String note) {
  StringBuilder newContents = new StringBuilder(100);
  StringBuilder newDisplayContents = new StringBuilder(100);
  newContents.append("BEGIN:VCARD").append(TERMINATOR);
  appendUpToUnique(newContents, newDisplayContents, "N", names, 1, null);
  append(newContents, newDisplayContents, "ORG", organization);
  appendUpToUnique(newContents, newDisplayContents, "ADR", addresses, 1, null);
  appendUpToUnique(newContents, newDisplayContents, "TEL", phones, Integer.MAX_VALUE, new Formatter() {
    @Override
    public String format(String source) {
      return PhoneNumberUtils.formatNumber(source);
    }
  });
  appendUpToUnique(newContents, newDisplayContents, "EMAIL", emails, Integer.MAX_VALUE, null);
  append(newContents, newDisplayContents, "URL", url);
  append(newContents, newDisplayContents, "NOTE", note);
  newContents.append("END:VCARD").append(TERMINATOR);
  return new String[] { newContents.toString(), newDisplayContents.toString() };
}
 

@Override
public CharSequence getDisplayContents() {
  SMSParsedResult smsResult = (SMSParsedResult) getResult();
  String[] rawNumbers = smsResult.getNumbers();
  String[] formattedNumbers = new String[rawNumbers.length];
  for (int i = 0; i < rawNumbers.length; i++) {
    formattedNumbers[i] = PhoneNumberUtils.formatNumber(rawNumbers[i]);
  }
  StringBuilder contents = new StringBuilder(50);
  ParsedResult.maybeAppend(formattedNumbers, contents);
  ParsedResult.maybeAppend(smsResult.getSubject(), contents);
  ParsedResult.maybeAppend(smsResult.getBody(), contents);
  return contents.toString();
}
 

@Override
public String[] encode(Iterable<String> names,
                       String organization,
                       Iterable<String> addresses,
                       Iterable<String> phones,
                       Iterable<String> emails,
                       Iterable<String> urls,
                       String note) {
  StringBuilder newContents = new StringBuilder(100);
  newContents.append("BEGIN:VCARD").append(TERMINATOR);
  newContents.append("VERSION:3.0").append(TERMINATOR);
  StringBuilder newDisplayContents = new StringBuilder(100);
  appendUpToUnique(newContents, newDisplayContents, "N", names, 1, null);
  append(newContents, newDisplayContents, "ORG", organization);
  appendUpToUnique(newContents, newDisplayContents, "ADR", addresses, 1, null);
  appendUpToUnique(newContents, newDisplayContents, "TEL", phones, Integer.MAX_VALUE, new Formatter() {
    @Override
    public String format(String source) {
      return PhoneNumberUtils.formatNumber(source);
    }
  });
  appendUpToUnique(newContents, newDisplayContents, "EMAIL", emails, Integer.MAX_VALUE, null);
  appendUpToUnique(newContents, newDisplayContents, "URL", urls, Integer.MAX_VALUE, null);
  append(newContents, newDisplayContents, "NOTE", note);
  newContents.append("END:VCARD").append(TERMINATOR);
  return new String[] { newContents.toString(), newDisplayContents.toString() };
}
 

@SuppressWarnings({"SimplifiableIfStatement", "RedundantIfStatement"})
@Override
public boolean isValid() {
    if (Utils.isBlank(destination))
        return false;
    if (!PhoneNumberUtils.isWellFormedSmsAddress(destination))
        return false;
    if (Utils.isBlank(content))
        return false;
    return true;
}
 

@Override
public CharSequence getDisplayContents() {
  SMSParsedResult smsResult = (SMSParsedResult) getResult();
  String[] rawNumbers = smsResult.getNumbers();
  String[] formattedNumbers = new String[rawNumbers.length];
  for (int i = 0; i < rawNumbers.length; i++) {
    formattedNumbers[i] = PhoneNumberUtils.formatNumber(rawNumbers[i]);
  }
  StringBuilder contents = new StringBuilder(50);
  ParsedResult.maybeAppend(formattedNumbers, contents);
  ParsedResult.maybeAppend(smsResult.getSubject(), contents);
  ParsedResult.maybeAppend(smsResult.getBody(), contents);
  return contents.toString();
}
 

private String makeNumberValid(String contact)	{
	if (contact == null)	{
		return null;
	}
	String number = PhoneNumberUtils.normalizeNumber(contact);
	if (DEBUG)	{
		Log.e(TAG, "corrected number: " + number );
	}
	boolean valid = isNumberValid(number);
	if (valid)	{
		return number;
	}
	return null;
}
 

private Boolean isNumberValid(String contact)	{
if (contact == null)	{
	return false;
}
boolean valid1 = PhoneNumberUtils.isGlobalPhoneNumber(contact);
boolean valid2 = PhoneNumberUtils.isWellFormedSmsAddress(contact);
      return (valid1) && (valid2);
  }
 

@Override
public CharSequence format(CharSequence value, int index) {
  value = PhoneNumberUtils.formatNumber(value.toString());
  Map<String,Set<String>> metadata =
      metadataForIndex == null || metadataForIndex.size() <= index ? null : metadataForIndex.get(index);
  value = formatMetadata(value, metadata);
  return value;
}
 

@Override
public CharSequence format(CharSequence value, int index) {
  value = PhoneNumberUtils.formatNumber(value.toString());
  Map<String,Set<String>> metadata =
      metadataForIndex == null || metadataForIndex.size() <= index ? null : metadataForIndex.get(index);
  value = formatMetadata(value, metadata);
  return value;
}
 

@Override
public CharSequence getDisplayContents() {
  SMSParsedResult smsResult = (SMSParsedResult) getResult();
  String[] rawNumbers = smsResult.getNumbers();
  String[] formattedNumbers = new String[rawNumbers.length];
  for (int i = 0; i < rawNumbers.length; i++) {
    formattedNumbers[i] = PhoneNumberUtils.formatNumber(rawNumbers[i]);
  }
  StringBuilder contents = new StringBuilder(50);
  ParsedResult.maybeAppend(formattedNumbers, contents);
  ParsedResult.maybeAppend(smsResult.getSubject(), contents);
  ParsedResult.maybeAppend(smsResult.getBody(), contents);
  return contents.toString();
}
 

/**
 * Checks address completion status in the given profile.
 *
 * If the country code is not set or invalid, but all fields for the default locale's country
 * code are present, then the profile is deemed "complete." AutoflllAddress.toPaymentAddress()
 * will use the default locale to fill in a blank country code before sending the address to the
 * renderer.
 *
 * @param  profile The autofill profile containing the address information.
 * @return int     The completion status.
 */
@CompletionStatus
public static int checkAddressCompletionStatus(
        AutofillProfile profile, @CompletenessCheckType int checkType) {
    int invalidFieldsCount = 0;
    int completionStatus = COMPLETE;

    if (checkType != IGNORE_PHONE_COMPLETENESS_CHECK
            && !PhoneNumberUtils.isGlobalPhoneNumber(
                       PhoneNumberUtils.stripSeparators(profile.getPhoneNumber().toString()))) {
        completionStatus = INVALID_PHONE_NUMBER;
        invalidFieldsCount++;
    }

    List<Integer> requiredFields = AutofillProfileBridge.getRequiredAddressFields(
            AutofillAddress.getCountryCode(profile));
    for (int fieldId : requiredFields) {
        if (fieldId == AddressField.RECIPIENT || fieldId == AddressField.COUNTRY) continue;
        if (!TextUtils.isEmpty(getProfileField(profile, fieldId))) continue;
        completionStatus = INVALID_ADDRESS;
        invalidFieldsCount++;
        break;
    }

    if (TextUtils.isEmpty(profile.getFullName())) {
        completionStatus = INVALID_RECIPIENT;
        invalidFieldsCount++;
    }

    if (invalidFieldsCount > 1) {
        completionStatus = INVALID_MULTIPLE_FIELDS;
    }

    return completionStatus;
}
 

/**
     * updates hint
     */
    private void updateHint() {
        if (editText_registeredCarrierNumber != null && hintExampleNumberEnabled) {
            String formattedNumber = "";
            Phonenumber.PhoneNumber exampleNumber = getPhoneUtil().getExampleNumberForType(getSelectedCountryNameCode(), getSelectedHintNumberType());
            if (exampleNumber != null) {
                formattedNumber = exampleNumber.getNationalNumber() + "";
//                Log.d(TAG, "updateHint: " + formattedNumber);
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                    formattedNumber = PhoneNumberUtils.formatNumber(getSelectedCountryCodeWithPlus() + formattedNumber, getSelectedCountryNameCode());
                } else {
                    formattedNumber = PhoneNumberUtils.formatNumber(getSelectedCountryCodeWithPlus() + formattedNumber);
                }
                if (formattedNumber != null) {
                    formattedNumber = formattedNumber.substring(getSelectedCountryCodeWithPlus().length()).trim();
                }
//                Log.d(TAG, "updateHint: after format " + formattedNumber + " " + selectionMemoryTag);
            } else {
//                Log.w(TAG, "updateHint: No example number found for this country (" + getSelectedCountryNameCode() + ") or this type (" + hintExampleNumberType.name() + ").");
            }

            //fallback to original hint
            if (formattedNumber == null) {
                formattedNumber = originalHint;
            }

            editText_registeredCarrierNumber.setHint(formattedNumber);
        }
    }
 

@Override
public CharSequence getDisplayContents() {
    SMSParsedResult smsResult = (SMSParsedResult) getResult();
    StringBuilder contents = new StringBuilder(50);
    String[] rawNumbers = smsResult.getNumbers();
    String[] formattedNumbers = new String[rawNumbers.length];
    for (int i = 0; i < rawNumbers.length; i++) {
        formattedNumbers[i] = PhoneNumberUtils.formatNumber(rawNumbers[i]);
    }
    ParsedResult.maybeAppend(formattedNumbers, contents);
    ParsedResult.maybeAppend(smsResult.getSubject(), contents);
    ParsedResult.maybeAppend(smsResult.getBody(), contents);
    return contents.toString();
}
 

@Override
public CharSequence getDisplayContents() {
  SMSParsedResult smsResult = (SMSParsedResult) getResult();
  String[] rawNumbers = smsResult.getNumbers();
  String[] formattedNumbers = new String[rawNumbers.length];
  for (int i = 0; i < rawNumbers.length; i++) {
    formattedNumbers[i] = PhoneNumberUtils.formatNumber(rawNumbers[i]);
  }
  StringBuilder contents = new StringBuilder(50);
  ParsedResult.maybeAppend(formattedNumbers, contents);
  ParsedResult.maybeAppend(smsResult.getSubject(), contents);
  ParsedResult.maybeAppend(smsResult.getBody(), contents);
  return contents.toString();
}
 

/**
 * Generate the formatted number by ignoring all non-dialable chars and stick the cursor to the
 * nearest dialable char to the left. For instance, if the number is  (650) 123-45678 and '4' is
 * removed then the cursor should be behind '3' instead of '-'.
 */
private String reformat(CharSequence s, int cursor) {
    // The index of char to the leftward of the cursor.
    int curIndex = cursor - 1;
    String formatted = null;
    mFormatter.clear();
    char lastNonSeparator = 0;
    boolean hasCursor = false;
    int len = s.length();
    for (int i = 0; i < len; i++) {
        char c = s.charAt(i);
        if (PhoneNumberUtils.isNonSeparator(c)) {
            if (lastNonSeparator != 0) {
                formatted = getFormattedNumber(lastNonSeparator, hasCursor);
                hasCursor = false;
            }
            lastNonSeparator = c;
        }
        if (i == curIndex) {
            hasCursor = true;
        }
    }
    if (lastNonSeparator != 0) {
        formatted = getFormattedNumber(lastNonSeparator, hasCursor);
    }
    return formatted;
}
 

@VisibleForTesting
static boolean isNumberAddress(@NonNull String number) {
  if (number.contains("@"))             return false;

  final String networkNumber = PhoneNumberUtils.extractNetworkPortion(number);

  if (TextUtils.isEmpty(networkNumber)) return false;
  if (networkNumber.length() < 3)       return false;

  return PhoneNumberUtils.isWellFormedSmsAddress(number);
}
 

/**
 * {@inheritDoc}
 * Precondition :  At least number should not be null
 */
@Override
public NdefMessage createSms(@NotNull String number, String message) throws FormatException {
    number = number.startsWith("+") ? "+" + number.replaceAll("\\D", "") : number.replaceAll("\\D", "");
    if (!PhoneNumberUtils.isGlobalPhoneNumber((number))) {
        throw new FormatException();
    }
    String smsPattern = "sms:" + number + "?body=" + message;
    //String externalType = "nfclab.com:smsService";
    return createUriMessage(smsPattern, NfcPayloadHeader.CUSTOM_SCHEME);
}
 

private static String parseRecipient(String recipient) throws RecipientFormattingException {
  recipient = recipient.trim();

  if ((recipient.indexOf('<') != -1) && (recipient.indexOf('>') != -1))
    return parseBracketedNumber(recipient);

  if (PhoneNumberUtils.isWellFormedSmsAddress(recipient))
    return recipient;

  throw new RecipientFormattingException("Recipient: " + recipient + " is badly formatted.");
}
 

private boolean isValidAddress(String number, boolean isMms) {
    /*if (isMms) {
        return MessageUtils.isValidMmsAddress(number);
    } else {*/
        // TODO: PhoneNumberUtils.isWellFormedSmsAddress() only check if the number is a valid
        // GSM SMS address. If the address contains a dialable char, it considers it a well
        // formed SMS addr. CDMA doesn't work that way and has a different parser for SMS
        // address (see CdmaSmsAddress.parse(String address)). We should definitely fix this!!!
    return PhoneNumberUtils.isWellFormedSmsAddress(number);
}
 

@Override
public CharSequence format(CharSequence value, int index) {
  value = PhoneNumberUtils.formatNumber(value.toString());
  Map<String,Set<String>> metadata =
      metadataForIndex == null || metadataForIndex.size() <= index ? null : metadataForIndex.get(index);
  value = formatMetadata(value, metadata);
  return value;
}
 

@Override
public CharSequence getDisplayContents() {
  SMSParsedResult smsResult = (SMSParsedResult) getResult();
  String[] rawNumbers = smsResult.getNumbers();
  String[] formattedNumbers = new String[rawNumbers.length];
  for (int i = 0; i < rawNumbers.length; i++) {
    formattedNumbers[i] = PhoneNumberUtils.formatNumber(rawNumbers[i]);
  }
  StringBuilder contents = new StringBuilder(50);
  ParsedResult.maybeAppend(formattedNumbers, contents);
  ParsedResult.maybeAppend(smsResult.getSubject(), contents);
  ParsedResult.maybeAppend(smsResult.getBody(), contents);
  return contents.toString();
}
 

private boolean hasSeparator(final CharSequence s, final int start, final int count) {
    for (int i = start; i < start + count; i++) {
        char c = s.charAt(i);
        if (!PhoneNumberUtils.isNonSeparator(c)) {
            return true;
        }
    }
    return false;
}