Merge "Revert "[VCN06] Support request background network"" am: b380466d29

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

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: Ic8f292997e582da1eeeb469c91a52225ba4a2217

5 files changed, 3 insertions, 112 deletions

diff --git a/core/api/module-lib-current.txt b/core/api/module-lib-current.txt
index 6d05e5d6b4c2..9349770ee4fd 100644
--- a/core/api/module-lib-current.txt
+++ b/core/api/module-lib-current.txt
@@ -10,10 +10,6 @@ package android.app {
 
 package android.net {
 
-  public class ConnectivityManager {
-    method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_STACK, android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK}) public void requestBackgroundNetwork(@NonNull android.net.NetworkRequest, @Nullable android.os.Handler, @NonNull android.net.ConnectivityManager.NetworkCallback);
-  }
-
   public final class TcpRepairWindow {
     ctor public TcpRepairWindow(int, int, int, int, int, int);
     field public final int maxWindow;
diff --git a/core/java/android/net/ConnectivityManager.java b/core/java/android/net/ConnectivityManager.java
index 074c7fbdf2af..ce0ed5bc0553 100644
--- a/core/java/android/net/ConnectivityManager.java
+++ b/core/java/android/net/ConnectivityManager.java
@@ -15,9 +15,7 @@
  */
 package android.net;
 
-import static android.annotation.SystemApi.Client.MODULE_LIBRARIES;
 import static android.net.IpSecManager.INVALID_RESOURCE_ID;
-import static android.net.NetworkRequest.Type.BACKGROUND_REQUEST;
 import static android.net.NetworkRequest.Type.LISTEN;
 import static android.net.NetworkRequest.Type.REQUEST;
 import static android.net.NetworkRequest.Type.TRACK_DEFAULT;
@@ -29,7 +27,6 @@ import android.annotation.Nullable;
 import android.annotation.RequiresPermission;
 import android.annotation.SdkConstant;
 import android.annotation.SdkConstant.SdkConstantType;
-import android.annotation.SuppressLint;
 import android.annotation.SystemApi;
 import android.annotation.SystemService;
 import android.annotation.TestApi;
@@ -4851,92 +4848,4 @@ public class ConnectivityManager {
         Log.d(TAG, "setOemNetworkPreference called with preference: "
                 + preference.toString());
     }
-
-    /**
-     * Request a network to satisfy a set of {@link android.net.NetworkCapabilities}, but
-     * does not cause any networks to retain the NET_CAPABILITY_FOREGROUND capability. This can
-     * be used to request that the system provide a network without causing the network to be
-     * in the foreground.
-     *
-     * <p>This method will attempt to find the best network that matches the passed
-     * {@link NetworkRequest}, and to bring up one that does if none currently satisfies the
-     * criteria. The platform will evaluate which network is the best at its own discretion.
-     * Throughput, latency, cost per byte, policy, user preference and other considerations
-     * may be factored in the decision of what is considered the best network.
-     *
-     * <p>As long as this request is outstanding, the platform will try to maintain the best network
-     * matching this request, while always attempting to match the request to a better network if
-     * possible. If a better match is found, the platform will switch this request to the now-best
-     * network and inform the app of the newly best network by invoking
-     * {@link NetworkCallback#onAvailable(Network)} on the provided callback. Note that the platform
-     * will not try to maintain any other network than the best one currently matching the request:
-     * a network not matching any network request may be disconnected at any time.
-     *
-     * <p>For example, an application could use this method to obtain a connected cellular network
-     * even if the device currently has a data connection over Ethernet. This may cause the cellular
-     * radio to consume additional power. Or, an application could inform the system that it wants
-     * a network supporting sending MMSes and have the system let it know about the currently best
-     * MMS-supporting network through the provided {@link NetworkCallback}.
-     *
-     * <p>The status of the request can be followed by listening to the various callbacks described
-     * in {@link NetworkCallback}. The {@link Network} object passed to the callback methods can be
-     * used to direct traffic to the network (although accessing some networks may be subject to
-     * holding specific permissions). Callers will learn about the specific characteristics of the
-     * network through
-     * {@link NetworkCallback#onCapabilitiesChanged(Network, NetworkCapabilities)} and
-     * {@link NetworkCallback#onLinkPropertiesChanged(Network, LinkProperties)}. The methods of the
-     * provided {@link NetworkCallback} will only be invoked due to changes in the best network
-     * matching the request at any given time; therefore when a better network matching the request
-     * becomes available, the {@link NetworkCallback#onAvailable(Network)} method is called
-     * with the new network after which no further updates are given about the previously-best
-     * network, unless it becomes the best again at some later time. All callbacks are invoked
-     * in order on the same thread, which by default is a thread created by the framework running
-     * in the app.
-     *
-     * <p>This{@link NetworkRequest} will live until released via
-     * {@link #unregisterNetworkCallback(NetworkCallback)} or the calling application exits, at
-     * which point the system may let go of the network at any time.
-     *
-     * <p>It is presently unsupported to request a network with mutable
-     * {@link NetworkCapabilities} such as
-     * {@link NetworkCapabilities#NET_CAPABILITY_VALIDATED} or
-     * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL}
-     * as these {@code NetworkCapabilities} represent states that a particular
-     * network may never attain, and whether a network will attain these states
-     * is unknown prior to bringing up the network so the framework does not
-     * know how to go about satisfying a request with these capabilities.
-     *
-     * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the
-     * number of outstanding requests to 100 per app (identified by their UID), shared with
-     * all variants of this method, of {@link #registerNetworkCallback} as well as
-     * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}.
-     * Requesting a network with this method will count toward this limit. If this limit is
-     * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources,
-     * make sure to unregister the callbacks with
-     * {@link #unregisterNetworkCallback(NetworkCallback)}.
-     *
-     * @param request {@link NetworkRequest} describing this request.
-     * @param handler {@link Handler} to specify the thread upon which the callback will be invoked.
-     *                If null, the callback is invoked on the default internal Handler.
-     * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note
-     *                        the callback must not be shared - it uniquely specifies this request.
-     * @throws IllegalArgumentException if {@code request} contains invalid network capabilities.
-     * @throws SecurityException if missing the appropriate permissions.
-     * @throws RuntimeException if the app already has too many callbacks registered.
-     *
-     * @hide
-     */
-    @SystemApi(client = MODULE_LIBRARIES)
-    @SuppressLint("ExecutorRegistration")
-    @RequiresPermission(anyOf = {
-            android.Manifest.permission.NETWORK_SETTINGS,
-            android.Manifest.permission.NETWORK_STACK,
-            NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK
-    })
-    public void requestBackgroundNetwork(@NonNull NetworkRequest request,
-            @Nullable Handler handler, @NonNull NetworkCallback networkCallback) {
-        final NetworkCapabilities nc = request.networkCapabilities;
-        sendRequestForNetwork(nc, networkCallback, 0, BACKGROUND_REQUEST,
-                TYPE_NONE, handler == null ? getDefaultHandler() : new CallbackHandler(handler));
-    }
 }
