Merge "Improve AllowedNetworkTypesForReason and refactor PreferredNetworkType" (69affb0c) · Commits · e / os / android_frameworks_opt_telephony

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

+57 −32

Original line number	Diff line number	Diff line
		@@ -24,12 +24,14 @@ import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.content.res.Resources;
		import android.database.ContentObserver;
		import android.os.Handler;
		import android.os.HandlerExecutor;
		import android.os.Message;
		import android.os.PersistableBundle;
		import android.provider.Settings;
		import android.telephony.CarrierConfigManager;
		import android.telephony.PhoneStateListener;
		import android.telephony.RadioAccessFamily;
		import android.telephony.ServiceState;
		import android.telephony.SubscriptionManager;
		import android.telephony.SubscriptionManager.OnSubscriptionsChangedListener;
		@@ -71,9 +73,32 @@ public class CarrierServiceStateTracker extends Handler {
		@VisibleForTesting
		public static final String PREF_NETWORK_NOTIFICATION_TAG = "PrefNetworkNotification";

		private long mAllowedNetworkType = -1;
		private AllowedNetworkTypesChangedListener mAllowedNetworkTypesChangedListenerListener;
		private TelephonyManager mTelephonyManager;

		/**
		* The listener for allowed network types changed
		*/
		@VisibleForTesting
		public class AllowedNetworkTypesChangedListener extends PhoneStateListener
		implements PhoneStateListener.AllowedNetworkTypesChangedListener {
		@Override
		public void onAllowedNetworkTypesChanged(Map<Integer, Long> allowedNetworkTypesList) {
		long newAllowedNetworkType = allowedNetworkTypesList.get(
		TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER);
		if (mAllowedNetworkType != newAllowedNetworkType) {
		mAllowedNetworkType = newAllowedNetworkType;
		handlePrefNetworkModeChanged();
		}
		}
		}

		public CarrierServiceStateTracker(Phone phone, ServiceStateTracker sst) {
		this.mPhone = phone;
		this.mSST = sst;
		mTelephonyManager = mPhone.getContext().getSystemService(
		TelephonyManager.class).createForSubscriptionId(mPhone.getSubId());
		phone.getContext().registerReceiver(mBroadcastReceiver, new IntentFilter(
		CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED));
		// Listen for subscriber changes
		@@ -84,44 +109,42 @@ public class CarrierServiceStateTracker extends Handler {
		int subId = mPhone.getSubId();
		if (mPreviousSubId != subId) {
		mPreviousSubId = subId;
		registerPrefNetworkModeObserver();
		mTelephonyManager = mTelephonyManager.createForSubscriptionId(
		mPhone.getSubId());
		registerAllowedNetworkTypesListener();
		}
		}
		});

		registerNotificationTypes();
		registerPrefNetworkModeObserver();
		}

		private ContentObserver mPrefNetworkModeObserver = new ContentObserver(this) {
		@Override
		public void onChange(boolean selfChange) {
		handlePrefNetworkModeChanged();
		mAllowedNetworkType = RadioAccessFamily.getNetworkTypeFromRaf(
		(int) mPhone.getAllowedNetworkTypes(
		TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
		mAllowedNetworkTypesChangedListenerListener = new AllowedNetworkTypesChangedListener();
		registerAllowedNetworkTypesListener();
		}
		};

		/**
		* Return preferred network mode observer
		* Return preferred network mode listener
		*/
		@VisibleForTesting
		public ContentObserver getContentObserver() {
		return mPrefNetworkModeObserver;
		public AllowedNetworkTypesChangedListener getAllowedNetworkTypesChangedListener() {
		return mAllowedNetworkTypesChangedListenerListener;
		}

		private void registerPrefNetworkModeObserver() {
		private void registerAllowedNetworkTypesListener() {
		int subId = mPhone.getSubId();
		unregisterPrefNetworkModeObserver();
		unregisterAllowedNetworkTypesListener();
		if (SubscriptionManager.isValidSubscriptionId(subId)) {
		mPhone.getContext().getContentResolver().registerContentObserver(
		Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + subId),
		true,
		mPrefNetworkModeObserver);
		if (mTelephonyManager != null) {
		mTelephonyManager.registerPhoneStateListener(new HandlerExecutor(this),
		mAllowedNetworkTypesChangedListenerListener);
		}
		}
		}

		private void unregisterPrefNetworkModeObserver() {
		mPhone.getContext().getContentResolver().unregisterContentObserver(
		mPrefNetworkModeObserver);
		private void unregisterAllowedNetworkTypesListener() {
		mTelephonyManager.unregisterPhoneStateListener(mAllowedNetworkTypesChangedListenerListener);
		}

		/**
		@@ -196,13 +219,10 @@ public class CarrierServiceStateTracker extends Handler {
		* Returns true if the preferred network is set to 'Global'.
		*/
		private boolean isGlobalMode() {
		Context context = mPhone.getContext();
		int preferredNetworkSetting = -1;
		try {
		preferredNetworkSetting =
		android.provider.Settings.Global.getInt(context.getContentResolver(),
		android.provider.Settings.Global.PREFERRED_NETWORK_MODE
		+ mPhone.getSubId(), Phone.PREFERRED_NT_MODE);
		preferredNetworkSetting = PhoneFactory.calculatePreferredNetworkType(
		mPhone.getPhoneId());
		} catch (Exception e) {
		Rlog.e(LOG_TAG, "Unable to get PREFERRED_NETWORK_MODE.");
		return true;
		@@ -210,9 +230,11 @@ public class CarrierServiceStateTracker extends Handler {

		if (isNrSupported()) {
		return (preferredNetworkSetting
		== RILConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
		== RadioAccessFamily.getRafFromNetworkType(
		RILConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA));
		} else {
		return (preferredNetworkSetting == RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA);
		return (preferredNetworkSetting == RadioAccessFamily.getRafFromNetworkType(
		RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
		}
		}

		@@ -225,7 +247,9 @@ public class CarrierServiceStateTracker extends Handler {
		boolean isRadioAccessFamilySupported = checkSupportedBitmask(
		tm.getSupportedRadioAccessFamily(), TelephonyManager.NETWORK_TYPE_BITMASK_NR);
		boolean isNrNetworkTypeAllowed = checkSupportedBitmask(
		tm.getAllowedNetworkTypes(), TelephonyManager.NETWORK_TYPE_BITMASK_NR);
		tm.getAllowedNetworkTypesForReason(
		TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER),
		TelephonyManager.NETWORK_TYPE_BITMASK_NR);

		Rlog.i(LOG_TAG, "isNrSupported: " + " carrierConfigEnabled: " + isCarrierConfigEnabled
		+ ", AccessFamilySupported: " + isRadioAccessFamilySupported
		@@ -246,7 +270,8 @@ public class CarrierServiceStateTracker extends Handler {
		Rlog.e(LOG_TAG, "isCarrierConfigEnableNr: Cannot get config " + mPhone.getSubId());
		return false;
		}
		return config.getBoolean(CarrierConfigManager.KEY_NR_ENABLED_BOOL);
		return config.getInt(CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITY_INT)
		!= CarrierConfigManager.CARRIER_NR_AVAILABILITY_NONE;
		}

		private boolean checkSupportedBitmask(@NetworkTypeBitMask long supportedBitmask,
		@@ -369,7 +394,7 @@ public class CarrierServiceStateTracker extends Handler {
		* Dispose the CarrierServiceStateTracker.
		*/
		public void dispose() {
		unregisterPrefNetworkModeObserver();
		unregisterAllowedNetworkTypesListener();
		}

		/**

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

+3 −3

Original line number	Diff line number	Diff line
		@@ -1567,15 +1567,15 @@ public interface CommandsInterface {
		* @param networkTypeBitmask {@link TelephonyManager.NetworkTypeBitMask}
		* @param response is callback message
		*/
		void setAllowedNetworkTypeBitmask(
		void setAllowedNetworkTypesBitmap(
		@TelephonyManager.NetworkTypeBitMask int networkTypeBitmask, Message response);

		/**
		* Query the allowed network types setting.
		*
		* @param response is callback message to report one of NT_*_TYPE
		* @param response is callback message to report allowed network types bitmask
		*/
		void getAllowedNetworkTypeBitmask(Message response);
		void getAllowedNetworkTypesBitmap(Message response);

		/**
		* Enable/Disable E-UTRA-NR Dual Connectivity

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

+8 −0

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

		import java.util.List;
		import java.util.Map;

		/**
		* broadcast intents
		@@ -249,6 +250,13 @@ public class DefaultPhoneNotifier implements PhoneNotifier {
		mTelephonyRegistryMgr.notifyDataEnabled(enabled, reason);
		}

		@Override
		public void notifyAllowedNetworkTypesChanged(Phone sender,
		Map<Integer, Long> allowedNetworkTypeList) {
		mTelephonyRegistryMgr.notifyAllowedNetworkTypesChanged(sender.getSubId(),
		sender.getPhoneId(), allowedNetworkTypeList);
		}

		/**
		* Convert the {@link DataActivityState} enum into the TelephonyManager.DATA_* constants for the
		* public API.

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

+78 −57

Original line number	Diff line number	Diff line
		@@ -15,7 +15,6 @@
		*/

		package com.android.internal.telephony;

		import static com.android.internal.telephony.CommandException.Error.GENERIC_FAILURE;
		import static com.android.internal.telephony.CommandException.Error.SIM_BUSY;
		import static com.android.internal.telephony.CommandsInterface.CF_ACTION_DISABLE;
		@@ -70,6 +69,7 @@ import android.telephony.CellIdentity;
		import android.telephony.ImsiEncryptionInfo;
		import android.telephony.NetworkScanRequest;
		import android.telephony.PhoneNumberUtils;
		import android.telephony.RadioAccessFamily;
		import android.telephony.ServiceState;
		import android.telephony.ServiceState.RilRadioTechnology;
		import android.telephony.SignalThresholdInfo;
		@@ -2740,6 +2740,7 @@ 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() {
		@@ -2875,58 +2876,16 @@ public class GsmCdmaPhone extends Phone {
		mCi.getVoiceRadioTechnology(obtainMessage(EVENT_REQUEST_VOICE_RADIO_TECH_DONE));
		}

		// Update broadcastEmergencyCallStateChanges
		CarrierConfigManager configMgr = (CarrierConfigManager)
		getContext().getSystemService(Context.CARRIER_CONFIG_SERVICE);
		PersistableBundle b = configMgr.getConfigForSubId(getSubId());
		if (b != null) {
		boolean broadcastEmergencyCallStateChanges = b.getBoolean(
		CarrierConfigManager.KEY_BROADCAST_EMERGENCY_CALL_STATE_CHANGES_BOOL);
		logd("broadcastEmergencyCallStateChanges = " +
		broadcastEmergencyCallStateChanges);
		setBroadcastEmergencyCallStateChanges(broadcastEmergencyCallStateChanges);
		} else {
		loge("didn't get broadcastEmergencyCallStateChanges from carrier config");
		}

		// Changing the cdma roaming settings based carrier config.
		if (b != null) {
		int config_cdma_roaming_mode = b.getInt(
		CarrierConfigManager.KEY_CDMA_ROAMING_MODE_INT);
		int current_cdma_roaming_mode =
		Settings.Global.getInt(getContext().getContentResolver(),
		Settings.Global.CDMA_ROAMING_MODE,
		TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT);
		switch (config_cdma_roaming_mode) {
		// Carrier's cdma_roaming_mode will overwrite the user's previous settings
		// Keep the user's previous setting in global variable which will be used
		// when carrier's setting is turn off.
		case TelephonyManager.CDMA_ROAMING_MODE_HOME:
		case TelephonyManager.CDMA_ROAMING_MODE_AFFILIATED:
		case TelephonyManager.CDMA_ROAMING_MODE_ANY:
		logd("cdma_roaming_mode is going to changed to "
		+ config_cdma_roaming_mode);
		setCdmaRoamingPreference(config_cdma_roaming_mode,
		obtainMessage(EVENT_SET_ROAMING_PREFERENCE_DONE));
		break;
		updateBroadcastEmergencyCallStateChangesAfterCarrierConfigChanged(b);

		// When carrier's setting is turn off, change the cdma_roaming_mode to the
		// previous user's setting
		case TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT:
		if (current_cdma_roaming_mode != config_cdma_roaming_mode) {
		logd("cdma_roaming_mode is going to changed to "
		+ current_cdma_roaming_mode);
		setCdmaRoamingPreference(current_cdma_roaming_mode,
		obtainMessage(EVENT_SET_ROAMING_PREFERENCE_DONE));
		}
		updateCdmaRoamingSettingsAfterCarrierConfigChanged(b);

		updateNrSettingsAfterCarrierConfigChanged();

		default:
		loge("Invalid cdma_roaming_mode settings: "
		+ config_cdma_roaming_mode);
		}
		} else {
		loge("didn't get the cdma_roaming_mode changes from the carrier config.");
		}
		break;

		case EVENT_SET_ROAMING_PREFERENCE_DONE:
		@@ -3487,7 +3446,8 @@ public class GsmCdmaPhone extends Phone {
		*/
		public boolean shouldForceAutoNetworkSelect() {

		int nwMode = Phone.PREFERRED_NT_MODE;
		int networkTypeBitmask = RadioAccessFamily.getRafFromNetworkType(
		RILConstants.PREFERRED_NETWORK_MODE);
		int subId = getSubId();

		// If it's invalid subId, we shouldn't force to auto network select mode.
		@@ -3495,21 +3455,23 @@ public class GsmCdmaPhone extends Phone {
		return false;
		}

		nwMode = android.provider.Settings.Global.getInt(mContext.getContentResolver(),
		android.provider.Settings.Global.PREFERRED_NETWORK_MODE + subId, nwMode);
		networkTypeBitmask = (int) getAllowedNetworkTypes(
		TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER);

		logd("shouldForceAutoNetworkSelect in mode = " + nwMode);
		logd("shouldForceAutoNetworkSelect in mode = " + networkTypeBitmask);
		/*
		* For multimode targets in global mode manual network
		* selection is disallowed. So we should force auto select mode.
		*/
		if (isManualSelProhibitedInGlobalMode()
		&& ((nwMode == TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)
		\|\| (nwMode == TelephonyManager.NETWORK_MODE_GLOBAL)) ){
		logd("Should force auto network select mode = " + nwMode);
		&& ((networkTypeBitmask == RadioAccessFamily.getRafFromNetworkType(
		TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA))
		\|\| (networkTypeBitmask == RadioAccessFamily.getRafFromNetworkType(
		TelephonyManager.NETWORK_MODE_GLOBAL)))) {
		logd("Should force auto network select mode = " + networkTypeBitmask);
		return true;
		} else {
		logd("Should not force auto network select mode = " + nwMode);
		logd("Should not force auto network select mode = " + networkTypeBitmask);
		}

		/*
		@@ -4621,4 +4583,63 @@ public class GsmCdmaPhone extends Phone {

		return packages;
		}

		private void updateBroadcastEmergencyCallStateChangesAfterCarrierConfigChanged(
		PersistableBundle config) {
		if (config == null) {
		loge("didn't get broadcastEmergencyCallStateChanges from carrier config");
		return;
		}

		// get broadcastEmergencyCallStateChanges
		boolean broadcastEmergencyCallStateChanges = config.getBoolean(
		CarrierConfigManager.KEY_BROADCAST_EMERGENCY_CALL_STATE_CHANGES_BOOL);
		logd("broadcastEmergencyCallStateChanges = " + broadcastEmergencyCallStateChanges);
		setBroadcastEmergencyCallStateChanges(broadcastEmergencyCallStateChanges);
		}

		private void updateNrSettingsAfterCarrierConfigChanged() {
		updateAllowedNetworkTypes(null);
		}

		private void updateCdmaRoamingSettingsAfterCarrierConfigChanged(PersistableBundle config) {
		if (config == null) {
		loge("didn't get the cdma_roaming_mode changes from the carrier config.");
		return;
		}

		// Changing the cdma roaming settings based carrier config.
		int config_cdma_roaming_mode = config.getInt(
		CarrierConfigManager.KEY_CDMA_ROAMING_MODE_INT);
		int current_cdma_roaming_mode =
		Settings.Global.getInt(getContext().getContentResolver(),
		Settings.Global.CDMA_ROAMING_MODE,
		TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT);
		switch (config_cdma_roaming_mode) {
		// Carrier's cdma_roaming_mode will overwrite the user's previous settings
		// Keep the user's previous setting in global variable which will be used
		// when carrier's setting is turn off.
		case TelephonyManager.CDMA_ROAMING_MODE_HOME:
		case TelephonyManager.CDMA_ROAMING_MODE_AFFILIATED:
		case TelephonyManager.CDMA_ROAMING_MODE_ANY:
		logd("cdma_roaming_mode is going to changed to "
		+ config_cdma_roaming_mode);
		setCdmaRoamingPreference(config_cdma_roaming_mode,
		obtainMessage(EVENT_SET_ROAMING_PREFERENCE_DONE));
		break;

		// When carrier's setting is turn off, change the cdma_roaming_mode to the
		// previous user's setting
		case TelephonyManager.CDMA_ROAMING_MODE_RADIO_DEFAULT:
		if (current_cdma_roaming_mode != config_cdma_roaming_mode) {
		logd("cdma_roaming_mode is going to changed to "
		+ current_cdma_roaming_mode);
		setCdmaRoamingPreference(current_cdma_roaming_mode,
		obtainMessage(EVENT_SET_ROAMING_PREFERENCE_DONE));
		}
		break;
		default:
		loge("Invalid cdma_roaming_mode settings: " + config_cdma_roaming_mode);
		}
		}
		}

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

+170 −85

File changed.

Preview size limit exceeded, changes collapsed.