1 /* 2 * Copyright (C) 2020 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server; 18 19 import android.content.Context; 20 import android.util.Log; 21 22 import com.android.modules.utils.build.SdkLevel; 23 import com.android.networkstack.apishim.ConstantsShim; 24 import com.android.server.connectivity.ConnectivityNativeService; 25 import com.android.server.ethernet.EthernetService; 26 import com.android.server.ethernet.EthernetServiceImpl; 27 import com.android.server.nearby.NearbyService; 28 29 /** 30 * Connectivity service initializer for core networking. This is called by system server to create 31 * a new instance of connectivity services. 32 */ 33 public final class ConnectivityServiceInitializer extends SystemService { 34 private static final String TAG = ConnectivityServiceInitializer.class.getSimpleName(); 35 private final ConnectivityNativeService mConnectivityNative; 36 private final ConnectivityService mConnectivity; 37 private final IpSecService mIpSecService; 38 private final NsdService mNsdService; 39 private final NearbyService mNearbyService; 40 private final EthernetServiceImpl mEthernetServiceImpl; 41 ConnectivityServiceInitializer(Context context)42 public ConnectivityServiceInitializer(Context context) { 43 super(context); 44 // Load JNI libraries used by ConnectivityService and its dependencies 45 System.loadLibrary("service-connectivity"); 46 mEthernetServiceImpl = createEthernetService(context); 47 mConnectivity = new ConnectivityService(context); 48 mIpSecService = createIpSecService(context); 49 mConnectivityNative = createConnectivityNativeService(context); 50 mNsdService = createNsdService(context); 51 mNearbyService = createNearbyService(context); 52 } 53 54 @Override onStart()55 public void onStart() { 56 if (mEthernetServiceImpl != null) { 57 Log.i(TAG, "Registering " + Context.ETHERNET_SERVICE); 58 publishBinderService(Context.ETHERNET_SERVICE, mEthernetServiceImpl, 59 /* allowIsolated= */ false); 60 } 61 62 Log.i(TAG, "Registering " + Context.CONNECTIVITY_SERVICE); 63 publishBinderService(Context.CONNECTIVITY_SERVICE, mConnectivity, 64 /* allowIsolated= */ false); 65 66 if (mIpSecService != null) { 67 Log.i(TAG, "Registering " + Context.IPSEC_SERVICE); 68 publishBinderService(Context.IPSEC_SERVICE, mIpSecService, /* allowIsolated= */ false); 69 } 70 71 if (mConnectivityNative != null) { 72 Log.i(TAG, "Registering " + ConnectivityNativeService.SERVICE_NAME); 73 publishBinderService(ConnectivityNativeService.SERVICE_NAME, mConnectivityNative, 74 /* allowIsolated= */ false); 75 } 76 77 if (mNsdService != null) { 78 Log.i(TAG, "Registering " + Context.NSD_SERVICE); 79 publishBinderService(Context.NSD_SERVICE, mNsdService, /* allowIsolated= */ false); 80 } 81 82 if (mNearbyService != null) { 83 Log.i(TAG, "Registering " + ConstantsShim.NEARBY_SERVICE); 84 publishBinderService(ConstantsShim.NEARBY_SERVICE, mNearbyService, 85 /* allowIsolated= */ false); 86 } 87 88 } 89 90 @Override onBootPhase(int phase)91 public void onBootPhase(int phase) { 92 if (mNearbyService != null) { 93 mNearbyService.onBootPhase(phase); 94 } 95 96 if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY && mEthernetServiceImpl != null) { 97 mEthernetServiceImpl.start(); 98 } 99 } 100 101 /** 102 * Return IpSecService instance, or null if current SDK is lower than T. 103 */ createIpSecService(final Context context)104 private IpSecService createIpSecService(final Context context) { 105 if (!SdkLevel.isAtLeastT()) return null; 106 107 return new IpSecService(context); 108 } 109 110 /** 111 * Return ConnectivityNativeService instance, or null if current SDK is lower than T. 112 */ createConnectivityNativeService(final Context context)113 private ConnectivityNativeService createConnectivityNativeService(final Context context) { 114 if (!SdkLevel.isAtLeastT()) return null; 115 try { 116 return new ConnectivityNativeService(context); 117 } catch (UnsupportedOperationException e) { 118 Log.d(TAG, "Unable to get ConnectivityNative service", e); 119 return null; 120 } 121 } 122 123 /** Return NsdService instance or null if current SDK is lower than T */ createNsdService(final Context context)124 private NsdService createNsdService(final Context context) { 125 if (!SdkLevel.isAtLeastT()) return null; 126 127 return NsdService.create(context); 128 } 129 130 /** Return Nearby service instance or null if current SDK is lower than T */ createNearbyService(final Context context)131 private NearbyService createNearbyService(final Context context) { 132 if (!SdkLevel.isAtLeastT()) return null; 133 try { 134 return new NearbyService(context); 135 } catch (UnsupportedOperationException e) { 136 // Nearby is not yet supported in all branches 137 // TODO: remove catch clause when it is available. 138 Log.i(TAG, "Skipping unsupported service " + ConstantsShim.NEARBY_SERVICE); 139 return null; 140 } 141 } 142 143 /** 144 * Return EthernetServiceImpl instance or null if current SDK is lower than T or Ethernet 145 * service isn't necessary. 146 */ createEthernetService(final Context context)147 private EthernetServiceImpl createEthernetService(final Context context) { 148 if (!SdkLevel.isAtLeastT() || !mConnectivity.deviceSupportsEthernet(context)) { 149 return null; 150 } 151 return EthernetService.create(context); 152 } 153 } 154