diff --git a/services/core/java/com/android/server/ConnectivityService.java b/services/core/java/com/android/server/ConnectivityService.java
index d67850c33f5f..7541833b1569 100644
--- a/services/core/java/com/android/server/ConnectivityService.java
+++ b/services/core/java/com/android/server/ConnectivityService.java
@@ -5688,9 +5688,6 @@ public class ConnectivityService extends IConnectivityManager.Stub
                 networkCapabilities = createDefaultNetworkCapabilitiesForUid(callingUid);
                 enforceAccessPermission();
                 break;
-            case BACKGROUND_REQUEST:
-                enforceNetworkStackOrSettingsPermission();
-                // Fall-through since other checks are the same with normal requests.
             case REQUEST:
                 networkCapabilities = new NetworkCapabilities(networkCapabilities);
                 enforceNetworkRequestPermissions(networkCapabilities, callingPackageName,
diff --git a/tests/net/java/android/net/ConnectivityManagerTest.java b/tests/net/java/android/net/ConnectivityManagerTest.java
index c2fddf3d9e82..f2dd27effe91 100644
--- a/tests/net/java/android/net/ConnectivityManagerTest.java
+++ b/tests/net/java/android/net/ConnectivityManagerTest.java
@@ -32,7 +32,6 @@ import static android.net.NetworkCapabilities.TRANSPORT_BLUETOOTH;
 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
 import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET;
 import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
-import static android.net.NetworkRequest.Type.BACKGROUND_REQUEST;
 import static android.net.NetworkRequest.Type.REQUEST;
 import static android.net.NetworkRequest.Type.TRACK_DEFAULT;
 
@@ -369,12 +368,6 @@ public class ConnectivityManagerTest {
                 eq(TRACK_DEFAULT.ordinal()), any(), anyInt(), any(), eq(TYPE_NONE),
                 eq(testPkgName), eq(null));
         reset(mService);
-
-        manager.requestBackgroundNetwork(request, null, callback);
-        verify(mService).requestNetwork(eq(request.networkCapabilities),
-                eq(BACKGROUND_REQUEST.ordinal()), any(), anyInt(), any(), eq(TYPE_NONE),
-                eq(testPkgName), eq(null));
-        reset(mService);
     }
 
     static Message makeMessage(NetworkRequest req, int messageType) {
diff --git a/tests/net/java/com/android/server/ConnectivityServiceTest.java b/tests/net/java/com/android/server/ConnectivityServiceTest.java
index f64ab60edba6..37307a46b8ac 100644
--- a/tests/net/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/net/java/com/android/server/ConnectivityServiceTest.java
@@ -3676,13 +3676,10 @@ public class ConnectivityServiceTest {
 
     @Test
     public void testBackgroundNetworks() throws Exception {
-        // Create a cellular background request.
+        // Create a background request. We can't do this ourselves because ConnectivityService
+        // doesn't have an API for it. So just turn on mobile data always on.
+        setAlwaysOnNetworks(true);
         grantUsingBackgroundNetworksPermissionForUid(Binder.getCallingUid());
-        final TestNetworkCallback cellBgCallback = new TestNetworkCallback();
-        mCm.requestBackgroundNetwork(new NetworkRequest.Builder()
-                .addTransportType(TRANSPORT_CELLULAR).build(), null, cellBgCallback);
-
-        // Make callbacks for monitoring.
         final NetworkRequest request = new NetworkRequest.Builder().build();
         final NetworkRequest fgRequest = new NetworkRequest.Builder()
                 .addCapability(NET_CAPABILITY_FOREGROUND).build();
@@ -3751,7 +3748,6 @@ public class ConnectivityServiceTest {
 
         mCm.unregisterNetworkCallback(callback);
         mCm.unregisterNetworkCallback(fgCallback);
-        mCm.unregisterNetworkCallback(cellBgCallback);
     }
 
     @Ignore // This test has instrinsic chances of spurious failures: ignore for continuous testing.