现状

最近在接触插件化方面的技术，学习后赶紧坐下笔记，给入门的朋友看，一起学习，一起进步。
当前比较热门的插件化框架有下面几个：

框架	优点	缺点
dynamic-load-apk	1.插件无需安装host即可吊起 2.支持R访问插件资源 3.插件支持Activity和FragmentActivity 4.基本无反射调用 5.插件安装后任可独立运行	1.不支持Service和BroadcastReceiver 2.迁移成本，需要修改插件，插件app需要继承自proxyActivity
Droid Plugin	1.插件无需任何修改，可独立安装运行，也可以做插件运行 2.四大组件无需在Host程序注册 3.超强隔离性，不同插件运行在不同的进程中 4.资源完全隔离 5.实现进程管理，插件的空进程会被及时回收，占用内存低插件的静态广播会被当作动态处理，如果插件没有运行，静态广播永远不会触发 6.API侵入性低	1.无法使用自定义资源的通知 2.无法注册一些特殊Intent Filter的组件（四大组件） 3.对Native支持不好
DynamicAPK	1.迁移成本低（无需做任何activity/fragment/resource的proxy实现）不使用代理来管理插件的activity/fragment的生命周期。修改后aapt会处理插件种的资源，R.java中的资源引用和普通Android工程没有区别，开发者可以保持原有的开发规范 2.更加有利于并发开发 3.提升编译速度 4.提升启动速度。dex解压、dexopt、加载耗时较长，使用按需加载启动时间过长 5.适合HotFix（代码和资源） 6.按需下载和加载任意功能模块（包含代码和资源）	目前已停止维护
RePlugin	1.极其灵活：主程序无需升级（无需在Manifest中预埋组件），即可支持新增的四大组件，甚至全新的插件 2.非常稳定：Hook点仅有一处（ClassLoader），无任何Binder Hook！如此可做到其崩溃率仅为“万分之一”，并完美兼容市面上近乎所有的Android ROM 3.特性丰富：支持近乎所有在“单品”开发时的特性。包括静态Receiver、Task-Affinity坑位、自定义Theme、进程坑位、AppCompat、DataBinding等 4.易于集成：无论插件还是主程序，只需“数行”就能完成接入 5.管理成熟：拥有成熟稳定的“插件管理方案”，支持插件安装、升级、卸载、版本管理，甚至包括进程通讯、协议版本、安全校验等 6.数亿支撑：有360手机卫士庞大的数亿用户做支撑，三年多的残酷验证，确保App用到的方案是最稳定、最适合使用的

介绍

下面我们主要介绍的就是RePlugin框架.中文文档地址：https://github.com/Qihoo360/RePlugin/blob/dev/README_CN.md。
官方对这个框架的介绍：
RePlugin是一套完整的、稳定的、适合全面使用的，占坑类插件化方案，由360手机卫士的RePlugin Team研发，也是业内首个提出”全面插件化“（全面特性、全面兼容、全面使用）的方案。
其主要优势有：

极其灵活：主程序无需升级（无需在Manifest中预埋组件），即可支持新增的四大组件，甚至全新的插件
非常稳定：Hook点仅有一处（ClassLoader），无任何Binder Hook！如此可做到其崩溃率仅为“万分之一”，并完美兼容市面上近乎所有的Android ROM
特性丰富：支持近乎所有在“单品”开发时的特性。包括静态Receiver、Task-Affinity坑位、自定义Theme、进程坑位、AppCompat、DataBinding等
易于集成：无论插件还是主程序，只需“数行”就能完成接入
管理成熟：拥有成熟稳定的“插件管理方案”，支持插件安装、升级、卸载、版本管理，甚至包括进程通讯、协议版本、安全校验等
数亿支撑：有360手机卫士庞大的数亿用户做支撑，三年多的残酷验证，确保App用到的方案是最稳定、最适合使用的

支持的特性：

