背景
Android12项目中，我们的LowRam设备被测试组报了个bug，说打开了十几个应用，但最近应用列表中最多只能有9个应用历史，而对比机pixel上则无此限制。
最初我以为是Launcher3的问题，因为launcher3分了好几个版本，其中就有针对GO设备的，因此从launcher3上入手追查了一下。从显示最近应用历史的view上入手，到获取最近应用列表的路线查。
分析
先从launcher3的RecentTasksList代码上入手，launcher显示最近应用列表的来源在：
// packages/apps/Launcher3/quickstep/src/com/android/quickstep/RecentTasksList.java
@VisibleForTesting
TaskLoadResult loadTasksInBackground(int numTasks, int requestId, boolean loadKeysOnly) {
int currentUserId = Process.myUserHandle().getIdentifier();
List<ActivityManager.RecentTaskInfo> rawTasks =
mActivityManagerWrapper.getRecentTasks(numTasks, currentUserId);
// The raw tasks are given in most-recent to least-recent order, we need to reverse it
Collections.reverse(rawTasks);
……
}RecentTasksList调用loadTasksInBackground在后台从AMS中获取RecentTasks，所以最近应用列表实际上是AMS进行管理的，这个非常好理解，毕竟AMS是所有Activity的管理者，最近所启动的应用在AMS中必定能监控到。
getRecentTasks方法第一个参数是获取最近应用的个数，那么最初是怀疑此处numTasks的值限制了low ram设备的launcher3最多只能显示9个最近应用，因此查了一下这个参数的来源，其来源如下：
// packages/apps/Launcher3/quickstep/src/com/android/quickstep/RecentTasksList.java
public synchronized int getTasks(boolean loadKeysOnly, Consumer<ArrayList<Task>> callback) {
// Kick off task loading in the background
mLoadingTasksInBackground = true;
UI_HELPER_EXECUTOR.execute(() -> {
if (!mResultsBg.isValidForRequest(requestLoadId, loadKeysOnly)) {
mResultsBg = loadTasksInBackground(Integer.MAX_VALUE, requestLoadId, loadKeysOnly);
}
TaskLoadResult loadResult = mResultsBg;
mMainThreadExecutor.execute(() -> {
mLoadingTasksInBackground = false;
mResultsUi = loadResult;
if (callback != null) {
ArrayList<Task> result = copyOf(mResultsUi);
callback.accept(result);
}
});
});
return requestLoadId;
}同样是RecentTasksList中，getTasks方法会去调用loadTasksInBackground方法去加载RecentTasks，而传入的第一个参数是int类型数据的最大值，即不做任何限制，因此可以排除掉是launcher3自身的限制。
排除掉launcher3的嫌疑后，只能把目光投向到AMS中。针对于GO设备而言，AMS可能为了节省内存，会去对RecentTasks的个数做了限制。因此我们继续去看AMS.getRecentTasks这个方法的具体实现。
AMS.getRecentTasks最终是调用到RecentTask.getRecentTasksImpl中：
// frameworks/base/services/core/java/com/android/server/wm/RecentTasks.java
private ArrayList<ActivityManager.RecentTaskInfo> getRecentTasksImpl(int maxNum, int flags,
boolean getTasksAllowed, int userId, int callingUid) {
final boolean withExcluded = (flags & RECENT_WITH_EXCLUDED) != 0;
if (!isUserRunning(userId, FLAG_AND_UNLOCKED)) {
Slog.i(TAG, "user " + userId + " is still locked. Cannot load recents");
return new ArrayList<>();
}
loadUserRecentsLocked(userId);
final Set<Integer> includedUsers = getProfileIds(userId);
includedUsers.add(Integer.valueOf(userId));
final ArrayList<ActivityManager.RecentTaskInfo> res = new ArrayList<>();
final int size = mTasks.size();
int numVisibleTasks = 0;
for (int i = 0; i < size; i++) {
final Task task = mTasks.get(i);
if (isVisibleRecentTask(task)) {
numVisibleTasks++;
if (isInVisibleRange(task, i, numVisibleTasks, withExcluded)) {
// Fall through
} else {
// Not in visible range
continue;
}
} else {
// Not visible
continue;
}
// Skip remaining tasks once we reach the requested size
if (res.size() >= maxNum) {
continue;
}
// Only add calling user or related users recent tasks
if (!includedUsers.contains(Integer.valueOf(task.mUserId))) {
if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, not user: " + task);
continue;
}
if (task.realActivitySuspended) {
if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, activity suspended: " + task);
continue;
}
if (!getTasksAllowed) {
// If the caller doesn't have the GET_TASKS permission, then only
// allow them to see a small subset of tasks -- their own and home.
if (!task.isActivityTypeHome() && task.effectiveUid != callingUid) {
if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, not allowed: " + task);
continue;
}
}
if (task.autoRemoveRecents && task.getTopNonFinishingActivity() == null) {
// Don't include auto remove tasks that are finished or finishing.
if (DEBUG_RECENTS) {
Slog.d(TAG_RECENTS, "Skipping, auto-remove without activity: " + task);
}
continue;
}
if ((flags & RECENT_IGNORE_UNAVAILABLE) != 0 && !task.isAvailable) {
if (DEBUG_RECENTS) {
Slog.d(TAG_RECENTS, "Skipping, unavail real act: " + task);
}
continue;
}
if (!task.mUserSetupComplete) {
// Don't include task launched while user is not done setting-up.
if (DEBUG_RECENTS) {
Slog.d(TAG_RECENTS, "Skipping, user setup not complete: " + task);
}
continue;
}
res.add(createRecentTaskInfo(task, true /* stripExtras */));
}
return res;
}从getRecentTasksImpl的源码中推测，此方法并没有什么明显的限制，最多只是判断了Task的合法性，那么只能怀疑是mTasks中的个数可能真的是最多只有9个，因此，在此处加了个打印，在调用进来是将mTasks的元素个数值打印出来，发现确实到9后，再打开新的应用，此时该值仍是9。因此继续追查mTasks会在哪有remove的操作，将超出限制的元素清除掉。在源码中搜索mTasks.remove，排查所有调用的地方。
下面就是可疑之处，然后加上打印，发现确实每次打印新的应用，增加新的RecentTask时，就会被触发，trimInactiveRecentTasks方法中有两处mTasks.remove调用：
// frameworks/base/services/core/java/com/android/server/wm/RecentTasks.java
private void trimInactiveRecentTasks() {
if (mFreezeTaskListReordering) {
// Defer trimming inactive recent tasks until we are unfrozen
return;
}
int recentsCount = mTasks.size();
// Remove from the end of the list until we reach the max number of recents
while (recentsCount > mGlobalMaxNumTasks) {
final Task task = mTasks.remove(recentsCount - 1);
notifyTaskRemoved(task, true /* wasTrimmed */, false /* killProcess */);
recentsCount--;
if (DEBUG_RECENTS_TRIM_TASKS) {
Slog.d(TAG, "Trimming over max-recents task=" + task
+ " max=" + mGlobalMaxNumTasks);
}
}
// Remove any tasks that belong to currently quiet profiles
final int[] profileUserIds = getCurrentProfileIds();
mTmpQuietProfileUserIds.clear();
for (int userId : profileUserIds) {
final UserInfo userInfo = getUserInfo(userId);
if (userInfo != null && userInfo.isManagedProfile() && userInfo.isQuietModeEnabled()) {
mTmpQuietProfileUserIds.put(userId, true);
}
if (DEBUG_RECENTS_TRIM_TASKS) {
Slog.d(TAG, "User: " + userInfo
+ " quiet=" + mTmpQuietProfileUserIds.get(userId));
}
}
// Remove any inactive tasks, calculate the latest set of visible tasks.
int numVisibleTasks = 0;
for (int i = 0; i < mTasks.size(); ) {
final Task task = mTasks.get(i);
if (isActiveRecentTask(task, mTmpQuietProfileUserIds)) {
if (!mHasVisibleRecentTasks) {
// Keep all active tasks if visible recent tasks is not supported
i++;
continue;
}
if (!isVisibleRecentTask(task)) {
// Keep all active-but-invisible tasks
i++;
continue;
} else {
numVisibleTasks++;
if (isInVisibleRange(task, i, numVisibleTasks, false /* skipExcludedCheck */)
|| !isTrimmable(task)) {
// Keep visible tasks in range
i++;
continue;
} else {
// Fall through to trim visible tasks that are no longer in range and
// trimmable
if (DEBUG_RECENTS_TRIM_TASKS) {
Slog.d(TAG,
"Trimming out-of-range visible task=" + task);
}
}
}
} else {
// Fall through to trim inactive tasks
if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "Trimming inactive task=" + task);
}
// Task is no longer active, trim it from the list
mTasks.remove(task);
notifyTaskRemoved(task, true /* wasTrimmed */, false /* killProcess */);
notifyTaskPersisterLocked(task, false /* flush */);
}
}其中一处是由mGlobalMaxNumTasks这个值来控制，当mTasks元素个数超过这个值时，则会remove掉超出的Task。经过打印，mGlobalMaxNumTasks这个值并不是9，这个值得来源如下：
mGlobalMaxNumTasks = ActivityTaskManager.getMaxRecentTasksStatic();
// frameworks/base/core/java/android/app/ActivityTaskManager.java
public static int getMaxRecentTasksStatic() {
if (sMaxRecentTasks < 0) {
return sMaxRecentTasks = ActivityManager.isLowRamDeviceStatic() ? 36 : 48;
}
return sMaxRecentTasks;
}对于LowRam设备而言，此值为36，也就是说，GO设置最多只能有36条RecentTask记录，而非GO最多只能有48个。
但这个值仍不是这个问题的限制值，在加上打印是，可以得知trimInactiveRecentTasks方法remove超出的Task是方法的结束地方，回到trimInactiveRecentTasks方法，可以看到，这个方法会遍历mTasks的所有元素，然后将不符合要求的Task remove掉，而这些条件中，有一个方法是最符合我们的想法的 -- isInVisibleRange：
// frameworks/base/services/core/java/com/android/server/wm/RecentTasks.java
private boolean isInVisibleRange(Task task, int taskIndex, int numVisibleTasks,
boolean skipExcludedCheck) {
if (!skipExcludedCheck) {
// Keep the most recent task even if it is excluded from recents
final boolean isExcludeFromRecents =
(task.getBaseIntent().getFlags() & FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
== FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
if (isExcludeFromRecents) {
if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "\texcludeFromRecents=true");
return taskIndex == 0;
}
}
if (mMinNumVisibleTasks >= 0 && numVisibleTasks <= mMinNumVisibleTasks) {
// Always keep up to the min number of recent tasks, after that fall through to the
// checks below
return true;
}
// The given task if always treated as in visible range if it is the origin of pinned task.
if (task.mChildPipActivity != null) return true;
if (mMaxNumVisibleTasks >= 0) {
// Always keep up to the max number of recent tasks, but return false afterwards
return numVisibleTasks <= mMaxNumVisibleTasks;
}
if (mActiveTasksSessionDurationMs > 0) {
// Keep the task if the inactive time is within the session window, this check must come
// after the checks for the min/max visible task range
if (task.getInactiveDuration() <= mActiveTasksSessionDurationMs) {
return true;
}
}
return false;
}
上面的isInVisibleRange方法中，可以看到一个很显眼的变量 -- mMaxNumVisibleTasks，当mMaxNumVisibleTasks这个值大于等于0时，则表明生效，如果可见的RecentTasks个数小于mMaxNumVisibleTasks的值，则跳过mMaxNumVisibleTasks中的remove操作，但如果超出了，则会执行remove操作。
再看mMaxNumVisibleTasks这个值的来源：
1.RecentTasks.setParameters，通过源码的搜索及注解，可以认为此接口只为测试所用。
2.RecentTasks.loadParametersFromResources，这个是根据不同的方案类型读取了不同的值：
// frameworks/base/services/core/java/com/android/server/wm/RecentTasks.java
void loadParametersFromResources(Resources res) {
if (ActivityManager.isLowRamDeviceStatic()) {
mMinNumVisibleTasks = res.getInteger(
com.android.internal.R.integer.config_minNumVisibleRecentTasks_lowRam);
mMaxNumVisibleTasks = res.getInteger(
com.android.internal.R.integer.config_maxNumVisibleRecentTasks_lowRam);
} else if (SystemProperties.getBoolean("ro.recents.grid", false)) {
mMinNumVisibleTasks = res.getInteger(
com.android.internal.R.integer.config_minNumVisibleRecentTasks_grid);
mMaxNumVisibleTasks = res.getInteger(
com.android.internal.R.integer.config_maxNumVisibleRecentTasks_grid);
} else {
mMinNumVisibleTasks = res.getInteger(
com.android.internal.R.integer.config_minNumVisibleRecentTasks);
mMaxNumVisibleTasks = res.getInteger(
com.android.internal.R.integer.config_maxNumVisibleRecentTasks);
}
final int sessionDurationHrs = res.getInteger(
com.android.internal.R.integer.config_activeTaskDurationHours);
mActiveTasksSessionDurationMs = (sessionDurationHrs > 0)
? TimeUnit.HOURS.toMillis(sessionDurationHrs)
: -1;
}
可以看到LowRam设备的值来源于config_maxNumVisibleRecentTasks_lowRam这个配置。原生配置中，此值就是9：
./core/res/res/values/config.xml:2915: <integer name="config_maxNumVisibleRecentTasks_lowRam">9</integer>问题澄清。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
