java类android.telephony.PhoneNumberUtils的实例源码

@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;
}

/**
 * 调起系统打电话功能
 */
public void doCallPhoneTo(String phoneNumber) {
  if (PhoneNumberUtils.isGlobalPhoneNumber(phoneNumber)) {
    if (mayCallPhone()) {
      Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + phoneNumber));
      if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE)
          != PackageManager.PERMISSION_GRANTED) {
        // TODO: Consider calling
        //    ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
        //                                          int[] grantResults)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.
        return;
      }
      startActivity(intent);
    }
  }
}

/**
 * For a given address type, extract the recipients from the headers.
 *
 * @param addressType can be PduHeaders.FROM or PduHeaders.TO
 * @param recipients a HashSet that is loaded with the recipients from the FROM or TO headers
 * @param addressMap a HashMap of the addresses from the ADDRESS_FIELDS header
 * @param excludeMyNumber if true, the number of this phone will be excluded from recipients
 */
private void loadRecipients(int addressType, HashSet<String> recipients,
        HashMap<Integer, EncodedStringValue[]> addressMap, boolean excludeMyNumber) {
    EncodedStringValue[] array = addressMap.get(addressType);
    if (array == null) {
        return;
    }
    // If the TO recipients is only a single address, then we can skip loadRecipients when
    // we're excluding our own number because we know that address is our own.
    if (excludeMyNumber && array.length == 1) {
        return;
    }
    String myNumber = excludeMyNumber ? mTelephonyManager.getLine1Number() : null;
    for (EncodedStringValue v : array) {
        if (v != null) {
            String number = v.getString();
            if ((myNumber == null || !PhoneNumberUtils.compare(number, myNumber)) &&
                    !recipients.contains(number)) {
                // Only add numbers which aren't my own number.
                recipients.add(number);
            }
        }
    }
}

/**
 * Formats address to normal form like +[country][prefix][localnumber]
 * @param address
 * @return
 */
private static String getNormalizedAddress(String address) {
    String number=stripAddress(address);
    try {
        //parse number using current locale rules
        Phonenumber.PhoneNumber phonenumber=phoneNumberUtil.parseAndKeepRawInput(number, Locale.getDefault().getCountry());
        //Phonenumber.PhoneNumber phonenumber = phoneNumberUtil.parse(number, Locale.getDefault().getCountry());
        //format to international form
        //phoneNumberUtil
        number=phoneNumberUtil.format(phonenumber, PhoneNumberUtil.PhoneNumberFormat.INTERNATIONAL);
        //stripe any formatting symbols
        return stripAddress(number);
    }
    catch(Exception ex) {
        //in case of fail use default formatting rules
        number=PhoneNumberUtils.formatNumber(number);
        //stripe any formatting symbols
        return stripAddress(number);
    }
}

private void enterState(int state) {
    switch(state) {
        case LOADING:
            mActionBar.setTitle(R.string.bt_card_details);
            mViewSwitcher.setDisplayedChild(0);
            break;
        case CARD_ENTRY:
            mActionBar.setTitle(R.string.bt_card_details);
            mAddCardView.setVisibility(VISIBLE);
            break;
        case DETAILS_ENTRY:
            mActionBar.setTitle(R.string.bt_card_details);
            mEditCardView.setCardNumber(mAddCardView.getCardForm().getCardNumber());
            mEditCardView.useUnionPay(this, mUnionPayCard, mUnionPayDebitCard);
            mEditCardView.setVisibility(VISIBLE);
            break;
        case ENROLLMENT_ENTRY:
            mActionBar.setTitle(R.string.bt_confirm_enrollment);
            mEnrollmentCardView.setPhoneNumber(
                    PhoneNumberUtils.formatNumber(mEditCardView.getCardForm().getCountryCode() +
                            mEditCardView.getCardForm().getMobileNumber()));
            mEnrollmentCardView.setVisibility(VISIBLE);
            break;
    }
}