特性	描述
组件	四大组件（含静态Receiver）
升级无需改主程序Manifest	完美支持
Android特性	支持近乎所有（包括SO库等）
TaskAffinity & 多进程	支持（坑位方案）
插件类型	支持自带插件（自识别）、外置插件
插件间耦合	支持Binder、Class Loader、资源等
进程间通讯	支持同步、异步、Binder、广播等
自定义Theme & AppComat	支持
DataBinding	支持
安全校验	支持
资源方案	独立资源 + Context传递（相对稳定）
Android 版本	API Level 9+ （2.3及以上）

使用

一、添加依赖

项目目录下的build.gradle文件：

dependencies {
        classpath 'com.android.tools.build:gradle:3.0.0'

        classpath 'com.qihoo360.replugin:replugin-host-gradle:2.2.1'
        classpath 'com.qihoo360.replugin:replugin-plugin-gradle:2.2.1'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }

宿主目录下的build.gradle文件

apply plugin: 'replugin-host-gradle'
/**
 * 配置项均为可选配置，默认无需添加
 * 更多可选配置项参见replugin-host-gradle的RepluginConfig类
 * 可更改配置项参见 自动生成RePluginHostConfig.java
 */
repluginHostConfig {
    /**
     * 是否使用 AppCompat 库
     * 不需要个性化配置时，无需添加
     */
    useAppCompat = true
//    /**
//     * 背景不透明的坑的数量
//     * 不需要个性化配置时，无需添加
//     */
//    countNotTranslucentStandard = 6
//    countNotTranslucentSingleTop = 2
//    countNotTranslucentSingleTask = 3
//    countNotTranslucentSingleInstance = 2
}

dependencies {
     ……………………………………………………………………………
    compile 'com.qihoo360.replugin:replugin-host-lib:2.2.1'
}

插件目录下的build.gradle文件

apply plugin: 'replugin-plugin-gradle'

dependencies {
    ……………………………………………………………………………
    compile 'com.qihoo360.replugin:replugin-plugin-lib:2.2.1'
}

修改完上面的文件后，点击sync后，就可以开始实现插件化了。

配置Application类

如果您的工程已有Application类，则可以将基类切换到RePluginApplication即可。然后可以通过自定义RePluginCallbacks类和RePluginEventCallbacks类来实现宿主针对RePlugin的自定义行为

public class MyApplication extends RePluginApplication{
    @Override
    public void onCreate() {
        super.onCreate();
        RePlugin.App.onCreate();
    }
    @Override
    protected RePluginConfig createConfig() {
        RePluginConfig c = new RePluginConfig();
        // 允许“插件使用宿主类”。默认为“关闭”
        c.setUseHostClassIfNotFound(true);
        // FIXME RePlugin默认会对安装的外置插件进行签名校验，这里先关掉，避免调试时出现签名错误
        c.setVerifySign(false);
        c.setPrintDetailLog(BuildConfig.DEBUG);
        c.setUseHostClassIfNotFound(true);
        // 针对“安装失败”等情况来做进一步的事件处理
        c.setEventCallbacks(new HostEventCallbacks(this));
        c.setMoveFileWhenInstalling(true);
        // FIXME 若宿主为Release，则此处应加上您认为"合法"的插件的签名，例如，可以写上"宿主"自己的。
        // RePlugin.addCertSignature("AAAAAAAAA");

        return c;
    }
    @Override
    protected RePluginCallbacks createCallbacks() {
        return new HostCallbacks(this);
    }

}

/**
 * 宿主针对RePlugin的自定义行为
 */
public class HostCallbacks extends RePluginCallbacks {

    public HostCallbacks(Context context) {
        super(context);
    }

    @Override
    public boolean onLoadLargePluginForActivity(Context context, String plugin, Intent intent, int process) {
        return super.onLoadLargePluginForActivity(context, plugin, intent, process);
    }

    @Override
    public boolean onPluginNotExistsForActivity(final Context context, final String plugin, Intent intent, int process) {
        // FIXME 当插件"没有安装"时触发此逻辑，可打开您的"下载对话框"并开始下载。
        // FIXME 其中"intent"需传递到"对话框"内，这样可在下载完成后，打开这个插件的Activity
        if (BuildConfig.DEBUG) {
            Log.d("morse", "onPluginNotExistsForActivity: Start download... p=" + plugin + "; i=" + intent);
        }
        return super.onPluginNotExistsForActivity(context, plugin, intent, process);
    }
}

