Android apk动态加载机制的研究

深藏阁楼爱情的钟 2022-07-26 04:22 152阅读 0赞

转载请注明出处：[http://blog.csdn.net/singwhatiwanna/article/details/22597587][http_blog.csdn.net_singwhatiwanna_article_details_22597587] （来自singwhatiwanna的csdn博客）

## 背景 ##

问题是这样的：我们知道，apk必须安装才能运行，如果不安装要是也能运行该多好啊，事实上，这不是完全不可能的，尽管它比较难实现。在理论层面上，我们可以通过一个宿主程序来运行一些未安装的apk，当然，实践层面上也能实现，不过这对未安装的apk有要求。我们的想法是这样的，首先要明白apk未安装是不能被直接调起来的，但是我们可以采用一个程序（称之为宿主程序）去动态加载apk文件并将其放在自己的进程中执行，本文要介绍的就是这么一种方法，同时这种方法还有很多问题，尤其是资源的访问。因为将apk加载到宿主程序中去执行，就无法通过宿主程序的Context去取到apk中的资源,比如图片、文本等，这是很好理解的，因为apk已经不存在上下文了，它执行时所采用的上下文是宿主程序的上下文，用别人的Context是无法得到自己的资源的，不过这个问题貌似可以这么解决：将apk中的资源解压到某个目录，然后通过文件去操作资源，这只是理论上可行，实际上还是会有很多的难点的。除了资源存取的问题，还有一个问题是activity的生命周期，因为apk被宿主程序加载执行后，它的activity其实就是一个普通的类，正常情况下，activity的生命周期是由系统来管理的，现在被宿主程序接管了以后，如何替代系统对apk中的activity的生命周期进行管理是有难度的，不过这个问题比资源的访问好解决一些，比如我们可以在宿主程序中模拟activity的生命周期并合适地调用apk中activity的生命周期方法。本文暂时不对这两个问题进行解决，因为很难，本文仅仅对apk的动态执行机制进行介绍，尽管如此，听起来还是有点小激动，不是吗?

## 工作原理 ##

如下图所示，首先宿主程序会到文件系统比如sd卡去加载apk，然后通过一个叫做proxy的activity去执行apk中的activity。

关于动态加载apk，理论上可以用到的有DexClassLoader、PathClassLoader和URLClassLoader。

DexClassLoader ：可以加载文件系统上的jar、dex、apk

PathClassLoader ：可以加载/data/app目录下的apk，这也意味着，它只能加载已经安装的apk

URLClassLoader ：可以加载java中的jar，但是由于dalvik不能直接识别jar，所以此方法在android中无法使用，尽管还有这个类

关于jar、dex和apk，dex和apk是可以直接加载的，因为它们都是或者内部有dex文件，而原始的jar是不行的，必须转换成dalvik所能识别的字节码文件，转换工具可以使用android sdk中platform-tools目录下的dx

转换命令 ：dx --dex --output=dest.jar src.jar

![SouthEast][]

## 示例 ##

### 宿主程序的实现 ###

1. 主界面很简单，放了一个button，点击就会调起apk，我把apk直接放在了sd卡中，至于先把apk从网上下载到本地再加载其实是一个道理。

**\[java\]**  [view plain][]  [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  @Override  
2.  **public** **void** onClick(View v) \{  
3.      **if** (v == mOpenClient) \{  
4.          Intent intent = **new** Intent(**this**, ProxyActivity.**class**);  
5.          intent.putExtra(ProxyActivity.EXTRA\_DEX\_PATH, "/mnt/sdcard/DynamicLoadHost/plugin.apk");  
6.          startActivity(intent);  
7.      \}  
8.    
9.  \}

点击button以后，proxy会被调起，然后加载apk并调起的任务就交给它了

2. 代理activity的实现（proxy）

**\[java\]**  [view plain][]  [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.ryg.dynamicloadhost;  
2.    
3.  **import** java.lang.reflect.Constructor;  
4.  **import** java.lang.reflect.Method;  
5.    
6.  **import** dalvik.system.DexClassLoader;  
7.  **import** android.annotation.SuppressLint;  
8.  **import** android.app.Activity;  
9.  **import** android.content.pm.PackageInfo;  
10. **import** android.os.Bundle;  
11. **import** android.util.Log;  
12.   
13. **public** **class** ProxyActivity **extends** Activity \{  
14.   
15.     **private** **static** **final** String TAG = "ProxyActivity";  
16.   
17.     **public** **static** **final** String FROM = "extra.from";  
18.     **public** **static** **final** **int** FROM\_EXTERNAL = 0;  
19.     **public** **static** **final** **int** FROM\_INTERNAL = 1;  
20.   
21.     **public** **static** **final** String EXTRA\_DEX\_PATH = "extra.dex.path";  
22.     **public** **static** **final** String EXTRA\_CLASS = "extra.class";  
23.   
24.     **private** String mClass;  
25.     **private** String mDexPath;  
26.   
27.     @Override  
28.     **protected** **void** onCreate(Bundle savedInstanceState) \{  
29.         **super**.onCreate(savedInstanceState);  
30.         mDexPath = getIntent().getStringExtra(EXTRA\_DEX\_PATH);  
31.         mClass = getIntent().getStringExtra(EXTRA\_CLASS);  
32.   
33.         Log.d(TAG, "mClass=" + mClass + " mDexPath=" + mDexPath);  
34.         **if** (mClass == **null**) \{  
35.             launchTargetActivity();  
36.         \} **else** \{  
37.             launchTargetActivity(mClass);  
38.         \}  
39.     \}  
40.   
41.     @SuppressLint("NewApi")  
42.     **protected** **void** launchTargetActivity() \{  
43.         PackageInfo packageInfo = getPackageManager().getPackageArchiveInfo(  
44.                 mDexPath, 1);  
45.         **if** ((packageInfo.activities != **null**)  
46.                 && (packageInfo.activities.length > 0)) \{  
47.             String activityName = packageInfo.activities\[0\].name;  
48.             mClass = activityName;  
49.             launchTargetActivity(mClass);  
50.         \}  
51.     \}  
52.   
53.     @SuppressLint("NewApi")  
54.     **protected** **void** launchTargetActivity(**final** String className) \{  
55.         Log.d(TAG, "start launchTargetActivity, className=" + className);  
56.         File dexOutputDir = **this**.getDir("dex", 0);  
57.         **final** String dexOutputPath = dexOutputDir.getAbsolutePath();  
58.         ClassLoader localClassLoader = ClassLoader.getSystemClassLoader();  
59.         DexClassLoader dexClassLoader = **new** DexClassLoader(mDexPath,  
60.                 dexOutputPath, **null**, localClassLoader);  
61.         **try** \{  
62.             Class<?> localClass = dexClassLoader.loadClass(className);  
63.             Constructor<?> localConstructor = localClass  
64.                     .getConstructor(**new** Class\[\] \{\});  
65.             Object instance = localConstructor.newInstance(**new** Object\[\] \{\});  
66.             Log.d(TAG, "instance = " + instance);  
67.   
68.             Method setProxy = localClass.getMethod("setProxy",  
69.                     **new** Class\[\] \{ Activity.**class** \});  
70.             setProxy.setAccessible(**true**);  
71.             setProxy.invoke(instance, **new** Object\[\] \{ **this** \});  
72.   
73.             Method onCreate = localClass.getDeclaredMethod("onCreate",  
74.                     **new** Class\[\] \{ Bundle.**class** \});  
75.             onCreate.setAccessible(**true**);  
76.             Bundle bundle = **new** Bundle();  
77.             bundle.putInt(FROM, FROM\_EXTERNAL);  
78.             onCreate.invoke(instance, **new** Object\[\] \{ bundle \});  
79.         \} **catch** (Exception e) \{  
80.             e.printStackTrace();  
81.         \}  
82.     \}  
83.   
84. \}

说明：程序不难理解，思路是这样的：采用DexClassLoader去加载apk，然后如果没有指定class，就调起主activity，否则调起指定的class。activity被调起的过程是这样的：首先通过类加载器去加载apk中activity的类并创建一个新对象，然后通过反射去调用这个对象的setProxy方法和onCreate方法，setProxy方法的作用是将activity内部的执行全部交由宿主程序中的proxy（也是一个activity），onCreate方法是activity的入口，setProxy以后就调用onCreate方法，这个时候activity就被调起来了。

自此，宿主程序就实现完成了，记得不要忘记在配置文件中添加权限<uses-permission android:name="android.permission.READ\_EXTERNAL\_STORAGE"/>

配置文件如下：

<?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.androidtest2"
        android:versionCode="1"
        android:versionName="1.0" >
    
        <uses-sdk
            android:minSdkVersion="8"
            android:targetSdkVersion="19" />
        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    
        <application
            android:allowBackup="true"
            android:icon="@drawable/ic_launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme" >
            <activity
                android:name="com.example.androidtest2.MainActivity"
                android:label="@string/app_name" >
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
            <activity android:name="ProxyActivity">
                <intent-filter>
                    <action android:name="com.fang.VIEW" />
    
                    <category android:name="android.intent.category.DEFAULT" />
                </intent-filter>
            </activity>
            
        </application>
    
    </manifest>

其中ProxyActivity中的intent-filter中添加了自定义的action，名为com.fang.VIEW,这个action字符串会在未安装的apk的程序中使用到。

### 待执行apk的实现 ###

1. 为了让proxy全面接管apk中所有activity的执行，需要为activity定义一个基类BaseActivity，在基类中处理代理相关的事情，同时BaseActivity还对是否使用代理进行了判断，如果不使用代理，那么activity的逻辑仍然按照正常的方式执行，也就是说，这个apk既可以按照执行，也可以由宿主程序来执行。

**\[java\]**  [view plain][]  [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.ryg.dynamicloadclient;  
2.    
3.  **import** android.app.Activity;  
4.  **import** android.content.Intent;  
5.  **import** android.os.Bundle;  
6.  **import** android.util.Log;  
7.  **import** android.view.View;  
8.  **import** android.view.ViewGroup.LayoutParams;  
9.    
10. **public** **class** BaseActivity **extends** Activity \{  
11.   
12.     **private** **static** **final** String TAG = "Client-BaseActivity";  
13.   
14.     **public** **static** **final** String FROM = "extra.from";  
15.     **public** **static** **final** **int** FROM\_EXTERNAL = 0;  
16.     **public** **static** **final** **int** FROM\_INTERNAL = 1;  
17.     **public** **static** **final** String EXTRA\_DEX\_PATH = "extra.dex.path";  
18.     **public** **static** **final** String EXTRA\_CLASS = "extra.class";  
19.   
20.     **public** **static** **final** String PROXY\_VIEW\_ACTION = "com.fang.VIEW";  
21.     **public** **static** **final** String DEX\_PATH = "/mnt/sdcard/DynamicLoadHost/plugin.apk";  
22.   
23.     **protected** Activity mProxyActivity;  
24.     **protected** **int** mFrom = FROM\_INTERNAL;  
25.   
26.     **public** **void** setProxy(Activity proxyActivity) \{  
27.         Log.d(TAG, "setProxy: proxyActivity= " + proxyActivity);  
28.         mProxyActivity = proxyActivity;  
29.     \}  
30.   
31.     @Override  
32.     **protected** **void** onCreate(Bundle savedInstanceState) \{  
33.         **if** (savedInstanceState != **null**) \{  
34.             mFrom = savedInstanceState.getInt(FROM, FROM\_INTERNAL);  
35.         \}  
36.         **if** (mFrom == FROM\_INTERNAL) \{  
37.             **super**.onCreate(savedInstanceState);  
38.             mProxyActivity = **this**;  
39.         \}  
40.         Log.d(TAG, "onCreate: from= " + mFrom);  
41.     \}  
42.   
43.     **protected** **void** startActivityByProxy(String className) \{  
44.         **if** (mProxyActivity == **this**) \{  
45.             Intent intent = **new** Intent();  
46.             intent.setClassName(**this**, className);  
47.             **this**.startActivity(intent);  
48.         \} **else** \{  
49.             Intent intent = **new** Intent(PROXY\_VIEW\_ACTION);  
50.             intent.putExtra(EXTRA\_DEX\_PATH, DEX\_PATH);  
51.             intent.putExtra(EXTRA\_CLASS, className);  
52.             mProxyActivity.startActivity(intent);  
53.         \}  
54.     \}  
55.   
56.     @Override  
57.     **public** **void** setContentView(View view) \{  
58.         **if** (mProxyActivity == **this**) \{  
59.             **super**.setContentView(view);  
60.         \} **else** \{  
61.             mProxyActivity.setContentView(view);  
62.         \}  
63.     \}  
64.   
65.     @Override  
66.     **public** **void** setContentView(View view, LayoutParams params) \{  
67.         **if** (mProxyActivity == **this**) \{  
68.             **super**.setContentView(view, params);  
69.         \} **else** \{  
70.             mProxyActivity.setContentView(view, params);  
71.         \}  
72.     \}  
73.   
74.     @Deprecated  
75.     @Override  
76.     **public** **void** setContentView(**int** layoutResID) \{  
77.         **if** (mProxyActivity == **this**) \{  
78.             **super**.setContentView(layoutResID);  
79.         \} **else** \{  
80.             mProxyActivity.setContentView(layoutResID);  
81.         \}  
82.     \}  
83.   
84.     @Override  
85.     **public** **void** addContentView(View view, LayoutParams params) \{  
86.         **if** (mProxyActivity == **this**) \{  
87.             **super**.addContentView(view, params);  
88.         \} **else** \{  
89.             mProxyActivity.addContentView(view, params);  
90.         \}  
91.     \}  
92. \}

说明：相信大家一看代码就明白了，其中setProxy方法的作用就是为了让宿主程序能够接管自己的执行，一旦被接管以后，其所有的执行均通过proxy，且Context也变成了宿主程序的Context，也许这么说比较形象：宿主程序其实就是个空壳，它只是把其它apk加载到自己的内部去执行，这也就更能理解为什么资源访问变得很困难，你会发现好像访问不到apk中的资源了，的确是这样的，但是目前我还没有很好的方法去解决。  
2. 入口activity的实现

**\[java\]**  [view plain][]  [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** MainActivity **extends** BaseActivity \{  
2.    
3.      **private** **static** **final** String TAG = "Client-MainActivity";  
4.    
5.      @Override  
6.      **protected** **void** onCreate(Bundle savedInstanceState) \{  
7.          **super**.onCreate(savedInstanceState);  
8.          initView(savedInstanceState);  
9.      \}  
10.   
11.     **private** **void** initView(Bundle savedInstanceState) \{  
12.         mProxyActivity.setContentView(generateContentView(mProxyActivity));  
13.     \}  
14.   
15.     **private** View generateContentView(**final** Context context) \{  
16.         LinearLayout layout = **new** LinearLayout(context);  
17.         layout.setLayoutParams(**new** LayoutParams(LayoutParams.MATCH\_PARENT,  
18.                 LayoutParams.MATCH\_PARENT));  
19.         layout.setBackgroundColor(Color.parseColor("\#F79AB5"));  
20.         Button button = **new** Button(context);  
21.         button.setText("button");  
22.         layout.addView(button, LayoutParams.MATCH\_PARENT,  
23.                 LayoutParams.WRAP\_CONTENT);  
24.         button.setOnClickListener(**new** OnClickListener() \{  
25.             @Override  
26.             **public** **void** onClick(View v) \{  
27.                 Toast.makeText(context, "you clicked button",  
28.                         Toast.LENGTH\_SHORT).show();  
29.                 startActivityByProxy("com.ryg.dynamicloadclient.TestActivity");  
30.             \}  
31.         \});  
32.         **return** layout;  
33.     \}  
34.   
35. \}

说明：由于访问不到apk中的资源了，所以界面是代码写的，而不是写在xml中，因为xml读不到了，这也是个大问题。注意到主界面中有一个button，点击后跳到了另一个activity，这个时候是不能直接调用系统的startActivity方法的，而是必须通过宿主程序中的proxy来执行，原因很简单，首先apk本书没有Context，所以它无法调起activity，另外由于这个子activity是apk中的，通过宿主程序直接调用它也是不行的，因为它对宿主程序来说是不可见的，所以只能通过proxy来调用，是不是感觉很麻烦？但是，你还有更好的办法吗?

3. 子activity的实现

**\[java\]**  [view plain][]  [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.ryg.dynamicloadclient;  
2.    
3.  **import** android.graphics.Color;  
4.  **import** android.os.Bundle;  
5.  **import** android.view.ViewGroup.LayoutParams;  
6.  **import** android.widget.Button;  
7.    
8.  **public** **class** TestActivity **extends** BaseActivity\{  
9.    
10.     @Override  
11.     **protected** **void** onCreate(Bundle savedInstanceState) \{  
12.         **super**.onCreate(savedInstanceState);  
13.         Button button = **new** Button(mProxyActivity);  
14.         button.setLayoutParams(**new** LayoutParams(LayoutParams.MATCH\_PARENT,  
15.                 LayoutParams.MATCH\_PARENT));  
16.         button.setBackgroundColor(Color.YELLOW);  
17.         button.setText("这是测试页面");  
18.         setContentView(button);  
19.     \}  
20.   
21. \}

说明：代码很简单，不用介绍了，同理，界面还是用代码来写的。

## 运行效果 ##

1. 首先看apk安装时的运行效果

![SouthEast 1][]

2. 再看看未安装时被宿主程序执行的效果

![SouthEast 2][]![SouthEast 3][]

说明：可以发现，安装和未安装，执行效果是一样的，差别在于：首先未安装的时候由于采用了反射，所以执行效率会略微降低，其次，应用的标题发生了改变，也就是说，尽管apk被执行了，但是它毕竟是在宿主程序里面执行的，所以它还是属于宿主程序的，因此apk未安装被执行时其标题不是自己的，不过这也可以间接证明，apk的确被宿主程序执行了，不信看标题。最后，我想说一下这么做的意义，这样做有利于实现模块化，同时还可以实现插件机制，但是问题还是很多的，最复杂的两个问题：资源的访问和activity生命周期的管理，期待大家有好的解决办法，欢迎交流。

代码下载：

[http://download.csdn.net/detail/zenmela2011/9484617][http_download.csdn.net_detail_zenmela2011_9484617]

[http_blog.csdn.net_singwhatiwanna_article_details_22597587]: http://blog.csdn.net/singwhatiwanna/article/details/22597587
[SouthEast]: /images/20220724/0f7d686f6b1441fbbbeb24c3a92605a8.png
[view plain]: http://blog.csdn.net/singwhatiwanna/article/details/22597587#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/265589
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/265589/fork
[SouthEast 1]: /images/20220724/d0a96e62e141421daebfb017482eba90.png
[SouthEast 2]: https://img-blog.csdn.net/20140330192712140?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2luZ3doYXRpd2FubmE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 3]: /images/20220724/201709fb221a45eab7282971158476fd.png
[http_download.csdn.net_detail_zenmela2011_9484617]: http://download.csdn.net/detail/zenmela2011/9484617