目前行业内已经有较多的插件化实现方案。本文主要对DL(DynamicLoadApk)这一个开源的侵入式插件化方案进行简单分析。因为Service组件插件化的实现逻辑和Activity大体相似，所以在这里主要用Activity来分析。
基本介绍
基本概念
1、宿主:主App,可以加载插件.
2、插件:插件App.被宿主App加载的App.
3、组件:对于Android来说,指的就是Android中的四大组件(Activity、Service、BroadcastReceiver、ContentProvider)
基本使用
1、PluginActivity
public class MainActivity extends DLBasePluginActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}2、HostActivity
public class MainActivity extends AppCompatActivity {
private Button btnTest;
private TextView tvTip;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
this.btnTest = (Button) findViewById(R.id.btn_test);
this.tvTip = (TextView) findViewById(R.id.tv_tip);
this.init();
}
private void init() {
String pluginFolder = "/mnt/sdcard/PluginDir";
File file = new File(pluginFolder);
File[] plugins = file.listFiles();
if (plugins == null || plugins.length == 0) {
this.tvTip.setVisibility(View.VISIBLE);
return;
}
File plugin = plugins[0];
final PluginItem item = new PluginItem();
item.pluginPath = plugin.getAbsolutePath();
item.packageInfo = DLUtils.getPackageInfo(this, item.pluginPath);
if (item.packageInfo.activities != null && item.packageInfo.activities.length > 0) {
item.launcherActivityName = item.packageInfo.activities[1].name;//这里写死了要启动的插件Activity
}
tvTip.setText("检测到一个插件:" + item.pluginPath);
DLPluginManager.getInstance(this).loadApk(item.pluginPath);
this.btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(getApplicationContext(), "开始调用插件", Toast.LENGTH_SHORT).show();
usePlugin(item);
}
});
}
private void usePlugin(PluginItem pluginItem) {
DLPluginManager pluginManager = DLPluginManager.getInstance(this);
pluginManager.startPluginActivity(this, new DLIntent(pluginItem.packageInfo.packageName, pluginItem.launcherActivityName));
}
public static class PluginItem {
public PackageInfo packageInfo;
public String pluginPath;
public String launcherActivityName;
public String launcherServiceName;
public PluginItem() {
}
}
}
3、AndroidManifest.xml
<activity
android:name="example.hjd.com.mydl.DLProxyActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="com.hjd.dynamicload.proxy.activity.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>效果
关系示意图
解释:
1)DLPluginManager调用loadApk(...)加载插件.
2)启动插件Activity 的时候首先启动的是ProxyActivity
3)初始化插件Activity和 将插件Activity和代理Activity双向绑定
插件化中的3个基本问题
资源的加载
宿主App调起插件Apk的时候,需要访问插件中的资源,但是宿主中的R只能访问宿主中的资源，访问不了插件中的资源。这时候可以通过AssetManager加载插件apk的资源，通过新建一个Resource对象来读取插件中的资源。
/*
创建一个AssetManager,加载插件资源
*/
private AssetManager createAssetManager(String dexPath) {
try {
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPathMethod = assetManager.getClass().getMethod("addAssetPath", String.class);
/*
调用addAssetPath将目标目录下的所有资源都加载到AssetManager中
*/
addAssetPathMethod.invoke(assetManager, dexPath);
return assetManager;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/*
创建加载了插件资源的Resources
*/
private Resources createResources(AssetManager assetManager) {
Resources superResource = context.getResources();
Resources resources = new Resources(assetManager, superResource.getDisplayMetrics(), superResource.getConfiguration());
return resources;
}插件Activity生命周期的管理
插件Activity的生命周期管理常见的有以下两种实现思路:反射式、接口式。
反射式
反射式的主要实现思路是:在代理Activity中通过反射来调用插件Activity的生命周期。
Demo代码如下所示：
onResume(){
Method pluginActivityOnResume = clsObj.getMethod("onResume");
pluginActivityOnResume.invoke(...)
}接口式
使用反射来解决相应的问题在很多场景下都很常见，但是反射存在一定的性能开销。接口式的主要思想是把插件Activity中的生命周期或者其他重要节点的时机抽象成一个接口，由代理Activity去调插件Activity生命周期的方法。
Demo代码如下：
class ProxyActivity extends Activity{
DLPlugin pluginActivity;
....
onResume(){
pluginActivity.onResume();
super.onResume();
}
....
}
插件的管理
在DL中，是通过一个HashMap来实现不同插件的存取。
ex:
Map<String,PluginPackage> pluginHolders = new HashMap<>()
DLPluginManager源码简单解析
插件管理器,负责插件的加载、管理和插件组件的启动。
loadApk函数流程图
startPluginActivity函数流程图
源码
package example.hjd.com.mydl.internal;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.text.TextUtils;
import java.io.File;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import dalvik.system.DexClassLoader;
import example.hjd.com.mydl.DLBasePluginActivity;
import example.hjd.com.mydl.DLProxyActivity;
import example.hjd.com.mydl.utils.DLConstants;
import example.hjd.com.mydl.utils.SoLibManager;
/*
DynamicLoadApk的核心类
主要功能主要有:
1)加载和管理插件.(这里的插件指的是apk)
2)启动插件组件.(这里的组件包括Activity,Service)
*/
public class DLPluginManager {
public static int START_RESULT_SUCCESS = 0;
public static int START_RESULT_NO_PKG = 1;
public static int START_RESULT_NO_CLASS = 2;
public static int START_RESULT_TYPE_ERROR = 3;
private static DLPluginManager instance;
//已经加载过的插件的存储结构
private Map<String, DLPluginPackage> packageHolder = new HashMap<>();
//插件apk的so库 拷到 宿主后的存储目录
private String nativeLibDir = null;
//dex解压之后的存储路径
private String dexOutputPath;
private Context context;
//标记来源(可用于区分是直接启动插件组件,还是启动代理组件)
private int from;
/*
用于标记启动插件service的执行结果
*/
private int result;
/*
单例
*/
public static DLPluginManager getInstance(Context context) {
if (instance == null) {
synchronized (DLPluginManager.class) {
if (instance == null) {
instance = new DLPluginManager(context);
}
}
}
return instance;
}
public DLPluginManager(Context context) {
this.context = context.getApplicationContext();
//默认使用data/data/pkgName/pluginlib
this.nativeLibDir = context.getDir("pluginlib", Context.MODE_PRIVATE).getAbsolutePath();
}
/*
加载插件.
dexPath:插件的存储路径(例如/mnt/sdcard/xxxx.apk)
hasSoLib:是否含有so库.
启动插件之前必须先加载插件.
*/
public DLPluginPackage loadApk(String dexPath, boolean hasSoLib) {
//将插件的来源标记为external
from = DLConstants.FROM_EXTERNAL;
//获取插件中的activity的组件和service的组件信息
PackageInfo packageInfo = context.getPackageManager().getPackageArchiveInfo(dexPath, PackageManager.GET_ACTIVITIES | PackageManager.GET_SERVICES);
//如果没有获取到packageInfo
if (packageInfo == null) {
//直接返回null
return null;
}
//加载插件
DLPluginPackage pluginPackage = preparePluginEnv(packageInfo, dexPath);
//拷贝so库
if (hasSoLib) {
copySoLib(dexPath);
}
//返回加载完成的插件
return pluginPackage;
}
public DLPluginPackage loadApk(String dexPath) {
return loadApk(dexPath, true);
}
/*
加载插件及其资源
*/
public DLPluginPackage preparePluginEnv(PackageInfo packageInfo, String dexPath) {
/*
判断一下是否有缓存
*/
DLPluginPackage pluginPackage = packageHolder.get(packageInfo.packageName);
if (pluginPackage != null) {
return pluginPackage;
}
/*
加载插件并读取资源
*/
DexClassLoader classLoader = createDexClassLoader(dexPath);
AssetManager assetManager = createAssetManager(dexPath);
Resources resources = createResources(assetManager);
pluginPackage = new DLPluginPackage(classLoader, resources, packageInfo);
//将插件存入缓存中
packageHolder.put(packageInfo.packageName, pluginPackage);
return pluginPackage;
}
/*
创建DexClassLoader
*/
private DexClassLoader createDexClassLoader(String dexPath) {
File dexOutputFile = context.getDir("dex", Context.MODE_PRIVATE);
dexOutputPath = dexOutputFile.getAbsolutePath();
/*
dexPath:插件apk的存储路径
dexOutputPath:dex解压之后的存储路径
nativeLibDir:so库在存储路径(在宿主apk中的存储路径)
*/
DexClassLoader dexClassLoader = new DexClassLoader(dexPath, dexOutputPath, nativeLibDir, context.getClassLoader());
return dexClassLoader;
}
/*
创建一个AssetManager,加载插件资源
*/
private AssetManager createAssetManager(String dexPath) {
try {
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPathMethod = assetManager.getClass().getMethod("addAssetPath", String.class);
/*
调用addAssetPath将目标目录下的所有资源都加载到AssetManager中
*/
addAssetPathMethod.invoke(assetManager, dexPath);
return assetManager;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/*
创建加载了插件资源的Resources
*/
private Resources createResources(AssetManager assetManager) {
Resources superResource = context.getResources();
Resources resources = new Resources(assetManager, superResource.getDisplayMetrics(), superResource.getConfiguration());
return resources;
}
/*
根据packageName来从缓存中获取已经加载过的插件
*/
public DLPluginPackage getPluginPackage(String packageName) {
return packageHolder.get(packageName);
}
/*
将插件中的so库拷贝到宿主的nativeLibDir中
*/
private void copySoLib(String dexPath) {
SoLibManager.getSoLoader().copyPluginSoLib(context, dexPath, nativeLibDir);
}
/*
启动插件Activity并返回结果
如果是内部调用,直接启动插件Activity
如果是外部调用,启动代理Activity.
*/
public int startPluginActivityFroResult(Context context, DLIntent intent, int requestCode) {
//判断一下是否是内部调用
if (from == DLConstants.FROM_INTERNAL) {
//直接启用插件activity
intent.setClassName(context, intent.getPluginClsName());
performStartActivityForResult(context, intent, requestCode);
return START_RESULT_SUCCESS;
}
//获取要启动的插件的packgaeName
String pluginPkgName = intent.getPluginPkgName();
/*
检查一下plugin的packageName是否为空
*/
if (TextUtils.isEmpty(pluginPkgName)) {
new IllegalStateException("disallow null packageName");
}
/*
在内存缓存中获取该packageName所对应的package信息(判断一下该插件是否被加载过)
*/
DLPluginPackage pluginPackage = packageHolder.get(pluginPkgName);
//如果pluginPackage为空
if (pluginPackage == null) {
//表明该插件没有被加载过,直接返回NO_PKG
return START_RESULT_NO_PKG;
}
String pluginClsFullName = getPluginActivityFullPath(intent, pluginPackage);
//加载要启动的插件cls对象(使用PluginClassLoader来加载要启动的PluginClass)
Class<?> pluginCls = loadPluginClass(pluginPackage.classLoader, pluginClsFullName);
//如果要启动的插件组件的class对象为空
if (pluginCls == null) {
//返回NO_CLASS错误
return START_RESULT_NO_CLASS;
}
//根据插件Activity找到相应的代理Activity
Class<? extends Activity> proxyActivityClass = getProxyActivityClass(pluginCls);
//如果没找到对应的代理Activity
if (proxyActivityClass == null) {
//直接返回TYPE_ERROR
return START_RESULT_TYPE_ERROR;
}
/*
启动的代理Activity
*/
//在intent中设置plugin的class和packageName
intent.putExtra(DLConstants.EXTRA_CLASS, pluginClsFullName);
intent.putExtra(DLConstants.EXTRA_PACKAGE, pluginPkgName);
intent.setClass(context, proxyActivityClass);
performStartActivityForResult(context, intent, requestCode);
return START_RESULT_SUCCESS;
}
/*
根据实际情况执行startActivity操作
*/
private void performStartActivityForResult(Context context, DLIntent intent, int requestCode) {
//如果context是Activity的实例
if (context instanceof Activity) {
//调用startActivityForResult
((Activity) context).startActivityForResult(intent, requestCode);
} else {
//执行startActivity()方法
context.startActivity(intent);
}
}
/*
获取要启动的插件Activity的全路径名.
例如(example.hjd.com.plugin.MainActivity)
如果要启动的插件Activity为空,则默认启动lauch main activity.
*/
private String getPluginActivityFullPath(DLIntent intent, DLPluginPackage pluginPackage) {
String pluginClsName = intent.getPluginClsName();
//判断一下clsName是否为空
pluginClsName = (TextUtils.isEmpty(pluginClsName) ? pluginPackage.defaultActivity : pluginClsName);
//判断一下clsName是否补全,例如.xxxxActivity的情况
if (pluginClsName.startsWith(".")) {
/*
pkgName:example.hjd.com.plugin
*/
pluginClsName = intent.getPluginPkgName() + pluginClsName;
}
return pluginClsName;
}
/*
获取一个插件Activity Cls所对应的代理Activity Cls
*/
private Class<? extends Activity> getProxyActivityClass(Class<?> pluginActivityCls) {
Class<? extends Activity> proxyActivityCls = null;
//如果pluginActivityCls是DLBasePluginActivity的子类
if (DLBasePluginActivity.class.isAssignableFrom(pluginActivityCls)) {
//那么对应的代理Activity就是DLProxyActivity
proxyActivityCls = DLProxyActivity.class;
}
return proxyActivityCls;
}
/*
使用PluginClassLoader来加载PluginClass(要启动的插件组件)
*/
private Class<?> loadPluginClass(ClassLoader classLoader, String clsName) {
Class pluginCls = null;
try {
pluginCls = Class.forName(clsName, true, classLoader);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return pluginCls;
}
/*
启动插件Activity
*/
public void startPluginActivity(Context context, DLIntent intent) {
startPluginActivityFroResult(context, intent, -1);
}
}