public class HostEventCallbacks extends RePluginEventCallbacks {
    public HostEventCallbacks(Context context) {
        super(context);
    }

    @Override
    public void onInstallPluginSucceed(PluginInfo info) {
        Log.d("morse", "onInstallPluginSucceed: Failed! info=" + info);
        super.onInstallPluginSucceed(info);
    }

    @Override
    public void onInstallPluginFailed(String path, InstallResult code) {
        // FIXME 当插件安装失败时触发此逻辑。您可以在此处做“打点统计”，也可以针对安装失败情况做“特殊处理”
        // 大部分可以通过RePlugin.install的返回值来判断是否成功
        Log.d("morse", "onInstallPluginFailed: Failed! path=" + path + "; r=" + code);
        super.onInstallPluginFailed(path, code);
    }

    @Override
    public void onStartActivityCompleted(String plugin, String activity, boolean result) {
        // FIXME 当打开Activity成功时触发此逻辑，可在这里做一些APM、打点统计等相关工作
        Log.d("morse", "onStartActivityCompleted: plugin=" + plugin + "\r\n result=" + result);
        super.onStartActivityCompleted(plugin, activity, result);
    }
}

安装或者升级插件

思路：
1、判断插件是否已经安装；
2、如果没有安装，检测本地是否下载插件；
3、没有下载插件，需要先下载插件；
4、如果没有安装插件，需要安装插件；

