码迷,mamicode.com
首页 > 移动开发 > 详细

Android中插件开发篇之----动态加载Activity(免安装运行程序)

时间:2017-03-01 16:28:29      阅读:267      评论:0      收藏:0      [点我收藏+]

标签:应该   ffd   uid   sql   hsb   jmm   current   aqi   detail   

一、前言

又到周末了,时间过的很快,今天我们来看一下Android中插件开发篇的最后一篇文章的内容:动态加载Activity(免安装运行程序),在上一篇文章中说道了,如何动态加载资源(应用换肤原理解析),没看过的同学,可以转战:

http://blog.csdn.NET/jiangwei0910410003/article/details/47679843

当然,今天说道的内容还这这篇文章有关系。关于动态加载Activity的内容,网上也是有很多文章介绍了。但是他们可能大部分都是介绍通过代理的方式去实现的,所以今天我要说的加载会有两种方式:

1、使用反射机制修改类加载器

2、使用代理的方式

这两种方式都有各自的优缺点,我会在后面的文章详细解说。

 

二、技术介绍

1、第一种方式:使用反射机制修改类加载器来实现动态加载Activity

首先来看一个例子:360安全卫士

技术分享         技术分享

在主界面有一个添加更多工具的菜单,点进去之后,可以看到有很多功能选项。我们添加一个手机防盗的功能:有一个进度条开始添加。那么我们如何知道他是使用动态加载的呢?我们可以去查看他的数据文件目录:

技术分享

我们可以看到有两个目录,比较见名知意:

app_plugins_v3
app_plugins_v3_odex

第一个目录是存放需要动态加载的功能插件,第二个目录是存放加载之后释放的dex目录。

 

上面分析了360的动态加载Activity功能,下面我们就来实现以下这个功能吧:

不过我们还得了解一下Android中的类加载器的相关知识,这里就不做介绍了:我在这篇文章中详细介绍了类加载器:

http://blog.csdn.Net/jiangwei0910410003/article/details/41384667

我们知道PathClassLoader是一个应用的默认加载器(而且他只能加载data/app/xxx.apk的文件),但是我们加载插件一般使用DexClassLoader加载器,所以这里就有问题了,其实如果对于开始的时候,每个人都会认为很简单,很容易想到使用DexClassLoader来加载Activity获取到class对象,在使用Intent启动,这个很简单呀?但是实际上并不是想象的这么简单。原因很简单,因为Android中的四大组件都有一个特点就是他们有自己的启动流程和生命周期,我们使用DexClassLoader加载进来的Activity是不会涉及到任何启动流程和生命周期的概念,说白了,他就是一个普普通通的类。所以启动肯定会出错。

 

所以我们知道了问题所在,解决起来也就简单了,但是我们这里还有两种思路去解决这个问题:

 

1) 第一个思路: 替换LoadedApk中的mClassLoader

我们只要让加载进来的Activity有启动流程和生命周期就OK了,所以这里我们需要看一下一个Activity的启动过程。当然这里不会详细介绍一个Activity启动过程的,因为那个太复杂了,而且我也说不清楚,我们知道我们可以将我们使用的DexClassLoader加载器绑定到系统加载Activity的类加载器上就可以了,这个是我们的思路。也是最重要的突破点。下面我们就来通过源码看看如何找到加载Activity的类加载器。

加载Activity的时候,有一个很重要的类:LoadedApk.Java,这个类是负责加载一个Apk程序的,我们可以看一下他的源码:

技术分享

我们可以看到他内部有一个mClassLoader变量,他就是负责加载一个Apk程序的,那么我们只要获取到这个类加载器就可以了。他不是static的,所以我们还得获取一个LoadedApk对象。我们在去看一下另外一个类:ActivityThread.java的源码

技术分享

这里我们可以看到ActivityThread类中有一个自己的static对象,然后还有一个ArrayMap存放Apk包名和LoadedApk映射关系的数据结构,那么我们分析清楚了,下面就来通过反射来获取mClassLoader对象吧。

