diff options
10 files changed, 194 insertions, 70 deletions
diff --git a/services/core/java/com/android/server/am/ActiveServices.java b/services/core/java/com/android/server/am/ActiveServices.java index 4070bca199e0..405a2d0ca478 100644 --- a/services/core/java/com/android/server/am/ActiveServices.java +++ b/services/core/java/com/android/server/am/ActiveServices.java @@ -1138,7 +1138,7 @@ public final class ActiveServices { for (int j = smap.mActiveForegroundApps.size()-1; j >= 0; j--) { ActiveForegroundApp active = smap.mActiveForegroundApps.valueAt(j); if (active.mUid == uidRec.uid) { - if (uidRec.curProcState <= ActivityManager.PROCESS_STATE_TOP) { + if (uidRec.getCurProcState() <= ActivityManager.PROCESS_STATE_TOP) { if (!active.mAppOnTop) { active.mAppOnTop = true; changed = true; @@ -1257,7 +1257,7 @@ public final class ActiveServices { active.mShownWhileScreenOn = mScreenOn; if (r.app != null) { active.mAppOnTop = active.mShownWhileTop = - r.app.uidRecord.curProcState + r.app.uidRecord.getCurProcState() <= ActivityManager.PROCESS_STATE_TOP; } active.mStartTime = active.mStartVisibleTime diff --git a/services/core/java/com/android/server/am/ActiveUids.java b/services/core/java/com/android/server/am/ActiveUids.java new file mode 100644 index 000000000000..4e1435e14679 --- /dev/null +++ b/services/core/java/com/android/server/am/ActiveUids.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.server.am; + +import android.util.SparseArray; + +/** Class for tracking active uids for running processes. */ +final class ActiveUids { + + private ActivityManagerService mService; + + private boolean mPostChangesToAtm; + private final SparseArray<UidRecord> mActiveUids = new SparseArray<>(); + + ActiveUids(ActivityManagerService service, boolean postChangesToAtm) { + mService = service; + mPostChangesToAtm = postChangesToAtm; + } + + void put(int uid, UidRecord value) { + mActiveUids.put(uid, value); + if (mPostChangesToAtm) { + mService.mAtmInternal.onUidActive(uid, value.getCurProcState()); + } + } + + void remove(int uid) { + mActiveUids.remove(uid); + if (mPostChangesToAtm) { + mService.mAtmInternal.onUidInactive(uid); + } + } + + void clear() { + mActiveUids.clear(); + if (mPostChangesToAtm) { + mService.mAtmInternal.onActiveUidsCleared(); + } + } + + UidRecord get(int uid) { + return mActiveUids.get(uid); + } + + int size() { + return mActiveUids.size(); + } + + UidRecord valueAt(int index) { + return mActiveUids.valueAt(index); + } + + int keyAt(int index) { + return mActiveUids.keyAt(index); + } + + int indexOfKey(int uid) { + return mActiveUids.indexOfKey(uid); + } +} diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java index d56b523f07aa..a5629d59a32c 100644 --- a/services/core/java/com/android/server/am/ActivityManagerService.java +++ b/services/core/java/com/android/server/am/ActivityManagerService.java @@ -24,6 +24,7 @@ import static android.Manifest.permission.INTERACT_ACROSS_USERS_FULL; import static android.Manifest.permission.REMOVE_TASKS; import static android.app.ActivityManager.PROCESS_STATE_CACHED_ACTIVITY; import static android.app.ActivityManager.PROCESS_STATE_LAST_ACTIVITY; +import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT; import static android.app.ActivityManagerInternal.ALLOW_FULL_ONLY; import static android.app.ActivityManagerInternal.ALLOW_NON_FULL; import static android.app.AppOpsManager.OP_NONE; @@ -745,16 +746,14 @@ public class ActivityManagerService extends IActivityManager.Stub */ boolean mFullPssPending = false; - /** - * Track all uids that have actively running processes. - */ - final SparseArray<UidRecord> mActiveUids = new SparseArray<>(); + /** Track all uids that have actively running processes. */ + final ActiveUids mActiveUids = new ActiveUids(this, true /* postChangesToAtm */); /** * This is for verifying the UID report flow. */ static final boolean VALIDATE_UID_STATES = true; - final SparseArray<UidRecord> mValidateUids = new SparseArray<>(); + final ActiveUids mValidateUids = new ActiveUids(this, false /* postChangesToAtm */); /** * Fingerprints (hashCode()) of stack traces that we've @@ -2703,7 +2702,7 @@ public class ActivityManagerService extends IActivityManager.Stub "getPackageProcessState"); } - int procState = ActivityManager.PROCESS_STATE_NONEXISTENT; + int procState = PROCESS_STATE_NONEXISTENT; synchronized (this) { for (int i=mProcessList.mLruProcesses.size()-1; i>=0; i--) { final ProcessRecord proc = mProcessList.mLruProcesses.get(i); @@ -2839,7 +2838,7 @@ public class ActivityManagerService extends IActivityManager.Stub } else { UidRecord validateUid = mValidateUids.get(item.uid); if (validateUid == null) { - validateUid = new UidRecord(item.uid); + validateUid = new UidRecord(item.uid, mAtmInternal); mValidateUids.put(item.uid, validateUid); } if ((item.change & UidRecord.CHANGE_IDLE) != 0) { @@ -2847,7 +2846,7 @@ public class ActivityManagerService extends IActivityManager.Stub } else if ((item.change & UidRecord.CHANGE_ACTIVE) != 0) { validateUid.idle = false; } - validateUid.curProcState = validateUid.setProcState = item.processState; + validateUid.setCurProcState(validateUid.setProcState = item.processState); validateUid.lastDispatchedProcStateSeq = item.procStateSeq; } } @@ -2923,8 +2922,7 @@ public class ActivityManagerService extends IActivityManager.Stub final boolean newAboveCut = item.processState <= reg.cutpoint; doReport = lastAboveCut != newAboveCut; } else { - doReport = item.processState - != ActivityManager.PROCESS_STATE_NONEXISTENT; + doReport = item.processState != PROCESS_STATE_NONEXISTENT; } } if (doReport) { @@ -5142,7 +5140,7 @@ public class ActivityManagerService extends IActivityManager.Stub if (uidRec == null || uidRec.idle) { return false; } - return uidRec.curProcState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; + return uidRec.getCurProcState() <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; } } @@ -5156,7 +5154,7 @@ public class ActivityManagerService extends IActivityManager.Stub int getUidStateLocked(int uid) { UidRecord uidRec = mActiveUids.get(uid); - return uidRec == null ? ActivityManager.PROCESS_STATE_NONEXISTENT : uidRec.curProcState; + return uidRec == null ? PROCESS_STATE_NONEXISTENT : uidRec.getCurProcState(); } // ========================================================= @@ -5210,8 +5208,7 @@ public class ActivityManagerService extends IActivityManager.Stub synchronized (mPidsSelfLocked) { for (int i = 0; i < pids.length; i++) { ProcessRecord pr = mPidsSelfLocked.get(pids[i]); - states[i] = (pr == null) ? ActivityManager.PROCESS_STATE_NONEXISTENT : - pr.getCurProcState(); + states[i] = (pr == null) ? PROCESS_STATE_NONEXISTENT : pr.getCurProcState(); if (scores != null) { scores[i] = (pr == null) ? ProcessList.INVALID_ADJ : pr.curAdj; } @@ -7619,7 +7616,7 @@ public class ActivityManagerService extends IActivityManager.Stub synchronized (this) { UidRecord uidRec = mActiveUids.get(uid); - return uidRec != null ? uidRec.curProcState : ActivityManager.PROCESS_STATE_NONEXISTENT; + return uidRec != null ? uidRec.getCurProcState() : PROCESS_STATE_NONEXISTENT; } } @@ -9568,7 +9565,7 @@ public class ActivityManagerService extends IActivityManager.Stub return -1; } - boolean dumpUids(PrintWriter pw, String dumpPackage, int dumpAppId, SparseArray<UidRecord> uids, + boolean dumpUids(PrintWriter pw, String dumpPackage, int dumpAppId, ActiveUids uids, String header, boolean needSep) { boolean printed = false; for (int i=0; i<uids.size(); i++) { @@ -16222,8 +16219,7 @@ public class ActivityManagerService extends IActivityManager.Stub mPendingPssProcesses.clear(); for (int i = mProcessList.getLruSizeLocked() - 1; i >= 0; i--) { ProcessRecord app = mProcessList.mLruProcesses.get(i); - if (app.thread == null - || app.getCurProcState() == ActivityManager.PROCESS_STATE_NONEXISTENT) { + if (app.thread == null || app.getCurProcState() == PROCESS_STATE_NONEXISTENT) { continue; } if (memLowered || (always && now > @@ -16604,7 +16600,7 @@ public class ActivityManagerService extends IActivityManager.Stub } } } - if (app.setProcState == ActivityManager.PROCESS_STATE_NONEXISTENT + if (app.setProcState == PROCESS_STATE_NONEXISTENT || ProcessList.procStatesDifferForMem(app.getCurProcState(), app.setProcState)) { if (false && mTestPssMode && app.setProcState >= 0 && app.lastStateTime <= (now-200)) { // Experimental code to more aggressively collect pss while @@ -16793,8 +16789,7 @@ public class ActivityManagerService extends IActivityManager.Stub } } pendingChange.change = change; - pendingChange.processState = uidRec != null - ? uidRec.setProcState : ActivityManager.PROCESS_STATE_NONEXISTENT; + pendingChange.processState = uidRec != null ? uidRec.setProcState : PROCESS_STATE_NONEXISTENT; pendingChange.ephemeral = uidRec != null ? uidRec.ephemeral : isEphemeralLocked(uid); pendingChange.procStateSeq = uidRec != null ? uidRec.curProcStateSeq : 0; if (uidRec != null) { @@ -17229,8 +17224,8 @@ public class ActivityManagerService extends IActivityManager.Stub final UidRecord uidRec = app.uidRecord; if (uidRec != null) { uidRec.ephemeral = app.info.isInstantApp(); - if (uidRec.curProcState > app.getCurProcState()) { - uidRec.curProcState = app.getCurProcState(); + if (uidRec.getCurProcState() > app.getCurProcState()) { + uidRec.setCurProcState(app.getCurProcState()); } if (app.hasForegroundServices()) { uidRec.foregroundServices = true; @@ -17437,14 +17432,14 @@ public class ActivityManagerService extends IActivityManager.Stub for (int i=mActiveUids.size()-1; i>=0; i--) { final UidRecord uidRec = mActiveUids.valueAt(i); int uidChange = UidRecord.CHANGE_PROCSTATE; - if (uidRec.curProcState != ActivityManager.PROCESS_STATE_NONEXISTENT - && (uidRec.setProcState != uidRec.curProcState + if (uidRec.getCurProcState() != PROCESS_STATE_NONEXISTENT + && (uidRec.setProcState != uidRec.getCurProcState() || uidRec.setWhitelist != uidRec.curWhitelist)) { - if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, - "Changes in " + uidRec + ": proc state from " + uidRec.setProcState - + " to " + uidRec.curProcState + ", whitelist from " + uidRec.setWhitelist + if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, "Changes in " + uidRec + + ": proc state from " + uidRec.setProcState + " to " + + uidRec.getCurProcState() + ", whitelist from " + uidRec.setWhitelist + " to " + uidRec.curWhitelist); - if (ActivityManager.isProcStateBackground(uidRec.curProcState) + if (ActivityManager.isProcStateBackground(uidRec.getCurProcState()) && !uidRec.curWhitelist) { // UID is now in the background (and not on the temp whitelist). Was it // previously in the foreground (or on the temp whitelist)? @@ -17477,17 +17472,16 @@ public class ActivityManagerService extends IActivityManager.Stub } final boolean wasCached = uidRec.setProcState > ActivityManager.PROCESS_STATE_RECEIVER; - final boolean isCached = uidRec.curProcState + final boolean isCached = uidRec.getCurProcState() > ActivityManager.PROCESS_STATE_RECEIVER; - if (wasCached != isCached || - uidRec.setProcState == ActivityManager.PROCESS_STATE_NONEXISTENT) { + if (wasCached != isCached || uidRec.setProcState == PROCESS_STATE_NONEXISTENT) { uidChange |= isCached ? UidRecord.CHANGE_CACHED : UidRecord.CHANGE_UNCACHED; } - uidRec.setProcState = uidRec.curProcState; + uidRec.setProcState = uidRec.getCurProcState(); uidRec.setWhitelist = uidRec.curWhitelist; uidRec.setIdle = uidRec.idle; enqueueUidChangeLocked(uidRec, -1, uidChange); - noteUidProcessState(uidRec.uid, uidRec.curProcState); + noteUidProcessState(uidRec.uid, uidRec.getCurProcState()); if (uidRec.foregroundServices) { mServices.foregroundServiceProcStateChangedLocked(uidRec); } @@ -17648,7 +17642,7 @@ public class ActivityManagerService extends IActivityManager.Stub continue; } // If process state is not changed, then there's nothing to do. - if (uidRec.setProcState == uidRec.curProcState) { + if (uidRec.setProcState == uidRec.getCurProcState()) { continue; } final int blockState = getBlockStateForUid(uidRec); @@ -17712,8 +17706,9 @@ public class ActivityManagerService extends IActivityManager.Stub @VisibleForTesting int getBlockStateForUid(UidRecord uidRec) { // Denotes whether uid's process state is currently allowed network access. - final boolean isAllowed = isProcStateAllowedWhileIdleOrPowerSaveMode(uidRec.curProcState) - || isProcStateAllowedWhileOnRestrictBackground(uidRec.curProcState); + final boolean isAllowed = + isProcStateAllowedWhileIdleOrPowerSaveMode(uidRec.getCurProcState()) + || isProcStateAllowedWhileOnRestrictBackground(uidRec.getCurProcState()); // Denotes whether uid's process state was previously allowed network access. final boolean wasAllowed = isProcStateAllowedWhileIdleOrPowerSaveMode(uidRec.setProcState) || isProcStateAllowedWhileOnRestrictBackground(uidRec.setProcState); diff --git a/services/core/java/com/android/server/am/ActivityStarter.java b/services/core/java/com/android/server/am/ActivityStarter.java index 45a06524745a..14b4de9e3ec5 100644 --- a/services/core/java/com/android/server/am/ActivityStarter.java +++ b/services/core/java/com/android/server/am/ActivityStarter.java @@ -883,18 +883,18 @@ class ActivityStarter { try { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "logActivityStart"); - final int callingUidProcState = mService.mAm.getUidStateLocked(callingUid); + final int callingUidProcState = mService.getUidStateLocked(callingUid); final boolean callingUidHasAnyVisibleWindow = mService.mWindowManager.isAnyWindowVisibleForUid(callingUid); final int realCallingUidProcState = (callingUid == realCallingUid) ? callingUidProcState - : mService.mAm.getUidStateLocked(realCallingUid); + : mService.getUidStateLocked(realCallingUid); final boolean realCallingUidHasAnyVisibleWindow = (callingUid == realCallingUid) ? callingUidHasAnyVisibleWindow : mService.mWindowManager.isAnyWindowVisibleForUid(realCallingUid); final String targetPackage = r.packageName; final int targetUid = (r.appInfo != null) ? r.appInfo.uid : -1; - final int targetUidProcState = mService.mAm.getUidStateLocked(targetUid); + final int targetUidProcState = mService.getUidStateLocked(targetUid); final boolean targetUidHasAnyVisibleWindow = (targetUid != -1) ? mService.mWindowManager.isAnyWindowVisibleForUid(targetUid) : false; diff --git a/services/core/java/com/android/server/am/ActivityTaskManagerService.java b/services/core/java/com/android/server/am/ActivityTaskManagerService.java index 8ae5495cfa05..fa3039f63b6d 100644 --- a/services/core/java/com/android/server/am/ActivityTaskManagerService.java +++ b/services/core/java/com/android/server/am/ActivityTaskManagerService.java @@ -27,6 +27,7 @@ import static android.Manifest.permission.REMOVE_TASKS; import static android.Manifest.permission.START_TASKS_FROM_RECENTS; import static android.Manifest.permission.STOP_APP_SWITCHES; import static android.app.ActivityManager.LOCK_TASK_MODE_NONE; +import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT; import static android.app.ActivityManagerInternal.ALLOW_FULL_ONLY; import static android.app.ActivityTaskManager.RESIZE_MODE_PRESERVE_WINDOW; import static android.app.ActivityTaskManager.SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT; @@ -347,6 +348,8 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { WindowManagerService mWindowManager; private UserManagerService mUserManager; private AppOpsService mAppOpsService; + /** All active uids in the system. */ + final SparseArray<Integer> mActiveUids = new SparseArray<>(); /** All processes currently running that might have a window organized by name. */ final ProcessMap<WindowProcessController> mProcessNames = new ProcessMap<>(); /** All processes we currently have running mapped by pid */ @@ -5455,6 +5458,10 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { return null; } + int getUidStateLocked(int uid) { + return mActiveUids.get(uid, PROCESS_STATE_NONEXISTENT); + } + void logAppTooSlow(WindowProcessController app, long startTime, String msg) { if (true || Build.IS_USER) { return; @@ -6627,5 +6634,35 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { return mStackSupervisor.finishTopCrashedActivitiesLocked(crashedApp, reason); } } + + @Override + public void onUidActive(int uid, int procState) { + synchronized (mGlobalLock) { + mActiveUids.put(uid, procState); + } + } + + @Override + public void onUidInactive(int uid) { + synchronized (mGlobalLock) { + mActiveUids.remove(uid); + } + } + + @Override + public void onActiveUidsCleared() { + synchronized (mGlobalLock) { + mActiveUids.clear(); + } + } + + @Override + public void onUidProcStateChanged(int uid, int procState) { + synchronized (mGlobalLock) { + if (mActiveUids.get(uid) != null) { + mActiveUids.put(uid, procState); + } + } + } } } diff --git a/services/core/java/com/android/server/am/ProcessList.java b/services/core/java/com/android/server/am/ProcessList.java index 3f172cc11468..5fdcb9220fca 100644 --- a/services/core/java/com/android/server/am/ProcessList.java +++ b/services/core/java/com/android/server/am/ProcessList.java @@ -1911,7 +1911,7 @@ public final class ProcessList { } UidRecord uidRec = mService.mActiveUids.get(proc.uid); if (uidRec == null) { - uidRec = new UidRecord(proc.uid); + uidRec = new UidRecord(proc.uid, mService.mAtmInternal); // This is the first appearance of the uid, report it now! if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, "Creating new process uid: " + uidRec); @@ -1923,7 +1923,7 @@ public final class ProcessList { uidRec.updateHasInternetPermission(); mService.mActiveUids.put(proc.uid, uidRec); EventLogTags.writeAmUidRunning(uidRec.uid); - mService.noteUidProcessState(uidRec.uid, uidRec.curProcState); + mService.noteUidProcessState(uidRec.uid, uidRec.getCurProcState()); } proc.uidRecord = uidRec; diff --git a/services/core/java/com/android/server/am/UidRecord.java b/services/core/java/com/android/server/am/UidRecord.java index 3b859edd3cf9..6cb1097c7ddf 100644 --- a/services/core/java/com/android/server/am/UidRecord.java +++ b/services/core/java/com/android/server/am/UidRecord.java @@ -18,7 +18,6 @@ package com.android.server.am; import android.Manifest; import android.app.ActivityManager; -import android.app.ActivityManagerProto; import android.content.pm.PackageManager; import android.os.SystemClock; import android.os.UserHandle; @@ -27,14 +26,14 @@ import android.util.proto.ProtoOutputStream; import android.util.proto.ProtoUtils; import com.android.internal.annotations.GuardedBy; -import com.android.internal.annotations.VisibleForTesting; +import com.android.server.wm.ActivityTaskManagerInternal; /** * Overall information about a uid that has actively running processes. */ public final class UidRecord { final int uid; - int curProcState; + private int mCurProcState; int setProcState = ActivityManager.PROCESS_STATE_NONEXISTENT; long lastBackgroundTime; boolean ephemeral; @@ -44,11 +43,12 @@ public final class UidRecord { boolean idle; boolean setIdle; int numProcs; + final ActivityTaskManagerInternal mAtmInternal; /** - * Sequence number associated with the {@link #curProcState}. This is incremented using + * Sequence number associated with the {@link #mCurProcState}. This is incremented using * {@link ActivityManagerService#mProcStateSeqCounter} - * when {@link #curProcState} changes from background to foreground or vice versa. + * when {@link #mCurProcState} changes from background to foreground or vice versa. */ @GuardedBy("networkStateUpdate") long curProcStateSeq; @@ -117,14 +117,26 @@ public final class UidRecord { ChangeItem pendingChange; int lastReportedChange; - public UidRecord(int _uid) { + public UidRecord(int _uid, ActivityTaskManagerInternal atmInternal) { uid = _uid; idle = true; + mAtmInternal = atmInternal; reset(); } + public int getCurProcState() { + return mCurProcState; + } + + public void setCurProcState(int curProcState) { + mCurProcState = curProcState; + if (mAtmInternal != null) { + mAtmInternal.onUidProcStateChanged(uid, curProcState); + } + } + public void reset() { - curProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; + setCurProcState(ActivityManager.PROCESS_STATE_CACHED_EMPTY); foregroundServices = false; } @@ -148,7 +160,7 @@ public final class UidRecord { void writeToProto(ProtoOutputStream proto, long fieldId) { long token = proto.start(fieldId); proto.write(UidRecordProto.UID, uid); - proto.write(UidRecordProto.CURRENT, ProcessList.makeProcStateProtoEnum(curProcState)); + proto.write(UidRecordProto.CURRENT, ProcessList.makeProcStateProtoEnum(mCurProcState)); proto.write(UidRecordProto.EPHEMERAL, ephemeral); proto.write(UidRecordProto.FG_SERVICES, foregroundServices); proto.write(UidRecordProto.WHILELIST, curWhitelist); @@ -178,7 +190,7 @@ public final class UidRecord { sb.append(' '); UserHandle.formatUid(sb, uid); sb.append(' '); - sb.append(ProcessList.makeProcStateString(curProcState)); + sb.append(ProcessList.makeProcStateString(mCurProcState)); if (ephemeral) { sb.append(" ephemeral"); } diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java b/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java index 7f9ee8405dfc..ac308990d514 100644 --- a/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java +++ b/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java @@ -439,4 +439,9 @@ public abstract class ActivityTaskManagerInternal { */ public abstract int finishTopCrashedActivities( WindowProcessController crashedApp, String reason); + + public abstract void onUidActive(int uid, int procState); + public abstract void onUidInactive(int uid); + public abstract void onActiveUidsCleared(); + public abstract void onUidProcStateChanged(int uid, int procState); } diff --git a/services/tests/servicestests/src/com/android/server/am/ActivityManagerInternalTest.java b/services/tests/servicestests/src/com/android/server/am/ActivityManagerInternalTest.java index 9a7488e42326..8c27e256456f 100644 --- a/services/tests/servicestests/src/com/android/server/am/ActivityManagerInternalTest.java +++ b/services/tests/servicestests/src/com/android/server/am/ActivityManagerInternalTest.java @@ -133,7 +133,7 @@ public class ActivityManagerInternalTest { private UidRecord addActiveUidRecord(int uid, long curProcStateSeq, long lastNetworkUpdatedProcStateSeq) { - final UidRecord record = new UidRecord(uid); + final UidRecord record = new UidRecord(uid, null /* atmInternal */); record.lastNetworkUpdatedProcStateSeq = lastNetworkUpdatedProcStateSeq; record.curProcStateSeq = curProcStateSeq; record.waitingForNetwork = true; diff --git a/services/tests/servicestests/src/com/android/server/am/ActivityManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/am/ActivityManagerServiceTest.java index f42f5b1fff2e..349c0a37a4c1 100644 --- a/services/tests/servicestests/src/com/android/server/am/ActivityManagerServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/am/ActivityManagerServiceTest.java @@ -255,7 +255,7 @@ public class ActivityManagerServiceTest { } private UidRecord addUidRecord(int uid) { - final UidRecord uidRec = new UidRecord(uid); + final UidRecord uidRec = new UidRecord(uid, null /* atmInternal */); uidRec.waitingForNetwork = true; uidRec.hasInternetPermission = true; mAms.mActiveUids.put(uid, uidRec); @@ -274,7 +274,7 @@ public class ActivityManagerServiceTest { thread.startAndWait("Unexpected state for " + uidRec); uidRec.setProcState = prevState; - uidRec.curProcState = curState; + uidRec.setCurProcState(curState); mAms.incrementProcStateSeqAndNotifyAppsLocked(); assertEquals(expectedGlobalCounter, mAms.mProcessList.mProcStateSeqCounter); @@ -301,7 +301,7 @@ public class ActivityManagerServiceTest { @Test public void testBlockStateForUid() { - final UidRecord uidRec = new UidRecord(TEST_UID); + final UidRecord uidRec = new UidRecord(TEST_UID, null /* atmInternal */); int expectedBlockState; final String errorTemplate = "Block state should be %s, prevState: %s, curState: %s"; @@ -309,47 +309,48 @@ public class ActivityManagerServiceTest { return String.format(errorTemplate, valueToString(ActivityManagerService.class, "NETWORK_STATE_", blockState), valueToString(ActivityManager.class, "PROCESS_STATE_", uidRec.setProcState), - valueToString(ActivityManager.class, "PROCESS_STATE_", uidRec.curProcState)); + valueToString(ActivityManager.class, "PROCESS_STATE_", uidRec.getCurProcState()) + ); }; // No change in uid state uidRec.setProcState = PROCESS_STATE_RECEIVER; - uidRec.curProcState = PROCESS_STATE_RECEIVER; + uidRec.setCurProcState(PROCESS_STATE_RECEIVER); expectedBlockState = NETWORK_STATE_NO_CHANGE; assertEquals(errorMsg.apply(expectedBlockState), expectedBlockState, mAms.getBlockStateForUid(uidRec)); // Foreground to foreground uidRec.setProcState = PROCESS_STATE_FOREGROUND_SERVICE; - uidRec.curProcState = PROCESS_STATE_BOUND_FOREGROUND_SERVICE; + uidRec.setCurProcState(PROCESS_STATE_BOUND_FOREGROUND_SERVICE); expectedBlockState = NETWORK_STATE_NO_CHANGE; assertEquals(errorMsg.apply(expectedBlockState), expectedBlockState, mAms.getBlockStateForUid(uidRec)); // Background to background uidRec.setProcState = PROCESS_STATE_CACHED_ACTIVITY; - uidRec.curProcState = PROCESS_STATE_CACHED_EMPTY; + uidRec.setCurProcState(PROCESS_STATE_CACHED_EMPTY); expectedBlockState = NETWORK_STATE_NO_CHANGE; assertEquals(errorMsg.apply(expectedBlockState), expectedBlockState, mAms.getBlockStateForUid(uidRec)); // Background to background uidRec.setProcState = PROCESS_STATE_NONEXISTENT; - uidRec.curProcState = PROCESS_STATE_CACHED_ACTIVITY; + uidRec.setCurProcState(PROCESS_STATE_CACHED_ACTIVITY); expectedBlockState = NETWORK_STATE_NO_CHANGE; assertEquals(errorMsg.apply(expectedBlockState), expectedBlockState, mAms.getBlockStateForUid(uidRec)); // Background to foreground uidRec.setProcState = PROCESS_STATE_SERVICE; - uidRec.curProcState = PROCESS_STATE_FOREGROUND_SERVICE; + uidRec.setCurProcState(PROCESS_STATE_FOREGROUND_SERVICE); expectedBlockState = NETWORK_STATE_BLOCK; assertEquals(errorMsg.apply(expectedBlockState), expectedBlockState, mAms.getBlockStateForUid(uidRec)); // Foreground to background uidRec.setProcState = PROCESS_STATE_TOP; - uidRec.curProcState = PROCESS_STATE_LAST_ACTIVITY; + uidRec.setCurProcState(PROCESS_STATE_LAST_ACTIVITY); expectedBlockState = NETWORK_STATE_UNBLOCK; assertEquals(errorMsg.apply(expectedBlockState), expectedBlockState, mAms.getBlockStateForUid(uidRec)); @@ -593,10 +594,10 @@ public class ActivityManagerServiceTest { assertNotNull("validateUidRecord should not be null since the change is neither " + "CHANGE_GONE nor CHANGE_GONE_IDLE", validateUidRecord); assertEquals("processState: " + item.processState + " curProcState: " - + validateUidRecord.curProcState + " should have been equal", - item.processState, validateUidRecord.curProcState); + + validateUidRecord.getCurProcState() + " should have been equal", + item.processState, validateUidRecord.getCurProcState()); assertEquals("processState: " + item.processState + " setProcState: " - + validateUidRecord.curProcState + " should have been equal", + + validateUidRecord.getCurProcState() + " should have been equal", item.processState, validateUidRecord.setProcState); if (item.change == UidRecord.CHANGE_IDLE) { assertTrue("UidRecord.idle should be updated to true for CHANGE_IDLE", @@ -626,7 +627,7 @@ public class ActivityManagerServiceTest { @Test public void testEnqueueUidChangeLocked_procStateSeqUpdated() { - final UidRecord uidRecord = new UidRecord(TEST_UID); + final UidRecord uidRecord = new UidRecord(TEST_UID, null /* atmInternal */); uidRecord.curProcStateSeq = TEST_PROC_STATE_SEQ1; // Verify with no pending changes for TEST_UID. @@ -672,7 +673,7 @@ public class ActivityManagerServiceTest { @MediumTest @Test public void testEnqueueUidChangeLocked_dispatchUidsChanged() { - final UidRecord uidRecord = new UidRecord(TEST_UID); + final UidRecord uidRecord = new UidRecord(TEST_UID, null /* atmInternal */); final int expectedProcState = PROCESS_STATE_SERVICE; uidRecord.setProcState = expectedProcState; uidRecord.curProcStateSeq = TEST_PROC_STATE_SEQ1; @@ -744,7 +745,7 @@ public class ActivityManagerServiceTest { private void verifyWaitingForNetworkStateUpdate(long curProcStateSeq, long lastDispatchedProcStateSeq, long lastNetworkUpdatedProcStateSeq, final long procStateSeqToWait, boolean expectWait) throws Exception { - final UidRecord record = new UidRecord(Process.myUid()); + final UidRecord record = new UidRecord(Process.myUid(), null /* atmInternal */); record.curProcStateSeq = curProcStateSeq; record.lastDispatchedProcStateSeq = lastDispatchedProcStateSeq; record.lastNetworkUpdatedProcStateSeq = lastNetworkUpdatedProcStateSeq; |