Android 取得应用程序的启动次数和运行时间等信息

最新推荐文章于 2021-05-27 16:13:34 发布

顾开花

最新推荐文章于 2021-05-27 16:13:34 发布

阅读量631

点赞数

转载自http://www.2cto.com/kf/201501/371519.html

使用情景：最近有个需求是统计后台应用运行时间，如果一个应用在后台运行超过一定时间就Kill掉进程，达到省电的目的。此时就可以使用PkgUsageStats这个类来实现啦！

通过com.android.internal.os.PkgUsageStats这个类可以得到一个应用程序的启动次数，运行时间等信息，功能强大，但是google并没有将这个类作为API接口提供给开发者，如果在android 源码下开发，可以通过以下代码来使用这个类：
import com.android.internal.app.IUsageStats;
import com.android.internal.os.PkgUsageStats;

//比较两个应用程序的启动次数和运行时间
public final int compare(ApplicationInfo a, ApplicationInfo b) {
ComponentName aName = a.intent.getComponent();
ComponentName bName = b.intent.getComponent();
int result = 0;
// get usagestats service
IUsageStats mUsageStatsService = IUsageStats.Stub
.asInterface(ServiceManager.getService("usagestats"));
try {
// get PkgUsageStats
PkgUsageStats aStats = mUsageStatsService.getPkgUsageStats(aName);
PkgUsageStats bStats = mUsageStatsService.getPkgUsageStats(bName);
if (aStats != null && bStats != null) {
if ((aStats.launchCount > bStats.launchCount)
|| ((aStats.launchCount == bStats.launchCount) && (aStats.usageTime > bStats.usageTime)))
result = -1;
else if ((aStats.launchCount < bStats.launchCount)
|| ((aStats.launchCount == bStats.launchCount) && (aStats.usageTime < bStats.usageTime)))
result = 1;
else {
result = 0;
}
} else if (aStats != null && bStats == null) {
result = -1;
} else if (aStats == null && bStats != null) {
result = 1;
}
} catch (RemoteException e) {
Log.i("TAG", "get package usage stats fail");
}
return result;
}

那么如果想在sdk中使用这个类要如果作呢--可以使用反射的方法，代码如下：
public final int compare(ApplicationInfo a, ApplicationInfo b) {
ComponentName aName = a.intent.getComponent();
ComponentName bName = b.intent.getComponent();
int aLaunchCount, bLaunchCount;
long aUseTime, bUseTime;
int result = 0;
try {
// 获得ServiceManager类
Class ServiceManager = Class
.forName("android.os.ServiceManager");
// 获得ServiceManager的getService方法
Method getService = ServiceManager.getMethod("getService",
java.lang.String.class);
// 调用getService获取RemoteService
Object oRemoteService = getService.invoke(null, "usagestats");
// 获得IUsageStats.Stub类
Class cStub = Class
.forName("com.android.internal.app.IUsageStats$Stub");
// 获得asInterface方法
Method asInterface = cStub.getMethod("asInterface",
android.os.IBinder.class);
// 调用asInterface方法获取IUsageStats对象
Object oIUsageStats = asInterface.invoke(null, oRemoteService);
// 获得getPkgUsageStats(ComponentName)方法
Method getPkgUsageStats = oIUsageStats.getClass().getMethod(
"getPkgUsageStats", ComponentName.class);
// 调用getPkgUsageStats 获取PkgUsageStats对象
Object aStats = getPkgUsageStats.invoke(oIUsageStats, aName);
Object bStats = getPkgUsageStats.invoke(oIUsageStats, bName);
// 获得PkgUsageStats类
Class PkgUsageStats = Class
.forName("com.android.internal.os.PkgUsageStats");
aLaunchCount = PkgUsageStats.getDeclaredField("launchCount")
.getInt(aStats);
bLaunchCount = PkgUsageStats.getDeclaredField("launchCount")
.getInt(bStats);
aUseTime = PkgUsageStats.getDeclaredField("usageTime").getLong(
aStats);
bUseTime = PkgUsageStats.getDeclaredField("usageTime").getLong(
bStats);
if ((aLaunchCount > bLaunchCount)
|| ((aLaunchCount == bLaunchCount) && (aUseTime > bUseTime)))
result = 1;
else if ((aLaunchCount < bLaunchCount)
|| ((aLaunchCount == bLaunchCount) && (aUseTime < bUseTime)))
result = -1;
else {
result = 0;
}
} catch (Exception e) {
Log.e("###", e.toString(), e);
}
return result;
}