友情提示:这里可能有些同学会困惑,怎么能够找到这个mClassLoader呢。我在这里因为是为了讲解内容,所以反过来找这个东西了,其实正常情况下,我们在找关于一个Apk或者是Activity的相关信息的时候,特别是启动流程的时候,我们肯定会去找:ActivityThread.java这个类,这个类是很重要很重要的,也是关键的突破口,它内部其实有很多信息的,所以,我们应该先去找这个ActivityThread,然后从这个类中发现信息,然后会找到了LoadedApk这个类。关于ActivityThread这个类,为何如此重要,我们可以在看看他的源码:

技术分享

他有这个方法?这个方法看到很熟悉呀?他不是Java程序运行的入口main方法吗?是的,没错,所有的app程序的执行入口就是这里,所以以后有人问你Android中程序运行的入口是哪里?不要再说是Application的onCreate方法了,其实是ActivityThread中的main方法。

 

好的,回到主干上来,我们现在开始编写代码来实现反射获取mClassLoader类,然后将其替换成我们的DexClassLoader类,不多说了,看一下Demo工程结构:

PluginActivity1 ==》插件工程

DynamicActivityForClassLoader ==》宿主工程

其中PluginActivity1工程很简单啦,就一个Activiity:

 

[java] view plain copy
 
  1. package com.example.dynamicactivityapk;  
  2.   
  3. import android.app.Activity;  
  4. import android.os.Bundle;  
  5. import android.view.View;  
  6. import android.view.View.OnClickListener;  
  7. import android.widget.Toast;  
  8.   
  9. public class MainActivity extends Activity {  
  10.       
  11.     private static View parentView;  
  12.   
  13.     @Override  
  14.     protected void onCreate(Bundle savedInstanceState) {  
  15.         super.onCreate(savedInstanceState);  
  16.         if(parentView == null){  
  17.             setContentView(R.layout.activity_main);  
  18.         }else{  
  19.             setContentView(parentView);  
  20.         }  
  21.           
  22.         findViewById(R.id.btn).setOnClickListener(new OnClickListener(){  
  23.   
  24.             @Override  
  25.             public void onClick(View arg0) {  
  26.                 Toast.makeText(getApplicationContext(), "I came from 插件~~", Toast.LENGTH_LONG).show();  
  27.             }});  
  28.           
  29.     }  
  30.       
  31.     public static void setLayoutView(View view){  
  32.         parentView = view;  
  33.     }  
  34.   
  35. }  


我们看到其实这里有一个问题,为何要定义一个setLayoutView的方法,这个我们后面会说道。

 

我们编译这个工程,得到PluginActivity1.apk程序:

技术分享

 

下面来看一下宿主工程

宿主工程其实最大的功能就是加载上面的PluginActivity1.apk,然后启动内部的MainActivity就可以了,这里的核心代码就是如何通过反射替换系统的mClassLoader类:

 

[java] view plain copy
 
  1. @SuppressLint("NewApi")  
  2. private void loadApkClassLoader(DexClassLoader dLoader){  
  3.     try{  
  4.   
  5.         String filesDir = this.getCacheDir().getAbsolutePath();  
  6.         String libPath = filesDir + File.separator +"PluginActivity1.apk";  
  7.   
  8.         // 配置动态加载环境  
  9.         Object currentActivityThread = RefInvoke.invokeStaticMethod(  
  10.                 "android.app.ActivityThread", "currentActivityThread",  
  11.                 new Class[] {}, new Object[] {});//获取主线程对象  
  12.         String packageName = this.getPackageName();//当前apk的包名  
  13.         ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldOjbect(  
  14.                 "android.app.ActivityThread", currentActivityThread,  
  15.                 "mPackages");  
  16.         WeakReference wr = (WeakReference) mPackages.get(packageName);  
  17.         RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader",  
  18.                 wr.get(), dLoader);  
  19.   
  20.         Log.i("demo", "classloader:"+dLoader);  
  21.   
  22.     }catch(Exception e){  
  23.         Log.i("demo", "load apk classloader error:"+Log.getStackTraceString(e));  
  24.     }  
  25.   
  26. }  

 

