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

Commit 8e2117bb authored by SongFerngWang's avatar SongFerngWang
Browse files

The phone didn't reload the allowed Network Type 

Reload the allowed Network after device insert SIM card.
Change the behavior of notifyAllowedNetworkTypesChanged.

Bug: 180903931
Test: atest cts/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTest.java#testSetAllowedNetworkTypesForReason_moreReason
atest cts/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTest.java#testSetAllowedNetworkTypesForReason
atest android.telephony.cts.TelephonyCallbackTest

Change-Id: I028405f8f19a1db3d6102a4e5269ca98b5cef8ad
Merged-In: I028405f8f19a1db3d6102a4e5269ca98b5cef8ad
parent 1b3b09e8

src/java/com/android/internal/telephony/CarrierServiceStateTracker.java

+4 −7
Original line number Diff line number Diff line
@@ -84,17 +84,14 @@ public class CarrierServiceStateTracker extends Handler { 
    public class AllowedNetworkTypesListener extends TelephonyCallback

            implements TelephonyCallback.AllowedNetworkTypesListener {

        @Override

        public void onAllowedNetworkTypesChanged(Map<Integer, Long> allowedNetworkTypesList) {

            if (!allowedNetworkTypesList.containsKey(

                    TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)) {

        public void onAllowedNetworkTypesChanged(int reason, long newAllowedNetworkType) {

            if (reason != TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER) {

                return;

            }



            long newAllowedNetworkType = allowedNetworkTypesList.get(

                    TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER);

            if (mAllowedNetworkType != newAllowedNetworkType) {

                mAllowedNetworkType = newAllowedNetworkType;

                handlePrefNetworkModeChanged();

                handleAllowedNetworkTypeChanged();

            }

        }

    }
@@ -291,7 +288,7 @@ public class CarrierServiceStateTracker extends Handler { 
        }

    }



    private void handlePrefNetworkModeChanged() {

    private void handleAllowedNetworkTypeChanged() {

        NotificationType notificationType = mNotificationTypeMap.get(NOTIFICATION_PREF_NETWORK);

        if (notificationType != null) {

            evaluateSendingMessageOrCancelNotification(notificationType);

src/java/com/android/internal/telephony/DefaultPhoneNotifier.java

+4 −5
Original line number Diff line number Diff line
@@ -41,7 +41,6 @@ import com.android.internal.telephony.PhoneInternalInterface.DataActivityState; 
import com.android.telephony.Rlog;



import java.util.List;

import java.util.Map;



/**

 * broadcast intents
@@ -253,10 +252,10 @@ public class DefaultPhoneNotifier implements PhoneNotifier { 
    }



    @Override

    public void notifyAllowedNetworkTypesChanged(Phone sender,

            Map<Integer, Long> allowedNetworkTypeList) {

        mTelephonyRegistryMgr.notifyAllowedNetworkTypesChanged(sender.getSubId(),

                sender.getPhoneId(), allowedNetworkTypeList);

    public void notifyAllowedNetworkTypesChanged(Phone sender, int reason,

            long allowedNetworkType) {

        mTelephonyRegistryMgr.notifyAllowedNetworkTypesChanged(sender.getPhoneId(),

                sender.getSubId(), reason, allowedNetworkType);

    }



    @Override

src/java/com/android/internal/telephony/GsmCdmaPhone.java

+12 −5
Original line number Diff line number Diff line
@@ -2720,7 +2720,6 @@ public class GsmCdmaPhone extends Phone { 
        // If this is on APM off, SIM may already be loaded. Send setPreferredNetworkType

        // request to RIL to preserve user setting across APM toggling

        setPreferredNetworkTypeIfSimLoaded();

        notifyAllowedNetworkTypesChanged();

    }



    private void handleRadioOffOrNotAvailable() {
@@ -2869,8 +2868,9 @@ public class GsmCdmaPhone extends Phone { 


                updateCdmaRoamingSettingsAfterCarrierConfigChanged(b);



                updateNrSettingsAfterCarrierConfigChanged();



                updateNrSettingsAfterCarrierConfigChanged(b);

                loadAllowedNetworksFromSubscriptionDatabase();

                updateAllowedNetworkTypes(null);

                break;



            case EVENT_SET_ROAMING_PREFERENCE_DONE:
@@ -4566,8 +4566,15 @@ public class GsmCdmaPhone extends Phone { 
        setBroadcastEmergencyCallStateChanges(broadcastEmergencyCallStateChanges);

    }



    private void updateNrSettingsAfterCarrierConfigChanged() {

        updateAllowedNetworkTypes(null);

    private void updateNrSettingsAfterCarrierConfigChanged(PersistableBundle config) {

        if (config == null) {

            loge("didn't get the carrier_nr_availability_int from the carrier config.");

            return;

        }

        mIsCarrierNrSupported = config.getInt(

                CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITY_INT,

                CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA)

                != CarrierConfigManager.CARRIER_NR_AVAILABILITY_NONE;

    }



    private void updateCdmaRoamingSettingsAfterCarrierConfigChanged(PersistableBundle config) {

src/java/com/android/internal/telephony/Phone.java

+104 −72
Original line number Diff line number Diff line
@@ -448,6 +448,7 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
    private static final String ALLOWED_NETWORK_TYPES_TEXT_CARRIER = "carrier";

    private static final String ALLOWED_NETWORK_TYPES_TEXT_ENABLE_2G = "enable_2g";

    private static final int INVALID_ALLOWED_NETWORK_TYPES = -1;

    protected boolean mIsCarrierNrSupported = false;



    private boolean mUnitTestMode;

    private final CarrierPrivilegesTracker mCarrierPrivilegesTracker;
@@ -2215,25 +2216,23 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
                allowedNetworkTypes = allowedNetworkTypes & networkTypes;

            }

        }

        Rlog.d(LOG_TAG, "getEffectiveAllowedNetworkTypes: " + allowedNetworkTypes);

        if (!mIsCarrierNrSupported) {

            allowedNetworkTypes &= ~TelephonyManager.NETWORK_TYPE_BITMASK_NR;

        }

        logd("SubId" + getSubId() + ",getEffectiveAllowedNetworkTypes: "

                + TelephonyManager.convertNetworkTypeBitmaskToString(allowedNetworkTypes));

        return allowedNetworkTypes;

    }



    /**

     * Notify the allowed network types changed.

     * Notify the latest allowed network types changed.

     */

    public void notifyAllowedNetworkTypesChanged() {

        List<Integer> listOfAllowedNetworkTypesForReasons = new ArrayList<>(

                Arrays.asList(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,

                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_POWER,

                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER,

                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_ENABLE_2G));

        Map<Integer, Long> allowedNetworkTypeList = new HashMap<>();

        for (Integer reasonItem : listOfAllowedNetworkTypesForReasons) {

            allowedNetworkTypeList.put(reasonItem, getAllowedNetworkTypes(reasonItem));

        }

        Rlog.d(LOG_TAG, "notifyAllowedNetworkTypesChanged: " + allowedNetworkTypeList.toString());

        mNotifier.notifyAllowedNetworkTypesChanged(this, allowedNetworkTypeList);

    public void notifyAllowedNetworkTypesChanged(

            @TelephonyManager.AllowedNetworkTypesReason int reason) {

        logd("SubId" + getSubId() + ",notifyAllowedNetworkTypesChanged: reason: " + reason

                + " value:" + TelephonyManager.convertNetworkTypeBitmaskToString(

                getAllowedNetworkTypes(reason)));

        mNotifier.notifyAllowedNetworkTypesChanged(this, reason, getAllowedNetworkTypes(reason));

    }



    /**
@@ -2267,7 +2266,7 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
     */

    public @TelephonyManager.NetworkTypeBitMask long getAllowedNetworkTypes(

            @TelephonyManager.AllowedNetworkTypesReason int reason) {

        long allowedNetworkTypes = INVALID_ALLOWED_NETWORK_TYPES;

        long allowedNetworkTypes;

        long defaultAllowedNetworkTypes = RadioAccessFamily.getRafFromNetworkType(

                RILConstants.PREFERRED_NETWORK_MODE);
@@ -2276,41 +2275,41 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
        }



        synchronized (mAllowedNetworkTypesForReasons) {

            // Try to load ALLOWED_NETWORK_TYPES from SIMINFO.

            if (SubscriptionController.getInstance() != null

                    && !mAllowedNetworkTypesForReasons.containsKey(reason)) {

                String result = SubscriptionController.getInstance().getSubscriptionProperty(

                        getSubId(),

                        SubscriptionManager.ALLOWED_NETWORK_TYPES);

                if (result != null) {

                    try {

                        filterAllowedNetworkTypesFromDb(result);

                    } catch (NumberFormatException err) {

                        Rlog.e(LOG_TAG, "allowedNetworkTypes NumberFormat exception");

                    }

                }

            }



            allowedNetworkTypes = mAllowedNetworkTypesForReasons.getOrDefault(

                    reason,

                    defaultAllowedNetworkTypes);

        }



        if (reason == TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER) {

            allowedNetworkTypes = updateAllowedNetworkTypeForCarrierWithCarrierConfig(reason,

                    allowedNetworkTypes);

        if (!mIsCarrierNrSupported

                && reason == TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER) {

            allowedNetworkTypes = updateAllowedNetworkTypeForCarrierWithCarrierConfig();

        }

        Rlog.d(LOG_TAG,

                "get allowed network types " + convertAllowedNetworkTypeMapIndexToDbName(reason)

                        + ": value = " + allowedNetworkTypes);



        logd("SubId" + getSubId() + ",get allowed network types "

                + convertAllowedNetworkTypeMapIndexToDbName(reason)

                + ": value = " + TelephonyManager.convertNetworkTypeBitmaskToString(

                allowedNetworkTypes));

        return allowedNetworkTypes;

    }



    private void filterAllowedNetworkTypesFromDb(String result) {

        if (TextUtils.isEmpty(result)) {

    /**

     * Loads the allowed network type from subscription database.

     */

    public void loadAllowedNetworksFromSubscriptionDatabase() {

        // Try to load ALLOWED_NETWORK_TYPES from SIMINFO.

        if (SubscriptionController.getInstance() == null) {

            return;

        }



        String result = SubscriptionController.getInstance().getSubscriptionProperty(

                getSubId(),

                SubscriptionManager.ALLOWED_NETWORK_TYPES);

        if (result == null) {

            return;

        }



        logd("SubId" + getSubId() + ",load allowed network types : value = " + result);

        Map<Integer, Long> oldAllowedNetworkTypes = new HashMap<>(mAllowedNetworkTypesForReasons);

        mAllowedNetworkTypesForReasons.clear();

        try {

            // Format: "REASON=VALUE,REASON2=VALUE2"

            for (String pair : result.trim().split(",")) {

                String[] networkTypesValues = (pair.trim().toLowerCase()).split("=");
@@ -2320,11 +2319,26 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
                }

                int key = convertAllowedNetworkTypeDbNameToMapIndex(networkTypesValues[0]);

                long value = Long.parseLong(networkTypesValues[1]);

            if (key != INVALID_ALLOWED_NETWORK_TYPES && value != INVALID_ALLOWED_NETWORK_TYPES) {

                if (key != INVALID_ALLOWED_NETWORK_TYPES

                        && value != INVALID_ALLOWED_NETWORK_TYPES) {

                    synchronized (mAllowedNetworkTypesForReasons) {

                        mAllowedNetworkTypesForReasons.put(key, value);

                    }

                    if (!oldAllowedNetworkTypes.containsKey(key)

                            || oldAllowedNetworkTypes.get(key) != value) {

                        if (oldAllowedNetworkTypes.containsKey(key)) {

                            oldAllowedNetworkTypes.remove(key);

                        }

                        notifyAllowedNetworkTypesChanged(key);

                    }

                }

            }

        } catch (NumberFormatException e) {

            Rlog.e(LOG_TAG, "allowedNetworkTypes NumberFormat exception" + e);

        }



        for (int key : oldAllowedNetworkTypes.keySet()) {

            notifyAllowedNetworkTypesChanged(key);

        }

    }
@@ -2358,24 +2372,23 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
        }

    }



    private long updateAllowedNetworkTypeForCarrierWithCarrierConfig(

            @TelephonyManager.AllowedNetworkTypesReason int reason,

            @TelephonyManager.NetworkTypeBitMask long allowedNetworkTypes) {

        CarrierConfigManager configMgr = (CarrierConfigManager)

                getContext().getSystemService(Context.CARRIER_CONFIG_SERVICE);

        PersistableBundle config = configMgr.getConfigForSubId(getSubId());

        if (config == null) {

            return allowedNetworkTypes;

    private @TelephonyManager.NetworkTypeBitMask long

            updateAllowedNetworkTypeForCarrierWithCarrierConfig() {

        long defaultAllowedNetworkTypes = RadioAccessFamily.getRafFromNetworkType(

                RILConstants.PREFERRED_NETWORK_MODE);

        long allowedNetworkTypes;

        synchronized (mAllowedNetworkTypesForReasons) {

            allowedNetworkTypes = mAllowedNetworkTypesForReasons.getOrDefault(

                    TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER,

                    defaultAllowedNetworkTypes);

        }

        boolean isNrSupported = config.getInt(

                CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITY_INT,

                CarrierConfigManager.CARRIER_NR_AVAILABILITY_NSA)

                != CarrierConfigManager.CARRIER_NR_AVAILABILITY_NONE;

        if (!isNrSupported) {

            allowedNetworkTypes =

                    allowedNetworkTypes & ~TelephonyManager.NETWORK_TYPE_BITMASK_NR;

            Rlog.d(LOG_TAG, reason + " with carrier config value = " + allowedNetworkTypes);

        if (mIsCarrierNrSupported) {

            return allowedNetworkTypes;

        }

        allowedNetworkTypes = allowedNetworkTypes & ~TelephonyManager.NETWORK_TYPE_BITMASK_NR;



        logd("Allowed network types for 'carrier' reason is changed by carrier config = "

                + TelephonyManager.convertNetworkTypeBitmaskToString(allowedNetworkTypes));

        return allowedNetworkTypes;

    }
@@ -2402,10 +2415,10 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
        SubscriptionManager.setSubscriptionProperty(getSubId(),

                SubscriptionManager.ALLOWED_NETWORK_TYPES,

                mapAsString);

        Rlog.d(LOG_TAG, "setAllowedNetworkTypes " + mapAsString);

        notifyAllowedNetworkTypesChanged();

        logd("SubId" + getSubId() + ",setAllowedNetworkTypes " + mapAsString);



        updateAllowedNetworkTypes(response);

        notifyAllowedNetworkTypesChanged(reason);

    }



    protected void updateAllowedNetworkTypes(Message response) {
@@ -2424,8 +2437,11 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 


        int filteredRaf = (int) (modemRaf & getEffectiveAllowedNetworkTypes());



        Rlog.d(LOG_TAG, "setAllowedNetworkTypes: modemRaf = " + modemRaf

                + " filteredRaf = " + filteredRaf);

        logd("setAllowedNetworkTypes: modemRafBitMask = " + modemRaf

                + " ,modemRaf = " + TelephonyManager.convertNetworkTypeBitmaskToString(modemRaf)

                + " ,filteredRafBitMask = " + filteredRaf

                + " ,filteredRaf = " + TelephonyManager.convertNetworkTypeBitmaskToString(

                filteredRaf));

        mCi.setAllowedNetworkTypesBitmap(filteredRaf, response);

        mPreferredNetworkTypeRegistrants.notifyRegistrants();

    }
@@ -4929,4 +4945,20 @@ public abstract class Phone extends Handler implements PhoneInternalInterface { 
            pw.println("++++++++++++++++++++++++++++++++");

        }

    }



    private void logd(String s) {

        Rlog.d(LOG_TAG, "[" + mPhoneId + "] " + s);

    }



    private void logi(String s) {

        Rlog.i(LOG_TAG, "[" + mPhoneId + "] " + s);

    }



    private void loge(String s) {

        Rlog.e(LOG_TAG, "[" + mPhoneId + "] " + s);

    }



    private static String pii(String s) {

        return Rlog.pii(LOG_TAG, s);

    }

}

src/java/com/android/internal/telephony/PhoneNotifier.java

+1 −2
Original line number Diff line number Diff line
@@ -35,7 +35,6 @@ import android.telephony.emergency.EmergencyNumber; 
import android.telephony.ims.ImsReasonInfo;



import java.util.List;

import java.util.Map;



/**

 * {@hide}
@@ -129,7 +128,7 @@ public interface PhoneNotifier { 
    void notifyDataEnabled(Phone sender, boolean enabled, @DataEnabledReason int reason);



    /** Notify Allowed Network Type has changed. */

    void notifyAllowedNetworkTypesChanged(Phone sender, Map<Integer, Long> allowedNetworkType);

    void notifyAllowedNetworkTypesChanged(Phone sender, int reason, long allowedNetworkType);



    /** Notify link capacity estimate has changed. */

    void notifyLinkCapacityEstimateChanged(Phone sender,