TaskPersister.java revision 852975d5377bfe5f4abc9d2a28e301aa2fa99994
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server.am; 18 19import android.graphics.Bitmap; 20import android.graphics.BitmapFactory; 21import android.os.Debug; 22import android.os.SystemClock; 23import android.util.ArraySet; 24import android.util.AtomicFile; 25import android.util.Slog; 26import android.util.Xml; 27import com.android.internal.util.FastXmlSerializer; 28import com.android.internal.util.XmlUtils; 29import org.xmlpull.v1.XmlPullParser; 30import org.xmlpull.v1.XmlPullParserException; 31import org.xmlpull.v1.XmlSerializer; 32 33import java.io.BufferedReader; 34import java.io.File; 35import java.io.FileOutputStream; 36import java.io.FileReader; 37import java.io.IOException; 38import java.io.StringWriter; 39import java.util.ArrayList; 40import java.util.Arrays; 41import java.util.Comparator; 42 43public class TaskPersister { 44 static final String TAG = "TaskPersister"; 45 static final boolean DEBUG = false; 46 47 /** When not flushing don't write out files faster than this */ 48 private static final long INTER_WRITE_DELAY_MS = 500; 49 50 /** When not flushing delay this long before writing the first file out. This gives the next 51 * task being launched a chance to load its resources without this occupying IO bandwidth. */ 52 private static final long PRE_TASK_DELAY_MS = 3000; 53 54 private static final String RECENTS_FILENAME = "_task"; 55 private static final String TASKS_DIRNAME = "recent_tasks"; 56 private static final String TASK_EXTENSION = ".xml"; 57 private static final String IMAGES_DIRNAME = "recent_images"; 58 static final String IMAGE_EXTENSION = ".png"; 59 60 private static final String TAG_TASK = "task"; 61 62 static File sImagesDir; 63 static File sTasksDir; 64 65 private final ActivityManagerService mService; 66 private final ActivityStackSupervisor mStackSupervisor; 67 68 /** Value determines write delay mode as follows: 69 * < 0 We are Flushing. No delays between writes until the image queue is drained and all 70 * tasks needing persisting are written to disk. There is no delay between writes. 71 * == 0 We are Idle. Next writes will be delayed by #PRE_TASK_DELAY_MS. 72 * > 0 We are Actively writing. Next write will be at this time. Subsequent writes will be 73 * delayed by #INTER_WRITE_DELAY_MS. */ 74 private long mNextWriteTime = 0; 75 76 private final LazyTaskWriterThread mLazyTaskWriterThread; 77 78 private static class WriteQueueItem {} 79 private static class TaskWriteQueueItem extends WriteQueueItem { 80 final TaskRecord mTask; 81 TaskWriteQueueItem(TaskRecord task) { 82 mTask = task; 83 } 84 } 85 private static class ImageWriteQueueItem extends WriteQueueItem { 86 final String mFilename; 87 Bitmap mImage; 88 ImageWriteQueueItem(String filename, Bitmap image) { 89 mFilename = filename; 90 mImage = image; 91 } 92 } 93 94 ArrayList<WriteQueueItem> mWriteQueue = new ArrayList<WriteQueueItem>(); 95 96 TaskPersister(File systemDir, ActivityStackSupervisor stackSupervisor) { 97 sTasksDir = new File(systemDir, TASKS_DIRNAME); 98 if (!sTasksDir.exists()) { 99 if (DEBUG) Slog.d(TAG, "Creating tasks directory " + sTasksDir); 100 if (!sTasksDir.mkdir()) { 101 Slog.e(TAG, "Failure creating tasks directory " + sTasksDir); 102 } 103 } 104 105 sImagesDir = new File(systemDir, IMAGES_DIRNAME); 106 if (!sImagesDir.exists()) { 107 if (DEBUG) Slog.d(TAG, "Creating images directory " + sTasksDir); 108 if (!sImagesDir.mkdir()) { 109 Slog.e(TAG, "Failure creating images directory " + sImagesDir); 110 } 111 } 112 113 mStackSupervisor = stackSupervisor; 114 mService = stackSupervisor.mService; 115 116 mLazyTaskWriterThread = new LazyTaskWriterThread("LazyTaskWriterThread"); 117 } 118 119 void startPersisting() { 120 mLazyTaskWriterThread.start(); 121 } 122 123 void wakeup(TaskRecord task, boolean flush) { 124 synchronized (this) { 125 if (task != null) { 126 int queueNdx; 127 for (queueNdx = mWriteQueue.size() - 1; queueNdx >= 0; --queueNdx) { 128 final WriteQueueItem item = mWriteQueue.get(queueNdx); 129 if (item instanceof TaskWriteQueueItem && 130 ((TaskWriteQueueItem) item).mTask == task) { 131 break; 132 } 133 } 134 if (queueNdx < 0) { 135 mWriteQueue.add(new TaskWriteQueueItem(task)); 136 } 137 } else { 138 // Dummy. 139 mWriteQueue.add(new WriteQueueItem()); 140 } 141 if (flush) { 142 mNextWriteTime = -1; 143 } else if (mNextWriteTime == 0) { 144 mNextWriteTime = SystemClock.uptimeMillis() + PRE_TASK_DELAY_MS; 145 } 146 if (DEBUG) Slog.d(TAG, "wakeup: task=" + task + " flush=" + flush + " mNextWriteTime=" 147 + mNextWriteTime + " Callers=" + Debug.getCallers(4)); 148 notifyAll(); 149 } 150 } 151 152 void saveImage(Bitmap image, String filename) { 153 synchronized (this) { 154 int queueNdx; 155 for (queueNdx = mWriteQueue.size() - 1; queueNdx >= 0; --queueNdx) { 156 final WriteQueueItem item = mWriteQueue.get(queueNdx); 157 if (item instanceof ImageWriteQueueItem) { 158 ImageWriteQueueItem imageWriteQueueItem = (ImageWriteQueueItem) item; 159 if (imageWriteQueueItem.mFilename.equals(filename)) { 160 // replace the Bitmap with the new one. 161 imageWriteQueueItem.mImage = image; 162 break; 163 } 164 } 165 } 166 if (queueNdx < 0) { 167 mWriteQueue.add(new ImageWriteQueueItem(filename, image)); 168 } 169 if (mNextWriteTime == 0) { 170 mNextWriteTime = SystemClock.uptimeMillis() + PRE_TASK_DELAY_MS; 171 } 172 if (DEBUG) Slog.d(TAG, "saveImage: filename=" + filename + " now=" + 173 SystemClock.uptimeMillis() + " mNextWriteTime=" + 174 mNextWriteTime + " Callers=" + Debug.getCallers(4)); 175 notifyAll(); 176 } 177 } 178 179 Bitmap getThumbnail(String filename) { 180 synchronized (this) { 181 for (int queueNdx = mWriteQueue.size() - 1; queueNdx >= 0; --queueNdx) { 182 final WriteQueueItem item = mWriteQueue.get(queueNdx); 183 if (item instanceof ImageWriteQueueItem) { 184 ImageWriteQueueItem imageWriteQueueItem = (ImageWriteQueueItem) item; 185 if (imageWriteQueueItem.mFilename.equals(filename)) { 186 return imageWriteQueueItem.mImage; 187 } 188 } 189 } 190 return null; 191 } 192 } 193 194 private StringWriter saveToXml(TaskRecord task) throws IOException, XmlPullParserException { 195 if (DEBUG) Slog.d(TAG, "saveToXml: task=" + task); 196 final XmlSerializer xmlSerializer = new FastXmlSerializer(); 197 StringWriter stringWriter = new StringWriter(); 198 xmlSerializer.setOutput(stringWriter); 199 200 if (DEBUG) xmlSerializer.setFeature( 201 "http://xmlpull.org/v1/doc/features.html#indent-output", true); 202 203 // save task 204 xmlSerializer.startDocument(null, true); 205 206 xmlSerializer.startTag(null, TAG_TASK); 207 task.saveToXml(xmlSerializer); 208 xmlSerializer.endTag(null, TAG_TASK); 209 210 xmlSerializer.endDocument(); 211 xmlSerializer.flush(); 212 213 return stringWriter; 214 } 215 216 private String fileToString(File file) { 217 final String newline = System.lineSeparator(); 218 try { 219 BufferedReader reader = new BufferedReader(new FileReader(file)); 220 StringBuffer sb = new StringBuffer((int) file.length() * 2); 221 String line; 222 while ((line = reader.readLine()) != null) { 223 sb.append(line + newline); 224 } 225 reader.close(); 226 return sb.toString(); 227 } catch (IOException ioe) { 228 Slog.e(TAG, "Couldn't read file " + file.getName()); 229 return null; 230 } 231 } 232 233 private TaskRecord taskIdToTask(int taskId, ArrayList<TaskRecord> tasks) { 234 if (taskId < 0) { 235 return null; 236 } 237 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 238 final TaskRecord task = tasks.get(taskNdx); 239 if (task.taskId == taskId) { 240 return task; 241 } 242 } 243 Slog.e(TAG, "Restore affiliation error looking for taskId=" + taskId); 244 return null; 245 } 246 247 ArrayList<TaskRecord> restoreTasksLocked() { 248 final ArrayList<TaskRecord> tasks = new ArrayList<TaskRecord>(); 249 ArraySet<Integer> recoveredTaskIds = new ArraySet<Integer>(); 250 251 File[] recentFiles = sTasksDir.listFiles(); 252 if (recentFiles == null) { 253 Slog.e(TAG, "Unable to list files from " + sTasksDir); 254 return tasks; 255 } 256 257 for (int taskNdx = 0; taskNdx < recentFiles.length; ++taskNdx) { 258 File taskFile = recentFiles[taskNdx]; 259 if (DEBUG) Slog.d(TAG, "restoreTasksLocked: taskFile=" + taskFile.getName()); 260 BufferedReader reader = null; 261 boolean deleteFile = false; 262 try { 263 reader = new BufferedReader(new FileReader(taskFile)); 264 final XmlPullParser in = Xml.newPullParser(); 265 in.setInput(reader); 266 267 int event; 268 while (((event = in.next()) != XmlPullParser.END_DOCUMENT) && 269 event != XmlPullParser.END_TAG) { 270 final String name = in.getName(); 271 if (event == XmlPullParser.START_TAG) { 272 if (DEBUG) Slog.d(TAG, "restoreTasksLocked: START_TAG name=" + name); 273 if (TAG_TASK.equals(name)) { 274 final TaskRecord task = 275 TaskRecord.restoreFromXml(in, mStackSupervisor); 276 if (DEBUG) Slog.d(TAG, "restoreTasksLocked: restored task=" + 277 task); 278 if (task != null) { 279 task.isPersistable = true; 280 // XXX Don't add to write queue... there is no reason to write 281 // out the stuff we just read, if we don't write it we will 282 // read the same thing again. 283 //mWriteQueue.add(new TaskWriteQueueItem(task)); 284 tasks.add(task); 285 final int taskId = task.taskId; 286 recoveredTaskIds.add(taskId); 287 mStackSupervisor.setNextTaskId(taskId); 288 } else { 289 Slog.e(TAG, "Unable to restore taskFile=" + taskFile + ": " + 290 fileToString(taskFile)); 291 } 292 } else { 293 Slog.wtf(TAG, "restoreTasksLocked Unknown xml event=" + event + 294 " name=" + name); 295 } 296 } 297 XmlUtils.skipCurrentTag(in); 298 } 299 } catch (Exception e) { 300 Slog.wtf(TAG, "Unable to parse " + taskFile + ". Error ", e); 301 Slog.e(TAG, "Failing file: " + fileToString(taskFile)); 302 deleteFile = true; 303 } finally { 304 if (reader != null) { 305 try { 306 reader.close(); 307 } catch (IOException e) { 308 } 309 } 310 if (!DEBUG && deleteFile) { 311 if (true || DEBUG) Slog.d(TAG, "Deleting file=" + taskFile.getName()); 312 taskFile.delete(); 313 } 314 } 315 } 316 317 if (!DEBUG) { 318 removeObsoleteFiles(recoveredTaskIds); 319 } 320 321 // Fixup task affiliation from taskIds 322 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 323 final TaskRecord task = tasks.get(taskNdx); 324 task.setPrevAffiliate(taskIdToTask(task.mPrevAffiliateTaskId, tasks)); 325 task.setNextAffiliate(taskIdToTask(task.mNextAffiliateTaskId, tasks)); 326 } 327 328 TaskRecord[] tasksArray = new TaskRecord[tasks.size()]; 329 tasks.toArray(tasksArray); 330 Arrays.sort(tasksArray, new Comparator<TaskRecord>() { 331 @Override 332 public int compare(TaskRecord lhs, TaskRecord rhs) { 333 final long diff = rhs.mLastTimeMoved - lhs.mLastTimeMoved; 334 if (diff < 0) { 335 return -1; 336 } else if (diff > 0) { 337 return +1; 338 } else { 339 return 0; 340 } 341 } 342 }); 343 344 return new ArrayList<TaskRecord>(Arrays.asList(tasksArray)); 345 } 346 347 private static void removeObsoleteFiles(ArraySet<Integer> persistentTaskIds, File[] files) { 348 if (DEBUG) Slog.d(TAG, "removeObsoleteFile: persistentTaskIds=" + persistentTaskIds + 349 " files=" + files); 350 for (int fileNdx = 0; fileNdx < files.length; ++fileNdx) { 351 File file = files[fileNdx]; 352 String filename = file.getName(); 353 final int taskIdEnd = filename.indexOf('_'); 354 if (taskIdEnd > 0) { 355 final int taskId; 356 try { 357 taskId = Integer.valueOf(filename.substring(0, taskIdEnd)); 358 if (DEBUG) Slog.d(TAG, "removeObsoleteFile: Found taskId=" + taskId); 359 } catch (Exception e) { 360 Slog.wtf(TAG, "removeObsoleteFile: Can't parse file=" + file.getName()); 361 file.delete(); 362 continue; 363 } 364 if (!persistentTaskIds.contains(taskId)) { 365 if (true || DEBUG) Slog.d(TAG, "removeObsoleteFile: deleting file=" + 366 file.getName()); 367 file.delete(); 368 } 369 } 370 } 371 } 372 373 private void removeObsoleteFiles(ArraySet<Integer> persistentTaskIds) { 374 removeObsoleteFiles(persistentTaskIds, sTasksDir.listFiles()); 375 removeObsoleteFiles(persistentTaskIds, sImagesDir.listFiles()); 376 } 377 378 static Bitmap restoreImage(String filename) { 379 if (DEBUG) Slog.d(TAG, "restoreImage: restoring " + filename); 380 return BitmapFactory.decodeFile(sImagesDir + File.separator + filename); 381 } 382 383 private class LazyTaskWriterThread extends Thread { 384 385 LazyTaskWriterThread(String name) { 386 super(name); 387 } 388 389 @Override 390 public void run() { 391 ArraySet<Integer> persistentTaskIds = new ArraySet<Integer>(); 392 while (true) { 393 // We can't lock mService while holding TaskPersister.this, but we don't want to 394 // call removeObsoleteFiles every time through the loop, only the last time before 395 // going to sleep. The risk is that we call removeObsoleteFiles() successively. 396 final boolean probablyDone; 397 synchronized (TaskPersister.this) { 398 probablyDone = mWriteQueue.isEmpty(); 399 } 400 if (probablyDone) { 401 if (DEBUG) Slog.d(TAG, "Looking for obsolete files."); 402 persistentTaskIds.clear(); 403 synchronized (mService) { 404 final ArrayList<TaskRecord> tasks = mService.mRecentTasks; 405 if (DEBUG) Slog.d(TAG, "mRecents=" + tasks); 406 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 407 final TaskRecord task = tasks.get(taskNdx); 408 if (DEBUG) Slog.d(TAG, "LazyTaskWriter: task=" + task + " persistable=" + 409 task.isPersistable); 410 if (task.isPersistable && !task.stack.isHomeStack()) { 411 if (DEBUG) Slog.d(TAG, "adding to persistentTaskIds task=" + task); 412 persistentTaskIds.add(task.taskId); 413 } else { 414 if (DEBUG) Slog.d(TAG, "omitting from persistentTaskIds task=" + task); 415 } 416 } 417 } 418 removeObsoleteFiles(persistentTaskIds); 419 } 420 421 // If mNextWriteTime, then don't delay between each call to saveToXml(). 422 final WriteQueueItem item; 423 synchronized (TaskPersister.this) { 424 if (mNextWriteTime >= 0) { 425 // The next write we don't have to wait so long. 426 mNextWriteTime = SystemClock.uptimeMillis() + INTER_WRITE_DELAY_MS; 427 if (DEBUG) Slog.d(TAG, "Next write time may be in " + 428 INTER_WRITE_DELAY_MS + " msec. (" + mNextWriteTime + ")"); 429 } 430 431 while (mWriteQueue.isEmpty()) { 432 mNextWriteTime = 0; // idle. 433 try { 434 if (DEBUG) Slog.d(TAG, "LazyTaskWriter: waiting indefinitely."); 435 TaskPersister.this.wait(); 436 } catch (InterruptedException e) { 437 } 438 // Invariant: mNextWriteTime is either -1 or PRE_WRITE_DELAY_MS from now. 439 } 440 item = mWriteQueue.remove(0); 441 442 long now = SystemClock.uptimeMillis(); 443 if (DEBUG) Slog.d(TAG, "LazyTaskWriter: now=" + now + " mNextWriteTime=" + 444 mNextWriteTime); 445 while (now < mNextWriteTime) { 446 try { 447 if (DEBUG) Slog.d(TAG, "LazyTaskWriter: waiting " + 448 (mNextWriteTime - now)); 449 TaskPersister.this.wait(mNextWriteTime - now); 450 } catch (InterruptedException e) { 451 } 452 now = SystemClock.uptimeMillis(); 453 } 454 455 // Got something to do. 456 } 457 458 if (item instanceof ImageWriteQueueItem) { 459 ImageWriteQueueItem imageWriteQueueItem = (ImageWriteQueueItem) item; 460 final String filename = imageWriteQueueItem.mFilename; 461 final Bitmap bitmap = imageWriteQueueItem.mImage; 462 if (DEBUG) Slog.d(TAG, "writing bitmap: filename=" + filename); 463 FileOutputStream imageFile = null; 464 try { 465 imageFile = new FileOutputStream(new File(sImagesDir, filename)); 466 bitmap.compress(Bitmap.CompressFormat.PNG, 100, imageFile); 467 } catch (Exception e) { 468 Slog.e(TAG, "saveImage: unable to save " + filename, e); 469 } finally { 470 if (imageFile != null) { 471 try { 472 imageFile.close(); 473 } catch (IOException e) { 474 } 475 } 476 } 477 } else if (item instanceof TaskWriteQueueItem) { 478 // Write out one task. 479 StringWriter stringWriter = null; 480 TaskRecord task = ((TaskWriteQueueItem) item).mTask; 481 if (DEBUG) Slog.d(TAG, "Writing task=" + task); 482 synchronized (mService) { 483 if (mService.mRecentTasks.contains(task)) { 484 // Still there. 485 try { 486 if (DEBUG) Slog.d(TAG, "Saving task=" + task); 487 stringWriter = saveToXml(task); 488 } catch (IOException e) { 489 } catch (XmlPullParserException e) { 490 } 491 } 492 } 493 if (stringWriter != null) { 494 // Write out xml file while not holding mService lock. 495 FileOutputStream file = null; 496 AtomicFile atomicFile = null; 497 try { 498 atomicFile = new AtomicFile(new File(sTasksDir, String.valueOf( 499 task.taskId) + RECENTS_FILENAME + TASK_EXTENSION)); 500 file = atomicFile.startWrite(); 501 file.write(stringWriter.toString().getBytes()); 502 file.write('\n'); 503 atomicFile.finishWrite(file); 504 } catch (IOException e) { 505 if (file != null) { 506 atomicFile.failWrite(file); 507 } 508 Slog.e(TAG, "Unable to open " + atomicFile + " for persisting. " + 509 e); 510 } 511 } 512 } 513 } 514 } 515 } 516} 517