这里有一个参数就是需要替换的DexClassLoader的,从外部传递过来,然后进行替换。我们看看外部定义的DexClassLoader类:

[java] view plain copy
 
  1. String filesDir = this.getCacheDir().getAbsolutePath();  
  2. String libPath = filesDir + File.separator +"PluginActivity1.apk";  
  3. Log.i("inject", "fileexist:"+new File(libPath).exists());  
  4.   
  5. //loadResources(libPath);  
  6.   
  7. DexClassLoader loader = new DexClassLoader(libPath, filesDir,filesDir, getClassLoader());  

 

 

这里,需要注意的是,DexClassLoader的最后一个参数,是DexClassLoader的parent,这里需要设置成PathClassLoader类,因为我们上面虽然说是替换PathClassLoader为DexClassLoader。但是PathClassLoader是系统本身默认的类加载器(也就是mClassLoader变量的值,我们如果单独的将DexClassLoader设置为mClassLoader的值的话,就会出错的),所以一定要讲DexClassLoader的父加载器设置成PathClassLoader,因为类加载器是符合双亲委派机制的。

 

下面我们来运行一下这个程序,首先我们将PluginActivity1.apk放到宿主工程的data/data/cache目录下:

技术分享

运行程序,点击加载:

技术分享

 

运行发现失败,说是插件中的那个MainActivity没有在AndroidManifest.xml中声明?不对呀,我们在插件工程中明明声明了呀,为何他还是提示没有声明呢?

技术分享

哎,其实仔细想想原因很简单的,因为DexClassLoader加载插件Apk,不会将其xml中的内容加载进来,所以在插件中声明是没有任何用途的,必须在宿主工程中声明:

 

[java] view plain copy
 
  1. <activity   
  2.     android:name="com.example.dynamicactivityapk.MainActivity">  
  3. </activity>  

 

我们在运行程序:

技术分享

我们点击按钮,看效果啦。果然可以加载成功了啦啦啦。很开心了。

不过这里还是需要注意两个问题:

1>、因为要加载插件中的资源,所以需要调用loadResources方法

2>、在测试的过程中,发现插件工程中setContentView方法没有效果了。所以就在插件工程中定义一个static的方法,用来提前设置视图的。

 

2) 第二思路:合并PathClassLoader和DexClassLoader中的dexElements数组

好了,这里就介绍了一个如何使用反射机制来动态加载一个Activity了,但是到这里还没有结束呢?因为还要介绍另外一种方式来设置类加载器。

我们首先来看一下PathClassLoader和DexClassLoader类加载器的父类BaseDexClassloader的源码:

(这里需要注意的是PathClassLoader和DexClassLoader类的父加载器是BootClassLoader,他们的父类是BaseDexClassLoader)

技术分享

这里有一个DexPathList对象,在来看一下DexPathList.java源码:

技术分享

首先看一下这个类的描述,还有一个Elements数组,我们看到这个变量他是专门存放加载的dex文件的路径的,系统默认的类加载器是PathClassLoader,本身一个程序加载之后会释放一个dex出来,这时候会将dex路径放到里面,当然DexClassLoader也是一样的,那么我们会想到,我们是否可以将DexClassLoader中的dexElements和PathClassLoader中的dexElements进行合并,然后在设置给PathClassLoader中呢?这也是一个思路。我们来看代码:

 