如何看自己的android的详细使用信息：
我们使用Andoroid手机时想看看自己的手机的使用情况，那么我们又如何去操作呢？也是必需得像程序这样要自己写一个程序才能查看吧，如果用户不是编程的，那得怎么办，呵，其实我们查看自己的手机使用详情是没有那么复杂的，今天androidkaifa.com就会大家说一下如何查询自己的手机的使用情况，下面是具体的查看方法，
其实查看方法非常简单，直接进入 Android 的工程模式即可，操作步骤如下：（笔者的android手机系统是4.2）
1、首先进入Android手机操作系统的拨号界面，直接输入“*#*#4636#*#*”（不加引号）即可以快速进入Android操作系统的工程测试模式。
2、在“测试”模式菜单中有手机信息“Phone information”、电池信息“Battery information”、WI-FI信息“WI-FI information”、使用状态“Usage statistics”四个选项。
3、我们点击选择第二项“Battery information”进入电池信息，然后就可以看到手机电池的详细信息了，其中包括电量等级、电池状态、温度、电池材质、电压等等信息。
4: 我们相应点击其实的选择就可以看到其实的相应的使用详细信息
==================================================================================================================
import com.android.internal.app.IUsageStats;
import com.android.settings.R;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Bundle;
import android.os.RemoteException;
import android.os.ServiceManager;
import com.android.internal.os.PkgUsageStats;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.AdapterView.OnItemSelectedListener;

/**
* Activity to display package usage statistics.
*/
public class UsageStats extends Activity implements OnItemSelectedListener {
private static final String TAG="UsageStatsActivity";
private static final boolean localLOGV = true;
private Spinner mTypeSpinner;
private ListView mListView;
private IUsageStats mUsageStatsService;
private LayoutInflater mInflater;
private UsageStatsAdapter mAdapter;
private PackageManager mPm;

public static class AppNameComparator implements Comparator {
Map mAppLabelList;
AppNameComparator(Map appList) {
mAppLabelList = appList;
}
public final int compare(PkgUsageStats a, PkgUsageStats b) {
String alabel = mAppLabelList.get(a.packageName).toString();
String blabel = mAppLabelList.get(b.packageName).toString();
return alabel.compareTo(blabel);
}
}

public static class LaunchCountComparator implements Comparator {
public final int compare(PkgUsageStats a, PkgUsageStats b) {
// return by descending order
return b.launchCount - a.launchCount;
}
}

public static class UsageTimeComparator implements Comparator {
public final int compare(PkgUsageStats a, PkgUsageStats b) {
long ret = a.usageTime-b.usageTime;
if (ret == 0) {
return 0;
}
if (ret < 0) {
return 1;
}
return -1;
}
}

// View Holder used when displaying views
static class AppViewHolder {
TextView pkgName;
TextView launchCount;
TextView usageTime;
}

class UsageStatsAdapter extends BaseAdapter {
// Constants defining order for display order
private static final int _DISPLAY_ORDER_USAGE_TIME = 0;
private static final int _DISPLAY_ORDER_LAUNCH_COUNT = 1;
private static final int _DISPLAY_ORDER_APP_NAME = 2;

private int mDisplayOrder = _DISPLAY_ORDER_USAGE_TIME;
private List mUsageStats;
private LaunchCountComparator mLaunchCountComparator;
private UsageTimeComparator mUsageTimeComparator;
private AppNameComparator mAppLabelComparator;
private HashMap mAppLabelMap;

UsageStatsAdapter() {
mUsageStats = new ArrayList();
mAppLabelMap = new HashMap();
PkgUsageStats[] stats;
try {
stats = mUsageStatsService.getAllPkgUsageStats();
} catch (RemoteException e) {
Log.e(TAG, "Failed initializing usage stats service");
return;
}
if (stats == null) {
return;
}
for (PkgUsageStats ps : stats) {
mUsageStats.add(ps);
// load application labels for each application
CharSequence label;
try {
ApplicationInfo appInfo = mPm.getApplicationInfo(ps.packageName, 0);
label = appInfo.loadLabel(mPm);
} catch (NameNotFoundException e) {
label = ps.packageName;
}
mAppLabelMap.put(ps.packageName, label);
}
// Sort list
mLaunchCountComparator = new LaunchCountComparator();
mUsageTimeComparator = new UsageTimeComparator();
mAppLabelComparator = new AppNameComparator(mAppLabelMap);
sortList();
}
public int getCount() {
return mUsageStats.size();
}

public Object getItem(int position) {
return mUsageStats.get(position);
}

public long getItemId(int position) {
return position;
}

public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unneccessary calls
// to findViewById() on each row.
AppViewHolder holder;

// When convertView is not null, we can reuse it directly, there is no need
// to reinflate it. We only inflate a new View when the convertView supplied
// by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(R.layout.usage_stats_item, null);

// Creates a ViewHolder and store references to the two children views
// we want to bind data to.
holder = new AppViewHolder();
holder.pkgName = (TextView) convertView.findViewById(R.id.package_name);
holder.launchCount = (TextView) convertView.findViewById(R.id.launch_count);
holder.usageTime = (TextView) convertView.findViewById(R.id.usage_time);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (AppViewHolder) convertView.getTag();
}

// Bind the data efficiently with the holder
PkgUsageStats pkgStats = mUsageStats.get(position);
if (pkgStats != null) {
CharSequence label = mAppLabelMap.get(pkgStats.packageName);
holder.pkgName.setText(label);
holder.launchCount.setText(String.valueOf(pkgStats.launchCount));
holder.usageTime.setText(String.valueOf(pkgStats.usageTime)+" ms");
} else {
Log.w(TAG, "No usage stats info for package:" + position);
}
return convertView;
}

