RePlugin插件化框架的学习

3,687 阅读10分钟

现状

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

框架 优点 缺点
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框架.中文文档地址:github.com/Qihoo360/Re…
官方对这个框架的介绍:
RePlugin是一套完整的、稳定的、适合全面使用的,占坑类插件化方案,由360手机卫士的RePlugin Team研发,也是业内首个提出”全面插件化“(全面特性、全面兼容、全面使用)的方案。
其主要优势有:

  1. 极其灵活:主程序无需升级(无需在Manifest中预埋组件),即可支持新增的四大组件,甚至全新的插件
  2. 非常稳定:Hook点仅有一处(ClassLoader),无任何Binder Hook!如此可做到其崩溃率仅为“万分之一”,并完美兼容市面上近乎所有的Android ROM
  3. 特性丰富:支持近乎所有在“单品”开发时的特性。包括静态Receiver、Task-Affinity坑位、自定义Theme、进程坑位、AppCompat、DataBinding等
  4. 易于集成:无论插件还是主程序,只需“数行”就能完成接入
    管理成熟:拥有成熟稳定的“插件管理方案”,支持插件安装、升级、卸载、版本管理,甚至包括进程通讯、协议版本、安全校验等
  5. 数亿支撑:有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();
                }

注意问题

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

运行结果

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

image.png
image.png

image.png
image.png

总结

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