[java] view plain copy
 
  1. /** 
  2.  * 以下是一种方式实现的 
  3.  * @param loader 
  4.  */  
  5. private void inject(DexClassLoader loader){  
  6.     PathClassLoader pathLoader = (PathClassLoader) getClassLoader();  
  7.   
  8.     try {  
  9.         Object dexElements = combineArray(  
  10.                 getDexElements(getPathList(pathLoader)),  
  11.                 getDexElements(getPathList(loader)));  
  12.         Object pathList = getPathList(pathLoader);  
  13.         setField(pathList, pathList.getClass(), "dexElements", dexElements);  
  14.     } catch (IllegalArgumentException e) {  
  15.         e.printStackTrace();  
  16.     } catch (NoSuchFieldException e) {  
  17.         e.printStackTrace();  
  18.     } catch (IllegalAccessException e) {  
  19.         e.printStackTrace();  
  20.     } catch (ClassNotFoundException e) {  
  21.         e.printStackTrace();  
  22.     }  
  23. }  
  24.   
  25. private static Object getPathList(Object baseDexClassLoader)  
  26.         throws IllegalArgumentException, NoSuchFieldException, IllegalAccessException, ClassNotFoundException {  
  27.     ClassLoader bc = (ClassLoader)baseDexClassLoader;  
  28.     return getField(baseDexClassLoader, Class.forName("dalvik.system.BaseDexClassLoader"), "pathList");  
  29. }  
  30.   
  31. private static Object getField(Object obj, Class<?> cl, String field)  
  32.         throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {  
  33.     Field localField = cl.getDeclaredField(field);  
  34.     localField.setAccessible(true);  
  35.     return localField.get(obj);  
  36. }  
  37.   
  38. private static Object getDexElements(Object paramObject)  
  39.         throws IllegalArgumentException, NoSuchFieldException, IllegalAccessException {  
  40.     return getField(paramObject, paramObject.getClass(), "dexElements");  
  41. }  
  42. private static void setField(Object obj, Class<?> cl, String field,  
  43.         Object value) throws NoSuchFieldException,  
  44.         IllegalArgumentException, IllegalAccessException {  
  45.   
  46.     Field localField = cl.getDeclaredField(field);  
  47.     localField.setAccessible(true);  
  48.     localField.set(obj, value);  
  49. }  
  50.   
  51. private static Object combineArray(Object arrayLhs, Object arrayRhs) {  
  52.     Class<?> localClass = arrayLhs.getClass().getComponentType();  
  53.     int i = Array.getLength(arrayLhs);  
  54.     int j = i + Array.getLength(arrayRhs);  
  55.     Object result = Array.newInstance(localClass, j);  
  56.     for (int k = 0; k < j; ++k) {  
  57.         if (k < i) {  
  58.             Array.set(result, k, Array.get(arrayLhs, k));  
  59.         } else {  
  60.             Array.set(result, k, Array.get(arrayRhs, k - i));  
  61.         }  
  62.     }  
  63.     return result;  
  64. }  

我们在运行宿主程序,发现发现也是可以的,这里就不演示了,效果都是一样的。

 

这里总结一下:

我们在使用反射机制来动态加载Activity的时候,有两个思路:

1>、替换LoadApk类中的mClassLoader变量的值,将我们动态加载类DexClassLoader设置为mClassLoader的值

2>、合并系统默认加载器PathClassLoader和动态加载器DexClassLoader中的dexElements数组

这两个的思路原理都是一样的:就是让我们动态加载进来的Activity能够具备正常的启动流程和生命周期。

 

项目下载地址:http://download.csdn.net/detail/jiangwei0910410003/9063377

 

2、第二种方式来动态加载Activity:静态代理的方式

首先我们也是先来看一个例子:23Code

这个应用的功能就是实时的展示一些开源的UI控件。他是在线下载,然后动态加载进行展示的:

技术分享            技术分享

我们看到,点击运行Demo的时候,他会去下载apk,我们看看他的数据目录结构:

技术分享

技术分享

这里我们看到了,他把下载之后的apk都用每个插件的功能包名存起来的。

好了,上面分析了23Code的加载机制,我们来看看如何使用代理的方式来动态加载Activity

先来看看原理:

技术分享

所以说,这种方式来加载Activity的话,其实真正意义上每个插件的Activity都不再是想方式一中的那样,没有生命周期,没有启动流程了,他们就是一个普通的Activity类,然后将其生命周期的所有任务都交给代理Activity去执行就可以了。

下面我们来看一下项目工程:

1、DynamicActivityForProxy ==》宿主工程

2、PluginActivity2 ==》插件工程

看一下插件工程

BaseActivity.java