void sortList(int sortOrder) {
if (mDisplayOrder == sortOrder) {
// do nothing
return;
}
mDisplayOrder= sortOrder;
sortList();
}
private void sortList() {
if (mDisplayOrder == _DISPLAY_ORDER_USAGE_TIME) {
if (localLOGV) Log.i(TAG, "Sorting by usage time");
Collections.sort(mUsageStats, mUsageTimeComparator);
} else if (mDisplayOrder == _DISPLAY_ORDER_LAUNCH_COUNT) {
if (localLOGV) Log.i(TAG, "Sorting launch count");
Collections.sort(mUsageStats, mLaunchCountComparator);
} else if (mDisplayOrder == _DISPLAY_ORDER_APP_NAME) {
if (localLOGV) Log.i(TAG, "Sorting by application name");
Collections.sort(mUsageStats, mAppLabelComparator);
}
notifyDataSetChanged();
}
}

/** Called when the activity is first created. */
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
mUsageStatsService = IUsageStats.Stub.asInterface(ServiceManager.getService("usagestats"));
if (mUsageStatsService == null) {
Log.e(TAG, "Failed to retrieve usagestats service");
return;
}
mInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
mPm = getPackageManager();

setContentView(R.layout.usage_stats);
mTypeSpinner = (Spinner) findViewById(R.id.typeSpinner);
mTypeSpinner.setOnItemSelectedListener(this);

mListView = (ListView) findViewById(R.id.pkg_list);
// Initialize the inflater

mAdapter = new UsageStatsAdapter();
mListView.setAdapter(mAdapter);
}

public void onItemSelected(AdapterView parent, View view, int position,
long id) {
mAdapter.sortList(position);
}

public void onNothingSelected(AdapterView parent) {
// do nothing
}
}

================================================================================

来源网络：

android本身有PkgUsageStats等相关类来统计应用使用情况，但这些类在SDK不公开，只能通过反射或者在源码环境下才能访问到。所以，针对这一特点，如果需要获取应用使用信息，可以采取反射或者源码下开发这两种方式。

1、在源码环境下（源码环境下可以访问一些标记为hide的方法），代码如下：

[java] view plaincopy 加载中...

