Android_实现静默安装和卸载应用

简介: 转:http://www.cnblogs.com/ondream/archive/2012/04/13/2446138.html    前段时间做了一个批量安装卸载应用程序的小应用,由于安装卸载应用程序的部分API是隐藏的,所以必须在ubuntu下下载Android系统源码,并编译之后使用MM命令编译生成APK文件,其实也难。

转:http://www.cnblogs.com/ondream/archive/2012/04/13/2446138.html

  

前段时间做了一个批量安装卸载应用程序的小应用,由于安装卸载应用程序的部分API是隐藏的,所以必须在ubuntu下下载Android系统源码,并编译之后使用MM命令编译生成APK文件,其实也难。思路是这样的,在XX/packages/apps目录下有一个PackageInstaller的应用程序,Android机器中安装卸载都是由这个应用程序完成的。但是它没有批量安装和卸载的功能,如果要在自己的应用程序中添加批量安装和卸载的功能,其实很简单,只需要参考PakcageInstaller里面的安装卸载代码加个循环就可以了。但值得注意的是在编译的过程中必须复制PackageInstaller里面的Android.mk文件,修改文件为工程目录名。好了,废话不再多说,下面是关键代码

   1、 Android.mk文件

复制代码
LOCAL_PATH:= $(call my-dir)  
include $(CLEAR_VARS)  
  
LOCAL_MODULE_TAGS := optional  
  
LOCAL_SRC_FILES := $(call all-subdir-java-files)  
  
LOCAL_PACKAGE_NAME := PackageInstaller  
LOCAL_CERTIFICATE := platform  
  
include $(BUILD_PACKAGE)  
复制代码

 

 

重点是LOCAL_CERTIFICATE := platform要对

 

 

   2、PakcageInstaller.java文件(关键代码)

复制代码
package cn.ceadic.apkmgr;  
  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
import android.content.Context;  
import android.content.Intent;  
import android.content.pm.PackageInfo;  
import android.content.pm.PackageManager;  
import android.content.pm.PackageManager.NameNotFoundException;  
import android.net.Uri;  
import android.util.Log;  
  
import android.content.pm.IPackageInstallObserver;  
import android.content.pm.IPackageDeleteObserver;  
import android.os.FileUtils;  
  
  
public class PackageInstaller {  
      
    private File mTmpFile;  
    private final String TMP_FILE_NAME = "tmpCopy.apk";  
  
    private final static String TAG = "PackInstaller";  
    private Context mContext;  
  
    public PackageInstaller(Context context) {  
        mContext = context;  
    }  
  
      
    public void install(String path,String packageName){  
         Intent intent = new Intent(Intent.ACTION_VIEW);  
         intent.setDataAndType(Uri.fromFile(new File(path)),  
         "application/vnd.android.package-archive");  
         mContext.startActivity(intent);  
    }  
      
    public void instatllBatch(String path, String packageName) {  
  
        Log.i(TAG, "path=" + path);  
        int installFlags = 0;  
        PackageManager pm = mContext.getPackageManager();  
        try {  
            PackageInfo pi = pm.getPackageInfo(packageName,  
                    PackageManager.GET_UNINSTALLED_PACKAGES);  
            if (pi != null) {  
                installFlags |= PackageManager.INSTALL_REPLACE_EXISTING;  
            }  
        } catch (NameNotFoundException e) {  
        }  
        if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {  
            Log.w(TAG, "Replacing package:" + packageName);  
        }  
  
        // Create temp file before invoking install api  
        mTmpFile = createTempPackageFile(path);  
        if (mTmpFile == null) {  
            // Message msg = mHandler.obtainMessage(INSTALL_COMPLETE);  
            // msg.arg1 = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;  
            // mHandler.sendMessage(msg);  
            return;  
        }  
        Uri mPackageURI = Uri.parse("file://" + mTmpFile.getPath());  
        String installerPackageName = mContext.getIntent().getStringExtra(  
                Intent.EXTRA_INSTALLER_PACKAGE_NAME);  
  
        PackageInstallObserver observer = new PackageInstallObserver();  
        pm.installPackage(mPackageURI, observer, installFlags,  
                installerPackageName);  
    }  
  
    private File createTempPackageFile(String filePath) {  
        File tmpPackageFile = mContext.getFileStreamPath(TMP_FILE_NAME);  
        if (tmpPackageFile == null) {  
            Log.w(TAG, "Failed to create temp file");  
            return null;  
        }  
        if (tmpPackageFile.exists()) {  
            tmpPackageFile.delete();  
        }  
        // Open file to make it world readable  
        FileOutputStream fos;  
        try {  
            fos = openFileOutput(TMP_FILE_NAME, MODE_WORLD_READABLE);  
        } catch (FileNotFoundException e1) {  
            Log.e(TAG, "Error opening file " + TMP_FILE_NAME);  
            return null;  
        }  
        try {  
            fos.close();  
        } catch (IOException e) {  
            Log.e(TAG, "Error opening file " + TMP_FILE_NAME);  
            return null;  
        }  
  
        File srcPackageFile = new File(filePath);  
        if (!FileUtils.copyFile(srcPackageFile, tmpPackageFile)) {  
            Log.w(TAG, "Failed to make copy of file: " + srcPackageFile);  
            return null;  
        }  
        return tmpPackageFile;  
    }  
  
