1 /*
2  * Copyright (C) 2019 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_ALL;
20 import static android.app.ActivityManager.PROCESS_CAPABILITY_BFSL;
21 import static android.app.ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
22 import static android.app.ActivityManager.PROCESS_STATE_BOUND_TOP;
23 import static android.app.ActivityManager.PROCESS_STATE_CACHED_ACTIVITY;
24 import static android.app.ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT;
25 import static android.app.ActivityManager.PROCESS_STATE_CACHED_EMPTY;
26 import static android.app.ActivityManager.PROCESS_STATE_CACHED_RECENT;
27 import static android.app.ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
28 import static android.app.ActivityManager.PROCESS_STATE_HEAVY_WEIGHT;
29 import static android.app.ActivityManager.PROCESS_STATE_HOME;
30 import static android.app.ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND;
31 import static android.app.ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
32 import static android.app.ActivityManager.PROCESS_STATE_LAST_ACTIVITY;
33 import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
34 import static android.app.ActivityManager.PROCESS_STATE_PERSISTENT;
35 import static android.app.ActivityManager.PROCESS_STATE_PERSISTENT_UI;
36 import static android.app.ActivityManager.PROCESS_STATE_RECEIVER;
37 import static android.app.ActivityManager.PROCESS_STATE_SERVICE;
38 import static android.app.ActivityManager.PROCESS_STATE_TOP;
39 import static android.app.ActivityManager.PROCESS_STATE_TOP_SLEEPING;
40 import static android.app.ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND;
41 import static android.app.ActivityManagerInternal.OOM_ADJ_REASON_ACTIVITY;
42 import static android.app.ActivityManagerInternal.OOM_ADJ_REASON_NONE;
43 import static android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE;
44 
45 import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
46 
47 import static com.android.server.am.ProcessList.BACKUP_APP_ADJ;
48 import static com.android.server.am.ProcessList.CACHED_APP_MAX_ADJ;
49 import static com.android.server.am.ProcessList.CACHED_APP_MIN_ADJ;
50 import static com.android.server.am.ProcessList.FOREGROUND_APP_ADJ;
51 import static com.android.server.am.ProcessList.HEAVY_WEIGHT_APP_ADJ;
52 import static com.android.server.am.ProcessList.HOME_APP_ADJ;
53 import static com.android.server.am.ProcessList.PERCEPTIBLE_APP_ADJ;
54 import static com.android.server.am.ProcessList.PERCEPTIBLE_LOW_APP_ADJ;
55 import static com.android.server.am.ProcessList.PERCEPTIBLE_MEDIUM_APP_ADJ;
56 import static com.android.server.am.ProcessList.PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ;
57 import static com.android.server.am.ProcessList.PERSISTENT_PROC_ADJ;
58 import static com.android.server.am.ProcessList.PERSISTENT_SERVICE_ADJ;
59 import static com.android.server.am.ProcessList.PREVIOUS_APP_ADJ;
60 import static com.android.server.am.ProcessList.SCHED_GROUP_BACKGROUND;
61 import static com.android.server.am.ProcessList.SCHED_GROUP_DEFAULT;
62 import static com.android.server.am.ProcessList.SCHED_GROUP_RESTRICTED;
63 import static com.android.server.am.ProcessList.SCHED_GROUP_TOP_APP;
64 import static com.android.server.am.ProcessList.SCHED_GROUP_TOP_APP_BOUND;
65 import static com.android.server.am.ProcessList.SERVICE_ADJ;
66 import static com.android.server.am.ProcessList.SERVICE_B_ADJ;
67 import static com.android.server.am.ProcessList.UNKNOWN_ADJ;
68 import static com.android.server.am.ProcessList.VISIBLE_APP_ADJ;
69 
70 import static org.junit.Assert.assertEquals;
71 import static org.junit.Assert.assertNotEquals;
72 import static org.junit.Assert.assertTrue;
73 import static org.mockito.AdditionalAnswers.answer;
74 import static org.mockito.Mockito.any;
75 import static org.mockito.Mockito.anyBoolean;
76 import static org.mockito.Mockito.anyInt;
77 import static org.mockito.Mockito.doAnswer;
78 import static org.mockito.Mockito.doCallRealMethod;
79 import static org.mockito.Mockito.doNothing;
80 import static org.mockito.Mockito.doReturn;
81 import static org.mockito.Mockito.mock;
82 import static org.mockito.Mockito.spy;
83 
84 import android.app.ActivityManager;
85 import android.app.AppOpsManager;
86 import android.app.IApplicationThread;
87 import android.app.IServiceConnection;
88 import android.content.ComponentName;
89 import android.content.Context;
90 import android.content.pm.ApplicationInfo;
91 import android.content.pm.PackageManagerInternal;
92 import android.content.pm.ServiceInfo;
93 import android.os.Build;
94 import android.os.IBinder;
95 import android.os.PowerManagerInternal;
96 import android.os.SystemClock;
97 import android.os.UserHandle;
98 import android.platform.test.annotations.Presubmit;
99 import android.util.ArrayMap;
100 import android.util.SparseArray;
101 
102 import com.android.server.LocalServices;
103 import com.android.server.wm.ActivityServiceConnectionsHolder;
104 import com.android.server.wm.ActivityTaskManagerService;
105 import com.android.server.wm.WindowProcessController;
106 
107 import org.junit.AfterClass;
108 import org.junit.BeforeClass;
109 import org.junit.Test;
110 
111 import java.io.File;
112 import java.lang.reflect.Field;
113 import java.lang.reflect.Modifier;
114 import java.util.ArrayList;
115 import java.util.Collections;
116 import java.util.concurrent.atomic.AtomicInteger;
117 
118 /**
119  * Test class for {@link OomAdjuster}.
120  *
121  * Build/Install/Run:
122  * atest MockingOomAdjusterTests
123  */
124 @Presubmit
125 public class MockingOomAdjusterTests {
126     private static final int MOCKAPP_PID = 12345;
127     private static final int MOCKAPP_UID = 12345;
128     private static final String MOCKAPP_PROCESSNAME = "test #1";
129     private static final String MOCKAPP_PACKAGENAME = "com.android.test.test1";
130     private static final int MOCKAPP2_PID = MOCKAPP_PID + 1;
131     private static final int MOCKAPP2_UID = MOCKAPP_UID + 1;
132     private static final String MOCKAPP2_PROCESSNAME = "test #2";
133     private static final String MOCKAPP2_PACKAGENAME = "com.android.test.test2";
134     private static final int MOCKAPP3_PID = MOCKAPP_PID + 2;
135     private static final int MOCKAPP3_UID = MOCKAPP_UID + 2;
136     private static final String MOCKAPP3_PROCESSNAME = "test #3";
137     private static final String MOCKAPP3_PACKAGENAME = "com.android.test.test3";
138     private static final int MOCKAPP4_PID = MOCKAPP_PID + 3;
139     private static final int MOCKAPP4_UID = MOCKAPP_UID + 3;
140     private static final String MOCKAPP4_PROCESSNAME = "test #4";
141     private static final String MOCKAPP4_PACKAGENAME = "com.android.test.test4";
142     private static final int MOCKAPP5_PID = MOCKAPP_PID + 4;
143     private static final int MOCKAPP5_UID = MOCKAPP_UID + 4;
144     private static final String MOCKAPP5_PROCESSNAME = "test #5";
145     private static final String MOCKAPP5_PACKAGENAME = "com.android.test.test5";
146     private static final int MOCKAPP2_UID_OTHER = MOCKAPP2_UID + UserHandle.PER_USER_RANGE;
147     private static int sFirstCachedAdj = ProcessList.CACHED_APP_MIN_ADJ
148                                           + ProcessList.CACHED_APP_IMPORTANCE_LEVELS;
149     private static Context sContext;
150     private static PackageManagerInternal sPackageManagerInternal;
151     private static ActivityManagerService sService;
152 
153     @SuppressWarnings("GuardedBy")
154     @BeforeClass
setUpOnce()155     public static void setUpOnce() {
156         sContext = getInstrumentation().getTargetContext();
157         System.setProperty("dexmaker.share_classloader", "true");
158 
159         sPackageManagerInternal = mock(PackageManagerInternal.class);
160         doReturn(new ComponentName("", "")).when(sPackageManagerInternal)
161                 .getSystemUiServiceComponent();
162         // Remove stale instance of PackageManagerInternal if there is any
163         LocalServices.removeServiceForTest(PackageManagerInternal.class);
164         LocalServices.addService(PackageManagerInternal.class, sPackageManagerInternal);
165 
166         sService = mock(ActivityManagerService.class);
167         sService.mActivityTaskManager = new ActivityTaskManagerService(sContext);
168         sService.mActivityTaskManager.initialize(null, null, sContext.getMainLooper());
169         sService.mPackageManagerInt = sPackageManagerInternal;
170         sService.mAtmInternal = spy(sService.mActivityTaskManager.getAtmInternal());
171 
172         sService.mConstants = new ActivityManagerConstants(sContext, sService,
173                 sContext.getMainThreadHandler());
174         setFieldValue(ActivityManagerService.class, sService, "mContext",
175                 sContext);
176         ProcessList pr = spy(new ProcessList());
177         pr.mService = sService;
178         AppProfiler profiler = mock(AppProfiler.class);
179         setFieldValue(ActivityManagerService.class, sService, "mProcessList",
180                 pr);
181         setFieldValue(ActivityManagerService.class, sService, "mHandler",
182                 mock(ActivityManagerService.MainHandler.class));
183         setFieldValue(ActivityManagerService.class, sService, "mProcessStats",
184                 new ProcessStatsService(sService, new File(sContext.getFilesDir(), "procstats")));
185         setFieldValue(ActivityManagerService.class, sService, "mBackupTargets",
186                 mock(SparseArray.class));
187         setFieldValue(ActivityManagerService.class, sService, "mOomAdjProfiler",
188                 mock(OomAdjProfiler.class));
189         setFieldValue(ActivityManagerService.class, sService, "mUserController",
190                 mock(UserController.class));
191         setFieldValue(ActivityManagerService.class, sService, "mAppProfiler", profiler);
192         setFieldValue(ActivityManagerService.class, sService, "mProcLock",
193                 new ActivityManagerProcLock());
194         setFieldValue(ActivityManagerService.class, sService, "mServices",
195                 spy(new ActiveServices(sService)));
196         setFieldValue(ActivityManagerService.class, sService, "mInternal",
197                 mock(ActivityManagerService.LocalService.class));
198         setFieldValue(ActivityManagerService.class, sService, "mBatteryStatsService",
199                 mock(BatteryStatsService.class));
200         setFieldValue(ActivityManagerService.class, sService, "mInjector",
201                 new ActivityManagerService.Injector(sContext));
202         doReturn(mock(AppOpsManager.class)).when(sService).getAppOpsManager();
203         doCallRealMethod().when(sService).enqueueOomAdjTargetLocked(any(ProcessRecord.class));
204         doCallRealMethod().when(sService).updateOomAdjPendingTargetsLocked(OOM_ADJ_REASON_ACTIVITY);
205         setFieldValue(AppProfiler.class, profiler, "mProfilerLock", new Object());
206         doReturn(new ActivityManagerService.ProcessChangeItem()).when(pr)
207                 .enqueueProcessChangeItemLocked(anyInt(), anyInt());
208         sService.mOomAdjuster = new OomAdjuster(sService, sService.mProcessList,
209                 new ActiveUids(sService, false));
210         sService.mOomAdjuster.mAdjSeq = 10000;
211         sService.mWakefulness = new AtomicInteger(PowerManagerInternal.WAKEFULNESS_AWAKE);
212         if (sService.mConstants.USE_TIERED_CACHED_ADJ) {
213             sFirstCachedAdj = ProcessList.CACHED_APP_MIN_ADJ + 10;
214         }
215     }
216 
217     @AfterClass
tearDownOnce()218     public static void tearDownOnce() {
219         LocalServices.removeServiceForTest(PackageManagerInternal.class);
220     }
221 
setFieldValue(Class clazz, Object obj, String fieldName, T val)222     private static <T> void setFieldValue(Class clazz, Object obj, String fieldName, T val) {
223         try {
224             Field field = clazz.getDeclaredField(fieldName);
225             field.setAccessible(true);
226             Field mfield = Field.class.getDeclaredField("accessFlags");
227             mfield.setAccessible(true);
228             mfield.setInt(field, mfield.getInt(field) & ~(Modifier.FINAL | Modifier.PRIVATE));
229             field.set(obj, val);
230         } catch (NoSuchFieldException | IllegalAccessException e) {
231         }
232     }
233 
assertBfsl(ProcessRecord app)234     private static void assertBfsl(ProcessRecord app) {
235         assertEquals(PROCESS_CAPABILITY_BFSL,
236                 app.mState.getSetCapability() & PROCESS_CAPABILITY_BFSL);
237     }
238 
assertNoBfsl(ProcessRecord app)239     private static void assertNoBfsl(ProcessRecord app) {
240         assertEquals(0, app.mState.getSetCapability() & PROCESS_CAPABILITY_BFSL);
241     }
242 
243     /**
244      * Replace the process LRU with the given processes.
245      * @param apps
246      */
setProcessesToLru(ProcessRecord... apps)247     private void setProcessesToLru(ProcessRecord... apps) {
248         ArrayList<ProcessRecord> lru = sService.mProcessList.getLruProcessesLOSP();
249         lru.clear();
250         Collections.addAll(lru, apps);
251     }
252 
253     /**
254      * Run updateOomAdjLocked().
255      * - If there's only one process, then it calls updateOomAdjLocked(ProcessRecord, int).
256      * - Otherwise, sets the processes to the LRU and run updateOomAdjLocked(int).
257      */
258     @SuppressWarnings("GuardedBy")
updateOomAdj(ProcessRecord... apps)259     private void updateOomAdj(ProcessRecord... apps) {
260         if (apps.length == 1) {
261             sService.mOomAdjuster.updateOomAdjLocked(apps[0], OOM_ADJ_REASON_NONE);
262         } else {
263             setProcessesToLru(apps);
264             sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
265             sService.mProcessList.getLruProcessesLOSP().clear();
266         }
267     }
268 
269     @SuppressWarnings("GuardedBy")
270     @Test
testUpdateOomAdj_DoOne_Persistent_TopUi_Sleeping()271     public void testUpdateOomAdj_DoOne_Persistent_TopUi_Sleeping() {
272         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
273                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
274         app.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
275         app.mState.setHasTopUi(true);
276         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_ASLEEP);
277         updateOomAdj(app);
278         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
279 
280         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERSISTENT_PROC_ADJ,
281                 SCHED_GROUP_RESTRICTED);
282         assertBfsl(app);
283     }
284 
285     @SuppressWarnings("GuardedBy")
286     @Test
testUpdateOomAdj_DoOne_Persistent_TopUi_Awake()287     public void testUpdateOomAdj_DoOne_Persistent_TopUi_Awake() {
288         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
289                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
290         app.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
291         app.mState.setHasTopUi(true);
292         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
293         updateOomAdj(app);
294 
295         assertProcStates(app, PROCESS_STATE_PERSISTENT_UI, PERSISTENT_PROC_ADJ,
296                 SCHED_GROUP_TOP_APP);
297     }
298 
299     @SuppressWarnings("GuardedBy")
300     @Test
testUpdateOomAdj_DoOne_Persistent_TopApp()301     public void testUpdateOomAdj_DoOne_Persistent_TopApp() {
302         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
303                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
304         app.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
305         doReturn(app).when(sService).getTopApp();
306         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
307         updateOomAdj(app);
308         doReturn(null).when(sService).getTopApp();
309 
310         assertProcStates(app, PROCESS_STATE_PERSISTENT_UI, PERSISTENT_PROC_ADJ,
311                 SCHED_GROUP_TOP_APP);
312     }
313 
314     @SuppressWarnings("GuardedBy")
315     @Test
testUpdateOomAdj_DoOne_TopApp_Awake()316     public void testUpdateOomAdj_DoOne_TopApp_Awake() {
317         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
318                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
319         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
320         doReturn(app).when(sService).getTopApp();
321         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
322         updateOomAdj(app);
323         doReturn(null).when(sService).getTopApp();
324 
325         assertProcStates(app, PROCESS_STATE_TOP, FOREGROUND_APP_ADJ, SCHED_GROUP_TOP_APP);
326     }
327 
328     @SuppressWarnings("GuardedBy")
329     @Test
testUpdateOomAdj_DoOne_RunningAnimations()330     public void testUpdateOomAdj_DoOne_RunningAnimations() {
331         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
332                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
333         doReturn(PROCESS_STATE_TOP_SLEEPING).when(sService.mAtmInternal).getTopProcessState();
334         app.mState.setRunningRemoteAnimation(true);
335         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
336         updateOomAdj(app);
337         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
338 
339         assertProcStates(app, PROCESS_STATE_TOP_SLEEPING, VISIBLE_APP_ADJ, SCHED_GROUP_TOP_APP);
340     }
341 
342     @SuppressWarnings("GuardedBy")
343     @Test
testUpdateOomAdj_DoOne_RunningInstrumentation()344     public void testUpdateOomAdj_DoOne_RunningInstrumentation() {
345         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
346                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
347         doReturn(mock(ActiveInstrumentation.class)).when(app).getActiveInstrumentation();
348         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
349         updateOomAdj(app);
350         doCallRealMethod().when(app).getActiveInstrumentation();
351 
352         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, FOREGROUND_APP_ADJ,
353                 SCHED_GROUP_DEFAULT);
354         assertBfsl(app);
355     }
356 
357     @SuppressWarnings("GuardedBy")
358     @Test
testUpdateOomAdj_DoOne_ReceivingBroadcast()359     public void testUpdateOomAdj_DoOne_ReceivingBroadcast() {
360         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
361                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
362         doReturn(true).when(sService).isReceivingBroadcastLocked(any(ProcessRecord.class),
363                 any(int[].class));
364         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
365         updateOomAdj(app);
366         doReturn(false).when(sService).isReceivingBroadcastLocked(any(ProcessRecord.class),
367                 any(int[].class));
368 
369         assertProcStates(app, PROCESS_STATE_RECEIVER, FOREGROUND_APP_ADJ, SCHED_GROUP_BACKGROUND);
370     }
371 
372     @SuppressWarnings("GuardedBy")
373     @Test
testUpdateOomAdj_DoOne_ExecutingService()374     public void testUpdateOomAdj_DoOne_ExecutingService() {
375         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
376                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
377         app.mServices.startExecutingService(mock(ServiceRecord.class));
378         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
379         updateOomAdj(app);
380 
381         assertProcStates(app, PROCESS_STATE_SERVICE, FOREGROUND_APP_ADJ, SCHED_GROUP_BACKGROUND);
382     }
383 
384     @SuppressWarnings("GuardedBy")
385     @Test
testUpdateOomAdj_DoOne_TopApp_Sleeping()386     public void testUpdateOomAdj_DoOne_TopApp_Sleeping() {
387         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
388                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
389         doReturn(PROCESS_STATE_TOP_SLEEPING).when(sService.mAtmInternal).getTopProcessState();
390         doReturn(app).when(sService).getTopApp();
391         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_ASLEEP);
392         updateOomAdj(app);
393         doReturn(null).when(sService).getTopApp();
394         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
395         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
396 
397         assertProcStates(app, PROCESS_STATE_TOP_SLEEPING, FOREGROUND_APP_ADJ,
398                 SCHED_GROUP_BACKGROUND);
399     }
400 
401     @SuppressWarnings("GuardedBy")
402     @Test
testUpdateOomAdj_DoOne_CachedEmpty()403     public void testUpdateOomAdj_DoOne_CachedEmpty() {
404         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
405                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
406         app.mState.setCurRawAdj(CACHED_APP_MIN_ADJ);
407         doReturn(null).when(sService).getTopApp();
408         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
409         updateOomAdj(app);
410 
411         assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, CACHED_APP_MIN_ADJ,
412                 SCHED_GROUP_BACKGROUND);
413     }
414 
415     @SuppressWarnings("GuardedBy")
416     @Test
testUpdateOomAdj_DoOne_VisibleActivities()417     public void testUpdateOomAdj_DoOne_VisibleActivities() {
418         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
419                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
420         WindowProcessController wpc = app.getWindowProcessController();
421         doReturn(true).when(wpc).hasActivities();
422         doAnswer(answer(callback -> {
423             Field field = callback.getClass().getDeclaredField("adj");
424             field.set(callback, VISIBLE_APP_ADJ);
425             field = callback.getClass().getDeclaredField("foregroundActivities");
426             field.set(callback, true);
427             field = callback.getClass().getDeclaredField("procState");
428             field.set(callback, PROCESS_STATE_TOP);
429             field = callback.getClass().getDeclaredField("schedGroup");
430             field.set(callback, SCHED_GROUP_TOP_APP);
431             return 0;
432         })).when(wpc).computeOomAdjFromActivities(
433                 any(WindowProcessController.ComputeOomAdjCallback.class));
434         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
435         updateOomAdj(app);
436 
437         assertProcStates(app, PROCESS_STATE_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_TOP_APP);
438     }
439 
440     @SuppressWarnings("GuardedBy")
441     @Test
testUpdateOomAdj_DoOne_RecentTasks()442     public void testUpdateOomAdj_DoOne_RecentTasks() {
443         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
444                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
445         WindowProcessController wpc = app.getWindowProcessController();
446         doReturn(true).when(wpc).hasRecentTasks();
447         app.mState.setLastTopTime(SystemClock.uptimeMillis());
448         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
449         updateOomAdj(app);
450         doCallRealMethod().when(wpc).hasRecentTasks();
451 
452         assertEquals(PROCESS_STATE_CACHED_RECENT, app.mState.getSetProcState());
453     }
454 
455     @SuppressWarnings("GuardedBy")
456     @Test
testUpdateOomAdj_DoOne_FgServiceLocation()457     public void testUpdateOomAdj_DoOne_FgServiceLocation() {
458         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
459                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
460         app.mServices.setHasForegroundServices(true, ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION,
461                 /* hasNoneType=*/false);
462         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
463         updateOomAdj(app);
464 
465         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
466                 SCHED_GROUP_DEFAULT);
467         assertBfsl(app);
468     }
469 
470     @SuppressWarnings("GuardedBy")
471     @Test
testUpdateOomAdj_DoOne_FgService()472     public void testUpdateOomAdj_DoOne_FgService() {
473         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
474                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
475         app.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
476         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
477         updateOomAdj(app);
478 
479         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
480                 SCHED_GROUP_DEFAULT);
481         assertBfsl(app);
482     }
483 
484     @SuppressWarnings("GuardedBy")
485     @Test
testUpdateOomAdj_DoOne_FgService_ShortFgs()486     public void testUpdateOomAdj_DoOne_FgService_ShortFgs() {
487         sService.mConstants.TOP_TO_FGS_GRACE_DURATION = 100_000;
488         sService.mConstants.mShortFgsProcStateExtraWaitDuration = 200_000;
489 
490         ServiceRecord s = ServiceRecord.newEmptyInstanceForTest(sService);
491         s.startRequested = true;
492         s.isForeground = true;
493         s.foregroundServiceType = FOREGROUND_SERVICE_TYPE_SHORT_SERVICE;
494         s.setShortFgsInfo(SystemClock.uptimeMillis());
495 
496         // SHORT_SERVICE FGS will get IMP_FG and a slightly different recent-adjustment.
497         {
498             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
499                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
500             app.mServices.startService(s);
501             app.mServices.setHasForegroundServices(true,
502                     FOREGROUND_SERVICE_TYPE_SHORT_SERVICE, /* hasNoneType=*/false);
503             app.mState.setLastTopTime(SystemClock.uptimeMillis());
504             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
505 
506             updateOomAdj(app);
507 
508             assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE,
509                     PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ + 1, SCHED_GROUP_DEFAULT);
510             assertNoBfsl(app);
511         }
512 
513         // SHORT_SERVICE, but no longer recent.
514         {
515             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
516                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
517             app.mServices.setHasForegroundServices(true,
518                     FOREGROUND_SERVICE_TYPE_SHORT_SERVICE, /* hasNoneType=*/false);
519             app.mServices.startService(s);
520             app.mState.setLastTopTime(SystemClock.uptimeMillis()
521                     - sService.mConstants.TOP_TO_FGS_GRACE_DURATION);
522             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
523 
524             updateOomAdj(app);
525 
526             assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE,
527                     PERCEPTIBLE_MEDIUM_APP_ADJ + 1, SCHED_GROUP_DEFAULT);
528             assertNoBfsl(app);
529         }
530 
531         // SHORT_SERVICE, timed out already.
532         s = ServiceRecord.newEmptyInstanceForTest(sService);
533         s.startRequested = true;
534         s.isForeground = true;
535         s.foregroundServiceType = FOREGROUND_SERVICE_TYPE_SHORT_SERVICE;
536         s.setShortFgsInfo(SystemClock.uptimeMillis()
537                 - sService.mConstants.mShortFgsTimeoutDuration
538                 - sService.mConstants.mShortFgsProcStateExtraWaitDuration);
539         {
540             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
541                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
542             app.mServices.setHasForegroundServices(true,
543                     FOREGROUND_SERVICE_TYPE_SHORT_SERVICE, /* hasNoneType=*/false);
544             app.mServices.startService(s);
545             app.mState.setLastTopTime(SystemClock.uptimeMillis()
546                     - sService.mConstants.TOP_TO_FGS_GRACE_DURATION);
547             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
548 
549             updateOomAdj(app);
550 
551             // Procstate should be lower than FGS. (It should be SERVICE)
552             assertEquals(app.mState.getSetProcState(), PROCESS_STATE_SERVICE);
553             assertNoBfsl(app);
554         }
555     }
556 
557     @SuppressWarnings("GuardedBy")
558     @Test
testUpdateOomAdj_DoOne_OverlayUi()559     public void testUpdateOomAdj_DoOne_OverlayUi() {
560         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
561                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
562         app.mState.setHasOverlayUi(true);
563         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
564         updateOomAdj(app);
565 
566         assertProcStates(app, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
567                 SCHED_GROUP_DEFAULT);
568     }
569 
570     @SuppressWarnings("GuardedBy")
571     @Test
testUpdateOomAdj_DoOne_PerceptibleRecent_FgService()572     public void testUpdateOomAdj_DoOne_PerceptibleRecent_FgService() {
573         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
574                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
575         app.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
576         app.mState.setLastTopTime(SystemClock.uptimeMillis());
577         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
578         updateOomAdj(app);
579 
580         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE,
581                 PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ, SCHED_GROUP_DEFAULT);
582         assertBfsl(app);
583     }
584 
585     @SuppressWarnings("GuardedBy")
586     @Test
testUpdateOomAdj_DoOne_PerceptibleRecent_AlmostPerceptibleService()587     public void testUpdateOomAdj_DoOne_PerceptibleRecent_AlmostPerceptibleService() {
588         // Grace period allows the adjustment.
589         {
590             ProcessRecord system = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
591                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
592             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
593                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, true));
594             long nowUptime = SystemClock.uptimeMillis();
595             app.mState.setLastTopTime(nowUptime);
596             // Simulate the system starting and binding to a service in the app.
597             ServiceRecord s = bindService(app, system,
598                     null, Context.BIND_ALMOST_PERCEPTIBLE, mock(IBinder.class));
599             s.lastTopAlmostPerceptibleBindRequestUptimeMs = nowUptime;
600             s.getConnections().clear();
601             app.mServices.updateHasTopStartedAlmostPerceptibleServices();
602             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
603             updateOomAdj(app);
604 
605             assertEquals(PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ + 2, app.mState.getSetAdj());
606         }
607 
608         // Out of grace period but valid binding allows the adjustment.
609         {
610             ProcessRecord system = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
611                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
612             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
613                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, true));
614             long nowUptime = SystemClock.uptimeMillis();
615             app.mState.setLastTopTime(nowUptime);
616             // Simulate the system starting and binding to a service in the app.
617             ServiceRecord s = bindService(app, system,
618                     null, Context.BIND_ALMOST_PERCEPTIBLE + 2, mock(IBinder.class));
619             s.lastTopAlmostPerceptibleBindRequestUptimeMs =
620                     nowUptime - 2 * sService.mConstants.mServiceBindAlmostPerceptibleTimeoutMs;
621             app.mServices.updateHasTopStartedAlmostPerceptibleServices();
622             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
623             updateOomAdj(app);
624 
625             assertEquals(PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ + 2, app.mState.getSetAdj());
626         }
627 
628         // Out of grace period and no valid binding so no adjustment.
629         {
630             ProcessRecord system = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
631                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
632             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
633                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, true));
634             long nowUptime = SystemClock.uptimeMillis();
635             app.mState.setLastTopTime(nowUptime);
636             // Simulate the system starting and binding to a service in the app.
637             ServiceRecord s = bindService(app, system,
638                     null, Context.BIND_ALMOST_PERCEPTIBLE, mock(IBinder.class));
639             s.lastTopAlmostPerceptibleBindRequestUptimeMs =
640                     nowUptime - 2 * sService.mConstants.mServiceBindAlmostPerceptibleTimeoutMs;
641             s.getConnections().clear();
642             app.mServices.updateHasTopStartedAlmostPerceptibleServices();
643             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
644             updateOomAdj(app);
645 
646             assertNotEquals(PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ + 2, app.mState.getSetAdj());
647         }
648     }
649 
650     @SuppressWarnings("GuardedBy")
651     @Test
testUpdateOomAdj_DoOne_ImpFg_AlmostPerceptibleService()652     public void testUpdateOomAdj_DoOne_ImpFg_AlmostPerceptibleService() {
653         ProcessRecord system = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
654                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
655         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
656                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, true));
657         system.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
658         system.mState.setHasTopUi(true);
659         // Simulate the system starting and binding to a service in the app.
660         ServiceRecord s = bindService(app, system,
661                 null, Context.BIND_ALMOST_PERCEPTIBLE, mock(IBinder.class));
662         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
663         sService.mOomAdjuster.updateOomAdjLocked(app, OOM_ADJ_REASON_NONE);
664 
665         assertProcStates(app, PROCESS_STATE_IMPORTANT_FOREGROUND,
666                 PERCEPTIBLE_APP_ADJ + 1, SCHED_GROUP_DEFAULT);
667     }
668 
669     @SuppressWarnings("GuardedBy")
670     @Test
testUpdateOomAdj_DoOne_Toast()671     public void testUpdateOomAdj_DoOne_Toast() {
672         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
673                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
674         app.mState.setForcingToImportant(new Object());
675         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
676         updateOomAdj(app);
677 
678         assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
679                 SCHED_GROUP_DEFAULT);
680     }
681 
682     @SuppressWarnings("GuardedBy")
683     @Test
testUpdateOomAdj_DoOne_HeavyWeight()684     public void testUpdateOomAdj_DoOne_HeavyWeight() {
685         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
686                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
687         WindowProcessController wpc = app.getWindowProcessController();
688         doReturn(true).when(wpc).isHeavyWeightProcess();
689         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
690         updateOomAdj(app);
691         doReturn(false).when(wpc).isHeavyWeightProcess();
692 
693         assertProcStates(app, PROCESS_STATE_HEAVY_WEIGHT, HEAVY_WEIGHT_APP_ADJ,
694                 SCHED_GROUP_BACKGROUND);
695     }
696 
697     @SuppressWarnings("GuardedBy")
698     @Test
testUpdateOomAdj_DoOne_HomeApp()699     public void testUpdateOomAdj_DoOne_HomeApp() {
700         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
701                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
702         WindowProcessController wpc = app.getWindowProcessController();
703         doReturn(true).when(wpc).isHomeProcess();
704         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
705         updateOomAdj(app);
706 
707         assertProcStates(app, PROCESS_STATE_HOME, HOME_APP_ADJ, SCHED_GROUP_BACKGROUND);
708     }
709 
710     @SuppressWarnings("GuardedBy")
711     @Test
testUpdateOomAdj_DoOne_PreviousApp()712     public void testUpdateOomAdj_DoOne_PreviousApp() {
713         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
714                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
715         WindowProcessController wpc = app.getWindowProcessController();
716         doReturn(true).when(wpc).isPreviousProcess();
717         doReturn(true).when(wpc).hasActivities();
718         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
719         updateOomAdj(app);
720 
721         assertProcStates(app, PROCESS_STATE_LAST_ACTIVITY, PREVIOUS_APP_ADJ,
722                 SCHED_GROUP_BACKGROUND);
723     }
724 
725     @SuppressWarnings("GuardedBy")
726     @Test
testUpdateOomAdj_DoOne_Backup()727     public void testUpdateOomAdj_DoOne_Backup() {
728         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
729                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
730         BackupRecord backupTarget = new BackupRecord(null, 0, 0, 0);
731         backupTarget.app = app;
732         doReturn(backupTarget).when(sService.mBackupTargets).get(anyInt());
733         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
734         updateOomAdj(app);
735         doReturn(null).when(sService.mBackupTargets).get(anyInt());
736 
737         assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, BACKUP_APP_ADJ,
738                 SCHED_GROUP_BACKGROUND);
739     }
740 
741     @SuppressWarnings("GuardedBy")
742     @Test
testUpdateOomAdj_DoOne_ClientActivities()743     public void testUpdateOomAdj_DoOne_ClientActivities() {
744         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
745                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
746         app.mServices.setHasClientActivities(true);
747         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
748         updateOomAdj(app);
749 
750         assertEquals(PROCESS_STATE_CACHED_ACTIVITY_CLIENT, app.mState.getSetProcState());
751     }
752 
753     @SuppressWarnings("GuardedBy")
754     @Test
testUpdateOomAdj_DoOne_TreatLikeActivity()755     public void testUpdateOomAdj_DoOne_TreatLikeActivity() {
756         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
757                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
758         app.mServices.setTreatLikeActivity(true);
759         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
760         updateOomAdj(app);
761 
762         assertEquals(PROCESS_STATE_CACHED_ACTIVITY, app.mState.getSetProcState());
763     }
764 
765     @SuppressWarnings("GuardedBy")
766     @Test
testUpdateOomAdj_DoOne_ServiceB()767     public void testUpdateOomAdj_DoOne_ServiceB() {
768         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
769                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
770         app.mState.setServiceB(true);
771         ServiceRecord s = mock(ServiceRecord.class);
772         doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s).getConnections();
773         s.startRequested = true;
774         s.lastActivity = SystemClock.uptimeMillis();
775         app.mServices.startService(s);
776         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
777         updateOomAdj(app);
778 
779         assertProcStates(app, PROCESS_STATE_SERVICE, SERVICE_B_ADJ, SCHED_GROUP_BACKGROUND);
780     }
781 
782     @SuppressWarnings("GuardedBy")
783     @Test
testUpdateOomAdj_DoOne_MaxAdj()784     public void testUpdateOomAdj_DoOne_MaxAdj() {
785         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
786                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
787         app.mState.setMaxAdj(PERCEPTIBLE_LOW_APP_ADJ);
788         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
789         updateOomAdj(app);
790 
791         assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, PERCEPTIBLE_LOW_APP_ADJ,
792                 SCHED_GROUP_DEFAULT);
793     }
794 
795     @SuppressWarnings("GuardedBy")
796     @Test
testUpdateOomAdj_DoOne_NonCachedToCached()797     public void testUpdateOomAdj_DoOne_NonCachedToCached() {
798         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
799                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
800         app.mState.setCached(false);
801         app.mState.setCurRawAdj(SERVICE_ADJ);
802         doReturn(null).when(sService).getTopApp();
803         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
804         updateOomAdj(app);
805 
806         assertTrue(ProcessList.CACHED_APP_MIN_ADJ <= app.mState.getSetAdj());
807         assertTrue(ProcessList.CACHED_APP_MAX_ADJ >= app.mState.getSetAdj());
808     }
809 
810     @SuppressWarnings("GuardedBy")
811     @Test
testUpdateOomAdj_DoOne_Service_Started()812     public void testUpdateOomAdj_DoOne_Service_Started() {
813         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
814                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
815         ServiceRecord s = mock(ServiceRecord.class);
816         doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s).getConnections();
817         s.startRequested = true;
818         s.lastActivity = SystemClock.uptimeMillis();
819         app.mServices.startService(s);
820         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
821         updateOomAdj(app);
822 
823         assertProcStates(app, PROCESS_STATE_SERVICE, SERVICE_ADJ, SCHED_GROUP_BACKGROUND);
824     }
825 
826     @SuppressWarnings("GuardedBy")
827     @Test
testUpdateOomAdj_DoOne_Service_Started_WaivePriority()828     public void testUpdateOomAdj_DoOne_Service_Started_WaivePriority() {
829         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
830                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
831         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
832                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
833         ServiceRecord s = bindService(app, client, null, Context.BIND_WAIVE_PRIORITY,
834                 mock(IBinder.class));
835         s.startRequested = true;
836         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
837         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
838         doReturn(client).when(sService).getTopApp();
839         updateOomAdj(client, app);
840         doReturn(null).when(sService).getTopApp();
841 
842         assertProcStates(app, PROCESS_STATE_SERVICE, sFirstCachedAdj, SCHED_GROUP_BACKGROUND);
843     }
844 
845     @SuppressWarnings("GuardedBy")
846     @Test
testUpdateOomAdj_DoOne_Service_Started_WaivePriority_TreatLikeActivity()847     public void testUpdateOomAdj_DoOne_Service_Started_WaivePriority_TreatLikeActivity() {
848         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
849                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
850         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
851                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
852         bindService(app, client, null, Context.BIND_WAIVE_PRIORITY
853                 | Context.BIND_TREAT_LIKE_ACTIVITY, mock(IBinder.class));
854         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
855         updateOomAdj(client, app);
856 
857         assertEquals(PROCESS_STATE_CACHED_ACTIVITY, app.mState.getSetProcState());
858     }
859 
860     @SuppressWarnings("GuardedBy")
861     @Test
testUpdateOomAdj_DoOne_Service_Started_WaivePriority_AdjustWithActivity()862     public void testUpdateOomAdj_DoOne_Service_Started_WaivePriority_AdjustWithActivity() {
863         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
864                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
865         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
866                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
867         IBinder binder = mock(IBinder.class);
868         ServiceRecord s = bindService(app, client, null, Context.BIND_WAIVE_PRIORITY
869                 | Context.BIND_ADJUST_WITH_ACTIVITY | Context.BIND_IMPORTANT, binder);
870         ConnectionRecord cr = s.getConnections().get(binder).get(0);
871         setFieldValue(ConnectionRecord.class, cr, "activity",
872                 mock(ActivityServiceConnectionsHolder.class));
873         doReturn(true).when(cr.activity).isActivityVisible();
874         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
875         updateOomAdj(client, app);
876 
877         assertEquals(FOREGROUND_APP_ADJ, app.mState.getSetAdj());
878         assertEquals(SCHED_GROUP_TOP_APP_BOUND, app.mState.getSetSchedGroup());
879     }
880 
881     @SuppressWarnings("GuardedBy")
882     @Test
testUpdateOomAdj_DoOne_Service_Self()883     public void testUpdateOomAdj_DoOne_Service_Self() {
884         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
885                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
886         bindService(app, app, null, 0, mock(IBinder.class));
887         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
888         updateOomAdj(app);
889 
890         assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, sFirstCachedAdj, SCHED_GROUP_BACKGROUND);
891     }
892 
893     @SuppressWarnings("GuardedBy")
894     @Test
testUpdateOomAdj_DoOne_Service_CachedActivity()895     public void testUpdateOomAdj_DoOne_Service_CachedActivity() {
896         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
897                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
898         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
899                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
900         client.mServices.setTreatLikeActivity(true);
901         bindService(app, client, null, 0, mock(IBinder.class));
902         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
903         updateOomAdj(client, app);
904 
905         assertEquals(PROCESS_STATE_CACHED_EMPTY, app.mState.getSetProcState());
906     }
907 
908     @SuppressWarnings("GuardedBy")
909     @Test
testUpdateOomAdj_DoOne_Service_AllowOomManagement()910     public void testUpdateOomAdj_DoOne_Service_AllowOomManagement() {
911         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
912                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, true));
913         WindowProcessController wpc = app.getWindowProcessController();
914         doReturn(false).when(wpc).isHomeProcess();
915         doReturn(true).when(wpc).isPreviousProcess();
916         doReturn(true).when(wpc).hasActivities();
917         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
918                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
919         bindService(app, client, null, Context.BIND_ALLOW_OOM_MANAGEMENT, mock(IBinder.class));
920         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
921         doReturn(client).when(sService).getTopApp();
922         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
923         updateOomAdj(client, app);
924         doReturn(null).when(sService).getTopApp();
925 
926         assertEquals(PREVIOUS_APP_ADJ, app.mState.getSetAdj());
927     }
928 
929     @SuppressWarnings("GuardedBy")
930     @Test
testUpdateOomAdj_DoOne_Service_BoundByPersistentService()931     public void testUpdateOomAdj_DoOne_Service_BoundByPersistentService() {
932         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
933                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
934         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
935                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
936         bindService(app, client, null, Context.BIND_FOREGROUND_SERVICE, mock(IBinder.class));
937         client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
938         client.mState.setHasTopUi(true);
939         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
940         updateOomAdj(client, app);
941 
942         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, VISIBLE_APP_ADJ,
943                 SCHED_GROUP_DEFAULT);
944         assertBfsl(app);
945     }
946 
947     @SuppressWarnings("GuardedBy")
948     @Test
testUpdateOomAdj_DoOne_Service_Bound_ImportantFg()949     public void testUpdateOomAdj_DoOne_Service_Bound_ImportantFg() {
950         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
951                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
952         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
953                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
954         bindService(app, client, null, Context.BIND_IMPORTANT, mock(IBinder.class));
955         client.mServices.startExecutingService(mock(ServiceRecord.class));
956         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
957         updateOomAdj(client, app);
958 
959         assertEquals(FOREGROUND_APP_ADJ, app.mState.getSetAdj());
960         assertNoBfsl(app);
961     }
962 
963     @SuppressWarnings("GuardedBy")
964     @Test
testUpdateOomAdj_DoOne_Service_BoundByTop()965     public void testUpdateOomAdj_DoOne_Service_BoundByTop() {
966         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
967                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
968         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
969                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
970         bindService(app, client, null, 0, mock(IBinder.class));
971         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
972         doReturn(client).when(sService).getTopApp();
973         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
974         updateOomAdj(client, app);
975         doReturn(null).when(sService).getTopApp();
976 
977         assertProcStates(app, PROCESS_STATE_BOUND_TOP, VISIBLE_APP_ADJ, SCHED_GROUP_DEFAULT);
978     }
979 
980     @SuppressWarnings("GuardedBy")
981     @Test
testUpdateOomAdj_DoOne_Service_BoundFgService()982     public void testUpdateOomAdj_DoOne_Service_BoundFgService() {
983         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
984                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
985         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
986                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
987         bindService(app, client, null, Context.BIND_FOREGROUND_SERVICE, mock(IBinder.class));
988         client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
989         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
990         updateOomAdj(client, app);
991 
992         assertEquals(PROCESS_STATE_BOUND_FOREGROUND_SERVICE, app.mState.getSetProcState());
993         assertEquals(PROCESS_STATE_PERSISTENT, client.mState.getSetProcState());
994         assertBfsl(client);
995         assertBfsl(app);
996     }
997 
998     @SuppressWarnings("GuardedBy")
999     @Test
testUpdateOomAdj_DoOne_Service_BoundNotForeground()1000     public void testUpdateOomAdj_DoOne_Service_BoundNotForeground() {
1001         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1002                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1003         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1004                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1005         bindService(app, client, null, Context.BIND_NOT_FOREGROUND, mock(IBinder.class));
1006         client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1007         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1008         updateOomAdj(app);
1009 
1010         assertEquals(PROCESS_STATE_TRANSIENT_BACKGROUND, app.mState.getSetProcState());
1011         assertNoBfsl(app);
1012     }
1013 
1014     @SuppressWarnings("GuardedBy")
1015     @Test
testUpdateOomAdj_DoOne_Service_ImportantFgService()1016     public void testUpdateOomAdj_DoOne_Service_ImportantFgService() {
1017         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1018                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1019         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1020                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1021         bindService(app, client, null, 0, mock(IBinder.class));
1022         client.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1023         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1024         updateOomAdj(client, app);
1025 
1026         assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, client.mState.getSetProcState());
1027         assertBfsl(client);
1028         assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, app.mState.getSetProcState());
1029         assertBfsl(app);
1030     }
1031 
1032     @SuppressWarnings("GuardedBy")
1033     @Test
testUpdateOomAdj_DoOne_Service_ImportantFgService_ShortFgs()1034     public void testUpdateOomAdj_DoOne_Service_ImportantFgService_ShortFgs() {
1035         // Client has a SHORT_SERVICE FGS, which isn't allowed BFSL.
1036         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1037                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1038         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1039                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1040         bindService(app, client, null, 0, mock(IBinder.class));
1041 
1042         // In order to trick OomAdjuster to think it has a short-service, we need this logic.
1043         ServiceRecord s = ServiceRecord.newEmptyInstanceForTest(sService);
1044         s.startRequested = true;
1045         s.isForeground = true;
1046         s.foregroundServiceType = FOREGROUND_SERVICE_TYPE_SHORT_SERVICE;
1047         s.setShortFgsInfo(SystemClock.uptimeMillis());
1048         client.mServices.startService(s);
1049         client.mState.setLastTopTime(SystemClock.uptimeMillis());
1050 
1051         client.mServices.setHasForegroundServices(true, FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,
1052                 /* hasNoneType=*/false);
1053         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1054         updateOomAdj(client, app);
1055 
1056         // Client only has a SHORT_FGS, so it doesn't have BFSL, and that's propagated.
1057         assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, client.mState.getSetProcState());
1058         assertNoBfsl(client);
1059         assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, app.mState.getSetProcState());
1060         assertNoBfsl(app);
1061     }
1062 
1063     @SuppressWarnings("GuardedBy")
1064     @Test
testUpdateOomAdj_DoOne_Service_BoundForegroundService_with_ShortFgs()1065     public void testUpdateOomAdj_DoOne_Service_BoundForegroundService_with_ShortFgs() {
1066 
1067         // app2, which is bound by app1 (which makes it BFGS)
1068         // but it also has a short-fgs.
1069         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1070                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1071 
1072         // In order to trick OomAdjuster to think it has a short-service, we need this logic.
1073         ServiceRecord s = ServiceRecord.newEmptyInstanceForTest(sService);
1074         s.startRequested = true;
1075         s.isForeground = true;
1076         s.foregroundServiceType = FOREGROUND_SERVICE_TYPE_SHORT_SERVICE;
1077         s.setShortFgsInfo(SystemClock.uptimeMillis());
1078         app2.mServices.startService(s);
1079         app2.mState.setLastTopTime(SystemClock.uptimeMillis());
1080 
1081         app2.mServices.setHasForegroundServices(true, FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,
1082                 /* hasNoneType=*/false);
1083         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1084         updateOomAdj(app2);
1085 
1086         // Client only has a SHORT_FGS, so it doesn't have BFSL, and that's propagated.
1087         assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, app2.mState.getSetProcState());
1088         assertNoBfsl(app2);
1089 
1090         // Now, create a BFGS process (app1), and make it bind to app 2
1091 
1092         // Persistent process
1093         ProcessRecord pers = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1094                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1095         pers.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1096 
1097         // app1, which is bound by pers (which makes it BFGS)
1098         ProcessRecord app1 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1099                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1100 
1101         bindService(app1, pers, null, Context.BIND_FOREGROUND_SERVICE, mock(IBinder.class));
1102         bindService(app2, app1, null, 0, mock(IBinder.class));
1103 
1104         updateOomAdj(pers, app1, app2);
1105 
1106         assertEquals(PROCESS_STATE_BOUND_FOREGROUND_SERVICE, app1.mState.getSetProcState());
1107         assertBfsl(app1);
1108 
1109         // Now, app2 gets BFSL from app1.
1110         assertEquals(PROCESS_STATE_FOREGROUND_SERVICE, app2.mState.getSetProcState());
1111         assertBfsl(app2);
1112     }
1113 
1114     @SuppressWarnings("GuardedBy")
1115     @Test
testUpdateOomAdj_DoOne_Service_BoundByBackup_AboveClient()1116     public void testUpdateOomAdj_DoOne_Service_BoundByBackup_AboveClient() {
1117         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1118                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1119         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1120                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1121         bindService(app, client, null, Context.BIND_ABOVE_CLIENT, mock(IBinder.class));
1122         BackupRecord backupTarget = new BackupRecord(null, 0, 0, 0);
1123         backupTarget.app = client;
1124         doReturn(backupTarget).when(sService.mBackupTargets).get(anyInt());
1125         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1126         updateOomAdj(client, app);
1127 
1128         doReturn(null).when(sService.mBackupTargets).get(anyInt());
1129 
1130         assertEquals(BACKUP_APP_ADJ, app.mState.getSetAdj());
1131         assertNoBfsl(app);
1132 
1133         client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1134         updateOomAdj(app);
1135 
1136         assertEquals(PERSISTENT_SERVICE_ADJ, app.mState.getSetAdj());
1137         assertBfsl(app);
1138     }
1139 
1140     @SuppressWarnings("GuardedBy")
1141     @Test
testUpdateOomAdj_DoOne_Service_NotPerceptible()1142     public void testUpdateOomAdj_DoOne_Service_NotPerceptible() {
1143         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1144                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1145         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1146                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1147         bindService(app, client, null, Context.BIND_NOT_PERCEPTIBLE, mock(IBinder.class));
1148         client.mState.setRunningRemoteAnimation(true);
1149         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1150         updateOomAdj(app);
1151 
1152         assertEquals(PERCEPTIBLE_LOW_APP_ADJ, app.mState.getSetAdj());
1153     }
1154 
1155     @SuppressWarnings("GuardedBy")
1156     @Test
testUpdateOomAdj_DoOne_Service_NotVisible()1157     public void testUpdateOomAdj_DoOne_Service_NotVisible() {
1158         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1159                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1160         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1161                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1162         bindService(app, client, null, Context.BIND_NOT_VISIBLE, mock(IBinder.class));
1163         client.mState.setRunningRemoteAnimation(true);
1164         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1165         updateOomAdj(client, app);
1166 
1167         assertEquals(PERCEPTIBLE_APP_ADJ, app.mState.getSetAdj());
1168     }
1169 
1170     @SuppressWarnings("GuardedBy")
1171     @Test
testUpdateOomAdj_DoOne_Service_Perceptible()1172     public void testUpdateOomAdj_DoOne_Service_Perceptible() {
1173         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1174                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1175         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1176                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1177         bindService(app, client, null, 0, mock(IBinder.class));
1178         client.mState.setHasOverlayUi(true);
1179         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1180         updateOomAdj(client, app);
1181 
1182         assertEquals(PERCEPTIBLE_APP_ADJ, app.mState.getSetAdj());
1183     }
1184 
1185     @SuppressWarnings("GuardedBy")
1186     @Test
testUpdateOomAdj_DoOne_Service_AlmostPerceptible()1187     public void testUpdateOomAdj_DoOne_Service_AlmostPerceptible() {
1188         {
1189             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1190                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1191             ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1192                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1193             bindService(app, client, null,
1194                     Context.BIND_ALMOST_PERCEPTIBLE | Context.BIND_NOT_FOREGROUND,
1195                     mock(IBinder.class));
1196             client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1197             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1198             updateOomAdj(client, app);
1199 
1200             assertEquals(PERCEPTIBLE_MEDIUM_APP_ADJ + 2, app.mState.getSetAdj());
1201         }
1202 
1203         {
1204             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1205                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1206             ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1207                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1208             WindowProcessController wpc = client.getWindowProcessController();
1209             doReturn(true).when(wpc).isHeavyWeightProcess();
1210             bindService(app, client, null,
1211                     Context.BIND_ALMOST_PERCEPTIBLE | Context.BIND_NOT_FOREGROUND,
1212                     mock(IBinder.class));
1213             client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1214             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1215             updateOomAdj(client, app);
1216             doReturn(false).when(wpc).isHeavyWeightProcess();
1217 
1218             assertEquals(PERCEPTIBLE_MEDIUM_APP_ADJ + 2, app.mState.getSetAdj());
1219         }
1220 
1221         {
1222             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1223                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1224             ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1225                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1226             bindService(app, client, null,
1227                     Context.BIND_ALMOST_PERCEPTIBLE,
1228                     mock(IBinder.class));
1229             client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1230             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1231             sService.mOomAdjuster.updateOomAdjLocked(app, OOM_ADJ_REASON_NONE);
1232 
1233             assertEquals(PERCEPTIBLE_APP_ADJ + 1, app.mState.getSetAdj());
1234         }
1235 
1236         {
1237             ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1238                     MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1239             ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1240                     MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1241             WindowProcessController wpc = client.getWindowProcessController();
1242             doReturn(true).when(wpc).isHeavyWeightProcess();
1243             bindService(app, client, null,
1244                     Context.BIND_ALMOST_PERCEPTIBLE,
1245                     mock(IBinder.class));
1246             client.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1247             sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1248             sService.mOomAdjuster.updateOomAdjLocked(app, OOM_ADJ_REASON_NONE);
1249             doReturn(false).when(wpc).isHeavyWeightProcess();
1250 
1251             assertEquals(PERCEPTIBLE_APP_ADJ + 1, app.mState.getSetAdj());
1252         }
1253     }
1254 
1255     @SuppressWarnings("GuardedBy")
1256     @Test
testUpdateOomAdj_DoOne_Service_Other()1257     public void testUpdateOomAdj_DoOne_Service_Other() {
1258         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1259                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1260         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1261                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1262         bindService(app, client, null, 0, mock(IBinder.class));
1263         client.mState.setRunningRemoteAnimation(true);
1264         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1265         updateOomAdj(client, app);
1266 
1267         assertEquals(VISIBLE_APP_ADJ, app.mState.getSetAdj());
1268     }
1269 
1270     @SuppressWarnings("GuardedBy")
1271     @Test
testUpdateOomAdj_DoOne_Service_Bind_ImportantBg()1272     public void testUpdateOomAdj_DoOne_Service_Bind_ImportantBg() {
1273         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1274                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1275         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1276                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1277         bindService(app, client, null, Context.BIND_IMPORTANT_BACKGROUND, mock(IBinder.class));
1278         client.mState.setHasOverlayUi(true);
1279         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1280         updateOomAdj(client, app);
1281 
1282         assertEquals(PROCESS_STATE_IMPORTANT_BACKGROUND, app.mState.getSetProcState());
1283         assertNoBfsl(app);
1284     }
1285 
1286     @SuppressWarnings("GuardedBy")
1287     @Test
testUpdateOomAdj_DoOne_Provider_Self()1288     public void testUpdateOomAdj_DoOne_Provider_Self() {
1289         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1290                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1291         bindProvider(app, app, null, null, false);
1292         updateOomAdj(app);
1293 
1294         assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, sFirstCachedAdj, SCHED_GROUP_BACKGROUND);
1295     }
1296 
1297     @SuppressWarnings("GuardedBy")
1298     @Test
testUpdateOomAdj_DoOne_Provider_Cached_Activity()1299     public void testUpdateOomAdj_DoOne_Provider_Cached_Activity() {
1300         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1301                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1302         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1303                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1304         bindProvider(app, client, null, null, false);
1305         client.mServices.setTreatLikeActivity(true);
1306         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1307         updateOomAdj(app, client);
1308 
1309         assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, sFirstCachedAdj, SCHED_GROUP_BACKGROUND);
1310     }
1311 
1312     @SuppressWarnings("GuardedBy")
1313     @Test
testUpdateOomAdj_DoOne_Provider_TopApp()1314     public void testUpdateOomAdj_DoOne_Provider_TopApp() {
1315         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1316                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1317         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1318                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1319         bindProvider(app, client, null, null, false);
1320         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
1321         doReturn(client).when(sService).getTopApp();
1322         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1323         updateOomAdj(client, app);
1324         doReturn(null).when(sService).getTopApp();
1325 
1326         assertProcStates(app, PROCESS_STATE_BOUND_TOP, FOREGROUND_APP_ADJ, SCHED_GROUP_DEFAULT);
1327     }
1328 
1329     @SuppressWarnings("GuardedBy")
1330     @Test
testUpdateOomAdj_DoOne_Provider_FgService()1331     public void testUpdateOomAdj_DoOne_Provider_FgService() {
1332         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1333                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1334         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1335                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1336         client.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1337         bindProvider(app, client, null, null, false);
1338         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1339         updateOomAdj(client, app);
1340 
1341         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1342                 SCHED_GROUP_DEFAULT);
1343         assertBfsl(app);
1344     }
1345 
1346     @SuppressWarnings("GuardedBy")
1347     @Test
testUpdateOomAdj_DoOne_Provider_FgService_ShortFgs()1348     public void testUpdateOomAdj_DoOne_Provider_FgService_ShortFgs() {
1349         // Client has a SHORT_SERVICE FGS, which isn't allowed BFSL.
1350         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1351                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1352         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1353                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1354 
1355         // In order to trick OomAdjuster to think it has a short-service, we need this logic.
1356         ServiceRecord s = ServiceRecord.newEmptyInstanceForTest(sService);
1357         s.startRequested = true;
1358         s.isForeground = true;
1359         s.foregroundServiceType = FOREGROUND_SERVICE_TYPE_SHORT_SERVICE;
1360         s.setShortFgsInfo(SystemClock.uptimeMillis());
1361         client.mServices.startService(s);
1362         client.mState.setLastTopTime(SystemClock.uptimeMillis());
1363 
1364         client.mServices.setHasForegroundServices(true, FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,
1365                 /* hasNoneType=*/false);
1366         bindProvider(app, client, null, null, false);
1367         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1368         updateOomAdj(client, app);
1369 
1370         // Client only has a SHORT_FGS, so it doesn't have BFSL, and that's propagated.
1371         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE,
1372                 PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ + 1,
1373                 SCHED_GROUP_DEFAULT);
1374         assertNoBfsl(client);
1375         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE,
1376                 PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ + 1,
1377                 SCHED_GROUP_DEFAULT);
1378         assertNoBfsl(app);
1379     }
1380 
1381     @SuppressWarnings("GuardedBy")
1382     @Test
testUpdateOomAdj_DoOne_Provider_ExternalProcessHandles()1383     public void testUpdateOomAdj_DoOne_Provider_ExternalProcessHandles() {
1384         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1385                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1386         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1387                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1388         bindProvider(app, client, null, null, true);
1389         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1390         updateOomAdj(client, app);
1391 
1392         assertProcStates(app, PROCESS_STATE_IMPORTANT_FOREGROUND, FOREGROUND_APP_ADJ,
1393                 SCHED_GROUP_DEFAULT);
1394     }
1395 
1396     @SuppressWarnings("GuardedBy")
1397     @Test
testUpdateOomAdj_DoOne_Provider_Retention()1398     public void testUpdateOomAdj_DoOne_Provider_Retention() {
1399         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1400                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1401         app.mProviders.setLastProviderTime(SystemClock.uptimeMillis());
1402         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1403         updateOomAdj(app);
1404 
1405         assertProcStates(app, PROCESS_STATE_LAST_ACTIVITY, PREVIOUS_APP_ADJ,
1406                 SCHED_GROUP_BACKGROUND);
1407     }
1408 
1409     @SuppressWarnings("GuardedBy")
1410     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByTop()1411     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByTop() {
1412         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1413                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1414         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1415                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1416         bindService(app, client, null, 0, mock(IBinder.class));
1417         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1418                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1419         bindService(client, client2, null, 0, mock(IBinder.class));
1420         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
1421         doReturn(client2).when(sService).getTopApp();
1422         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1423         updateOomAdj(client, client2, app);
1424         doReturn(null).when(sService).getTopApp();
1425 
1426         assertProcStates(app, PROCESS_STATE_BOUND_TOP, VISIBLE_APP_ADJ,
1427                 SCHED_GROUP_DEFAULT);
1428     }
1429 
1430     @SuppressWarnings("GuardedBy")
1431     @Test
testUpdateOomAdj_DoOne_Service_BoundByFgService_Branch()1432     public void testUpdateOomAdj_DoOne_Service_BoundByFgService_Branch() {
1433         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1434                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1435         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1436                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1437         bindService(app, client, null, 0, mock(IBinder.class));
1438         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1439                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1440         bindService(app, client2, null, 0, mock(IBinder.class));
1441         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1442         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1443         updateOomAdj(client, client2, app);
1444 
1445         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1446                 SCHED_GROUP_DEFAULT);
1447         assertBfsl(app);
1448     }
1449 
1450     @SuppressWarnings("GuardedBy")
1451     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService()1452     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService() {
1453         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1454                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1455         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1456                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1457         bindService(app, client, null, 0, mock(IBinder.class));
1458         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1459                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1460         bindService(client, client2, null, 0, mock(IBinder.class));
1461         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1462         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1463         updateOomAdj(client, client2, app);
1464 
1465         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1466                 SCHED_GROUP_DEFAULT);
1467         assertBfsl(app);
1468     }
1469 
1470     @SuppressWarnings("GuardedBy")
1471     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle()1472     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle() {
1473         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1474                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1475         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1476                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1477         bindService(app, client, null, 0, mock(IBinder.class));
1478         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1479                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1480         bindService(client, client2, null, 0, mock(IBinder.class));
1481         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1482         bindService(client2, app, null, 0, mock(IBinder.class));
1483 
1484         // Note: We add processes to LRU but still call updateOomAdjLocked() with a specific
1485         // processes.
1486         setProcessesToLru(app, client, client2);
1487         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1488         updateOomAdj(app);
1489 
1490         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1491                 SCHED_GROUP_DEFAULT);
1492         assertProcStates(client, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1493                 SCHED_GROUP_DEFAULT);
1494         assertProcStates(client2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1495                 SCHED_GROUP_DEFAULT);
1496         assertBfsl(app);
1497         assertBfsl(client);
1498         assertBfsl(client2);
1499 
1500         client2.mServices.setHasForegroundServices(false, 0, /* hasNoneType=*/false);
1501         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1502         sService.mOomAdjuster.updateOomAdjLocked(client2, OOM_ADJ_REASON_NONE);
1503 
1504         assertEquals(PROCESS_STATE_CACHED_EMPTY, client2.mState.getSetProcState());
1505         assertEquals(PROCESS_STATE_CACHED_EMPTY, client.mState.getSetProcState());
1506         assertEquals(PROCESS_STATE_CACHED_EMPTY, app.mState.getSetProcState());
1507         assertNoBfsl(app);
1508         assertNoBfsl(client);
1509         assertNoBfsl(client2);
1510     }
1511 
1512     @SuppressWarnings("GuardedBy")
1513     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_2()1514     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_2() {
1515         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1516                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1517         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1518                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1519         bindService(app, client, null, 0, mock(IBinder.class));
1520         bindService(client, app, null, 0, mock(IBinder.class));
1521         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1522                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1523         bindService(client2, client, null, 0, mock(IBinder.class));
1524         client.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1525         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1526         updateOomAdj(app, client, client2);
1527 
1528         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1529                 SCHED_GROUP_DEFAULT);
1530         assertProcStates(client, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1531                 SCHED_GROUP_DEFAULT);
1532         assertProcStates(client2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1533                 SCHED_GROUP_DEFAULT);
1534         assertBfsl(app);
1535         assertBfsl(client);
1536         assertBfsl(client2);
1537     }
1538 
1539     @SuppressWarnings("GuardedBy")
1540     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_3()1541     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_3() {
1542         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1543                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1544         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1545                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1546         bindService(app, client, null, 0, mock(IBinder.class));
1547         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1548                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1549         bindService(client, client2, null, 0, mock(IBinder.class));
1550         bindService(client2, client, null, 0, mock(IBinder.class));
1551         client.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1552         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1553         updateOomAdj(app, client, client2);
1554 
1555         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1556                 SCHED_GROUP_DEFAULT);
1557         assertProcStates(client, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1558                 SCHED_GROUP_DEFAULT);
1559         assertProcStates(client2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1560                 SCHED_GROUP_DEFAULT);
1561         assertBfsl(app);
1562         assertBfsl(client);
1563         assertBfsl(client2);
1564     }
1565 
1566     @SuppressWarnings("GuardedBy")
1567     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_4()1568     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_4() {
1569         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1570                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1571         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1572                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1573         bindService(app, client, null, 0, mock(IBinder.class));
1574         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1575                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1576         bindService(client, client2, null, 0, mock(IBinder.class));
1577         bindService(client2, client, null, 0, mock(IBinder.class));
1578         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1579                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1580         bindService(client3, client, null, 0, mock(IBinder.class));
1581         ProcessRecord client4 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1582                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1583         bindService(client3, client4, null, 0, mock(IBinder.class));
1584         bindService(client4, client3, null, 0, mock(IBinder.class));
1585         client.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1586         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1587         updateOomAdj(app, client, client2, client3, client4);
1588 
1589         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1590                 SCHED_GROUP_DEFAULT);
1591         assertProcStates(client, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1592                 SCHED_GROUP_DEFAULT);
1593         assertProcStates(client2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1594                 SCHED_GROUP_DEFAULT);
1595         assertProcStates(client3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1596                 SCHED_GROUP_DEFAULT);
1597         assertProcStates(client4, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1598                 SCHED_GROUP_DEFAULT);
1599         assertBfsl(app);
1600         assertBfsl(client);
1601         assertBfsl(client2);
1602         assertBfsl(client3);
1603         assertBfsl(client4);
1604     }
1605 
1606     @SuppressWarnings("GuardedBy")
1607     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_Branch()1608     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_Branch() {
1609         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1610                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1611         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1612                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1613         bindService(app, client, null, 0, mock(IBinder.class));
1614         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1615                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1616         bindService(client, client2, null, 0, mock(IBinder.class));
1617         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1618         bindService(client2, app, null, 0, mock(IBinder.class));
1619         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1620                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1621         client3.mState.setForcingToImportant(new Object());
1622         bindService(app, client3, null, 0, mock(IBinder.class));
1623         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1624         updateOomAdj(app, client, client2, client3);
1625 
1626         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1627                 SCHED_GROUP_DEFAULT);
1628         assertBfsl(app);
1629     }
1630 
1631     @SuppressWarnings("GuardedBy")
1632     @Test
testUpdateOomAdj_DoOne_Service_Chain_Perceptible_Cycle_Branch()1633     public void testUpdateOomAdj_DoOne_Service_Chain_Perceptible_Cycle_Branch() {
1634         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1635                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1636         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1637                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1638         bindService(app, client, null, 0, mock(IBinder.class));
1639         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1640                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1641         bindService(client, client2, null, 0, mock(IBinder.class));
1642         bindService(client2, app, null, 0, mock(IBinder.class));
1643         WindowProcessController wpc = client2.getWindowProcessController();
1644         doReturn(true).when(wpc).isHomeProcess();
1645         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1646                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1647         client3.mState.setForcingToImportant(new Object());
1648         bindService(app, client3, null, 0, mock(IBinder.class));
1649         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1650         updateOomAdj(app, client, client2, client3);
1651 
1652         assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
1653                 SCHED_GROUP_DEFAULT);
1654     }
1655 
1656     @SuppressWarnings("GuardedBy")
1657     @Test
testUpdateOomAdj_DoOne_Service_Chain_Perceptible_Cycle_2()1658     public void testUpdateOomAdj_DoOne_Service_Chain_Perceptible_Cycle_2() {
1659         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1660                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1661         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1662                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1663         bindService(app, client, null, 0, mock(IBinder.class));
1664         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1665                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1666         bindService(client, client2, null, 0, mock(IBinder.class));
1667         bindService(client2, app, null, 0, mock(IBinder.class));
1668         WindowProcessController wpc = client2.getWindowProcessController();
1669         doReturn(true).when(wpc).isHomeProcess();
1670         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1671                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1672         ProcessRecord client4 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1673                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1674         client4.mState.setForcingToImportant(new Object());
1675         bindService(app, client4, null, 0, mock(IBinder.class));
1676         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1677         updateOomAdj(app, client, client2, client3, client4);
1678 
1679         assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
1680                 SCHED_GROUP_DEFAULT);
1681     }
1682 
1683     @SuppressWarnings("GuardedBy")
1684     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_Branch_2()1685     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Cycle_Branch_2() {
1686         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1687                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1688         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1689                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1690         bindService(app, client, null, 0, mock(IBinder.class));
1691         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1692                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1693         bindService(client, client2, null, 0, mock(IBinder.class));
1694         bindService(client2, app, null, 0, mock(IBinder.class));
1695         WindowProcessController wpc = client2.getWindowProcessController();
1696         doReturn(true).when(wpc).isHomeProcess();
1697         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1698                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1699         client3.mState.setForcingToImportant(new Object());
1700         bindService(app, client3, null, 0, mock(IBinder.class));
1701         ProcessRecord client4 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
1702                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
1703         client4.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1704         bindService(app, client4, null, 0, mock(IBinder.class));
1705         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1706         updateOomAdj(app, client, client2, client3, client4);
1707 
1708         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1709                 SCHED_GROUP_DEFAULT);
1710         assertBfsl(app);
1711     }
1712 
1713     @SuppressWarnings("GuardedBy")
1714     @Test
testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Branch_3()1715     public void testUpdateOomAdj_DoOne_Service_Chain_BoundByFgService_Branch_3() {
1716         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1717                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1718         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1719                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1720         WindowProcessController wpc = client.getWindowProcessController();
1721         doReturn(true).when(wpc).isHomeProcess();
1722         bindService(app, client, null, 0, mock(IBinder.class));
1723         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1724                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1725         bindService(app, client2, null, 0, mock(IBinder.class));
1726         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1727         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1728                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1729         client3.mState.setForcingToImportant(new Object());
1730         bindService(app, client3, null, 0, mock(IBinder.class));
1731         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1732         updateOomAdj(client, client2, client3, app);
1733 
1734         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1735                 SCHED_GROUP_DEFAULT);
1736         assertBfsl(app);
1737     }
1738 
1739     @SuppressWarnings("GuardedBy")
1740     @Test
testUpdateOomAdj_DoOne_Service_Provider()1741     public void testUpdateOomAdj_DoOne_Service_Provider() {
1742         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1743                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1744         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1745                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1746         bindService(app, client, null, 0, mock(IBinder.class));
1747         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1748                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1749         bindProvider(client, client2, null, null, false);
1750         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1751         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1752         updateOomAdj(client, client2, app);
1753 
1754         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1755                 SCHED_GROUP_DEFAULT);
1756         assertBfsl(app);
1757     }
1758 
1759     @SuppressWarnings("GuardedBy")
1760     @Test
testUpdateOomAdj_DoOne_Service_Provider_Cycle()1761     public void testUpdateOomAdj_DoOne_Service_Provider_Cycle() {
1762         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1763                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1764         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1765                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1766         bindService(app, client, null, 0, mock(IBinder.class));
1767         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1768                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1769         bindProvider(client, client2, null, null, false);
1770         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1771         bindService(client2, app, null, 0, mock(IBinder.class));
1772         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1773         updateOomAdj(app, client, client2);
1774 
1775         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1776                 SCHED_GROUP_DEFAULT);
1777         assertBfsl(app);
1778     }
1779 
1780     @SuppressWarnings("GuardedBy")
1781     @Test
testUpdateOomAdj_DoOne_Provider_Chain_BoundByFgService()1782     public void testUpdateOomAdj_DoOne_Provider_Chain_BoundByFgService() {
1783         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1784                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1785         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1786                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1787         bindProvider(app, client, null, null, false);
1788         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1789                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1790         bindProvider(client, client2, null, null, false);
1791         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1792         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1793         updateOomAdj(client, client2, app);
1794 
1795         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1796                 SCHED_GROUP_DEFAULT);
1797         assertBfsl(app);
1798     }
1799 
1800     @SuppressWarnings("GuardedBy")
1801     @Test
testUpdateOomAdj_DoOne_Provider_Chain_BoundByFgService_Cycle()1802     public void testUpdateOomAdj_DoOne_Provider_Chain_BoundByFgService_Cycle() {
1803         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1804                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1805         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1806                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1807         bindProvider(app, client, null, null, false);
1808         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1809                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1810         bindProvider(client, client2, null, null, false);
1811         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1812         bindProvider(client2, app, null, null, false);
1813         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1814         updateOomAdj(app, client, client2);
1815 
1816         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1817                 SCHED_GROUP_DEFAULT);
1818         assertBfsl(app);
1819     }
1820 
1821     @SuppressWarnings("GuardedBy")
1822     @Test
testUpdateOomAdj_DoOne_ScheduleLikeTop()1823     public void testUpdateOomAdj_DoOne_ScheduleLikeTop() {
1824         final ProcessRecord app1 = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1825                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1826         final ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1827                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1828         final ProcessRecord client1 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1829                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1830         final ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1831                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1832         bindService(app1, client1, null, Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE,
1833                 mock(IBinder.class));
1834         bindService(app2, client2, null, Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE,
1835                 mock(IBinder.class));
1836         client1.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1837         client2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1838 
1839         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1840         updateOomAdj(client1, client2, app1, app2);
1841 
1842         assertProcStates(app1, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, VISIBLE_APP_ADJ,
1843                 SCHED_GROUP_DEFAULT);
1844         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1845                 SCHED_GROUP_DEFAULT);
1846         assertBfsl(app1);
1847         assertBfsl(app2);
1848 
1849         bindService(app1, client1, null, Context.BIND_SCHEDULE_LIKE_TOP_APP, mock(IBinder.class));
1850         bindService(app2, client2, null, Context.BIND_SCHEDULE_LIKE_TOP_APP, mock(IBinder.class));
1851         updateOomAdj(app1, app2);
1852 
1853         assertProcStates(app1, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, VISIBLE_APP_ADJ,
1854                 SCHED_GROUP_TOP_APP);
1855         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1856                 SCHED_GROUP_DEFAULT);
1857 
1858         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_ASLEEP);
1859         updateOomAdj(client1, client2, app1, app2);
1860         assertProcStates(app1, PROCESS_STATE_IMPORTANT_FOREGROUND, VISIBLE_APP_ADJ,
1861                 SCHED_GROUP_TOP_APP);
1862         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1863                 SCHED_GROUP_DEFAULT);
1864         assertBfsl(app2);
1865 
1866         bindService(client2, app1, null, 0, mock(IBinder.class));
1867         bindService(app1, client2, null, 0, mock(IBinder.class));
1868         client2.mServices.setHasForegroundServices(false, 0, /* hasNoneType=*/false);
1869         updateOomAdj(app1, client1, client2);
1870         assertProcStates(app1, PROCESS_STATE_IMPORTANT_FOREGROUND, VISIBLE_APP_ADJ,
1871                 SCHED_GROUP_TOP_APP);
1872     }
1873 
1874     @SuppressWarnings("GuardedBy")
1875     @Test
testUpdateOomAdj_DoOne_TreatLikeVisFGS()1876     public void testUpdateOomAdj_DoOne_TreatLikeVisFGS() {
1877         final ProcessRecord app1 = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1878                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1879         final ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
1880                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
1881         final ProcessRecord client1 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1882                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1883         final ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
1884                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
1885         client1.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1886         client2.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1887 
1888         final ServiceRecord s1 = bindService(app1, client1, null,
1889                 Context.BIND_TREAT_LIKE_VISIBLE_FOREGROUND_SERVICE, mock(IBinder.class));
1890         final ServiceRecord s2 = bindService(app2, client2, null,
1891                 Context.BIND_IMPORTANT, mock(IBinder.class));
1892 
1893         updateOomAdj(client1, client2, app1, app2);
1894 
1895         assertProcStates(app1, PROCESS_STATE_FOREGROUND_SERVICE, VISIBLE_APP_ADJ,
1896                 SCHED_GROUP_DEFAULT);
1897         assertProcStates(app2, PROCESS_STATE_PERSISTENT, PERSISTENT_SERVICE_ADJ,
1898                 SCHED_GROUP_DEFAULT);
1899 
1900         bindService(app2, client1, s2, Context.BIND_TREAT_LIKE_VISIBLE_FOREGROUND_SERVICE,
1901                 mock(IBinder.class));
1902         updateOomAdj(app2);
1903         assertProcStates(app2, PROCESS_STATE_PERSISTENT, PERSISTENT_SERVICE_ADJ,
1904                 SCHED_GROUP_DEFAULT);
1905 
1906         s1.getConnections().clear();
1907         s2.getConnections().clear();
1908         client1.mState.setMaxAdj(UNKNOWN_ADJ);
1909         client2.mState.setMaxAdj(UNKNOWN_ADJ);
1910         client1.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1911         client2.mState.setHasOverlayUi(true);
1912 
1913         bindService(app1, client1, s1, Context.BIND_TREAT_LIKE_VISIBLE_FOREGROUND_SERVICE,
1914                 mock(IBinder.class));
1915         bindService(app2, client2, s2, Context.BIND_TREAT_LIKE_VISIBLE_FOREGROUND_SERVICE,
1916                 mock(IBinder.class));
1917 
1918         updateOomAdj(app1, app2);
1919 
1920         // VISIBLE_APP_ADJ is the max oom-adj for BIND_TREAT_LIKE_VISIBLE_FOREGROUND_SERVICE.
1921         assertProcStates(app1, PROCESS_STATE_FOREGROUND_SERVICE, VISIBLE_APP_ADJ,
1922                 SCHED_GROUP_DEFAULT);
1923         assertProcStates(app2, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
1924                 SCHED_GROUP_DEFAULT);
1925 
1926         client2.mState.setHasOverlayUi(false);
1927         doReturn(PROCESS_STATE_TOP).when(sService.mAtmInternal).getTopProcessState();
1928         doReturn(client2).when(sService).getTopApp();
1929         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1930 
1931         sService.mOomAdjuster.updateOomAdjLocked(app2, OOM_ADJ_REASON_NONE);
1932         assertProcStates(app2, PROCESS_STATE_BOUND_TOP, VISIBLE_APP_ADJ,
1933                 SCHED_GROUP_DEFAULT);
1934     }
1935 
1936     @SuppressWarnings("GuardedBy")
1937     @Test
testUpdateOomAdj_DoOne_BindNotPerceptibleFGS()1938     public void testUpdateOomAdj_DoOne_BindNotPerceptibleFGS() {
1939         final ProcessRecord app1 = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1940                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1941         final ProcessRecord client1 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1942                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1943         client1.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1944 
1945         app1.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1946         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1947 
1948         bindService(app1, client1, null, Context.BIND_NOT_PERCEPTIBLE, mock(IBinder.class));
1949 
1950         updateOomAdj(client1, app1);
1951 
1952         assertProcStates(app1, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1953                 SCHED_GROUP_DEFAULT);
1954         assertBfsl(app1);
1955     }
1956 
1957     @SuppressWarnings("GuardedBy")
1958     @Test
testUpdateOomAdj_DoOne_BindAlmostPerceptibleFGS()1959     public void testUpdateOomAdj_DoOne_BindAlmostPerceptibleFGS() {
1960         final ProcessRecord app1 = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1961                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1962         final ProcessRecord client1 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
1963                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
1964         client1.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
1965 
1966         app1.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
1967         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
1968 
1969         bindService(app1, client1, null, Context.BIND_ALMOST_PERCEPTIBLE, mock(IBinder.class));
1970 
1971         updateOomAdj(client1, app1);
1972 
1973         assertProcStates(app1, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
1974                 SCHED_GROUP_DEFAULT);
1975         assertBfsl(app1);
1976     }
1977 
1978     @SuppressWarnings("GuardedBy")
1979     @Test
testUpdateOomAdj_DoOne_PendingFinishAttach()1980     public void testUpdateOomAdj_DoOne_PendingFinishAttach() {
1981         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1982                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1983         app.setPendingFinishAttach(true);
1984         app.mState.setHasForegroundActivities(false);
1985 
1986         sService.mOomAdjuster.setAttachingProcessStatesLSP(app);
1987         updateOomAdj(app);
1988 
1989         assertProcStates(app, PROCESS_STATE_CACHED_EMPTY, FOREGROUND_APP_ADJ,
1990                 SCHED_GROUP_DEFAULT);
1991     }
1992 
1993     @SuppressWarnings("GuardedBy")
1994     @Test
testUpdateOomAdj_DoOne_TopApp_PendingFinishAttach()1995     public void testUpdateOomAdj_DoOne_TopApp_PendingFinishAttach() {
1996         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
1997                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
1998         app.setPendingFinishAttach(true);
1999         app.mState.setHasForegroundActivities(true);
2000 
2001         sService.mOomAdjuster.setAttachingProcessStatesLSP(app);
2002         updateOomAdj(app);
2003 
2004         assertProcStates(app, PROCESS_STATE_TOP, FOREGROUND_APP_ADJ,
2005                 SCHED_GROUP_TOP_APP);
2006     }
2007 
2008     @SuppressWarnings("GuardedBy")
2009     @Test
testUpdateOomAdj_UidIdle_StopService()2010     public void testUpdateOomAdj_UidIdle_StopService() {
2011         final ProcessRecord app1 = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2012                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2013         final ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2014                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2015         final ProcessRecord client1 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2016                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2017         final ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP3_UID,
2018                 MOCKAPP4_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2019         final ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
2020                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
2021         final UidRecord app1UidRecord = new UidRecord(MOCKAPP_UID, sService);
2022         final UidRecord app2UidRecord = new UidRecord(MOCKAPP2_UID, sService);
2023         final UidRecord app3UidRecord = new UidRecord(MOCKAPP5_UID, sService);
2024         final UidRecord clientUidRecord = new UidRecord(MOCKAPP3_UID, sService);
2025         app1.setUidRecord(app1UidRecord);
2026         app2.setUidRecord(app2UidRecord);
2027         app3.setUidRecord(app3UidRecord);
2028         client1.setUidRecord(clientUidRecord);
2029         client2.setUidRecord(clientUidRecord);
2030 
2031         client1.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2032         client2.mState.setForcingToImportant(new Object());
2033         setProcessesToLru(app1, app2, app3, client1, client2);
2034         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2035 
2036         final ComponentName cn1 = ComponentName.unflattenFromString(
2037                 MOCKAPP_PACKAGENAME + "/.TestService");
2038         final ServiceRecord s1 = bindService(app1, client1, null, 0, mock(IBinder.class));
2039         setFieldValue(ServiceRecord.class, s1, "name", cn1);
2040         s1.startRequested = true;
2041 
2042         final ComponentName cn2 = ComponentName.unflattenFromString(
2043                 MOCKAPP2_PACKAGENAME + "/.TestService");
2044         final ServiceRecord s2 = bindService(app2, client2, null, 0, mock(IBinder.class));
2045         setFieldValue(ServiceRecord.class, s2, "name", cn2);
2046         s2.startRequested = true;
2047 
2048         final ComponentName cn3 = ComponentName.unflattenFromString(
2049                 MOCKAPP5_PACKAGENAME + "/.TestService");
2050         final ServiceRecord s3 = bindService(app3, client1, null, 0, mock(IBinder.class));
2051         setFieldValue(ServiceRecord.class, s3, "name", cn3);
2052         s3.startRequested = true;
2053 
2054         final ComponentName cn4 = ComponentName.unflattenFromString(
2055                 MOCKAPP3_PACKAGENAME + "/.TestService");
2056         final ServiceRecord c2s = makeServiceRecord(client2);
2057         setFieldValue(ServiceRecord.class, c2s, "name", cn4);
2058         c2s.startRequested = true;
2059 
2060         try {
2061             sService.mOomAdjuster.mActiveUids.put(MOCKAPP_UID, app1UidRecord);
2062             sService.mOomAdjuster.mActiveUids.put(MOCKAPP2_UID, app2UidRecord);
2063             sService.mOomAdjuster.mActiveUids.put(MOCKAPP5_UID, app3UidRecord);
2064             sService.mOomAdjuster.mActiveUids.put(MOCKAPP3_UID, clientUidRecord);
2065 
2066             setServiceMap(s1, MOCKAPP_UID, cn1);
2067             setServiceMap(s2, MOCKAPP2_UID, cn2);
2068             setServiceMap(s3, MOCKAPP5_UID, cn3);
2069             setServiceMap(c2s, MOCKAPP3_UID, cn4);
2070             app2UidRecord.setIdle(false);
2071             sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2072 
2073             assertProcStates(app1, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2074                     SCHED_GROUP_DEFAULT);
2075             assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2076                     SCHED_GROUP_DEFAULT);
2077             assertProcStates(client1, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2078                     SCHED_GROUP_DEFAULT);
2079             assertEquals(PROCESS_STATE_TRANSIENT_BACKGROUND, app2.mState.getSetProcState());
2080             assertEquals(PROCESS_STATE_TRANSIENT_BACKGROUND, client2.mState.getSetProcState());
2081 
2082             client1.mServices.setHasForegroundServices(false, 0, /* hasNoneType=*/false);
2083             client2.mState.setForcingToImportant(null);
2084             app1UidRecord.reset();
2085             app2UidRecord.reset();
2086             app3UidRecord.reset();
2087             clientUidRecord.reset();
2088             app1UidRecord.setIdle(true);
2089             app2UidRecord.setIdle(true);
2090             app3UidRecord.setIdle(true);
2091             clientUidRecord.setIdle(true);
2092             doReturn(ActivityManager.APP_START_MODE_DELAYED).when(sService)
2093                     .getAppStartModeLOSP(anyInt(), any(String.class), anyInt(),
2094                     anyInt(), anyBoolean(), anyBoolean(), anyBoolean());
2095             doNothing().when(sService.mServices)
2096                     .scheduleServiceTimeoutLocked(any(ProcessRecord.class));
2097             sService.mOomAdjuster.updateOomAdjLocked(client1, OOM_ADJ_REASON_NONE);
2098 
2099             assertEquals(PROCESS_STATE_CACHED_EMPTY, client1.mState.getSetProcState());
2100             assertEquals(PROCESS_STATE_SERVICE, app1.mState.getSetProcState());
2101             assertEquals(PROCESS_STATE_SERVICE, client2.mState.getSetProcState());
2102         } finally {
2103             doCallRealMethod().when(sService)
2104                     .getAppStartModeLOSP(anyInt(), any(String.class), anyInt(),
2105                     anyInt(), anyBoolean(), anyBoolean(), anyBoolean());
2106             sService.mServices.mServiceMap.clear();
2107             sService.mOomAdjuster.mActiveUids.clear();
2108         }
2109     }
2110 
2111     @SuppressWarnings("GuardedBy")
2112     @Test
testUpdateOomAdj_DoAll_Unbound()2113     public void testUpdateOomAdj_DoAll_Unbound() {
2114         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2115                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2116         app.mState.setForcingToImportant(new Object());
2117         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2118                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2119         app2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2120 
2121         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2122         updateOomAdj(app, app2);
2123 
2124         assertProcStates(app, PROCESS_STATE_TRANSIENT_BACKGROUND, PERCEPTIBLE_APP_ADJ,
2125                 SCHED_GROUP_DEFAULT);
2126         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2127                 SCHED_GROUP_DEFAULT);
2128         assertBfsl(app2);
2129     }
2130 
2131     @SuppressWarnings("GuardedBy")
2132     @Test
testUpdateOomAdj_DoAll_BoundFgService()2133     public void testUpdateOomAdj_DoAll_BoundFgService() {
2134         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2135                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2136         app.mState.setForcingToImportant(new Object());
2137         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2138                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2139         app2.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2140         bindService(app, app2, null, 0, mock(IBinder.class));
2141         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2142         updateOomAdj(app, app2);
2143 
2144         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2145                 SCHED_GROUP_DEFAULT);
2146         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2147                 SCHED_GROUP_DEFAULT);
2148         assertBfsl(app);
2149         assertBfsl(app2);
2150     }
2151 
2152     @SuppressWarnings("GuardedBy")
2153     @Test
testUpdateOomAdj_DoAll_BoundFgService_Cycle()2154     public void testUpdateOomAdj_DoAll_BoundFgService_Cycle() {
2155         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2156                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2157         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2158                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2159         bindService(app, app2, null, 0, mock(IBinder.class));
2160         ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2161                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2162         bindService(app2, app3, null, 0, mock(IBinder.class));
2163         app3.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2164         bindService(app3, app, null, 0, mock(IBinder.class));
2165         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2166         updateOomAdj(app, app2, app3);
2167 
2168         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2169                 SCHED_GROUP_DEFAULT);
2170         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2171                 SCHED_GROUP_DEFAULT);
2172         assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2173                 SCHED_GROUP_DEFAULT);
2174         assertEquals("service", app.mState.getAdjType());
2175         assertEquals("service", app2.mState.getAdjType());
2176         assertEquals("fg-service", app3.mState.getAdjType());
2177         assertEquals(false, app.isCached());
2178         assertEquals(false, app2.isCached());
2179         assertEquals(false, app3.isCached());
2180         assertEquals(false, app.mState.isEmpty());
2181         assertEquals(false, app2.mState.isEmpty());
2182         assertEquals(false, app3.mState.isEmpty());
2183         assertBfsl(app);
2184         assertBfsl(app2);
2185         assertBfsl(app3);
2186     }
2187 
2188     @SuppressWarnings("GuardedBy")
2189     @Test
testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_2()2190     public void testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_2() {
2191         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2192                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2193         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2194                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2195         ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
2196         ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2197                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2198         bindService(app2, app3, null, 0, mock(IBinder.class));
2199         bindService(app3, app, null, 0, mock(IBinder.class));
2200         WindowProcessController wpc = app3.getWindowProcessController();
2201         doReturn(true).when(wpc).isHomeProcess();
2202         ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
2203                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
2204         app4.mState.setHasOverlayUi(true);
2205         bindService(app, app4, s, 0, mock(IBinder.class));
2206         ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
2207                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
2208         app5.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2209         bindService(app, app5, s, 0, mock(IBinder.class));
2210         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2211         updateOomAdj(app, app2, app3, app4, app5);
2212 
2213         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2214                 SCHED_GROUP_DEFAULT);
2215         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2216                 SCHED_GROUP_DEFAULT);
2217         assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2218                 SCHED_GROUP_DEFAULT);
2219         assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
2220                 SCHED_GROUP_DEFAULT);
2221         assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2222                 SCHED_GROUP_DEFAULT);
2223         assertBfsl(app);
2224         assertBfsl(app2);
2225         assertBfsl(app3);
2226         // 4 is IMP_FG
2227         assertBfsl(app5);
2228     }
2229 
2230     @SuppressWarnings("GuardedBy")
2231     @Test
testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_3()2232     public void testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_3() {
2233         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2234                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2235         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2236                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2237         ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
2238         ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2239                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2240         bindService(app2, app3, null, 0, mock(IBinder.class));
2241         bindService(app3, app, null, 0, mock(IBinder.class));
2242         WindowProcessController wpc = app3.getWindowProcessController();
2243         doReturn(true).when(wpc).isHomeProcess();
2244         ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
2245                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
2246         app4.mState.setHasOverlayUi(true);
2247         bindService(app, app4, s, 0, mock(IBinder.class));
2248         ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
2249                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
2250         app5.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2251         bindService(app, app5, s, 0, mock(IBinder.class));
2252         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2253         updateOomAdj(app5, app4, app3, app2, app);
2254 
2255         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2256                 SCHED_GROUP_DEFAULT);
2257         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2258                 SCHED_GROUP_DEFAULT);
2259         assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2260                 SCHED_GROUP_DEFAULT);
2261         assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
2262                 SCHED_GROUP_DEFAULT);
2263         assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2264                 SCHED_GROUP_DEFAULT);
2265         assertBfsl(app);
2266         assertBfsl(app2);
2267         assertBfsl(app3);
2268         // 4 is IMP_FG
2269         assertBfsl(app5);
2270     }
2271 
2272     @SuppressWarnings("GuardedBy")
2273     @Test
testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_4()2274     public void testUpdateOomAdj_DoAll_BoundFgService_Cycle_Branch_4() {
2275         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2276                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2277         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2278                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2279         ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
2280         ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2281                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2282         bindService(app2, app3, null, 0, mock(IBinder.class));
2283         bindService(app3, app, null, 0, mock(IBinder.class));
2284         WindowProcessController wpc = app3.getWindowProcessController();
2285         doReturn(true).when(wpc).isHomeProcess();
2286         ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
2287                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
2288         app4.mState.setHasOverlayUi(true);
2289         bindService(app, app4, s, 0, mock(IBinder.class));
2290         ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
2291                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
2292         app5.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2293         bindService(app, app5, s, 0, mock(IBinder.class));
2294         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2295         updateOomAdj(app3, app4, app2, app, app5);
2296 
2297         assertProcStates(app, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2298                 SCHED_GROUP_DEFAULT);
2299         assertProcStates(app2, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2300                 SCHED_GROUP_DEFAULT);
2301         assertProcStates(app3, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2302                 SCHED_GROUP_DEFAULT);
2303         assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
2304                 SCHED_GROUP_DEFAULT);
2305         assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2306                 SCHED_GROUP_DEFAULT);
2307         assertBfsl(app);
2308         assertBfsl(app2);
2309         assertBfsl(app3);
2310         // 4 is IMP_FG
2311         assertBfsl(app5);
2312     }
2313 
2314     @SuppressWarnings("GuardedBy")
2315     @Test
testUpdateOomAdj_DoAll_BoundByPersService_Cycle_Branch_Capability()2316     public void testUpdateOomAdj_DoAll_BoundByPersService_Cycle_Branch_Capability() {
2317         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2318                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2319         ProcessRecord client = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2320                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2321         bindService(app, client, null, Context.BIND_INCLUDE_CAPABILITIES, mock(IBinder.class));
2322         ProcessRecord client2 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2323                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2324         bindService(client, client2, null, Context.BIND_INCLUDE_CAPABILITIES, mock(IBinder.class));
2325         bindService(client2, app, null, Context.BIND_INCLUDE_CAPABILITIES, mock(IBinder.class));
2326         ProcessRecord client3 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
2327                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
2328         client3.mState.setMaxAdj(PERSISTENT_PROC_ADJ);
2329         bindService(app, client3, null, Context.BIND_INCLUDE_CAPABILITIES, mock(IBinder.class));
2330         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2331         updateOomAdj(app, client, client2, client3);
2332 
2333         final int expected = PROCESS_CAPABILITY_ALL & ~PROCESS_CAPABILITY_BFSL;
2334         assertEquals(expected, client.mState.getSetCapability());
2335         assertEquals(expected, client2.mState.getSetCapability());
2336         assertEquals(expected, app.mState.getSetCapability());
2337     }
2338 
2339     @SuppressWarnings("GuardedBy")
2340     @Test
testUpdateOomAdj_DoAll_Provider_Cycle_Branch_2()2341     public void testUpdateOomAdj_DoAll_Provider_Cycle_Branch_2() {
2342         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2343                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2344         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2345                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2346         ContentProviderRecord cr = bindProvider(app, app2, null, null, false);
2347         ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2348                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2349         bindProvider(app2, app3, null, null, false);
2350         bindProvider(app3, app, null, null, false);
2351         WindowProcessController wpc = app3.getWindowProcessController();
2352         doReturn(true).when(wpc).isHomeProcess();
2353         ProcessRecord app4 = spy(makeDefaultProcessRecord(MOCKAPP4_PID, MOCKAPP4_UID,
2354                 MOCKAPP4_PROCESSNAME, MOCKAPP4_PACKAGENAME, false));
2355         app4.mState.setHasOverlayUi(true);
2356         bindProvider(app, app4, cr, null, false);
2357         ProcessRecord app5 = spy(makeDefaultProcessRecord(MOCKAPP5_PID, MOCKAPP5_UID,
2358                 MOCKAPP5_PROCESSNAME, MOCKAPP5_PACKAGENAME, false));
2359         app5.mServices.setHasForegroundServices(true, 0, /* hasNoneType=*/true);
2360         bindProvider(app, app5, cr, null, false);
2361         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2362         updateOomAdj(app, app2, app3, app4, app5);
2363 
2364         assertProcStates(app, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2365                 SCHED_GROUP_DEFAULT);
2366         assertProcStates(app2, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2367                 SCHED_GROUP_DEFAULT);
2368         assertProcStates(app3, PROCESS_STATE_BOUND_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2369                 SCHED_GROUP_DEFAULT);
2370         assertProcStates(app4, PROCESS_STATE_IMPORTANT_FOREGROUND, PERCEPTIBLE_APP_ADJ,
2371                 SCHED_GROUP_DEFAULT);
2372         assertProcStates(app5, PROCESS_STATE_FOREGROUND_SERVICE, PERCEPTIBLE_APP_ADJ,
2373                 SCHED_GROUP_DEFAULT);
2374         assertBfsl(app);
2375         assertBfsl(app2);
2376         assertBfsl(app3);
2377         // 4 is IMP_FG
2378         assertBfsl(app5);
2379     }
2380 
2381     @SuppressWarnings("GuardedBy")
2382     @Test
testUpdateOomAdj_DoAll_ServiceB()2383     public void testUpdateOomAdj_DoAll_ServiceB() {
2384         ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2385                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2386         ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2387                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2388         long now = SystemClock.uptimeMillis();
2389         ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
2390         s.startRequested = true;
2391         s.lastActivity = now;
2392         s = bindService(app2, app, null, 0, mock(IBinder.class));
2393         s.startRequested = true;
2394         s.lastActivity = now;
2395         ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2396                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2397         s = mock(ServiceRecord.class);
2398         s.app = app3;
2399         setFieldValue(ServiceRecord.class, s, "connections",
2400                 new ArrayMap<IBinder, ArrayList<ConnectionRecord>>());
2401         app3.mServices.startService(s);
2402         doCallRealMethod().when(s).getConnections();
2403         s.startRequested = true;
2404         s.lastActivity = now;
2405         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2406         sService.mOomAdjuster.mNumServiceProcs = 3;
2407         updateOomAdj(app3, app2, app);
2408 
2409         assertEquals(SERVICE_B_ADJ, app3.mState.getSetAdj());
2410         assertEquals(SERVICE_ADJ, app2.mState.getSetAdj());
2411         assertEquals(SERVICE_ADJ, app.mState.getSetAdj());
2412     }
2413 
2414     @SuppressWarnings("GuardedBy")
2415     @Test
testUpdateOomAdj_DoAll_Service_KeepWarmingList()2416     public void testUpdateOomAdj_DoAll_Service_KeepWarmingList() {
2417         final ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2418                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2419         final ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID_OTHER,
2420                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2421         final int userOwner = 0;
2422         final int userOther = 1;
2423         final int cachedAdj1 = sService.mConstants.USE_TIERED_CACHED_ADJ
2424                                ? CACHED_APP_MIN_ADJ + 10
2425                                : CACHED_APP_MIN_ADJ + ProcessList.CACHED_APP_IMPORTANCE_LEVELS;
2426         final int cachedAdj2 = sService.mConstants.USE_TIERED_CACHED_ADJ
2427                                ? CACHED_APP_MIN_ADJ + 10
2428                                : cachedAdj1 + ProcessList.CACHED_APP_IMPORTANCE_LEVELS * 2;
2429         doReturn(userOwner).when(sService.mUserController).getCurrentUserId();
2430 
2431         final ArrayList<ProcessRecord> lru = sService.mProcessList.getLruProcessesLOSP();
2432         lru.clear();
2433         lru.add(app2);
2434         lru.add(app);
2435 
2436         final ComponentName cn = ComponentName.unflattenFromString(
2437                 MOCKAPP_PACKAGENAME + "/.TestService");
2438         final ComponentName cn2 = ComponentName.unflattenFromString(
2439                 MOCKAPP2_PACKAGENAME + "/.TestService");
2440         final long now = SystemClock.uptimeMillis();
2441 
2442         sService.mConstants.KEEP_WARMING_SERVICES.clear();
2443         final ServiceInfo si = mock(ServiceInfo.class);
2444         si.applicationInfo = mock(ApplicationInfo.class);
2445         ServiceRecord s = spy(new ServiceRecord(sService, cn, cn, null, 0, null,
2446                 si, false, null));
2447         doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s).getConnections();
2448         s.startRequested = true;
2449         s.lastActivity = now;
2450 
2451         app.mState.setCached(false);
2452         app.mServices.startService(s);
2453         app.mState.setHasShownUi(true);
2454 
2455         final ServiceInfo si2 = mock(ServiceInfo.class);
2456         si2.applicationInfo = mock(ApplicationInfo.class);
2457         si2.applicationInfo.uid = MOCKAPP2_UID_OTHER;
2458         ServiceRecord s2 = spy(new ServiceRecord(sService, cn2, cn2, null, 0, null,
2459                 si2, false, null));
2460         doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s2).getConnections();
2461         s2.startRequested = true;
2462         s2.lastActivity = now - sService.mConstants.MAX_SERVICE_INACTIVITY - 1;
2463 
2464         app2.mState.setCached(false);
2465         app2.mServices.startService(s2);
2466         app2.mState.setHasShownUi(false);
2467 
2468         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2469         sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2470 
2471         assertProcStates(app, true, PROCESS_STATE_SERVICE, cachedAdj1, "cch-started-ui-services");
2472         assertProcStates(app2, true, PROCESS_STATE_SERVICE, cachedAdj2, "cch-started-services");
2473 
2474         app.mState.setSetProcState(PROCESS_STATE_NONEXISTENT);
2475         app.mState.setAdjType(null);
2476         app.mState.setSetAdj(UNKNOWN_ADJ);
2477         app.mState.setHasShownUi(false);
2478         sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2479 
2480         assertProcStates(app, false, PROCESS_STATE_SERVICE, SERVICE_ADJ, "started-services");
2481 
2482         app.mState.setCached(false);
2483         app.mState.setSetProcState(PROCESS_STATE_NONEXISTENT);
2484         app.mState.setAdjType(null);
2485         app.mState.setSetAdj(UNKNOWN_ADJ);
2486         s.lastActivity = now - sService.mConstants.MAX_SERVICE_INACTIVITY - 1;
2487         sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2488 
2489         assertProcStates(app, true, PROCESS_STATE_SERVICE, cachedAdj1, "cch-started-services");
2490 
2491         app.mServices.stopService(s);
2492         app.mState.setSetProcState(PROCESS_STATE_NONEXISTENT);
2493         app.mState.setAdjType(null);
2494         app.mState.setSetAdj(UNKNOWN_ADJ);
2495         app.mState.setHasShownUi(true);
2496         sService.mConstants.KEEP_WARMING_SERVICES.add(cn);
2497         sService.mConstants.KEEP_WARMING_SERVICES.add(cn2);
2498         s = spy(new ServiceRecord(sService, cn, cn, null, 0, null,
2499                 si, false, null));
2500         doReturn(new ArrayMap<IBinder, ArrayList<ConnectionRecord>>()).when(s).getConnections();
2501         s.startRequested = true;
2502         s.lastActivity = now;
2503 
2504         app.mServices.startService(s);
2505         sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2506 
2507         assertProcStates(app, false, PROCESS_STATE_SERVICE, SERVICE_ADJ, "started-services");
2508         assertProcStates(app2, true, PROCESS_STATE_SERVICE, cachedAdj1, "cch-started-services");
2509 
2510         app.mState.setCached(true);
2511         app.mState.setSetProcState(PROCESS_STATE_NONEXISTENT);
2512         app.mState.setAdjType(null);
2513         app.mState.setSetAdj(UNKNOWN_ADJ);
2514         app.mState.setHasShownUi(false);
2515         s.lastActivity = now - sService.mConstants.MAX_SERVICE_INACTIVITY - 1;
2516         sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2517 
2518         assertProcStates(app, false, PROCESS_STATE_SERVICE, SERVICE_ADJ, "started-services");
2519         assertProcStates(app2, true, PROCESS_STATE_SERVICE, cachedAdj1, "cch-started-services");
2520 
2521         doReturn(userOther).when(sService.mUserController).getCurrentUserId();
2522         sService.mOomAdjuster.handleUserSwitchedLocked();
2523 
2524         sService.mOomAdjuster.updateOomAdjLocked(OOM_ADJ_REASON_NONE);
2525         assertProcStates(app, true, PROCESS_STATE_SERVICE, cachedAdj1, "cch-started-services");
2526         assertProcStates(app2, false, PROCESS_STATE_SERVICE, SERVICE_ADJ, "started-services");
2527     }
2528 
2529     @SuppressWarnings("GuardedBy")
2530     @Test
testUpdateOomAdj_DoAll_Side_Cycle()2531     public void testUpdateOomAdj_DoAll_Side_Cycle() {
2532         final ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
2533                 MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
2534         final ProcessRecord app2 = spy(makeDefaultProcessRecord(MOCKAPP2_PID, MOCKAPP2_UID,
2535                 MOCKAPP2_PROCESSNAME, MOCKAPP2_PACKAGENAME, false));
2536         final ProcessRecord app3 = spy(makeDefaultProcessRecord(MOCKAPP3_PID, MOCKAPP3_UID,
2537                 MOCKAPP3_PROCESSNAME, MOCKAPP3_PACKAGENAME, false));
2538         long now = SystemClock.uptimeMillis();
2539         ServiceRecord s = bindService(app, app2, null, 0, mock(IBinder.class));
2540         s.startRequested = true;
2541         s.lastActivity = now;
2542         s = bindService(app2, app3, null, 0, mock(IBinder.class));
2543         s.lastActivity = now;
2544         s = bindService(app3, app2, null, 0, mock(IBinder.class));
2545         s.lastActivity = now;
2546 
2547         sService.mWakefulness.set(PowerManagerInternal.WAKEFULNESS_AWAKE);
2548         sService.mOomAdjuster.mNumServiceProcs = 3;
2549         updateOomAdj(app, app2, app3);
2550 
2551         assertEquals(SERVICE_ADJ, app.mState.getSetAdj());
2552         assertTrue(sFirstCachedAdj <= app2.mState.getSetAdj());
2553         assertTrue(sFirstCachedAdj <= app3.mState.getSetAdj());
2554         assertTrue(CACHED_APP_MAX_ADJ >= app2.mState.getSetAdj());
2555         assertTrue(CACHED_APP_MAX_ADJ >= app3.mState.getSetAdj());
2556     }
2557 
makeDefaultProcessRecord(int pid, int uid, String processName, String packageName, boolean hasShownUi)2558     private ProcessRecord makeDefaultProcessRecord(int pid, int uid, String processName,
2559             String packageName, boolean hasShownUi) {
2560         long now = SystemClock.uptimeMillis();
2561         return makeProcessRecord(sService, pid, uid, processName,
2562                 packageName, 12345, Build.VERSION_CODES.CUR_DEVELOPMENT,
2563                 now, now, now, 12345, UNKNOWN_ADJ, UNKNOWN_ADJ,
2564                 UNKNOWN_ADJ, CACHED_APP_MAX_ADJ,
2565                 SCHED_GROUP_DEFAULT, SCHED_GROUP_DEFAULT,
2566                 PROCESS_STATE_NONEXISTENT, PROCESS_STATE_NONEXISTENT,
2567                 PROCESS_STATE_NONEXISTENT, PROCESS_STATE_NONEXISTENT,
2568                 0, 0, false, false, false, ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE,
2569                 false, false, false, hasShownUi, false, false, false, false, false, false, null,
2570                 0, 0, 0, true, 0, null, false);
2571     }
2572 
makeProcessRecord(ActivityManagerService service, int pid, int uid, String processName, String packageName, long versionCode, int targetSdkVersion, long lastActivityTime, long lastPssTime, long nextPssTime, long lastPss, int maxAdj, int setRawAdj, int curAdj, int setAdj, int curSchedGroup, int setSchedGroup, int curProcState, int repProcState, int curRawProcState, int setProcState, int connectionGroup, int connectionImportance, boolean serviceb, boolean hasClientActivities, boolean hasForegroundServices, int fgServiceTypes, boolean hasForegroundActivities, boolean repForegroundActivities, boolean systemNoUi, boolean hasShownUi, boolean hasTopUi, boolean hasOverlayUi, boolean runningRemoteAnimation, boolean hasAboveClient, boolean treatLikeActivity, boolean killedByAm, Object forcingToImportant, int numOfCurReceivers, long lastProviderTime, long lastTopTime, boolean cached, int numOfExecutingServices, String isolatedEntryPoint, boolean execServicesFg)2573     private ProcessRecord makeProcessRecord(ActivityManagerService service, int pid, int uid,
2574             String processName, String packageName, long versionCode, int targetSdkVersion,
2575             long lastActivityTime, long lastPssTime, long nextPssTime, long lastPss, int maxAdj,
2576             int setRawAdj, int curAdj, int setAdj, int curSchedGroup, int setSchedGroup,
2577             int curProcState, int repProcState, int curRawProcState, int setProcState,
2578             int connectionGroup, int connectionImportance, boolean serviceb,
2579             boolean hasClientActivities, boolean hasForegroundServices, int fgServiceTypes,
2580             boolean hasForegroundActivities, boolean repForegroundActivities, boolean systemNoUi,
2581             boolean hasShownUi, boolean hasTopUi, boolean hasOverlayUi,
2582             boolean runningRemoteAnimation, boolean hasAboveClient, boolean treatLikeActivity,
2583             boolean killedByAm, Object forcingToImportant, int numOfCurReceivers,
2584             long lastProviderTime, long lastTopTime, boolean cached, int numOfExecutingServices,
2585             String isolatedEntryPoint, boolean execServicesFg) {
2586         ApplicationInfo ai = spy(new ApplicationInfo());
2587         ai.uid = uid;
2588         ai.packageName = packageName;
2589         ai.longVersionCode = versionCode;
2590         ai.targetSdkVersion = targetSdkVersion;
2591         ProcessRecord app = new ProcessRecord(service, ai, processName, uid);
2592         final ProcessStateRecord state = app.mState;
2593         final ProcessServiceRecord services = app.mServices;
2594         final ProcessReceiverRecord receivers = app.mReceivers;
2595         final ProcessProfileRecord profile = app.mProfile;
2596         final ProcessProviderRecord providers = app.mProviders;
2597         app.makeActive(mock(IApplicationThread.class), sService.mProcessStats);
2598         app.setLastActivityTime(lastActivityTime);
2599         app.setKilledByAm(killedByAm);
2600         app.setIsolatedEntryPoint(isolatedEntryPoint);
2601         setFieldValue(ProcessRecord.class, app, "mWindowProcessController",
2602                 mock(WindowProcessController.class));
2603         profile.setLastPssTime(lastPssTime);
2604         profile.setNextPssTime(nextPssTime);
2605         profile.setLastPss(lastPss);
2606         state.setMaxAdj(maxAdj);
2607         state.setSetRawAdj(setRawAdj);
2608         state.setCurAdj(curAdj);
2609         state.setSetAdj(setAdj);
2610         state.setCurrentSchedulingGroup(curSchedGroup);
2611         state.setSetSchedGroup(setSchedGroup);
2612         state.setCurProcState(curProcState);
2613         state.setReportedProcState(repProcState);
2614         state.setCurRawProcState(curRawProcState);
2615         state.setSetProcState(setProcState);
2616         state.setServiceB(serviceb);
2617         state.setRepForegroundActivities(repForegroundActivities);
2618         state.setHasForegroundActivities(hasForegroundActivities);
2619         state.setSystemNoUi(systemNoUi);
2620         state.setHasShownUi(hasShownUi);
2621         state.setHasTopUi(hasTopUi);
2622         state.setRunningRemoteAnimation(runningRemoteAnimation);
2623         state.setHasOverlayUi(hasOverlayUi);
2624         state.setCached(cached);
2625         state.setLastTopTime(lastTopTime);
2626         state.setForcingToImportant(forcingToImportant);
2627         services.setConnectionGroup(connectionGroup);
2628         services.setConnectionImportance(connectionImportance);
2629         services.setHasClientActivities(hasClientActivities);
2630         services.setHasForegroundServices(hasForegroundServices, fgServiceTypes,
2631                 /* hasNoneType=*/false);
2632         services.setHasAboveClient(hasAboveClient);
2633         services.setTreatLikeActivity(treatLikeActivity);
2634         services.setExecServicesFg(execServicesFg);
2635         for (int i = 0; i < numOfExecutingServices; i++) {
2636             services.startExecutingService(mock(ServiceRecord.class));
2637         }
2638         for (int i = 0; i < numOfCurReceivers; i++) {
2639             receivers.addCurReceiver(mock(BroadcastRecord.class));
2640         }
2641         providers.setLastProviderTime(lastProviderTime);
2642         return app;
2643     }
2644 
makeServiceRecord(ProcessRecord app)2645     private ServiceRecord makeServiceRecord(ProcessRecord app) {
2646         final ServiceRecord record = mock(ServiceRecord.class);
2647         record.app = app;
2648         setFieldValue(ServiceRecord.class, record, "connections",
2649                 new ArrayMap<IBinder, ArrayList<ConnectionRecord>>());
2650         doCallRealMethod().when(record).getConnections();
2651         setFieldValue(ServiceRecord.class, record, "packageName", app.info.packageName);
2652         app.mServices.startService(record);
2653         record.appInfo = app.info;
2654         setFieldValue(ServiceRecord.class, record, "bindings", new ArrayMap<>());
2655         setFieldValue(ServiceRecord.class, record, "pendingStarts", new ArrayList<>());
2656         return record;
2657     }
2658 
setServiceMap(ServiceRecord s, int uid, ComponentName cn)2659     private void setServiceMap(ServiceRecord s, int uid, ComponentName cn) {
2660         ActiveServices.ServiceMap serviceMap = sService.mServices.mServiceMap.get(
2661                 UserHandle.getUserId(uid));
2662         if (serviceMap == null) {
2663             serviceMap = mock(ActiveServices.ServiceMap.class);
2664             setFieldValue(ActiveServices.ServiceMap.class, serviceMap, "mServicesByInstanceName",
2665                     new ArrayMap<>());
2666             setFieldValue(ActiveServices.ServiceMap.class, serviceMap, "mActiveForegroundApps",
2667                     new ArrayMap<>());
2668             setFieldValue(ActiveServices.ServiceMap.class, serviceMap, "mServicesByIntent",
2669                     new ArrayMap<>());
2670             setFieldValue(ActiveServices.ServiceMap.class, serviceMap, "mDelayedStartList",
2671                     new ArrayList<>());
2672             sService.mServices.mServiceMap.put(UserHandle.getUserId(uid), serviceMap);
2673         }
2674         serviceMap.mServicesByInstanceName.put(cn, s);
2675     }
2676 
bindService(ProcessRecord service, ProcessRecord client, ServiceRecord record, long bindFlags, IBinder binder)2677     private ServiceRecord bindService(ProcessRecord service, ProcessRecord client,
2678             ServiceRecord record, long bindFlags, IBinder binder) {
2679         if (record == null) {
2680             record = makeServiceRecord(service);
2681         }
2682         AppBindRecord binding = new AppBindRecord(record, null, client, null);
2683         ConnectionRecord cr = spy(new ConnectionRecord(binding,
2684                 mock(ActivityServiceConnectionsHolder.class),
2685                 mock(IServiceConnection.class), bindFlags,
2686                 0, null, client.uid, client.processName, client.info.packageName, null));
2687         doCallRealMethod().when(record).addConnection(any(IBinder.class),
2688                 any(ConnectionRecord.class));
2689         record.addConnection(binder, cr);
2690         client.mServices.addConnection(cr);
2691         binding.connections.add(cr);
2692         doNothing().when(cr).trackProcState(anyInt(), anyInt());
2693         return record;
2694     }
2695 
bindProvider(ProcessRecord publisher, ProcessRecord client, ContentProviderRecord record, String name, boolean hasExternalProviders)2696     private ContentProviderRecord bindProvider(ProcessRecord publisher, ProcessRecord client,
2697             ContentProviderRecord record, String name, boolean hasExternalProviders) {
2698         if (record == null) {
2699             record = mock(ContentProviderRecord.class);
2700             publisher.mProviders.installProvider(name, record);
2701             record.proc = publisher;
2702             setFieldValue(ContentProviderRecord.class, record, "connections",
2703                     new ArrayList<ContentProviderConnection>());
2704             doReturn(hasExternalProviders).when(record).hasExternalProcessHandles();
2705         }
2706         ContentProviderConnection conn = spy(new ContentProviderConnection(record, client,
2707                 client.info.packageName, UserHandle.getUserId(client.uid)));
2708         record.connections.add(conn);
2709         client.mProviders.addProviderConnection(conn);
2710         return record;
2711     }
2712 
assertProcStates(ProcessRecord app, int expectedProcState, int expectedAdj, int expectedSchedGroup)2713     private void assertProcStates(ProcessRecord app, int expectedProcState, int expectedAdj,
2714             int expectedSchedGroup) {
2715         final ProcessStateRecord state = app.mState;
2716         assertEquals(expectedProcState, state.getSetProcState());
2717         assertEquals(expectedAdj, state.getSetAdj());
2718         assertEquals(expectedSchedGroup, state.getSetSchedGroup());
2719 
2720         // Below BFGS should never have BFSL.
2721         if (expectedProcState > PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
2722             assertNoBfsl(app);
2723         }
2724         // Above FGS should always have BFSL.
2725         if (expectedProcState < PROCESS_STATE_FOREGROUND_SERVICE) {
2726             assertBfsl(app);
2727         }
2728     }
2729 
assertProcStates(ProcessRecord app, boolean expectedCached, int expectedProcState, int expectedAdj, String expectedAdjType)2730     private void assertProcStates(ProcessRecord app, boolean expectedCached,
2731             int expectedProcState, int expectedAdj, String expectedAdjType) {
2732         final ProcessStateRecord state = app.mState;
2733         assertEquals(expectedCached, state.isCached());
2734         assertEquals(expectedProcState, state.getSetProcState());
2735         assertEquals(expectedAdj, state.getSetAdj());
2736         assertEquals(expectedAdjType, state.getAdjType());
2737 
2738         // Below BFGS should never have BFSL.
2739         if (expectedProcState > PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
2740             assertNoBfsl(app);
2741         }
2742         // Above FGS should always have BFSL.
2743         if (expectedProcState < PROCESS_STATE_FOREGROUND_SERVICE) {
2744             assertBfsl(app);
2745         }
2746     }
2747 }
2748