533 lines
18 KiB
Java
Executable File
533 lines
18 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2006-2007 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.am;
|
|
|
|
import com.android.internal.app.IUsageStats;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.os.Binder;
|
|
import android.os.IBinder;
|
|
import com.android.internal.os.PkgUsageStats;
|
|
import android.os.Parcel;
|
|
import android.os.Process;
|
|
import android.os.ServiceManager;
|
|
import android.os.SystemClock;
|
|
import android.util.Log;
|
|
import java.io.File;
|
|
import java.io.FileDescriptor;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
/**
|
|
* This service collects the statistics associated with usage
|
|
* of various components, like when a particular package is launched or
|
|
* paused and aggregates events like number of time a component is launched
|
|
* total duration of a component launch.
|
|
*/
|
|
public final class UsageStatsService extends IUsageStats.Stub {
|
|
public static final String SERVICE_NAME = "usagestats";
|
|
private static final boolean localLOGV = false;
|
|
private static final String TAG = "UsageStats";
|
|
static IUsageStats sService;
|
|
private Context mContext;
|
|
// structure used to maintain statistics since the last checkin.
|
|
final private Map<String, PkgUsageStatsExtended> mStats;
|
|
// Lock to update package stats. Methods suffixed by SLOCK should invoked with
|
|
// this lock held
|
|
final Object mStatsLock;
|
|
// Lock to write to file. Methods suffixed by FLOCK should invoked with
|
|
// this lock held.
|
|
final Object mFileLock;
|
|
// Order of locks is mFileLock followed by mStatsLock to avoid deadlocks
|
|
private String mResumedPkg;
|
|
private File mFile;
|
|
//private File mBackupFile;
|
|
private long mLastWriteRealTime;
|
|
private int _FILE_WRITE_INTERVAL = 30*60*1000; //ms
|
|
private static final String _PREFIX_DELIMIT=".";
|
|
private String mFilePrefix;
|
|
private Calendar mCal;
|
|
private static final int _MAX_NUM_FILES = 10;
|
|
private long mLastTime;
|
|
|
|
private class PkgUsageStatsExtended {
|
|
int mLaunchCount;
|
|
long mUsageTime;
|
|
long mPausedTime;
|
|
long mResumedTime;
|
|
|
|
PkgUsageStatsExtended() {
|
|
mLaunchCount = 0;
|
|
mUsageTime = 0;
|
|
}
|
|
void updateResume() {
|
|
mLaunchCount ++;
|
|
mResumedTime = SystemClock.elapsedRealtime();
|
|
}
|
|
void updatePause() {
|
|
mPausedTime = SystemClock.elapsedRealtime();
|
|
mUsageTime += (mPausedTime - mResumedTime);
|
|
}
|
|
void clear() {
|
|
mLaunchCount = 0;
|
|
mUsageTime = 0;
|
|
}
|
|
}
|
|
|
|
UsageStatsService(String fileName) {
|
|
mStats = new HashMap<String, PkgUsageStatsExtended>();
|
|
mStatsLock = new Object();
|
|
mFileLock = new Object();
|
|
mFilePrefix = fileName;
|
|
mCal = Calendar.getInstance();
|
|
// Update current stats which are binned by date
|
|
String uFileName = getCurrentDateStr(mFilePrefix);
|
|
mFile = new File(uFileName);
|
|
readStatsFromFile();
|
|
mLastWriteRealTime = SystemClock.elapsedRealtime();
|
|
mLastTime = new Date().getTime();
|
|
}
|
|
|
|
/*
|
|
* Utility method to convert date into string.
|
|
*/
|
|
private String getCurrentDateStr(String prefix) {
|
|
mCal.setTime(new Date());
|
|
StringBuilder sb = new StringBuilder();
|
|
if (prefix != null) {
|
|
sb.append(prefix);
|
|
sb.append(".");
|
|
}
|
|
int mm = mCal.get(Calendar.MONTH) - Calendar.JANUARY +1;
|
|
if (mm < 10) {
|
|
sb.append("0");
|
|
}
|
|
sb.append(mm);
|
|
int dd = mCal.get(Calendar.DAY_OF_MONTH);
|
|
if (dd < 10) {
|
|
sb.append("0");
|
|
}
|
|
sb.append(dd);
|
|
sb.append(mCal.get(Calendar.YEAR));
|
|
return sb.toString();
|
|
}
|
|
|
|
private Parcel getParcelForFile(File file) throws IOException {
|
|
FileInputStream stream = new FileInputStream(file);
|
|
byte[] raw = readFully(stream);
|
|
Parcel in = Parcel.obtain();
|
|
in.unmarshall(raw, 0, raw.length);
|
|
in.setDataPosition(0);
|
|
stream.close();
|
|
return in;
|
|
}
|
|
|
|
private void readStatsFromFile() {
|
|
File newFile = mFile;
|
|
synchronized (mFileLock) {
|
|
try {
|
|
if (newFile.exists()) {
|
|
readStatsFLOCK(newFile);
|
|
} else {
|
|
// Check for file limit before creating a new file
|
|
checkFileLimitFLOCK();
|
|
newFile.createNewFile();
|
|
}
|
|
} catch (IOException e) {
|
|
Log.w(TAG,"Error : " + e + " reading data from file:" + newFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void readStatsFLOCK(File file) throws IOException {
|
|
Parcel in = getParcelForFile(file);
|
|
while (in.dataAvail() > 0) {
|
|
String pkgName = in.readString();
|
|
PkgUsageStatsExtended pus = new PkgUsageStatsExtended();
|
|
pus.mLaunchCount = in.readInt();
|
|
pus.mUsageTime = in.readLong();
|
|
synchronized (mStatsLock) {
|
|
mStats.put(pkgName, pus);
|
|
}
|
|
}
|
|
}
|
|
|
|
private ArrayList<String> getUsageStatsFileListFLOCK() {
|
|
File dir = getUsageFilesDir();
|
|
if (dir == null) {
|
|
Log.w(TAG, "Couldnt find writable directory for usage stats file");
|
|
return null;
|
|
}
|
|
// Check if there are too many files in the system and delete older files
|
|
String fList[] = dir.list();
|
|
if (fList == null) {
|
|
return null;
|
|
}
|
|
File pre = new File(mFilePrefix);
|
|
String filePrefix = pre.getName();
|
|
// file name followed by dot
|
|
int prefixLen = filePrefix.length()+1;
|
|
ArrayList<String> fileList = new ArrayList<String>();
|
|
for (String file : fList) {
|
|
int index = file.indexOf(filePrefix);
|
|
if (index == -1) {
|
|
continue;
|
|
}
|
|
if (file.endsWith(".bak")) {
|
|
continue;
|
|
}
|
|
fileList.add(file);
|
|
}
|
|
return fileList;
|
|
}
|
|
|
|
private File getUsageFilesDir() {
|
|
if (mFilePrefix == null) {
|
|
return null;
|
|
}
|
|
File pre = new File(mFilePrefix);
|
|
return new File(pre.getParent());
|
|
}
|
|
|
|
private void checkFileLimitFLOCK() {
|
|
File dir = getUsageFilesDir();
|
|
if (dir == null) {
|
|
Log.w(TAG, "Couldnt find writable directory for usage stats file");
|
|
return;
|
|
}
|
|
// Get all usage stats output files
|
|
ArrayList<String> fileList = getUsageStatsFileListFLOCK();
|
|
if (fileList == null) {
|
|
// Strange but we dont have to delete any thing
|
|
return;
|
|
}
|
|
int count = fileList.size();
|
|
if (count <= _MAX_NUM_FILES) {
|
|
return;
|
|
}
|
|
// Sort files
|
|
Collections.sort(fileList);
|
|
count -= _MAX_NUM_FILES;
|
|
// Delete older files
|
|
for (int i = 0; i < count; i++) {
|
|
String fileName = fileList.get(i);
|
|
File file = new File(dir, fileName);
|
|
Log.i(TAG, "Deleting file : "+fileName);
|
|
file.delete();
|
|
}
|
|
}
|
|
|
|
private void writeStatsToFile() {
|
|
synchronized (mFileLock) {
|
|
long currTime = new Date().getTime();
|
|
boolean dayChanged = ((currTime - mLastTime) >= (24*60*60*1000));
|
|
long currRealTime = SystemClock.elapsedRealtime();
|
|
if (((currRealTime-mLastWriteRealTime) < _FILE_WRITE_INTERVAL) &&
|
|
(!dayChanged)) {
|
|
// wait till the next update
|
|
return;
|
|
}
|
|
// Get the most recent file
|
|
String todayStr = getCurrentDateStr(mFilePrefix);
|
|
// Copy current file to back up
|
|
File backupFile = new File(mFile.getPath() + ".bak");
|
|
mFile.renameTo(backupFile);
|
|
try {
|
|
checkFileLimitFLOCK();
|
|
mFile.createNewFile();
|
|
// Write mStats to file
|
|
writeStatsFLOCK();
|
|
mLastWriteRealTime = currRealTime;
|
|
mLastTime = currTime;
|
|
if (dayChanged) {
|
|
// clear stats
|
|
synchronized (mStats) {
|
|
mStats.clear();
|
|
}
|
|
mFile = new File(todayStr);
|
|
}
|
|
// Delete the backup file
|
|
if (backupFile != null) {
|
|
backupFile.delete();
|
|
}
|
|
} catch (IOException e) {
|
|
Log.w(TAG, "Failed writing stats to file:" + mFile);
|
|
if (backupFile != null) {
|
|
backupFile.renameTo(mFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void writeStatsFLOCK() throws IOException {
|
|
FileOutputStream stream = new FileOutputStream(mFile);
|
|
Parcel out = Parcel.obtain();
|
|
writeStatsToParcelFLOCK(out);
|
|
stream.write(out.marshall());
|
|
out.recycle();
|
|
stream.flush();
|
|
stream.close();
|
|
}
|
|
|
|
private void writeStatsToParcelFLOCK(Parcel out) {
|
|
synchronized (mStatsLock) {
|
|
Set<String> keys = mStats.keySet();
|
|
for (String key : keys) {
|
|
PkgUsageStatsExtended pus = mStats.get(key);
|
|
out.writeString(key);
|
|
out.writeInt(pus.mLaunchCount);
|
|
out.writeLong(pus.mUsageTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void publish(Context context) {
|
|
mContext = context;
|
|
ServiceManager.addService(SERVICE_NAME, asBinder());
|
|
}
|
|
|
|
public static IUsageStats getService() {
|
|
if (sService != null) {
|
|
return sService;
|
|
}
|
|
IBinder b = ServiceManager.getService(SERVICE_NAME);
|
|
sService = asInterface(b);
|
|
return sService;
|
|
}
|
|
|
|
public void noteResumeComponent(ComponentName componentName) {
|
|
enforceCallingPermission();
|
|
String pkgName;
|
|
if ((componentName == null) ||
|
|
((pkgName = componentName.getPackageName()) == null)) {
|
|
return;
|
|
}
|
|
if ((mResumedPkg != null) && (mResumedPkg.equalsIgnoreCase(pkgName))) {
|
|
// Moving across activities in same package. just return
|
|
return;
|
|
}
|
|
if (localLOGV) Log.i(TAG, "started component:"+pkgName);
|
|
synchronized (mStatsLock) {
|
|
PkgUsageStatsExtended pus = mStats.get(pkgName);
|
|
if (pus == null) {
|
|
pus = new PkgUsageStatsExtended();
|
|
mStats.put(pkgName, pus);
|
|
}
|
|
pus.updateResume();
|
|
}
|
|
mResumedPkg = pkgName;
|
|
}
|
|
|
|
public void notePauseComponent(ComponentName componentName) {
|
|
enforceCallingPermission();
|
|
String pkgName;
|
|
if ((componentName == null) ||
|
|
((pkgName = componentName.getPackageName()) == null)) {
|
|
return;
|
|
}
|
|
if ((mResumedPkg == null) || (!pkgName.equalsIgnoreCase(mResumedPkg))) {
|
|
Log.w(TAG, "Something wrong here, Didn't expect "+pkgName+" to be paused");
|
|
return;
|
|
}
|
|
if (localLOGV) Log.i(TAG, "paused component:"+pkgName);
|
|
synchronized (mStatsLock) {
|
|
PkgUsageStatsExtended pus = mStats.get(pkgName);
|
|
if (pus == null) {
|
|
// Weird some error here
|
|
Log.w(TAG, "No package stats for pkg:"+pkgName);
|
|
return;
|
|
}
|
|
pus.updatePause();
|
|
}
|
|
// Persist data to file
|
|
writeStatsToFile();
|
|
}
|
|
|
|
public void enforceCallingPermission() {
|
|
if (Binder.getCallingPid() == Process.myPid()) {
|
|
return;
|
|
}
|
|
mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS,
|
|
Binder.getCallingPid(), Binder.getCallingUid(), null);
|
|
}
|
|
|
|
public PkgUsageStats getPkgUsageStats(ComponentName componentName) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.PACKAGE_USAGE_STATS, null);
|
|
String pkgName;
|
|
if ((componentName == null) ||
|
|
((pkgName = componentName.getPackageName()) == null)) {
|
|
return null;
|
|
}
|
|
synchronized (mStatsLock) {
|
|
PkgUsageStatsExtended pus = mStats.get(pkgName);
|
|
if (pus == null) {
|
|
return null;
|
|
}
|
|
return new PkgUsageStats(pkgName, pus.mLaunchCount, pus.mUsageTime);
|
|
}
|
|
}
|
|
|
|
public PkgUsageStats[] getAllPkgUsageStats() {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.PACKAGE_USAGE_STATS, null);
|
|
synchronized (mStatsLock) {
|
|
Set<String> keys = mStats.keySet();
|
|
int size = keys.size();
|
|
if (size <= 0) {
|
|
return null;
|
|
}
|
|
PkgUsageStats retArr[] = new PkgUsageStats[size];
|
|
int i = 0;
|
|
for (String key: keys) {
|
|
PkgUsageStatsExtended pus = mStats.get(key);
|
|
retArr[i] = new PkgUsageStats(key, pus.mLaunchCount, pus.mUsageTime);
|
|
i++;
|
|
}
|
|
return retArr;
|
|
}
|
|
}
|
|
|
|
static byte[] readFully(FileInputStream stream) throws java.io.IOException {
|
|
int pos = 0;
|
|
int avail = stream.available();
|
|
byte[] data = new byte[avail];
|
|
while (true) {
|
|
int amt = stream.read(data, pos, data.length-pos);
|
|
if (amt <= 0) {
|
|
return data;
|
|
}
|
|
pos += amt;
|
|
avail = stream.available();
|
|
if (avail > data.length-pos) {
|
|
byte[] newData = new byte[pos+avail];
|
|
System.arraycopy(data, 0, newData, 0, pos);
|
|
data = newData;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void collectDumpInfoFLOCK(PrintWriter pw, String[] args) {
|
|
List<String> fileList = getUsageStatsFileListFLOCK();
|
|
if (fileList == null) {
|
|
return;
|
|
}
|
|
final boolean isCheckinRequest = scanArgs(args, "-c");
|
|
Collections.sort(fileList);
|
|
File usageFile = new File(mFilePrefix);
|
|
String dirName = usageFile.getParent();
|
|
File dir = new File(dirName);
|
|
String filePrefix = usageFile.getName();
|
|
// file name followed by dot
|
|
int prefixLen = filePrefix.length()+1;
|
|
String todayStr = getCurrentDateStr(null);
|
|
for (String file : fileList) {
|
|
File dFile = new File(dir, file);
|
|
String dateStr = file.substring(prefixLen);
|
|
try {
|
|
Parcel in = getParcelForFile(dFile);
|
|
collectDumpInfoFromParcelFLOCK(in, pw, dateStr, isCheckinRequest);
|
|
if (isCheckinRequest && !todayStr.equalsIgnoreCase(dateStr)) {
|
|
// Delete old file after collecting info only for checkin requests
|
|
dFile.delete();
|
|
}
|
|
} catch (FileNotFoundException e) {
|
|
Log.w(TAG, "Failed with "+e+" when collecting dump info from file : " + file);
|
|
return;
|
|
} catch (IOException e) {
|
|
Log.w(TAG, "Failed with "+e+" when collecting dump info from file : "+file);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void collectDumpInfoFromParcelFLOCK(Parcel in, PrintWriter pw,
|
|
String date, boolean isCheckinRequest) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("Date:");
|
|
sb.append(date);
|
|
boolean first = true;
|
|
while (in.dataAvail() > 0) {
|
|
String pkgName = in.readString();
|
|
int launchCount = in.readInt();
|
|
long usageTime = in.readLong();
|
|
if (isCheckinRequest) {
|
|
if (!first) {
|
|
sb.append(",");
|
|
}
|
|
sb.append(pkgName);
|
|
sb.append(",");
|
|
sb.append(launchCount);
|
|
sb.append(",");
|
|
sb.append(usageTime);
|
|
sb.append("ms");
|
|
} else {
|
|
if (first) {
|
|
sb.append("\n");
|
|
}
|
|
sb.append("pkg=");
|
|
sb.append(pkgName);
|
|
sb.append(", launchCount=");
|
|
sb.append(launchCount);
|
|
sb.append(", usageTime=");
|
|
sb.append(usageTime);
|
|
sb.append(" ms\n");
|
|
}
|
|
first = false;
|
|
}
|
|
pw.write(sb.toString());
|
|
}
|
|
|
|
/**
|
|
* Searches array of arguments for the specified string
|
|
* @param args array of argument strings
|
|
* @param value value to search for
|
|
* @return true if the value is contained in the array
|
|
*/
|
|
private static boolean scanArgs(String[] args, String value) {
|
|
if (args != null) {
|
|
for (String arg : args) {
|
|
if (value.equals(arg)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
/*
|
|
* The data persisted to file is parsed and the stats are computed.
|
|
*/
|
|
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
|
synchronized (mFileLock) {
|
|
collectDumpInfoFLOCK(pw, args);
|
|
}
|
|
}
|
|
|
|
}
|