Merge "The phone didn't reload the allowed Network Type" (c68a450e) · Commits · e / os / android_frameworks_opt_telephony

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,