Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 44c84a6f authored by sparvathy's avatar sparvathy
Browse files

(Emergency call routing type) Determined routing type for emergency numbers 

Default set as emergency call.
Based on the value of is_normal_routing field from database routing type is
modified.
If is_normal_routing is true and mnc list is null then normal routing.
If list of mnc not null then normal routing only for those mnc's.
support to use DB routing while merging of duplicate numbers.

Test: atest EmergencyNumberTrackerTest & emergency call test in device
Bug: 238359415
Change-Id: I907939de6b0c281c51e457ed4b4400af9384191b
parent 3dcfe53d

src/java/com/android/internal/telephony/emergency/EmergencyNumberTracker.java

+168 −17
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ import android.os.ParcelFileDescriptor; 
import android.os.PersistableBundle;

import android.os.SystemProperties;

import android.telephony.CarrierConfigManager;

import android.telephony.CellIdentity;

import android.telephony.PhoneNumberUtils;

import android.telephony.ServiceState;

import android.telephony.SubscriptionManager;
@@ -38,6 +39,8 @@ import android.telephony.emergency.EmergencyNumber; 
import android.telephony.emergency.EmergencyNumber.EmergencyCallRouting;

import android.telephony.emergency.EmergencyNumber.EmergencyServiceCategories;

import android.text.TextUtils;

import android.util.ArrayMap;

import android.util.ArraySet;

import android.util.LocalLog;



import com.android.internal.annotations.VisibleForTesting;
@@ -70,6 +73,8 @@ import java.util.Arrays; 
import java.util.Collections;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import java.util.zip.GZIPInputStream;



/**
@@ -104,6 +109,11 @@ public class EmergencyNumberTracker extends Handler { 
    private int mCurrentDatabaseVersion = INVALID_DATABASE_VERSION;

    private boolean mIsHalVersionLessThan1Dot4 = false;

    private Resources mResources = null;

    /**

     * Used for storing all specific mnc's along with the list of emergency numbers

     * for which normal routing should be supported.

     */

    private Map<String, Set<String>> mNormalRoutedNumbers = new ArrayMap<>();



    /**

     * Indicates if the country iso is set by another subscription.
@@ -415,7 +425,8 @@ public class EmergencyNumberTracker extends Handler { 
                EVENT_OVERRIDE_OTA_EMERGENCY_NUMBER_DB_FILE_PATH, null).sendToTarget();

    }



    private EmergencyNumber convertEmergencyNumberFromEccInfo(EccInfo eccInfo, String countryIso) {

    private EmergencyNumber convertEmergencyNumberFromEccInfo(EccInfo eccInfo, String countryIso,

            int emergencyCallRouting) {

        String phoneNumber = eccInfo.phoneNumber.trim();

        if (phoneNumber.isEmpty()) {

            loge("EccInfo has empty phone number.");
@@ -456,13 +467,54 @@ public class EmergencyNumberTracker extends Handler { 
                    // Ignores unknown types.

            }

        }

        return new EmergencyNumber(phoneNumber, countryIso, "", emergencyServiceCategoryBitmask,

                new ArrayList<String>(), EmergencyNumber.EMERGENCY_NUMBER_SOURCE_DATABASE,

                EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN);

        return new EmergencyNumber(phoneNumber, countryIso, "",

                emergencyServiceCategoryBitmask, new ArrayList<String>(),

                EmergencyNumber.EMERGENCY_NUMBER_SOURCE_DATABASE, emergencyCallRouting);

    }



    /**

     * Get routing type of emergency numbers from DB. Update mnc's list with numbers that are

     * to supported as normal routing type in the respective mnc's.

     */

    private int getRoutingInfoFromDB(EccInfo eccInfo,

            Map<String, Set<String>> normalRoutedNumbers) {

        int emergencyCallRouting = EmergencyNumber.EMERGENCY_CALL_ROUTING_EMERGENCY;

        String phoneNumber = eccInfo.phoneNumber.trim();

        if (phoneNumber.isEmpty()) {

            loge("EccInfo has empty phone number.");

            return emergencyCallRouting;

        }



        if (eccInfo.isNormalRouted) {

            emergencyCallRouting = EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL;



            if (((eccInfo.normalRoutingMncs).length != 0)

                    && (eccInfo.normalRoutingMncs[0].length() > 0)) {

                emergencyCallRouting = EmergencyNumber.EMERGENCY_CALL_ROUTING_EMERGENCY;



                for (String routingMnc : eccInfo.normalRoutingMncs) {

                    boolean mncExist = normalRoutedNumbers.containsKey(routingMnc);

                    Set phoneNumberList;

                    if (!mncExist) {

                        phoneNumberList = new ArraySet<String>();

                        phoneNumberList.add(phoneNumber);

                        normalRoutedNumbers.put(routingMnc, phoneNumberList);

                    } else {

                        phoneNumberList = normalRoutedNumbers.get(routingMnc);

                        if (!phoneNumberList.contains(phoneNumber)) {

                            phoneNumberList.add(phoneNumber);

                        }

                    }

                }

                logd("Normal routed mncs with phoneNumbers:" + normalRoutedNumbers);

            }

        }

        return emergencyCallRouting;

    }



    private void cacheEmergencyDatabaseByCountry(String countryIso) {

        int assetsDatabaseVersion;

        Map<String, Set<String>> assetNormalRoutedNumbers = new ArrayMap<>();



        // Read the Asset emergency number database

        List<EmergencyNumber> updatedAssetEmergencyNumberList = new ArrayList<>();
@@ -478,8 +530,13 @@ public class EmergencyNumberTracker extends Handler { 
            for (ProtobufEccData.CountryInfo countryEccInfo : allEccMessages.countries) {

                if (countryEccInfo.isoCode.equals(countryIso.toUpperCase(Locale.ROOT))) {

                    for (ProtobufEccData.EccInfo eccInfo : countryEccInfo.eccs) {

                        int emergencyCallRouting = EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN;

                        if (!shouldEmergencyNumberRoutingFromDbBeIgnored()) {

                            emergencyCallRouting = getRoutingInfoFromDB(eccInfo,

                                    assetNormalRoutedNumbers);

                        }

                        updatedAssetEmergencyNumberList.add(convertEmergencyNumberFromEccInfo(

                                eccInfo, countryIso));

                                eccInfo, countryIso, emergencyCallRouting));

                    }

                }

            }
