Android插件式开发学习笔记-白红宇

Android插件式开发学习笔记

阅读量：2342 次

发布时间：2019-05-10

本文共 8891 字，大约阅读时间需要 29 分钟。

最近在学习android下的插件式开发，做个笔记整理一下。

参考链接：

http://blog.csdn.net/singwhatiwanna/article/details/22597587

http://blog.csdn.net/singwhatiwanna/article/details/23387079

http://blog.csdn.net/bboyfeiyu/article/details/11710497

http://blog.csdn.net/com360/article/details/14125683

http://www.cnblogs.com/LittleRedPoint/p/3429709.html

http://blog.csdn.net/wenchao126/article/details/41216513

http://blog.zhourunsheng.com/2011/09/%E6%8E%A2%E7%A7%98%E8%85%BE%E8%AE%AFandroid%E6%89%8B%E6%9C%BA%E6%B8%B8%E6%88%8F%E5%B9%B3%E5%8F%B0%E4%B9%8B%E4%B8%8D%E5%AE%89%E8%A3%85%E6%B8%B8%E6%88%8Fapk%E7%9B%B4%E6%8E%A5%E5%90%AF%E5%8A%A8%E6%B3%95/

概念

许多平台化的应用，诸如支付宝钱包和微信，为了方便的扩展功能，都采用了插件式开发的思想。

主要包含如下几个意思：

插件不能独立运行，必须运行一个宿主程序中，宿主程序去调用插件。

插件一般情况下可以独立安装，android中就可以设计一个apk。

宿主程序中可以管理插件，比如添加，删除，禁用等。

宿主程序应该保证插件向下兼容，新的宿主程序应该兼容老的插件。

插件式模型是：宿主程序（一个独立apk），插件程序（apk）。其中插件程序分两种，一种需要安装apk的，一种不需要安装的。前者没什么可说的，直接intent启动插件即可，本文主要说不安装apk的情况。

主要需要解决的问题

插件apk中类的加载，方法的调用。

资源访问问题，plugin的上下文已经不存在，无法直接调用，可以考虑文件读写。

activity生命周期，plguin里面的activity对宿主程序来说只是普通的类，生命周期不受系统控制，可以考虑手动在宿主activity里调用plugin的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

DexClassLoader这个类的使用过程基本是这样：

通过PacageMangager获得指定的apk的安装的目录，dex的解压缩目录，c/c++库的目录

创建一个 DexClassLoader实例

加载指定的类返回一个Class

然后使用反射调用这个Class

下面是代码部分，代码参考自《Android内核剖析》（作者柯元旦，这本书不错，推荐阅读）：

[html]
 @SuppressLint("NewApi") private void useDexClassLoader(){  
     //创建一个意图，用来找到指定的apk  
     Intent intent = new Intent("com.suchangli.android.plugin", null);  
     //获得包管理器  
     PackageManager pm = getPackageManager();  
     List<ResolveInfo> resolveinfoes =  pm.queryIntentActivities(intent, 0);  
     //获得指定的activity的信息  
     ActivityInfo actInfo = resolveinfoes.get(0).activityInfo;  
       
     //获得包名  
     String pacageName = actInfo.packageName;  
     //获得apk的目录或者jar的目录  
     String apkPath = actInfo.applicationInfo.sourceDir;  
     //dex解压后的目录,注意，这个用宿主程序的目录，android中只允许程序读取写自己  
     //目录下的文件  
     String dexOutputDir = getApplicationInfo().dataDir;  
       
     //native代码的目录  
     String libPath = actInfo.applicationInfo.nativeLibraryDir;  
     //创建类加载器，把dex加载到虚拟机中  
     DexClassLoader calssLoader = new DexClassLoader(apkPath, dexOutputDir, libPath,  
             this.getClass().getClassLoader());  
       
     //利用反射调用插件包内的类的方法  
       
     try {  
         Class<?> clazz = calssLoader.loadClass(pacageName+".Plugin1");  
           
         Object obj = clazz.newInstance();  
         Class[] param = new Class[2];  
         param[0] = Integer.TYPE;  
         param[1] = Integer.TYPE;  
           
         Method method = clazz.getMethod("function1", param);  
           
         Integer ret = (Integer)method.invoke(obj, 1,12);  
           
         Log.i("Host", "return result is " + ret);  
           
     } catch (ClassNotFoundException e) {  
         e.printStackTrace();  
     } catch (InstantiationException e) {  
         e.printStackTrace();  
     } catch (IllegalAccessException e) {  
         e.printStackTrace();  
     } catch (NoSuchMethodException e) {  
         e.printStackTrace();  
     } catch (IllegalArgumentException e) {  
         e.printStackTrace();  
     } catch (InvocationTargetException e) {  
         e.printStackTrace();  
     }  
    }  
 