private void retrieveFiles(){
    RealmResults<CallHistory> result = myRealm.where(CallHistory.class)
            .isNotNull(CallHistory.kCOL_FILE_PATH)
            .findAllSorted(CallHistory.kCOL_DATE_TIME, Sort.DESCENDING);

    arrayFilePaths.clear();
    arrayCalls.clear();

    if (result.size() > 0) {
        for(CallHistory c:result) {
            arrayFilePaths.add(PhoneNumberUtils.formatNumber(c.phoneNumber) + "   " + getDate(c.dateTime, "d/MM/yyyy HH:mm:ss"));
            arrayCalls.add(c);
        }
    }

    if (adapter != null) {
        adapter.notifyDataSetChanged();

        if (arrayCalls.size() > 0 && !hasPlayerSetup){
            AudioWife.getInstance().init(CallReceiverActivity.this, Uri.parse(arrayCalls.get(0).getFilePath())).useDefaultUi(llMediaPlayer, getLayoutInflater());
            hasPlayerSetup = true;
        }
    }
}

/**
 * This function combines selected country code from CCP and carrier number from @param editTextCarrierNumber
 * This will return formatted number.
 *
 * @return Full number is countryCode + carrierNumber i.e countryCode= 91 and carrier number= 8866667722, this will return "918866667722"
 */
public String getFormattedFullNumber() {
    String formattedFullNumber;
    Phonenumber.PhoneNumber phoneNumber;
    if (editText_registeredCarrierNumber != null) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            formattedFullNumber = PhoneNumberUtils.formatNumber(getFullNumberWithPlus(), getSelectedCountryCode());
        } else {
            formattedFullNumber = PhoneNumberUtils.formatNumber(getFullNumberWithPlus());
        }
    } else {
        formattedFullNumber = getSelectedCountry().getPhoneCode();
        Log.w(TAG, "EditText for carrier number is not registered. Register it using registerCarrierNumberEditText() before getFullNumber() or setFullNumber().");
    }
    return formattedFullNumber;
}

@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() };
}

@Nullable
private static ListIterator<User> getUserPosition(Context context, User user) {
    ArrayList<User> users = getUsers(context);

    if (users != null) {
        ListIterator<User> iterator;
        iterator = users.listIterator();
        while (iterator.hasNext()) {
            if (PhoneNumberUtils.compare(iterator.next().number, user.number)) {
                return iterator;
            }
        }
    }

    return null;
}

@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 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 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);
}

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

  final String networkNumber = PhoneNumberUtils.extractNetworkPortion(number);

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

  return PhoneNumberUtils.isWellFormedSmsAddress(number);
}

protected long insertMessageOutbox(long threadId, OutgoingTextMessage message,
                                   long type, boolean forceSms, long date)
{
  if      (message.isKeyExchange())   type |= Types.KEY_EXCHANGE_BIT;
  else if (message.isSecureMessage()) type |= (Types.SECURE_MESSAGE_BIT | Types.PUSH_MESSAGE_BIT);
  else if (message.isEndSession())    type |= Types.END_SESSION_BIT;
  if      (forceSms)                  type |= Types.MESSAGE_FORCE_SMS_BIT;

  String address = message.getRecipients().getPrimaryRecipient().getNumber();

  ContentValues contentValues = new ContentValues(6);
  contentValues.put(ADDRESS, PhoneNumberUtils.formatNumber(address));
  contentValues.put(THREAD_ID, threadId);
  contentValues.put(BODY, message.getMessageBody());
  contentValues.put(DATE_RECEIVED, System.currentTimeMillis());
  contentValues.put(DATE_SENT, date);
  contentValues.put(READ, 1);
  contentValues.put(TYPE, type);
  contentValues.put(SUBSCRIPTION_ID, message.getSubscriptionId());
  contentValues.put(EXPIRES_IN, message.getExpiresIn());

  try {
    contentValues.put(RECEIPT_COUNT, earlyReceiptCache.remove(date, canonicalizeNumber(context, address)));
  } catch (InvalidNumberException e) {
    Log.w(TAG, e);
  }

  SQLiteDatabase db        = databaseHelper.getWritableDatabase();
  long           messageId = db.insert(TABLE_NAME, ADDRESS, contentValues);

  DatabaseFactory.getThreadDatabase(context).update(threadId, true);
  DatabaseFactory.getThreadDatabase(context).setLastSeen(threadId);
  notifyConversationListeners(threadId);
  jobManager.add(new TrimThreadJob(context, threadId));

  return messageId;
}

