/*
|
* Copyright (C) 2014 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 com.android.server.wm.RootActivityContainer.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS;
|
|
import android.annotation.NonNull;
|
import android.graphics.Bitmap;
|
import android.graphics.BitmapFactory;
|
import android.os.Debug;
|
import android.os.Environment;
|
import android.os.FileUtils;
|
import android.os.SystemClock;
|
import android.util.ArraySet;
|
import android.util.AtomicFile;
|
import android.util.Slog;
|
import android.util.SparseArray;
|
import android.util.SparseBooleanArray;
|
import android.util.Xml;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.util.FastXmlSerializer;
|
import com.android.internal.util.XmlUtils;
|
|
import libcore.io.IoUtils;
|
|
import org.xmlpull.v1.XmlPullParser;
|
import org.xmlpull.v1.XmlPullParserException;
|
import org.xmlpull.v1.XmlSerializer;
|
|
import java.io.BufferedReader;
|
import java.io.BufferedWriter;
|
import java.io.File;
|
import java.io.FileNotFoundException;
|
import java.io.FileOutputStream;
|
import java.io.FileReader;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.io.StringWriter;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.List;
|
|
/**
|
* Persister that saves recent tasks into disk.
|
*/
|
public class TaskPersister implements PersisterQueue.Listener {
|
static final String TAG = "TaskPersister";
|
static final boolean DEBUG = false;
|
static final String IMAGE_EXTENSION = ".png";
|
|
private static final String TASKS_DIRNAME = "recent_tasks";
|
private static final String TASK_FILENAME_SUFFIX = "_task.xml";
|
private static final String IMAGES_DIRNAME = "recent_images";
|
private static final String PERSISTED_TASK_IDS_FILENAME = "persisted_taskIds.txt";
|
|
private static final String TAG_TASK = "task";
|
|
private final ActivityTaskManagerService mService;
|
private final ActivityStackSupervisor mStackSupervisor;
|
private final RecentTasks mRecentTasks;
|
private final SparseArray<SparseBooleanArray> mTaskIdsInFile = new SparseArray<>();
|
private final File mTaskIdsDir;
|
// To lock file operations in TaskPersister
|
private final Object mIoLock = new Object();
|
private final PersisterQueue mPersisterQueue;
|
|
private final ArraySet<Integer> mTmpTaskIds = new ArraySet<>();
|
|
TaskPersister(File systemDir, ActivityStackSupervisor stackSupervisor,
|
ActivityTaskManagerService service, RecentTasks recentTasks,
|
PersisterQueue persisterQueue) {
|
|
final File legacyImagesDir = new File(systemDir, IMAGES_DIRNAME);
|
if (legacyImagesDir.exists()) {
|
if (!FileUtils.deleteContents(legacyImagesDir) || !legacyImagesDir.delete()) {
|
Slog.i(TAG, "Failure deleting legacy images directory: " + legacyImagesDir);
|
}
|
}
|
|
final File legacyTasksDir = new File(systemDir, TASKS_DIRNAME);
|
if (legacyTasksDir.exists()) {
|
if (!FileUtils.deleteContents(legacyTasksDir) || !legacyTasksDir.delete()) {
|
Slog.i(TAG, "Failure deleting legacy tasks directory: " + legacyTasksDir);
|
}
|
}
|
|
mTaskIdsDir = new File(Environment.getDataDirectory(), "system_de");
|
mStackSupervisor = stackSupervisor;
|
mService = service;
|
mRecentTasks = recentTasks;
|
mPersisterQueue = persisterQueue;
|
mPersisterQueue.addListener(this);
|
}
|
|
@VisibleForTesting
|
TaskPersister(File workingDir) {
|
mTaskIdsDir = workingDir;
|
mStackSupervisor = null;
|
mService = null;
|
mRecentTasks = null;
|
mPersisterQueue = new PersisterQueue();
|
mPersisterQueue.addListener(this);
|
}
|
|
private void removeThumbnails(TaskRecord task) {
|
mPersisterQueue.removeItems(
|
item -> {
|
File file = new File(item.mFilePath);
|
return file.getName().startsWith(Integer.toString(task.taskId));
|
},
|
ImageWriteQueueItem.class);
|
}
|
|
@NonNull
|
SparseBooleanArray loadPersistedTaskIdsForUser(int userId) {
|
if (mTaskIdsInFile.get(userId) != null) {
|
return mTaskIdsInFile.get(userId).clone();
|
}
|
final SparseBooleanArray persistedTaskIds = new SparseBooleanArray();
|
synchronized (mIoLock) {
|
BufferedReader reader = null;
|
String line;
|
try {
|
reader = new BufferedReader(new FileReader(getUserPersistedTaskIdsFile(userId)));
|
while ((line = reader.readLine()) != null) {
|
for (String taskIdString : line.split("\\s+")) {
|
int id = Integer.parseInt(taskIdString);
|
persistedTaskIds.put(id, true);
|
}
|
}
|
} catch (FileNotFoundException e) {
|
// File doesn't exist. Ignore.
|
} catch (Exception e) {
|
Slog.e(TAG, "Error while reading taskIds file for user " + userId, e);
|
} finally {
|
IoUtils.closeQuietly(reader);
|
}
|
}
|
mTaskIdsInFile.put(userId, persistedTaskIds);
|
return persistedTaskIds.clone();
|
}
|
|
|
@VisibleForTesting
|
void writePersistedTaskIdsForUser(@NonNull SparseBooleanArray taskIds, int userId) {
|
if (userId < 0) {
|
return;
|
}
|
final File persistedTaskIdsFile = getUserPersistedTaskIdsFile(userId);
|
synchronized (mIoLock) {
|
BufferedWriter writer = null;
|
try {
|
writer = new BufferedWriter(new FileWriter(persistedTaskIdsFile));
|
for (int i = 0; i < taskIds.size(); i++) {
|
if (taskIds.valueAt(i)) {
|
writer.write(String.valueOf(taskIds.keyAt(i)));
|
writer.newLine();
|
}
|
}
|
} catch (Exception e) {
|
Slog.e(TAG, "Error while writing taskIds file for user " + userId, e);
|
} finally {
|
IoUtils.closeQuietly(writer);
|
}
|
}
|
}
|
|
void unloadUserDataFromMemory(int userId) {
|
mTaskIdsInFile.delete(userId);
|
}
|
|
void wakeup(TaskRecord task, boolean flush) {
|
synchronized (mPersisterQueue) {
|
if (task != null) {
|
final TaskWriteQueueItem item = mPersisterQueue.findLastItem(
|
queueItem -> task == queueItem.mTask, TaskWriteQueueItem.class);
|
if (item != null && !task.inRecents) {
|
removeThumbnails(task);
|
}
|
|
if (item == null && task.isPersistable) {
|
mPersisterQueue.addItem(new TaskWriteQueueItem(task, mService), flush);
|
}
|
} else {
|
// Dummy. Ensures removeObsoleteFiles is called when LazyTaskThreadWriter is
|
// notified.
|
mPersisterQueue.addItem(PersisterQueue.EMPTY_ITEM, flush);
|
}
|
if (DEBUG) {
|
Slog.d(TAG, "wakeup: task=" + task + " flush=" + flush + " Callers="
|
+ Debug.getCallers(4));
|
}
|
}
|
|
mPersisterQueue.yieldIfQueueTooDeep();
|
}
|
|
void flush() {
|
mPersisterQueue.flush();
|
}
|
|
void saveImage(Bitmap image, String filePath) {
|
mPersisterQueue.updateLastOrAddItem(new ImageWriteQueueItem(filePath, image),
|
/* flush */ false);
|
if (DEBUG) {
|
Slog.d(TAG, "saveImage: filePath=" + filePath + " now="
|
+ SystemClock.uptimeMillis() + " Callers=" + Debug.getCallers(4));
|
}
|
}
|
|
Bitmap getTaskDescriptionIcon(String filePath) {
|
// See if it is in the write queue
|
final Bitmap icon = getImageFromWriteQueue(filePath);
|
if (icon != null) {
|
return icon;
|
}
|
return restoreImage(filePath);
|
}
|
|
private Bitmap getImageFromWriteQueue(String filePath) {
|
final ImageWriteQueueItem item = mPersisterQueue.findLastItem(
|
queueItem -> queueItem.mFilePath.equals(filePath), ImageWriteQueueItem.class);
|
return item != null ? item.mImage : null;
|
}
|
|
private String fileToString(File file) {
|
final String newline = System.lineSeparator();
|
try {
|
BufferedReader reader = new BufferedReader(new FileReader(file));
|
StringBuffer sb = new StringBuffer((int) file.length() * 2);
|
String line;
|
while ((line = reader.readLine()) != null) {
|
sb.append(line + newline);
|
}
|
reader.close();
|
return sb.toString();
|
} catch (IOException ioe) {
|
Slog.e(TAG, "Couldn't read file " + file.getName());
|
return null;
|
}
|
}
|
|
private TaskRecord taskIdToTask(int taskId, ArrayList<TaskRecord> tasks) {
|
if (taskId < 0) {
|
return null;
|
}
|
for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
|
final TaskRecord task = tasks.get(taskNdx);
|
if (task.taskId == taskId) {
|
return task;
|
}
|
}
|
Slog.e(TAG, "Restore affiliation error looking for taskId=" + taskId);
|
return null;
|
}
|
|
List<TaskRecord> restoreTasksForUserLocked(final int userId, SparseBooleanArray preaddedTasks) {
|
final ArrayList<TaskRecord> tasks = new ArrayList<TaskRecord>();
|
ArraySet<Integer> recoveredTaskIds = new ArraySet<Integer>();
|
|
File userTasksDir = getUserTasksDir(userId);
|
|
File[] recentFiles = userTasksDir.listFiles();
|
if (recentFiles == null) {
|
Slog.e(TAG, "restoreTasksForUserLocked: Unable to list files from " + userTasksDir);
|
return tasks;
|
}
|
|
for (int taskNdx = 0; taskNdx < recentFiles.length; ++taskNdx) {
|
File taskFile = recentFiles[taskNdx];
|
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;
|
}
|
|
BufferedReader reader = null;
|
boolean deleteFile = false;
|
try {
|
reader = new BufferedReader(new FileReader(taskFile));
|
final XmlPullParser in = Xml.newPullParser();
|
in.setInput(reader);
|
|
int event;
|
while (((event = in.next()) != XmlPullParser.END_DOCUMENT) &&
|
event != XmlPullParser.END_TAG) {
|
final String name = in.getName();
|
if (event == XmlPullParser.START_TAG) {
|
if (DEBUG) Slog.d(TAG, "restoreTasksForUserLocked: START_TAG name=" + name);
|
if (TAG_TASK.equals(name)) {
|
final TaskRecord task = TaskRecord.restoreFromXml(in, mStackSupervisor);
|
if (DEBUG) Slog.d(TAG, "restoreTasksForUserLocked: restored task="
|
+ task);
|
if (task != null) {
|
// XXX Don't add to write queue... there is no reason to write
|
// out the stuff we just read, if we don't write it we will
|
// read the same thing again.
|
// mWriteQueue.add(new TaskWriteQueueItem(task));
|
|
final int taskId = task.taskId;
|
if (mService.mRootActivityContainer.anyTaskForId(taskId,
|
MATCH_TASK_IN_STACKS_OR_RECENT_TASKS) != null) {
|
// Should not happen.
|
Slog.wtf(TAG, "Existing task with taskId " + taskId + "found");
|
} else if (userId != task.userId) {
|
// Should not happen.
|
Slog.wtf(TAG, "Task with userId " + task.userId + " found in "
|
+ userTasksDir.getAbsolutePath());
|
} else {
|
// Looks fine.
|
mStackSupervisor.setNextTaskIdForUserLocked(taskId, userId);
|
task.isPersistable = true;
|
tasks.add(task);
|
recoveredTaskIds.add(taskId);
|
}
|
} else {
|
Slog.e(TAG, "restoreTasksForUserLocked: Unable to restore taskFile="
|
+ taskFile + ": " + fileToString(taskFile));
|
}
|
} else {
|
Slog.wtf(TAG, "restoreTasksForUserLocked: Unknown xml event=" + event
|
+ " name=" + name);
|
}
|
}
|
XmlUtils.skipCurrentTag(in);
|
}
|
} catch (Exception e) {
|
Slog.wtf(TAG, "Unable to parse " + taskFile + ". Error ", e);
|
Slog.e(TAG, "Failing file: " + fileToString(taskFile));
|
deleteFile = true;
|
} finally {
|
IoUtils.closeQuietly(reader);
|
if (deleteFile) {
|
if (DEBUG) Slog.d(TAG, "Deleting file=" + taskFile.getName());
|
taskFile.delete();
|
}
|
}
|
}
|
|
if (!DEBUG) {
|
removeObsoleteFiles(recoveredTaskIds, userTasksDir.listFiles());
|
}
|
|
// Fix up task affiliation from taskIds
|
for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
|
final TaskRecord task = tasks.get(taskNdx);
|
task.setPrevAffiliate(taskIdToTask(task.mPrevAffiliateTaskId, tasks));
|
task.setNextAffiliate(taskIdToTask(task.mNextAffiliateTaskId, tasks));
|
}
|
|
Collections.sort(tasks, new Comparator<TaskRecord>() {
|
@Override
|
public int compare(TaskRecord lhs, TaskRecord rhs) {
|
final long diff = rhs.mLastTimeMoved - lhs.mLastTimeMoved;
|
if (diff < 0) {
|
return -1;
|
} else if (diff > 0) {
|
return +1;
|
} else {
|
return 0;
|
}
|
}
|
});
|
return tasks;
|
}
|
|
@Override
|
public void onPreProcessItem(boolean queueEmpty) {
|
// We can't lock mService while locking the queue, but we don't want to
|
// call removeObsoleteFiles before every item, only the last time
|
// before going to sleep. The risk is that we call removeObsoleteFiles()
|
// successively.
|
if (queueEmpty) {
|
if (DEBUG) Slog.d(TAG, "Looking for obsolete files.");
|
mTmpTaskIds.clear();
|
synchronized (mService.mGlobalLock) {
|
if (DEBUG) Slog.d(TAG, "mRecents=" + mRecentTasks);
|
mRecentTasks.getPersistableTaskIds(mTmpTaskIds);
|
mService.mWindowManager.removeObsoleteTaskFiles(mTmpTaskIds,
|
mRecentTasks.usersWithRecentsLoadedLocked());
|
}
|
removeObsoleteFiles(mTmpTaskIds);
|
}
|
writeTaskIdsFiles();
|
}
|
|
private static void removeObsoleteFiles(ArraySet<Integer> persistentTaskIds, File[] files) {
|
if (DEBUG) Slog.d(TAG, "removeObsoleteFiles: persistentTaskIds=" + persistentTaskIds +
|
" files=" + files);
|
if (files == null) {
|
Slog.e(TAG, "File error accessing recents directory (directory doesn't exist?).");
|
return;
|
}
|
for (int fileNdx = 0; fileNdx < files.length; ++fileNdx) {
|
File file = files[fileNdx];
|
String filename = file.getName();
|
final int taskIdEnd = filename.indexOf('_');
|
if (taskIdEnd > 0) {
|
final int taskId;
|
try {
|
taskId = Integer.parseInt(filename.substring(0, taskIdEnd));
|
if (DEBUG) Slog.d(TAG, "removeObsoleteFiles: Found taskId=" + taskId);
|
} catch (Exception e) {
|
Slog.wtf(TAG, "removeObsoleteFiles: Can't parse file=" + file.getName());
|
file.delete();
|
continue;
|
}
|
if (!persistentTaskIds.contains(taskId)) {
|
if (DEBUG) Slog.d(TAG, "removeObsoleteFiles: deleting file=" + file.getName());
|
file.delete();
|
}
|
}
|
}
|
}
|
|
private void writeTaskIdsFiles() {
|
SparseArray<SparseBooleanArray> changedTaskIdsPerUser = new SparseArray<>();
|
synchronized (mService.mGlobalLock) {
|
for (int userId : mRecentTasks.usersWithRecentsLoadedLocked()) {
|
SparseBooleanArray taskIdsToSave = mRecentTasks.getTaskIdsForUser(userId);
|
SparseBooleanArray persistedIdsInFile = mTaskIdsInFile.get(userId);
|
if (persistedIdsInFile != null && persistedIdsInFile.equals(taskIdsToSave)) {
|
continue;
|
} else {
|
SparseBooleanArray taskIdsToSaveCopy = taskIdsToSave.clone();
|
mTaskIdsInFile.put(userId, taskIdsToSaveCopy);
|
changedTaskIdsPerUser.put(userId, taskIdsToSaveCopy);
|
}
|
}
|
}
|
for (int i = 0; i < changedTaskIdsPerUser.size(); i++) {
|
writePersistedTaskIdsForUser(changedTaskIdsPerUser.valueAt(i),
|
changedTaskIdsPerUser.keyAt(i));
|
}
|
}
|
|
private void removeObsoleteFiles(ArraySet<Integer> persistentTaskIds) {
|
int[] candidateUserIds;
|
synchronized (mService.mGlobalLock) {
|
// Remove only from directories of the users who have recents in memory synchronized
|
// with persistent storage.
|
candidateUserIds = mRecentTasks.usersWithRecentsLoadedLocked();
|
}
|
for (int userId : candidateUserIds) {
|
removeObsoleteFiles(persistentTaskIds, getUserImagesDir(userId).listFiles());
|
removeObsoleteFiles(persistentTaskIds, getUserTasksDir(userId).listFiles());
|
}
|
}
|
|
static Bitmap restoreImage(String filename) {
|
if (DEBUG) Slog.d(TAG, "restoreImage: restoring " + filename);
|
return BitmapFactory.decodeFile(filename);
|
}
|
|
private File getUserPersistedTaskIdsFile(int userId) {
|
File userTaskIdsDir = new File(mTaskIdsDir, String.valueOf(userId));
|
if (!userTaskIdsDir.exists() && !userTaskIdsDir.mkdirs()) {
|
Slog.e(TAG, "Error while creating user directory: " + userTaskIdsDir);
|
}
|
return new File(userTaskIdsDir, PERSISTED_TASK_IDS_FILENAME);
|
}
|
|
private static File getUserTasksDir(int userId) {
|
return new File(Environment.getDataSystemCeDirectory(userId), TASKS_DIRNAME);
|
}
|
|
static File getUserImagesDir(int userId) {
|
return new File(Environment.getDataSystemCeDirectory(userId), IMAGES_DIRNAME);
|
}
|
|
private static boolean createParentDirectory(String filePath) {
|
File parentDir = new File(filePath).getParentFile();
|
return parentDir.exists() || parentDir.mkdirs();
|
}
|
|
private static class TaskWriteQueueItem implements PersisterQueue.WriteQueueItem {
|
private final ActivityTaskManagerService mService;
|
private final TaskRecord mTask;
|
|
TaskWriteQueueItem(TaskRecord task, ActivityTaskManagerService service) {
|
mTask = task;
|
mService = service;
|
}
|
|
private StringWriter saveToXml(TaskRecord task) throws IOException, XmlPullParserException {
|
if (DEBUG) Slog.d(TAG, "saveToXml: task=" + task);
|
final XmlSerializer xmlSerializer = new FastXmlSerializer();
|
StringWriter stringWriter = new StringWriter();
|
xmlSerializer.setOutput(stringWriter);
|
|
if (DEBUG) {
|
xmlSerializer.setFeature(
|
"http://xmlpull.org/v1/doc/features.html#indent-output", true);
|
}
|
|
// save task
|
xmlSerializer.startDocument(null, true);
|
|
xmlSerializer.startTag(null, TAG_TASK);
|
task.saveToXml(xmlSerializer);
|
xmlSerializer.endTag(null, TAG_TASK);
|
|
xmlSerializer.endDocument();
|
xmlSerializer.flush();
|
|
return stringWriter;
|
}
|
|
@Override
|
public void process() {
|
// Write out one task.
|
StringWriter stringWriter = null;
|
TaskRecord task = mTask;
|
if (DEBUG) Slog.d(TAG, "Writing task=" + task);
|
synchronized (mService.mGlobalLock) {
|
if (task.inRecents) {
|
// Still there.
|
try {
|
if (DEBUG) Slog.d(TAG, "Saving task=" + task);
|
stringWriter = saveToXml(task);
|
} catch (IOException e) {
|
} catch (XmlPullParserException e) {
|
}
|
}
|
}
|
if (stringWriter != null) {
|
// Write out xml file while not holding mService lock.
|
FileOutputStream file = null;
|
AtomicFile atomicFile = null;
|
try {
|
File userTasksDir = getUserTasksDir(task.userId);
|
if (!userTasksDir.isDirectory() && !userTasksDir.mkdirs()) {
|
Slog.e(TAG, "Failure creating tasks directory for user " + task.userId
|
+ ": " + userTasksDir + " Dropping persistence for task " + task);
|
return;
|
}
|
atomicFile = new AtomicFile(new File(userTasksDir,
|
String.valueOf(task.taskId) + TASK_FILENAME_SUFFIX));
|
file = atomicFile.startWrite();
|
file.write(stringWriter.toString().getBytes());
|
file.write('\n');
|
atomicFile.finishWrite(file);
|
} catch (IOException e) {
|
if (file != null) {
|
atomicFile.failWrite(file);
|
}
|
Slog.e(TAG,
|
"Unable to open " + atomicFile + " for persisting. " + e);
|
}
|
}
|
}
|
|
@Override
|
public String toString() {
|
return "TaskWriteQueueItem{task=" + mTask + "}";
|
}
|
}
|
|
private static class ImageWriteQueueItem implements
|
PersisterQueue.WriteQueueItem<ImageWriteQueueItem> {
|
final String mFilePath;
|
Bitmap mImage;
|
|
ImageWriteQueueItem(String filePath, Bitmap image) {
|
mFilePath = filePath;
|
mImage = image;
|
}
|
|
@Override
|
public void process() {
|
final String filePath = mFilePath;
|
if (!createParentDirectory(filePath)) {
|
Slog.e(TAG, "Error while creating images directory for file: " + filePath);
|
return;
|
}
|
final Bitmap bitmap = mImage;
|
if (DEBUG) Slog.d(TAG, "writing bitmap: filename=" + filePath);
|
FileOutputStream imageFile = null;
|
try {
|
imageFile = new FileOutputStream(new File(filePath));
|
bitmap.compress(Bitmap.CompressFormat.PNG, 100, imageFile);
|
} catch (Exception e) {
|
Slog.e(TAG, "saveImage: unable to save " + filePath, e);
|
} finally {
|
IoUtils.closeQuietly(imageFile);
|
}
|
}
|
|
@Override
|
public boolean matches(ImageWriteQueueItem item) {
|
return mFilePath.equals(item.mFilePath);
|
}
|
|
@Override
|
public void updateFrom(ImageWriteQueueItem item) {
|
mImage = item.mImage;
|
}
|
|
@Override
|
public String toString() {
|
return "ImageWriteQueueItem{path=" + mFilePath
|
+ ", image=(" + mImage.getWidth() + "x" + mImage.getHeight() + ")}";
|
}
|
}
|
}
|