    private class PackageInstallObserver extends IPackageInstallObserver.Stub {  
        public void packageInstalled(String packageName, int returnCode) {  
            // Message msg = mHandler.obtainMessage(INSTALL_COMPLETE);  
            // msg.arg1 = returnCode;  
            // mHandler.sendMessage(msg);  
            Log.i(TAG, "====INSTALL_COMPLETE");  
        }  
    }  
      
    private class PackageDeleteObserver extends IPackageDeleteObserver.Stub {  
        public void packageDeleted(boolean succeeded) {  
//            Message msg = mHandler.obtainMessage(UNINSTALL_COMPLETE);  
//            msg.arg1 = succeeded?SUCCEEDED:FAILED;  
//            mHandler.sendMessage(msg);  
            Log.i(TAG, "====UNINSTALL_COMPLETE");  
        }  
    }  
      
    public void uninstall(String packageName){  
        Uri packageURI = Uri.parse("package:" + packageName);  
        Intent uninstallIntent = new Intent(Intent.ACTION_DELETE,  
        packageURI);  
        mContext.startActivity(uninstallIntent);  
    }  
      
    public void uninstallBatch(String packageName) {  
        PackageDeleteObserver observer = new PackageDeleteObserver();  
        mContext.getPackageManager().deletePackage(packageName, observer, 0);  
          
    }  
}  
复制代码

 

   3、别忘记添加权限

复制代码
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>  
    <uses-permission android:name="android.permission.INSTALL_PACKAGES" />  
    <uses-permission android:name="android.permission.DELETE_PACKAGES" />  
    <uses-permission android:name="android.permission.CLEAR_APP_CACHE" />  
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />  
    <uses-permission android:name="android.permission.CLEAR_APP_USER_DATA" />  
复制代码

 


以上代码在Android2.1的SDK中编译通过,并正确批量安装卸载应用程序

 

转自:http://blog.csdn.net/tangcheng_ok/article/details/6681453

另外关键的是:你要有linux环境或其他可以mmm交叉编译的环境,因为这个用到的是隐藏api,SDK中没有的,ecilipse里面会提示包不存在,但交叉编译可以,如果你不知道mmm编译,请return。

调用uinstall会弹出卸载界面,而调用uninstallBatch不会弹出卸载界面。

在Windows下可下载模拟的unix环境cygwin

另外还可参考:

 

实现静默安装APK的两种方法

 android静默安装步骤:http://download.csdn.net/download/lyj286326189/4049858


 

android静默安装探讨
 

1)在网上搜寻该问题的解决方法,且查阅android开发文档,没有发现可以实现该功能的显示API调用,网络上很多人请教同样的问题,但都没有能够实现解答;说是android为了用户的安全,已屏蔽该实现该方法的功能,第三方法应用是无法实现静默安装的。


(2)然后自己试图去看看android实现普通安装程序的源码文件,能否找到解决的办法,打算绕过普通安装时的提示框,直接调用通过确认后调用的函数进行安装;在查看android应用程序的普通安装过程后,发现应用程序安装过程的方法调用过程为:首先进入到com/android/packageinstaller/PackageInstallerActivity.java这个Activity中,在这个Activity中首先检查所欲安装的程序是否是正确的安装文件,以及当前系统中是否已安装了此应用程序,提示用户是否重复安装,另外还获取所欲安装的程序所讲用到的权限,然后将这些信息通过一个对话框提示给用户,当用户确定安装时,启动com.android.packageinstaller.InstallAppProgress.java这个Activity,在这个Activity中,调用

android.content.pm.PackageManager.installPackage(Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName)进行安装应用程序,在InstallAppProgress中得到的PackageManager是通过PackageManager pm = getPackageManager()得到的,得到的对象是一个android.app.ContextImpl.ApplicationPackageManager对象,而

ApplicationPackageManager对象经过封装,

ApplicationPackageManager(ContextImpl context,
                IPackageManager pm) {
            mContext = context;
            mPM = pm;
        }
其installPackage方法为
  @Override
        public void installPackage(Uri packageURI, IPackageInstallObserver observer, int flags,
                String installerPackageName) {
            try {
                mPM.installPackage(packageURI, observer, flags, installerPackageName);
            } catch (RemoteException e) {
                // Should never happen!
            }
        }