[java] view plain copy
 
  1. package com.example.dynamicactivity;  
  2.   
  3. import com.example.dynamicactivity.R;  
  4.   
  5. import android.app.Activity;  
  6. import android.os.Bundle;  
  7. import android.view.View;  
  8. import android.view.View.OnClickListener;  
  9. import android.widget.Toast;  
  10.   
  11. public class BaseActivity extends Activity {  
  12.     protected Activity mProxyActivity;  
  13.   
  14.     public void setProxy(Activity proxyActivity) {   
  15.         mProxyActivity = proxyActivity;  
  16.     }  
  17.   
  18.     @Override  
  19.     protected void onCreate(Bundle savedInstanceState) {  
  20.     }  
  21.   
  22.     @Override  
  23.     public void setContentView(int layoutResID) {   
  24.         if (mProxyActivity != null && mProxyActivity instanceof Activity) {  
  25.             mProxyActivity.setContentView(layoutResID);  
  26.             mProxyActivity.findViewById(R.id.btn).setOnClickListener(  
  27.                     new OnClickListener() {  
  28.                         @Override  
  29.                         public void onClick(View v) {  
  30.                             Toast.makeText(mProxyActivity, "我是插件,你是谁!",Toast.LENGTH_LONG).show();  
  31.                         }  
  32.                     });  
  33.         }  
  34.     }  
  35.   
  36. }  

这里会重写setContentView的方法,同时有一个setProxy方法。

 

在来看一下MainActivity.java

[java] view plain copy
 
  1. package com.example.dynamicactivity;  
  2.   
  3. import com.example.dynamicactivity.R;  
  4.   
  5. import android.os.Bundle;  
  6. import android.util.Log;  
  7.   
  8. public class MainActivity extends BaseActivity {  
  9.       
  10.     @Override  
  11.     protected void onCreate(Bundle savedInstanceState) {  
  12.         super.onCreate(savedInstanceState);  
  13.         setContentView(R.layout.activity_main);  
  14.     }  
  15.   
  16.     @Override  
  17.     protected void onDestroy() {  
  18.         //这里需要注意的是,不能调用super.onDestroy的方法了,不然报错,原因也很简单,这个Activity实质上不是真正的Activity了,没有生命周期的概念了,调用super的方法肯定报错  
  19.         Log.i("demo", "onDestory");  
  20.     }  
  21.   
  22.     @Override  
  23.     protected void onPause() {  
  24.         Log.i("demo", "onPause");  
  25.     }  
  26.   
  27.     @Override  
  28.     protected void onResume() {  
  29.         Log.i("demo", "onResume");  
  30.     }  
  31.   
  32.     @Override  
  33.     protected void onStart() {  
  34.         Log.i("demo", "onStart");  
  35.     }  
  36.   
  37.     @Override  
  38.     protected void onStop() {  
  39.         Log.i("demo", "onStop");  
  40.     }  
  41.       
  42.       
  43.   
  44. }  

这里打印一下生命周期中的每个方法,待会需要验证。

 

注意:这里的生命周期方法不能再调用super.XXX方法了,否则会报错的,原因很简单啦。插件Activity不在是真正意义上的Activity了,就是一个空壳的Activity。所以调用的话,肯定会出错

运行插件工程,得到一个PluginActivity2.apk

 

下面来看一下宿主工程:

首先我们来看一下重要的代理对象ProxyActiviity