private static String parseBracketedNumber(String recipient) throws RecipientFormattingException {
  int begin    = recipient.indexOf('<');
  int end      = recipient.indexOf('>');
  String value = recipient.substring(begin + 1, end);

  if (PhoneNumberUtils.isWellFormedSmsAddress(value))
    return value;
  else
    throw new RecipientFormattingException("Bracketed value: " + value + " is not valid.");
}

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.");
}

@Override
 public final CharSequence convertToString(Cursor cursor) {
    CharSequence number = ContactsWrapper.getInstance().transformToSipUri(mContext, cursor);
     boolean isExternalPhone = ContactsWrapper.getInstance().isExternalPhoneNumber(mContext, cursor);
    if(!TextUtils.isEmpty(number) && isExternalPhone) {
        String stripNbr = PhoneNumberUtils.stripSeparators(number.toString());
return Filter.rewritePhoneNumber(mContext, currentAccId, stripNbr);
    }
    return number;
 }

private void applyRewritingInfo() {
    // Rewrite information textView update
    String newText = digits.getText().toString();
    if(accountChooserFilterItem != null && accountChooserFilterItem.isChecked()) {
        if(isDigit) {
            newText = PhoneNumberUtils.stripSeparators(newText);
        }
        rewriteTextInfo.setText(rewriteNumber(newText));
    }else {
        rewriteTextInfo.setText("");
    }
}

private boolean equalNumbers(String number1, String number2) {
//        if (PhoneNumberUtils.isUriNumber(number1) || PhoneNumberUtils.isUriNumber(number2)) {
//            return compareSipAddresses(number1, number2);
//        } else {
        // Optim -- first try to compare very simply
        if(number1 != null && number2 != null && number1.equals(number2)) {
            return true;
        }
        return PhoneNumberUtils.compare(number1, number2);
//        }
    }

@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) {
    int invalidFieldsCount = 0;
    int completionStatus = COMPLETE;

    if (!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;
}

public static String buildNameAndNumber(String name, String number) {
    // Format like this: Mike Cleron <(650) 555-1234>
    //                   Erick Tseng <(650) 555-1212>
    //                   (408) 555-1289

    if (!TextUtils.isEmpty(name) &&
            !name.equals(number)) {
        return name + " <" + PhoneNumberUtils.formatNumber(number) + ">";
    } else {
        return PhoneNumberUtils.formatNumber(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();
}

@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 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();
}

/**
 * 调起系统发短信功能
 */
public void doSendSMSTo(String phoneNumber, String message) {
  if (PhoneNumberUtils.isGlobalPhoneNumber(phoneNumber)) {
    Intent intent = new Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:" + phoneNumber));
    intent.putExtra("sms_body", message);
    startActivity(intent);
  }
}

public static boolean isValidPhone(String target) {
    if (target.equals("")) {
        return false;
    }
    else if(target.length()!=10){
        return false;
    }
    else {
        return PhoneNumberUtils.isGlobalPhoneNumber(target);
    }
}

/**
 * Uses an implicit intent to make the phone call.
 * Before calling, checks to see if permission is granted.
 *
 * @param view View that was clicked.
 */
public void callNumber(View view) {
    String normalizedPhoneNumber;
    // Find the editText_main view and assign it to editText.
    EditText editText = (EditText) findViewById(R.id.editText_main);
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
        Log.d(TAG, "Running version earlier than Lollipop. Can't normalize number.");
        normalizedPhoneNumber = editText.getText().toString();
    } else {
        normalizedPhoneNumber =
                PhoneNumberUtils.normalizeNumber(editText.getText().toString());
    }
    // Use format with "tel:" and phone number to create phoneNumber.
    String phoneNumber = String.format("tel: %s", normalizedPhoneNumber);
    // Log the concatenated phone number for dialing.
    Log.d(TAG, getString(R.string.dial_number) + phoneNumber);
    Toast.makeText(this, getString(R.string.dial_number) + phoneNumber,
            Toast.LENGTH_LONG).show();
    // Create the intent.
    Intent callIntent = new Intent(Intent.ACTION_CALL);
    // Set the data for the intent as the phone number.
    callIntent.setData(Uri.parse(phoneNumber));
    // If package resolves to an app, check for phone permission,
    // and send intent.
    if (callIntent.resolveActivity(getPackageManager()) != null) {
        checkForPhonePermission();
        startActivity(callIntent);
    } else {
        Log.e(TAG, "Can't resolve app for ACTION_CALL Intent.");
    }
}

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);
}