Removed TelephonyNetworkFactory (843c3b07) · Commits · e / os / android_frameworks_opt_telephony

flags/data.aconfig

+0 −11

Original line number	Diff line number	Diff line
		@@ -110,17 +110,6 @@ flag {
		bug:"353723350"
		}

		# OWNER=jackyu TARGET=25Q1
		flag {
		name: "support_network_provider"
		namespace: "telephony"
		description: "Deprecate network factory and adapt the new network provider model from connectivity service"
		bug: "343370895"
		metadata {
		purpose: PURPOSE_BUGFIX
		}
		}

		# OWNER=jackyu TARGET=25Q2
		flag {
		name: "oem_paid_private"

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

+5 −65

Original line number	Diff line number	Diff line
		@@ -45,7 +45,6 @@ import android.util.LocalLog;
		import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager;
		import com.android.internal.telephony.data.CellularNetworkValidator;
		import com.android.internal.telephony.data.PhoneSwitcher;
		import com.android.internal.telephony.data.TelephonyNetworkFactory;
		import com.android.internal.telephony.data.TelephonyNetworkProvider;
		import com.android.internal.telephony.euicc.EuiccCardController;
		import com.android.internal.telephony.euicc.EuiccController;
		@@ -78,7 +77,7 @@ public class PhoneFactory {

		//***** Class Variables

		// lock sLockProxyPhones protects sPhones, sPhone and sTelephonyNetworkFactories
		// lock sLockProxyPhones protects sPhones, sPhone
		final static Object sLockProxyPhones = new Object();
		static private Phone[] sPhones = null;
		static private Phone sPhone = null;
		@@ -101,7 +100,6 @@ public class PhoneFactory {
		static private PhoneConfigurationManager sPhoneConfigurationManager;
		static private SimultaneousCallingTracker sSimultaneousCallingTracker;
		static private PhoneSwitcher sPhoneSwitcher;
		static private TelephonyNetworkFactory[] sTelephonyNetworkFactories;
		private static TelephonyNetworkProvider sTelephonyNetworkProvider;
		static private NotificationChannelController sNotificationChannelController;
		static private CellularNetworkValidator sCellularNetworkValidator;
		@@ -179,7 +177,6 @@ public class PhoneFactory {
		int[] networkModes = new int[numPhones];
		sPhones = new Phone[numPhones];
		sCommandsInterfaces = new RIL[numPhones];
		sTelephonyNetworkFactories = new TelephonyNetworkFactory[numPhones];

		for (int i = 0; i < numPhones; i++) {
		// reads the system properties and makes commandsinterface
		@@ -287,16 +284,9 @@ public class PhoneFactory {

		sNotificationChannelController = new NotificationChannelController(context);

		if (featureFlags.supportNetworkProvider()) {
		// Create the TelephonyNetworkProvider instance, which is a singleton.
		sTelephonyNetworkProvider = new TelephonyNetworkProvider(Looper.myLooper(),
		context, featureFlags);
		} else {
		for (int i = 0; i < numPhones; i++) {
		sTelephonyNetworkFactories[i] = new TelephonyNetworkFactory(
		Looper.myLooper(), sPhones[i], featureFlags);
		}
		}
		}
		}
		}
		@@ -313,7 +303,6 @@ public class PhoneFactory {
		int prevActiveModemCount = sPhones.length;
		if (prevActiveModemCount == activeModemCount) return;

		// TODO: clean up sPhones, sCommandsInterfaces and sTelephonyNetworkFactories objects.
		// Currently we will not clean up the 2nd Phone object, so that it can be re-used if
		// user switches back.
		if (prevActiveModemCount > activeModemCount) return;
		@@ -321,10 +310,6 @@ public class PhoneFactory {
		sPhones = copyOf(sPhones, activeModemCount);
		sCommandsInterfaces = copyOf(sCommandsInterfaces, activeModemCount);

		if (!sFeatureFlags.supportNetworkProvider()) {
		sTelephonyNetworkFactories = copyOf(sTelephonyNetworkFactories, activeModemCount);
		}

		int cdmaSubscription = CdmaSubscriptionSourceManager.getDefault(context);
		for (int i = prevActiveModemCount; i < activeModemCount; i++) {
		sCommandsInterfaces[i] = new RIL(context, RadioAccessFamily.getRafFromNetworkType(
		@@ -335,11 +320,6 @@ public class PhoneFactory {
		PackageManager.FEATURE_TELEPHONY_IMS)) {
		sPhones[i].createImsPhone();
		}

		if (!sFeatureFlags.supportNetworkProvider()) {
		sTelephonyNetworkFactories[i] = new TelephonyNetworkFactory(
		Looper.myLooper(), sPhones[i], sFeatureFlags);
		}
		}
		}
		}
		@@ -411,36 +391,6 @@ public class PhoneFactory {
		return sTelephonyNetworkProvider;
		}

		/**
		* Get the network factory associated with a given phone ID.
		* @param phoneId the phone id
		* @return a factory for this phone ID, or null if none.
		*/
		public static TelephonyNetworkFactory getNetworkFactory(int phoneId) {
		synchronized (sLockProxyPhones) {
		if (!sMadeDefaults) {
		throw new IllegalStateException("Default phones haven't been made yet!");
		}
		final String dbgInfo;
		if (phoneId == SubscriptionManager.DEFAULT_PHONE_INDEX) {
		dbgInfo = "getNetworkFactory with DEFAULT_PHONE_ID => factory for sPhone";
		phoneId = sPhone.getSubId();
		} else {
		dbgInfo = "getNetworkFactory with non-default, return factory for passed id";
		}
		// sTelephonyNetworkFactories is null in tests because in tests makeDefaultPhones()
		// is not called.
		final TelephonyNetworkFactory factory = (sTelephonyNetworkFactories != null
		&& (phoneId >= 0 && phoneId < sTelephonyNetworkFactories.length))
		? sTelephonyNetworkFactories[phoneId] : null;
		if (DBG) {
		Rlog.d(LOG_TAG, "getNetworkFactory:-" + dbgInfo + " phoneId=" + phoneId
		+ " factory=" + factory);
		}
		return factory;
		}
		}

		/**
		* Returns the preferred network type bitmask that should be set in the modem.
		*
		@@ -596,20 +546,10 @@ public class PhoneFactory {

		pw.flush();
		pw.println("++++++++++++++++++++++++++++++++");

		if (!sFeatureFlags.supportNetworkProvider()) {
		sTelephonyNetworkFactories[i].dump(fd, pw, args);
		}

		pw.flush();
		pw.decreaseIndent();
		pw.println("++++++++++++++++++++++++++++++++");
		}

		pw.increaseIndent();
		if (sFeatureFlags.supportNetworkProvider()) {
		sTelephonyNetworkProvider.dump(fd, pw, args);
		}
		pw.decreaseIndent();
		pw.println("++++++++++++++++++++++++++++++++");

src/java/com/android/internal/telephony/data/DataNetwork.java

+12 −28

Original line number	Diff line number	Diff line
		@@ -29,7 +29,6 @@ import android.net.LinkProperties;
		import android.net.NetworkAgent;
		import android.net.NetworkAgentConfig;
		import android.net.NetworkCapabilities;
		import android.net.NetworkFactory;
		import android.net.NetworkProvider;
		import android.net.NetworkRequest;
		import android.net.NetworkScore;
		@@ -1180,21 +1179,13 @@ public class DataNetwork extends StateMachine {
		}

		NetworkProvider provider;
		if (mFlags.supportNetworkProvider()) {
		provider = PhoneFactory.getNetworkProvider();
		} else {
		final NetworkFactory factory = PhoneFactory.getNetworkFactory(
		mPhone.getPhoneId());
		provider = (null == factory) ? null : factory.getProvider();
		}

		NetworkScore.Builder builder = new NetworkScore.Builder()
		.setKeepConnectedReason(isHandoverInProgress()
		? NetworkScore.KEEP_CONNECTED_FOR_HANDOVER
		: NetworkScore.KEEP_CONNECTED_NONE);
		if (mFlags.supportNetworkProvider()) {
		builder.setTransportPrimary(mOnPreferredDataPhone);
		}
		mNetworkScore = builder.build();
		logl("mNetworkScore: isPrimary=" + mNetworkScore.isTransportPrimary()
		+ ", keepConnectedReason=" + mNetworkScore.getKeepConnectedReason());
		@@ -1259,7 +1250,6 @@ public class DataNetwork extends StateMachine {
		mDataNetworkController.getDataSettingsManager()
		.registerCallback(mDataSettingsManagerCallback);

		if (mFlags.supportNetworkProvider()) {
		mPhoneSwitcherCallback = new PhoneSwitcherCallback(Runnable::run) {
		@Override
		public void onPreferredDataPhoneIdChanged(int phoneId) {
		@@ -1267,7 +1257,6 @@ public class DataNetwork extends StateMachine {
		}
		};
		mPhoneSwitcher.registerCallback(mPhoneSwitcherCallback);
		}

		mPhone.getDisplayInfoController().registerForTelephonyDisplayInfoChanged(
		getHandler(), EVENT_DISPLAY_INFO_CHANGED, null);
		@@ -1360,9 +1349,7 @@ public class DataNetwork extends StateMachine {
		mPhone.getServiceStateTracker().unregisterForServiceStateChanged(getHandler());
		mPhone.getDisplayInfoController().unregisterForTelephonyDisplayInfoChanged(
		getHandler());
		if (mFlags.supportNetworkProvider()) {
		mPhoneSwitcher.unregisterCallback(mPhoneSwitcherCallback);
		}
		mDataNetworkController.getDataSettingsManager()
		.unregisterCallback(mDataSettingsManagerCallback);
		mRil.unregisterForPcoData(getHandler());
		@@ -3373,13 +3360,10 @@ public class DataNetwork extends StateMachine {
		int connectedReason = keepConnectedForHandover
		? NetworkScore.KEEP_CONNECTED_FOR_HANDOVER : NetworkScore.KEEP_CONNECTED_NONE;
		if (mNetworkScore.getKeepConnectedReason() != connectedReason
		\|\| (mFlags.supportNetworkProvider()
		&& mNetworkScore.isTransportPrimary() != mOnPreferredDataPhone)) {
		\|\| mNetworkScore.isTransportPrimary() != mOnPreferredDataPhone) {
		NetworkScore.Builder builder = new NetworkScore.Builder()
		.setKeepConnectedReason(connectedReason);
		if (mFlags.supportNetworkProvider()) {
		builder.setTransportPrimary(mOnPreferredDataPhone);
		}
		mNetworkScore = builder.build();
		mNetworkAgent.sendNetworkScore(mNetworkScore);
		logl("updateNetworkScore: isPrimary=" + mNetworkScore.isTransportPrimary()

src/java/com/android/internal/telephony/data/DataNetworkController.java

+13 −39

Original line number	Diff line number	Diff line
		@@ -2530,7 +2530,6 @@ public class DataNetworkController extends Handler {
		}

		private void onRemoveNetworkRequest(@NonNull TelephonyNetworkRequest request) {
		if (mFeatureFlags.supportNetworkProvider()) {
		if (!mAllNetworkRequestList.remove(request)) {
		loge("onRemoveNetworkRequest: Network request does not exist. " + request);
		return;
		@@ -2554,31 +2553,6 @@ public class DataNetworkController extends Handler {
		return;
		}

		// The request generated from telephony network factory does not contain the information
		// the original request has, for example, attached data network. We need to find the
		// original one.
		TelephonyNetworkRequest networkRequest = mAllNetworkRequestList.stream()
		.filter(r -> r.equals(request))
		.findFirst()
		.orElse(null);
		if (networkRequest == null \|\| !mAllNetworkRequestList.remove(networkRequest)) {
		loge("onRemoveNetworkRequest: Network request does not exist. " + networkRequest);
		return;
		}

		if (networkRequest.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) {
		mImsThrottleCounter.addOccurrence();
		mLastReleasedImsRequestCapabilities = networkRequest.getCapabilities();
		mLastImsOperationIsRelease = true;
		}

		if (networkRequest.getAttachedNetwork() != null) {
		networkRequest.getAttachedNetwork().detachNetworkRequest(
		networkRequest, false /* shouldRetry */);
		}
		log("onRemoveNetworkRequest: Removed " + networkRequest);
		}

		/**
		* Check if the network request is existing. Note this method is not thread safe so can be only
		* called within the modules in {@link com.android.internal.telephony.data}.

src/java/com/android/internal/telephony/data/PhoneSwitcher.java

+8 −110

Original line number	Diff line number	Diff line
		@@ -38,10 +38,8 @@ import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.net.ConnectivityManager;
		import android.net.MatchAllNetworkSpecifier;
		import android.net.Network;
		import android.net.NetworkCapabilities;
		import android.net.NetworkFactory;
		import android.net.NetworkRequest;
		import android.net.NetworkSpecifier;
		import android.net.TelephonyNetworkSpecifier;
		@@ -50,7 +48,6 @@ import android.os.Handler;
		import android.os.Looper;
		import android.os.Message;
		import android.os.PersistableBundle;
		import android.os.Registrant;
		import android.os.RegistrantList;
		import android.os.RemoteException;
		import android.telephony.CarrierConfigManager;
		@@ -88,7 +85,6 @@ import com.android.internal.telephony.imsphone.ImsPhone;
		import com.android.internal.telephony.metrics.TelephonyMetrics;
		import com.android.internal.telephony.nano.TelephonyProto.TelephonyEvent;
		import com.android.internal.telephony.nano.TelephonyProto.TelephonyEvent.DataSwitch;
		import com.android.internal.telephony.nano.TelephonyProto.TelephonyEvent.OnDemandDataSwitch;
		import com.android.internal.telephony.subscription.SubscriptionInfoInternal;
		import com.android.internal.telephony.subscription.SubscriptionManagerService;
		import com.android.internal.telephony.subscription.SubscriptionManagerService.SubscriptionManagerServiceCallback;
		@@ -267,7 +263,7 @@ public class PhoneSwitcher extends Handler {
		@VisibleForTesting
		// It decides:
		// 1. In modem layer, which modem is DDS (preferred to have data traffic on)
		// 2. In TelephonyNetworkFactory, which subscription will apply default network requests, which
		// 2. In TelephonyNetworkProvider, which subscription will apply default network requests, which
		// are requests without specifying a subId.
		// Corresponding phoneId after considering mOpptDataSubId, mPrimaryDataSubId and
		// mPhoneIdInVoiceCall above.
		@@ -290,8 +286,6 @@ public class PhoneSwitcher extends Handler {

		private static final int EVENT_PRIMARY_DATA_SUB_CHANGED = 101;
		protected static final int EVENT_SUBSCRIPTION_CHANGED = 102;
		private static final int EVENT_REQUEST_NETWORK = 103;
		private static final int EVENT_RELEASE_NETWORK = 104;
		// ECBM has started/ended. If we just ended an emergency call and mEmergencyOverride is not
		// null, we will wait for EVENT_EMERGENCY_TOGGLE again with ECBM ending to send the message
		// EVENT_REMOVE_DDS_EMERGENCY_OVERRIDE to remove the override after the mEmergencyOverride
		@@ -651,37 +645,6 @@ public class PhoneSwitcher extends Handler {
		this, EVENT_MULTI_SIM_CONFIG_CHANGED, null);

		mConnectivityManager.registerDefaultNetworkCallback(mDefaultNetworkCallback, this);

		if (!mFlags.supportNetworkProvider()) {
		final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder()
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.addCapability(NetworkCapabilities.NET_CAPABILITY_IA)
		.addCapability(NetworkCapabilities.NET_CAPABILITY_MMTEL)
		.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
		.addEnterpriseId(NetworkCapabilities.NET_ENTERPRISE_ID_1)
		.addEnterpriseId(NetworkCapabilities.NET_ENTERPRISE_ID_2)
		.addEnterpriseId(NetworkCapabilities.NET_ENTERPRISE_ID_3)
		.addEnterpriseId(NetworkCapabilities.NET_ENTERPRISE_ID_4)
		.addEnterpriseId(NetworkCapabilities.NET_ENTERPRISE_ID_5)
		.setNetworkSpecifier(new MatchAllNetworkSpecifier());
		TelephonyNetworkRequest.getAllSupportedNetworkCapabilities()
		.forEach(builder::addCapability);

		if (mFlags.satelliteInternet()) {
		// TODO: b/328622096 remove the try/catch
		try {
		builder.addTransportType(NetworkCapabilities.TRANSPORT_SATELLITE);
		} catch (IllegalArgumentException exception) {
		loge("TRANSPORT_SATELLITE is not supported.");
		}
		}

		NetworkFactory networkFactory = new PhoneSwitcherNetworkRequestListener(looper, context,
		builder.build(), this);
		// we want to see all requests
		networkFactory.registerIgnoringScore();
		}

		updateHalCommandToUse();

		logl("PhoneSwitcher started");
		@@ -750,14 +713,6 @@ public class PhoneSwitcher extends Handler {
		DataSwitch.Reason.DATA_SWITCH_REASON_MANUAL);
		break;
		}
		case EVENT_REQUEST_NETWORK: {
		onRequestNetwork((NetworkRequest)msg.obj);
		break;
		}
		case EVENT_RELEASE_NETWORK: {
		onReleaseNetwork((NetworkRequest)msg.obj);
		break;
		}
		case EVENT_EMERGENCY_TOGGLE: {
		boolean isInEcm = isInEmergencyCallbackMode();
		if (mEmergencyOverride != null) {
		@@ -1100,43 +1055,15 @@ public class PhoneSwitcher extends Handler {
		return false;
		}

		// TODO: Remove after removing TelephonyNetworkFactory
		private static class PhoneSwitcherNetworkRequestListener extends NetworkFactory {
		private final PhoneSwitcher mPhoneSwitcher;
		public PhoneSwitcherNetworkRequestListener (Looper l, Context c,
		NetworkCapabilities nc, PhoneSwitcher ps) {
		super(l, c, "PhoneSwitcherNetworkRequestListener", nc);
		mPhoneSwitcher = ps;
		}

		@Override
		protected void needNetworkFor(@NonNull NetworkRequest networkRequest) {
		if (VDBG) log("needNetworkFor " + networkRequest);
		Message msg = mPhoneSwitcher.obtainMessage(EVENT_REQUEST_NETWORK);
		msg.obj = networkRequest;
		msg.sendToTarget();
		}

		@Override
		protected void releaseNetworkFor(@NonNull NetworkRequest networkRequest) {
		if (VDBG) log("releaseNetworkFor " + networkRequest);
		Message msg = mPhoneSwitcher.obtainMessage(EVENT_RELEASE_NETWORK);
		msg.obj = networkRequest;
		msg.sendToTarget();
		}
		}

		/**
		* Called when receiving a network request.
		*
		* @param networkRequest The network request.
		*/
		// TODO: Transform to TelephonyNetworkRequest after removing TelephonyNetworkFactory
		public void onRequestNetwork(@NonNull NetworkRequest networkRequest) {
		TelephonyNetworkRequest telephonyNetworkRequest = new TelephonyNetworkRequest(
		networkRequest, PhoneFactory.getDefaultPhone(), mFlags);
		if (!mNetworkRequestList.contains(telephonyNetworkRequest)) {
		mNetworkRequestList.add(telephonyNetworkRequest);
		public void onRequestNetwork(@NonNull TelephonyNetworkRequest networkRequest) {
		if (!mNetworkRequestList.contains(networkRequest)) {
		mNetworkRequestList.add(networkRequest);
		onEvaluate(REQUESTS_CHANGED, "netRequest");
		}
		}
		@@ -1146,13 +1073,9 @@ public class PhoneSwitcher extends Handler {
		*
		* @param networkRequest The network request to release.
		*/
		// TODO: Transform to TelephonyNetworkRequest after removing TelephonyNetworkFactory
		public void onReleaseNetwork(@NonNull NetworkRequest networkRequest) {
		TelephonyNetworkRequest telephonyNetworkRequest = new TelephonyNetworkRequest(
		networkRequest, PhoneFactory.getDefaultPhone(), mFlags);
		if (mNetworkRequestList.remove(telephonyNetworkRequest)) {
		public void onReleaseNetwork(@NonNull TelephonyNetworkRequest networkRequest) {
		if (mNetworkRequestList.remove(networkRequest)) {
		onEvaluate(REQUESTS_CHANGED, "netReleased");
		collectReleaseNetworkMetrics(networkRequest);
		}
		}

		@@ -1161,18 +1084,6 @@ public class PhoneSwitcher extends Handler {
		mDefaultNetworkCallback.mSwitchReason = reason;
		}

		private void collectReleaseNetworkMetrics(NetworkRequest networkRequest) {
		// Release network for MMS will recover the network on default data subscription, this only
		// happen on multi-sim device.
		if (mActiveModemCount > 1 && networkRequest.hasCapability(
		NetworkCapabilities.NET_CAPABILITY_MMS)) {
		OnDemandDataSwitch onDemandDataSwitch = new OnDemandDataSwitch();
		onDemandDataSwitch.apn = TelephonyEvent.ApnType.APN_TYPE_MMS;
		onDemandDataSwitch.state = TelephonyEvent.EventState.EVENT_STATE_END;
		TelephonyMetrics.getInstance().writeOnDemandDataSwitch(onDemandDataSwitch);
		}
		}

		/**
		* Cancel any auto switch attempts when the current environment is not suitable for auto switch.
		*/
		@@ -1609,17 +1520,6 @@ public class PhoneSwitcher extends Handler {
		return mPhoneStates[phoneId].active;
		}

		/**
		* If preferred phone changes, or phone activation status changes, registrants
		* will be notified.
		*/
		// TODO: Remove after removing TelephonyNetworkFactory
		public void registerForActivePhoneSwitch(Handler h, int what, Object o) {
		Registrant r = new Registrant(h, what, o);
		mActivePhoneRegistrants.add(r);
		r.notifyRegistrant();
		}

		/**
		* Set opportunistic data subscription. It's an indication to switch Internet data to this
		* subscription. It has to be an active subscription, and PhoneSwitcher will try to validate
		@@ -2037,11 +1937,9 @@ public class PhoneSwitcher extends Handler {
		// Notify all registrants
		mActivePhoneRegistrants.notifyRegistrants();
		notifyPreferredDataSubIdChanged();
		if (mFlags.supportNetworkProvider()) {
		mPhoneSwitcherCallbacks.forEach(callback -> callback.invokeFromExecutor(
		() -> callback.onPreferredDataPhoneIdChanged(phoneId)));
		}
		}

		private boolean isPhoneIdValidForRetry(int phoneId) {
		int ddsPhoneId = mSubscriptionManagerService.getPhoneId(