批量安装于卸载

有尝试过在Android手机里批量安装于批量卸载你的应用程序吗，现在就简单教你怎么做，其实很简单，还有后台安装于卸载问题：

1.后台安装于卸载步骤：

首先你需要使用其Pm命令，如一下

1. pm install [-l] [-r] [-t] [-i INSTALLER_PACKAGE_NAME] [-s] [-f] PATH
2. pm uninstall [-k] PACKAGE

代码实现也很简单，使用流的方式来进行相关操作：

1. public static void execCommand(String... command) {
2. 02 Process process = null;
3. 03 try {
4. 04 process = new ProcessBuilder().command(command).start();
5. 05 //对于命令的执行结果我们可以通过流来读取
6. 06 // InputStream in = process.getInputStream();
7. 07 // OutputStream out = process.getOutputStream();
8. 08 // InputStream err = process.getErrorStream();
9. 09 } catch (IOException e) {
10. 10 e.printStackTrace();
11. 11 } finally {
12. 12 if (process != null)
13. 13 process.destroy();
14. 14 }
15. 15 }
17. 1 execCommand("pm", "install", "-f", filePath);//安装apk，filePath为apk文件路径，如/mnt/sdcard/ApiDemos.apk
18. 2 execCommand("pm", "uninstall", packageName);//卸载apk，packageName为包名，如com.example.android.apis

注意一下：

1. 编译生成apk时，要在你的manifest文件下添加android:sharedUserId="android.uid.system"，编译完成之后还无法正常安装，会出现Installation error: INSTALL_FAILED_SHARED_USER_INCOMPATIBLE错误，此时，要为apk重新签名。
3. 在android源码\build\target\product\security中找platform.pk8和platform.x509.pem两个文件，在android 编绎目录out下找到 signapk.jar 这个包（源码目录\build\tools\signapk），并把编译好的apk（如PMDemo.apk）放在同一目录下，在重新签名之前，用rar文件打开apk文件，进入META-INF目录下，将CERT.SF和CERT.RSA这两个文件删除掉，然后在命令行中执行以下命令：
5. 1 java -jar signapk.jar platform.x509.pem platform.pk8 PMDemo.apk NewPMDemo.apk
6. 安装前先把旧的apk卸载，这样重新签名之后的apk就可以正常安装了。

很简单吧，下面看下批量操作：

直接看代码吧：

