获取手机已经安装的所有App的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/**
 * 已安装应用的实例类,应用的消息类
 * @author luckchoudog
 */
public class AppInfo {

	private String appLabel; // 应用程序标签(应用名称)
	private Drawable appIcon; // 应用程序图像
	private String pkgName; // 应用程序所对应的包名

	private long cachesize; // 缓存大小
	private long datasize; // 数据大小
	private long codesieze; // 应用程序大小
	private boolean isSizeKnow = false; // 应用程序大小是否获取成功false表示不知道

	public long getCachesize() {
		return cachesize;
	}

	public void setCachesize(long cachesize) {
		this.cachesize = cachesize;
	}

	public long getDatasize() {
		return datasize;
	}

	public void setDatasize(long datasize) {
		this.datasize = datasize;
	}

	public long getCodesieze() {
		return codesieze;
	}

	public void setCodesieze(long codesieze) {
		this.codesieze = codesieze;
	}

	public AppInfo() {
	}

	public String getAppLabel() {
		return appLabel;
	}

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

	public Drawable getAppIcon() {
		return appIcon;
	}

	public void setAppIcon(Drawable appIcon) {
		this.appIcon = appIcon;
	}

	public String getPkgName() {
		return pkgName;
	}

	public void setPkgName(String pkgName) {
		this.pkgName = pkgName;
	}

	public boolean getIsSizeKnow() {
		return isSizeKnow;
	}

	public void setIsSizeKnow(boolean isSizeKnow) {
		this.isSizeKnow = isSizeKnow;
	}