private void getPkgUsageStats()
{
IUsageStats statsService = (IUsageStats) IUsageStats.Stub.
asInterface(ServiceManager.getService("usagestats"));
PkgUsageStats[] pkgStats = null;
try {
pkgStats = statsService.getAllPkgUsageStats();
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(pkgStats != null)
{
StringBuffer sb = new StringBuffer();
sb.append("nerver used : ");
for(PkgUsageStats usageStats : pkgStats)
{
String packageName = usageStats.packageName;
int launchCount = usageStats.launchCount;
long usageTime = usageStats.usageTime;
if(launchCount > 0)
Log.v("getPkgUsageStats",packageName + " count: " + launchCount + " time: "
+ usageTime);
else{
sb.append(packageName+" ");
}
}
Log.v("getPkgUsageStats",sb.toString());
}
}

2、通过反射来调用，代码如下：
[java] view plaincopy
1. /**
2. * Use reflect to get Package Usage Statistics data.
3. */
4. public static void getPkgUsageStats() {
5. LogUtils.d(TAG, "[getPkgUsageStats]");
6. try {
7. Class cServiceManager = Class
8. .forName("android.os.ServiceManager");
9. Method mGetService = cServiceManager.getMethod("getService",
10. java.lang.String.class);
11. Object oRemoteService = mGetService.invoke(null, "usagestats");
13. // IUsageStats oIUsageStats =
14. // IUsageStats.Stub.asInterface(oRemoteService)
15. Class cStub = Class
16. .forName("com.android.internal.app.IUsageStats$Stub");
17. Method mUsageStatsService = cStub.getMethod("asInterface",
18. android.os.IBinder.class);
19. Object oIUsageStats = mUsageStatsService.invoke(null,
20. oRemoteService);
22. // PkgUsageStats[] oPkgUsageStatsArray =
23. // mUsageStatsService.getAllPkgUsageStats();
24. Class cIUsageStatus = Class
25. .forName("com.android.internal.app.IUsageStats");
26. Method mGetAllPkgUsageStats = cIUsageStatus.getMethod(
27. "getAllPkgUsageStats", (Class[]) null);
28. Object[] oPkgUsageStatsArray = (Object[]) mGetAllPkgUsageStats
29. .invoke(oIUsageStats, (Object[]) null);
30. LogUtils.d(TAG, "[getPkgUsageStats] oPkgUsageStatsArray = "+oPkgUsageStatsArray);
32. Class cPkgUsageStats = Class
33. .forName("com.android.internal.os.PkgUsageStats");
35. StringBuffer sb = new StringBuffer();
36. sb.append("nerver used : ");
37. for (Object pkgUsageStats : oPkgUsageStatsArray) {
38. // get pkgUsageStats.packageName, pkgUsageStats.launchCount,
39. // pkgUsageStats.usageTime
40. String packageName = (String) cPkgUsageStats.getDeclaredField(
41. "packageName").get(pkgUsageStats);
42. int launchCount = cPkgUsageStats
43. .getDeclaredField("launchCount").getInt(pkgUsageStats);
44. long usageTime = cPkgUsageStats.getDeclaredField("usageTime")
45. .getLong(pkgUsageStats);
46. if (launchCount > 0)
47. LogUtils.d(TAG, "[getPkgUsageStats] "+ packageName + " count: "
48. + launchCount + " time: " + usageTime);
49. else {
50. sb.append(packageName + "; ");
51. }
52. }
53. LogUtils.d(TAG, "[getPkgUsageStats] " + sb.toString());
54. } catch (IllegalArgumentException e) {
55. e.printStackTrace();
56. } catch (IllegalAccessException e) {
57. e.printStackTrace();
58. } catch (InvocationTargetException e) {
59. e.printStackTrace();
60. } catch (NoSuchFieldException e) {
61. e.printStackTrace();
62. } catch (ClassNotFoundException e) {
63. e.printStackTrace();
64. } catch (NoSuchMethodException e) {
65. e.printStackTrace();
66. }
67. }
  
  这是获取信息的两种实现方式，另外，要想让程序能够正常运行并成功获取到数据，我们还需要做如下的配置：
  1、在AndroidManifest.xml中增加android:sharedUserId="android.uid.system"
  <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  package="com.xxx"
  android:versionCode="1"
  android:versionName="1.0"
  android:sharedUserId="android.uid.system" >
  还有权限的声明
  
  2、对apk进行系统签名，在源码中取platform.pk8、platform.x509.pem、signapk.jar文件并通过如下命令实现apk的签名
  java -jar signapk.jar platform.x509.pem platform.pk8 unsigned.apk signed.apk
  
  unsigned.apk为签名之前的apk，signed.apk为通过命令签名成功的apk
  
  补充：
  
  UsageStats信息通过UsageStatsService保存在路径data/system/usagestats目录下，在系统启动后，UsageStatsService服务开启，在该Service的构造函数中调用readStatsFromFile()方法从本地获取UsageStats信息，并保存到mStats成员变量中。（见源码UsageStatsService.java）
  
  我们通过getAllPkgUsageStats()方法来获取信息，但是该方法所返回的信息并非从文件中读取的全部数据，而是开机后启动过的apk集合，代码如下：
  
  [java] view plaincopy
  1. public PkgUsageStats[] getAllPkgUsageStats() {
  2. mContext.enforceCallingOrSelfPermission(
  3. android.Manifest.permission.PACKAGE_USAGE_STATS, null);
  4. synchronized (mStatsLock) {
  5. int size = mLastResumeTimes.size();
  6. if (size <= 0) {
  7. return null;
  8. }
  9. PkgUsageStats retArr[] = new PkgUsageStats[size];
  10. int i = 0;
  11. for (Map.Entry<string, map> entry : mLastResumeTimes.entrySet()) {
  12. String pkg = entry.getKey();
  13. long usageTime = 0;
  14. int launchCount = 0;
  16. PkgUsageStatsExtended pus = mStats.get(pkg);
  17. if (pus != null) {
  18. usageTime = pus.mUsageTime;
  19. launchCount = pus.mLaunchCount;
  20. }
  21. retArr[i] = new PkgUsageStats(pkg, launchCount, usageTime, entry.getValue());
  22. i++;
  23. }
  24. return retArr;
  25. }
  26. }
    
    所以根据以上方法仅能获取开机后被启动过的apk信息集合，那如何获取所有apk的信息集合呢？该Service提供有另一个方法：
    
    public PkgUsageStats getPkgUsageStats(ComponentName componentName)
    
    我们可以先获取当前系统所有安装包包名，再根据包名逐个通过此方法去获取对应包名的启动次数和运行时间。