[java] view plain copy
 
  1. package com.example.dynamic.activity;  
  2.   
  3. import java.io.File;  
  4. import java.lang.reflect.Constructor;  
  5. import java.lang.reflect.Method;  
  6. import java.util.HashMap;  
  7.   
  8. import android.annotation.SuppressLint;  
  9. import android.app.Activity;  
  10. import android.os.Bundle;  
  11. import android.util.Log;  
  12. import dalvik.system.DexClassLoader;  
  13.   
  14. public class ProxyActivity extends BaseActivity {  
  15.       
  16.     private Object pluginActivity;  
  17.     private Class<?> pluginClass;  
  18.       
  19.     private HashMap<String, Method> methodMap = new HashMap<String,Method>();  
  20.   
  21.     @SuppressLint("NewApi")  
  22.     @Override  
  23.     protected void onCreate(Bundle savedInstanceState) {  
  24.         super.onCreate(savedInstanceState);  
  25.         try {  
  26.             DexClassLoader loader = initClassLoader();  
  27.               
  28.             //动态加载插件Activity  
  29.             pluginClass = loader.loadClass("com.example.dynamicactivity.MainActivity");  
  30.             Constructor<?> localConstructor = pluginClass.getConstructor(new Class[] {});  
  31.             pluginActivity = localConstructor.newInstance(new Object[] {});  
  32.   
  33.             //将代理对象设置给插件Activity  
  34.             Method setProxy = pluginClass.getMethod("setProxy",new Class[] { Activity.class });   
  35.             setProxy.setAccessible(true);  
  36.             setProxy.invoke(pluginActivity, new Object[] { this });  
  37.               
  38.             initMethodMap();  
  39.   
  40.             //调用它的onCreate方法  
  41.             Method onCreate = pluginClass.getDeclaredMethod("onCreate",  
  42.                     new Class[] { Bundle.class });  
  43.             onCreate.setAccessible(true);  
  44.             onCreate.invoke(pluginActivity, new Object[] { new Bundle() });  
  45.               
  46.         } catch (Exception e) {  
  47.             Log.i("demo", "load activity error:"+Log.getStackTraceString(e));  
  48.         }  
  49.     }  
  50.       
  51.     /** 
  52.      * 存储每个生命周期的方法 
  53.      */  
  54.     private void initMethodMap(){  
  55.         methodMap.put("onPause", null);  
  56.         methodMap.put("onResume", null);  
  57.         methodMap.put("onStart", null);  
  58.         methodMap.put("onStop", null);  
  59.         methodMap.put("onDestroy", null);  
  60.           
  61.         for(String key : methodMap.keySet()){  
  62.             try{  
  63.                 Method method = pluginClass.getDeclaredMethod(key);  
  64.                 method.setAccessible(true);  
  65.                 methodMap.put(key, method);  
  66.             }catch(Exception e){  
  67.                 Log.i("demo", "get method error:"+Log.getStackTraceString(e));  
  68.             }  
  69.         }  
  70.           
  71.     }  
  72.       
  73.     @SuppressLint("NewApi")  
  74.     private DexClassLoader initClassLoader(){  
  75.         String filesDir = this.getCacheDir().getAbsolutePath();  
  76.         String libPath = filesDir + File.separator +"PluginActivity2.apk";  
  77.         Log.i("inject", "fileexist:"+new File(libPath).exists());  
  78.         loadResources(libPath);  
  79.         DexClassLoader loader = new DexClassLoader(libPath, filesDir,null , getClass().getClassLoader());  
  80.         return loader;  
  81.     }  
  82.       
  83.     @Override  
  84.     protected void onDestroy() {  
  85.         super.onDestroy();  
  86.         Log.i("demo", "proxy onDestroy");  
  87.         try{  
  88.             methodMap.get("onDestroy").invoke(pluginActivity, new Object[]{});  
  89.         }catch(Exception e){  
  90.             Log.i("demo", "run destroy error:"+Log.getStackTraceString(e));  
  91.         }  
  92.     }  
  93.   
  94.     @Override  
  95.     protected void onPause() {  
  96.         super.onPause();  
  97.         Log.i("demo", "proxy onPause");  
  98.         try{  
  99.             methodMap.get("onPause").invoke(pluginActivity, new Object[]{});  
  100.         }catch(Exception e){  
  101.             Log.i("demo", "run pause error:"+Log.getStackTraceString(e));  
  102.         }  
  103.     }  
  104.   
  105.     @Override  
  106.     protected void onResume() {  
  107.         super.onResume();  
  108.         Log.i("demo", "proxy onResume");  
  109.         try{  
  110.             methodMap.get("onResume").invoke(pluginActivity, new Object[]{});  
  111.         }catch(Exception e){  
  112.             Log.i("demo", "run resume error:"+Log.getStackTraceString(e));  
  113.         }  
  114.     }  
  115.   
  116.     @Override  
  117.     protected void onStart() {  
  118.         super.onStart();  
  119.         Log.i("demo", "proxy onStart");  
  120.         try{  
  121.             methodMap.get("onStart").invoke(pluginActivity, new Object[]{});  
  122.         }catch(Exception e){  
  123.             Log.i("demo", "run start error:"+Log.getStackTraceString(e));  
  124.         }  
  125.     }  
  126.   
  127.     @Override  
  128.     protected void onStop() {  
  129.         super.onStop();  
  130.         Log.i("demo", "proxy onStop");  
  131.         try{  
  132.             methodMap.get("onStop").invoke(pluginActivity, new Object[]{});  
  133.         }catch(Exception e){  
  134.             Log.i("demo", "run stop error:"+Log.getStackTraceString(e));  
  135.         }  
  136.     }  
  137.   
  138. }  

