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

Commit 805f4d7c authored by satayev's avatar satayev Committed by Gerrit Code Review
Browse files

Merge "Revert "[VCN01] Add NOT_VCN_MANAGED capability""

parents 2c2853d0 0e9334cb

core/api/system-current.txt

+0 −1
Original line number Diff line number Diff line
@@ -6239,7 +6239,6 @@ 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

+7 −26
Original line number Diff line number Diff line
@@ -172,7 +172,6 @@ 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 { }
@@ -368,17 +367,8 @@ 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_NOT_VCN_MANAGED;

    private static final int MAX_NET_CAPABILITY = NET_CAPABILITY_VEHICLE_INTERNAL;



    /**

     * Network capabilities that are expected to be mutable, i.e., can change while a particular
@@ -395,8 +385,7 @@ 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_NOT_VCN_MANAGED);

            | (1 << NET_CAPABILITY_TEMPORARILY_NOT_METERED);



    /**

     * Network capabilities that are not allowed in NetworkRequests. This exists because the
@@ -405,22 +394,16 @@ 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)

            & ~(1 << NET_CAPABILITY_NOT_VCN_MANAGED);

            MUTABLE_CAPABILITIES & ~(1 << NET_CAPABILITY_TRUSTED);



    /**

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

            (1 << NET_CAPABILITY_NOT_RESTRICTED) |

            (1 << NET_CAPABILITY_TRUSTED) |

            (1 << NET_CAPABILITY_NOT_VPN);



    /**

     * Capabilities that suggest that a network is restricted.
@@ -480,8 +463,7 @@ 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_VCN_MANAGED);

            | (1 << NET_CAPABILITY_NOT_SUSPENDED);



    /**

     * Adds the given capability to this {@code NetworkCapability} instance.
@@ -1969,7 +1951,6 @@ 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

+0 −1
Original line number Diff line number Diff line
@@ -242,7 +242,6 @@ 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

+28 −51
Original line number Diff line number Diff line
@@ -63,7 +63,6 @@ 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;
@@ -6907,58 +6906,36 @@ 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 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.

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



        mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);

        mCellNetworkAgent.connect(true);

            callbackWithCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

            callbackWithoutCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

        trustedCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

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

        reset(mMockNetd);



        mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);

        mWiFiNetworkAgent.connect(true);

            callbackWithCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);

            callbackWithoutCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);

        trustedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);

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

        reset(mMockNetd);



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

        mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_TRUSTED);

        trustedCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);

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

        reset(mMockNetd);



            mCellNetworkAgent.removeCapability(testCap);

            callbackWithCap.expectCallback(CallbackEntry.LOST, mCellNetworkAgent);

            callbackWithoutCap.assertNoCallback();

        mCellNetworkAgent.removeCapability(NET_CAPABILITY_TRUSTED);

        trustedCallback.expectCallback(CallbackEntry.LOST, mCellNetworkAgent);

        verify(mMockNetd).networkClearDefault();



            mCm.unregisterNetworkCallback(callbackWithCap);

            mCm.unregisterNetworkCallback(callbackWithoutCap);

        }

        mCm.unregisterNetworkCallback(trustedCallback);

    }



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