Android PackageManager 用法

参考资料：http://blog.csdn.net/qinjuning/article/details/6867806，有改动。

PackageManger的主要职责是管理应用程序包，通过它可以获取应用程序信息。

AnroidManifest.xml文件节点说明：

一 、相关类介绍

1. PackageItemInfo类

AndroidManifest.xml文件中所有节点的基类，并不直接使用，而是由子类继承然后调用相应方法。

常用字段：

int icon             资源图片在R文件中的值 (对应于android:icon属性)
int labelRes         label在R文件中的值(对应于android:label属性)
String name          节点的name值 (对应于android:name属性)
String packagename   应用程序的包名 (对应于android：packagename属性)

常用方法：

Drawable loadIcon(PackageManager pm)          获得当前应用程序的图标
CharSequence loadLabel(PackageManager pm)     获得当前应用程序的label，从上图可知是app_name

PackageItemInfo继承关系图：

2. ActivityInfo类

<activity>或者 <receiver>节点信息 。可获取theme 、launchMode、launchmode等属性

常用方法继承自PackageItemInfo类，下同。

3. ServiceInfo类

<service>节点信息。

4. ApplicationInfo类

<application>节点的信息。

字段说明：

flags字段：
FLAG_SYSTEM　系统应用程序
FLAG_EXTERNAL_STORAGE　表示该应用安装在sdcard中

5. ResolveInfo类

根据<intent-filter>节点获取其上一层目录的信息，通常是<activity>、<receiver>、<service>节点信息。
常用字段：

ActivityInfo activityInfo    获取 ActivityInfo对象，即<activity>或<receiver>节点信息
ServiceInfo serviceInfo     获取 ServiceInfo对象，即<service>节点信息

ApplicationInfo与ResolveInfo比较：前者能够得到Icon、Label、meta-data、description。后者只能得到Icon、Label。

6. PackageInfo类

AndroidManifest.xml文件的信息

常用字段：

String packageName               包名
ActivityInfo[] activities        所有<activity>节点信息
ApplicationInfo applicationInfo  <application>节点信息，只有一个
ActivityInfo[] receivers         所有<receiver>节点信息，多个
ServiceInfo[] services           所有<service>节点信息 ，多个

7. PackageManger 类

通过getPackageManager()方法获得。
常用方法：

PackageManager getPackageManager();
// 获得一个PackageManger对象

Drawable getApplicationIcon(String packageName);
// 返回给定包名的图标，否则返回null

ApplicationInfo getApplicationInfo(String packageName, int flags);
// 返回该ApplicationInfo对象
// flags标记通常直接赋予常数0

List<ApplicationInfo> getInstalledApplications(int flags);
// 返回给定条件的所有ApplicationInfo
// flag为一般为GET_UNINSTALLED_PACKAGES，后续可进一步过滤结果

List<PackageInfo> getInstalledPackages(int flags);
// 返回给定条件的所有PackageInfo

ResolveInfo resolveActivity(Intent intent, int flags);
// 返回给定条件的ResolveInfo对象(本质上是Activity)
// intent 是查询条件，Activity所配置的action和category
// 可选flags：
// MATCH_DEFAULT_ONLY ：Category必须带有CATEGORY_DEFAULT的Activity，才匹配
// GET_INTENT_FILTERS ：匹配Intent条件即可
// GET_RESOLVED_FILTER ：匹配Intent条件即可

List<ResolveInfo> queryIntentActivities(Intent intent, int flags);
// 返回给定条件的所有ResolveInfo对象(本质上是Activity)

ResolveInfo resolveService(Intent intent, int flags);
// 返回给定条件的ResolveInfo对象(本质上是Service)

List<ResolveInfo> queryIntentServices(Intent intent, int flags);
// 返回给定条件的所有ResolveInfo对象(本质上是Service)，集合对象

8. PackageStats 类

安装包的大小信息。AndroidSDK中并没有显式提供方法获得PackageStats对象，只能通过反射机制来调用系统中隐藏的函数(@hide)。

常用字段：

long cachesize      缓存大小
long codesize       应用程序大小
long datasize       数据大小
String packageName  包名

PS:应用程序的总大小 = cachesize + codesize + datasize。

二、常用代码片

1.根据PackageInfo对象获取APP信息：

ApplicationInfo applicationInfo = packageInfo.applicationInfo;
// APP 包名
String packageName = packageInfo.packageName;
// APP icon
Drawable icon = packageManager.getApplicationIcon(applicationInfo);
// APP 名称
String appName = packageManager.getApplicationLabel(applicationInfo).toString();
// APP 权限
String[] permissions = packageManager.getPackageInfo(packageName,PackageManager.GET_PERMISSIONS).requestedPermissions;

