1 /*
2 * Copyright (C) 2023 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.app.AlarmManager
20 import android.app.AppOpsManager
21 import android.bluetooth.BluetoothManager
22 import android.content.BroadcastReceiver
23 import android.content.Context
24 import android.content.Intent
25 import android.content.IntentFilter
26 import android.content.pm.PackageManager.PERMISSION_GRANTED
27 import android.content.pm.UserInfo
28 import android.content.res.Resources
29 import android.net.ConnectivityManager
30 import android.net.INetd
31 import android.net.INetd.PERMISSION_INTERNET
32 import android.net.InetAddresses
33 import android.net.LinkProperties
34 import android.net.LocalNetworkConfig
35 import android.net.NetworkAgentConfig
36 import android.net.NetworkCapabilities
37 import android.net.NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED
38 import android.net.NetworkCapabilities.TRANSPORT_BLUETOOTH
39 import android.net.NetworkCapabilities.TRANSPORT_CELLULAR
40 import android.net.NetworkCapabilities.TRANSPORT_ETHERNET
41 import android.net.NetworkCapabilities.TRANSPORT_TEST
42 import android.net.NetworkCapabilities.TRANSPORT_VPN
43 import android.net.NetworkCapabilities.TRANSPORT_WIFI
44 import android.net.NetworkPolicyManager
45 import android.net.NetworkProvider
46 import android.net.NetworkScore
47 import android.net.PacProxyManager
48 import android.net.connectivity.ConnectivityCompatChanges.ENABLE_MATCH_LOCAL_NETWORK
49 import android.net.networkstack.NetworkStackClientBase
50 import android.os.BatteryStatsManager
51 import android.os.Bundle
52 import android.os.Handler
53 import android.os.HandlerThread
54 import android.os.Process
55 import android.os.UserHandle
56 import android.os.UserManager
57 import android.permission.PermissionManager.PermissionResult
58 import android.telephony.SubscriptionManager
59 import android.telephony.TelephonyManager
60 import android.testing.TestableContext
61 import androidx.test.platform.app.InstrumentationRegistry
62 import com.android.internal.app.IBatteryStats
63 import com.android.internal.util.test.BroadcastInterceptingContext
64 import com.android.modules.utils.build.SdkLevel
65 import com.android.net.module.util.ArrayTrackRecord
66 import com.android.networkstack.apishim.common.UnsupportedApiLevelException
67 import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker
68 import com.android.server.connectivity.CarrierPrivilegeAuthenticator
69 import com.android.server.connectivity.ClatCoordinator
70 import com.android.server.connectivity.ConnectivityFlags
71 import com.android.server.connectivity.InterfaceTracker
72 import com.android.server.connectivity.MulticastRoutingCoordinatorService
73 import com.android.server.connectivity.MultinetworkPolicyTracker
74 import com.android.server.connectivity.MultinetworkPolicyTrackerTestDependencies
75 import com.android.server.connectivity.NetworkRequestStateStatsMetrics
76 import com.android.server.connectivity.PermissionMonitor
77 import com.android.server.connectivity.ProxyTracker
78 import com.android.server.connectivity.SatelliteAccessController
79 import com.android.testutils.visibleOnHandlerThread
80 import com.android.testutils.waitForIdle
81 import java.util.concurrent.Executors
82 import java.util.concurrent.LinkedBlockingQueue
83 import java.util.concurrent.TimeUnit
84 import java.util.function.BiConsumer
85 import java.util.function.Consumer
86 import kotlin.annotation.AnnotationRetention.RUNTIME
87 import kotlin.annotation.AnnotationTarget.FUNCTION
88 import kotlin.test.assertNotNull
89 import kotlin.test.assertNull
90 import kotlin.test.fail
91 import org.junit.After
92 import org.junit.Before
93 import org.junit.Rule
94 import org.junit.rules.TestName
95 import org.mockito.AdditionalAnswers.delegatesTo
96 import org.mockito.ArgumentMatchers.anyInt
97 import org.mockito.Mockito.doAnswer
98 import org.mockito.Mockito.doReturn
99 import org.mockito.Mockito.mock
100
101 internal const val HANDLER_TIMEOUT_MS = 2_000L
102 internal const val BROADCAST_TIMEOUT_MS = 3_000L
103 internal const val TEST_PACKAGE_NAME = "com.android.test.package"
104 internal const val WIFI_WOL_IFNAME = "test_wlan_wol"
105 internal val LOCAL_IPV4_ADDRESS = InetAddresses.parseNumericAddress("192.0.2.1")
106
107 open class FromS<Type>(val value: Type)
108
109 internal const val VERSION_UNMOCKED = -1
110 internal const val VERSION_R = 1
111 internal const val VERSION_S = 2
112 internal const val VERSION_T = 3
113 internal const val VERSION_U = 4
114 internal const val VERSION_V = 5
115 internal const val VERSION_B = 6
116 internal const val VERSION_MAX = VERSION_B
117
118 internal const val CALLING_UID_UNMOCKED = Process.INVALID_UID
119
getLegacyTypenull120 private fun NetworkCapabilities.getLegacyType() =
121 when (transportTypes.getOrElse(0) { TRANSPORT_WIFI }) {
122 TRANSPORT_BLUETOOTH -> ConnectivityManager.TYPE_BLUETOOTH
123 TRANSPORT_CELLULAR -> ConnectivityManager.TYPE_MOBILE
124 TRANSPORT_ETHERNET -> ConnectivityManager.TYPE_ETHERNET
125 TRANSPORT_TEST -> ConnectivityManager.TYPE_TEST
126 TRANSPORT_VPN -> ConnectivityManager.TYPE_VPN
127 TRANSPORT_WIFI -> ConnectivityManager.TYPE_WIFI
128 else -> ConnectivityManager.TYPE_NONE
129 }
130
131 /**
132 * Base class for tests testing ConnectivityService and its satellites.
133 *
134 * This class sets up a ConnectivityService running locally in the test.
135 */
136 // TODO (b/272685721) : make ConnectivityServiceTest smaller and faster by moving the setup
137 // parts into this class and moving the individual tests to multiple separate classes.
138 open class CSTest {
139 @get:Rule
140 val testNameRule = TestName()
141
142 companion object {
143 val CSTestExecutor = Executors.newSingleThreadExecutor()
144 }
145
146 init {
147 if (!SdkLevel.isAtLeastS()) {
148 throw UnsupportedApiLevelException(
149 "CSTest subclasses must be annotated to only " +
150 "run on S+, e.g. @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)"
151 )
152 }
153 }
154
155 val instrumentationContext =
156 TestableContext(InstrumentationRegistry.getInstrumentation().context)
157 val context = CSContext(instrumentationContext)
158
159 // See constructor for default-enabled features. All queried features must be either enabled
160 // or disabled, because the test can't hold READ_DEVICE_CONFIG and device config utils query
161 // permissions using static contexts.
<lambda>null162 val enabledFeatures = HashMap<String, Boolean>().also {
163 it[ConnectivityFlags.NO_REMATCH_ALL_REQUESTS_ON_REGISTER] = true
164 it[ConnectivityFlags.REQUEST_RESTRICTED_WIFI] = true
165 it[ConnectivityService.KEY_DESTROY_FROZEN_SOCKETS_VERSION] = true
166 it[ConnectivityService.ALLOW_SYSUI_CONNECTIVITY_REPORTS] = true
167 it[ConnectivityService.ALLOW_SATALLITE_NETWORK_FALLBACK] = true
168 it[ConnectivityFlags.INGRESS_TO_VPN_ADDRESS_FILTERING] = true
169 it[ConnectivityFlags.BACKGROUND_FIREWALL_CHAIN] = true
170 it[ConnectivityFlags.DELAY_DESTROY_SOCKETS] = true
171 it[ConnectivityFlags.USE_DECLARED_METHODS_FOR_CALLBACKS] = true
172 it[ConnectivityFlags.QUEUE_CALLBACKS_FOR_FROZEN_APPS] = true
173 it[ConnectivityFlags.QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER] = true
174 }
setFeatureEnablednull175 fun setFeatureEnabled(flag: String, enabled: Boolean) = enabledFeatures.set(flag, enabled)
176
177 // When adding new members, consider if it's not better to build the object in CSTestHelpers
178 // to keep this file clean of implementation details. Generally, CSTestHelpers should only
179 // need changes when new details of instrumentation are needed.
180 val contentResolver = makeMockContentResolver(context)
181
182 val PRIMARY_USER = 0
183 val PRIMARY_USER_INFO = UserInfo(
184 PRIMARY_USER,
185 "", // name
186 UserInfo.FLAG_PRIMARY
187 )
188 val PRIMARY_USER_HANDLE = UserHandle(PRIMARY_USER)
189 val userManager = makeMockUserManager(PRIMARY_USER_INFO, PRIMARY_USER_HANDLE)
190 val activityManager = makeActivityManager()
191
192 val networkStack = mock<NetworkStackClientBase>()
193 val csHandlerThread = HandlerThread("CSTestHandler")
194 val sysResources = mock<Resources>().also { initMockedResources(it) }
195 val packageManager = makeMockPackageManager(instrumentationContext)
196 val connResources = makeMockConnResources(sysResources, packageManager)
197
198 val netd = mock<INetd>()
199 val interfaceTracker = mock<InterfaceTracker>()
<lambda>null200 val bpfNetMaps = mock<BpfNetMaps>().also {
201 doReturn(PERMISSION_INTERNET).`when`(it).getNetPermForUid(anyInt())
202 }
203 val clatCoordinator = mock<ClatCoordinator>()
204 val networkRequestStateStatsMetrics = mock<NetworkRequestStateStatsMetrics>()
205 val proxyTracker = ProxyTracker(
206 context,
207 mock<Handler>(),
208 16 // EVENT_PROXY_HAS_CHANGED
209 )
210 val systemConfigManager = makeMockSystemConfigManager()
211 val batteryStats = mock<IBatteryStats>()
212 val batteryManager = BatteryStatsManager(batteryStats)
213 val appOpsManager = mock<AppOpsManager>()
<lambda>null214 val telephonyManager = mock<TelephonyManager>().also {
215 doReturn(true).`when`(it).isDataCapable()
216 }
217 val subscriptionManager = mock<SubscriptionManager>()
218 val bluetoothManager = mock<BluetoothManager>()
219
220 val multicastRoutingCoordinatorService = mock<MulticastRoutingCoordinatorService>()
221 val satelliteAccessController = mock<SatelliteAccessController>()
222 val destroySocketsWrapper = mock<DestroySocketsWrapper>()
223
224 val deps = CSDeps()
225 val permDeps = PermDeps()
226
227 // Initializations that start threads are done from setUp to avoid thread leak
228 lateinit var alarmHandlerThread: HandlerThread
229 lateinit var alarmManager: AlarmManager
230 lateinit var service: ConnectivityService
231 lateinit var cm: ConnectivityManager
232 lateinit var csHandler: Handler
233
234 // Tests can use this annotation to set flag values before constructing ConnectivityService
235 // e.g. @FeatureFlags([Flag(flagName1, true/false), Flag(flagName2, true/false)])
236 @Retention(RUNTIME)
237 @Target(FUNCTION)
238 annotation class FeatureFlags(val flags: Array<Flag>)
239
240 @Retention(RUNTIME)
241 @Target(FUNCTION)
242 annotation class Flag(val name: String, val enabled: Boolean)
243
244 @Before
setUpnull245 fun setUp() {
246 // Set feature flags before constructing ConnectivityService
247 val testMethodName = testNameRule.methodName
248 try {
249 val testMethod = this::class.java.getMethod(testMethodName)
250 val featureFlags = testMethod.getAnnotation(FeatureFlags::class.java)
251 if (featureFlags != null) {
252 for (flag in featureFlags.flags) {
253 setFeatureEnabled(flag.name, flag.enabled)
254 }
255 }
256 } catch (ignored: NoSuchMethodException) {
257 // This is expected for parameterized tests
258 }
259
260 alarmHandlerThread = HandlerThread("TestAlarmManager").also { it.start() }
261 alarmManager = makeMockAlarmManager(alarmHandlerThread)
262 service = makeConnectivityService(context, netd, deps, permDeps).also {
263 it.systemReadyInternal()
264 }
265 cm = ConnectivityManager(context, service)
266 // csHandler initialization must be after makeConnectivityService since ConnectivityService
267 // constructor starts csHandlerThread
268 csHandler = Handler(csHandlerThread.looper)
269 }
270
271 @After
tearDownnull272 fun tearDown() {
273 csHandlerThread.quitSafely()
274 csHandlerThread.join()
275 alarmHandlerThread.quitSafely()
276 alarmHandlerThread.join()
277 }
278
279 // Class to be mocked and used to verify destroy sockets methods call
280 open inner class DestroySocketsWrapper {
destroyLiveTcpSocketsByOwnerUidsnull281 open fun destroyLiveTcpSocketsByOwnerUids(ownerUids: Set<Int>) {}
282 }
283
284 inner class CSDeps : ConnectivityService.Dependencies() {
getResourcesnull285 override fun getResources(ctx: Context) = connResources
286 override fun getBpfNetMaps(
287 context: Context,
288 netd: INetd,
289 interfaceTracker: InterfaceTracker
290 ) = this@CSTest.bpfNetMaps
291 override fun getClatCoordinator(netd: INetd?) = this@CSTest.clatCoordinator
292 override fun getNetworkStack() = this@CSTest.networkStack
293
294 override fun makeHandlerThread(tag: String) = csHandlerThread
295 override fun makeProxyTracker(context: Context, connServiceHandler: Handler) = proxyTracker
296 override fun makeMulticastRoutingCoordinatorService(handler: Handler) =
297 this@CSTest.multicastRoutingCoordinatorService
298
299 override fun makeCarrierPrivilegeAuthenticator(
300 context: Context,
301 tm: TelephonyManager,
302 requestRestrictedWifiEnabled: Boolean,
303 listener: BiConsumer<Int, Int>,
304 handler: Handler
305 ) = if (SdkLevel.isAtLeastT()) mock<CarrierPrivilegeAuthenticator>() else null
306
307 var satelliteNetworkFallbackUidUpdate: Consumer<Set<Int>>? = null
308 override fun makeSatelliteAccessController(
309 context: Context,
310 updateSatelliteNetworkFallackUid: Consumer<Set<Int>>?,
311 csHandlerThread: Handler
312 ): SatelliteAccessController? {
313 satelliteNetworkFallbackUidUpdate = updateSatelliteNetworkFallackUid
314 return satelliteAccessController
315 }
316
317 private inner class AOOKTDeps(c: Context) : AutomaticOnOffKeepaliveTracker.Dependencies(c) {
isTetheringFeatureNotChickenedOutnull318 override fun isTetheringFeatureNotChickenedOut(name: String): Boolean {
319 return isFeatureEnabled(context, name)
320 }
321 }
makeAutomaticOnOffKeepaliveTrackernull322 override fun makeAutomaticOnOffKeepaliveTracker(c: Context, h: Handler) =
323 AutomaticOnOffKeepaliveTracker(c, h, AOOKTDeps(c))
324
325 override fun makeMultinetworkPolicyTracker(c: Context, h: Handler, r: Runnable) =
326 MultinetworkPolicyTracker(
327 c,
328 h,
329 r,
330 MultinetworkPolicyTrackerTestDependencies(connResources.get())
331 )
332
333 override fun makeNetworkRequestStateStatsMetrics(c: Context) =
334 this@CSTest.networkRequestStateStatsMetrics
335
336 // All queried features must be mocked, because the test cannot hold the
337 // READ_DEVICE_CONFIG permission and device config utils use static methods for
338 // checking permissions.
339 override fun isFeatureEnabled(context: Context?, name: String?) =
340 enabledFeatures[name] ?: fail("Unmocked feature $name, see CSTest.enabledFeatures")
341 override fun isFeatureNotChickenedOut(context: Context?, name: String?) =
342 enabledFeatures[name] ?: fail("Unmocked feature $name, see CSTest.enabledFeatures")
343
344 // Mocked change IDs
345 private val enabledChangeIds = arrayListOf(ENABLE_MATCH_LOCAL_NETWORK)
346 fun setChangeIdEnabled(enabled: Boolean, changeId: Long) {
347 // enabledChangeIds is read on the handler thread and maybe the test thread, so
348 // make sure both threads see it before continuing.
349 visibleOnHandlerThread(csHandler) {
350 if (enabled) {
351 enabledChangeIds.add(changeId)
352 } else {
353 enabledChangeIds.remove(changeId)
354 }
355 }
356 }
357
358 // Need a non-zero value to avoid disarming the timer.
359 val defaultCellDataInactivityTimeoutForTest: Int = 81
getDefaultCellularDataInactivityTimeoutnull360 override fun getDefaultCellularDataInactivityTimeout(): Int {
361 return defaultCellDataInactivityTimeoutForTest
362 }
363
364 // Need a non-zero value to avoid disarming the timer.
365 val defaultWifiDataInactivityTimeoutForTest: Int = 121
getDefaultWifiDataInactivityTimeoutnull366 override fun getDefaultWifiDataInactivityTimeout(): Int {
367 return defaultWifiDataInactivityTimeoutForTest
368 }
369
isChangeEnablednull370 override fun isChangeEnabled(changeId: Long, pkg: String, user: UserHandle) =
371 changeId in enabledChangeIds
372 override fun isChangeEnabled(changeId: Long, uid: Int) =
373 changeId in enabledChangeIds
374
375 // In AOSP, build version codes can't always distinguish between some versions (e.g. at the
376 // time of this writing U == V). Define custom ones.
377 private var sdkLevel = VERSION_UNMOCKED
378 private val isSdkUnmocked get() = sdkLevel == VERSION_UNMOCKED
379
380 fun setBuildSdk(sdkLevel: Int) {
381 require(sdkLevel <= VERSION_MAX) {
382 "setBuildSdk must not be called with Build.VERSION constants but " +
383 "CsTest.VERSION_* constants"
384 }
385 visibleOnHandlerThread(csHandler) { this.sdkLevel = sdkLevel }
386 }
387
isAtLeastSnull388 override fun isAtLeastS() = if (isSdkUnmocked) super.isAtLeastS() else sdkLevel >= VERSION_S
389 override fun isAtLeastT() = if (isSdkUnmocked) super.isAtLeastT() else sdkLevel >= VERSION_T
390 override fun isAtLeastU() = if (isSdkUnmocked) super.isAtLeastU() else sdkLevel >= VERSION_U
391 override fun isAtLeastV() = if (isSdkUnmocked) super.isAtLeastV() else sdkLevel >= VERSION_V
392 override fun isAtLeastB() = if (isSdkUnmocked) super.isAtLeastB() else sdkLevel >= VERSION_B
393
394 private var callingUid = CALLING_UID_UNMOCKED
395
396 fun unmockCallingUid() {
397 setCallingUid(CALLING_UID_UNMOCKED)
398 }
399
setCallingUidnull400 fun setCallingUid(callingUid: Int) {
401 visibleOnHandlerThread(csHandler) { this.callingUid = callingUid }
402 }
403
getCallingUidnull404 override fun getCallingUid() =
405 if (callingUid == CALLING_UID_UNMOCKED) super.getCallingUid() else callingUid
406
407 override fun destroyLiveTcpSocketsByOwnerUids(ownerUids: Set<Int>) {
408 // Call mocked destroyLiveTcpSocketsByOwnerUids so that test can verify this method call
409 destroySocketsWrapper.destroyLiveTcpSocketsByOwnerUids(ownerUids)
410 }
411
makeL2capNetworkProvidernull412 override fun makeL2capNetworkProvider(context: Context) = null
413 }
414
415 inner class PermDeps : PermissionMonitor.Dependencies() {
416 override fun shouldEnforceLocalNetRestrictions(uid: Int) = false
417 }
418
419 inner class CSContext(base: Context) : BroadcastInterceptingContext(base) {
420 val pacProxyManager = mock<PacProxyManager>()
421 val networkPolicyManager = mock<NetworkPolicyManager>()
422
423 // Map of permission name -> PermissionManager.Permission_{GRANTED|DENIED} constant
424 // For permissions granted across the board, the key is only the permission name.
425 // For permissions only granted to a combination of uid/pid, the key
426 // is "<permission name>,<pid>,<uid>". PID+UID permissions have priority over generic ones.
427 private val mMockedPermissions: HashMap<String, Int> = HashMap()
428 private val mStartedActivities = LinkedBlockingQueue<Intent>()
getPackageManagernull429 override fun getPackageManager() = this@CSTest.packageManager
430 override fun getContentResolver() = this@CSTest.contentResolver
431
432 // If the permission result does not set in the mMockedPermissions, it will be
433 // considered as PERMISSION_GRANTED as existing design to prevent breaking other tests.
434 override fun checkPermission(permission: String, pid: Int, uid: Int) =
435 checkMockedPermission(permission, pid, uid, PERMISSION_GRANTED)
436
437 override fun enforceCallingOrSelfPermission(permission: String, message: String?) {
438 // If the permission result does not set in the mMockedPermissions, it will be
439 // considered as PERMISSION_GRANTED as existing design to prevent breaking other tests.
440 val granted = checkMockedPermission(
441 permission,
442 Process.myPid(),
443 Process.myUid(),
444 PERMISSION_GRANTED
445 )
446 if (!granted.equals(PERMISSION_GRANTED)) {
447 throw SecurityException("[Test] permission denied: " + permission)
448 }
449 }
450
451 // If the permission result does not set in the mMockedPermissions, it will be
452 // considered as PERMISSION_GRANTED as existing design to prevent breaking other tests.
checkCallingOrSelfPermissionnull453 override fun checkCallingOrSelfPermission(permission: String) =
454 checkMockedPermission(permission, Process.myPid(), Process.myUid(), PERMISSION_GRANTED)
455
456 private fun checkMockedPermission(
457 permission: String,
458 pid: Int,
459 uid: Int,
460 default: Int
461 ): Int {
462 val processSpecificKey = "$permission,$pid,$uid"
463 return mMockedPermissions[processSpecificKey]
464 ?: mMockedPermissions[permission] ?: default
465 }
466
467 /**
468 * Mock checks for the specified permission, and have them behave as per `granted` or
469 * `denied`.
470 *
471 * This will apply to all calls no matter what the checked UID and PID are.
472 *
473 * @param granted One of {@link PackageManager#PermissionResult}.
474 */
setPermissionnull475 fun setPermission(permission: String, @PermissionResult granted: Int) {
476 mMockedPermissions.put(permission, granted)
477 }
478
479 /**
480 * Mock checks for the specified permission, and have them behave as per `granted` or
481 * `denied`.
482 *
483 * This will only apply to the passed UID and PID.
484 *
485 * @param granted One of {@link PackageManager#PermissionResult}.
486 */
setPermissionnull487 fun setPermission(permission: String, pid: Int, uid: Int, @PermissionResult granted: Int) {
488 mMockedPermissions.put("$permission,$pid,$uid", granted)
489 }
490
491 // Necessary for MultinetworkPolicyTracker, which tries to register a receiver for
492 // all users. The test can't do that since it doesn't hold INTERACT_ACROSS_USERS.
493 // TODO : ensure MultinetworkPolicyTracker's BroadcastReceiver is tested ; ideally,
494 // just returning null should not have tests pass
registerReceiverForAllUsersnull495 override fun registerReceiverForAllUsers(
496 receiver: BroadcastReceiver?,
497 filter: IntentFilter,
498 broadcastPermission: String?,
499 scheduler: Handler?
500 ): Intent? = null
501
502 // Create and cache user managers on the fly as necessary.
503 val userManagers = HashMap<UserHandle, UserManager>()
504 override fun createContextAsUser(user: UserHandle, flags: Int): Context {
505 val asUser = mock(Context::class.java, delegatesTo<Any>(this))
506 doReturn(user).`when`(asUser).getUser()
507 doAnswer { userManagers.computeIfAbsent(user) {
508 mock(UserManager::class.java, delegatesTo<Any>(userManager)) }
509 }.`when`(asUser).getSystemService(Context.USER_SERVICE)
510 return asUser
511 }
512
513 // List of mocked services. Add additional services here or in subclasses.
getSystemServicenull514 override fun getSystemService(serviceName: String) = when (serviceName) {
515 Context.CONNECTIVITY_SERVICE -> cm
516 Context.PAC_PROXY_SERVICE -> pacProxyManager
517 Context.NETWORK_POLICY_SERVICE -> networkPolicyManager
518 Context.ALARM_SERVICE -> alarmManager
519 Context.USER_SERVICE -> userManager
520 Context.ACTIVITY_SERVICE -> activityManager
521 Context.SYSTEM_CONFIG_SERVICE -> systemConfigManager
522 Context.TELEPHONY_SERVICE -> telephonyManager
523 Context.TELEPHONY_SUBSCRIPTION_SERVICE -> subscriptionManager
524 Context.BATTERY_STATS_SERVICE -> batteryManager
525 Context.STATS_MANAGER -> null // Stats manager is final and can't be mocked
526 Context.APP_OPS_SERVICE -> appOpsManager
527 Context.BLUETOOTH_SERVICE -> bluetoothManager
528 else -> super.getSystemService(serviceName)
529 }
530
531 internal val orderedBroadcastAsUserHistory = ArrayTrackRecord<Intent>().newReadHead()
532
expectNoDataActivityBroadcastnull533 fun expectNoDataActivityBroadcast(timeoutMs: Int) {
534 assertNull(orderedBroadcastAsUserHistory.poll(timeoutMs.toLong()))
535 }
536
sendOrderedBroadcastAsUsernull537 override fun sendOrderedBroadcastAsUser(
538 intent: Intent,
539 user: UserHandle,
540 receiverPermission: String?,
541 resultReceiver: BroadcastReceiver?,
542 scheduler: Handler?,
543 initialCode: Int,
544 initialData: String?,
545 initialExtras: Bundle?
546 ) {
547 orderedBroadcastAsUserHistory.add(intent)
548 }
549
startActivityAsUsernull550 override fun startActivityAsUser(intent: Intent, handle: UserHandle) {
551 mStartedActivities.put(intent)
552 }
553
expectStartActivityIntentnull554 fun expectStartActivityIntent(timeoutMs: Long = HANDLER_TIMEOUT_MS): Intent {
555 val intent = mStartedActivities.poll(timeoutMs, TimeUnit.MILLISECONDS)
556 assertNotNull(intent, "Did not receive sign-in intent after " + timeoutMs + "ms")
557 return intent
558 }
559 }
560
561 // Utility methods for subclasses to use
waitForIdlenull562 fun waitForIdle() = csHandlerThread.waitForIdle(HANDLER_TIMEOUT_MS)
563
564 // Network agents. See CSAgentWrapper. This class contains utility methods to simplify
565 // creation.
566 fun Agent(
567 nc: NetworkCapabilities = defaultNc(),
568 nac: NetworkAgentConfig = emptyAgentConfig(nc.getLegacyType()),
569 lp: LinkProperties = defaultLp(),
570 lnc: FromS<LocalNetworkConfig>? = null,
571 score: FromS<NetworkScore> = defaultScore(),
572 provider: NetworkProvider? = null
573 ) = CSAgentWrapper(context, deps, csHandlerThread, networkStack,
574 nac, nc, lp, lnc, score, provider)
575 fun Agent(
576 vararg transports: Int,
577 baseNc: NetworkCapabilities = defaultNc(),
578 lp: LinkProperties = defaultLp()
579 ): CSAgentWrapper {
580 val nc = NetworkCapabilities.Builder(baseNc).apply {
581 transports.forEach {
582 addTransportType(it)
583 }
584 }.addCapability(NET_CAPABILITY_NOT_SUSPENDED)
585 .build()
586 return Agent(nc = nc, lp = lp)
587 }
588 }
589