Merge "Do not hold wm lock when loading recent task files" into main
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
index 24c8ebb..514a3d8 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -2505,6 +2505,11 @@
userId = handleIncomingUser(Binder.getCallingPid(), callingUid, userId, "getRecentTasks");
final boolean allowed = isGetTasksAllowed("getRecentTasks", Binder.getCallingPid(),
callingUid);
+ if (!mAmInternal.isUserRunning(userId, ActivityManager.FLAG_AND_UNLOCKED)) {
+ Slog.i(TAG, "User " + userId + " is locked. Cannot load recents");
+ return ParceledListSlice.emptyList();
+ }
+ mRecentTasks.loadRecentTasksIfNeeded(userId);
synchronized (mGlobalLock) {
return mRecentTasks.getRecentTasks(maxNum, flags, allowed, userId, callingUid);
}
@@ -7056,11 +7061,9 @@
@Override
public void loadRecentTasksForUser(int userId) {
- synchronized (mGlobalLock) {
- mRecentTasks.loadUserRecentsLocked(userId);
- // TODO renaming the methods(?)
- mPackageConfigPersister.loadUserPackages(userId);
- }
+ // This runs on android.fg thread when the user is unlocking.
+ mRecentTasks.loadRecentTasksIfNeeded(userId);
+ mPackageConfigPersister.loadUserPackages(userId);
}
@Override
diff --git a/services/core/java/com/android/server/wm/RecentTasks.java b/services/core/java/com/android/server/wm/RecentTasks.java
index e027eb6..dd14642 100644
--- a/services/core/java/com/android/server/wm/RecentTasks.java
+++ b/services/core/java/com/android/server/wm/RecentTasks.java
@@ -16,7 +16,6 @@
package com.android.server.wm;
-import static android.app.ActivityManager.FLAG_AND_UNLOCKED;
import static android.app.ActivityManager.RECENT_IGNORE_UNAVAILABLE;
import static android.app.ActivityManager.RECENT_WITH_EXCLUDED;
import static android.app.ActivityTaskManager.INVALID_TASK_ID;
@@ -69,6 +68,7 @@
import android.os.UserHandle;
import android.text.TextUtils;
import android.util.ArraySet;
+import android.util.IntArray;
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseBooleanArray;
@@ -89,9 +89,9 @@
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
-import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
/**
* Class for managing the recent tasks list. The list is ordered by most recent (index 0) to the
@@ -167,8 +167,9 @@
/**
* Mapping of user id -> whether recent tasks have been loaded for that user.
+ * The AtomicBoolean per user will be locked when reading persisted task from storage.
*/
- private final SparseBooleanArray mUsersWithRecentsLoaded = new SparseBooleanArray(
+ private final SparseArray<AtomicBoolean> mUsersWithRecentsLoaded = new SparseArray<>(
DEFAULT_INITIAL_CAPACITY);
/**
@@ -481,29 +482,49 @@
/**
* Loads the persistent recentTasks for {@code userId} into this list from persistent storage.
- * Does nothing if they are already loaded.
- *
- * @param userId the user Id
+ * Does nothing if they are already loaded. This may perform IO operation, so the caller should
+ * not hold a lock.
*/
- void loadUserRecentsLocked(int userId) {
- if (mUsersWithRecentsLoaded.get(userId)) {
- // User already loaded, return early
- return;
- }
-
- // Load the task ids if not loaded.
- loadPersistedTaskIdsForUserLocked(userId);
-
- // Check if any tasks are added before recents is loaded
- final SparseBooleanArray preaddedTasks = new SparseBooleanArray();
- for (final Task task : mTasks) {
- if (task.mUserId == userId && shouldPersistTaskLocked(task)) {
- preaddedTasks.put(task.mTaskId, true);
+ void loadRecentTasksIfNeeded(int userId) {
+ AtomicBoolean userLoaded;
+ synchronized (mService.mGlobalLock) {
+ userLoaded = mUsersWithRecentsLoaded.get(userId);
+ if (userLoaded == null) {
+ mUsersWithRecentsLoaded.append(userId, userLoaded = new AtomicBoolean());
}
}
+ synchronized (userLoaded) {
+ if (userLoaded.get()) {
+ // The recent tasks of the user are already loaded.
+ return;
+ }
+ // Read task files from storage.
+ final SparseBooleanArray persistedTaskIds =
+ mTaskPersister.readPersistedTaskIdsFromFileForUser(userId);
+ final TaskPersister.RecentTaskFiles taskFiles = TaskPersister.loadTasksForUser(userId);
+ synchronized (mService.mGlobalLock) {
+ restoreRecentTasksLocked(userId, persistedTaskIds, taskFiles);
+ }
+ userLoaded.set(true);
+ }
+ }
- Slog.i(TAG, "Loading recents for user " + userId + " into memory.");
- List<Task> tasks = mTaskPersister.restoreTasksForUserLocked(userId, preaddedTasks);
+ /** Restores recent tasks from raw data (the files are already read into memory). */
+ private void restoreRecentTasksLocked(int userId, SparseBooleanArray persistedTaskIds,
+ TaskPersister.RecentTaskFiles taskFiles) {
+ mTaskPersister.setPersistedTaskIds(userId, persistedTaskIds);
+ mPersistedTaskIds.put(userId, persistedTaskIds.clone());
+ // Check if any tasks are added before recents is loaded.
+ final IntArray existedTaskIds = new IntArray();
+ for (int i = mTasks.size() - 1; i >= 0; i--) {
+ final Task task = mTasks.get(i);
+ if (task.mUserId == userId && shouldPersistTaskLocked(task)) {
+ existedTaskIds.add(task.mTaskId);
+ }
+ }
+ Slog.i(TAG, "Restoring recents for user " + userId);
+ final ArrayList<Task> tasks = mTaskPersister.restoreTasksForUserLocked(userId, taskFiles,
+ existedTaskIds);
// Tasks are ordered from most recent to least recent. Update the last active time to be
// in sync with task recency when device reboots, so the most recent task has the
@@ -516,37 +537,34 @@
mTasks.addAll(tasks);
cleanupLocked(userId);
- mUsersWithRecentsLoaded.put(userId, true);
// If we have tasks added before loading recents, we need to update persistent task IDs.
- if (preaddedTasks.size() > 0) {
+ if (existedTaskIds.size() > 0) {
syncPersistentTaskIdsLocked();
}
}
- private void loadPersistedTaskIdsForUserLocked(int userId) {
- // An empty instead of a null set here means that no persistent taskIds were present
- // on file when we loaded them.
- if (mPersistedTaskIds.get(userId) == null) {
- mPersistedTaskIds.put(userId, mTaskPersister.loadPersistedTaskIdsForUser(userId));
- Slog.i(TAG, "Loaded persisted task ids for user " + userId);
- }
+ private boolean isRecentTasksLoaded(int userId) {
+ final AtomicBoolean userLoaded = mUsersWithRecentsLoaded.get(userId);
+ return userLoaded != null && userLoaded.get();
}
/**
* @return whether the {@param taskId} is currently in use for the given user.
*/
boolean containsTaskId(int taskId, int userId) {
- loadPersistedTaskIdsForUserLocked(userId);
- return mPersistedTaskIds.get(userId).get(taskId);
+ final SparseBooleanArray taskIds = mPersistedTaskIds.get(userId);
+ return taskIds != null && taskIds.get(taskId);
}
- /**
- * @return all the task ids for the user with the given {@param userId}.
- */
- SparseBooleanArray getTaskIdsForUser(int userId) {
- loadPersistedTaskIdsForUserLocked(userId);
- return mPersistedTaskIds.get(userId);
+ /** Returns all the task ids for the user from {@link #usersWithRecentsLoadedLocked}. */
+ SparseBooleanArray getTaskIdsForLoadedUser(int loadedUserId) {
+ final SparseBooleanArray taskIds = mPersistedTaskIds.get(loadedUserId);
+ if (taskIds == null) {
+ Slog.wtf(TAG, "Loaded user without loaded tasks, userId=" + loadedUserId);
+ return new SparseBooleanArray();
+ }
+ return taskIds;
}
/**
@@ -565,7 +583,7 @@
private void syncPersistentTaskIdsLocked() {
for (int i = mPersistedTaskIds.size() - 1; i >= 0; i--) {
int userId = mPersistedTaskIds.keyAt(i);
- if (mUsersWithRecentsLoaded.get(userId)) {
+ if (isRecentTasksLoaded(userId)) {
// Recents are loaded only after task ids are loaded. Therefore, the set of taskids
// referenced here should not be null.
mPersistedTaskIds.valueAt(i).clear();
@@ -621,7 +639,7 @@
int len = 0;
for (int i = 0; i < usersWithRecentsLoaded.length; i++) {
int userId = mUsersWithRecentsLoaded.keyAt(i);
- if (mUsersWithRecentsLoaded.valueAt(i)) {
+ if (mUsersWithRecentsLoaded.valueAt(i).get()) {
usersWithRecentsLoaded[len++] = userId;
}
}
@@ -639,7 +657,7 @@
* @param userId the id of the user
*/
void unloadUserDataFromMemoryLocked(int userId) {
- if (mUsersWithRecentsLoaded.get(userId)) {
+ if (isRecentTasksLoaded(userId)) {
Slog.i(TAG, "Unloading recents for user " + userId + " from memory.");
mUsersWithRecentsLoaded.delete(userId);
removeTasksForUserLocked(userId);
@@ -922,11 +940,6 @@
return mService.mAmInternal.getCurrentProfileIds();
}
- @VisibleForTesting
- boolean isUserRunning(int userId, int flags) {
- return mService.mAmInternal.isUserRunning(userId, flags);
- }
-
/**
* @return the list of recent tasks for presentation.
*/
@@ -942,13 +955,6 @@
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));
diff --git a/services/core/java/com/android/server/wm/TaskPersister.java b/services/core/java/com/android/server/wm/TaskPersister.java
index 5ec0119..d89dc0b 100644
--- a/services/core/java/com/android/server/wm/TaskPersister.java
+++ b/services/core/java/com/android/server/wm/TaskPersister.java
@@ -27,6 +27,7 @@
import android.os.SystemClock;
import android.util.ArraySet;
import android.util.AtomicFile;
+import android.util.IntArray;
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseBooleanArray;
@@ -43,20 +44,20 @@
import java.io.BufferedReader;
import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
-import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
+import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
-import java.util.List;
/**
* Persister that saves recent tasks into disk.
@@ -129,11 +130,9 @@
ImageWriteQueueItem.class);
}
+ /** Reads task ids from file. This should not be called in lock. */
@NonNull
- SparseBooleanArray loadPersistedTaskIdsForUser(int userId) {
- if (mTaskIdsInFile.get(userId) != null) {
- return mTaskIdsInFile.get(userId).clone();
- }
+ SparseBooleanArray readPersistedTaskIdsFromFileForUser(int userId) {
final SparseBooleanArray persistedTaskIds = new SparseBooleanArray();
synchronized (mIoLock) {
BufferedReader reader = null;
@@ -154,11 +153,10 @@
IoUtils.closeQuietly(reader);
}
}
- mTaskIdsInFile.put(userId, persistedTaskIds);
- return persistedTaskIds.clone();
+ Slog.i(TAG, "Loaded persisted task ids for user " + userId);
+ return persistedTaskIds;
}
-
@VisibleForTesting
void writePersistedTaskIdsForUser(@NonNull SparseBooleanArray taskIds, int userId) {
if (userId < 0) {
@@ -183,6 +181,10 @@
}
}
+ void setPersistedTaskIds(int userId, @NonNull SparseBooleanArray taskIds) {
+ mTaskIdsInFile.put(userId, taskIds);
+ }
+
void unloadUserDataFromMemory(int userId) {
mTaskIdsInFile.delete(userId);
}
@@ -241,7 +243,7 @@
return item != null ? item.mImage : null;
}
- private String fileToString(File file) {
+ private static String fileToString(File file) {
final String newline = System.lineSeparator();
try {
BufferedReader reader = new BufferedReader(new FileReader(file));
@@ -272,44 +274,64 @@
return null;
}
- List<Task> restoreTasksForUserLocked(final int userId, SparseBooleanArray preaddedTasks) {
- final ArrayList<Task> tasks = new ArrayList<Task>();
- ArraySet<Integer> recoveredTaskIds = new ArraySet<Integer>();
-
- File userTasksDir = getUserTasksDir(userId);
-
- File[] recentFiles = userTasksDir.listFiles();
+ /** Loads task files from disk. This should not be called in lock. */
+ static RecentTaskFiles loadTasksForUser(int userId) {
+ final ArrayList<RecentTaskFile> taskFiles = new ArrayList<>();
+ final File userTasksDir = getUserTasksDir(userId);
+ final File[] recentFiles = userTasksDir.listFiles();
if (recentFiles == null) {
- Slog.e(TAG, "restoreTasksForUserLocked: Unable to list files from " + userTasksDir);
+ Slog.i(TAG, "loadTasksForUser: Unable to list files from " + userTasksDir
+ + " exists=" + userTasksDir.exists());
+ return new RecentTaskFiles(new File[0], taskFiles);
+ }
+ for (File taskFile : recentFiles) {
+ if (!taskFile.getName().endsWith(TASK_FILENAME_SUFFIX)) {
+ continue;
+ }
+ final int taskId;
+ try {
+ taskId = Integer.parseInt(taskFile.getName().substring(
+ 0 /* beginIndex */,
+ taskFile.getName().length() - TASK_FILENAME_SUFFIX.length()));
+ } catch (NumberFormatException e) {
+ Slog.w(TAG, "Unexpected task file name", e);
+ continue;
+ }
+ try {
+ taskFiles.add(new RecentTaskFile(taskId, taskFile));
+ } catch (IOException e) {
+ Slog.w(TAG, "Failed to read file: " + fileToString(taskFile), e);
+ taskFile.delete();
+ }
+ }
+ return new RecentTaskFiles(recentFiles, taskFiles);
+ }
+
+ /** Restores tasks from raw bytes (no read storage operation). */
+ ArrayList<Task> restoreTasksForUserLocked(int userId, RecentTaskFiles recentTaskFiles,
+ IntArray existedTaskIds) {
+ final ArrayList<Task> tasks = new ArrayList<>();
+ final ArrayList<RecentTaskFile> taskFiles = recentTaskFiles.mLoadedFiles;
+ if (taskFiles.isEmpty()) {
return tasks;
}
- for (int taskNdx = 0; taskNdx < recentFiles.length; ++taskNdx) {
- File taskFile = recentFiles[taskNdx];
+ final ArraySet<Integer> recoveredTaskIds = new ArraySet<>();
+ for (int taskNdx = 0; taskNdx < taskFiles.size(); ++taskNdx) {
+ final RecentTaskFile recentTask = taskFiles.get(taskNdx);
+ if (existedTaskIds.contains(recentTask.mTaskId)) {
+ Slog.w(TAG, "Task #" + recentTask.mTaskId
+ + " has already been created, so skip restoring");
+ continue;
+ }
+ final File taskFile = recentTask.mFile;
if (DEBUG) {
Slog.d(TAG, "restoreTasksForUserLocked: userId=" + userId
+ ", taskFile=" + taskFile.getName());
}
- if (!taskFile.getName().endsWith(TASK_FILENAME_SUFFIX)) {
- continue;
- }
- try {
- final int taskId = Integer.parseInt(taskFile.getName().substring(
- 0 /* beginIndex */,
- taskFile.getName().length() - TASK_FILENAME_SUFFIX.length()));
- if (preaddedTasks.get(taskId, false)) {
- Slog.w(TAG, "Task #" + taskId +
- " has already been created so we don't restore again");
- continue;
- }
- } catch (NumberFormatException e) {
- Slog.w(TAG, "Unexpected task file name", e);
- continue;
- }
-
boolean deleteFile = false;
- try (InputStream is = new FileInputStream(taskFile)) {
+ try (InputStream is = recentTask.mXmlContent) {
final TypedXmlPullParser in = Xml.resolvePullParser(is);
int event;
@@ -345,7 +367,7 @@
} else if (userId != task.mUserId) {
// Should not happen.
Slog.wtf(TAG, "Task with userId " + task.mUserId + " found in "
- + userTasksDir.getAbsolutePath());
+ + taskFile.getAbsolutePath());
} else {
// Looks fine.
mTaskSupervisor.setNextTaskIdForUser(taskId, userId);
@@ -377,7 +399,7 @@
}
if (!DEBUG) {
- removeObsoleteFiles(recoveredTaskIds, userTasksDir.listFiles());
+ removeObsoleteFiles(recoveredTaskIds, recentTaskFiles.mUserTaskFiles);
}
// Fix up task affiliation from taskIds
@@ -456,7 +478,7 @@
SparseArray<SparseBooleanArray> changedTaskIdsPerUser = new SparseArray<>();
synchronized (mService.mGlobalLock) {
for (int userId : mRecentTasks.usersWithRecentsLoadedLocked()) {
- SparseBooleanArray taskIdsToSave = mRecentTasks.getTaskIdsForUser(userId);
+ SparseBooleanArray taskIdsToSave = mRecentTasks.getTaskIdsForLoadedUser(userId);
SparseBooleanArray persistedIdsInFile = mTaskIdsInFile.get(userId);
if (persistedIdsInFile != null && persistedIdsInFile.equals(taskIdsToSave)) {
continue;
@@ -512,6 +534,30 @@
return parentDir.isDirectory() || parentDir.mkdir();
}
+ private static class RecentTaskFile {
+ final int mTaskId;
+ final File mFile;
+ final ByteArrayInputStream mXmlContent;
+
+ RecentTaskFile(int taskId, File file) throws IOException {
+ mTaskId = taskId;
+ mFile = file;
+ mXmlContent = new ByteArrayInputStream(Files.readAllBytes(file.toPath()));
+ }
+ }
+
+ static class RecentTaskFiles {
+ /** All files under the user task directory. */
+ final File[] mUserTaskFiles;
+ /** The successfully loaded files. */
+ final ArrayList<RecentTaskFile> mLoadedFiles;
+
+ RecentTaskFiles(File[] userFiles, ArrayList<RecentTaskFile> loadedFiles) {
+ mUserTaskFiles = userFiles;
+ mLoadedFiles = loadedFiles;
+ }
+ }
+
private static class TaskWriteQueueItem implements PersisterQueue.WriteQueueItem {
private final ActivityTaskManagerService mService;
private final Task mTask;
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
index 9930c88..f7c253d 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
@@ -46,7 +46,6 @@
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.mock;
@@ -73,6 +72,7 @@
import android.os.UserManager;
import android.platform.test.annotations.Presubmit;
import android.util.ArraySet;
+import android.util.IntArray;
import android.util.SparseBooleanArray;
import android.view.Surface;
import android.window.TaskSnapshot;
@@ -527,20 +527,20 @@
mTaskPersister.mUserTaskIdsOverride.put(1, true);
mTaskPersister.mUserTaskIdsOverride.put(2, true);
mTaskPersister.mUserTasksOverride = new ArrayList<>();
- mTaskPersister.mUserTasksOverride.add(createTaskBuilder(".UserTask1").build());
- mTaskPersister.mUserTasksOverride.add(createTaskBuilder(".UserTask2").build());
+ mTaskPersister.mUserTasksOverride.add(mTasks.get(0));
+ mTaskPersister.mUserTasksOverride.add(mTasks.get(1));
// Assert no user tasks are initially loaded
assertThat(mRecentTasks.usersWithRecentsLoadedLocked()).hasLength(0);
// Load user 0 tasks
- mRecentTasks.loadUserRecentsLocked(TEST_USER_0_ID);
+ mRecentTasks.loadRecentTasksIfNeeded(TEST_USER_0_ID);
assertThat(mRecentTasks.usersWithRecentsLoadedLocked()).asList().contains(TEST_USER_0_ID);
assertTrue(mRecentTasks.containsTaskId(1, TEST_USER_0_ID));
assertTrue(mRecentTasks.containsTaskId(2, TEST_USER_0_ID));
// Load user 1 tasks
- mRecentTasks.loadUserRecentsLocked(TEST_USER_1_ID);
+ mRecentTasks.loadRecentTasksIfNeeded(TEST_USER_1_ID);
assertThat(mRecentTasks.usersWithRecentsLoadedLocked()).asList().contains(TEST_USER_0_ID);
assertThat(mRecentTasks.usersWithRecentsLoadedLocked()).asList().contains(TEST_USER_1_ID);
assertTrue(mRecentTasks.containsTaskId(1, TEST_USER_0_ID));
@@ -575,15 +575,15 @@
mTaskPersister.mUserTaskIdsOverride.put(2, true);
mTaskPersister.mUserTaskIdsOverride.put(3, true);
mTaskPersister.mUserTasksOverride = new ArrayList<>();
- mTaskPersister.mUserTasksOverride.add(createTaskBuilder(".UserTask1").build());
- mTaskPersister.mUserTasksOverride.add(createTaskBuilder(".UserTask2").build());
- mTaskPersister.mUserTasksOverride.add(createTaskBuilder(".UserTask3").build());
+ mTaskPersister.mUserTasksOverride.add(mTasks.get(0));
+ mTaskPersister.mUserTasksOverride.add(mTasks.get(1));
+ mTaskPersister.mUserTasksOverride.add(mTasks.get(2));
// Assert no user tasks are initially loaded
assertThat(mRecentTasks.usersWithRecentsLoadedLocked()).hasLength(0);
// Load tasks
- mRecentTasks.loadUserRecentsLocked(TEST_USER_0_ID);
+ mRecentTasks.loadRecentTasksIfNeeded(TEST_USER_0_ID);
assertThat(mRecentTasks.usersWithRecentsLoadedLocked()).asList().contains(TEST_USER_0_ID);
// Sort the time descendingly so the order should be in-sync with task recency (most
@@ -1419,8 +1419,6 @@
}
private List<RecentTaskInfo> getRecentTasks(int flags) {
- doNothing().when(mRecentTasks).loadUserRecentsLocked(anyInt());
- doReturn(true).when(mRecentTasks).isUserRunning(anyInt(), anyInt());
return mRecentTasks.getRecentTasks(MAX_VALUE, flags, true /* getTasksAllowed */,
TEST_USER_0_ID, 0 /* callingUid */).getList();
}
@@ -1590,19 +1588,20 @@
}
@Override
- SparseBooleanArray loadPersistedTaskIdsForUser(int userId) {
+ SparseBooleanArray readPersistedTaskIdsFromFileForUser(int userId) {
if (mUserTaskIdsOverride != null) {
return mUserTaskIdsOverride;
}
- return super.loadPersistedTaskIdsForUser(userId);
+ return super.readPersistedTaskIdsFromFileForUser(userId);
}
@Override
- List<Task> restoreTasksForUserLocked(int userId, SparseBooleanArray preaddedTasks) {
+ ArrayList<Task> restoreTasksForUserLocked(int userId, RecentTaskFiles recentTaskFiles,
+ IntArray existedTaskIds) {
if (mUserTasksOverride != null) {
return mUserTasksOverride;
}
- return super.restoreTasksForUserLocked(userId, preaddedTasks);
+ return super.restoreTasksForUserLocked(userId, recentTaskFiles, existedTaskIds);
}
}
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskPersisterTest.java b/services/tests/wmtests/src/com/android/server/wm/TaskPersisterTest.java
index 12ed3c2..319be89 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskPersisterTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskPersisterTest.java
@@ -29,8 +29,6 @@
import android.platform.test.annotations.Presubmit;
import android.util.SparseBooleanArray;
-import androidx.test.filters.FlakyTest;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -81,7 +79,7 @@
}
mTaskPersister.writePersistedTaskIdsForUser(taskIdsOnFile, mTestUserId);
SparseBooleanArray newTaskIdsOnFile = mTaskPersister
- .loadPersistedTaskIdsForUser(mTestUserId);
+ .readPersistedTaskIdsFromFileForUser(mTestUserId);
assertEquals("TaskIds written differ from TaskIds read back from file",
taskIdsOnFile, newTaskIdsOnFile);
}