1. 通常情况下，android是没有提供静默方式的上层接口，我们需要在android源代码下来调用这个隐藏的接口来完成静默安装。
2. 最重要的就是参考android系统目录下的packages/apps/PackageInstaller，
3. 当中有两个文件 PackageInstallerActivity.java,InstallAppProgress.java ,前者就是我们通常看到的带有提示对话框的安装应用程序，后者是点确定安装后调用的intent。
4. 现提供一个静默安装的关键类，该类在android2.2下成功编译, 其中通过循环调用接口instatllBatch则可实现批量安装
5. 当然最后的应用程序别忘记添加权限
7. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
8. <uses-permission android:name="android.permission.INSTALL_PACKAGES" />
9. <uses-permission android:name="android.permission.DELETE_PACKAGES" />
10. <uses-permission android:name="android.permission.CLEAR_APP_CACHE" />
11. <uses-permission android:name="android.permission.READ_PHONE_STATE" />
12. <uses-permission android:name="android.permission.CLEAR_APP_USER_DATA" />
14. package com.android.util;
16. import java.io.File;
18. import java.io.FileNotFoundException;
20. import java.io.FileOutputStream;
22. import java.io.IOException;
24. import android.content.Context;
26. import android.content.Intent;
28. import android.content.pm.PackageInfo;
30. import android.content.pm.PackageManager;
32. import android.content.pm.PackageManager.NameNotFoundException;
34. import android.content.pm.ApplicationInfo;
36. import android.content.pm.PackageParser;
38. import android.net.Uri;
40. import android.util.Log;
42. import android.util.DisplayMetrics;
44. import android.content.pm.IPackageInstallObserver;
46. import android.content.pm.IPackageDeleteObserver;
48. import android.os.FileUtils;
50. import android.os.Handler;
52. import android.os.Message;
56. public class PackageInstaller {
60. private File mTmpFile;
62. private final int INSTALL_COMPLETE = 1;
64. final static int SUCCEEDED = 1;
66. final static int FAILED = 0;
68. private final static String TAG = "PackInstaller";
70. private Context mContext;
72. private ApplicationInfo mAppInfo;
74. public PackageInstaller(Context context) {
76. mContext = context;
78. }
80. public void install(String path,String packageName){
82. Intent intent = new Intent(Intent.ACTION_VIEW);
84. intent.setDataAndType(Uri.fromFile(new File(path)),
86. "application/vnd.android.package-archive");
88. mContext.startActivity(intent);
90. }
94. public void instatllBatch(String path) {
96. Log.i(TAG, "path=" + path);
98. int installFlags = 0;
100. Uri mPackageURI = Uri.fromFile(new File(path));
102. PackageParser.Package mPkgInfo = getPackageInfo(mPackageURI);
104. mAppInfo = mPkgInfo.applicationInfo;
106. String packageName = mAppInfo.packageName;
108. Log.i(TAG, "====install packageName ="+packageName);
110. PackageManager pm = mContext.getPackageManager();
112. try {
114. PackageInfo pi = pm.getPackageInfo(packageName,
116. PackageManager.GET_UNINSTALLED_PACKAGES);
118. if (pi != null) {
120. installFlags |= PackageManager.INSTALL_REPLACE_EXISTING;
122. }
124. } catch (NameNotFoundException e) {
126. }
128. if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
130. Log.w(TAG, "Replacing package:" + packageName);
132. }
136. PackageInstallObserver observer = new PackageInstallObserver();
138. pm.installPackage(mPackageURI, observer, installFlags,
140. packageName);
142. }
144. private class PackageInstallObserver extends IPackageInstallObserver.Stub {
146. public void packageInstalled(String packageName, int returnCode) {
148. // Message msg = mHandler.obtainMessage(INSTALL_COMPLETE);
150. // msg.arg1 = returnCode;
152. // mHandler.sendMessage(msg);
154. Log.i(TAG, "====INSTALL_COMPLETE");
156. }
158. }
160. private class PackageDeleteObserver extends IPackageDeleteObserver.Stub {
162. public void packageDeleted(boolean succeeded) {
164. // Message msg = mHandler.obtainMessage(UNINSTALL_COMPLETE);
166. // msg.arg1 = succeeded?SUCCEEDED:FAILED;
168. // mHandler.sendMessage(msg);
170. Log.i(TAG, "====UNINSTALL_COMPLETE");
172. }
174. }
176. public void uninstall(String packageName){
178. Uri packageURI = Uri.parse("package:" + packageName);
180. Intent uninstallIntent = new Intent(Intent.ACTION_DELETE,
182. packageURI);
184. mContext.startActivity(uninstallIntent);
186. }
190. public void uninstallBatch(String packageName) {
192. PackageDeleteObserver observer = new PackageDeleteObserver();
194. mContext.getPackageManager().deletePackage(packageName, observer, 0);
198. }
200. public PackageParser.Package getPackageInfo(Uri packageURI) {
202. final String archiveFilePath = packageURI.getPath();
204. PackageParser packageParser = new PackageParser(archiveFilePath);
206. File sourceFile = new File(archiveFilePath);
208. DisplayMetrics metrics = new DisplayMetrics();
210. metrics.setToDefaults();
212. PackageParser.Package pkg = packageParser.parsePackage(sourceFile,
214. archiveFilePath, metrics, 0);
216. // Nuke the parser reference.
218. packageParser = null;
220. return pkg;
222. }
224. public ApplicationInfo getApplicationInfo(Uri packageURI) {
226. final String archiveFilePath = packageURI.getPath();
228. PackageParser packageParser = new PackageParser(archiveFilePath);
230. File sourceFile = new File(archiveFilePath);
232. DisplayMetrics metrics = new DisplayMetrics();
234. metrics.setToDefaults();
236. PackageParser.Package pkg = packageParser.parsePackage(sourceFile, archiveFilePath, metrics, 0);
238. if (pkg == null) {
240. return null;
242. }
244. return pkg.applicationInfo;
246. }
248. private Handler mHandler = new Handler() {
250. public void handleMessage(Message msg) {
252. switch (msg.what) {
254. case INSTALL_COMPLETE:
256. if(msg.arg1 == SUCCEEDED) {
260. } else {}
262. break;
264. default:
266. break;
268. }
270. }
272. };
274. }