	@Override
	public String toString() {
		return "AppInfo [appLabel=" + appLabel + ", appIcon=" + appIcon
				+ ", pkgName=" + pkgName + ", cachesize=" + cachesize
				+ ", datasize=" + datasize + ", codesieze=" + codesieze
				+ ", isSizeKnow=" + isSizeKnow + "]";
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
/**
 * 获取App信息的类,包括获取当前App信息和安装包的信息
 * <pre>
 * 信息包括其中有：
 * 安装包名称,安装包包名称,安装包版本信息,安装包图标
 * </pre>
 * @author luckchoudog
 */
public class GetAppMsg {
	/**
	 * 获取当前App版本号
	 * 
	 * @return 当前应用的版本号
	 */
	public static String getVersion(Context context) {
		try {
			PackageManager manager = context.getPackageManager();
			PackageInfo info = manager.getPackageInfo(context.getPackageName(),
					0);
			String version = info.versionName;
			return version;
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 获取当前App名称
	 * 
	 * @return 当前应用的App名称
	 */
	public static String getAppName(Context context) {
		try {
			PackageManager manager = context.getPackageManager();
			PackageInfo info = manager.getPackageInfo(context.getPackageName(),
					0);
			ApplicationInfo appInfo = info.applicationInfo;
			String appName = manager.getApplicationLabel(appInfo).toString();
			return appName;
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 获取当前App包名称
	 * 
	 * @return 当前应用的App包名称
	 */
	public static String getPackageName(Context context) {
		try {
			PackageManager manager = context.getPackageManager();
			PackageInfo info = manager.getPackageInfo(context.getPackageName(),
					0);
			String packageName = info.packageName;
			return packageName;
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 获取当前App的Ico
	 * 
	 * @return 当前应用的Ico
	 */
	public static Drawable getIcon(Context context) {
		try {
			PackageManager manager = context.getPackageManager();
			PackageInfo info = manager.getPackageInfo(context.getPackageName(),
					0);
			ApplicationInfo appInfo = info.applicationInfo;
			Drawable icon = manager.getApplicationIcon(appInfo);
			return icon;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取任何安装包App信息
	 * 
	 * @param context
	 *            上下文
	 * @param appDir
	 *            安装包包的路径,比如说下载在SD卡上的一个安装包
	 * @return 
	 *         包含安装包App信息的HashMap,其中有AppName(安装包名称),AppPackageName(安装包包名称),AppVersion
	 *         (安装包版本信息),AppIcon(安装包图标)
	 */
	public HashMap<String, Object> getAppMsg(Context context, String appDir) {
		HashMap<String, Object> result = new HashMap<String, Object>();
		PackageManager pm = context.getPackageManager();
		PackageInfo info = pm.getPackageArchiveInfo(appDir,
				PackageManager.GET_ACTIVITIES);
		if (info != null) {
			ApplicationInfo appInfo = info.applicationInfo;
			String appName = pm.getApplicationLabel(appInfo).toString();
			String packageName = appInfo.packageName;
			String version = info.versionName;
			Drawable icon = pm.getApplicationIcon(appInfo);
			result.put("AppName", appName);
			result.put("AppPackageName", packageName);
			result.put("AppVersion", version);
			result.put("AppIcon", icon);
		}
		return result;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
/**
 * 获取设备所有已经安装的应用
 * @author luckchoudog
 */
public class GetApps {
	private String TAG = GetApps.class.getSimpleName();
	private AppInfo mAppInfo;

	public GetApps() {
		mAppInfo = new AppInfo();
	}

	/**
	 * 获取app的大小
	 * 
	 * @param context
	 * @param app
	 *            想要获取大小的app
	 * @return AppInfo
	 */
	public void getAppSizeInfo(Context context, AppInfo app) {
		Logger.d(TAG, "getAppSizeInfo ~ start");
		if (null == app.getPkgName() || "".equals(app.getPkgName())) {
			Logger.d(TAG, "getAppSizeInfo ~ end1");
			return;
		}
		this.mAppInfo = app;
		PackageManager pm = context.getPackageManager();
		try {
			Method getPackageSizeInfo = pm.getClass().getMethod(
					"getPackageSizeInfo", String.class,
					IPackageStatsObserver.class);
			getPackageSizeInfo.invoke(pm, app.getPkgName(),
					new PkgSizeObserver());
		} catch (Exception e) {
			Logger.e(TAG, "getAppSizeInfo ~ error",e);
		}
	}

	class PkgSizeObserver extends IPackageStatsObserver.Stub {
		public void onGetStatsCompleted(PackageStats pStats, boolean succeeded) {
			if (pStats != null) {
				mAppInfo.setCodesieze(pStats.codeSize);// 应用程序大小
				mAppInfo.setCachesize(pStats.cacheSize);// 缓存大小
				mAppInfo.setDatasize(pStats.dataSize);// 数据大小
				mAppInfo.setIsSizeKnow(true);
			}
		}
	}

	/**
	 * 获取手机所有程序列表
	 * 
	 * @param context
	 * @return 返回手机已经安装的Applist
	 */
	public List<AppInfo> getPhoneAppList(Context context) {
		Logger.d(TAG, "getPhoneAppList ~ start");
		PackageManager packageManager = context.getPackageManager();
		List<AppInfo> list = new ArrayList<AppInfo>();
		// 获取手机所有应用
		List<PackageInfo> temp = packageManager.getInstalledPackages(0);
		AppInfo tempAppInfo;
		for (PackageInfo packageInfo : temp) {
			tempAppInfo = new AppInfo();
			// 获取图标
			tempAppInfo.setAppIcon(packageInfo.applicationInfo
					.loadIcon(packageManager));
			// 获取应用名称
			tempAppInfo.setAppLabel(packageInfo.applicationInfo.loadLabel(
					packageManager).toString());
			// 获取应用安装路径
			tempAppInfo.setPkgName(packageInfo.applicationInfo.packageName);
			getAppSizeInfo(context, tempAppInfo);
			list.add(tempAppInfo);
		}
		Logger.d(TAG, "getPhoneAppList ~ end");
		return list;
	}

	/**
	 * 获取手机正在运行列表
	 * 
	 * @param context
	 * @return 所有正在运行的Applist
	 */
	public List<AppInfo> getRunningProcess(Context context) {
		Logger.d(TAG, "getRunningProcess ~ start");
		PackageManager packageManager = context.getPackageManager();
		List<AppInfo> list = new ArrayList<AppInfo>();
		ActivityManager am = (ActivityManager) context
				.getSystemService("activity");
		// 获取正在运行的应用
		List<RunningAppProcessInfo> run = am.getRunningAppProcesses();
		List<ApplicationInfo> temp = packageManager
				.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
		for (int i = 0; i < run.size(); i++) {
			// 这里主要是过滤系统的应用和电话应用，当然你也可以把它注释掉。
			if (run.get(i).processName.equals("system")
					|| run.get(i).processName.equals("com.android.phone")) {
				continue;
			}
			AppInfo tempAppInfo;
			for (int j = 0; j < temp.size(); j++) {
				if (temp.get(j).processName.equals(run.get(i).processName)) {
					tempAppInfo = new AppInfo();
					tempAppInfo
							.setAppIcon(temp.get(j).loadIcon(packageManager));
					tempAppInfo.setAppLabel((String) temp.get(j).loadLabel(
							packageManager));
					tempAppInfo.setPkgName(temp.get(j).packageName);
					getAppSizeInfo(context, tempAppInfo);
					list.add(tempAppInfo);
				}
			}
		}
		Logger.d(TAG, "getRunningProcess ~ end");
		return list;
	}

	/**
	 * 获取系统应用
	 * 
	 * @param context
	 * @return
	 */
	public List<AppInfo> getSystemApp(Context context) {
		Logger.d(TAG, "getSystemApp ~ start");
		PackageManager packageManager = context.getPackageManager();
		List<AppInfo> list = new ArrayList<AppInfo>();
		List<ApplicationInfo> temp = packageManager
				.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
		AppInfo tempAppInfo;
		for (int i = 0; i < temp.size(); i++) {
			if ((temp.get(i).flags & ApplicationInfo.FLAG_SYSTEM) == 1) {
				tempAppInfo = new AppInfo();
				tempAppInfo.setAppIcon(temp.get(i).loadIcon(packageManager));
				tempAppInfo.setAppLabel(temp.get(i).processName);
				tempAppInfo.setPkgName(temp.get(i).packageName);
				getAppSizeInfo(context, tempAppInfo);
				list.add(tempAppInfo);
			}
		}
		Logger.d(TAG, "getSystemApp ~ end");
		return list;
	}

	/**
	 * 获取安装在SD卡上的App
	 * 
	 * @param context
	 * @return
	 */
	public List<AppInfo> getSDCardApp(Context context) {
		Logger.d(TAG, "getSDCardApp ~ start");
		PackageManager packageManager = context.getPackageManager();
		List<AppInfo> list = new ArrayList<AppInfo>();
		List<ApplicationInfo> temp = packageManager
				.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
		AppInfo tempAppInfo;
		for (int i = 0; i < temp.size(); i++) {
			if ((temp.get(i).flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0) {
				tempAppInfo = new AppInfo();
				tempAppInfo.setAppIcon(temp.get(i).loadIcon(packageManager));
				tempAppInfo.setAppLabel(temp.get(i).processName);
				tempAppInfo.setPkgName(temp.get(i).packageName);
				getAppSizeInfo(context, tempAppInfo);
				list.add(tempAppInfo);
			}
		}
		Logger.d(TAG, "getSDCardApp ~ end");
		return list;
	}

	/**
	 * 获取设备上的第三方App
	 * 
	 * @param context
	 * @return
	 */
	public List<AppInfo> getThirdApp(Context context) {
		Logger.d(TAG, "getThirdApp ~ start");
		PackageManager packageManager = context.getPackageManager();
		List<AppInfo> list = new ArrayList<AppInfo>();
		List<ApplicationInfo> temp = packageManager
				.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
		AppInfo tempAppInfo;
		for (int i = 0; i < temp.size(); i++) {
			if ((temp.get(i).flags & ApplicationInfo.FLAG_SYSTEM) <= 0) {
				tempAppInfo = new AppInfo();
				tempAppInfo.setAppIcon(temp.get(i).loadIcon(packageManager));
				tempAppInfo.setAppLabel(temp.get(i).processName);
				tempAppInfo.setPkgName(temp.get(i).packageName);
				getAppSizeInfo(context, tempAppInfo);
				list.add(tempAppInfo);
			}
		}
		Logger.d(TAG, "getThirdApp ~ end");
		return list;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
 * 启动卸载某个App
 * @author luckchoudog
 */
public class StarUninstallApp {
	/**
	 * 卸载某个APP
	 * 
	 * @param context
	 * @param packageName
	 *            app的包名
	 */
	public void uninstallApp(Context context, String packageName) {
		Uri uri = Uri.parse("package:" + packageName);
		Intent intent = new Intent(Intent.ACTION_DELETE, uri);
		context.startActivity(intent);
	}

	/**
	 * 通过包名启动其他已经安装的程序
	 * 
	 * @param context
	 * @param packageName
	 *            已经安装的app的包名
	 * @throws Exception
	 *             包名不存在异常
	 */
	public void openAPP(Context context, String packageName) throws Exception {
		PackageManager packageManager = context.getPackageManager();
		Intent intent = new Intent();
		intent = packageManager.getLaunchIntentForPackage(packageName);
		context.startActivity(intent);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
/**
 * 数据清除管理器 描述: 主要功能有清除内/外缓存，清除数据库，清除sharedPreference，清除files和清除自定义目录
 * @author luckchoudog
 */
public class DataCleanManager {
	/**
	 * 清除本应用内部缓存(/data/data/com.xxx.xxx/cache)
	 */
	public static void cleanInternalCache(Context context) {
		deleteFilesByDirectory(context.getCacheDir());
	}

	/**
	 * 清除本应用所有数据库(/data/data/com.xxx.xxx/databases)
	 */
	@SuppressLint("SdCardPath")
	public static void cleanDatabases(Context context) {
		deleteFilesByDirectory(new File("/data/data/" + context.getPackageName() + "/databases"));
	}

	/**
	 * 清除本应用SharedPreference(/data/data/com.xxx.xxx/shared_prefs)
	 */
	@SuppressLint("SdCardPath")
	public static void cleanSharedPreference(Context context) {
		deleteFilesByDirectory(new File("/data/data/" + context.getPackageName() + "/shared_prefs"));
	}

	/**
	 * 按名字清除本应用数据库
	 * 
	 * @param context
	 * @param dbName
	 */
	public static void cleanDatabaseByName(Context context, String dbName) {
		context.deleteDatabase(dbName);
	}

	/**
	 * 清除/data/data/com.xxx.xxx/files下的内容
	 */
	public static void cleanFiles(Context context) {
		deleteFilesByDirectory(context.getFilesDir());
	}

	/**
	 * 清除外部cache下的内容(/mnt/sdcard/android/data/com.xxx.xxx/cache)
	 */
	public static void cleanExternalCache(Context context) {
		if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
			deleteFilesByDirectory(context.getExternalCacheDir());
		}
	}

	/**
	 * 清除自定义路径下的文件，使用需小心，请不要误删。而且只支持目录下的文件删除
	 * 
	 * @param filePath
	 */
	public static void cleanCustomCache(String filePath) {
		deleteFilesByDirectory(new File(filePath));
	}

	/**
	 * 清除本应用所有的数据
	 * 
	 * @param context
	 * @param filepath
	 */
	public static void cleanApplicationData(Context context, String... filepath) {
		cleanInternalCache(context);
		cleanExternalCache(context);
		cleanDatabases(context);
		cleanSharedPreference(context);
		cleanFiles(context);
		if (filepath == null) {
			return;
		}
		for (String filePath : filepath) {
			cleanCustomCache(filePath);
		}
	}

	/**
	 * 删除方法 这里只会删除某个文件夹下的文件，如果传入的directory是个文件，将不做处理
	 * 
	 * @param directory
	 */
	private static void deleteFilesByDirectory(File directory) {
		if (directory != null && directory.exists() && directory.isDirectory()) {
			for (File item : directory.listFiles()) {
				item.delete();
			}
		}
	}

	/**
	 * 获取文件的大小
	 * 
	 * @param file
	 * @return
	 * @throws Exception
	 */
	public static long getFolderSize(File file) throws Exception {
		long size = 0;
		try {
			File[] fileList = file.listFiles();
			for (int i = 0; i < fileList.length; i++) {
				// 如果下面还有文件
				if (fileList[i].isDirectory()) {
					size = size + getFolderSize(fileList[i]);
				} else {
					size = size + fileList[i].length();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return size;
	}

	/**
	 * 删除指定目录下文件及目录
	 * 
	 * @param deleteThisPath
	 * @param filepath
	 * @return
	 */
	public static void deleteFolderFile(String filePath, boolean deleteThisPath) {
		if (!TextUtils.isEmpty(filePath)) {
			try {
				File file = new File(filePath);
				if (file.isDirectory()) {// 如果下面还有文件
					File files[] = file.listFiles();
					for (int i = 0; i < files.length; i++) {
						deleteFolderFile(files[i].getAbsolutePath(), true);
					}
				}
				if (deleteThisPath) {
					if (!file.isDirectory()) {// 如果是文件，删除
						file.delete();
					} else {// 目录
						if (file.listFiles().length == 0) {// 目录下没有文件或者目录，删除
							file.delete();
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 格式化单位
	 * 
	 * @param size
	 * @return
	 */
	public static String getFormatSize(double size) {
		double kiloByte = size / 1024;
		if (kiloByte < 1) {
			return size + "Byte";
		}

		double megaByte = kiloByte / 1024;
		if (megaByte < 1) {
			BigDecimal result1 = new BigDecimal(Double.toString(kiloByte));
			return result1.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "KB";
		}

		double gigaByte = megaByte / 1024;
		if (gigaByte < 1) {
			BigDecimal result2 = new BigDecimal(Double.toString(megaByte));
			return result2.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "MB";
		}

		double teraBytes = gigaByte / 1024;
		if (teraBytes < 1) {
			BigDecimal result3 = new BigDecimal(Double.toString(gigaByte));
			return result3.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "GB";
		}
		BigDecimal result4 = new BigDecimal(teraBytes);
		return result4.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "TB";
	}
}