可见调用的installPackage方法为 IPackageManager.installPackage(packageURI, observer, flags, installerPackageName);
在ContextImpl中,由IPackageManager pm = ActivityThread.getPackageManager()获得IPackageManager实例对象;在ActivityThread.getPackageManager()方法中,
static IPackageManager sPackageManager;
public static IPackageManager getPackageManager() {
        if (sPackageManager != null) {
            return sPackageManager;
        }
        IBinder b = ServiceManager.getService("package");
        sPackageManager = IPackageManager.Stub.asInterface(b);
        return sPackageManager;
    }

最终得到的installPackage确实是IPackageManager.installPackage方法;

因为class PackageManagerService extends IPackageManager.Stub所以IPackageManager.installPackage调用的是:PackageManagerService.java (frameworks\base\services\java\com\android\server)文件中的
/* Called when a downloaded package installation has been confirmed by the user */
    public void installPackage(
            final Uri packageURI, final IPackageInstallObserver observer, final int flags) {
        installPackage(packageURI, observer, flags, null);
    }
(这里不明白为何IPackageManager.installPackage方法调用的是PackageManagerService.java,只是在网上的一篇文章中它给出了上面的原因,因为class PackageManagerService extends IPackageManager.Stub,我不明白,但也找不到其他的函数,通过PackageManagerService.java的源码,可以看出它确实是进行应用程序安装的,所以应该可以确定最终调用的方法就是

PackageManagerService.installPackage(final Uri packageURI, final IPackageInstallObserver observer, final int flags))

于是考虑如何得到PackageManagerService.installPackage(),考虑通过反射的方法得到installPackage(),但其中难以得到的是其参数中的IPackageInstallObserver类型,IPackageInstallObserver是由aidl文件定义的,通过aidl文件的特性,将IPackageInstallObserver.aidl文件拷到本地程序中,可以得到类IPackageInstallObserver.calss,通过它反射出installPackage()方法,但在invoke该方法时,却无法得到IPackageInstallObserver的实例对象,IPackageInstallObserver的实例对象必须通过

IPackageInstallObserver.Stub.asInterface(IBinder binder)方式得到,无法得到与其绑定的IBinder对象,因而无法执行反射出来的方法;另外PackageManagerService.installPackage()似乎是不能被第三方应用程序执行的,有权限的限制,这从下面的实例中似乎可以得到证实。

(3)在程序中执行Runtime.getRuntime().exec("pm install -r " + new File(Environment.getExternalStorageDirectory(),
"download/Shuffle-1.6.3.apk")); 进行安装,这个命令的执行在 com.android.commands.pm.Pm中,直接调用IPackageManager.installPackage(Uri.fromFile(new File(apkFilePath)), obs, installFlags,installerPackageName)方法,在此方法中,
IPackageManager mPm;
mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
且class PackageManagerService extends IPackageManager.Stub
所以IPackageManager.installPackage调用的是:PackageManagerService.java (frameworks\base\services\java\com\android\server)文件中的
/* Called when a downloaded package installation has been confirmed by the user */
    public void installPackage(
            final Uri packageURI, final IPackageInstallObserver observer, final int flags) {
        installPackage(packageURI, observer, flags, null);
    }

在此方法执行中会出现 Not granting permission android.permission.DELETE_PACKAGES错误,这应该是该权限不能授给第三方应用,因而在程序中不能执行,与android中普通安装应用程序最终调用的方法是相同的,但是却对第三方应用是没有权限执行的。。

(4) 另外解决思路:

1> 使用android:sharedUserId="android.uid.system"属性来使应用程序获得系统权限,看看是否能够执行行Runtime.getRuntime().exec("pm install -r ... ")方法。
2> 阅读android实现应用程序安装更底层的代码,看看能否可以调用的底层方法进行安装或者自己实现一个安装程序的代码,但这可能性不大,因为这涉及到android更底层的调用,

肯定会有一定的权限限制。
3> 在网上看到一个文件管理程序,据说是可以实现批量寂寞安装应用程序,但说明运行时需要用户确定得到手机的root权限,所以没有太大意义。
4> 定制自己的android系统,可以解决。

 

说了这么多,最后总结的是:修改android。mk文件并在linux下和系统源代码一起编译及签名为目标系统签名来生成apk,然后参照packegeinstaller源代码调用方法即可

确保或者获取手机root权限,然后执行

Runtime.getRuntime().exec("pm install -r " + filePath);

 

转自 http://hcq0618.blog.163.com/blog/static/178090351201222552215372/

欢迎各位同学加入 android 技术群 155595043

个人微博: http://weibo.com/338226333

