Update DataConfigManager methods (61952ab2) · Commits · e / os / android_frameworks_opt_telephony

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

+24 −26

Original line number	Diff line number	Diff line
		@@ -68,6 +68,7 @@ import java.util.stream.Collectors;
		* {@link CarrierConfigManager}. All the data config will be loaded once and stored here.
		*/
		public class DataConfigManager extends Handler {
		/** Event for carrier config changed. */
		private static final int EVENT_CARRIER_CONFIG_CHANGED = 1;

		/** Indicates the bandwidth estimation source is from the modem. */
		@@ -199,16 +200,18 @@ public class DataConfigManager extends Handler {
		/** The data retry rules */
		private @NonNull final List<DataRetryRule> mDataRetryRules = new ArrayList<>();
		/** The metered APN types for home network */
		private @NonNull final @ApnType List<Integer> mMeteredApnTypes = new ArrayList<>();
		private @NonNull final @ApnType Set<Integer> mMeteredApnTypes = new HashSet<>();
		/** The metered APN types for roaming network */
		private @NonNull final @ApnType List<Integer> mRoamingMeteredApnTypes =
		new ArrayList<>();
		private @NonNull final @ApnType Set<Integer> mRoamingMeteredApnTypes = new HashSet<>();
		/** The network types that only support single data networks */
		private @NonNull final @NetworkType List<Integer> mSingleDataNetworkTypeList =
		new ArrayList<>();
		/** The network types that support temporarily not metered */
		private @NonNull final @DataConfigNetworkType Set<String> mUnmeteredNetworkTypes =
		new HashSet<>();
		/** The network types that support temporarily not metered when roaming */
		private @NonNull final @DataConfigNetworkType Set<String> mRoamingUnmeteredNetworkTypes =
		new HashSet<>();
		/** A map of network types to the downlink and uplink bandwidth values for that network type */
		private @NonNull final @DataConfigNetworkType Map<String, DataNetwork.NetworkBandwidth>
		mBandwidthMap = new ConcurrentHashMap<>();
		@@ -405,17 +408,15 @@ public class DataConfigManager extends Handler {
		/**
		* @return The metered APN types when connected to a home network
		*/
		public @NonNull @ApnType List<Integer> getMeteredApnTypes() {
		// TODO: return as set instead of list
		return Collections.unmodifiableList(mMeteredApnTypes);
		public @NonNull @ApnType Set<Integer> getMeteredApnTypes() {
		return Collections.unmodifiableSet(mMeteredApnTypes);
		}

		/**
		* @return The metered APN types when roaming
		*/
		public @NonNull @ApnType List<Integer> getMeteredApnTypesWhenRoaming() {
		// TODO: return as set instead of list
		return Collections.unmodifiableList(mRoamingMeteredApnTypes);
		public @NonNull @ApnType Set<Integer> getMeteredApnTypesWhenRoaming() {
		return Collections.unmodifiableSet(mRoamingMeteredApnTypes);
		}

		/**
		@@ -436,12 +437,9 @@ public class DataConfigManager extends Handler {
		CarrierConfigManager.KEY_ONLY_SINGLE_DC_ALLOWED_INT_ARRAY);
		if (singleDataNetworkTypeList != null) {
		Arrays.stream(singleDataNetworkTypeList)
		.map(ServiceState::rilRadioTechnologyToNetworkType)
		.distinct()
		.forEach(mSingleDataNetworkTypeList::add);
		}
		}

		}

		/**
		@@ -471,28 +469,28 @@ public class DataConfigManager extends Handler {
		if (unmeteredNetworkTypes != null) {
		mUnmeteredNetworkTypes.addAll(Arrays.asList(unmeteredNetworkTypes));
		}
		mRoamingUnmeteredNetworkTypes.clear();
		String[] roamingUnmeteredNetworkTypes = mCarrierConfig.getStringArray(
		CarrierConfigManager.KEY_ROAMING_UNMETERED_NETWORK_TYPES_STRING_ARRAY);
		if (roamingUnmeteredNetworkTypes != null) {
		mRoamingUnmeteredNetworkTypes.addAll(Arrays.asList(roamingUnmeteredNetworkTypes));
		}
		}
		}

		/**
		* Get the meteredness for the network type from the carrier config.
		* Get whether the network type is unmetered from the carrier configs.
		*
		* @param networkType The network type to check meteredness for
		* @param serviceState The service state, used to determine NR state
		* @return Whether the carrier considers the given network type unmetered
		*/
		public boolean isNetworkTypeUnmeteredByCarrier(@NetworkType int networkType,
		public boolean isNetworkTypeUnmetered(@NetworkType int networkType,
		@NonNull ServiceState serviceState) {
		return mUnmeteredNetworkTypes.contains(
		getDataConfigNetworkType(networkType, serviceState));
		}

		/**
		* @return Whether NR is considered unmetered by the carrier when roaming
		*/
		public boolean isNrUnmeteredWhenRoaming() {
		return mCarrierConfig.getBoolean(
		CarrierConfigManager.KEY_UNMETERED_NR_NSA_WHEN_ROAMING_BOOL);
		String dataConfigNetworkType = getDataConfigNetworkType(networkType, serviceState);
		return serviceState.getDataRoaming()
		? mRoamingUnmeteredNetworkTypes.contains(dataConfigNetworkType)
		: mUnmeteredNetworkTypes.contains(dataConfigNetworkType);
		}

		/**
		@@ -580,7 +578,6 @@ public class DataConfigManager extends Handler {
		* @return The default MTU value in bytes from the carrier config.
		*/
		public int getDefaultMtu() {
		// TODO: Move values from mcc/mnc overlays to carrier configs
		return mCarrierConfig.getInt(CarrierConfigManager.KEY_DEFAULT_MTU_INT);
		}

		@@ -623,7 +620,6 @@ public class DataConfigManager extends Handler {
		*/
		public @Nullable String getTcpConfigString(@NetworkType int networkType,
		@NonNull ServiceState serviceState) {
		// TODO: Move values from mcc/mnc overlays to carrier configs
		return mTcpBufferSizeMap.get(getDataConfigNetworkType(networkType, serviceState));
		}

		@@ -829,6 +825,8 @@ public class DataConfigManager extends Handler {
		pw.println("Single data network types=" + mSingleDataNetworkTypeList.stream()
		.map(TelephonyManager::getNetworkTypeName).collect(Collectors.joining(",")));
		pw.println("Unmetered network types=" + String.join(",", mUnmeteredNetworkTypes));
		pw.println("Roaming unmetered network types="
		+ String.join(",", mRoamingUnmeteredNetworkTypes));
		pw.println("Bandwidths:");
		pw.increaseIndent();
		mBandwidthMap.forEach((key, value) -> pw.println(key + ":" + value));

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

+65 −10

Original line number	Diff line number	Diff line
		@@ -367,6 +367,18 @@ public class DataNetwork extends StateMachine {
		/** The network bandwidth. */
		private @NonNull NetworkBandwidth mNetworkBandwidth = new NetworkBandwidth(14, 14);

		/** The TCP buffer sizes config. */
		private @Nullable String mTcpBufferSizes = "";

		/** Whether {@link NetworkCapabilities#NET_CAPABILITY_TEMPORARILY_NOT_METERED} is supported. */
		private boolean mTempNotMeteredSupported = false;

		/** Whether the current data network is temporarily not metered. */
		private boolean mTempNotMetered = false;

		/** Whether the current data network is congested. */
		private boolean mCongested = false;

		/** The network requests associated with this data network */
		private @NonNull NetworkRequestList mAttachedNetworkRequestList = new NetworkRequestList();

		@@ -666,8 +678,8 @@ public class DataNetwork extends StateMachine {
		// TODO: Should update suspend state when CSS indicator changes.
		// TODO: Should update suspend state when call started/ended.
		updateSuspendState();
		// TODO: Update TCP buffer size
		// TODO: Update Bandwidth
		updateTcpBufferSizes();
		updateBandwidthFromDataConfig();
		break;
		}
		case EVENT_ATTACH_NETWORK_REQUEST: {
		@@ -1041,14 +1053,20 @@ public class DataNetwork extends StateMachine {
		private void updateNetworkCapabilities() {
		final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder()
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
		boolean roaming = mPhone.getServiceState().getDataRoaming();

		builder.setNetworkSpecifier(new TelephonyNetworkSpecifier.Builder()
		.setSubscriptionId(mSubId).build());
		builder.setSubscriptionIds(Collections.singleton(mSubId));

		ApnSetting apnSetting = mDataProfile.getApnSetting();
		boolean meteredApn = false;
		if (apnSetting != null) {
		for (int apnType : apnSetting.getApnTypes()) {
		if (!(roaming ? mDataConfigManager.getMeteredApnTypesWhenRoaming()
		: mDataConfigManager.getMeteredApnTypes()).contains(apnType)) {
		meteredApn = true;
		}
		int cap = DataUtils.apnTypeToNetworkCapability(apnType);
		if (cap >= 0) {
		builder.addCapability(cap);
		@@ -1056,16 +1074,24 @@ public class DataNetwork extends StateMachine {
		}
		}

		// TODO: Support NET_CAPABILITY_NOT_METERED
		// TODO: Support NET_CAPABILITY_NOT_METERED when non-restricted data is for unmetered use
		if (!meteredApn) {
		builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
		}
		// TODO: Support NET_CAPABILITY_NOT_RESTRICTED
		// TODO: Support NET_CAPABILITY_NOT_CONGESTED correctly
		if (!mCongested) {
		builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
		}

		// TODO: Support NET_CAPABILITY_TEMPORARILY_NOT_METERED
		// TODO: Support NET_CAPABILITY_TEMPORARILY_NOT_METERED correctly
		if (mTempNotMeteredSupported && mTempNotMetered) {
		builder.addCapability(NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED);
		}
		// TODO: Support NET_CAPABILITY_NOT_VCN_MANAGED correctly
		builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED);

		if (!mPhone.getServiceState().getDataRoaming()) {
		if (!roaming) {
		builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
		}

		@@ -1357,8 +1383,7 @@ public class DataNetwork extends StateMachine {
		linkProperties.setHttpProxy(proxy);
		}

		// updateTcpBufferSizes
		linkProperties.setTcpBufferSizes(getTcpConfig());
		linkProperties.setTcpBufferSizes(mTcpBufferSizes);

		mQosBearerSessions = response.getQosBearerSessions();
		if (mQosCallbackTracker != null) {
		@@ -1579,6 +1604,8 @@ public class DataNetwork extends StateMachine {
		log("onDataConfigUpdated");

		updateBandwidthFromDataConfig();
		updateTcpBufferSizes();
		updateMeteredAndCongested();
		}

		/**
		@@ -1643,8 +1670,8 @@ public class DataNetwork extends StateMachine {
		*/
		private void onDisplayInfoChanged() {
		updateBandwidthFromDataConfig();

		// TODO: Update meteredness flags.
		updateTcpBufferSizes();
		updateMeteredAndCongested();
		}

		/**
		@@ -1661,6 +1688,30 @@ public class DataNetwork extends StateMachine {
		updateNetworkCapabilities();
		}

		/**
		* Update the TCP buffer sizes from carrier configs.
		*/
		private void updateTcpBufferSizes() {
		log("updateTcpBufferSizes");
		mTcpBufferSizes = getTcpConfig();
		LinkProperties linkProperties = new LinkProperties(mLinkProperties);
		linkProperties.setTcpBufferSizes(mTcpBufferSizes);
		if (!linkProperties.equals(mLinkProperties)) {
		mLinkProperties = linkProperties;
		log("sendLinkProperties " + mLinkProperties);
		mNetworkAgent.sendLinkProperties(mLinkProperties);
		}
		}

		/**
		* Update the metered and congested values from carrier configs and subscription overrides
		*/
		private void updateMeteredAndCongested() {
		log("updateMeteredAndCongested");
		mTempNotMeteredSupported = mDataConfigManager.isTempNotMeteredSupportedByCarrier();
		// TODO: set mTempNotMetered and mCongested based on SubscriptionPlans and overrides
		}

		/**
		* @return The unique context id assigned by the data service in
		* {@link DataCallResponse#getId()}.
		@@ -1971,6 +2022,10 @@ public class DataNetwork extends StateMachine {
		pw.println("mNetworkCapabilities" + mNetworkCapabilities);
		pw.println("mLinkProperties=" + mLinkProperties);
		pw.println("mNetworkBandwidth=" + mNetworkBandwidth);
		pw.println("mTcpBufferSizes=" + mTcpBufferSizes);
		pw.println("mTempNotMeteredSupported=" + mTempNotMeteredSupported);
		pw.println("mTempNotMetered=" + mTempNotMetered);
		pw.println("mCongested=" + mCongested);
		pw.println("mDataCallResponse=" + mDataCallResponse);

		pw.println("Attached network requests:");

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -1206,7 +1206,7 @@ public class DataNetworkController extends Handler {
		if (transport == AccessNetworkConstants.TRANSPORT_TYPE_WLAN) {
		evaluation.addDataAllowedReason(DataAllowedReason.UNMETERED_USAGE);
		} else if (transport == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) {
		List<Integer> meteredApns = mServiceState.getDataRoaming()
		Set<Integer> meteredApns = mServiceState.getDataRoaming()
		? mDataConfigManager.getMeteredApnTypesWhenRoaming()
		: mDataConfigManager.getMeteredApnTypes();
		boolean unmetered = !meteredApns.isEmpty() && apnTypes.length != 0;

src/java/com/android/internal/telephony/dataconnection/DcTracker.java

+10 −4

Original line number	Diff line number	Diff line
		@@ -2381,6 +2381,7 @@ public class DcTracker extends Handler {
		* @return true if only single DataConnection is allowed
		*/
		private boolean isOnlySingleDcAllowed(int rilRadioTech) {
		int networkType = ServiceState.rilRadioTechnologyToNetworkType(rilRadioTech);
		// Default single dc rats with no knowledge of carrier
		int[] singleDcRats = null;
		// get the carrier specific value, if it exists, from CarrierConfigManager.
		@@ -2401,12 +2402,17 @@ public class DcTracker extends Handler {
		onlySingleDcAllowed = true;
		}
		if (singleDcRats != null) {
		for (int i=0; i < singleDcRats.length && onlySingleDcAllowed == false; i++) {
		if (rilRadioTech == singleDcRats[i]) onlySingleDcAllowed = true;
		for (int i = 0; i < singleDcRats.length && !onlySingleDcAllowed; i++) {
		if (networkType == singleDcRats[i]) {
		onlySingleDcAllowed = true;
		}
		}
		}

		if (DBG) log("isOnlySingleDcAllowed(" + rilRadioTech + "): " + onlySingleDcAllowed);
		if (DBG) {
		log("isOnlySingleDcAllowed(" + TelephonyManager.getNetworkTypeName(networkType) + "): "
		+ onlySingleDcAllowed);
		}
		return onlySingleDcAllowed;
		}

		@@ -4410,7 +4416,7 @@ public class DcTracker extends Handler {
		int rat = mPhone.getDisplayInfoController().getTelephonyDisplayInfo().getNetworkType();
		// congested override and either network is specified or unknown and all networks specified
		boolean isCongested = mCongestedOverride && (mCongestedNetworkTypes.contains(rat)
		\|\| mUnmeteredNetworkTypes.containsAll(Arrays.stream(
		\|\| mCongestedNetworkTypes.containsAll(Arrays.stream(
		TelephonyManager.getAllNetworkTypes()).boxed().collect(Collectors.toSet())));
		for (DataConnection dataConnection : mDataConnections.values()) {
		dataConnection.onCongestednessChanged(isCongested);