Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit abf87d33 authored by Jack Yu's avatar Jack Yu
Browse files

Added IWLAN handover rules support 

Support the new IWLAN handover rules to
allow/disallow handover based on different
scenarios.

Bug: 196597630
Test: atest DataNetworkControllerTest
Change-Id: I9871040d934502bbf254e218779a7d79b016e48e
parent 71bb82a4

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"));

    }

}