Added IWLAN handover rules support am: d30454c12b (4000e134) · Commits · e / os / android_frameworks_opt_telephony

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

+40 −5

Original line number	Diff line number	Diff line
		@@ -44,6 +44,7 @@ import android.util.IndentingPrintWriter;

		import com.android.internal.R;
		import com.android.internal.telephony.Phone;
		import com.android.internal.telephony.data.DataNetworkController.HandoverRule;
		import com.android.internal.telephony.data.DataRetryManager.DataRetryRule;
		import com.android.telephony.Rlog;

		@@ -214,6 +215,8 @@ public class DataConfigManager extends Handler {
		/** A map of network types to the TCP buffer sizes for that network type */
		private @NonNull final @DataConfigNetworkType Map<String, String> mTcpBufferSizeMap =
		new ConcurrentHashMap<>();
		/** Rules for handover between IWLAN and cellular network. */
		private @NonNull final List<HandoverRule> mHandoverRuleList = new ArrayList<>();

		/**
		* Constructor
		@@ -289,6 +292,7 @@ public class DataConfigManager extends Handler {
		updateUnmeteredNetworkTypes();
		updateBandwidths();
		updateTcpBuffers();
		updateHandoverRules();

		log("Data config updated. Config is " + (isConfigCarrierSpecific() ? "" : "not ")
		+ "carrier specific.");
		@@ -348,9 +352,13 @@ public class DataConfigManager extends Handler {
		String[] dataRetryRulesStrings = mCarrierConfig.getStringArray(
		CarrierConfigManager.KEY_TELEPHONY_DATA_RETRY_RULES_STRING_ARRAY);
		if (dataRetryRulesStrings != null) {
		Arrays.stream(dataRetryRulesStrings)
		.map(DataRetryRule::new)
		.forEach(mDataRetryRules::add);
		for (String ruleString : dataRetryRulesStrings) {
		try {
		mDataRetryRules.add(new DataRetryRule(ruleString));
		} catch (IllegalArgumentException e) {
		loge("updateDataRetryRules: " + e.getMessage());
		}
		}
		}
		}
		}
		@@ -444,8 +452,8 @@ public class DataConfigManager extends Handler {
		}

		/**
		* @return Whether {@link NetworkCapabilities.NET_CAPABILITY_TEMPORARILY_NOT_METERED}
		* is supported by the carrier
		* @return Whether {@link NetworkCapabilities#NET_CAPABILITY_TEMPORARILY_NOT_METERED}
		* is supported by the carrier.
		*/
		public boolean isTempNotMeteredSupportedByCarrier() {
		return mCarrierConfig.getBoolean(
		@@ -677,6 +685,33 @@ public class DataConfigManager extends Handler {
		return networkTypeToDataConfigNetworkType(networkType);
		}

		/** Update handover rules from carrier config. */
		private void updateHandoverRules() {
		synchronized (this) {
		mHandoverRuleList.clear();
		String[] handoverRulesStrings = mCarrierConfig.getStringArray(
		CarrierConfigManager.KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY);
		if (handoverRulesStrings != null) {
		for (String ruleString : handoverRulesStrings) {
		try {
		mHandoverRuleList.add(new HandoverRule(ruleString));
		} catch (IllegalArgumentException e) {
		loge("updateHandoverRules: " + e.getMessage());
		}
		}
		}
		}
		}

		/**
		* @return Get rules for handover between IWLAN and cellular networks.
		*
		* @see CarrierConfigManager#KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY
		*/
		public @NonNull List<HandoverRule> getHandoverRules() {
		return Collections.unmodifiableList(mHandoverRuleList);
		}

		/**
		* Get the data config network type for the given network type
		*

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

+152 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		package com.android.internal.telephony.data;

		import android.annotation.CallbackExecutor;
		import android.annotation.IntDef;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.content.BroadcastReceiver;
		@@ -32,11 +33,14 @@ import android.os.Handler;
		import android.os.Looper;
		import android.os.Message;
		import android.telephony.AccessNetworkConstants;
		import android.telephony.AccessNetworkConstants.AccessNetworkType;
		import android.telephony.AccessNetworkConstants.RadioAccessNetworkType;
		import android.telephony.AccessNetworkConstants.TransportType;
		import android.telephony.Annotation.DataFailureCause;
		import android.telephony.Annotation.NetCapability;
		import android.telephony.Annotation.NetworkType;
		import android.telephony.Annotation.ValidationStatus;
		import android.telephony.CarrierConfigManager;
		import android.telephony.DataFailCause;
		import android.telephony.NetworkRegistrationInfo;
		import android.telephony.NetworkRegistrationInfo.RegistrationState;
		@@ -83,12 +87,15 @@ import com.android.telephony.Rlog;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Collection;
		import java.util.Iterator;
		import java.util.LinkedList;
		import java.util.List;
		import java.util.Locale;
		import java.util.Map;
		import java.util.Objects;
		import java.util.Set;
		@@ -582,6 +589,151 @@ public class DataNetworkController extends Handler {
		}
		}

		/**
		* This class represent a rule allowing or disallowing handover between IWLAN and cellular
		* networks.
		*
		* @see CarrierConfigManager#KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY
		*/
		public static class HandoverRule {
		@Retention(RetentionPolicy.SOURCE)
		@IntDef(prefix = {"RULE_TYPE_"},
		value = {
		RULE_TYPE_ALLOWED,
		RULE_TYPE_DISALLOWED,
		})
		public @interface HandoverRuleType {}

		/** Indicating this rule is for allowing handover. */
		public static final int RULE_TYPE_ALLOWED = 1;

		/** Indicating this rule is for disallowing handover. */
		public static final int RULE_TYPE_DISALLOWED = 2;

		private static final String RULE_TAG_SOURCE_ACCESS_NETWORKS = "source";

		private static final String RULE_TAG_TARGET_ACCESS_NETWORKS = "target";

		private static final String RULE_TAG_TYPE = "type";

		private static final String RULE_TAG_ROAMING = "roaming";

		/** Handover rule type. */
		public final @HandoverRuleType int ruleType;

		/** The applicable source access networks for handover. */
		public final @NonNull @RadioAccessNetworkType Set<Integer> sourceAccessNetworks;

		/** The applicable target access networks for handover. */
		public final @NonNull @RadioAccessNetworkType Set<Integer> targetAccessNetworks;

		/** {@code true} indicates this policy is only applicable when the device is roaming. */
		public final boolean isRoaming;

		/**
		* Constructor
		*
		* @param ruleString The rule in string format.
		*
		* @see CarrierConfigManager#KEY_IWLAN_HANDOVER_POLICY_STRING_ARRAY
		*/
		public HandoverRule(@NonNull String ruleString) {
		if (TextUtils.isEmpty(ruleString)) {
		throw new IllegalArgumentException("illegal rule " + ruleString);
		}

		Set<Integer> source = null, target = null;
		int type = 0;
		boolean roaming = false;

		ruleString = ruleString.trim().toLowerCase(Locale.ROOT);
		String[] expressions = ruleString.split("\\s,\\s");
		for (String expression : expressions) {
		String[] tokens = expression.trim().split("\\s=\\s");
		if (tokens.length != 2) {
		throw new IllegalArgumentException("illegal rule " + ruleString + ", tokens="
		+ Arrays.toString(tokens));
		}
		String key = tokens[0].trim();
		String value = tokens[1].trim();
		try {
		switch (key) {
		case RULE_TAG_SOURCE_ACCESS_NETWORKS:
		source = Arrays.stream(value.split("\\s\\\|\\s"))
		.map(String::trim)
		.map(AccessNetworkType::fromString)
		.collect(Collectors.toSet());
		break;
		case RULE_TAG_TARGET_ACCESS_NETWORKS:
		target = Arrays.stream(value.split("\\s\\\|\\s"))
		.map(String::trim)
		.map(AccessNetworkType::fromString)
		.collect(Collectors.toSet());
		break;
		case RULE_TAG_TYPE:
		if (value.toLowerCase(Locale.ROOT).equals("allowed")) {
		type = RULE_TYPE_ALLOWED;
		} else if (value.toLowerCase(Locale.ROOT).equals("disallowed")) {
		type = RULE_TYPE_DISALLOWED;
		} else {
		throw new IllegalArgumentException("unexpected rule type " + value);
		}
		break;
		case RULE_TAG_ROAMING:
		roaming = Boolean.parseBoolean(value);
		break;
		default:
		throw new IllegalArgumentException("unexpected key " + key);
		}
		} catch (Exception e) {
		e.printStackTrace();
		throw new IllegalArgumentException("illegal rule \"" + ruleString + "\", e="
		+ e);
		}
		}

		if (source == null \|\| target == null) {
		throw new IllegalArgumentException("Need to specify both source and target. "
		+ "\"" + ruleString + "\"");
		}

		if (source.contains(AccessNetworkType.UNKNOWN)) {
		throw new IllegalArgumentException("Source access networks contains unknown. "
		+ "\"" + ruleString + "\"");
		}

		if (target.contains(AccessNetworkType.UNKNOWN)) {
		throw new IllegalArgumentException("Target access networks contains unknown. "
		+ "\"" + ruleString + "\"");
		}

		if (type == 0) {
		throw new IllegalArgumentException("Rule type is not specified correctly. "
		+ "\"" + ruleString + "\"");
		}

		if (!source.contains(AccessNetworkType.IWLAN)
		&& !target.contains(AccessNetworkType.IWLAN)) {
		throw new IllegalArgumentException("IWLAN must be specified in either source or "
		+ "target access networks.\"" + ruleString + "\"");
		}

		sourceAccessNetworks = source;
		targetAccessNetworks = target;
		ruleType = type;
		isRoaming = roaming;
		}

		@Override
		public String toString() {
		return "[HandoverRule: type=" + (ruleType == RULE_TYPE_ALLOWED ? "allowed"
		: "disallowed") + ", source=" + sourceAccessNetworks.stream()
		.map(AccessNetworkType::toString).collect(Collectors.joining("\|"))
		+ ", target=" + targetAccessNetworks.stream().map(AccessNetworkType::toString)
		.collect(Collectors.joining("\|")) + ", isRoaming=" + isRoaming + "]";
		}
		}

		/**
		* Constructor
		*

tests/telephonytests/src/com/android/internal/telephony/data/DataNetworkControllerTest.java

+50 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import static com.android.internal.telephony.data.DataNetworkController.NetworkR

		import static com.google.common.truth.Truth.assertThat;

		import static org.junit.Assert.assertThrows;
		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.ArgumentMatchers.anyBoolean;
		import static org.mockito.ArgumentMatchers.anyInt;
		@@ -43,6 +44,7 @@ import android.os.Message;
		import android.os.PersistableBundle;
		import android.os.RegistrantList;
		import android.telephony.AccessNetworkConstants;
		import android.telephony.AccessNetworkConstants.AccessNetworkType;
		import android.telephony.Annotation.NetworkType;
		import android.telephony.CarrierConfigManager;
		import android.telephony.NetworkRegistrationInfo;
		@@ -61,6 +63,7 @@ import com.android.internal.telephony.ISub;
		import com.android.internal.telephony.PhoneConstants;
		import com.android.internal.telephony.PhoneSwitcher;
		import com.android.internal.telephony.TelephonyTest;
		import com.android.internal.telephony.data.DataNetworkController.HandoverRule;

		import org.junit.After;
		import org.junit.Before;
		@@ -743,4 +746,51 @@ public class DataNetworkControllerTest extends TelephonyTest {
		// Verify data is allowed
		verifyInternetConnected();
		}

		@Test
		public void testHandoverRuleFromString() {
		HandoverRule handoverRule = new HandoverRule("source=GERAN\|UTRAN\|EUTRAN\|NGRAN\|IWLAN, "
		+ "target=GERAN\|UTRAN\|EUTRAN\|NGRAN\|IWLAN, type=allowed");
		assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.GERAN,
		AccessNetworkType.UTRAN, AccessNetworkType.EUTRAN, AccessNetworkType.NGRAN,
		AccessNetworkType.IWLAN);
		assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.GERAN,
		AccessNetworkType.UTRAN, AccessNetworkType.EUTRAN, AccessNetworkType.NGRAN,
		AccessNetworkType.IWLAN);
		assertThat(handoverRule.ruleType).isEqualTo(HandoverRule.RULE_TYPE_ALLOWED);
		assertThat(handoverRule.isRoaming).isFalse();

		handoverRule = new HandoverRule("source= NGRAN\| IWLAN, "
		+ "target = EUTRAN, type = disallowed");
		assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.NGRAN,
		AccessNetworkType.IWLAN);
		assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN);
		assertThat(handoverRule.ruleType).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED);
		assertThat(handoverRule.isRoaming).isFalse();

		handoverRule = new HandoverRule("source= IWLAN, "
		+ "target = EUTRAN, type = disallowed, roaming = true");
		assertThat(handoverRule.sourceAccessNetworks).containsExactly(AccessNetworkType.IWLAN);
		assertThat(handoverRule.targetAccessNetworks).containsExactly(AccessNetworkType.EUTRAN);
		assertThat(handoverRule.ruleType).isEqualTo(HandoverRule.RULE_TYPE_DISALLOWED);
		assertThat(handoverRule.isRoaming).isTrue();

		assertThrows(IllegalArgumentException.class,
		() -> new HandoverRule("V2hhdCBUaGUgRnVjayBpcyB0aGlzIQ=="));

		assertThrows(IllegalArgumentException.class,
		() -> new HandoverRule("target=GERAN\|UTRAN\|EUTRAN\|NGRAN\|IWLAN, type=allowed"));

		assertThrows(IllegalArgumentException.class,
		() -> new HandoverRule("source=GERAN\|UTRAN\|EUTRAN\|NGRAN\|IWLAN, type=allowed"));

		assertThrows(IllegalArgumentException.class,
		() -> new HandoverRule("source=GERAN, target=IWLAN, type=wtf"));

		assertThrows(IllegalArgumentException.class,
		() -> new HandoverRule("source=GERAN, target=NGRAN, type=allowed"));

		assertThrows(IllegalArgumentException.class,
		() -> new HandoverRule("source=IWLAN, target=WTFRAN, type=allowed"));
		}
		}