| /* |
| * Copyright (C) 2014 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.internal.telephony; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| |
| import android.content.Context; |
| import android.os.SystemProperties; |
| import android.os.Build; |
| import android.text.TextUtils; |
| import android.content.ContentResolver; |
| import android.database.Cursor; |
| import android.database.SQLException; |
| import android.telephony.PhoneNumberUtils; |
| import android.telephony.TelephonyManager; |
| import android.telephony.Rlog; |
| import com.android.internal.telephony.HbpcdLookup.MccIdd; |
| import com.android.internal.telephony.HbpcdLookup.MccLookup; |
| |
| |
| /** |
| * This class implements handle the MO SMS target address before sending. |
| * This is special for VZW requirement. Follow the specificaitons of assisted dialing |
| * of MO SMS while traveling on VZW CDMA, international CDMA or GSM markets. |
| * {@hide} |
| */ |
| public class SmsNumberUtils { |
| private static final String TAG = "SmsNumberUtils"; |
| private static final boolean DBG = Build.IS_DEBUGGABLE; |
| |
| private static final String PLUS_SIGN = "+"; |
| |
| private static final int NANP_SHORT_LENGTH = 7; |
| private static final int NANP_MEDIUM_LENGTH = 10; |
| private static final int NANP_LONG_LENGTH = 11; |
| |
| private static final int NANP_CC = 1; |
| private static final String NANP_NDD = "1"; |
| private static final String NANP_IDD = "011"; |
| |
| private static final int MIN_COUNTRY_AREA_LOCAL_LENGTH = 10; |
| |
| private static final int GSM_UMTS_NETWORK = 0; |
| private static final int CDMA_HOME_NETWORK = 1; |
| private static final int CDMA_ROAMING_NETWORK = 2; |
| |
| private static final int NP_NONE = 0; |
| private static final int NP_NANP_BEGIN = 1; |
| |
| /* <Phone Number>, <NXX>-<XXXX> N[2-9] */ |
| private static final int NP_NANP_LOCAL = NP_NANP_BEGIN; |
| |
| /* <Area_code>-<Phone Number>, <NXX>-<NXX>-<XXXX> N[2-9] */ |
| private static final int NP_NANP_AREA_LOCAL = NP_NANP_BEGIN + 1; |
| |
| /* <1>-<Area_code>-<Phone Number>, 1-<NXX>-<NXX>-<XXXX> N[2-9] */ |
| private static final int NP_NANP_NDD_AREA_LOCAL = NP_NANP_BEGIN + 2; |
| |
| /* <+><U.S.Country_code><Area_code><Phone Number>, +1-<NXX>-<NXX>-<XXXX> N[2-9] */ |
| private static final int NP_NANP_NBPCD_CC_AREA_LOCAL = NP_NANP_BEGIN + 3; |
| |
| /* <Local_IDD><Country_code><Area_code><Phone Number>, 001-1-<NXX>-<NXX>-<XXXX> N[2-9] */ |
| private static final int NP_NANP_LOCALIDD_CC_AREA_LOCAL = NP_NANP_BEGIN + 4; |
| |
| /* <+><Home_IDD><Country_code><Area_code><Phone Number>, +011-1-<NXX>-<NXX>-<XXXX> N[2-9] */ |
| private static final int NP_NANP_NBPCD_HOMEIDD_CC_AREA_LOCAL = NP_NANP_BEGIN + 5; |
| |
| private static final int NP_INTERNATIONAL_BEGIN = 100; |
| /* <+>-<Home_IDD>-<Country_code>-<Area_code>-<Phone Number>, +011-86-25-86281234 */ |
| private static final int NP_NBPCD_HOMEIDD_CC_AREA_LOCAL = NP_INTERNATIONAL_BEGIN; |
| |
| /* <Home_IDD>-<Country_code>-<Area_code>-<Phone Number>, 011-86-25-86281234 */ |
| private static final int NP_HOMEIDD_CC_AREA_LOCAL = NP_INTERNATIONAL_BEGIN + 1; |
| |
| /* <NBPCD>-<Country_code>-<Area_code>-<Phone Number>, +1-86-25-86281234 */ |
| private static final int NP_NBPCD_CC_AREA_LOCAL = NP_INTERNATIONAL_BEGIN + 2; |
| |
| /* <Local_IDD>-<Country_code>-<Area_code>-<Phone Number>, 00-86-25-86281234 */ |
| private static final int NP_LOCALIDD_CC_AREA_LOCAL = NP_INTERNATIONAL_BEGIN + 3; |
| |
| /* <Country_code>-<Area_code>-<Phone Number>, 86-25-86281234*/ |
| private static final int NP_CC_AREA_LOCAL = NP_INTERNATIONAL_BEGIN + 4; |
| |
| private static int[] ALL_COUNTRY_CODES = null; |
| private static int MAX_COUNTRY_CODES_LENGTH; |
| private static HashMap<String, ArrayList<String>> IDDS_MAPS = |
| new HashMap<String, ArrayList<String>>(); |
| |
| private static class NumberEntry { |
| public String number; |
| public String IDD; |
| public int countryCode; |
| public NumberEntry(String number) { |
| this.number = number; |
| } |
| } |
| |
| /* Breaks the given number down and formats it according to the rules |
| * for different number plans and differnt network. |
| * |
| * @param number destionation number which need to be format |
| * @param activeMcc current network's mcc |
| * @param networkType current network type |
| * |
| * @return the number after fromatting. |
| */ |
| private static String formatNumber(Context context, String number, |
| String activeMcc, |
| int networkType) { |
| if (number == null ) { |
| throw new IllegalArgumentException("number is null"); |
| } |
| |
| if (activeMcc == null || activeMcc.trim().length() == 0) { |
| throw new IllegalArgumentException("activeMcc is null or empty!"); |
| } |
| |
| String networkPortionNumber = PhoneNumberUtils.extractNetworkPortion(number); |
| if (networkPortionNumber == null || networkPortionNumber.length() == 0) { |
| throw new IllegalArgumentException("Number is invalid!"); |
| } |
| |
| NumberEntry numberEntry = new NumberEntry(networkPortionNumber); |
| ArrayList<String> allIDDs = getAllIDDs(context, activeMcc); |
| |
| // First check whether the number is a NANP number. |
| int nanpState = checkNANP(numberEntry, allIDDs); |
| if (DBG) Rlog.d(TAG, "NANP type: " + getNumberPlanType(nanpState)); |
| |
| if ((nanpState == NP_NANP_LOCAL) |
| || (nanpState == NP_NANP_AREA_LOCAL) |
| || (nanpState == NP_NANP_NDD_AREA_LOCAL)) { |
| return networkPortionNumber; |
| } else if (nanpState == NP_NANP_NBPCD_CC_AREA_LOCAL) { |
| if (networkType == CDMA_HOME_NETWORK |
| || networkType == CDMA_ROAMING_NETWORK) { |
| // Remove "+" |
| return networkPortionNumber.substring(1); |
| } else { |
| return networkPortionNumber; |
| } |
| } else if (nanpState == NP_NANP_LOCALIDD_CC_AREA_LOCAL) { |
| if (networkType == CDMA_HOME_NETWORK) { |
| return networkPortionNumber; |
| } else if (networkType == GSM_UMTS_NETWORK) { |
| // Remove the local IDD and replace with "+" |
| int iddLength = numberEntry.IDD != null ? numberEntry.IDD.length() : 0; |
| return PLUS_SIGN + networkPortionNumber.substring(iddLength); |
| } else if (networkType == CDMA_ROAMING_NETWORK) { |
| // Remove the local IDD |
| int iddLength = numberEntry.IDD != null ? numberEntry.IDD.length() : 0; |
| return networkPortionNumber.substring(iddLength); |
| } |
| } |
| |
| int internationalState = checkInternationalNumberPlan(context, numberEntry, allIDDs, |
| NANP_IDD); |
| if (DBG) Rlog.d(TAG, "International type: " + getNumberPlanType(internationalState)); |
| String returnNumber = null; |
| |
| switch (internationalState) { |
| case NP_NBPCD_HOMEIDD_CC_AREA_LOCAL: |
| if (networkType == GSM_UMTS_NETWORK) { |
| // Remove "+" |
| returnNumber = networkPortionNumber.substring(1); |
| } |
| break; |
| |
| case NP_NBPCD_CC_AREA_LOCAL: |
| // Replace "+" with "011" |
| returnNumber = NANP_IDD + networkPortionNumber.substring(1); |
| break; |
| |
| case NP_LOCALIDD_CC_AREA_LOCAL: |
| if (networkType == GSM_UMTS_NETWORK || networkType == CDMA_ROAMING_NETWORK) { |
| int iddLength = numberEntry.IDD != null ? numberEntry.IDD.length() : 0; |
| // Replace <Local IDD> to <Home IDD>("011") |
| returnNumber = NANP_IDD + networkPortionNumber.substring(iddLength); |
| } |
| break; |
| |
| case NP_CC_AREA_LOCAL: |
| int countryCode = numberEntry.countryCode; |
| |
| if (!inExceptionListForNpCcAreaLocal(numberEntry) |
| && networkPortionNumber.length() >= 11 && countryCode != NANP_CC) { |
| // Add "011" |
| returnNumber = NANP_IDD + networkPortionNumber; |
| } |
| break; |
| |
| case NP_HOMEIDD_CC_AREA_LOCAL: |
| returnNumber = networkPortionNumber; |
| break; |
| |
| default: |
| // Replace "+" with 011 in CDMA network if the number's country |
| // code is not in the HbpcdLookup database. |
| if (networkPortionNumber.startsWith(PLUS_SIGN) |
| && (networkType == CDMA_HOME_NETWORK || networkType == CDMA_ROAMING_NETWORK)) { |
| if (networkPortionNumber.startsWith(PLUS_SIGN + NANP_IDD)) { |
| // Only remove "+" |
| returnNumber = networkPortionNumber.substring(1); |
| } else { |
| // Replace "+" with "011" |
| returnNumber = NANP_IDD + networkPortionNumber.substring(1); |
| } |
| } |
| } |
| |
| if (returnNumber == null) { |
| returnNumber = networkPortionNumber; |
| } |
| return returnNumber; |
| } |
| |
| /* Query International direct dialing from HbpcdLookup.db |
| * for specified country code |
| * |
| * @param mcc current network's country code |
| * |
| * @return the IDD array list. |
| */ |
| private static ArrayList<String> getAllIDDs(Context context, String mcc) { |
| ArrayList<String> allIDDs = IDDS_MAPS.get(mcc); |
| if (allIDDs != null) { |
| return allIDDs; |
| } else { |
| allIDDs = new ArrayList<String>(); |
| } |
| |
| String projection[] = {MccIdd.IDD, MccIdd.MCC}; |
| String where = null; |
| |
| // if mcc is null : return all rows |
| // if mcc is empty-string : return those rows whose mcc is emptry-string |
| String[] selectionArgs = null; |
| if (mcc != null) { |
| where = MccIdd.MCC + "=?"; |
| selectionArgs = new String[] {mcc}; |
| } |
| |
| Cursor cursor = null; |
| try { |
| cursor = context.getContentResolver().query(MccIdd.CONTENT_URI, projection, |
| where, selectionArgs, null); |
| if (cursor.getCount() > 0) { |
| while (cursor.moveToNext()) { |
| String idd = cursor.getString(0); |
| if (!allIDDs.contains(idd)) { |
| allIDDs.add(idd); |
| } |
| } |
| } |
| } catch (SQLException e) { |
| Rlog.e(TAG, "Can't access HbpcdLookup database", e); |
| } finally { |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| |
| IDDS_MAPS.put(mcc, allIDDs); |
| |
| if (DBG) Rlog.d(TAG, "MCC = " + mcc + ", all IDDs = " + allIDDs); |
| return allIDDs; |
| } |
| |
| |
| /* Verify if the the destination number is a NANP number |
| * |
| * @param numberEntry including number and IDD array |
| * @param allIDDs the IDD array list of the current network's country code |
| * |
| * @return the number plan type related NANP |
| */ |
| private static int checkNANP(NumberEntry numberEntry, ArrayList<String> allIDDs) { |
| boolean isNANP = false; |
| String number = numberEntry.number; |
| |
| if (number.length() == NANP_SHORT_LENGTH) { |
| // 7 digits - Seven digit phone numbers |
| char firstChar = number.charAt(0); |
| if (firstChar >= '2' && firstChar <= '9') { |
| isNANP = true; |
| for (int i=1; i< NANP_SHORT_LENGTH; i++ ) { |
| char c= number.charAt(i); |
| if (!PhoneNumberUtils.isISODigit(c)) { |
| isNANP = false; |
| break; |
| } |
| } |
| } |
| if (isNANP) { |
| return NP_NANP_LOCAL; |
| } |
| } else if (number.length() == NANP_MEDIUM_LENGTH) { |
| // 10 digits - Three digit area code followed by seven digit phone numbers/ |
| if (isNANP(number)) { |
| return NP_NANP_AREA_LOCAL; |
| } |
| } else if (number.length() == NANP_LONG_LENGTH) { |
| // 11 digits - One digit U.S. NDD(National Direct Dial) prefix '1', |
| // followed by three digit area code and seven digit phone numbers |
| if (isNANP(number)) { |
| return NP_NANP_NDD_AREA_LOCAL; |
| } |
| } else if (number.startsWith(PLUS_SIGN)) { |
| number = number.substring(1); |
| if (number.length() == NANP_LONG_LENGTH) { |
| // '+' and 11 digits -'+', followed by NANP CC prefix '1' followed by |
| // three digit area code and seven digit phone numbers |
| if (isNANP(number)) { |
| return NP_NANP_NBPCD_CC_AREA_LOCAL; |
| } |
| } else if (number.startsWith(NANP_IDD) && number.length() == NANP_LONG_LENGTH + 3) { |
| // '+' and 14 digits -'+', followed by NANP IDD "011" followed by NANP CC |
| // prefix '1' followed by three digit area code and seven digit phone numbers |
| number = number.substring(3); |
| if (isNANP(number)) { |
| return NP_NANP_NBPCD_HOMEIDD_CC_AREA_LOCAL; |
| } |
| } |
| } else { |
| // Check whether it's NP_NANP_LOCALIDD_CC_AREA_LOCAL |
| for (String idd : allIDDs) { |
| if (number.startsWith(idd)) { |
| String number2 = number.substring(idd.length()); |
| if(number2 !=null && number2.startsWith(String.valueOf(NANP_CC))){ |
| if (isNANP(number2)) { |
| numberEntry.IDD = idd; |
| return NP_NANP_LOCALIDD_CC_AREA_LOCAL; |
| } |
| } |
| } |
| } |
| } |
| |
| return NP_NONE; |
| } |
| |
| private static boolean isNANP(String number) { |
| if (number.length() == NANP_MEDIUM_LENGTH |
| || (number.length() == NANP_LONG_LENGTH && number.startsWith(NANP_NDD))) { |
| if (number.length() == NANP_LONG_LENGTH) { |
| number = number.substring(1); |
| } |
| return (PhoneNumberUtils.isNanp(number)); |
| } |
| return false; |
| } |
| |
| /* Verify if the the destination number is an internal number |
| * |
| * @param numberEntry including number and IDD array |
| * @param allIDDs the IDD array list of the current network's country code |
| * |
| * @return the number plan type related international number |
| */ |
| private static int checkInternationalNumberPlan(Context context, NumberEntry numberEntry, |
| ArrayList<String> allIDDs,String homeIDD) { |
| String number = numberEntry.number; |
| int countryCode = -1; |
| |
| if (number.startsWith(PLUS_SIGN)) { |
| // +xxxxxxxxxx |
| String numberNoNBPCD = number.substring(1); |
| if (numberNoNBPCD.startsWith(homeIDD)) { |
| // +011xxxxxxxx |
| String numberCountryAreaLocal = numberNoNBPCD.substring(homeIDD.length()); |
| if ((countryCode = getCountryCode(context, numberCountryAreaLocal)) > 0) { |
| numberEntry.countryCode = countryCode; |
| return NP_NBPCD_HOMEIDD_CC_AREA_LOCAL; |
| } |
| } else if ((countryCode = getCountryCode(context, numberNoNBPCD)) > 0) { |
| numberEntry.countryCode = countryCode; |
| return NP_NBPCD_CC_AREA_LOCAL; |
| } |
| |
| } else if (number.startsWith(homeIDD)) { |
| // 011xxxxxxxxx |
| String numberCountryAreaLocal = number.substring(homeIDD.length()); |
| if ((countryCode = getCountryCode(context, numberCountryAreaLocal)) > 0) { |
| numberEntry.countryCode = countryCode; |
| return NP_HOMEIDD_CC_AREA_LOCAL; |
| } |
| } else { |
| for (String exitCode : allIDDs) { |
| if (number.startsWith(exitCode)) { |
| String numberNoIDD = number.substring(exitCode.length()); |
| if ((countryCode = getCountryCode(context, numberNoIDD)) > 0) { |
| numberEntry.countryCode = countryCode; |
| numberEntry.IDD = exitCode; |
| return NP_LOCALIDD_CC_AREA_LOCAL; |
| } |
| } |
| } |
| |
| if (!number.startsWith("0") && (countryCode = getCountryCode(context, number)) > 0) { |
| numberEntry.countryCode = countryCode; |
| return NP_CC_AREA_LOCAL; |
| } |
| } |
| return NP_NONE; |
| } |
| |
| /** |
| * Returns the country code from the given number. |
| */ |
| private static int getCountryCode(Context context, String number) { |
| int countryCode = -1; |
| if (number.length() >= MIN_COUNTRY_AREA_LOCAL_LENGTH) { |
| // Check Country code |
| int[] allCCs = getAllCountryCodes(context); |
| if (allCCs == null) { |
| return countryCode; |
| } |
| |
| int[] ccArray = new int[MAX_COUNTRY_CODES_LENGTH]; |
| for (int i = 0; i < MAX_COUNTRY_CODES_LENGTH; i ++) { |
| ccArray[i] = Integer.valueOf(number.substring(0, i+1)); |
| } |
| |
| for (int i = 0; i < allCCs.length; i ++) { |
| int tempCC = allCCs[i]; |
| for (int j = 0; j < MAX_COUNTRY_CODES_LENGTH; j ++) { |
| if (tempCC == ccArray[j]) { |
| if (DBG) Rlog.d(TAG, "Country code = " + tempCC); |
| return tempCC; |
| } |
| } |
| } |
| } |
| |
| return countryCode; |
| } |
| |
| /** |
| * Gets all country Codes information with given MCC. |
| */ |
| private static int[] getAllCountryCodes(Context context) { |
| if (ALL_COUNTRY_CODES != null) { |
| return ALL_COUNTRY_CODES; |
| } |
| |
| Cursor cursor = null; |
| try { |
| String projection[] = {MccLookup.COUNTRY_CODE}; |
| cursor = context.getContentResolver().query(MccLookup.CONTENT_URI, |
| projection, null, null, null); |
| |
| if (cursor.getCount() > 0) { |
| ALL_COUNTRY_CODES = new int[cursor.getCount()]; |
| int i = 0; |
| while (cursor.moveToNext()) { |
| int countryCode = cursor.getInt(0); |
| ALL_COUNTRY_CODES[i++] = countryCode; |
| int length = String.valueOf(countryCode).trim().length(); |
| if (length > MAX_COUNTRY_CODES_LENGTH) { |
| MAX_COUNTRY_CODES_LENGTH = length; |
| } |
| } |
| } |
| } catch (SQLException e) { |
| Rlog.e(TAG, "Can't access HbpcdLookup database", e); |
| } finally { |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| return ALL_COUNTRY_CODES; |
| } |
| |
| private static boolean inExceptionListForNpCcAreaLocal(NumberEntry numberEntry) { |
| int countryCode = numberEntry.countryCode; |
| boolean result = (numberEntry.number.length() == 12 |
| && (countryCode == 7 || countryCode == 20 |
| || countryCode == 65 || countryCode == 90)); |
| return result; |
| } |
| |
| private static String getNumberPlanType(int state) { |
| String numberPlanType = "Number Plan type (" + state + "): "; |
| |
| if (state == NP_NANP_LOCAL) { |
| numberPlanType = "NP_NANP_LOCAL"; |
| } else if (state == NP_NANP_AREA_LOCAL) { |
| numberPlanType = "NP_NANP_AREA_LOCAL"; |
| } else if (state == NP_NANP_NDD_AREA_LOCAL) { |
| numberPlanType = "NP_NANP_NDD_AREA_LOCAL"; |
| } else if (state == NP_NANP_NBPCD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_NANP_NBPCD_CC_AREA_LOCAL"; |
| } else if (state == NP_NANP_LOCALIDD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_NANP_LOCALIDD_CC_AREA_LOCAL"; |
| } else if (state == NP_NANP_NBPCD_HOMEIDD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_NANP_NBPCD_HOMEIDD_CC_AREA_LOCAL"; |
| } else if (state == NP_NBPCD_HOMEIDD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_NBPCD_IDD_CC_AREA_LOCAL"; |
| } else if (state == NP_HOMEIDD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_IDD_CC_AREA_LOCAL"; |
| } else if (state == NP_NBPCD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_NBPCD_CC_AREA_LOCAL"; |
| } else if (state == NP_LOCALIDD_CC_AREA_LOCAL) { |
| numberPlanType = "NP_IDD_CC_AREA_LOCAL"; |
| } else if (state == NP_CC_AREA_LOCAL) { |
| numberPlanType = "NP_CC_AREA_LOCAL"; |
| } else { |
| numberPlanType = "Unknown type"; |
| } |
| return numberPlanType; |
| } |
| |
| /** |
| * Filter the destination number if using VZW sim card. |
| */ |
| public static String filterDestAddr(PhoneBase phoneBase, String destAddr) { |
| if (DBG) Rlog.d(TAG, "enter filterDestAddr. destAddr=\"" + destAddr + "\"" ); |
| |
| if (destAddr == null || !PhoneNumberUtils.isGlobalPhoneNumber(destAddr)) { |
| Rlog.w(TAG, "destAddr" + destAddr + " is not a global phone number!"); |
| return destAddr; |
| } |
| |
| final String networkOperator = TelephonyManager.getDefault().getNetworkOperator(); |
| String result = null; |
| |
| if (needToConvert(phoneBase)) { |
| final int networkType = getNetworkType(phoneBase); |
| if (networkType != -1 && !TextUtils.isEmpty(networkOperator)) { |
| String networkMcc = networkOperator.substring(0, 3); |
| if (networkMcc != null && networkMcc.trim().length() > 0) { |
| result = formatNumber(phoneBase.getContext(), destAddr, networkMcc, networkType); |
| } |
| } |
| } |
| |
| if (DBG) Rlog.d(TAG, "leave filterDestAddr, new destAddr=\"" + result + "\"" ); |
| return result != null ? result : destAddr; |
| } |
| |
| /** |
| * Returns the current network type |
| */ |
| private static int getNetworkType(PhoneBase phoneBase) { |
| int networkType = -1; |
| int phoneType = TelephonyManager.getDefault().getPhoneType(); |
| |
| if (phoneType == TelephonyManager.PHONE_TYPE_GSM) { |
| networkType = GSM_UMTS_NETWORK; |
| } else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) { |
| if (isInternationalRoaming(phoneBase)) { |
| networkType = CDMA_ROAMING_NETWORK; |
| } else { |
| networkType = CDMA_HOME_NETWORK; |
| } |
| } else { |
| if (DBG) Rlog.w(TAG, "warning! unknown mPhoneType value=" + phoneType); |
| } |
| |
| return networkType; |
| } |
| |
| private static boolean isInternationalRoaming(PhoneBase phoneBase) { |
| String operatorIsoCountry = TelephonyManager.getDefault().getNetworkCountryIsoForPhone( |
| phoneBase.getPhoneId()); |
| String simIsoCountry = TelephonyManager.getDefault().getSimCountryIsoForPhone( |
| phoneBase.getPhoneId()); |
| boolean internationalRoaming = !TextUtils.isEmpty(operatorIsoCountry) |
| && !TextUtils.isEmpty(simIsoCountry) |
| && !simIsoCountry.equals(operatorIsoCountry); |
| if (internationalRoaming) { |
| if ("us".equals(simIsoCountry)) { |
| internationalRoaming = !"vi".equals(operatorIsoCountry); |
| } else if ("vi".equals(simIsoCountry)) { |
| internationalRoaming = !"us".equals(operatorIsoCountry); |
| } |
| } |
| return internationalRoaming; |
| } |
| |
| private static boolean needToConvert(PhoneBase phoneBase) { |
| boolean bNeedToConvert = false; |
| String[] listArray = phoneBase.getContext().getResources() |
| .getStringArray(com.android.internal.R.array |
| .config_sms_convert_destination_number_support); |
| if (listArray != null && listArray.length > 0) { |
| for (int i=0; i<listArray.length; i++) { |
| if (!TextUtils.isEmpty(listArray[i])) { |
| String[] needToConvertArray = listArray[i].split(";"); |
| if (needToConvertArray != null && needToConvertArray.length > 0) { |
| if (needToConvertArray.length == 1) { |
| bNeedToConvert = "true".equalsIgnoreCase(needToConvertArray[0]); |
| } else if (needToConvertArray.length == 2 && |
| !TextUtils.isEmpty(needToConvertArray[1]) && |
| compareGid1(phoneBase, needToConvertArray[1])) { |
| bNeedToConvert = "true".equalsIgnoreCase(needToConvertArray[0]); |
| break; |
| } |
| } |
| } |
| } |
| } |
| return bNeedToConvert; |
| } |
| |
| private static boolean compareGid1(PhoneBase phoneBase, String serviceGid1) { |
| String gid1 = phoneBase.getGroupIdLevel1(); |
| boolean ret = true; |
| |
| if (TextUtils.isEmpty(serviceGid1)) { |
| if (DBG) Rlog.d(TAG, "compareGid1 serviceGid is empty, return " + ret); |
| return ret; |
| } |
| |
| int gid_length = serviceGid1.length(); |
| // Check if gid1 match service GID1 |
| if (!((gid1 != null) && (gid1.length() >= gid_length) && |
| gid1.substring(0, gid_length).equalsIgnoreCase(serviceGid1))) { |
| if (DBG) Rlog.d(TAG, " gid1 " + gid1 + " serviceGid1 " + serviceGid1); |
| ret = false; |
| } |
| if (DBG) Rlog.d(TAG, "compareGid1 is " + (ret?"Same":"Different")); |
| return ret; |
| } |
| } |
