插件化框架DL源码的简单解析

目前行业内已经有较多的插件化实现方案。本文主要对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);
    }


}