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

Commit 63620be9 authored by Junyu Lai's avatar Junyu Lai Committed by Automerger Merge Worker
Browse files

Merge "[VCN01] Add NOT_VCN_MANAGED capability" am: ce075560 am: 6373b3b0... 

Merge "[VCN01] Add NOT_VCN_MANAGED capability" am: ce075560 am: 6373b3b0 am: 8062b53a am: 26c41600 am: 784c32ea

Original change: https://android-review.googlesource.com/c/platform/frameworks/base/+/1549897

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I8b63ba3b3ee06ccbdf41ddec92eb642e02171c9f
parents 385d2c62 784c32ea

core/java/android/net/NetworkCapabilities.java

+24 −7
Original line number Diff line number Diff line
@@ -204,6 +204,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 { }
@@ -399,8 +400,16 @@ 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

     */

    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
@@ -417,7 +426,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
@@ -426,16 +436,21 @@ 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);



    /**

     * Capabilities that suggest that a network is restricted.
@@ -495,7 +510,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.
@@ -1982,6 +1998,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

+57 −26
Original line number Diff line number Diff line
@@ -64,6 +64,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;
@@ -7326,36 +7327,66 @@ public class ConnectivityServiceTest { 
        b2.expectBroadcast();

    }



    /**

     * 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.addCapability(testCap);

            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.addCapability(testCap);

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

            // TODO: Test default network changes for NOT_VCN_MANAGED once the default request has

            //  it.

            if (testCap == NET_CAPABILITY_TRUSTED) {

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

            if (testCap == NET_CAPABILITY_TRUSTED) {

                verify(mMockNetd).networkClearDefault();

            }



        mCm.unregisterNetworkCallback(trustedCallback);

            mCm.unregisterNetworkCallback(callbackWithCap);

            mCm.unregisterNetworkCallback(callbackWithoutCap);

        }

    }



    @Test