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

Commit b1d55e7f authored by Aaron Huang's avatar Aaron Huang Committed by Automerger Merge Worker
Browse files

Merge "Move deduceRestrictedCapability to libs/net and rename it" am: c6725ad2 

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

Change-Id: I088dfe837eb986c2de792d0672a2e707112b6042
parents a087245e c6725ad2

packages/Connectivity/framework/src/android/net/NetworkCapabilities.java

+2 −64
Original line number Diff line number Diff line
@@ -537,43 +537,6 @@ public final class NetworkCapabilities implements Parcelable { 
            | (1 << NET_CAPABILITY_TRUSTED)

            | (1 << NET_CAPABILITY_NOT_VPN);



    /**

     * Capabilities that suggest that a network is restricted.

     * {@see #maybeMarkCapabilitiesRestricted}, {@see #FORCE_RESTRICTED_CAPABILITIES}

     */

    @VisibleForTesting

    /* package */ static final long RESTRICTED_CAPABILITIES =

            (1 << NET_CAPABILITY_CBS)

            | (1 << NET_CAPABILITY_DUN)

            | (1 << NET_CAPABILITY_EIMS)

            | (1 << NET_CAPABILITY_FOTA)

            | (1 << NET_CAPABILITY_IA)

            | (1 << NET_CAPABILITY_IMS)

            | (1 << NET_CAPABILITY_MCX)

            | (1 << NET_CAPABILITY_RCS)

            | (1 << NET_CAPABILITY_VEHICLE_INTERNAL)

            | (1 << NET_CAPABILITY_XCAP)

            | (1 << NET_CAPABILITY_ENTERPRISE);



    /**

     * Capabilities that force network to be restricted.

     * {@see #maybeMarkCapabilitiesRestricted}.

     */

    private static final long FORCE_RESTRICTED_CAPABILITIES =

            (1 << NET_CAPABILITY_OEM_PAID)

            | (1 << NET_CAPABILITY_OEM_PRIVATE);



    /**

     * Capabilities that suggest that a network is unrestricted.

     * {@see #maybeMarkCapabilitiesRestricted}.

     */

    @VisibleForTesting

    /* package */ static final long UNRESTRICTED_CAPABILITIES =

            (1 << NET_CAPABILITY_INTERNET)

            | (1 << NET_CAPABILITY_MMS)

            | (1 << NET_CAPABILITY_SUPL)

            | (1 << NET_CAPABILITY_WIFI_P2P);



    /**

     * Capabilities that are managed by ConnectivityService.

     */
@@ -811,37 +774,12 @@ public final class NetworkCapabilities implements Parcelable { 
    }



    /**

     * Deduces that all the capabilities it provides are typically provided by restricted networks

     * or not.

     *

     * @return {@code true} if the network should be restricted.

     * @hide

     */

    public boolean deduceRestrictedCapability() {

        // Check if we have any capability that forces the network to be restricted.

        final boolean forceRestrictedCapability =

                (mNetworkCapabilities & FORCE_RESTRICTED_CAPABILITIES) != 0;



        // Verify there aren't any unrestricted capabilities.  If there are we say

        // the whole thing is unrestricted unless it is forced to be restricted.

        final boolean hasUnrestrictedCapabilities =

                (mNetworkCapabilities & UNRESTRICTED_CAPABILITIES) != 0;



        // Must have at least some restricted capabilities.

        final boolean hasRestrictedCapabilities =

                (mNetworkCapabilities & RESTRICTED_CAPABILITIES) != 0;



        return forceRestrictedCapability

                || (hasRestrictedCapabilities && !hasUnrestrictedCapabilities);

    }



    /**

     * Removes the NET_CAPABILITY_NOT_RESTRICTED capability if deducing the network is restricted.

     * Removes the NET_CAPABILITY_NOT_RESTRICTED capability if inferring the network is restricted.

     *

     * @hide

     */

    public void maybeMarkCapabilitiesRestricted() {

        if (deduceRestrictedCapability()) {

        if (NetworkCapabilitiesUtils.inferRestrictedCapability(this)) {

            removeCapability(NET_CAPABILITY_NOT_RESTRICTED);

        }

    }

tests/net/common/java/android/net/NetworkCapabilitiesTest.java

+0 −36
Original line number Diff line number Diff line
@@ -38,14 +38,12 @@ import static android.net.NetworkCapabilities.NET_CAPABILITY_WIFI_P2P; 
import static android.net.NetworkCapabilities.REDACT_FOR_ACCESS_FINE_LOCATION;

import static android.net.NetworkCapabilities.REDACT_FOR_LOCAL_MAC_ADDRESS;

import static android.net.NetworkCapabilities.REDACT_FOR_NETWORK_SETTINGS;

import static android.net.NetworkCapabilities.RESTRICTED_CAPABILITIES;

import static android.net.NetworkCapabilities.SIGNAL_STRENGTH_UNSPECIFIED;

import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;

import static android.net.NetworkCapabilities.TRANSPORT_TEST;

import static android.net.NetworkCapabilities.TRANSPORT_VPN;

import static android.net.NetworkCapabilities.TRANSPORT_WIFI;

import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE;

import static android.net.NetworkCapabilities.UNRESTRICTED_CAPABILITIES;

import static android.os.Process.INVALID_UID;



import static com.android.modules.utils.build.SdkLevel.isAtLeastR;
@@ -103,20 +101,6 @@ public class NetworkCapabilitiesTest { 


    @Test

    public void testMaybeMarkCapabilitiesRestricted() {

        // verify EIMS is restricted

        assertEquals((1 << NET_CAPABILITY_EIMS) & RESTRICTED_CAPABILITIES,

                (1 << NET_CAPABILITY_EIMS));



        // verify CBS is also restricted

        assertEquals((1 << NET_CAPABILITY_CBS) & RESTRICTED_CAPABILITIES,

                (1 << NET_CAPABILITY_CBS));



        // verify default is not restricted

        assertEquals((1 << NET_CAPABILITY_INTERNET) & RESTRICTED_CAPABILITIES, 0);



        // just to see

        assertEquals(RESTRICTED_CAPABILITIES & UNRESTRICTED_CAPABILITIES, 0);



        // check that internet does not get restricted

        NetworkCapabilities netCap = new NetworkCapabilities();

        netCap.addCapability(NET_CAPABILITY_INTERNET);
@@ -985,26 +969,6 @@ public class NetworkCapabilitiesTest { 
        assertNotEquals(-50, nc.getSignalStrength());

    }



    @Test @IgnoreUpTo(Build.VERSION_CODES.Q)

    public void testDeduceRestrictedCapability() {

        final NetworkCapabilities nc = new NetworkCapabilities();

        // Default capabilities don't have restricted capability.

        assertFalse(nc.deduceRestrictedCapability());

        // If there is a force restricted capability, then the network capabilities is restricted.

        nc.addCapability(NET_CAPABILITY_OEM_PAID);

        nc.addCapability(NET_CAPABILITY_INTERNET);

        assertTrue(nc.deduceRestrictedCapability());

        // Except for the force restricted capability, if there is any unrestricted capability in

        // capabilities, then the network capabilities is not restricted.

        nc.removeCapability(NET_CAPABILITY_OEM_PAID);

        nc.addCapability(NET_CAPABILITY_CBS);

        assertFalse(nc.deduceRestrictedCapability());

        // Except for the force restricted capability, the network capabilities will only be treated

        // as restricted when there is no any unrestricted capability.

        nc.removeCapability(NET_CAPABILITY_INTERNET);

        assertTrue(nc.deduceRestrictedCapability());

    }



    private void assertNoTransport(NetworkCapabilities nc) {

        for (int i = MIN_TRANSPORT; i <= MAX_TRANSPORT; i++) {

            assertFalse(nc.hasTransport(i));