2.根据ResolveInfo对象获取APP信息：

// APP包名
resolve.activityInfo.packageName;
// APP icon
resolve.loadIcon(packageManager);
// APP名称
resolve.loadLabel(packageManager).toString();

3.根据包名获取APP中的主Activity：

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.setPackage(packageName);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
List<ResolveInfo> resolveInfos = pManager.queryIntentActivities(intent, 0);
// 一个App中只有一个主Activity，直接取出。注意不是任何包中都有主Activity
String mainActivityName = "";
if (resolveInfos != null && resolveInfos.size() >= 1) {
mainActivityName = resolveInfos.get(0).activityInfo.name;
}

4.根据包名获取APP信息：

PackageManager pManager = context.getPackageManager();
PackageInfo packageInfo = pManager.getPackageInfo(packageName, 0);
ApplicationInfo appInfo = packageInfo.applicationInfo;

// 获取App名
String appName = pManager.getApplicationLabel(appInfo).toString();
//// 也可以使用如下方法
//String appName = appInfo.loadLabel(pManager).toString();
// 获取App Icon
Drawable icon = pManager.getApplicationIcon(appInfo);
//// 也可以用如下两种方法
//Drawable icon = pManager.getApplicationIcon(packageName);
//Drawable icon = appInfo.loadIcon(pManager);
// 获取App versionName
String versionName = packageInfo.versionName; // versionName在xml的根节点中，只能用PackageInfo获取
// 获取权限
PackageInfo pPermissionInfo = pManager.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
String[] permissions = pPermissionInfo.requestedPermissions;

5.批量获取App信息的两种方法：

PackageManager packageManager = getPackageManager();

// 法一：通过解析AndroidManifest.xml的<application>标签中得到，可获取所有的app。
List<ApplicationInfo> applicationList = packageManager
.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);

// 法二：通过Intent查找相关的Activity，更准确，但无法获取Provider等应用
// 通过解析<Intent-filter>标签得到
// <action android:name=”android.intent.action.MAIN”/>
// <action android:name=”android.intent.category.LAUNCHER”/>
Intent intent = new Intent(Intent.ACTION_MAIN, null);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
List<ResolveInfo> resolveList = packageManager.queryIntentActivities(intent, 0);

6.区分系统APP、第三方APP、安装在SDCard上的APP：

