程序博客网 > 牛津简明英语词典 知乎

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

来源：互联网 发布：牛津简明英语词典 知乎 编辑：程序博客网 时间：2024/06/05 20:16

转载自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加载中...加载中...
  1. private void getPkgUsageStats()
  2. {
  3. IUsageStats statsService = (IUsageStats) IUsageStats.Stub.
  4. asInterface(ServiceManager.getService("usagestats"));
  6. PkgUsageStats[] pkgStats = null;
  7. try {
  8. pkgStats = statsService.getAllPkgUsageStats();
  9. } catch (RemoteException e) {
  10. // TODO Auto-generated catch block
  11. e.printStackTrace();
  12. }
  14. if(pkgStats != null)
  15. {
  16. StringBuffer sb = new StringBuffer();
  17. sb.append("nerver used : ");
  18. for(PkgUsageStats usageStats : pkgStats)
  19. {
  20. String packageName = usageStats.packageName;
  21. int launchCount = usageStats.launchCount;
  22. long usageTime = usageStats.usageTime;
  23. if(launchCount > 0)
  24. Log.v("getPkgUsageStats",packageName + " count: " + launchCount + " time: "
  25. + usageTime);
  26. else{
  27. sb.append(packageName+" ");
  28. }
  29. }
  31. Log.v("getPkgUsageStats",sb.toString());
  32. }
  33. } 





    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)

        我们可以先获取当前系统所有安装包包名，再根据包名逐个通过此方法去获取对应包名的启动次数和运行时间。

0 0
牛津简明英语词典 知乎 牛津简明英语词典 知乎
原创粉丝点击
热门IT博客
mac如何查看ip地址mac如何查看ip地址
爱淘宝网商城女装冬裙爱淘宝网商城女装冬裙
126 imap端口
库里16赛季数据
淘宝店铺详情页模板
阿里云华东2是哪里
软媒win10优化工具
淘宝护肤品店名
时时彩源码什么意思
闹钟提醒软件
淘宝jansport旗舰店
淘宝的费列罗是假货
巅峰软件大全手机
linux shell脚本 echo
云盘源码php
淘宝售假申诉
天猫数据魔方
诺基亚 x309玩java
爱知日语怎么样
淘宝电玩巴士华东总店
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 zozotown大狗欧美zookooidog人 欧美大尺码 欧美大鸟 欧美大屁屁 查看欧美一级大 欧美大黑 欧美大臀 欧美大鸡 欧美日大p 欧美干大黑妞 吊黑 歐美視頻 欧美装 欧美妆 欧美妆图片 你以为的欧美妆 欧美美妆博主 中国人化欧美妆容教程 欧美妆容画法步骤 欧美妆的画法步骤 怎么画欧美妆 网红混血妆化妆教程 混血妆教程 欧美妆容画法 欧美黑妞 欧美金发洋妞 欧美洋妞穴 欧美大码胖妞 欧美大白妞 欧美资 欧美自 欧美瓷砖属几线品牌 欧美姿面膜总代 化妆品欧美姿 欧美姿眼霜 欧美姿价格 欧美姿眼霜怎么样 欧美姿面膜代理价格 欧美姿面膜怎么样 欧美姿洋甘菊 欧美姿化妆品专柜

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里