private void startRePlugin(String pluginName,String apkPath) {
        //安装插件过程
        PluginInfo pluginInfo = RePlugin.getPluginInfo(pluginName);
        //插件文件，只有存在就进行安装或者更新
        File file = new File(apkPath);
        //判断是否已经安装插件
        if (pluginInfo == null) {
            //插件未安装的情况
            if (!file.exists()) {
                Toast.makeText(HostActivity.this, "插件安装失败，插件文件不存在", Toast.LENGTH_SHORT).show();
            } else {
                //安装插件
                PluginInfo pluginInfo1 = RePlugin.install(apkPath);
                if (pluginInfo1 == null) {
                    Toast.makeText(HostActivity.this, "插件安装失败，安装出错", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(HostActivity.this, "插件安装成功", Toast.LENGTH_SHORT).show();
                }
            }

        } else {
            //插件已安装,是否需要升级，判断条件是file是否为空
            if (file.exists()) {
                PluginInfo pluginInfo1 = RePlugin.install(file.getAbsolutePath());
                if (pluginInfo1 == null) {
                    Toast.makeText(HostActivity.this, "插件升级失败", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(HostActivity.this, "插件升级成功", Toast.LENGTH_SHORT).show();
                }
            } else {
                Toast.makeText(HostActivity.this, "插件已安装", Toast.LENGTH_SHORT).show();
                RePlugin.preload(pluginInfo);
            }
        }
    }

宿主调用插件

打开插件的activity

可以直接调用Replugin.startActivity方式，然后传入相应的参数就可以了，也可以通过forResult的方法进行启动。有挺多个重载的方法可以调用，具体的源码是位于RePlugin这个类中

    /**
     * 开启一个插件的Activity <p>
     * 其中Intent的ComponentName的Key应为插件名（而不是包名），可使用createIntent方法来创建Intent对象
     *
     * @param context Context对象
     * @param intent  要打开Activity的Intent，其中ComponentName的Key必须为插件名
     * @return 插件Activity是否被成功打开？
     * FIXME 是否需要Exception来做？
     * @see #createIntent(String, String)
     * @since 1.0.0
     */
    public static boolean startActivity(Context context, Intent intent) {
        // TODO 先用旧的开启Activity方案，以后再优化
        ComponentName cn = intent.getComponent();
        if (cn == null) {
            // TODO 需要支持Action方案
            return false;
        }
        String plugin = cn.getPackageName();
        String cls = cn.getClassName();
        return Factory.startActivityWithNoInjectCN(context, intent, plugin, cls, IPluginManager.PROCESS_AUTO);
    }

    /**
     * 通过 forResult 方式启动一个插件的 Activity
     *
     * @param activity    源 Activity
     * @param intent      要打开 Activity 的 Intent，其中 ComponentName 的 Key 必须为插件名
     * @param requestCode 请求码
     * @param options     附加的数据
     * @see #startActivityForResult(Activity, Intent, int, Bundle)
     * @since 2.1.3
     */
    public static boolean startActivityForResult(Activity activity, Intent intent, int requestCode, Bundle options) {
        return Factory.startActivityForResult(activity, intent, requestCode, options);
    }

绑定插件中的service

跟启动插件中的activity方式差不多，具体的源码是位于PluginServiceClient这个类中，下面是绑定service的方法：

  /**
     * 绑定插件服务，获取其AIDL。近似于Context.bindService
     *
     * @param context Context对象
     * @param intent  要打开的服务名。如何填写请参见类的说明
     * @param sc      ServiceConnection对象（等同于系统）
     * @param flags   flags对象。目前仅支持BIND_AUTO_CREATE标志
     * @return 是否成功绑定服务。大于0表示成功
     * @see android.content.Context#bindService(Intent, ServiceConnection, int)
     */
    public static boolean bindService(Context context, Intent intent, ServiceConnection sc, int flags) {
        return bindService(context, intent, sc, flags, false);
    }

插件调用宿主组件

打开宿主的activity，更加简单。调用service也是一样的道理。

Intent intent = new Intent();
intent.setComponent(new ComponentName("com.qihoo360.replugin.sample.host", "com.qihoo360.replugin.sample.host.MainActivity"));
context.startActivity(intent);

Intent intent1 = new Intent();
                intent1.setComponent(new ComponentName("com.example.asus.replugindemo",
                        "com.example.asus.replugindemo.HostService"));
                startService(intent1);

资源的互相获取

因为插件apk与宿主apk不在一个apk内，那么一些资源的访问必然要通过反射进行获取。

宿主获取插件资源

Context context = RePlugin.fetchContext("com.example.asus.plugin");
                //获取插件中的图片资源
                Class<?> c=null;
                try {
                    c=context.getClassLoader().loadClass("com.example.asus.plugin.R$drawable");
                    int drawableId= (int) c.getField("ic_face_black_24dp").get(null);
                    iv.setImageDrawable(context.getResources().getDrawable(drawableId));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                }
                //获取插件中的字符串资源
                Class<?> c1=null;
                try {
                    c1=context.getClassLoader().loadClass("com.example.asus.plugin.R$string");
                    Field field=c1.getField("app_name");
                    int strId= (int) field.get(null);
                    tv.setText(context.getResources().getString(strId));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                }

插件获取宿主资源

            //获取宿主中的字符串资源
                Class<?> clazz = null;
                try {
                    clazz = RePlugin.getHostClassLoader().loadClass("com.example.asus.replugindemo.R$string");
                    Field field = clazz.getField("app_name");
                    int identifierID = (int) field.get(null);
                    tv.setText(RePlugin.getHostContext().getResources().getString(identifierID));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                }
                //获取宿主中的图片资源
                Class<?> c = null;
                try {
                    c = RePlugin.getHostClassLoader().loadClass("com.example.asus.replugindemo.R$drawable");
                    Field field = c.getField("ic_tag_faces_black_24dp");
                    int drawableId = (int) field.get(null);
                    Drawable drawable = RePlugin.getHostContext().getResources().getDrawable(drawableId);
                    iv.setImageDrawable(drawable);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }

注意问题

context上下文对象，注意用的是插件的context还是宿主的context
插件相关权限要提前在宿主中注册。
利用反射来进行资源的访问

运行结果

自己写了个简单的Demo，就是宿主和插件之间四大组件的相互调用以及资源的相互获取。插件是外置插件。
源码地址：https://github.com/LXD312569496/RePluginDemo

总结

通过这个简单RePlugin的Demo，学会到了插件化的基本使用，以及了解到了插件化的原理实现。还有一点，就是RePlugin的源码注释写得真是非常清晰明了，很详细，值得学习。