这里主要就是:

 

1、加载插件Activity

2、使用反射将代理对象设置给插件Activity

3、测试插件Activity中的生命周期方法

运行程序,我们将上面的PluginActivity2.apk放到宿主程序的cache目录下:

技术分享

运行:

技术分享

也是成功了,看到效果啦啦,同时我们打印一下Log日志:

技术分享

插件Activity的每个生命周期的方法也是都执行了。

到这里我们就讲解完了使用代理的方式来实现动态加载Activity。这种方式其实还是很简单的。

 

项目下载地址:http://download.csdn.net/detail/jiangwei0910410003/9063483

 

总算是讲完了,累死了,两种方式各有千秋,各有各的好处。

 

三、案例分析

上面讲解的两种方式的时候,介绍了两个例子:一个是360卫士,一个是23Code

为什么要用这两个例子呢?原因下载说明一下啦:

1、首先来看一下360卫士,我们打开它的一个辅助功能:

使用:adb shell dumpsys activity top

技术分享

我们再来看一下他的AndroidManifest.xml内容:

技术分享

我们可以看到,他在宿主工程中声明了,而且我们会看到有很多个辅助功能都声明了。所以我们断定他使用的是第一种方式去实现动态加载的,所以我们可以看到这种方式有一个不好就是:需要在宿主工程中声明很多个插件Activity。

 

2、在来看一下23Code应用

运行一个例子之后,我们看到他的Activity是TestActivity

技术分享

我们再去切换另外一个例子运行之后,也是发现还是这个TestActivity。看看他的AndroidManifest.xml

技术分享

那么我们断定,这个TestActivity就是一个代理的Activity,他使用的是第二种方式来实现动态加载的。

现在知道为何我开始的时候为什么用这两个例子来说明了吧。

 

四、两种方式的比较

第一种方式:使用反射机制来实现

优点:可以不用太多的关心插件中的Activity的生命周期方法,因为他加载进来之后就是一个真正意义上的Activity了

缺点:需要在宿主工程中进行声明,如果插件中的Activity多的话,那么就不灵活了。

第二种方式:使用代理机制来实现

优点:不需要在宿主工程中进行声明太多的Activity了,只需要有一个代理Activity的声明就可以了,很灵活

缺点:需要管理手动的去管理插件中Activity的生命周期方法,难度复杂。

 

五、存在的问题

我们看到上面讲到的两种方式去动态加载Activity,其实两种方式都还存在很多问题:

1、其他组件的动态加载问题(服务,广播,ContentProvier)

2、跨进程访问的问题

 

六、总结

这篇文章讲完之后,那么插件开发篇的三部曲就算结束了,Android中的插件开发也算是有一个好的总结了,也是讲解了现在主流市场中加载的原理和机制。当然我们在真正的使用过程中还会存在很多问题,当然这个就需要我们自己去探索和解决了。

(PS:两种方式的项目下载地址都在上面给出了,如果在运行的过程中有什么问题的话,请留言。能帮就尽量帮助解决一下~~)

Android中插件开发篇之----动态加载Activity(免安装运行程序)

标签:应该   ffd   uid   sql   hsb   jmm   current   aqi   detail   

原文地址:http://www.cnblogs.com/chenxibobo/p/6075024.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!