Plugin1.apk中的一个类：

[html]

package com.suchangli.plugin1;

public class Plugin1 {

public int function1(int a, int b){

return a+b;

}

}

Log输出的结果：

这是我试验用的一个demo：

1.宿主程序中调用插件的方法

/**	 * 加载插件	 */	private void loadPlugin() {		String dexPath = Environment.getExternalStorageDirectory()				+ "/TestB.apk";		//必须通过这种方法建立一个受保护的目录，这个目录在/data/data/该程序下建立，目的是为了防止代码注入攻击		String optimizedDirectory = getApplicationContext().getDir("dex_dir",				MODE_PRIVATE).getAbsolutePath();		ClassLoader classLoader = ClassLoader.getSystemClassLoader();		// 建立dex类加载器		DexClassLoader dexClassLoader = new DexClassLoader(dexPath,				optimizedDirectory, null, classLoader);		// 通过apk获取package信息， 1是 GET_ACTIVITIES		PackageInfo packInfo = getPackageManager().getPackageArchiveInfo(				dexPath, 1);		if (packInfo != null) {			if (packInfo.activities != null) {				String actName = packInfo.activities[0].name;				Log.d(TAG, "activityname = " + actName);				try {					Class
     actClass = dexClassLoader.loadClass(actName);					Constructor
     actConstructor = actClass							.getConstructor(new Class[] {});					Object act = actConstructor.newInstance(new Object[] {});					Log.d(TAG, "activity = " + act);					// 调用一个弹toast的方法					Method method = actClass.getDeclaredMethod("getToast",							new Class[] { Activity.class });					method.setAccessible(true);					method.invoke(act, new Object[] { this });					// 传递给插件自己的引用					Method localMethodSetActivity = actClass.getDeclaredMethod(							"setActivity", new Class[] { Activity.class });					localMethodSetActivity.setAccessible(true);					localMethodSetActivity.invoke(act, new Object[] { this });					//启动插件oncreate					Bundle paramBundle = new Bundle();					Method methodonCreate = actClass.getDeclaredMethod(							"onCreate", new Class[] { Bundle.class });					methodonCreate.setAccessible(true);					methodonCreate.invoke(act, new Object[] { paramBundle });				} catch (Exception e) {					// TODO Auto-generated catch block					e.printStackTrace();				}			}		} else {			Log.d(TAG, "activityname =null dexpath:" + dexPath);		}	}

插件activity

public class PlugActivity extends Activity {	private static final String TAG = "PlugActivity";	private Activity otherActivity;	@Override	public void onCreate(Bundle savedInstanceState) {		Log.d(TAG, "onCreate..." + savedInstanceState);		super.onCreate(savedInstanceState);		//其实是偷梁换柱，用宿主程序加载的。		otherActivity.setContentView(new TextView(otherActivity));			}	public void setActivity(Activity paramActivity) {		Log.d(TAG, "setActivity..." + paramActivity);		this.otherActivity = paramActivity;	}	public void getToast(Activity paramActivity) {		Log.d(TAG, "getToast..." + paramActivity);		Toast.makeText(paramActivity, "testB toast", Toast.LENGTH_SHORT).show();	}}

资源访问问题

因为将apk加载到宿主程序中去执行，就无法通过宿主程序的Context去取到apk中的资源,比如图片、文本等，这是很好理解的，因为apk已经不存在上下文了，它执行时所采用的上下文是宿主程序的上下文，用别人的Context是无法得到自己的资源的，不过这个问题貌似可以这么解决：将apk中的资源解压到某个目录，然后通过文件去操作资源，这只是理论上可行，实际上还是会有很多的难点的。

对于已经安装的apk插件，资源访问可以通过createPackageContext获得插件的context，很方便的获取资源。

对于未安装的apk，最原始的办法是解压apk然后手动获取，但太麻烦了。有位大神开发了一款叫dynamic-load-apk的框架，其中使用了重写API的getResource方法把插件apk也加入R.java的方法，很好的解决了该问题，后面有详细说明。

生命周期问题

apk被宿主程序调起以后，apk中的activity其实就是一个普通的对象，不具有activity的性质，因为系统启动activity是要做很多初始化工作的，而我们在应用层通过反射去启动activity是很难完成系统所做的初始化工作的，所以activity的大部分特性都无法使用包括activity的生命周期管理，这就需要我们自己去管理。谈到activity生命周期，其实就是那几个常见的方法：onCreate、onStart、onResume、onPause等，由于apk中的activity不是真正意义上的activity（没有在宿主程序中注册且没有完全初始化），所以这几个生命周期的方法系统就不会去自动调用了。针对此类问题，采用Fragment是一个不错的方法，Fragment从3.0引入，通过support-v4包，可以兼容3.0以下的android版本。Fragment既有类似于Activity的生命周期，又有类似于View的界面，将Fragment加入到Activity中，activity会自动管理Fragment的生命周期，通过第一篇文章我们知道，apk中的activity是通过宿主程序中的代理activity启动的，将Fragment加入到代理activity内部，其生命周期将完全由代理activity来管理，但是采用这种方法，就要求apk尽量采用Fragment来实现，还有就是在做页面跳转的时候有点麻烦，当然关于Fragment相关的内容我将在后面再做研究，本文不采用Fragment而是通过反射去手动管理activity的生命周期。

我们要在代理activity中去反射apk中activity的所有生命周期的方法，然后将activity的生命周期和代理activity的生命周期进行同步。首先，反射activity生命周期的所有方法，还反射了onActivityResult这个方法，尽管它不是典型的生命周期方法，但是它很有用。

[java]
 protected void instantiateLifecircleMethods(Class<?> localClass) {  
     String[] methodNames = new String[] {  
             "onRestart",  
             "onStart",  
             "onResume",  
             "onPause",  
             "onStop",  
             "onDestory"  
     };  
     for (String methodName : methodNames) {  
         Method method = null;  
         try {  
             method = localClass.getDeclaredMethod(methodName, new Class[] { });  
             method.setAccessible(true);  
         } catch (NoSuchMethodException e) {  
             e.printStackTrace();  
         }  
         mActivityLifecircleMethods.put(methodName, method);  
     }  
   
     Method onCreate = null;  
     try {  
         onCreate = localClass.getDeclaredMethod("onCreate", new Class[] { Bundle.class });  
         onCreate.setAccessible(true);  
     } catch (NoSuchMethodException e) {  
         e.printStackTrace();  
     }  
     mActivityLifecircleMethods.put("onCreate", onCreate);  
   
     Method onActivityResult = null;  
     try {  
         onActivityResult = localClass.getDeclaredMethod("onActivityResult",  
                 new Class[] { int.class, int.class, Intent.class });  
         onActivityResult.setAccessible(true);  
     } catch (NoSuchMethodException e) {  
         e.printStackTrace();  
     }  
     mActivityLifecircleMethods.put("onActivityResult", onActivityResult);  
 }  

其次，同步生命周期，主要看一下onResume和onPause，其他方法是类似的。看如下代码，很好理解，就是当系统调用代理activity生命周期方法的时候，就通过反射去显式调用apk中activity的对应方法。

[java]
 @Override  
 protected void onResume() {  
     super.onResume();  
     Method onResume = mActivityLifecircleMethods.get("onResume");  
     if (onResume != null) {  
         try {  
             onResume.invoke(mRemoteActivity, new Object[] { });  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
 }  
   
 @Override  
 protected void onPause() {  
     Method onPause = mActivityLifecircleMethods.get("onPause");  
     if (onPause != null) {  
         try {  
             onPause.invoke(mRemoteActivity, new Object[] { });  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
     super.onPause();  
 }  