1 /** 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 5 * use this file except in compliance with the License. You may obtain a copy 6 * 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, WITHOUT 12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 * License for the specific language governing permissions and limitations 14 * under the License. 15 */ 16 17 package com.android.server.usage; 18 19 import android.os.Environment; 20 import android.os.SystemClock; 21 import android.os.UserHandle; 22 import android.util.ArrayMap; 23 import android.util.AtomicFile; 24 import android.util.Slog; 25 import android.util.SparseArray; 26 import android.util.TimeUtils; 27 import android.util.Xml; 28 29 import com.android.internal.annotations.VisibleForTesting; 30 import com.android.internal.util.FastXmlSerializer; 31 import com.android.internal.util.IndentingPrintWriter; 32 33 import libcore.io.IoUtils; 34 35 import org.xmlpull.v1.XmlPullParser; 36 import org.xmlpull.v1.XmlPullParserException; 37 38 import java.io.BufferedOutputStream; 39 import java.io.BufferedReader; 40 import java.io.File; 41 import java.io.FileInputStream; 42 import java.io.FileOutputStream; 43 import java.io.FileReader; 44 import java.io.IOException; 45 import java.nio.charset.StandardCharsets; 46 47 /** 48 * Keeps track of recent active state changes in apps. 49 * Access should be guarded by a lock by the caller. 50 */ 51 public class AppIdleHistory { 52 53 private static final String TAG = "AppIdleHistory"; 54 55 // History for all users and all packages 56 private SparseArray<ArrayMap<String,PackageHistory>> mIdleHistory = new SparseArray<>(); 57 private long mLastPeriod = 0; 58 private static final long ONE_MINUTE = 60 * 1000; 59 private static final int HISTORY_SIZE = 100; 60 private static final int FLAG_LAST_STATE = 2; 61 private static final int FLAG_PARTIAL_ACTIVE = 1; 62 private static final long PERIOD_DURATION = UsageStatsService.COMPRESS_TIME ? ONE_MINUTE 63 : 60 * ONE_MINUTE; 64 65 @VisibleForTesting 66 static final String APP_IDLE_FILENAME = "app_idle_stats.xml"; 67 private static final String TAG_PACKAGES = "packages"; 68 private static final String TAG_PACKAGE = "package"; 69 private static final String ATTR_NAME = "name"; 70 // Screen on timebase time when app was last used 71 private static final String ATTR_SCREEN_IDLE = "screenIdleTime"; 72 // Elapsed timebase time when app was last used 73 private static final String ATTR_ELAPSED_IDLE = "elapsedIdleTime"; 74 75 // device on time = mElapsedDuration + (timeNow - mElapsedSnapshot) 76 private long mElapsedSnapshot; // Elapsed time snapshot when last write of mDeviceOnDuration 77 private long mElapsedDuration; // Total device on duration since device was "born" 78 79 // screen on time = mScreenOnDuration + (timeNow - mScreenOnSnapshot) 80 private long mScreenOnSnapshot; // Elapsed time snapshot when last write of mScreenOnDuration 81 private long mScreenOnDuration; // Total screen on duration since device was "born" 82 83 private long mElapsedTimeThreshold; 84 private long mScreenOnTimeThreshold; 85 private final File mStorageDir; 86 87 private boolean mScreenOn; 88 89 private static class PackageHistory { 90 final byte[] recent = new byte[HISTORY_SIZE]; 91 long lastUsedElapsedTime; 92 long lastUsedScreenTime; 93 } 94 95 AppIdleHistory(long elapsedRealtime) { 96 this(Environment.getDataSystemDirectory(), elapsedRealtime); 97 } 98 99 @VisibleForTesting 100 AppIdleHistory(File storageDir, long elapsedRealtime) { 101 mElapsedSnapshot = elapsedRealtime; 102 mScreenOnSnapshot = elapsedRealtime; 103 mStorageDir = storageDir; 104 readScreenOnTimeLocked(); 105 } 106 107 public void setThresholds(long elapsedTimeThreshold, long screenOnTimeThreshold) { 108 mElapsedTimeThreshold = elapsedTimeThreshold; 109 mScreenOnTimeThreshold = screenOnTimeThreshold; 110 } 111 112 public void updateDisplayLocked(boolean screenOn, long elapsedRealtime) { 113 if (screenOn == mScreenOn) return; 114 115 mScreenOn = screenOn; 116 if (mScreenOn) { 117 mScreenOnSnapshot = elapsedRealtime; 118 } else { 119 mScreenOnDuration += elapsedRealtime - mScreenOnSnapshot; 120 mElapsedDuration += elapsedRealtime - mElapsedSnapshot; 121 mElapsedSnapshot = elapsedRealtime; 122 } 123 } 124 125 public long getScreenOnTimeLocked(long elapsedRealtime) { 126 long screenOnTime = mScreenOnDuration; 127 if (mScreenOn) { 128 screenOnTime += elapsedRealtime - mScreenOnSnapshot; 129 } 130 return screenOnTime; 131 } 132 133 @VisibleForTesting 134 File getScreenOnTimeFile() { 135 return new File(mStorageDir, "screen_on_time"); 136 } 137 138 private void readScreenOnTimeLocked() { 139 File screenOnTimeFile = getScreenOnTimeFile(); 140 if (screenOnTimeFile.exists()) { 141 try { 142 BufferedReader reader = new BufferedReader(new FileReader(screenOnTimeFile)); 143 mScreenOnDuration = Long.parseLong(reader.readLine()); 144 mElapsedDuration = Long.parseLong(reader.readLine()); 145 reader.close(); 146 } catch (IOException | NumberFormatException e) { 147 } 148 } else { 149 writeScreenOnTimeLocked(); 150 } 151 } 152 153 private void writeScreenOnTimeLocked() { 154 AtomicFile screenOnTimeFile = new AtomicFile(getScreenOnTimeFile()); 155 FileOutputStream fos = null; 156 try { 157 fos = screenOnTimeFile.startWrite(); 158 fos.write((Long.toString(mScreenOnDuration) + "\n" 159 + Long.toString(mElapsedDuration) + "\n").getBytes()); 160 screenOnTimeFile.finishWrite(fos); 161 } catch (IOException ioe) { 162 screenOnTimeFile.failWrite(fos); 163 } 164 } 165 166 /** 167 * To be called periodically to keep track of elapsed time when app idle times are written 168 */ 169 public void writeAppIdleDurationsLocked() { 170 final long elapsedRealtime = SystemClock.elapsedRealtime(); 171 // Only bump up and snapshot the elapsed time. Don't change screen on duration. 172 mElapsedDuration += elapsedRealtime - mElapsedSnapshot; 173 mElapsedSnapshot = elapsedRealtime; 174 writeScreenOnTimeLocked(); 175 } 176 177 public void reportUsageLocked(String packageName, int userId, long elapsedRealtime) { 178 ArrayMap<String, PackageHistory> userHistory = getUserHistoryLocked(userId); 179 PackageHistory packageHistory = getPackageHistoryLocked(userHistory, packageName, 180 elapsedRealtime); 181 182 shiftHistoryToNow(userHistory, elapsedRealtime); 183 184 packageHistory.lastUsedElapsedTime = mElapsedDuration 185 + (elapsedRealtime - mElapsedSnapshot); 186 packageHistory.lastUsedScreenTime = getScreenOnTimeLocked(elapsedRealtime); 187 packageHistory.recent[HISTORY_SIZE - 1] = FLAG_LAST_STATE | FLAG_PARTIAL_ACTIVE; 188 } 189 190 public void setIdle(String packageName, int userId, long elapsedRealtime) { 191 ArrayMap<String, PackageHistory> userHistory = getUserHistoryLocked(userId); 192 PackageHistory packageHistory = getPackageHistoryLocked(userHistory, packageName, 193 elapsedRealtime); 194 195 shiftHistoryToNow(userHistory, elapsedRealtime); 196 197 packageHistory.recent[HISTORY_SIZE - 1] &= ~FLAG_LAST_STATE; 198 } 199 200 private void shiftHistoryToNow(ArrayMap<String, PackageHistory> userHistory, 201 long elapsedRealtime) { 202 long thisPeriod = elapsedRealtime / PERIOD_DURATION; 203 // Has the period switched over? Slide all users' package histories 204 if (mLastPeriod != 0 && mLastPeriod < thisPeriod 205 && (thisPeriod - mLastPeriod) < HISTORY_SIZE - 1) { 206 int diff = (int) (thisPeriod - mLastPeriod); 207 final int NUSERS = mIdleHistory.size(); 208 for (int u = 0; u < NUSERS; u++) { 209 userHistory = mIdleHistory.valueAt(u); 210 for (PackageHistory idleState : userHistory.values()) { 211 // Shift left 212 System.arraycopy(idleState.recent, diff, idleState.recent, 0, 213 HISTORY_SIZE - diff); 214 // Replicate last state across the diff 215 for (int i = 0; i < diff; i++) { 216 idleState.recent[HISTORY_SIZE - i - 1] = 217 (byte) (idleState.recent[HISTORY_SIZE - diff - 1] & FLAG_LAST_STATE); 218 } 219 } 220 } 221 } 222 mLastPeriod = thisPeriod; 223 } 224 225 private ArrayMap<String, PackageHistory> getUserHistoryLocked(int userId) { 226 ArrayMap<String, PackageHistory> userHistory = mIdleHistory.get(userId); 227 if (userHistory == null) { 228 userHistory = new ArrayMap<>(); 229 mIdleHistory.put(userId, userHistory); 230 readAppIdleTimesLocked(userId, userHistory); 231 } 232 return userHistory; 233 } 234 235 private PackageHistory getPackageHistoryLocked(ArrayMap<String, PackageHistory> userHistory, 236 String packageName, long elapsedRealtime) { 237 PackageHistory packageHistory = userHistory.get(packageName); 238 if (packageHistory == null) { 239 packageHistory = new PackageHistory(); 240 packageHistory.lastUsedElapsedTime = getElapsedTimeLocked(elapsedRealtime); 241 packageHistory.lastUsedScreenTime = getScreenOnTimeLocked(elapsedRealtime); 242 userHistory.put(packageName, packageHistory); 243 } 244 return packageHistory; 245 } 246 247 public void onUserRemoved(int userId) { 248 mIdleHistory.remove(userId); 249 } 250 251 public boolean isIdleLocked(String packageName, int userId, long elapsedRealtime) { 252 ArrayMap<String, PackageHistory> userHistory = getUserHistoryLocked(userId); 253 PackageHistory packageHistory = 254 getPackageHistoryLocked(userHistory, packageName, elapsedRealtime); 255 if (packageHistory == null) { 256 return false; // Default to not idle 257 } else { 258 return hasPassedThresholdsLocked(packageHistory, elapsedRealtime); 259 } 260 } 261 262 private long getElapsedTimeLocked(long elapsedRealtime) { 263 return (elapsedRealtime - mElapsedSnapshot + mElapsedDuration); 264 } 265 266 public void setIdleLocked(String packageName, int userId, boolean idle, long elapsedRealtime) { 267 ArrayMap<String, PackageHistory> userHistory = getUserHistoryLocked(userId); 268 PackageHistory packageHistory = getPackageHistoryLocked(userHistory, packageName, 269 elapsedRealtime); 270 packageHistory.lastUsedElapsedTime = getElapsedTimeLocked(elapsedRealtime) 271 - mElapsedTimeThreshold; 272 packageHistory.lastUsedScreenTime = getScreenOnTimeLocked(elapsedRealtime) 273 - (idle ? mScreenOnTimeThreshold : 0) - 1000 /* just a second more */; 274 } 275 276 public void clearUsageLocked(String packageName, int userId) { 277 ArrayMap<String, PackageHistory> userHistory = getUserHistoryLocked(userId); 278 userHistory.remove(packageName); 279 } 280 281 private boolean hasPassedThresholdsLocked(PackageHistory packageHistory, long elapsedRealtime) { 282 return (packageHistory.lastUsedScreenTime 283 <= getScreenOnTimeLocked(elapsedRealtime) - mScreenOnTimeThreshold) 284 && (packageHistory.lastUsedElapsedTime 285 <= getElapsedTimeLocked(elapsedRealtime) - mElapsedTimeThreshold); 286 } 287 288 private File getUserFile(int userId) { 289 return new File(new File(new File(mStorageDir, "users"), 290 Integer.toString(userId)), APP_IDLE_FILENAME); 291 } 292 293 private void readAppIdleTimesLocked(int userId, ArrayMap<String, PackageHistory> userHistory) { 294 FileInputStream fis = null; 295 try { 296 AtomicFile appIdleFile = new AtomicFile(getUserFile(userId)); 297 fis = appIdleFile.openRead(); 298 XmlPullParser parser = Xml.newPullParser(); 299 parser.setInput(fis, StandardCharsets.UTF_8.name()); 300 301 int type; 302 while ((type = parser.next()) != XmlPullParser.START_TAG 303 && type != XmlPullParser.END_DOCUMENT) { 304 // Skip 305 } 306 307 if (type != XmlPullParser.START_TAG) { 308 Slog.e(TAG, "Unable to read app idle file for user " + userId); 309 return; 310 } 311 if (!parser.getName().equals(TAG_PACKAGES)) { 312 return; 313 } 314 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) { 315 if (type == XmlPullParser.START_TAG) { 316 final String name = parser.getName(); 317 if (name.equals(TAG_PACKAGE)) { 318 final String packageName = parser.getAttributeValue(null, ATTR_NAME); 319 PackageHistory packageHistory = new PackageHistory(); 320 packageHistory.lastUsedElapsedTime = 321 Long.parseLong(parser.getAttributeValue(null, ATTR_ELAPSED_IDLE)); 322 packageHistory.lastUsedScreenTime = 323 Long.parseLong(parser.getAttributeValue(null, ATTR_SCREEN_IDLE)); 324 userHistory.put(packageName, packageHistory); 325 } 326 } 327 } 328 } catch (IOException | XmlPullParserException e) { 329 Slog.e(TAG, "Unable to read app idle file for user " + userId); 330 } finally { 331 IoUtils.closeQuietly(fis); 332 } 333 } 334 335 public void writeAppIdleTimesLocked(int userId) { 336 FileOutputStream fos = null; 337 AtomicFile appIdleFile = new AtomicFile(getUserFile(userId)); 338 try { 339 fos = appIdleFile.startWrite(); 340 final BufferedOutputStream bos = new BufferedOutputStream(fos); 341 342 FastXmlSerializer xml = new FastXmlSerializer(); 343 xml.setOutput(bos, StandardCharsets.UTF_8.name()); 344 xml.startDocument(null, true); 345 xml.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); 346 347 xml.startTag(null, TAG_PACKAGES); 348 349 ArrayMap<String,PackageHistory> userHistory = getUserHistoryLocked(userId); 350 final int N = userHistory.size(); 351 for (int i = 0; i < N; i++) { 352 String packageName = userHistory.keyAt(i); 353 PackageHistory history = userHistory.valueAt(i); 354 xml.startTag(null, TAG_PACKAGE); 355 xml.attribute(null, ATTR_NAME, packageName); 356 xml.attribute(null, ATTR_ELAPSED_IDLE, 357 Long.toString(history.lastUsedElapsedTime)); 358 xml.attribute(null, ATTR_SCREEN_IDLE, 359 Long.toString(history.lastUsedScreenTime)); 360 xml.endTag(null, TAG_PACKAGE); 361 } 362 363 xml.endTag(null, TAG_PACKAGES); 364 xml.endDocument(); 365 appIdleFile.finishWrite(fos); 366 } catch (Exception e) { 367 appIdleFile.failWrite(fos); 368 Slog.e(TAG, "Error writing app idle file for user " + userId); 369 } 370 } 371 372 public void dump(IndentingPrintWriter idpw, int userId) { 373 idpw.println("Package idle stats:"); 374 idpw.increaseIndent(); 375 ArrayMap<String, PackageHistory> userHistory = mIdleHistory.get(userId); 376 final long elapsedRealtime = SystemClock.elapsedRealtime(); 377 final long totalElapsedTime = getElapsedTimeLocked(elapsedRealtime); 378 final long screenOnTime = getScreenOnTimeLocked(elapsedRealtime); 379 if (userHistory == null) return; 380 final int P = userHistory.size(); 381 for (int p = 0; p < P; p++) { 382 final String packageName = userHistory.keyAt(p); 383 final PackageHistory packageHistory = userHistory.valueAt(p); 384 idpw.print("package=" + packageName); 385 idpw.print(" lastUsedElapsed="); 386 TimeUtils.formatDuration(totalElapsedTime - packageHistory.lastUsedElapsedTime, idpw); 387 idpw.print(" lastUsedScreenOn="); 388 TimeUtils.formatDuration(screenOnTime - packageHistory.lastUsedScreenTime, idpw); 389 idpw.print(" idle=" + (isIdleLocked(packageName, userId, elapsedRealtime) ? "y" : "n")); 390 idpw.println(); 391 } 392 idpw.println(); 393 idpw.print("totalElapsedTime="); 394 TimeUtils.formatDuration(getElapsedTimeLocked(elapsedRealtime), idpw); 395 idpw.println(); 396 idpw.print("totalScreenOnTime="); 397 TimeUtils.formatDuration(getScreenOnTimeLocked(elapsedRealtime), idpw); 398 idpw.println(); 399 idpw.decreaseIndent(); 400 } 401 402 public void dumpHistory(IndentingPrintWriter idpw, int userId) { 403 ArrayMap<String, PackageHistory> userHistory = mIdleHistory.get(userId); 404 final long elapsedRealtime = SystemClock.elapsedRealtime(); 405 if (userHistory == null) return; 406 final int P = userHistory.size(); 407 for (int p = 0; p < P; p++) { 408 final String packageName = userHistory.keyAt(p); 409 final byte[] history = userHistory.valueAt(p).recent; 410 for (int i = 0; i < HISTORY_SIZE; i++) { 411 idpw.print(history[i] == 0 ? '.' : 'A'); 412 } 413 idpw.print(" idle=" + (isIdleLocked(packageName, userId, elapsedRealtime) ? "y" : "n")); 414 idpw.print(" " + packageName); 415 idpw.println(); 416 } 417 } 418 } 419