/** 判断是不是系统APP **/
// FLAG_SYSTEM = 1<<0，if set, this application is installed in the device's system image.
// 下面&运算有两种结果：
// 1，则flags的末位为1，即系统APP
// 0，则flags的末位为0，即非系统APP
if ( (applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 1 ){
......
}

/** 判断是不是第三方APP **/
// FLAG_SYSTEM = 1<<0，同上
if ( (applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
......
}
//本来是系统程序，被用户手动更新后，该系统程序也成为第三方应用程序了
// FLAG_UPDATED_SYSTEM_APP = 1<<7， this is set if this application has been
// install as an update to a built-in system application.
else if ((applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 1) {
......
}

/** 判断是不是安装在SDCard的应用程序 **/
// FLAG_EXTERNAL_STORAGE = 1<<18，Set to true if the application is
// currently installed on external/removable/unprotected storage
if ( (applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 1) {
......
}

三、工具类

获取APP信息：

/**
* 获取手机上安装的所有APP的信息 配合AppInfo类使用
*/
public class AppInfoUtil {
public static final int GET_ALL_APP = 0; // 所有APP
public static final int GET_SYSTEM_APP = 1; // 系统预装APP
public static final int GET_THIRD_APP = 2; // 第三方APP
public static final int GET_SDCARD_APP = 3; // SDCard的APP

private static AppInfoUtil infoUtil;

private PackageManager pManager;

// 所有应用
private List<PackageInfo> allPackageList;

// 筛选结果
private List<PackageInfo> result;

/** 私有构造器 **/
private AppInfoUtil(Context context) {
pManager = context.getPackageManager();
result = new ArrayList<PackageInfo>();
}

/** 单例 **/
public static AppInfoUtil getInstance(Context context) {
if (infoUtil == null) {
infoUtil = new AppInfoUtil(context);
}
return infoUtil;
}

/** 获取已安装的APP **/
public List<AppInfo> getInstalledApps(int type) {
// 0 表示不接受任何参数。其他参数都带有限制
// 版本号、APP权限只能通过PackageInfo获取，故这里不使用getInstalledApplications()方法
allPackageList = pManager.getInstalledPackages(0);
if (allPackageList == null) {
Log.e("AppInfoUtil类", "getInstalledApps()方法中的allPackageList为空");
return null;
}
// 根据APP名排序
Collections.sort(allPackageList, new PackageInfoComparator(pManager));
// 筛选
result.clear();
switch (type) {
case GET_ALL_APP:
result = allPackageList;
break;
case GET_SYSTEM_APP: // 系统自带APP
for (PackageInfo info : allPackageList) {
// FLAG_SYSTEM = 1<<0，if set, this application is installed in
// the device's system image.
// 下面&运算有两种结果：
// 1，则flags的末位为1，即系统APP
// 0，则flags的末位为0，即非系统APP
if ((info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 1) {
result.add(info);
}
}
break;
case GET_THIRD_APP: // 第三方APP
for (PackageInfo info : allPackageList) {
// FLAG_SYSTEM = 1<<0，同上
if ((info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
result.add(info);
}
// 本来是系统程序，被用户手动更新后，该系统程序也成为第三方应用程序了
// FLAG_UPDATED_SYSTEM_APP = 1<<7， this is set if this
// application has been
// install as an update to a built-in system application.
else if ((info.applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 1) {
result.add(info);
}
}
break;
case GET_SDCARD_APP: // 安装在SDCard的应用程序
for (PackageInfo info : allPackageList) {
// FLAG_EXTERNAL_STORAGE = 1<<18，Set to true if the application
// is
// currently installed on external/removable/unprotected storage
if ((info.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 1) {
result.add(info);
}
}
break;
}
return getAppInfoByPackageInfo(result);
}

public List<AppInfo> getAppInfoByIntent(Intent intent) {
List<ResolveInfo> resolveInfos = pManager.queryIntentActivities(intent,
PackageManager.GET_INTENT_FILTERS);
// 调用系统排序 ， 根据name排序
// 此排序会将系统自带App与用户安装的APP分开排序
Collections.sort(resolveInfos, new ResolveInfo.DisplayNameComparator(
pManager));
// // 此排序会将系统自带App与用户安装的APP混合排序
// Collections.sort(resolveInfos, new DisplayNameComparator(pManager));
return getAppInfobyResolveInfo(resolveInfos);
}

/** 获取单个App图标 **/
public Drawable getAppIcon(String packageName) throws NameNotFoundException {
Drawable icon = pManager.getApplicationIcon(packageName);
return icon;
}

/** 获取单个App名称 **/
public String getAppName(String packageName) throws NameNotFoundException {
ApplicationInfo appInfo = pManager.getApplicationInfo(packageName, 0);
String appName = pManager.getApplicationLabel(appInfo).toString();
return appName;
}

/** 获取单个App版本号 **/
public String getAppVersion(String packageName)
throws NameNotFoundException {
PackageInfo packageInfo = pManager.getPackageInfo(packageName, 0);
String appVersion = packageInfo.versionName;
return appVersion;
}

/** 获取单个App的所有权限 **/
public String[] getAppPermission(String packageName)
throws NameNotFoundException {
PackageInfo packageInfo = pManager.getPackageInfo(packageName,
PackageManager.GET_PERMISSIONS);
String[] permission = packageInfo.requestedPermissions;
return permission;
}

/** 获取单个App的签名 **/
public String getAppSignature(String packageName)
throws NameNotFoundException {
PackageInfo packageInfo = pManager.getPackageInfo(packageName,
PackageManager.GET_SIGNATURES);
String allSignature = packageInfo.signatures[0].toCharsString();
return allSignature;
}

// /** 使用示例 **/
// public static void main(String[] args) {
// AppInfoUtil appInfoUtil = AppInfo.getInstance(context);
//
// // 获取所有APP
// List<AppInfo> allAppInfo = appInfoUtil.getInstalledApps(AppInfoUtil.GET_ALL_APP);
// for (AppInfo app : allAppInfo) {
// String packageName = app.getPackageName();
// String appName = app.getAppName();
// Drawable icon = app.getIcon();
// String versionName = app.getVersionName();
// String[] permissions = app.getPermissions();
// // 自由发挥...
// }
//
// // 获取单个APP的信息
// String appName = appInfoUtil.getAppName(packageName);
// ...
// }

/** 从PackageInfo的List中提取App信息 **/
private List<AppInfo> getAppInfoByPackageInfo(List<PackageInfo> list) {
List<AppInfo> appList = new ArrayList<AppInfo>();
for (PackageInfo info : list) {
// 获取信息
String packageName = info.applicationInfo.packageName;
String appName = pManager.getApplicationLabel(info.applicationInfo)
.toString();
Drawable icon = pManager.getApplicationIcon(info.applicationInfo);
// // 也可以用如下方法获取APP图标，显然更烦琐
// ApplicationInfo applicationInfo =
// pManager.getApplicationInfo(packageName, 0);
// Drawable icon = applicationInfo.loadIcon(pManager);
String versionName = info.versionName;
String[] permissions = info.requestedPermissions;
String launchActivityName = getLaunchActivityName(packageName);
// 储存信息
AppInfo appInfo = new AppInfo();
appInfo.setPackageName(packageName);
appInfo.setAppName(appName);
appInfo.setIcon(icon);
appInfo.setVersionName(versionName);
appInfo.setPermissions(permissions);
appInfo.setLaunchActivityName(launchActivityName);
appList.add(appInfo);
}
return appList;
}

/** 从ResolveInfo的List中提取App信息 **/
private List<AppInfo> getAppInfobyResolveInfo(List<ResolveInfo> list) {
List<AppInfo> appList = new ArrayList<AppInfo>();
for (ResolveInfo info : list) {
String packageName = info.activityInfo.packageName;
String appName = info.loadLabel(pManager).toString();
Drawable icon = info.loadIcon(pManager);
String launchActivityName = getLaunchActivityName(packageName);
AppInfo appInfo = new AppInfo();
appInfo.setPackageName(packageName);
appInfo.setAppName(appName);
appInfo.setIcon(icon);
appInfo.setLaunchActivityName(launchActivityName);
appList.add(appInfo);
}
return appList;
}

/** 获取指定包中主Activity的类名，并不是所有包都有主Activity **/
private String getLaunchActivityName(String packageName) {
// 根据PackageInfo对象取不出其中的主Activity，须用Intent
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.setPackage(packageName);
List<ResolveInfo> resolveInfos = pManager.queryIntentActivities(intent,
0);
String mainActivityName = "";
if (resolveInfos != null && resolveInfos.size() >= 1) {
mainActivityName = resolveInfos.get(0).activityInfo.name;
}
return mainActivityName;
}

/** 此比较器直接复制Android源码，但是却可以把系统APP与用户APP混合排列，何解？ **/
private static class DisplayNameComparator implements
Comparator<ResolveInfo> {
public DisplayNameComparator(PackageManager pm) {
mPM = pm;
}

public final int compare(ResolveInfo a, ResolveInfo b) {
CharSequence sa = a.loadLabel(mPM);
if (sa == null)
sa = a.activityInfo.name;
CharSequence sb = b.loadLabel(mPM);
if (sb == null)
sb = b.activityInfo.name;
return sCollator.compare(sa.toString(), sb.toString());
}

private final Collator sCollator = Collator.getInstance();
private PackageManager mPM;
}

/** 自定义的PackageInfo排序器 **/
private static class PackageInfoComparator implements
Comparator<PackageInfo> {
public PackageInfoComparator(PackageManager pm) {
mPM = pm;
}

public final int compare(PackageInfo a, PackageInfo b) {
CharSequence sa = mPM.getApplicationLabel(a.applicationInfo);
CharSequence sb = mPM.getApplicationLabel(b.applicationInfo);
return sCollator.compare(sa.toString(), sb.toString());
}

private final Collator sCollator = Collator.getInstance();
private PackageManager mPM;
}

}

配套Model，AppInfo.java：

/**
* App信息类
*/
public class AppInfo {
// 包名
private String packageName;
// APP名
private String appName;
// 图标
private Drawable icon;
// 版本号
private String versionName;
// 权限
private String[] permissions;
// 主Activity的类名
private String launchActivityName;

public String getLaunchActivityName() {
return launchActivityName;
}

public void setLaunchActivityName(String launchActivityName) {
this.launchActivityName = launchActivityName;
}

public AppInfo() {}

public String getPackageName() {
return packageName;
}

public void setPackageName(String packageName) {
this.packageName = packageName;
}

public String getAppName() {
return appName;
}

public void setAppName(String appName) {
this.appName = appName;
}

public Drawable getIcon() {
return icon;
}

public void setIcon(Drawable icon) {
this.icon = icon;
}

public String getVersionName() {
return versionName;
}

public void setVersionName(String versionName) {
this.versionName = versionName;
}

public String[] getPermissions() {
return permissions;
}

public void setPermissions(String[] permissions) {
this.permissions = permissions;
};

}

四、通过反射获取APP包的大小

AndroidSDK中并没有显式提供方法获得PackageStats对象，只能通过反射机制来调用系统中隐藏的函数(@hide)。

具体方法如下：

第一步、 通过反射机制调用getPackageSizeInfo() ，方法原型为：

/*
* @param packageName 应用程序包名
* @param observer 当查询包的信息大小操作完成后
* 将回调给IPackageStatsObserver类中的onGetStatsCompleted()方法，
* 并且我们需要的PackageStats对象也封装在其参数里.
* @hide //隐藏函数的标记
*/
public abstract void getPackageSizeInfo(String packageName, IPackageStatsObserver observer);
{
//
}

内部调用流程如下，这个知识点较为复杂，知道即可：

getPackageSizeInfo方法内部调用getPackageSizeInfoLI(packageName, pStats)方法来完成包状态获取。

getPackageSizeInfoLI方法内部调用Installer.getSizeInfo(String pkgName, String apkPath,String fwdLockApkPath, PackageStats

pStats)，继而将包状态信息返回给参数pStats。

getSizeInfo这个方法内部是以本机Socket方式连接到Server，然后向server发送一个文本字符串命令，格式：getsize apkPath fwdLockApkPath 给server。

Server将结果返回，并解析到pStats中。

掌握这个调用知识链即可。

实现代码：

/** 获取指定包的大小信息 **/
public void queryPackageSize(String packageName) throws Exception {
Log.i(TAG, "packageName:" + packageName);
if (packageName != null) {
// 使用反射机制得到PackageManager类的隐藏函数getPackageSizeInfo
PackageManager pManager = getPackageManager();
//通过反射机制获得该隐藏函数
Method getPackageSizeInfo = pManager.getClass().getMethod("getPackageSizeInfo"
, String.class,IPackageStatsObserver.class);
//调用该函数，并且给其分配参数 ，待调用流程完成后会回调PkgSizeObserver类的函数
getPackageSizeInfo.invoke(pManager, packageName,new PkgSizeObserver());
}
}

第二步、由于需要获得系统级的服务或类，我们必须加入Android系统形成的AIDL文件，共两个： IPackageStatsObserver.aidl 和 PackageStats.aidl文件。将它们放置在android.content.pm包路径下。



IPackageStatsObserver.aidl 文件：

package android.content.pm;

import android.content.pm.PackageStats;
/**
* API for package data change related callbacks from the Package Manager.
* Some usage scenarios include deletion of cache directory, generate
* statistics related to code, data, cache usage(TODO)
* {@hide}
*/
oneway interface IPackageStatsObserver {

void onGetStatsCompleted(in PackageStats pStats, boolean succeeded);
}

PackageStats.aidl文件：

package android.content.pm;

parcelable PackageStats;

第三步、创建一个类继承至IPackageStatsObserver.Stub()它本质上实现了Binder机制。当我们把该类的一个实例通过getPackageSizeInfo()调用时，该函数启动中间流程去获取相关包的信息大小，扫描完成后，将查询信息回调至该类的onGetStatsCompleted(PackageStats pStats, boolean succeeded)方法，信息大小封装在此实例上。

实现代码：

/** aidl文件形成的Bindler机制服务类 **/
public class PkgSizeObserver extends IPackageStatsObserver.Stub{
/*** 回调函数，
* @param pStatus ,返回数据封装在PackageStats对象中
* @param succeeded  代表回调成功
*/
@Override
public void onGetStatsCompleted(PackageStats pStats, boolean succeeded) throws RemoteException {
cachesize = pStats.cacheSize; //缓存大小
datasize = pStats.dataSize;  //数据大小
codesize = pStats.codeSize;  //应用程序大小
totalsize = cachesize + datasize + codesize;
}
}

第四步、获取pStats的属性值（代码见上），再转换为对应的以kb/mb为计量单位的字符串。下面代码中，1 << 10是二进制的左移，相当于乘以2的10次方，即乘1024

实现代码：

/** 系统函数，字符串转换**/
private String formateFileSize(long size){
String str = "";
double newSize = 0;
if (size == 0) {
str = "0.00 B";
} else if (size < (1 << 10)) {
newSize = size;
str = newSize + " B";
} else if (size < (1 << 20)){
newSize = 1.0 * size / (1 << 10);
str = String.format("%.2f", newSize) + " KB";
} else if (size < (1 << 30)) {
newSize = 1.0 * size / (1 << 20);
str = String.format("%.2f", newSize) + " MB";
}
return str;
}

为了能够通过反射获取应用程序大小，必须加入以下权限，否则会出现警告且得不到实际值。

<uses-permission android:name="android.permission.GET_PACKAGE_SIZE"></uses-permission>

流程图如下：

五、Demo

代码见笔者的Github：https://github.com/kinglearnjava/AppInfo