弹窗安装

             Intent it = new Intent(Intent.ACTION_VIEW);
             it.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
             it.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
             context.startActivity(it);

 

 相关链接:http://blog.csdn.net/fenyush/article/details/6052914

              http://blog.csdn.net/sodino/article/details/6238818

               http://blog.sina.com.cn/s/blog_44e6424c0100zbhp.html

目录
相关文章
|
19天前
|
存储 安全 Android开发
构建高效的Android应用:Kotlin与Jetpack的结合
【5月更文挑战第31天】 在移动开发的世界中,Android 平台因其开放性和广泛的用户基础而备受开发者青睐。随着技术的进步和用户需求的不断升级,开发一个高效、流畅且易于维护的 Android 应用变得愈发重要。本文将探讨如何通过结合现代编程语言 Kotlin 和 Android Jetpack 组件来提升 Android 应用的性能和可维护性。我们将深入分析 Kotlin 语言的优势,探索 Jetpack 组件的核心功能,并通过实例演示如何在实际项目中应用这些技术。
|
20天前
|
移动开发 调度 Android开发
构建高效Android应用:Kotlin协程的实践指南
【5月更文挑战第30天】在移动开发领域,Android平台的流畅性与效率一直是开发者追求的核心。随着Kotlin语言的普及,其提供的协程特性为编写高效、轻量级的异步代码提供了强大工具。本文将深入探讨如何在Android项目中利用Kotlin协程来优化性能,提升用户体验。我们将从协程的基本概念出发,通过实例演示如何在实际开发中合理运用协程,并讨论协程对资源管理和错误处理的影响。
19 3
|
20天前
|
移动开发 安全 Android开发
构建高效Android应用:Kotlin协程的实践与优化策略
【5月更文挑战第30天】 在移动开发领域,性能优化始终是关键议题之一。特别是对于Android开发者来说,如何在保证应用流畅性的同时,提升代码的执行效率,已成为不断探索的主题。近年来,Kotlin语言凭借其简洁、安全和实用的特性,在Android开发中得到了广泛的应用。其中,Kotlin协程作为一种新的并发处理机制,为编写异步、非阻塞性的代码提供了强大工具。本文将深入探讨Kotlin协程在Android开发中的应用实践,以及如何通过协程优化应用性能,帮助开发者构建更高效的Android应用。
|
20天前
|
移动开发 数据库 Android开发
构建高效Android应用:Kotlin协程的实践指南
【5月更文挑战第30天】 在移动开发领域,性能优化和流畅的用户体验是至关重要的因素。对于Android开发者来说,Kotlin协程作为一种异步编程解决方案,提供了强大且轻量级的机制来处理后台任务,而不会对主线程造成阻塞。本文将深入探讨Kotlin协程的概念、优势以及如何在Android应用中实现它们,从而改善应用响应性和用户满意度。通过实例代码和最佳实践的分享,我们将展示如何有效利用协程来处理网络请求、数据库操作和耗时计算,同时确保UI的流畅性。
|
20小时前
|
XML 存储 数据库
如何使用Android Studio创建一个基本的音乐播放器应用
如何使用Android Studio创建一个基本的音乐播放器应用
9 0
|
4天前
|
前端开发 测试技术 API
探索安卓应用的架构演进:从MVC到MVVM
本篇文章将深入探讨安卓应用开发中的架构演进,特别关注从传统的MVC(Model-View-Controller)到现代流行的MVVM(Model-View-ViewModel)架构的转变。通过对比两种架构的设计理念、实现方式和实际应用案例,解析MVVM在提高代码可维护性和可测试性方面的优势。
9 0
|
5天前
|
JSON Android开发 C++
Android c++ core guideline checker 应用
Android c++ core guideline checker 应用
|
6天前
|
Android开发 Kotlin
kotlin开发安卓应用 如何修改app安装后的名称
在 Android 应用中,要修改安装后的显示名称,需更新 AndroidManifest.xml 文件中 application 标签的 android:label 属性。可直接在该属性内设置新名称,或在 res/values/strings.xml 文件中修改 app_name 并在 manifest 中引用。推荐使用 strings.xml 方式,以便支持多语言和集中管理。
|
12天前
|
XML Java Android开发
Android应用中如何保护JAVA代码
Android应用中如何保护JAVA代码
6 0
|
12天前
|
编解码 缓存 Android开发
构建高效的Android应用:从内存优化到响应式设计
【5月更文挑战第37天】 在竞争激烈的移动应用市场中,一个高效、流畅的Android应用是吸引和保留用户的关键。本文将深入探讨构建高效Android应用的多个关键方面,包括内存优化策略、布局性能和响应式设计原则。我们将通过具体的技术实践和案例分析,揭示如何提升应用性能,减少资源消耗,并确保在不同设备上的兼容性和用户体验一致性。