@@ -500,6 +557,8 @@ public class EmergencyNumberTracker extends Handler { 
            logd("Using Asset Emergency database. Version: " + assetsDatabaseVersion);

            mCurrentDatabaseVersion = assetsDatabaseVersion;

            mEmergencyNumberListFromDatabase = updatedAssetEmergencyNumberList;

            mNormalRoutedNumbers.clear();

            mNormalRoutedNumbers = assetNormalRoutedNumbers;

        } else {

            logd("Using Ota Emergency database. Version: " + otaDatabaseVersion);

        }
@@ -508,6 +567,7 @@ public class EmergencyNumberTracker extends Handler { 
    private int cacheOtaEmergencyNumberDatabase() {

        ProtobufEccData.AllInfo allEccMessages = null;

        int otaDatabaseVersion = INVALID_DATABASE_VERSION;

        Map<String, Set<String>> otaNormalRoutedNumbers = new ArrayMap<>();



        // Read the OTA emergency number database

        List<EmergencyNumber> updatedOtaEmergencyNumberList = new ArrayList<>();
@@ -538,8 +598,13 @@ public class EmergencyNumberTracker extends Handler { 
            for (ProtobufEccData.CountryInfo countryEccInfo : allEccMessages.countries) {

                if (countryEccInfo.isoCode.equals(countryIso.toUpperCase(Locale.ROOT))) {

                    for (ProtobufEccData.EccInfo eccInfo : countryEccInfo.eccs) {

                        int emergencyCallRouting = EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN;

                        if (!shouldEmergencyNumberRoutingFromDbBeIgnored()) {

                            emergencyCallRouting = getRoutingInfoFromDB(eccInfo,

                                    otaNormalRoutedNumbers);

                        }

                        updatedOtaEmergencyNumberList.add(convertEmergencyNumberFromEccInfo(

                                eccInfo, countryIso));

                                eccInfo, countryIso, emergencyCallRouting));

                    }

                }

            }
@@ -554,6 +619,8 @@ public class EmergencyNumberTracker extends Handler { 
                && mCurrentDatabaseVersion < otaDatabaseVersion) {

            mCurrentDatabaseVersion = otaDatabaseVersion;

            mEmergencyNumberListFromDatabase = updatedOtaEmergencyNumberList;

            mNormalRoutedNumbers.clear();

            mNormalRoutedNumbers = otaNormalRoutedNumbers;

        }

        return otaDatabaseVersion;

    }
