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

Commit 85e0ad79 authored by junyulai's avatar junyulai
Browse files

[VCN01] Add NOT_VCN_MANAGED capability 

Add new capability to indicate whether a network is
managed by Virtual Carrier Network (VCN). This is needed
to identify networks between VCN managed network and
others. And this capability will be:
  1. mutable
  2. requestable
  3. set by default for network agents and requests
  4. allowed for test networks

Test: 1. atest FrameworksNetTests CtsNetTestCases
      2. adb shell dumpsys connectivity
      3. atest ConnectivityServiceTest#testLoseMutableAndRequestableCaps
Bug: 175662146

Change-Id: Ia5eeb3912a687164fa95d7ba5516fd73abca79ba
parent 88baf235

core/api/system-current.txt

+1 −0
Original line number Diff line number Diff line
@@ -6239,6 +6239,7 @@ package android.net { 
    method @Nullable public String getSsid();

    method @NonNull public int[] getTransportTypes();

    method public boolean satisfiedByNetworkCapabilities(@Nullable android.net.NetworkCapabilities);

    field public static final int NET_CAPABILITY_NOT_VCN_MANAGED = 28; // 0x1c

    field public static final int NET_CAPABILITY_OEM_PAID = 22; // 0x16

    field public static final int NET_CAPABILITY_OEM_PRIVATE = 26; // 0x1a

    field public static final int NET_CAPABILITY_PARTIAL_CONNECTIVITY = 24; // 0x18

core/java/android/net/NetworkCapabilities.java

+26 −7
Original line number Diff line number Diff line
@@ -172,6 +172,7 @@ public final class NetworkCapabilities implements Parcelable { 
            NET_CAPABILITY_TEMPORARILY_NOT_METERED,

            NET_CAPABILITY_OEM_PRIVATE,

            NET_CAPABILITY_VEHICLE_INTERNAL,

            NET_CAPABILITY_NOT_VCN_MANAGED,

    })

    public @interface NetCapability { }
