/*
* 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);
}
}
}