Merge "Create service-connectivity.jar" am: bfceacea50 am: b91257f553

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

Change-Id: Ic068be012bee6d8b1cd7b974896da9750e6ca453

core/java/android/net/ConnectivityManager.java

@@ -898,6 +898,18 @@ public class ConnectivityManager {
         }
     }
 
+    /**
+     * @hide
+     * TODO: Expose for SystemServer when becomes a module.
+     */
+    public void systemReady() {
+        try {
+            mService.systemReady();
+        } catch (RemoteException e) {
+            throw e.rethrowFromSystemServer();
+        }
+    }
+
     /**
      * Checks if a given type uses the cellular data connection.
      * This should be replaced in the future by a network property.

core/java/android/net/IConnectivityManager.aidl

@@ -233,4 +233,6 @@ interface IConnectivityManager
 
     void simulateDataStall(int detectionMethod, long timestampMillis, in Network network,
                 in PersistableBundle extras);
+
+    void systemReady();
 }

services/Android.bp

@@ -83,6 +83,7 @@ java_library {
         "services.voiceinteraction",
         "services.wifi",
         "service-blobstore",
+        "service-connectivity",
         "service-jobscheduler",
         "android.hidl.base-V1.0-java",
     ],

services/core/Android.bp

@@ -1,6 +1,7 @@
 filegroup {
     name: "services.core-sources",
     srcs: ["java/**/*.java"],
+    exclude_srcs: [":connectivity-service-srcs"],
     path: "java",
     visibility: ["//frameworks/base/services"],
 }
@@ -177,3 +178,50 @@ prebuilt_etc {
     name: "protolog.conf.json.gz",
     src: ":services.core.json.gz",
 }
+
+// TODO: Move connectivity service sources to independent directory.
+filegroup {
+    name: "connectivity-service-srcs",
+    srcs: [
+        "java/com/android/server/ConnectivityService.java",
+        "java/com/android/server/ConnectivityServiceInitializer.java",
+        "java/com/android/server/TestNetworkService.java",
+        "java/com/android/server/connectivity/AutodestructReference.java",
+        "java/com/android/server/connectivity/ConnectivityConstants.java",
+        "java/com/android/server/connectivity/DataConnectionStats.java",
+        "java/com/android/server/connectivity/DefaultNetworkMetrics.java",
+        "java/com/android/server/connectivity/DnsManager.java",
+        "java/com/android/server/connectivity/IpConnectivityEventBuilder.java",
+        "java/com/android/server/connectivity/IpConnectivityMetrics.java",
+        "java/com/android/server/connectivity/KeepaliveTracker.java",
+        "java/com/android/server/connectivity/LingerMonitor.java",
+        "java/com/android/server/connectivity/MockableSystemProperties.java",
+        "java/com/android/server/connectivity/MultipathPolicyTracker.java",
+        "java/com/android/server/connectivity/Nat464Xlat.java",
+        "java/com/android/server/connectivity/NetdEventListenerService.java",
+        "java/com/android/server/connectivity/NetworkAgentInfo.java",
+        "java/com/android/server/connectivity/NetworkDiagnostics.java",
+        "java/com/android/server/connectivity/NetworkNotificationManager.java",
+        "java/com/android/server/connectivity/NetworkRanker.java",
+        "java/com/android/server/connectivity/PermissionMonitor.java",
+        "java/com/android/server/connectivity/ProxyTracker.java",
+        "java/com/android/server/connectivity/TcpKeepaliveController.java",
+        "java/com/android/server/connectivity/Vpn.java",
+        "java/com/android/server/connectivity/VpnIkev2Utils.java",
+        "java/com/android/server/net/LockdownVpnTracker.java",
+    ],
+}
+
+java_library {
+    name: "service-connectivity",
+    srcs: [
+        ":connectivity-service-srcs",
+    ],
+    installable: true,
+    libs: [
+        "android.net.ipsec.ike",
+        "services.core",
+        "services.net",
+        "unsupportedappusage",
+    ],
+}

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

@@ -2300,10 +2300,21 @@ public class ConnectivityService extends IConnectivityManager.Stub
     }
 
     /**
-     * Called when the system is ready and ConnectivityService can initialize remaining components.
+     * Called by SystemServer through ConnectivityManager when the system is ready.
+     */
+    @Override
+    public void systemReady() {
+        if (Binder.getCallingUid() != Process.SYSTEM_UID) {
+            throw new SecurityException("Calling Uid is not system uid.");
+        }
+        systemReadyInternal();
+    }
+
+    /**
+     * Called when ConnectivityService can initialize remaining components.
      */
     @VisibleForTesting