@@ -709,12 +776,97 @@ public class EmergencyNumberTracker extends Handler { 
     *         indication not support from the HAL.

     */

    public List<EmergencyNumber> getEmergencyNumberList() {

        List<EmergencyNumber> completeEmergencyNumberList;

        if (!mEmergencyNumberListFromRadio.isEmpty()) {

            return Collections.unmodifiableList(mEmergencyNumberList);

            completeEmergencyNumberList = Collections.unmodifiableList(mEmergencyNumberList);

        } else {

            completeEmergencyNumberList = getEmergencyNumberListFromEccListDatabaseAndTest();

        }

        if (shouldAdjustForRouting()) {

            return adjustRoutingForEmergencyNumbers(completeEmergencyNumberList);

        } else {

            return completeEmergencyNumberList;

        }

    }



    /**

     * Util function to check whether routing type and mnc value in emergency number needs

     * to be adjusted for the current network mnc.

     */

    private boolean shouldAdjustForRouting() {

        if (!shouldEmergencyNumberRoutingFromDbBeIgnored() && !mNormalRoutedNumbers.isEmpty()) {

            CellIdentity cellIdentity = mPhone.getCurrentCellIdentity();

            if (cellIdentity != null) {

                String networkMnc = cellIdentity.getMncString();

                if (mNormalRoutedNumbers.containsKey(networkMnc)) {

                    Set<String> phoneNumbers = mNormalRoutedNumbers.get(networkMnc);

                    if (phoneNumbers != null && !phoneNumbers.isEmpty()) {

                        return true;

                    }

                }

            }

        }

        return false;

    }



    /**

     * Adjust emergency numbers with mnc and routing type based on the current network mnc.

     */

    private List<EmergencyNumber> adjustRoutingForEmergencyNumbers(

            List<EmergencyNumber> emergencyNumbers) {

        CellIdentity cellIdentity = mPhone.getCurrentCellIdentity();

        if (cellIdentity != null) {

            String networkMnc = cellIdentity.getMncString();



            Set<String> normalRoutedPhoneNumbers = mNormalRoutedNumbers.get(networkMnc);

            if (normalRoutedPhoneNumbers == null || normalRoutedPhoneNumbers.isEmpty()) {

                return emergencyNumbers;

            }

            Set<String> normalRoutedPhoneNumbersWithPrefix = new ArraySet<String>();

            for (String num : normalRoutedPhoneNumbers) {

                Set<String> phoneNumbersWithPrefix = addPrefixToEmergencyNumber(num);

                if (phoneNumbersWithPrefix != null && !phoneNumbersWithPrefix.isEmpty()) {

                    normalRoutedPhoneNumbersWithPrefix.addAll(phoneNumbersWithPrefix);

                }

            }

            List<EmergencyNumber> adjustedEmergencyNumberList = new ArrayList<>();

            int routing;

            String mnc;

            for (EmergencyNumber num : emergencyNumbers) {

                routing = num.getEmergencyCallRouting();

                mnc = num.getMnc();

                if (num.isFromSources(EmergencyNumber.EMERGENCY_NUMBER_SOURCE_DATABASE)

                        && (normalRoutedPhoneNumbers.contains(num.getNumber())

                        || (normalRoutedPhoneNumbersWithPrefix.contains(num.getNumber())))) {

                    routing = EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL;

                    mnc = networkMnc;

                    logd("adjustRoutingForEmergencyNumbers for number" + num.getNumber());

                }

                adjustedEmergencyNumberList.add(new EmergencyNumber(num.getNumber(),

                        num.getCountryIso(), mnc,

                        num.getEmergencyServiceCategoryBitmask(),

                        num.getEmergencyUrns(), num.getEmergencyNumberSourceBitmask(),

                        routing));

            }

            return adjustedEmergencyNumberList;

        } else {

            return getEmergencyNumberListFromEccListDatabaseAndTest();

            return emergencyNumbers;

        }

    }





    /**

     * Util function to add prefix to the given emergency number.

     */

    private Set<String> addPrefixToEmergencyNumber(String number) {

        Set<String> phoneNumbersWithPrefix = new ArraySet<String>();

        for (String prefix : mEmergencyNumberPrefix) {

            if (!number.startsWith(prefix)) {

                phoneNumbersWithPrefix.add(prefix + number);

            }

        }

        return phoneNumbersWithPrefix;

    }



    /**

     * Checks if the number is an emergency number in the current Phone.
@@ -895,12 +1047,11 @@ public class EmergencyNumberTracker extends Handler { 
        List<EmergencyNumber> emergencyNumberListWithPrefix = new ArrayList<>();

        if (emergencyNumberList != null) {

            for (EmergencyNumber num : emergencyNumberList) {

                for (String prefix : mEmergencyNumberPrefix) {

                    // If an emergency number has started with the prefix,

                    // no need to apply the prefix.

                    if (!num.getNumber().startsWith(prefix)) {

                Set<String> phoneNumbersWithPrefix = addPrefixToEmergencyNumber(num.getNumber());

                if (phoneNumbersWithPrefix != null && !phoneNumbersWithPrefix.isEmpty()) {

                    for (String numberWithPrefix : phoneNumbersWithPrefix) {

                        emergencyNumberListWithPrefix.add(new EmergencyNumber(

                            prefix + num.getNumber(), num.getCountryIso(),

                                numberWithPrefix, num.getCountryIso(),

                                num.getMnc(), num.getEmergencyServiceCategoryBitmask(),

                                num.getEmergencyUrns(), num.getEmergencyNumberSourceBitmask(),

                                num.getEmergencyCallRouting()));
@@ -948,7 +1099,7 @@ public class EmergencyNumberTracker extends Handler { 
                return new EmergencyNumber(number, getLastKnownEmergencyCountryIso()

                        .toLowerCase(Locale.ROOT), "", num.getEmergencyServiceCategoryBitmask(),

                        new ArrayList<String>(), EmergencyNumber.EMERGENCY_NUMBER_SOURCE_DATABASE,

                        EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN);

                        num.getEmergencyCallRouting());

            }

        }

        return new EmergencyNumber(number, "", "",

tests/telephonytests/assets/eccdata

+45 B (96 B)

File changed.

No diff preview for this file type.

View original file
View changed file

tests/telephonytests/assets/eccdata_input.txt

+51 −0
Original line number Diff line number Diff line
@@ -10,6 +10,57 @@ countries { 
    types: MOUNTAIN_RESCUE

    types: MIEC

    types: AIEC

    is_normal_routed: true

    normal_routing_mncs: "05"

  }

  eccs {

    phone_number: "888"

    types: POLICE

    types: AMBULANCE

    types: FIRE

    types: MARINE_GUARD

    types: MOUNTAIN_RESCUE

    types: MIEC

    types: AIEC

    is_normal_routed: true

    normal_routing_mncs: "45"

    normal_routing_mncs: "47"

    normal_routing_mncs: "05"

  }

  eccs {

    phone_number: "654321"

    types: POLICE

    types: AMBULANCE

    types: FIRE

    types: MARINE_GUARD

    types: MOUNTAIN_RESCUE

    types: MIEC

    types: AIEC

    is_normal_routed: false

    normal_routing_mncs: ""

  }

  eccs {

    phone_number: "7654321"

    types: POLICE

    types: AMBULANCE

    types: FIRE

    types: MARINE_GUARD

    types: MOUNTAIN_RESCUE

    types: MIEC

    types: AIEC

    is_normal_routed: true

    normal_routing_mncs: ""

  }

  eccs {

    phone_number: "4321"

    types: POLICE

    types: AMBULANCE

    types: FIRE

    types: MARINE_GUARD

    types: MOUNTAIN_RESCUE

    types: MIEC

    types: AIEC

    is_normal_routed: true

  }

  ecc_fallback: "911"

}

tests/telephonytests/src/com/android/internal/telephony/emergency/EmergencyNumberTest.java

+30 −1
Original line number Diff line number Diff line
@@ -379,7 +379,36 @@ public class EmergencyNumberTest extends TestCase { 
                EmergencyNumber.EMERGENCY_NUMBER_SOURCE_NETWORK_SIGNALING,

                EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL);



        assertFalse(EmergencyNumber.areSameEmergencyNumbers(num1, num2));

        /* case 1: Check routing is not checked when comparing the same numbers. As routing will

        be unknown for all numbers apart from DB. Check merge when both are not from DB then

        routing value is merged from first number. */

        assertTrue(EmergencyNumber.areSameEmergencyNumbers(num1, num2));

        assertEquals(num1, EmergencyNumber.mergeSameEmergencyNumbers(num1, num2));



        num2 = new EmergencyNumber(

                "911",

                "jp",

                "30",

                EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED,

                new ArrayList<String>(),

                EmergencyNumber.EMERGENCY_NUMBER_SOURCE_DATABASE,

                EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL);



        /* case 1: Check routing is not checked when comparing the same numbers. Check merge when

        one of the number is from DB then routing value is merged from DB number. Along with

        source value is masked with both*/

        assertTrue(EmergencyNumber.areSameEmergencyNumbers(num1, num2));



        num2 = new EmergencyNumber(

                "911",

                "jp",

                "30",

                EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED,

                new ArrayList<String>(),

                EmergencyNumber.EMERGENCY_NUMBER_SOURCE_NETWORK_SIGNALING

                | EmergencyNumber.EMERGENCY_NUMBER_SOURCE_DATABASE,

                EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL);

        assertEquals(num2, EmergencyNumber.mergeSameEmergencyNumbers(num1, num2));

    }



    public void testSameEmergencyNumberDifferentSource() throws Exception {

tests/telephonytests/src/com/android/internal/telephony/emergency/EmergencyNumberTrackerTest.java

+191 −4

File changed.

Preview size limit exceeded, changes collapsed.