1 /* 2 * Copyright (C) 2024 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.am; 18 19 import static android.app.ActivityManager.PROCESS_CAPABILITY_FOREGROUND_MICROPHONE; 20 import static android.app.ActivityManager.PROCESS_CAPABILITY_NONE; 21 import static android.app.ActivityManager.PROCESS_STATE_CACHED_EMPTY; 22 import static android.app.ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE; 23 import static android.app.ActivityManager.PROCESS_STATE_HOME; 24 import static android.app.ActivityManager.PROCESS_STATE_SERVICE; 25 import static android.content.Context.BIND_ALLOW_OOM_MANAGEMENT; 26 import static android.content.Context.BIND_AUTO_CREATE; 27 import static android.content.Context.BIND_INCLUDE_CAPABILITIES; 28 import static android.content.Context.BIND_WAIVE_PRIORITY; 29 import static android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_SYSTEM_EXEMPTED; 30 import static android.os.UserHandle.USER_SYSTEM; 31 import static android.platform.test.flag.junit.SetFlagsRule.DefaultInitValueType.DEVICE_DEFAULT; 32 33 import static com.android.server.am.ProcessCachedOptimizerRecord.SHOULD_NOT_FREEZE_REASON_NONE; 34 import static com.android.server.am.ProcessList.CACHED_APP_MIN_ADJ; 35 import static com.android.server.am.ProcessList.HOME_APP_ADJ; 36 import static com.android.server.am.ProcessList.PERCEPTIBLE_APP_ADJ; 37 import static com.android.server.am.ProcessList.SERVICE_ADJ; 38 39 import static org.junit.Assert.assertNotEquals; 40 import static org.mockito.ArgumentMatchers.any; 41 import static org.mockito.ArgumentMatchers.anyInt; 42 import static org.mockito.ArgumentMatchers.anyLong; 43 import static org.mockito.ArgumentMatchers.anyString; 44 import static org.mockito.ArgumentMatchers.eq; 45 import static org.mockito.Mockito.atLeastOnce; 46 import static org.mockito.Mockito.clearInvocations; 47 import static org.mockito.Mockito.doNothing; 48 import static org.mockito.Mockito.doReturn; 49 import static org.mockito.Mockito.mock; 50 import static org.mockito.Mockito.never; 51 import static org.mockito.Mockito.spy; 52 import static org.mockito.Mockito.times; 53 import static org.mockito.Mockito.verify; 54 55 import android.app.IServiceConnection; 56 import android.app.usage.UsageStatsManagerInternal; 57 import android.content.ComponentName; 58 import android.content.Context; 59 import android.content.Intent; 60 import android.content.pm.ApplicationInfo; 61 import android.content.pm.PackageManagerInternal; 62 import android.content.pm.ResolveInfo; 63 import android.content.pm.ServiceInfo; 64 import android.os.Handler; 65 import android.os.HandlerThread; 66 import android.os.IBinder; 67 import android.platform.test.annotations.Presubmit; 68 import android.platform.test.annotations.RequiresFlagsDisabled; 69 import android.platform.test.annotations.RequiresFlagsEnabled; 70 import android.platform.test.flag.junit.CheckFlagsRule; 71 import android.platform.test.flag.junit.DeviceFlagsValueProvider; 72 import android.platform.test.flag.junit.SetFlagsRule; 73 74 import androidx.test.platform.app.InstrumentationRegistry; 75 76 import com.android.server.DropBoxManagerInternal; 77 import com.android.server.LocalServices; 78 import com.android.server.am.ActivityManagerService.Injector; 79 import com.android.server.am.ApplicationExitInfoTest.ServiceThreadRule; 80 import com.android.server.appop.AppOpsService; 81 import com.android.server.firewall.IntentFirewall; 82 import com.android.server.wm.ActivityTaskManagerService; 83 import com.android.server.wm.WindowProcessController; 84 85 import org.junit.After; 86 import org.junit.Before; 87 import org.junit.BeforeClass; 88 import org.junit.Rule; 89 import org.junit.Test; 90 import org.mockito.Mock; 91 import org.mockito.MockitoAnnotations; 92 import org.mockito.verification.VerificationMode; 93 94 import java.io.File; 95 import java.lang.reflect.Field; 96 import java.lang.reflect.Modifier; 97 import java.util.function.Consumer; 98 99 /** 100 * Test class for the service timeout. 101 * 102 * Build/Install/Run: 103 * atest ServiceBindingOomAdjPolicyTest 104 */ 105 @Presubmit 106 public final class ServiceBindingOomAdjPolicyTest { 107 private static final String TAG = ServiceBindingOomAdjPolicyTest.class.getSimpleName(); 108 109 private static final String TEST_APP1_NAME = "com.example.foo"; 110 private static final String TEST_SERVICE1_NAME = "com.example.foo.Foobar"; 111 private static final int TEST_APP1_UID = 10123; 112 private static final int TEST_APP1_PID = 12345; 113 114 private static final String TEST_APP2_NAME = "com.example.bar"; 115 private static final String TEST_SERVICE2_NAME = "com.example.bar.Buz"; 116 private static final int TEST_APP2_UID = 10124; 117 private static final int TEST_APP2_PID = 12346; 118 119 @Rule 120 public final ServiceThreadRule mServiceThreadRule = new ServiceThreadRule(); 121 @Rule 122 public final SetFlagsRule mSetFlagsRule = new SetFlagsRule(DEVICE_DEFAULT); 123 @Rule 124 public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); 125 126 private Context mContext; 127 private HandlerThread mHandlerThread; 128 129 @Mock 130 private AppOpsService mAppOpsService; 131 @Mock 132 private DropBoxManagerInternal mDropBoxManagerInt; 133 @Mock 134 private PackageManagerInternal mPackageManagerInt; 135 @Mock 136 private UsageStatsManagerInternal mUsageStatsManagerInt; 137 @Mock 138 private AppErrors mAppErrors; 139 @Mock 140 private IntentFirewall mIntentFirewall; 141 142 private ActivityManagerService mAms; 143 private ProcessList mProcessList; 144 private ActiveServices mActiveServices; 145 146 private int mCurrentCallingUid; 147 private int mCurrentCallingPid; 148 149 /** Run at the test class initialization */ 150 @BeforeClass setUpOnce()151 public static void setUpOnce() { 152 System.setProperty("dexmaker.share_classloader", "true"); 153 } 154 155 @SuppressWarnings("GuardedBy") 156 @Before setUp()157 public void setUp() throws Exception { 158 MockitoAnnotations.initMocks(this); 159 160 mContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); 161 162 mHandlerThread = new HandlerThread(TAG); 163 mHandlerThread.start(); 164 final ProcessList realProcessList = new ProcessList(); 165 mProcessList = spy(realProcessList); 166 167 LocalServices.removeServiceForTest(DropBoxManagerInternal.class); 168 LocalServices.addService(DropBoxManagerInternal.class, mDropBoxManagerInt); 169 LocalServices.removeServiceForTest(PackageManagerInternal.class); 170 LocalServices.addService(PackageManagerInternal.class, mPackageManagerInt); 171 doReturn(new ComponentName("", "")).when(mPackageManagerInt).getSystemUiServiceComponent(); 172 173 final ActivityManagerService realAms = new ActivityManagerService( 174 new TestInjector(mContext), mServiceThreadRule.getThread()); 175 final ActivityTaskManagerService realAtm = new ActivityTaskManagerService(mContext); 176 realAtm.initialize(null, null, mContext.getMainLooper()); 177 realAms.mActivityTaskManager = spy(realAtm); 178 realAms.mAtmInternal = spy(realAms.mActivityTaskManager.getAtmInternal()); 179 realAms.mProcessStateController = spy(realAms.mProcessStateController); 180 realAms.mOomAdjuster = spy(realAms.mOomAdjuster); 181 realAms.mOomAdjuster.mCachedAppOptimizer = spy(realAms.mOomAdjuster.mCachedAppOptimizer); 182 realAms.mPackageManagerInt = mPackageManagerInt; 183 realAms.mUsageStatsService = mUsageStatsManagerInt; 184 realAms.mAppProfiler = spy(realAms.mAppProfiler); 185 realAms.mProcessesReady = true; 186 mAms = spy(realAms); 187 realProcessList.mService = mAms; 188 189 doReturn(false).when(mPackageManagerInt).filterAppAccess(anyString(), anyInt(), anyInt()); 190 doReturn(true).when(mIntentFirewall).checkService(any(), any(), anyInt(), anyInt(), any(), 191 any()); 192 doReturn(false).when(mAms.mAtmInternal).hasSystemAlertWindowPermission(anyInt(), anyInt(), 193 any()); 194 doReturn(true).when(mAms.mOomAdjuster.mCachedAppOptimizer).useFreezer(); 195 doNothing().when(mAms.mOomAdjuster.mCachedAppOptimizer).freezeAppAsyncAtEarliestLSP( 196 any()); 197 doNothing().when(mAms.mAppProfiler).updateLowMemStateLSP(anyInt(), anyInt(), 198 anyInt(), anyLong()); 199 200 mCurrentCallingUid = TEST_APP1_UID; 201 mCurrentCallingPid = TEST_APP1_PID; 202 } 203 204 @After tearDown()205 public void tearDown() throws Exception { 206 LocalServices.removeServiceForTest(DropBoxManagerInternal.class); 207 LocalServices.removeServiceForTest(PackageManagerInternal.class); 208 mHandlerThread.quit(); 209 } 210 211 @Test testServiceSelfBindingOomAdj()212 public void testServiceSelfBindingOomAdj() throws Exception { 213 // Enable the flags. 214 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 215 216 // Verify that there should be 0 oom adj updates. 217 performTestServiceSelfBindingOomAdj(never(), never()); 218 219 // Disable the flags. 220 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 221 222 // Verify that there should be at least 1 oom adj update. 223 performTestServiceSelfBindingOomAdj(atLeastOnce(), atLeastOnce()); 224 } 225 226 @SuppressWarnings("GuardedBy") performTestServiceSelfBindingOomAdj(VerificationMode bindMode, VerificationMode unbindMode)227 private void performTestServiceSelfBindingOomAdj(VerificationMode bindMode, 228 VerificationMode unbindMode) throws Exception { 229 final ProcessRecord app = addProcessRecord( 230 TEST_APP1_PID, // pid 231 TEST_APP1_UID, // uid 232 PROCESS_STATE_SERVICE, // procstate 233 SERVICE_ADJ, // adj 234 PROCESS_CAPABILITY_NONE, // capabilities 235 TEST_APP1_NAME // packageName 236 ); 237 final Intent serviceIntent = createServiceIntent(TEST_APP1_NAME, TEST_SERVICE1_NAME, 238 TEST_APP1_UID); 239 final IServiceConnection serviceConnection = mock(IServiceConnection.class); 240 241 // Make a self binding. 242 assertNotEquals(0, mAms.bindService( 243 app.getThread(), // caller 244 null, // token 245 serviceIntent, // service 246 null, // resolveType 247 serviceConnection, // connection 248 BIND_AUTO_CREATE, // flags 249 TEST_APP1_NAME, // callingPackage 250 USER_SYSTEM // userId 251 )); 252 253 verify(mAms.mProcessStateController, bindMode).runPendingUpdate(anyInt()); 254 clearInvocations(mAms.mProcessStateController); 255 256 // Unbind the service. 257 mAms.unbindService(serviceConnection); 258 259 verify(mAms.mProcessStateController, unbindMode).runPendingUpdate(anyInt()); 260 clearInvocations(mAms.mProcessStateController); 261 262 removeProcessRecord(app); 263 } 264 265 @Test testServiceDistinctBindingOomAdjMoreImportant()266 public void testServiceDistinctBindingOomAdjMoreImportant() throws Exception { 267 // Enable the flags. 268 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 269 270 // Verify that there should be at least 1 oom adj update 271 // because the client is more important. 272 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 273 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 274 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 275 this::setHasForegroundServices, 276 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 277 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 278 this::setHomeProcess, 279 BIND_AUTO_CREATE, 280 atLeastOnce(), atLeastOnce()); 281 282 // Disable the flags. 283 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 284 285 // Verify that there should be at least 1 oom adj update 286 // because the client is more important. 287 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 288 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 289 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 290 this::setHasForegroundServices, 291 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 292 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 293 this::setHomeProcess, 294 BIND_AUTO_CREATE, 295 atLeastOnce(), atLeastOnce()); 296 } 297 298 @Test testServiceDistinctBindingOomAdjLessImportant()299 public void testServiceDistinctBindingOomAdjLessImportant() throws Exception { 300 // Enable the flags. 301 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 302 303 // Verify that there should be 0 oom adj update 304 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 305 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 306 this::setHomeProcess, 307 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 308 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 309 this::setHasForegroundServices, 310 BIND_AUTO_CREATE, 311 never(), never()); 312 313 // Disable the flags. 314 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 315 316 // Verify that there should be at least 1 oom adj update 317 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 318 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 319 this::setHomeProcess, 320 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 321 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 322 this::setHasForegroundServices, 323 BIND_AUTO_CREATE, 324 atLeastOnce(), atLeastOnce()); 325 } 326 327 @Test 328 @RequiresFlagsEnabled(com.android.server.am.Flags.FLAG_UNFREEZE_BIND_POLICY_FIX) testServiceDistinctBindingOomAdjShouldNotFreeze()329 public void testServiceDistinctBindingOomAdjShouldNotFreeze() throws Exception { 330 // Enable the flags. 331 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 332 333 // Verify that there should be at least 1 oom adj update 334 // because the shouldNotFreeze state needs to be propagated. 335 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 336 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 337 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 338 (app) -> { 339 this.setHasForegroundServices(app); 340 this.setAllowListed(app); 341 }, 342 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 343 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 344 this::setHomeProcess, 345 BIND_AUTO_CREATE, 346 atLeastOnce(), atLeastOnce()); 347 348 // Verify that there should be at least 1 oom adj update 349 // because the shouldNotFreeze state needs to be propagated. 350 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 351 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 352 (app) -> { 353 this.setHomeProcess(app); 354 this.setAllowListed(app); 355 }, 356 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 357 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 358 this::setHasForegroundServices, 359 BIND_AUTO_CREATE, 360 atLeastOnce(), atLeastOnce()); 361 362 // Verify that there should be at least 1 oom adj update 363 // because the client is more important (regardless of shouldNotFreeze state). 364 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 365 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 366 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 367 (app) -> { 368 this.setHasForegroundServices(app); 369 this.setAllowListed(app); 370 }, 371 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 372 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 373 (app) -> { 374 this.setHomeProcess(app); 375 this.setAllowListed(app); 376 }, 377 BIND_AUTO_CREATE, 378 atLeastOnce(), atLeastOnce()); 379 380 // Verify that there should be 0 oom adj update for binding 381 // because setShouldNotFreeze is already set 382 // but for the unbinding must update in case the binding could be the source of the 383 // shouldNotFreeze. 384 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 385 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 386 (app) -> { 387 this.setHomeProcess(app); 388 this.setAllowListed(app); 389 }, 390 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 391 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 392 (app) -> { 393 this.setHasForegroundServices(app); 394 this.setAllowListed(app); 395 }, 396 BIND_AUTO_CREATE, 397 never(), atLeastOnce()); 398 399 400 // Disable the flags. 401 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 402 403 // Verify that there should be at least 1 oom adj update 404 // because the client is more important. 405 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 406 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 407 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 408 (app) -> { 409 this.setHasForegroundServices(app); 410 this.setAllowListed(app); 411 }, 412 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 413 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 414 this::setHomeProcess, 415 BIND_AUTO_CREATE, 416 atLeastOnce(), atLeastOnce()); 417 } 418 419 @Test 420 @RequiresFlagsEnabled(com.android.server.am.Flags.FLAG_UNFREEZE_BIND_POLICY_FIX) testServiceDistinctBindingOomAdjAllowOomManagement()421 public void testServiceDistinctBindingOomAdjAllowOomManagement() throws Exception { 422 // Enable the flags. 423 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 424 425 // Verify that there should be at least 1 oom adj update 426 // because BIND_ALLOW_OOM_MANAGEMENT sets the shouldNotFreeze state which needs to be 427 // propagated. 428 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 429 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 430 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 431 this::setHasForegroundServices, 432 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 433 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 434 this::setHomeProcess, 435 BIND_AUTO_CREATE | BIND_ALLOW_OOM_MANAGEMENT, 436 atLeastOnce(), atLeastOnce()); 437 438 // Verify that there should be at least 1 oom adj update 439 // because BIND_ALLOW_OOM_MANAGEMENT sets the shouldNotFreeze state which needs to be 440 // propagated. 441 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 442 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 443 this::setHomeProcess, 444 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 445 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 446 this::setHasForegroundServices, 447 BIND_AUTO_CREATE | BIND_ALLOW_OOM_MANAGEMENT, 448 atLeastOnce(), atLeastOnce()); 449 450 // Verify that there should be at least 1 oom adj update 451 // because the client is more important (regardless of BIND_ALLOW_OOM_MANAGEMENT). 452 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 453 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 454 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 455 this::setHasForegroundServices, 456 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 457 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 458 (app) -> { 459 this.setHomeProcess(app); 460 this.setAllowListed(app); 461 }, 462 BIND_AUTO_CREATE | BIND_ALLOW_OOM_MANAGEMENT, 463 atLeastOnce(), atLeastOnce()); 464 465 // Verify that there should be 0 oom adj update for binding 466 // because setShouldNotFreeze is already set 467 // but for the unbinding must update in case the BIND_ALLOW_OOM_MANAGEMENT maintaining the 468 // shouldNotFreeze. 469 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 470 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 471 this::setHomeProcess, 472 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 473 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 474 (app) -> { 475 this.setHasForegroundServices(app); 476 this.setAllowListed(app); 477 }, 478 BIND_AUTO_CREATE | BIND_ALLOW_OOM_MANAGEMENT, 479 never(), atLeastOnce()); 480 481 482 // Disable the flags. 483 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 484 485 // Verify that there should be at least 1 oom adj update 486 // because the client is more important. 487 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 488 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 489 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 490 this::setHasForegroundServices, 491 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 492 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 493 this::setHomeProcess, 494 BIND_AUTO_CREATE | BIND_ALLOW_OOM_MANAGEMENT, 495 atLeastOnce(), atLeastOnce()); 496 } 497 498 @Test 499 @RequiresFlagsEnabled(com.android.server.am.Flags.FLAG_UNFREEZE_BIND_POLICY_FIX) testServiceDistinctBindingOomAdjWaivePriority_propagateUnfreeze()500 public void testServiceDistinctBindingOomAdjWaivePriority_propagateUnfreeze() throws Exception { 501 // Enable the flags. 502 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 503 504 // Verify that there should be at least 1 oom adj update 505 // because BIND_WAIVE_PRIORITY sets the shouldNotFreeze state which needs to be propagated. 506 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 507 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 508 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 509 this::setHasForegroundServices, 510 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 511 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 512 this::setHomeProcess, 513 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 514 atLeastOnce(), atLeastOnce()); 515 516 // Verify that there should be at least 1 oom adj update 517 // because BIND_WAIVE_PRIORITY sets the shouldNotFreeze state which needs to be propagated. 518 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 519 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 520 this::setHomeProcess, 521 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 522 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 523 this::setHasForegroundServices, 524 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 525 atLeastOnce(), atLeastOnce()); 526 527 // Verify that there should be 0 oom adj update for binding 528 // because setShouldNotFreeze is already set 529 // but for the unbinding, because client is better than service, we can't skip it safely. 530 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 531 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 532 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 533 this::setHasForegroundServices, 534 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 535 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 536 (app) -> { 537 this.setHomeProcess(app); 538 this.setAllowListed(app); 539 }, 540 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 541 never(), atLeastOnce()); 542 543 // Verify that there should be 0 oom adj update for binding 544 // because setShouldNotFreeze is already set 545 // but for the unbinding must update in case the BIND_WAIVE_PRIORITY maintaining the 546 // shouldNotFreeze. 547 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 548 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 549 this::setHomeProcess, 550 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 551 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 552 (app) -> { 553 this.setHasForegroundServices(app); 554 this.setAllowListed(app); 555 }, 556 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 557 never(), atLeastOnce()); 558 559 560 // Disable the flags. 561 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 562 563 // Verify that there should be at least 1 oom adj update 564 // because the client is more important. 565 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 566 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 567 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 568 this::setHasForegroundServices, 569 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 570 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 571 this::setHomeProcess, 572 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 573 atLeastOnce(), atLeastOnce()); 574 } 575 576 @Test 577 @RequiresFlagsDisabled(com.android.server.am.Flags.FLAG_UNFREEZE_BIND_POLICY_FIX) testServiceDistinctBindingOomAdjWaivePriority()578 public void testServiceDistinctBindingOomAdjWaivePriority() throws Exception { 579 // Enable the flags. 580 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 581 582 // Verify that there should be 0 oom adj update for binding 583 // because we're using the BIND_WAIVE_PRIORITY; 584 // but for the unbinding, because client is better than service, we can't skip it safely. 585 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 586 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 587 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 588 this::setHasForegroundServices, 589 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 590 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 591 this::setHomeProcess, 592 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 593 never(), atLeastOnce()); 594 595 // Verify that there should be 0 oom adj update 596 // because we're using the BIND_WAIVE_PRIORITY; 597 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 598 PROCESS_STATE_HOME, HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 599 this::setHomeProcess, 600 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 601 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 602 this::setHasForegroundServices, 603 BIND_AUTO_CREATE | BIND_WAIVE_PRIORITY, 604 never(), never()); 605 606 // Disable the flags. 607 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 608 609 // Verify that there should be at least 1 oom adj update 610 // because the client is more important. 611 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 612 PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ, 613 PROCESS_CAPABILITY_NONE, TEST_APP1_NAME, 614 this::setHasForegroundServices, 615 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_HOME, 616 HOME_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 617 this::setHomeProcess, 618 BIND_AUTO_CREATE, 619 atLeastOnce(), atLeastOnce()); 620 } 621 622 @Test testServiceDistinctBindingOomAdjNoIncludeCapabilities()623 public void testServiceDistinctBindingOomAdjNoIncludeCapabilities() throws Exception { 624 // Enable the flags. 625 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 626 627 // Verify that there should be 0 oom adj update 628 // because we didn't specify the "BIND_INCLUDE_CAPABILITIES" 629 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 630 PROCESS_STATE_HOME, HOME_APP_ADJ, 631 PROCESS_CAPABILITY_FOREGROUND_MICROPHONE, TEST_APP1_NAME, 632 this::setHomeProcess, 633 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 634 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 635 this::setHasForegroundServices, 636 BIND_AUTO_CREATE, 637 never(), never()); 638 639 // Disable the flags. 640 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 641 642 // Verify that there should be at least 1 oom adj update 643 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 644 PROCESS_STATE_HOME, HOME_APP_ADJ, 645 PROCESS_CAPABILITY_FOREGROUND_MICROPHONE, TEST_APP1_NAME, 646 this::setHomeProcess, 647 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 648 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 649 this::setHasForegroundServices, 650 BIND_AUTO_CREATE, 651 atLeastOnce(), atLeastOnce()); 652 } 653 654 @Test testServiceDistinctBindingOomAdjWithIncludeCapabilities()655 public void testServiceDistinctBindingOomAdjWithIncludeCapabilities() throws Exception { 656 // Enable the flags. 657 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 658 659 // Verify that there should be at least 1 oom adj update 660 // because we use the "BIND_INCLUDE_CAPABILITIES" 661 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 662 PROCESS_STATE_HOME, HOME_APP_ADJ, 663 PROCESS_CAPABILITY_FOREGROUND_MICROPHONE, TEST_APP1_NAME, 664 this::setHomeProcess, 665 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 666 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 667 this::setHasForegroundServices, 668 BIND_AUTO_CREATE | BIND_INCLUDE_CAPABILITIES, 669 atLeastOnce(), atLeastOnce()); 670 671 // Disable the flags. 672 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 673 674 // Verify that there should be at least 1 oom adj update 675 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 676 PROCESS_STATE_HOME, HOME_APP_ADJ, 677 PROCESS_CAPABILITY_FOREGROUND_MICROPHONE, TEST_APP1_NAME, 678 this::setHomeProcess, 679 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 680 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 681 this::setHasForegroundServices, 682 BIND_AUTO_CREATE | BIND_INCLUDE_CAPABILITIES, 683 atLeastOnce(), atLeastOnce()); 684 } 685 686 @Test testServiceDistinctBindingOomAdjFreezeCaller()687 public void testServiceDistinctBindingOomAdjFreezeCaller() throws Exception { 688 // Enable the flags. 689 mSetFlagsRule.enableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 690 691 // Verify that there should be 0 oom adj update 692 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 693 PROCESS_STATE_CACHED_EMPTY, CACHED_APP_MIN_ADJ, PROCESS_CAPABILITY_NONE, 694 TEST_APP1_NAME, null, 695 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 696 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 697 this::setHasForegroundServices, 698 BIND_AUTO_CREATE, 699 never(), never()); 700 701 // Disable the flags. 702 mSetFlagsRule.disableFlags(Flags.FLAG_SERVICE_BINDING_OOM_ADJ_POLICY); 703 704 // Verify that there should be at least 1 oom adj update 705 performTestServiceDistinctBindingOomAdj(TEST_APP1_PID, TEST_APP1_UID, 706 PROCESS_STATE_CACHED_EMPTY, CACHED_APP_MIN_ADJ, PROCESS_CAPABILITY_NONE, 707 TEST_APP1_NAME, null, 708 TEST_APP2_PID, TEST_APP2_UID, PROCESS_STATE_FOREGROUND_SERVICE, 709 PERCEPTIBLE_APP_ADJ, PROCESS_CAPABILITY_NONE, TEST_APP2_NAME, TEST_SERVICE2_NAME, 710 this::setHasForegroundServices, 711 BIND_AUTO_CREATE, 712 atLeastOnce(), atLeastOnce()); 713 } 714 715 @SuppressWarnings("GuardedBy") performTestServiceDistinctBindingOomAdj(int clientPid, int clientUid, int clientProcState, int clientAdj, int clientCap, String clientPackageName, Consumer<ProcessRecord> clientAppFixer, int servicePid, int serviceUid, int serviceProcState, int serviceAdj, int serviceCap, String servicePackageName, String serviceName, Consumer<ProcessRecord> serviceAppFixer, int bindingFlags, VerificationMode bindMode, VerificationMode unbindMode)716 private void performTestServiceDistinctBindingOomAdj(int clientPid, int clientUid, 717 int clientProcState, int clientAdj, int clientCap, String clientPackageName, 718 Consumer<ProcessRecord> clientAppFixer, 719 int servicePid, int serviceUid, int serviceProcState, int serviceAdj, 720 int serviceCap, String servicePackageName, String serviceName, 721 Consumer<ProcessRecord> serviceAppFixer, int bindingFlags, 722 VerificationMode bindMode, VerificationMode unbindMode) throws Exception { 723 final ProcessRecord clientApp = addProcessRecord( 724 clientPid, 725 clientUid, 726 clientProcState, 727 clientAdj, 728 clientCap, 729 clientPackageName 730 ); 731 final ProcessRecord serviceApp = addProcessRecord( 732 servicePid, 733 serviceUid, 734 serviceProcState, 735 serviceAdj, 736 serviceCap, 737 servicePackageName 738 ); 739 final Intent serviceIntent = createServiceIntent(servicePackageName, serviceName, 740 serviceUid); 741 final IServiceConnection serviceConnection = mock(IServiceConnection.class); 742 if (clientAppFixer != null) clientAppFixer.accept(clientApp); 743 if (serviceAppFixer != null) serviceAppFixer.accept(serviceApp); 744 745 // Make a self binding. 746 assertNotEquals(0, mAms.bindService( 747 clientApp.getThread(), // caller 748 null, // token 749 serviceIntent, // service 750 null, // resolveType 751 serviceConnection, // connection 752 bindingFlags, // flags 753 clientPackageName, // callingPackage 754 USER_SYSTEM // userId 755 )); 756 757 verify(mAms.mProcessStateController, bindMode).runPendingUpdate(anyInt()); 758 clearInvocations(mAms.mProcessStateController); 759 760 if (clientApp.isFreezable()) { 761 verify(mAms.mOomAdjuster.mCachedAppOptimizer, 762 times(Flags.serviceBindingOomAdjPolicy() ? 1 : 0)) 763 .freezeAppAsyncAtEarliestLSP(eq(clientApp)); 764 clearInvocations(mAms.mOomAdjuster.mCachedAppOptimizer); 765 } 766 767 // Unbind the service. 768 mAms.unbindService(serviceConnection); 769 770 verify(mAms.mProcessStateController, unbindMode).runPendingUpdate(anyInt()); 771 clearInvocations(mAms.mProcessStateController); 772 773 removeProcessRecord(clientApp); 774 removeProcessRecord(serviceApp); 775 } 776 setHasForegroundServices(ProcessRecord app)777 private void setHasForegroundServices(ProcessRecord app) { 778 app.mServices.setHasForegroundServices(true, 779 FOREGROUND_SERVICE_TYPE_SYSTEM_EXEMPTED, false); 780 } 781 setHomeProcess(ProcessRecord app)782 private void setHomeProcess(ProcessRecord app) { 783 final WindowProcessController wpc = app.getWindowProcessController(); 784 doReturn(true).when(wpc).isHomeProcess(); 785 } 786 787 @SuppressWarnings("GuardedBy") setAllowListed(ProcessRecord app)788 private void setAllowListed(ProcessRecord app) { 789 final UidRecord uidRec = mock(UidRecord.class); 790 app.setUidRecord(uidRec); 791 doReturn(true).when(uidRec).isCurAllowListed(); 792 793 app.mOptRecord.setShouldNotFreeze(true, SHOULD_NOT_FREEZE_REASON_NONE, 1234); 794 } 795 796 @SuppressWarnings("GuardedBy") addProcessRecord(int pid, int uid, int procState, int adj, int cap, String packageName)797 private ProcessRecord addProcessRecord(int pid, int uid, int procState, int adj, int cap, 798 String packageName) { 799 final ApplicationThreadDeferred appThread = mock(ApplicationThreadDeferred.class); 800 final IBinder threadBinder = mock(IBinder.class); 801 final ProcessRecord app = makeProcessRecord(pid, uid, uid, null, 0, 802 procState, adj, cap, 0L, 0L, packageName, packageName, mAms); 803 804 app.makeActive(appThread, mAms.mProcessStats); 805 doReturn(threadBinder).when(appThread).asBinder(); 806 mProcessList.addProcessNameLocked(app); 807 mProcessList.updateLruProcessLocked(app, false, null); 808 809 setFieldValue(ProcessRecord.class, app, "mWindowProcessController", 810 mock(WindowProcessController.class)); 811 812 doReturn(app.getSetCapability()).when(mAms.mOomAdjuster).getDefaultCapability( 813 eq(app), anyInt()); 814 815 return app; 816 } 817 818 @SuppressWarnings("GuardedBy") createServiceIntent(String packageName, String serviceName, int serviceUid)819 private Intent createServiceIntent(String packageName, String serviceName, int serviceUid) { 820 final ComponentName compName = new ComponentName(packageName, serviceName); 821 final Intent serviceIntent = new Intent().setComponent(compName); 822 final ResolveInfo rInfo = new ResolveInfo(); 823 rInfo.serviceInfo = makeServiceInfo(compName.getClassName(), compName.getPackageName(), 824 serviceUid); 825 doReturn(rInfo).when(mPackageManagerInt).resolveService(any(Intent.class), any(), 826 anyLong(), anyInt(), anyInt(), anyInt()); 827 828 return serviceIntent; 829 } 830 831 @SuppressWarnings("GuardedBy") removeProcessRecord(ProcessRecord app)832 private void removeProcessRecord(ProcessRecord app) { 833 app.setKilled(true); 834 mProcessList.removeProcessNameLocked(app.processName, app.uid); 835 mProcessList.removeLruProcessLocked(app); 836 } 837 838 @SuppressWarnings("GuardedBy") makeProcessRecord(int pid, int uid, int packageUid, Integer definingUid, int connectionGroup, int procState, int adj, int cap, long pss, long rss, String processName, String packageName, ActivityManagerService ams)839 private ProcessRecord makeProcessRecord(int pid, int uid, int packageUid, Integer definingUid, 840 int connectionGroup, int procState, int adj, int cap, long pss, long rss, 841 String processName, String packageName, ActivityManagerService ams) { 842 final ProcessRecord app = ApplicationExitInfoTest.makeProcessRecord(pid, uid, packageUid, 843 definingUid, connectionGroup, procState, pss, rss, processName, packageName, ams); 844 app.mState.setCurRawProcState(procState); 845 app.mState.setCurProcState(procState); 846 app.mState.setSetProcState(procState); 847 app.mState.setCurRawAdj(adj); 848 app.mState.setCurAdj(adj); 849 app.mState.setSetAdj(adj); 850 app.mState.setCurCapability(cap); 851 app.mState.setSetCapability(cap); 852 return app; 853 } 854 855 @SuppressWarnings("GuardedBy") makeServiceInfo(String serviceName, String packageName, int packageUid)856 private ServiceInfo makeServiceInfo(String serviceName, String packageName, int packageUid) { 857 final ServiceInfo sInfo = new ServiceInfo(); 858 sInfo.name = serviceName; 859 sInfo.processName = packageName; 860 sInfo.packageName = packageName; 861 sInfo.applicationInfo = new ApplicationInfo(); 862 sInfo.applicationInfo.uid = packageUid; 863 sInfo.applicationInfo.packageName = packageName; 864 sInfo.exported = true; 865 return sInfo; 866 } 867 setFieldValue(Class clazz, Object obj, String fieldName, T val)868 private static <T> void setFieldValue(Class clazz, Object obj, String fieldName, T val) { 869 try { 870 Field field = clazz.getDeclaredField(fieldName); 871 field.setAccessible(true); 872 Field mfield = Field.class.getDeclaredField("accessFlags"); 873 mfield.setAccessible(true); 874 mfield.setInt(field, mfield.getInt(field) & ~(Modifier.FINAL | Modifier.PRIVATE)); 875 field.set(obj, val); 876 } catch (NoSuchFieldException | IllegalAccessException e) { 877 } 878 } 879 880 private class TestInjector extends Injector { TestInjector(Context context)881 TestInjector(Context context) { 882 super(context); 883 } 884 885 @Override getAppOpsService(File recentAccessesFile, File storageFile, Handler handler)886 public AppOpsService getAppOpsService(File recentAccessesFile, File storageFile, 887 Handler handler) { 888 return mAppOpsService; 889 } 890 891 @Override getUiHandler(ActivityManagerService service)892 public Handler getUiHandler(ActivityManagerService service) { 893 return mHandlerThread.getThreadHandler(); 894 } 895 896 @Override getProcessList(ActivityManagerService service)897 public ProcessList getProcessList(ActivityManagerService service) { 898 return mProcessList; 899 } 900 901 @Override getActiveServices(ActivityManagerService service)902 public ActiveServices getActiveServices(ActivityManagerService service) { 903 if (mActiveServices == null) { 904 mActiveServices = spy(new ActiveServices(service)); 905 } 906 return mActiveServices; 907 } 908 909 @Override getCallingUid()910 public int getCallingUid() { 911 return mCurrentCallingUid; 912 } 913 914 @Override getCallingPid()915 public int getCallingPid() { 916 return mCurrentCallingPid; 917 } 918 919 @Override clearCallingIdentity()920 public long clearCallingIdentity() { 921 return (((long) mCurrentCallingUid) << 32) | mCurrentCallingPid; 922 } 923 924 @Override restoreCallingIdentity(long ident)925 public void restoreCallingIdentity(long ident) { 926 } 927 928 @Override getAppErrors()929 public AppErrors getAppErrors() { 930 return mAppErrors; 931 } 932 933 @Override getIntentFirewall()934 public IntentFirewall getIntentFirewall() { 935 return mIntentFirewall; 936 } 937 } 938 939 // TODO: [b/302724778] Remove manual JNI load 940 static { 941 System.loadLibrary("mockingservicestestjni"); 942 } 943 } 944