-    public void systemReady() {
+    public void systemReadyInternal() {
         // Let PermissionMonitor#startMonitoring() running in the beginning of the systemReady
         // before MultipathPolicyTracker.start(). Since mApps in PermissionMonitor needs to be
         // populated first to ensure that listening network request which is sent by

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server;
+
+import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_HIGH;
+import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_NORMAL;
+
+import android.content.Context;
+import android.net.INetworkPolicyManager;
+import android.net.INetworkStatsService;
+import android.os.INetworkManagementService;
+import android.os.ServiceManager;
+import android.util.Log;
+
+/**
+ * Connectivity service initializer for core networking. This is called by system server to create
+ * a new instance of ConnectivityService.
+ */
+public final class ConnectivityServiceInitializer extends SystemService {
+    private static final String TAG = ConnectivityServiceInitializer.class.getSimpleName();
+    private final ConnectivityService mConnectivity;
+
+    public ConnectivityServiceInitializer(Context context) {
+        super(context);
+        // TODO: Define formal APIs to get the needed services.
+        mConnectivity = new ConnectivityService(context, getNetworkManagementService(),
+                getNetworkStatsService(), getNetworkPolicyManager());
+    }
+
+    @Override
+    public void onStart() {
+        Log.i(TAG, "Registering " + Context.CONNECTIVITY_SERVICE);
+        publishBinderService(Context.CONNECTIVITY_SERVICE, mConnectivity,
+                /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
+    }
+
+    private INetworkManagementService getNetworkManagementService() {
+        return INetworkManagementService.Stub.asInterface(
+               ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));
+    }
+
+    private INetworkStatsService getNetworkStatsService() {
+        return INetworkStatsService.Stub.asInterface(
+                ServiceManager.getService(Context.NETWORK_STATS_SERVICE));
+    }
+
+    private INetworkPolicyManager getNetworkPolicyManager() {
+        return INetworkPolicyManager.Stub.asInterface(
+                ServiceManager.getService(Context.NETWORK_POLICY_SERVICE));
+    }
+
+}

services/java/com/android/server/SystemServer.java

@@ -47,7 +47,9 @@ import android.database.sqlite.SQLiteCompatibilityWalFlags;
 import android.database.sqlite.SQLiteGlobal;
 import android.graphics.GraphicsStatsService;
 import android.hardware.display.DisplayManagerInternal;
+import android.net.ConnectivityManager;
 import android.net.ConnectivityModuleConnector;
+import android.net.IConnectivityManager;
 import android.net.NetworkStackClient;
 import android.os.BaseBundle;
 import android.os.Binder;
@@ -103,7 +105,6 @@ import com.android.server.camera.CameraServiceProxy;
 import com.android.server.clipboard.ClipboardService;
 import com.android.server.compat.PlatformCompat;
 import com.android.server.compat.PlatformCompatNative;
-import com.android.server.connectivity.IpConnectivityMetrics;
 import com.android.server.contentcapture.ContentCaptureManagerInternal;
 import com.android.server.coverage.CoverageService;
 import com.android.server.devicepolicy.DevicePolicyManagerService;
@@ -302,6 +303,10 @@ public final class SystemServer {
             "com.android.server.blob.BlobStoreManagerService";
     private static final String ROLLBACK_MANAGER_SERVICE_CLASS =
             "com.android.server.rollback.RollbackManagerService";
+    private static final String CONNECTIVITY_SERVICE_INITIALIZER_CLASS =
+            "com.android.server.ConnectivityServiceInitializer";
+    private static final String IP_CONNECTIVITY_METRICS_CLASS =
+            "com.android.server.connectivity.IpConnectivityMetrics";
 
     private static final String TETHERING_CONNECTOR_CLASS = "android.net.ITetheringConnector";
 
@@ -1015,7 +1020,7 @@ public final class SystemServer {
         IpSecService ipSecService = null;
         NetworkStatsService networkStats = null;
         NetworkPolicyManagerService networkPolicy = null;
-        ConnectivityService connectivity = null;
+        IConnectivityManager connectivity = null;
         NsdService serviceDiscovery = null;
         WindowManagerService wm = null;
         SerialService serial = null;
@@ -1205,7 +1210,7 @@ public final class SystemServer {
             }
 
             t.traceBegin("IpConnectivityMetrics");
-            mSystemServiceManager.startService(IpConnectivityMetrics.class);
+            mSystemServiceManager.startService(IP_CONNECTIVITY_METRICS_CLASS);
             t.traceEnd();
 
             t.traceBegin("NetworkWatchlistService");
@@ -1531,16 +1536,15 @@ public final class SystemServer {
             }
 
             t.traceBegin("StartConnectivityService");
-            try {
-                connectivity = new ConnectivityService(
-                        context, networkManagement, networkStats, networkPolicy);
-                ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity,
-                        /* allowIsolated= */ false,
-                        DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
-                networkPolicy.bindConnectivityManager(connectivity);
-            } catch (Throwable e) {
-                reportWtf("starting Connectivity Service", e);
-            }
+            // This has to be called after NetworkManagementService, NetworkStatsService
+            // and NetworkPolicyManager because ConnectivityService needs to take these
+            // services to initialize.
+            // TODO: Dynamically load service-connectivity.jar by using startServiceFromJar.
+            mSystemServiceManager.startService(CONNECTIVITY_SERVICE_INITIALIZER_CLASS);
+            connectivity = IConnectivityManager.Stub.asInterface(
+                    ServiceManager.getService(Context.CONNECTIVITY_SERVICE));
+            // TODO: Use ConnectivityManager instead of ConnectivityService.
+            networkPolicy.bindConnectivityManager(connectivity);
             t.traceEnd();
 
             t.traceBegin("StartNsdService");
@@ -2217,7 +2221,6 @@ public final class SystemServer {
         final NetworkManagementService networkManagementF = networkManagement;
         final NetworkStatsService networkStatsF = networkStats;
         final NetworkPolicyManagerService networkPolicyF = networkPolicy;
-        final ConnectivityService connectivityF = connectivity;
         final CountryDetectorService countryDetectorF = countryDetector;
         final NetworkTimeUpdateService networkTimeUpdaterF = networkTimeUpdater;
         final InputManagerService inputManagerF = inputManager;
@@ -2226,6 +2229,8 @@ public final class SystemServer {
         final MmsServiceBroker mmsServiceF = mmsService;
         final IpSecService ipSecServiceF = ipSecService;
         final WindowManagerService windowManagerF = wm;
+        final ConnectivityManager connectivityF = (ConnectivityManager)
+                context.getSystemService(Context.CONNECTIVITY_SERVICE);
 
         // We now tell the activity manager it is okay to run third party
         // code.  It will call back into us once it has gotten to the state

tests/net/Android.bp

@@ -59,6 +59,7 @@ android_test {
         "mockito-target-minus-junit4",
         "net-tests-utils",
         "platform-test-annotations",
+        "service-connectivity",
         "services.core",
         "services.net",
     ],

tests/net/integration/Android.bp

@@ -32,6 +32,7 @@ android_test {
         "kotlin-reflect",
         "mockito-target-extended-minus-junit4",
         "net-tests-utils",
+        "service-connectivity",
         "services.core",
         "services.net",
         "testables",
@@ -59,6 +60,7 @@ java_library {
         "net-tests-utils",
     ],
     libs: [
+        "service-connectivity",
         "services.core",
         "services.net",
     ],

tests/net/integration/src/com/android/server/net/integrationtests/ConnectivityServiceIntegrationTest.kt

@@ -167,7 +167,7 @@ class ConnectivityServiceIntegrationTest {
         cm = ConnectivityManager(context, service)
         context.addMockSystemService(Context.CONNECTIVITY_SERVICE, cm)
 
-        service.systemReady()
+        service.systemReadyInternal()
     }
 
     private inner class TestConnectivityService(deps: Dependencies) : ConnectivityService(

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

@@ -1246,7 +1246,7 @@ public class ConnectivityServiceTest {
         // Create local CM before sending system ready so that we can answer
         // getSystemService() correctly.
         mCm = new WrappedConnectivityManager(InstrumentationRegistry.getContext(), mService);
-        mService.systemReady();
+        mService.systemReadyInternal();
         mockVpn(Process.myUid());
         mCm.bindProcessToNetwork(null);