| /* |
| * 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.wm; |
| |
| import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT; |
| import static android.os.Build.VERSION_CODES.Q; |
| import static android.view.Display.INVALID_DISPLAY; |
| |
| import static com.android.server.am.ActivityManagerService.MY_PID; |
| import static com.android.server.wm.ActivityStack.ActivityState.DESTROYED; |
| import static com.android.server.wm.ActivityStack.ActivityState.DESTROYING; |
| import static com.android.server.wm.ActivityStack.ActivityState.PAUSED; |
| import static com.android.server.wm.ActivityStack.ActivityState.PAUSING; |
| import static com.android.server.wm.ActivityStack.ActivityState.RESUMED; |
| import static com.android.server.wm.ActivityStack.ActivityState.STOPPING; |
| import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONFIGURATION; |
| import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RELEASE; |
| import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION; |
| import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RELEASE; |
| import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM; |
| import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME; |
| import static com.android.server.wm.ActivityTaskManagerService.ACTIVITY_BG_START_GRACE_PERIOD_MS; |
| import static com.android.server.wm.ActivityTaskManagerService.INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT_MS; |
| import static com.android.server.wm.ActivityTaskManagerService.KEY_DISPATCHING_TIMEOUT_MS; |
| import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE; |
| |
| import android.annotation.NonNull; |
| import android.app.Activity; |
| import android.app.ActivityThread; |
| import android.app.IApplicationThread; |
| import android.app.ProfilerInfo; |
| import android.app.servertransaction.ConfigurationChangeItem; |
| import android.content.Intent; |
| import android.content.pm.ActivityInfo; |
| import android.content.pm.ApplicationInfo; |
| import android.content.res.Configuration; |
| import android.os.Message; |
| import android.os.RemoteException; |
| import android.os.SystemClock; |
| import android.util.ArraySet; |
| import android.util.Log; |
| import android.util.Slog; |
| import android.util.proto.ProtoOutputStream; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.app.HeavyWeightSwitcherActivity; |
| import com.android.internal.util.function.pooled.PooledLambda; |
| import com.android.server.Watchdog; |
| import com.android.server.wm.ActivityTaskManagerService.HotPath; |
| |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| |
| /** |
| * The Activity Manager (AM) package manages the lifecycle of processes in the system through |
| * ProcessRecord. However, it is important for the Window Manager (WM) package to be aware |
| * of the processes and their state since it affects how WM manages windows and activities. This |
| * class that allows the ProcessRecord object in the AM package to communicate important |
| * changes to its state to the WM package in a structured way. WM package also uses |
| * {@link WindowProcessListener} to request changes to the process state on the AM side. |
| * Note that public calls into this class are assumed to be originating from outside the |
| * window manager so the window manager lock is held and appropriate permissions are checked before |
| * calls are allowed to proceed. |
| */ |
| public class WindowProcessController extends ConfigurationContainer<ConfigurationContainer> |
| implements ConfigurationContainerListener { |
| private static final String TAG = TAG_WITH_CLASS_NAME ? "WindowProcessController" : TAG_ATM; |
| private static final String TAG_RELEASE = TAG + POSTFIX_RELEASE; |
| private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION; |
| |
| // all about the first app in the process |
| final ApplicationInfo mInfo; |
| final String mName; |
| final int mUid; |
| // The process of this application; 0 if none |
| private volatile int mPid; |
| // user of process. |
| final int mUserId; |
| // The owner of this window process controller object. Mainly for identification when we |
| // communicate back to the activity manager side. |
| public final Object mOwner; |
| // List of packages running in the process |
| final ArraySet<String> mPkgList = new ArraySet<>(); |
| private final WindowProcessListener mListener; |
| private final ActivityTaskManagerService mAtm; |
| // The actual proc... may be null only if 'persistent' is true (in which case we are in the |
| // process of launching the app) |
| private IApplicationThread mThread; |
| // Currently desired scheduling class |
| private volatile int mCurSchedGroup; |
| // Currently computed process state |
| private volatile int mCurProcState = PROCESS_STATE_NONEXISTENT; |
| // Last reported process state; |
| private volatile int mRepProcState = PROCESS_STATE_NONEXISTENT; |
| // are we in the process of crashing? |
| private volatile boolean mCrashing; |
| // does the app have a not responding dialog? |
| private volatile boolean mNotResponding; |
| // always keep this application running? |
| private volatile boolean mPersistent; |
| // The ABI this process was launched with |
| private volatile String mRequiredAbi; |
| // Running any services that are foreground? |
| private volatile boolean mHasForegroundServices; |
| // Running any activities that are foreground? |
| private volatile boolean mHasForegroundActivities; |
| // Are there any client services with activities? |
| private volatile boolean mHasClientActivities; |
| // Is this process currently showing a non-activity UI that the user is interacting with? |
| // E.g. The status bar when it is expanded, but not when it is minimized. When true the process |
| // will be set to use the ProcessList#SCHED_GROUP_TOP_APP scheduling group to boost performance. |
| private volatile boolean mHasTopUi; |
| // Is the process currently showing a non-activity UI that overlays on-top of activity UIs on |
| // screen. E.g. display a window of type |
| // android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY When true the process will |
| // oom adj score will be set to ProcessList#PERCEPTIBLE_APP_ADJ at minimum to reduce the chance |
| // of the process getting killed. |
| private volatile boolean mHasOverlayUi; |
| // Want to clean up resources from showing UI? |
| private volatile boolean mPendingUiClean; |
| // The time we sent the last interaction event |
| private volatile long mInteractionEventTime; |
| // When we became foreground for interaction purposes |
| private volatile long mFgInteractionTime; |
| // When (uptime) the process last became unimportant |
| private volatile long mWhenUnimportant; |
| // was app launched for debugging? |
| private volatile boolean mDebugging; |
| // Active instrumentation running in process? |
| private volatile boolean mInstrumenting; |
| // Active instrumentation with background activity starts privilege running in process? |
| private volatile boolean mInstrumentingWithBackgroundActivityStartPrivileges; |
| // This process it perceptible by the user. |
| private volatile boolean mPerceptible; |
| // Set to true when process was launched with a wrapper attached |
| private volatile boolean mUsingWrapper; |
| // Set to true if this process is currently temporarily whitelisted to start activities even if |
| // it's not in the foreground |
| private volatile boolean mAllowBackgroundActivityStarts; |
| // Set of UIDs of clients currently bound to this process |
| private volatile ArraySet<Integer> mBoundClientUids = new ArraySet<Integer>(); |
| |
| // Thread currently set for VR scheduling |
| int mVrThreadTid; |
| |
| // all activities running in the process |
| private final ArrayList<ActivityRecord> mActivities = new ArrayList<>(); |
| // any tasks this process had run root activities in |
| private final ArrayList<TaskRecord> mRecentTasks = new ArrayList<>(); |
| // The most recent top-most activity that was resumed in the process for pre-Q app. |
| private ActivityRecord mPreQTopResumedActivity = null; |
| // The last time an activity was launched in the process |
| private long mLastActivityLaunchTime; |
| // The last time an activity was finished in the process while the process participated |
| // in a visible task |
| private long mLastActivityFinishTime; |
| |
| // Last configuration that was reported to the process. |
| private final Configuration mLastReportedConfiguration; |
| // Registered display id as a listener to override config change |
| private int mDisplayId; |
| |
| public WindowProcessController(ActivityTaskManagerService atm, ApplicationInfo info, |
| String name, int uid, int userId, Object owner, WindowProcessListener listener) { |
| mInfo = info; |
| mName = name; |
| mUid = uid; |
| mUserId = userId; |
| mOwner = owner; |
| mListener = listener; |
| mAtm = atm; |
| mLastReportedConfiguration = new Configuration(); |
| mDisplayId = INVALID_DISPLAY; |
| if (atm != null) { |
| onConfigurationChanged(atm.getGlobalConfiguration()); |
| } |
| } |
| |
| public void setPid(int pid) { |
| mPid = pid; |
| } |
| |
| public int getPid() { |
| return mPid; |
| } |
| |
| @HotPath(caller = HotPath.PROCESS_CHANGE) |
| public void setThread(IApplicationThread thread) { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| mThread = thread; |
| } |
| } |
| |
| IApplicationThread getThread() { |
| return mThread; |
| } |
| |
| boolean hasThread() { |
| return mThread != null; |
| } |
| |
| public void setCurrentSchedulingGroup(int curSchedGroup) { |
| mCurSchedGroup = curSchedGroup; |
| } |
| |
| int getCurrentSchedulingGroup() { |
| return mCurSchedGroup; |
| } |
| |
| public void setCurrentProcState(int curProcState) { |
| mCurProcState = curProcState; |
| } |
| |
| int getCurrentProcState() { |
| return mCurProcState; |
| } |
| |
| public void setReportedProcState(int repProcState) { |
| mRepProcState = repProcState; |
| } |
| |
| int getReportedProcState() { |
| return mRepProcState; |
| } |
| |
| public void setCrashing(boolean crashing) { |
| mCrashing = crashing; |
| } |
| |
| boolean isCrashing() { |
| return mCrashing; |
| } |
| |
| public void setNotResponding(boolean notResponding) { |
| mNotResponding = notResponding; |
| } |
| |
| boolean isNotResponding() { |
| return mNotResponding; |
| } |
| |
| public void setPersistent(boolean persistent) { |
| mPersistent = persistent; |
| } |
| |
| boolean isPersistent() { |
| return mPersistent; |
| } |
| |
| public void setHasForegroundServices(boolean hasForegroundServices) { |
| mHasForegroundServices = hasForegroundServices; |
| } |
| |
| boolean hasForegroundServices() { |
| return mHasForegroundServices; |
| } |
| |
| public void setHasForegroundActivities(boolean hasForegroundActivities) { |
| mHasForegroundActivities = hasForegroundActivities; |
| } |
| |
| boolean hasForegroundActivities() { |
| return mHasForegroundActivities; |
| } |
| |
| public void setHasClientActivities(boolean hasClientActivities) { |
| mHasClientActivities = hasClientActivities; |
| } |
| |
| boolean hasClientActivities() { |
| return mHasClientActivities; |
| } |
| |
| public void setHasTopUi(boolean hasTopUi) { |
| mHasTopUi = hasTopUi; |
| } |
| |
| boolean hasTopUi() { |
| return mHasTopUi; |
| } |
| |
| public void setHasOverlayUi(boolean hasOverlayUi) { |
| mHasOverlayUi = hasOverlayUi; |
| } |
| |
| boolean hasOverlayUi() { |
| return mHasOverlayUi; |
| } |
| |
| public void setPendingUiClean(boolean hasPendingUiClean) { |
| mPendingUiClean = hasPendingUiClean; |
| } |
| |
| boolean hasPendingUiClean() { |
| return mPendingUiClean; |
| } |
| |
| /** @return {@code true} if the process registered to a display as a config listener. */ |
| boolean registeredForDisplayConfigChanges() { |
| return mDisplayId != INVALID_DISPLAY; |
| } |
| |
| void postPendingUiCleanMsg(boolean pendingUiClean) { |
| if (mListener == null) return; |
| // Posting on handler so WM lock isn't held when we call into AM. |
| final Message m = PooledLambda.obtainMessage( |
| WindowProcessListener::setPendingUiClean, mListener, pendingUiClean); |
| mAtm.mH.sendMessage(m); |
| } |
| |
| public void setInteractionEventTime(long interactionEventTime) { |
| mInteractionEventTime = interactionEventTime; |
| } |
| |
| long getInteractionEventTime() { |
| return mInteractionEventTime; |
| } |
| |
| public void setFgInteractionTime(long fgInteractionTime) { |
| mFgInteractionTime = fgInteractionTime; |
| } |
| |
| long getFgInteractionTime() { |
| return mFgInteractionTime; |
| } |
| |
| public void setWhenUnimportant(long whenUnimportant) { |
| mWhenUnimportant = whenUnimportant; |
| } |
| |
| long getWhenUnimportant() { |
| return mWhenUnimportant; |
| } |
| |
| public void setRequiredAbi(String requiredAbi) { |
| mRequiredAbi = requiredAbi; |
| } |
| |
| String getRequiredAbi() { |
| return mRequiredAbi; |
| } |
| |
| /** Returns ID of display overriding the configuration for this process, or |
| * INVALID_DISPLAY if no display is overriding. */ |
| @VisibleForTesting |
| int getDisplayId() { |
| return mDisplayId; |
| } |
| |
| public void setDebugging(boolean debugging) { |
| mDebugging = debugging; |
| } |
| |
| boolean isDebugging() { |
| return mDebugging; |
| } |
| |
| public void setUsingWrapper(boolean usingWrapper) { |
| mUsingWrapper = usingWrapper; |
| } |
| |
| boolean isUsingWrapper() { |
| return mUsingWrapper; |
| } |
| |
| void setLastActivityLaunchTime(long launchTime) { |
| if (launchTime <= mLastActivityLaunchTime) { |
| return; |
| } |
| mLastActivityLaunchTime = launchTime; |
| } |
| |
| void setLastActivityFinishTimeIfNeeded(long finishTime) { |
| if (finishTime <= mLastActivityFinishTime || !hasActivityInVisibleTask()) { |
| return; |
| } |
| mLastActivityFinishTime = finishTime; |
| } |
| |
| public void setAllowBackgroundActivityStarts(boolean allowBackgroundActivityStarts) { |
| mAllowBackgroundActivityStarts = allowBackgroundActivityStarts; |
| } |
| |
| boolean areBackgroundActivityStartsAllowed() { |
| // allow if the whitelisting flag was explicitly set |
| if (mAllowBackgroundActivityStarts) { |
| return true; |
| } |
| // allow if any activity in the caller has either started or finished very recently, and |
| // it must be started or finished after last stop app switches time. |
| final long now = SystemClock.uptimeMillis(); |
| if (now - mLastActivityLaunchTime < ACTIVITY_BG_START_GRACE_PERIOD_MS |
| || now - mLastActivityFinishTime < ACTIVITY_BG_START_GRACE_PERIOD_MS) { |
| // if activity is started and finished before stop app switch time, we should not |
| // let app to be able to start background activity even it's in grace period. |
| if (mLastActivityLaunchTime > mAtm.getLastStopAppSwitchesTime() |
| || mLastActivityFinishTime > mAtm.getLastStopAppSwitchesTime()) { |
| return true; |
| } |
| } |
| // allow if the proc is instrumenting with background activity starts privs |
| if (mInstrumentingWithBackgroundActivityStartPrivileges) { |
| return true; |
| } |
| // allow if the caller has an activity in any foreground task |
| if (hasActivityInVisibleTask()) { |
| return true; |
| } |
| // allow if the caller is bound by a UID that's currently foreground |
| if (isBoundByForegroundUid()) { |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean isBoundByForegroundUid() { |
| for (int i = mBoundClientUids.size() - 1; i >= 0; --i) { |
| if (mAtm.isUidForeground(mBoundClientUids.valueAt(i))) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public void setBoundClientUids(ArraySet<Integer> boundClientUids) { |
| mBoundClientUids = boundClientUids; |
| } |
| |
| public void setInstrumenting(boolean instrumenting, |
| boolean hasBackgroundActivityStartPrivileges) { |
| mInstrumenting = instrumenting; |
| mInstrumentingWithBackgroundActivityStartPrivileges = hasBackgroundActivityStartPrivileges; |
| } |
| |
| boolean isInstrumenting() { |
| return mInstrumenting; |
| } |
| |
| public void setPerceptible(boolean perceptible) { |
| mPerceptible = perceptible; |
| } |
| |
| boolean isPerceptible() { |
| return mPerceptible; |
| } |
| |
| @Override |
| protected int getChildCount() { |
| return 0; |
| } |
| |
| @Override |
| protected ConfigurationContainer getChildAt(int index) { |
| return null; |
| } |
| |
| @Override |
| protected ConfigurationContainer getParent() { |
| return null; |
| } |
| |
| @HotPath(caller = HotPath.PROCESS_CHANGE) |
| public void addPackage(String packageName) { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| mPkgList.add(packageName); |
| } |
| } |
| |
| @HotPath(caller = HotPath.PROCESS_CHANGE) |
| public void clearPackageList() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| mPkgList.clear(); |
| } |
| } |
| |
| void addActivityIfNeeded(ActivityRecord r) { |
| // even if we already track this activity, note down that it has been launched |
| setLastActivityLaunchTime(r.lastLaunchTime); |
| if (mActivities.contains(r)) { |
| return; |
| } |
| mActivities.add(r); |
| } |
| |
| void removeActivity(ActivityRecord r) { |
| mActivities.remove(r); |
| } |
| |
| void makeFinishingForProcessRemoved() { |
| for (int i = mActivities.size() - 1; i >= 0; --i) { |
| mActivities.get(i).makeFinishingLocked(); |
| } |
| } |
| |
| void clearActivities() { |
| mActivities.clear(); |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public boolean hasActivities() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| return !mActivities.isEmpty(); |
| } |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public boolean hasVisibleActivities() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| for (int i = mActivities.size() - 1; i >= 0; --i) { |
| final ActivityRecord r = mActivities.get(i); |
| if (r.visible) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| @HotPath(caller = HotPath.LRU_UPDATE) |
| public boolean hasActivitiesOrRecentTasks() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| return !mActivities.isEmpty() || !mRecentTasks.isEmpty(); |
| } |
| } |
| |
| private boolean hasActivityInVisibleTask() { |
| for (int i = mActivities.size() - 1; i >= 0; --i) { |
| TaskRecord task = mActivities.get(i).getTaskRecord(); |
| if (task == null) { |
| continue; |
| } |
| ActivityRecord topActivity = task.getTopActivity(); |
| if (topActivity != null && topActivity.visible) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Update the top resuming activity in process for pre-Q apps, only the top-most visible |
| * activities are allowed to be resumed per process. |
| * @return {@code true} if the activity is allowed to be resumed by compatibility |
| * restrictions, which the activity was the topmost visible activity in process or the app is |
| * targeting after Q. |
| */ |
| boolean updateTopResumingActivityInProcessIfNeeded(@NonNull ActivityRecord activity) { |
| if (mInfo.targetSdkVersion >= Q || mPreQTopResumedActivity == activity) { |
| return true; |
| } |
| |
| final ActivityDisplay display = activity.getDisplay(); |
| if (display == null) { |
| // No need to update if the activity hasn't attach to any display. |
| return false; |
| } |
| |
| boolean canUpdate = false; |
| final ActivityDisplay topDisplay = |
| mPreQTopResumedActivity != null ? mPreQTopResumedActivity.getDisplay() : null; |
| // Update the topmost activity if current top activity was not on any display or no |
| // longer visible. |
| if (topDisplay == null || !mPreQTopResumedActivity.visible) { |
| canUpdate = true; |
| } |
| |
| // Update the topmost activity if the current top activity wasn't on top of the other one. |
| if (!canUpdate && topDisplay.mDisplayContent.compareTo(display.mDisplayContent) < 0) { |
| canUpdate = true; |
| } |
| |
| // Compare the z-order of ActivityStacks if both activities landed on same display. |
| if (display == topDisplay |
| && mPreQTopResumedActivity.getActivityStack().mTaskStack.compareTo( |
| activity.getActivityStack().mTaskStack) <= 0) { |
| canUpdate = true; |
| } |
| |
| if (canUpdate) { |
| // Make sure the previous top activity in the process no longer be resumed. |
| if (mPreQTopResumedActivity != null && mPreQTopResumedActivity.isState(RESUMED)) { |
| final ActivityStack stack = mPreQTopResumedActivity.getActivityStack(); |
| if (stack != null) { |
| stack.startPausingLocked(false /* userLeaving */, false /* uiSleeping */, |
| null /* resuming */, false /* pauseImmediately */); |
| } |
| } |
| mPreQTopResumedActivity = activity; |
| } |
| return canUpdate; |
| } |
| |
| public void stopFreezingActivities() { |
| synchronized (mAtm.mGlobalLock) { |
| int i = mActivities.size(); |
| while (i > 0) { |
| i--; |
| mActivities.get(i).stopFreezingScreenLocked(true); |
| } |
| } |
| } |
| |
| void finishActivities() { |
| ArrayList<ActivityRecord> activities = new ArrayList<>(mActivities); |
| for (int i = 0; i < activities.size(); i++) { |
| final ActivityRecord r = activities.get(i); |
| if (!r.finishing && r.isInStackLocked()) { |
| r.getActivityStack().finishActivityLocked(r, Activity.RESULT_CANCELED, |
| null, "finish-heavy", true); |
| } |
| } |
| } |
| |
| public boolean isInterestingToUser() { |
| synchronized (mAtm.mGlobalLock) { |
| final int size = mActivities.size(); |
| for (int i = 0; i < size; i++) { |
| ActivityRecord r = mActivities.get(i); |
| if (r.isInterestingToUserLocked()) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public boolean hasRunningActivity(String packageName) { |
| synchronized (mAtm.mGlobalLock) { |
| for (int i = mActivities.size() - 1; i >= 0; --i) { |
| final ActivityRecord r = mActivities.get(i); |
| if (packageName.equals(r.packageName)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public void clearPackagePreferredForHomeActivities() { |
| synchronized (mAtm.mGlobalLock) { |
| for (int i = mActivities.size() - 1; i >= 0; --i) { |
| final ActivityRecord r = mActivities.get(i); |
| if (r.isActivityTypeHome()) { |
| Log.i(TAG, "Clearing package preferred activities from " + r.packageName); |
| try { |
| ActivityThread.getPackageManager() |
| .clearPackagePreferredActivities(r.packageName); |
| } catch (RemoteException c) { |
| // pm is in same process, this will never happen. |
| } |
| } |
| } |
| } |
| } |
| |
| boolean hasStartedActivity(ActivityRecord launchedActivity) { |
| for (int i = mActivities.size() - 1; i >= 0; i--) { |
| final ActivityRecord activity = mActivities.get(i); |
| if (launchedActivity == activity) { |
| continue; |
| } |
| if (!activity.stopped) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| void updateIntentForHeavyWeightActivity(Intent intent) { |
| if (mActivities.isEmpty()) { |
| return; |
| } |
| ActivityRecord hist = mActivities.get(0); |
| intent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP, hist.packageName); |
| intent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK, hist.getTaskRecord().taskId); |
| } |
| |
| boolean shouldKillProcessForRemovedTask(TaskRecord tr) { |
| for (int k = 0; k < mActivities.size(); k++) { |
| final ActivityRecord activity = mActivities.get(k); |
| if (!activity.stopped) { |
| // Don't kill process(es) that has an activity not stopped. |
| return false; |
| } |
| final TaskRecord otherTask = activity.getTaskRecord(); |
| if (tr.taskId != otherTask.taskId && otherTask.inRecents) { |
| // Don't kill process(es) that has an activity in a different task that is |
| // also in recents. |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| ArraySet<TaskRecord> getReleaseSomeActivitiesTasks() { |
| // Examine all activities currently running in the process. |
| TaskRecord firstTask = null; |
| // Tasks is non-null only if two or more tasks are found. |
| ArraySet<TaskRecord> tasks = null; |
| if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Trying to release some activities in " + this); |
| for (int i = 0; i < mActivities.size(); i++) { |
| final ActivityRecord r = mActivities.get(i); |
| // First, if we find an activity that is in the process of being destroyed, |
| // then we just aren't going to do anything for now; we want things to settle |
| // down before we try to prune more activities. |
| if (r.finishing || r.isState(DESTROYING, DESTROYED)) { |
| if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Abort release; already destroying: " + r); |
| return null; |
| } |
| // Don't consider any activies that are currently not in a state where they |
| // can be destroyed. |
| if (r.visible || !r.stopped || !r.haveState |
| || r.isState(RESUMED, PAUSING, PAUSED, STOPPING)) { |
| if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Not releasing in-use activity: " + r); |
| continue; |
| } |
| |
| final TaskRecord task = r.getTaskRecord(); |
| if (task != null) { |
| if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Collecting release task " + task |
| + " from " + r); |
| if (firstTask == null) { |
| firstTask = task; |
| } else if (firstTask != task) { |
| if (tasks == null) { |
| tasks = new ArraySet<>(); |
| tasks.add(firstTask); |
| } |
| tasks.add(task); |
| } |
| } |
| } |
| |
| return tasks; |
| } |
| |
| public interface ComputeOomAdjCallback { |
| void onVisibleActivity(); |
| void onPausedActivity(); |
| void onStoppingActivity(boolean finishing); |
| void onOtherActivity(); |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public int computeOomAdjFromActivities(int minTaskLayer, ComputeOomAdjCallback callback) { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| final int activitiesSize = mActivities.size(); |
| for (int j = 0; j < activitiesSize; j++) { |
| final ActivityRecord r = mActivities.get(j); |
| if (r.app != this) { |
| Log.e(TAG, "Found activity " + r + " in proc activity list using " + r.app |
| + " instead of expected " + this); |
| if (r.app == null || (r.app.mUid == mUid)) { |
| // Only fix things up when they look sane |
| r.setProcess(this); |
| } else { |
| continue; |
| } |
| } |
| if (r.visible) { |
| callback.onVisibleActivity(); |
| final TaskRecord task = r.getTaskRecord(); |
| if (task != null && minTaskLayer > 0) { |
| final int layer = task.mLayerRank; |
| if (layer >= 0 && minTaskLayer > layer) { |
| minTaskLayer = layer; |
| } |
| } |
| break; |
| } else if (r.isState(PAUSING, PAUSED)) { |
| callback.onPausedActivity(); |
| } else if (r.isState(STOPPING)) { |
| callback.onStoppingActivity(r.finishing); |
| } else { |
| callback.onOtherActivity(); |
| } |
| } |
| } |
| |
| return minTaskLayer; |
| } |
| |
| public int computeRelaunchReason() { |
| synchronized (mAtm.mGlobalLock) { |
| final int activitiesSize = mActivities.size(); |
| for (int i = activitiesSize - 1; i >= 0; i--) { |
| final ActivityRecord r = mActivities.get(i); |
| if (r.mRelaunchReason != RELAUNCH_REASON_NONE) { |
| return r.mRelaunchReason; |
| } |
| } |
| } |
| return RELAUNCH_REASON_NONE; |
| } |
| |
| public long getInputDispatchingTimeout() { |
| synchronized (mAtm.mGlobalLock) { |
| return isInstrumenting() || isUsingWrapper() |
| ? INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT_MS : KEY_DISPATCHING_TIMEOUT_MS; |
| } |
| } |
| |
| void clearProfilerIfNeeded() { |
| if (mListener == null) return; |
| // Posting on handler so WM lock isn't held when we call into AM. |
| mAtm.mH.sendMessage(PooledLambda.obtainMessage( |
| WindowProcessListener::clearProfilerIfNeeded, mListener)); |
| } |
| |
| void updateProcessInfo(boolean updateServiceConnectionActivities, boolean activityChange, |
| boolean updateOomAdj) { |
| if (mListener == null) return; |
| // Posting on handler so WM lock isn't held when we call into AM. |
| final Message m = PooledLambda.obtainMessage(WindowProcessListener::updateProcessInfo, |
| mListener, updateServiceConnectionActivities, activityChange, updateOomAdj); |
| mAtm.mH.sendMessage(m); |
| } |
| |
| void updateServiceConnectionActivities() { |
| if (mListener == null) return; |
| // Posting on handler so WM lock isn't held when we call into AM. |
| mAtm.mH.sendMessage(PooledLambda.obtainMessage( |
| WindowProcessListener::updateServiceConnectionActivities, mListener)); |
| } |
| |
| void setPendingUiCleanAndForceProcessStateUpTo(int newState) { |
| if (mListener == null) return; |
| // Posting on handler so WM lock isn't held when we call into AM. |
| final Message m = PooledLambda.obtainMessage( |
| WindowProcessListener::setPendingUiCleanAndForceProcessStateUpTo, |
| mListener, newState); |
| mAtm.mH.sendMessage(m); |
| } |
| |
| boolean isRemoved() { |
| return mListener == null ? false : mListener.isRemoved(); |
| } |
| |
| private boolean shouldSetProfileProc() { |
| return mAtm.mProfileApp != null && mAtm.mProfileApp.equals(mName) |
| && (mAtm.mProfileProc == null || mAtm.mProfileProc == this); |
| } |
| |
| ProfilerInfo createProfilerInfoIfNeeded() { |
| final ProfilerInfo currentProfilerInfo = mAtm.mProfilerInfo; |
| if (currentProfilerInfo == null || currentProfilerInfo.profileFile == null |
| || !shouldSetProfileProc()) { |
| return null; |
| } |
| if (currentProfilerInfo.profileFd != null) { |
| try { |
| currentProfilerInfo.profileFd = currentProfilerInfo.profileFd.dup(); |
| } catch (IOException e) { |
| currentProfilerInfo.closeFd(); |
| } |
| } |
| return new ProfilerInfo(currentProfilerInfo); |
| } |
| |
| void onStartActivity(int topProcessState, ActivityInfo info) { |
| if (mListener == null) return; |
| String packageName = null; |
| if ((info.flags & ActivityInfo.FLAG_MULTIPROCESS) == 0 |
| || !"android".equals(info.packageName)) { |
| // Don't add this if it is a platform component that is marked to run in multiple |
| // processes, because this is actually part of the framework so doesn't make sense |
| // to track as a separate apk in the process. |
| packageName = info.packageName; |
| } |
| // Posting the message at the front of queue so WM lock isn't held when we call into AM, |
| // and the process state of starting activity can be updated quicker which will give it a |
| // higher scheduling group. |
| final Message m = PooledLambda.obtainMessage(WindowProcessListener::onStartActivity, |
| mListener, topProcessState, shouldSetProfileProc(), packageName, |
| info.applicationInfo.longVersionCode); |
| mAtm.mH.sendMessageAtFrontOfQueue(m); |
| } |
| |
| public void appDied() { |
| if (mListener == null) return; |
| // Posting on handler so WM lock isn't held when we call into AM. |
| final Message m = PooledLambda.obtainMessage( |
| WindowProcessListener::appDied, mListener); |
| mAtm.mH.sendMessage(m); |
| } |
| |
| void registerDisplayConfigurationListenerLocked(ActivityDisplay activityDisplay) { |
| if (activityDisplay == null) { |
| return; |
| } |
| // A process can only register to one display to listener to the override configuration |
| // change. Unregister existing listener if it has one before register the new one. |
| unregisterDisplayConfigurationListenerLocked(); |
| mDisplayId = activityDisplay.mDisplayId; |
| activityDisplay.registerConfigurationChangeListener(this); |
| } |
| |
| @VisibleForTesting |
| void unregisterDisplayConfigurationListenerLocked() { |
| if (mDisplayId == INVALID_DISPLAY) { |
| return; |
| } |
| final ActivityDisplay activityDisplay = |
| mAtm.mRootActivityContainer.getActivityDisplay(mDisplayId); |
| if (activityDisplay != null) { |
| activityDisplay.unregisterConfigurationChangeListener(this); |
| } |
| mDisplayId = INVALID_DISPLAY; |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newGlobalConfig) { |
| super.onConfigurationChanged(newGlobalConfig); |
| updateConfiguration(); |
| } |
| |
| @Override |
| public void onRequestedOverrideConfigurationChanged(Configuration newOverrideConfig) { |
| super.onRequestedOverrideConfigurationChanged(newOverrideConfig); |
| updateConfiguration(); |
| } |
| |
| private void updateConfiguration() { |
| final Configuration config = getConfiguration(); |
| if (mLastReportedConfiguration.diff(config) == 0) { |
| // Nothing changed. |
| return; |
| } |
| |
| try { |
| if (mThread == null) { |
| return; |
| } |
| if (DEBUG_CONFIGURATION) { |
| Slog.v(TAG_CONFIGURATION, "Sending to proc " + mName |
| + " new config " + config); |
| } |
| config.seq = mAtm.increaseConfigurationSeqLocked(); |
| mAtm.getLifecycleManager().scheduleTransaction(mThread, |
| ConfigurationChangeItem.obtain(config)); |
| setLastReportedConfiguration(config); |
| } catch (Exception e) { |
| Slog.e(TAG_CONFIGURATION, "Failed to schedule configuration change", e); |
| } |
| } |
| |
| private void setLastReportedConfiguration(Configuration config) { |
| mLastReportedConfiguration.setTo(config); |
| } |
| |
| Configuration getLastReportedConfiguration() { |
| return mLastReportedConfiguration; |
| } |
| |
| /** Returns the total time (in milliseconds) spent executing in both user and system code. */ |
| public long getCpuTime() { |
| return (mListener != null) ? mListener.getCpuTime() : 0; |
| } |
| |
| void addRecentTask(TaskRecord task) { |
| mRecentTasks.add(task); |
| } |
| |
| void removeRecentTask(TaskRecord task) { |
| mRecentTasks.remove(task); |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public boolean hasRecentTasks() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| return !mRecentTasks.isEmpty(); |
| } |
| } |
| |
| void clearRecentTasks() { |
| for (int i = mRecentTasks.size() - 1; i >= 0; i--) { |
| mRecentTasks.get(i).clearRootProcess(); |
| } |
| mRecentTasks.clear(); |
| } |
| |
| public void appEarlyNotResponding(String annotation, Runnable killAppCallback) { |
| synchronized (mAtm.mGlobalLock) { |
| if (mAtm.mController == null) { |
| return; |
| } |
| |
| try { |
| // 0 == continue, -1 = kill process immediately |
| int res = mAtm.mController.appEarlyNotResponding(mName, mPid, annotation); |
| if (res < 0 && mPid != MY_PID) { |
| killAppCallback.run(); |
| } |
| } catch (RemoteException e) { |
| mAtm.mController = null; |
| Watchdog.getInstance().setActivityController(null); |
| } |
| } |
| } |
| |
| public boolean appNotResponding(String info, Runnable killAppCallback, |
| Runnable serviceTimeoutCallback) { |
| Runnable targetRunnable = null; |
| synchronized (mAtm.mGlobalLock) { |
| if (mAtm.mController == null) { |
| return false; |
| } |
| |
| try { |
| // 0 == show dialog, 1 = keep waiting, -1 = kill process immediately |
| int res = mAtm.mController.appNotResponding(mName, mPid, info); |
| if (res != 0) { |
| if (res < 0 && mPid != MY_PID) { |
| targetRunnable = killAppCallback; |
| } else { |
| targetRunnable = serviceTimeoutCallback; |
| } |
| } |
| } catch (RemoteException e) { |
| mAtm.mController = null; |
| Watchdog.getInstance().setActivityController(null); |
| return false; |
| } |
| } |
| if (targetRunnable != null) { |
| targetRunnable.run(); |
| return true; |
| } |
| return false; |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public void onTopProcChanged() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| mAtm.mVrController.onTopProcChangedLocked(this); |
| } |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public boolean isHomeProcess() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| return this == mAtm.mHomeProcess; |
| } |
| } |
| |
| @HotPath(caller = HotPath.OOM_ADJUSTMENT) |
| public boolean isPreviousProcess() { |
| synchronized (mAtm.mGlobalLockWithoutBoost) { |
| return this == mAtm.mPreviousProcess; |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return mOwner != null ? mOwner.toString() : null; |
| } |
| |
| public void dump(PrintWriter pw, String prefix) { |
| synchronized (mAtm.mGlobalLock) { |
| if (mActivities.size() > 0) { |
| pw.print(prefix); pw.println("Activities:"); |
| for (int i = 0; i < mActivities.size(); i++) { |
| pw.print(prefix); pw.print(" - "); pw.println(mActivities.get(i)); |
| } |
| } |
| |
| if (mRecentTasks.size() > 0) { |
| pw.println(prefix + "Recent Tasks:"); |
| for (int i = 0; i < mRecentTasks.size(); i++) { |
| pw.println(prefix + " - " + mRecentTasks.get(i)); |
| } |
| } |
| |
| if (mVrThreadTid != 0) { |
| pw.print(prefix); pw.print("mVrThreadTid="); pw.println(mVrThreadTid); |
| } |
| } |
| pw.println(prefix + " Configuration=" + getConfiguration()); |
| pw.println(prefix + " OverrideConfiguration=" + getRequestedOverrideConfiguration()); |
| pw.println(prefix + " mLastReportedConfiguration=" + mLastReportedConfiguration); |
| } |
| |
| void writeToProto(ProtoOutputStream proto, long fieldId) { |
| if (mListener != null) { |
| mListener.writeToProto(proto, fieldId); |
| } |
| } |
| } |
