| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License |
| */ |
| |
| package com.android.dialer.phonenumberutil; |
| |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.Trace; |
| import android.provider.CallLog; |
| import android.support.annotation.NonNull; |
| import android.support.annotation.Nullable; |
| import android.telecom.PhoneAccountHandle; |
| import android.telephony.PhoneNumberUtils; |
| import android.telephony.SubscriptionInfo; |
| import android.telephony.TelephonyManager; |
| import android.text.BidiFormatter; |
| import android.text.TextDirectionHeuristics; |
| import android.text.TextUtils; |
| import com.android.dialer.common.Assert; |
| import com.android.dialer.common.LogUtil; |
| import com.android.dialer.compat.telephony.TelephonyManagerCompat; |
| import com.android.dialer.i18n.LocaleUtils; |
| import com.android.dialer.oem.MotorolaUtils; |
| import com.android.dialer.oem.PhoneNumberUtilsAccessor; |
| import com.android.dialer.phonenumbergeoutil.PhoneNumberGeoUtilComponent; |
| import com.android.dialer.telecom.TelecomUtil; |
| import com.google.common.base.Optional; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| public class PhoneNumberHelper { |
| |
| private static final Set<String> LEGACY_UNKNOWN_NUMBERS = |
| new HashSet<>(Arrays.asList("-1", "-2", "-3")); |
| |
| /** Returns true if it is possible to place a call to the given number. */ |
| public static boolean canPlaceCallsTo(CharSequence number, int presentation) { |
| return presentation == CallLog.Calls.PRESENTATION_ALLOWED |
| && !TextUtils.isEmpty(number) |
| && !isLegacyUnknownNumbers(number); |
| } |
| |
| /** |
| * Move the given cursor to a position where the number it points to matches the number in a |
| * contact lookup URI. |
| * |
| * <p>We assume the cursor is one returned by the Contacts Provider when the URI asks for a |
| * specific number. This method's behavior is undefined when the cursor doesn't meet the |
| * assumption. |
| * |
| * <p>When determining whether two phone numbers are identical enough for caller ID purposes, the |
| * Contacts Provider ignores special characters such as '#'. This makes it possible for the cursor |
| * returned by the Contacts Provider to have multiple rows even when the URI asks for a specific |
| * number. |
| * |
| * <p>For example, suppose the user has two contacts whose numbers are "#123" and "123", |
| * respectively. When the URI asks for number "123", both numbers will be returned. Therefore, the |
| * following strategy is employed to find a match. |
| * |
| * <p>In the following description, we use E to denote a number the cursor points to (an existing |
| * contact number), and L to denote the number in the contact lookup URI. |
| * |
| * <p>If neither E nor L contains special characters, return true to indicate a match is found. |
| * |
| * <p>If either E or L contains special characters, return true when the raw numbers of E and L |
| * are the same. Otherwise, move the cursor to its next position and start over. |
| * |
| * <p>Return false in all other circumstances to indicate that no match can be found. |
| * |
| * <p>When no match can be found, the cursor is after the last result when the method returns. |
| * |
| * @param cursor A cursor returned by the Contacts Provider. |
| * @param columnIndexForNumber The index of the column where phone numbers are stored. It is the |
| * caller's responsibility to pass the correct column index. |
| * @param contactLookupUri A URI used to retrieve a contact via the Contacts Provider. It is the |
| * caller's responsibility to ensure the URI is one that asks for a specific phone number. |
| * @return true if a match can be found. |
| */ |
| public static boolean updateCursorToMatchContactLookupUri( |
| @Nullable Cursor cursor, int columnIndexForNumber, @Nullable Uri contactLookupUri) { |
| if (cursor == null || contactLookupUri == null) { |
| return false; |
| } |
| |
| if (!cursor.moveToFirst()) { |
| return false; |
| } |
| |
| Assert.checkArgument( |
| 0 <= columnIndexForNumber && columnIndexForNumber < cursor.getColumnCount()); |
| |
| String lookupNumber = contactLookupUri.getLastPathSegment(); |
| if (TextUtils.isEmpty(lookupNumber)) { |
| return false; |
| } |
| |
| boolean lookupNumberHasSpecialChars = numberHasSpecialChars(lookupNumber); |
| |
| do { |
| String existingContactNumber = cursor.getString(columnIndexForNumber); |
| boolean existingContactNumberHasSpecialChars = numberHasSpecialChars(existingContactNumber); |
| |
| if ((!lookupNumberHasSpecialChars && !existingContactNumberHasSpecialChars) |
| || sameRawNumbers(existingContactNumber, lookupNumber)) { |
| return true; |
| } |
| |
| } while (cursor.moveToNext()); |
| |
| return false; |
| } |
| |
| /** Returns true if the input phone number contains special characters. */ |
| public static boolean numberHasSpecialChars(String number) { |
| return !TextUtils.isEmpty(number) && number.contains("#"); |
| } |
| |
| /** Returns true if the raw numbers of the two input phone numbers are the same. */ |
| public static boolean sameRawNumbers(String number1, String number2) { |
| String rawNumber1 = |
| PhoneNumberUtils.stripSeparators(PhoneNumberUtils.convertKeypadLettersToDigits(number1)); |
| String rawNumber2 = |
| PhoneNumberUtils.stripSeparators(PhoneNumberUtils.convertKeypadLettersToDigits(number2)); |
| |
| return rawNumber1.equals(rawNumber2); |
| } |
| |
| /** |
| * An enhanced version of {@link PhoneNumberUtils#isLocalEmergencyNumber(Context, String)}. |
| * |
| * <p>This methods supports checking the number for all SIMs. |
| * |
| * @param context the context which the number should be checked against |
| * @param number the number to tbe checked |
| * @return true if the specified number is an emergency number for any SIM in the device. |
| */ |
| @SuppressWarnings("Guava") |
| public static boolean isLocalEmergencyNumber(Context context, String number) { |
| List<PhoneAccountHandle> phoneAccountHandles = |
| TelecomUtil.getSubscriptionPhoneAccounts(context); |
| |
| // If the number of phone accounts with a subscription is no greater than 1, only one SIM is |
| // installed in the device. We hand over the job to PhoneNumberUtils#isLocalEmergencyNumber. |
| if (phoneAccountHandles.size() <= 1) { |
| return PhoneNumberUtils.isLocalEmergencyNumber(context, number); |
| } |
| |
| for (PhoneAccountHandle phoneAccountHandle : phoneAccountHandles) { |
| Optional<SubscriptionInfo> subscriptionInfo = |
| TelecomUtil.getSubscriptionInfo(context, phoneAccountHandle); |
| if (subscriptionInfo.isPresent() |
| && PhoneNumberUtilsAccessor.isLocalEmergencyNumber( |
| context, subscriptionInfo.get().getSubscriptionId(), number)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns true if the given number is the number of the configured voicemail. To be able to |
| * mock-out this, it is not a static method. |
| */ |
| public static boolean isVoicemailNumber( |
| Context context, PhoneAccountHandle accountHandle, CharSequence number) { |
| if (TextUtils.isEmpty(number)) { |
| return false; |
| } |
| return TelecomUtil.isVoicemailNumber(context, accountHandle, number.toString()); |
| } |
| |
| /** |
| * Returns true if the given number is a SIP address. To be able to mock-out this, it is not a |
| * static method. |
| */ |
| public static boolean isSipNumber(CharSequence number) { |
| return number != null && isUriNumber(number.toString()); |
| } |
| |
| public static boolean isUnknownNumberThatCanBeLookedUp( |
| Context context, PhoneAccountHandle accountHandle, CharSequence number, int presentation) { |
| if (presentation == CallLog.Calls.PRESENTATION_UNKNOWN) { |
| return false; |
| } |
| if (presentation == CallLog.Calls.PRESENTATION_RESTRICTED) { |
| return false; |
| } |
| if (presentation == CallLog.Calls.PRESENTATION_UNAVAILABLE) { |
| return false; |
| } |
| if (presentation == CallLog.Calls.PRESENTATION_PAYPHONE) { |
| return false; |
| } |
| if (TextUtils.isEmpty(number)) { |
| return false; |
| } |
| if (isVoicemailNumber(context, accountHandle, number)) { |
| return false; |
| } |
| if (isLegacyUnknownNumbers(number)) { |
| return false; |
| } |
| return true; |
| } |
| |
| public static boolean isLegacyUnknownNumbers(CharSequence number) { |
| return number != null && LEGACY_UNKNOWN_NUMBERS.contains(number.toString()); |
| } |
| |
| /** |
| * @param countryIso Country ISO used if there is no country code in the number, may be null |
| * otherwise. |
| * @return a geographical description string for the specified number. |
| */ |
| public static String getGeoDescription( |
| Context context, String number, @Nullable String countryIso) { |
| return PhoneNumberGeoUtilComponent.get(context) |
| .getPhoneNumberGeoUtil() |
| .getGeoDescription(context, number, countryIso); |
| } |
| |
| /** |
| * @param phoneAccountHandle {@code PhonAccountHandle} used to get current network country ISO. |
| * May be null if no account is in use or selected, in which case default account will be |
| * used. |
| * @return The ISO 3166-1 two letters country code of the country the user is in based on the |
| * network location. If the network location does not exist, fall back to the locale setting. |
| */ |
| public static String getCurrentCountryIso( |
| Context context, @Nullable PhoneAccountHandle phoneAccountHandle) { |
| Trace.beginSection("PhoneNumberHelper.getCurrentCountryIso"); |
| // Without framework function calls, this seems to be the most accurate location service |
| // we can rely on. |
| String countryIso = |
| TelephonyManagerCompat.getNetworkCountryIsoForPhoneAccountHandle( |
| context, phoneAccountHandle); |
| if (TextUtils.isEmpty(countryIso)) { |
| countryIso = LocaleUtils.getLocale(context).getCountry(); |
| LogUtil.i( |
| "PhoneNumberHelper.getCurrentCountryIso", |
| "No CountryDetector; falling back to countryIso based on locale: " + countryIso); |
| } |
| countryIso = countryIso.toUpperCase(); |
| Trace.endSection(); |
| |
| return countryIso; |
| } |
| |
| /** |
| * An enhanced version of {@link PhoneNumberUtils#formatNumber(String, String, String)}. |
| * |
| * <p>The {@link Context} parameter allows us to tweak formatting according to device properties. |
| * |
| * <p>Returns the formatted phone number (e.g, 1-123-456-7890) or the original number if |
| * formatting fails or is intentionally ignored. |
| */ |
| public static String formatNumber( |
| Context context, @Nullable String number, @Nullable String numberE164, String countryIso) { |
| // The number can be null e.g. schema is voicemail and uri content is empty. |
| if (number == null) { |
| return null; |
| } |
| |
| if (MotorolaUtils.shouldDisablePhoneNumberFormatting(context)) { |
| return number; |
| } |
| |
| String formattedNumber = PhoneNumberUtils.formatNumber(number, numberE164, countryIso); |
| return formattedNumber != null ? formattedNumber : number; |
| } |
| |
| /** @see #formatNumber(Context, String, String, String). */ |
| public static String formatNumber(Context context, @Nullable String number, String countryIso) { |
| return formatNumber(context, number, /* numberE164 = */ null, countryIso); |
| } |
| |
| @Nullable |
| public static CharSequence formatNumberForDisplay( |
| Context context, @Nullable String number, @NonNull String countryIso) { |
| if (number == null) { |
| return null; |
| } |
| |
| return PhoneNumberUtils.createTtsSpannable( |
| BidiFormatter.getInstance() |
| .unicodeWrap(formatNumber(context, number, countryIso), TextDirectionHeuristics.LTR)); |
| } |
| |
| /** |
| * Determines if the specified number is actually a URI (i.e. a SIP address) rather than a regular |
| * PSTN phone number, based on whether or not the number contains an "@" character. |
| * |
| * @param number Phone number |
| * @return true if number contains @ |
| * <p>TODO: Remove if PhoneNumberUtils.isUriNumber(String number) is made public. |
| */ |
| public static boolean isUriNumber(String number) { |
| // Note we allow either "@" or "%40" to indicate a URI, in case |
| // the passed-in string is URI-escaped. (Neither "@" nor "%40" |
| // will ever be found in a legal PSTN number.) |
| return number != null && (number.contains("@") || number.contains("%40")); |
| } |
| |
| /** |
| * @param number SIP address of the form "username@domainname" (or the URI-escaped equivalent |
| * "username%40domainname") |
| * <p>TODO: Remove if PhoneNumberUtils.getUsernameFromUriNumber(String number) is made public. |
| * @return the "username" part of the specified SIP address, i.e. the part before the "@" |
| * character (or "%40"). |
| */ |
| public static String getUsernameFromUriNumber(String number) { |
| // The delimiter between username and domain name can be |
| // either "@" or "%40" (the URI-escaped equivalent.) |
| int delimiterIndex = number.indexOf('@'); |
| if (delimiterIndex < 0) { |
| delimiterIndex = number.indexOf("%40"); |
| } |
| if (delimiterIndex < 0) { |
| LogUtil.i( |
| "PhoneNumberHelper.getUsernameFromUriNumber", |
| "getUsernameFromUriNumber: no delimiter found in SIP address: " |
| + LogUtil.sanitizePii(number)); |
| return number; |
| } |
| return number.substring(0, delimiterIndex); |
| } |
| |
| private static boolean isVerizon(Context context) { |
| // Verizon MCC/MNC codes copied from com/android/voicemailomtp/res/xml/vvm_config.xml. |
| // TODO(sail): Need a better way to do per carrier and per OEM configurations. |
| switch (context.getSystemService(TelephonyManager.class).getSimOperator()) { |
| case "310004": |
| case "310010": |
| case "310012": |
| case "310013": |
| case "310590": |
| case "310890": |
| case "310910": |
| case "311110": |
| case "311270": |
| case "311271": |
| case "311272": |
| case "311273": |
| case "311274": |
| case "311275": |
| case "311276": |
| case "311277": |
| case "311278": |
| case "311279": |
| case "311280": |
| case "311281": |
| case "311282": |
| case "311283": |
| case "311284": |
| case "311285": |
| case "311286": |
| case "311287": |
| case "311288": |
| case "311289": |
| case "311390": |
| case "311480": |
| case "311481": |
| case "311482": |
| case "311483": |
| case "311484": |
| case "311485": |
| case "311486": |
| case "311487": |
| case "311488": |
| case "311489": |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Gets the label to display for a phone call where the presentation is set as |
| * PRESENTATION_RESTRICTED. For Verizon we want this to be displayed as "Restricted". For all |
| * other carriers we want this to be be displayed as "Private number". |
| */ |
| public static String getDisplayNameForRestrictedNumber(Context context) { |
| if (isVerizon(context)) { |
| return context.getString(R.string.private_num_verizon); |
| } else { |
| return context.getString(R.string.private_num_non_verizon); |
| } |
| } |
| } |