@@ -367,8 +368,17 @@ public final class NetworkCapabilities implements Parcelable { 
    @SystemApi

    public static final int NET_CAPABILITY_VEHICLE_INTERNAL = 27;



    /**

     * Indicates that this network is not managed by a Virtual Carrier Network (VCN).

     *

     * TODO(b/177299683): Add additional clarifying javadoc.

     * @hide

     */

    @SystemApi

    public static final int NET_CAPABILITY_NOT_VCN_MANAGED = 28;



    private static final int MIN_NET_CAPABILITY = NET_CAPABILITY_MMS;

    private static final int MAX_NET_CAPABILITY = NET_CAPABILITY_VEHICLE_INTERNAL;

    private static final int MAX_NET_CAPABILITY = NET_CAPABILITY_NOT_VCN_MANAGED;



    /**

     * Network capabilities that are expected to be mutable, i.e., can change while a particular
@@ -385,7 +395,8 @@ public final class NetworkCapabilities implements Parcelable { 
            | (1 << NET_CAPABILITY_NOT_CONGESTED)

            | (1 << NET_CAPABILITY_NOT_SUSPENDED)

            | (1 << NET_CAPABILITY_PARTIAL_CONNECTIVITY)

            | (1 << NET_CAPABILITY_TEMPORARILY_NOT_METERED);

            | (1 << NET_CAPABILITY_TEMPORARILY_NOT_METERED)

            | (1 << NET_CAPABILITY_NOT_VCN_MANAGED);



    /**

     * Network capabilities that are not allowed in NetworkRequests. This exists because the
@@ -394,16 +405,22 @@ public final class NetworkCapabilities implements Parcelable { 
     * can get into a cycle where the NetworkFactory endlessly churns out NetworkAgents that then

     * get immediately torn down because they do not have the requested capability.

     */

    // Note that as a historical exception, the TRUSTED and NOT_VCN_MANAGED capabilities

    // are mutable but requestable. Factories are responsible for not getting

    // in an infinite loop about these.

    private static final long NON_REQUESTABLE_CAPABILITIES =

            MUTABLE_CAPABILITIES & ~(1 << NET_CAPABILITY_TRUSTED);

            MUTABLE_CAPABILITIES

            & ~(1 << NET_CAPABILITY_TRUSTED)

            & ~(1 << NET_CAPABILITY_NOT_VCN_MANAGED);



    /**

     * Capabilities that are set by default when the object is constructed.

     */

    private static final long DEFAULT_CAPABILITIES =

            (1 << NET_CAPABILITY_NOT_RESTRICTED) |

            (1 << NET_CAPABILITY_TRUSTED) |

            (1 << NET_CAPABILITY_NOT_VPN);

            (1 << NET_CAPABILITY_NOT_RESTRICTED)

            | (1 << NET_CAPABILITY_TRUSTED)

            | (1 << NET_CAPABILITY_NOT_VPN)

            | (1 << NET_CAPABILITY_NOT_VCN_MANAGED);



    /**

     * Capabilities that suggest that a network is restricted.
@@ -463,7 +480,8 @@ public final class NetworkCapabilities implements Parcelable { 
            | (1 << NET_CAPABILITY_NOT_VPN)

            | (1 << NET_CAPABILITY_NOT_ROAMING)

            | (1 << NET_CAPABILITY_NOT_CONGESTED)

            | (1 << NET_CAPABILITY_NOT_SUSPENDED);

            | (1 << NET_CAPABILITY_NOT_SUSPENDED)

            | (1 << NET_CAPABILITY_NOT_VCN_MANAGED);



    /**

     * Adds the given capability to this {@code NetworkCapability} instance.
@@ -1951,6 +1969,7 @@ public final class NetworkCapabilities implements Parcelable { 
            case NET_CAPABILITY_TEMPORARILY_NOT_METERED:    return "TEMPORARILY_NOT_METERED";

            case NET_CAPABILITY_OEM_PRIVATE:          return "OEM_PRIVATE";

            case NET_CAPABILITY_VEHICLE_INTERNAL:     return "NET_CAPABILITY_VEHICLE_INTERNAL";

            case NET_CAPABILITY_NOT_VCN_MANAGED:      return "NOT_VCN_MANAGED";

            default:                                  return Integer.toString(capability);

        }

    }

services/core/java/com/android/server/TestNetworkService.java

+1 −0
Original line number Diff line number Diff line
@@ -242,6 +242,7 @@ class TestNetworkService extends ITestNetworkManager.Stub { 
        nc.addTransportType(NetworkCapabilities.TRANSPORT_TEST);

        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);

        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);

        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED);

        nc.setNetworkSpecifier(new StringNetworkSpecifier(iface));

        nc.setAdministratorUids(administratorUids);

        if (!isMetered) {

tests/net/java/com/android/server/ConnectivityServiceTest.java

+51 −28
Original line number Diff line number Diff line
@@ -63,6 +63,7 @@ import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED; 
import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN;

import static android.net.NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVITY;

import static android.net.NetworkCapabilities.NET_CAPABILITY_RCS;
@@ -6906,36 +6907,58 @@ public class ConnectivityServiceTest { 
        mCm.unregisterNetworkCallback(vpnUidCallback);

    }



    /**

     * Test mutable and requestable network capabilities such as

     * {@link NetworkCapabilities#NET_CAPABILITY_TRUSTED} and

     * {@link NetworkCapabilities#NET_CAPABILITY_NOT_VCN_MANAGED}. Verify that the

     * {@code ConnectivityService} re-assign the networks accordingly.

     */

    @Test

    public final void testLoseTrusted() throws Exception {

        final NetworkRequest trustedRequest = new NetworkRequest.Builder()

                .addCapability(NET_CAPABILITY_TRUSTED)

                .build();

        final TestNetworkCallback trustedCallback = new TestNetworkCallback();

        mCm.requestNetwork(trustedRequest, trustedCallback);



    public final void testLoseMutableAndRequestableCaps() throws Exception {

        final int[] testCaps = new int [] {

                NET_CAPABILITY_TRUSTED,

                NET_CAPABILITY_NOT_VCN_MANAGED

        };

        for (final int testCap : testCaps) {

            // Create requests with and without the testing capability.

            final TestNetworkCallback callbackWithCap = new TestNetworkCallback();

            final TestNetworkCallback callbackWithoutCap = new TestNetworkCallback();

            mCm.requestNetwork(new NetworkRequest.Builder().addCapability(testCap).build(),

                    callbackWithCap);

            mCm.requestNetwork(new NetworkRequest.Builder().removeCapability(testCap).build(),

                    callbackWithoutCap);



            // Setup networks with testing capability and verify the default network changes.

            mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);

            mCellNetworkAgent.connect(true);

        trustedCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

            callbackWithCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

            callbackWithoutCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

            verify(mMockNetd).networkSetDefault(eq(mCellNetworkAgent.getNetwork().netId));

            reset(mMockNetd);



            mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);

            mWiFiNetworkAgent.connect(true);

        trustedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);

            callbackWithCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);

            callbackWithoutCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);

            verify(mMockNetd).networkSetDefault(eq(mWiFiNetworkAgent.getNetwork().netId));

            reset(mMockNetd);



        mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_TRUSTED);

        trustedCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);

            // Remove the testing capability on wifi, verify the callback and default network

            // changes back to cellular.

            mWiFiNetworkAgent.removeCapability(testCap);

            callbackWithCap.expectAvailableCallbacksValidated(mCellNetworkAgent);

            callbackWithoutCap.expectCapabilitiesWithout(testCap, mWiFiNetworkAgent);

            verify(mMockNetd).networkSetDefault(eq(mCellNetworkAgent.getNetwork().netId));

            reset(mMockNetd);



        mCellNetworkAgent.removeCapability(NET_CAPABILITY_TRUSTED);

        trustedCallback.expectCallback(CallbackEntry.LOST, mCellNetworkAgent);

            mCellNetworkAgent.removeCapability(testCap);

            callbackWithCap.expectCallback(CallbackEntry.LOST, mCellNetworkAgent);

            callbackWithoutCap.assertNoCallback();

            verify(mMockNetd).networkClearDefault();



        mCm.unregisterNetworkCallback(trustedCallback);

            mCm.unregisterNetworkCallback(callbackWithCap);

            mCm.unregisterNetworkCallback(callbackWithoutCap);

        }

    }



    @Ignore // 40%+ flakiness : figure out why and re-enable.