Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk

插件化

  • 前言
  • 什么是插件化
  • 插件化发展历程
  • 为什么需要插件化
  • 插件化的难点
  • 插件化需要掌握的技术
  • 实践
    • 总体逻辑
    • 加载dex,res等资源文件
    • 生命周期管理
    • 插件Activity编写
    • 宿主Activity编写

前言

在上篇文章Android热修复与插件化之–ClassLoader(类加载器)详解和双亲委派模型以及如何自定义类加载器详细介绍了ClassLoader原理,为今天的插件化开发做了些铺垫;可能很多人没有接触过插件化,但是你的生活中肯定有用到过与插件化技术有关的应用,看下图

Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk_第1张图片
Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk_第2张图片

想必大家能看出来,图一是支付宝的应用界面,图二是微信的应用界面,这两个APP都集成了很多第三方应用,那你有没有想过它们是怎么集成这么多应用的呢?难道是将这么多应用的代码与主应用一起打包成APP?这想想感觉就不可能,这么多的代码和资源文件,这支付宝和微信的APK体积不得上天;难不成是需要用户手机里安装这些APP,然后跳转?这也是不对的,我们在使用的时候都是在主应用内跳转的;那它们到底是怎么做到的呢?这就涉及到今天所讲的插件化技术了

什么是插件化

有插件一般都会伴随着宿主的存在,宿主APK实现了一套插件的加载和管理的框架,它作为应用的主工程存在,插件APK是依附于宿主APK存在的

插件也称为Plug-in,或者add-in,俗称外挂,是宿主应用的功能扩展,对宿主来说可有可无,但是一定程度上能提高宿主应用的高可用性;插件化就是在Android开发领域,在不改变宿主应用的情况下,通过插件动态扩展应用功能,在运行时将功能植入到应用系统中

正因如此,支付宝微信等这些大厂的应用才能集成如此之多的第三方应用

插件化发展历程

  • 2012年7月,AndroidDynamicLoader,大众点评,陶毅敏:思想是通过Fragment以及schema的方式实现的,这是一种可行的技术方案,但是还有限制太多,这意味这你的activity必须通过Fragment去实现,这在activity跳转和灵活性上有一定的不便,在实际的使用中会有一些很奇怪的bug不好解决,总之,这还是一种不是特别完备的动态加载技术。
  • 2013年,23Code,自定义控件的动态下载:主要利用 Java ClassLoader 的原理,可动态加载的内容包括 apk、dex、jar等。
  • 2014年初,Altas,阿里伯奎的技术分享:提出了插件化的思想以及一些思考的问题,相关资料比较少。
  • 2014年底,Dynamic-load-apk,任玉刚:动态加载APK,通过Activity代理的方式给插件Activity添加生命周期。
  • 2015年4月,OpenAltas/ACCD:Altas的开源项目,一款强大的Android非代理动态部署框架,目前已经处于稳定状态。
  • 2015年8月,DroidPlugin,360的张勇:DroidPlugin 是360手机助手在 Android 系统上实现了一种新的插件机制:通过Hook思想来实现,它可以在无需安装、修改的情况下运行APK文件,此机制对改进大型APP的架构,实现多团队协作开发具有一定的好处。
  • 2015年9月,AndFix,阿里:通过NDK的Hook来实现热修复。
  • 2015年11月,Nuwa,大众点评:通过dex分包方案实现热修复。
  • 2015年底,Small,林光亮:打通了宿主与插件之间的资源与代码共享。
  • 2016年4月,ZeusPlugin,掌阅:ZeusPlugin最大特点是:简单易懂,核心类只有6个,类总数只有13个
  • 2017年6月,VirtualAPK,滴滴开源了自研的插件化框架,该框架功能完备,支持Android四大组件,良好的兼容性,且入侵性较低

为什么需要插件化

插件化技术听起来很美好,但是要注意的一个问题就是使用插件化技术的APP是不能在Google Play上线的,因为Google是禁止开发商这种行为的;为什么呢?防止开发商窃取用户隐私!想想你一个做闹钟的应用,通过Google应用商店审核用户安装后,通过插件化技术给自己的APP增加了额外的功能,这就有很大的风险了,接下来你想做什么Google就不能控制其风险了

再者说这种技术有点钻操作系统空子,与原生系统对着干的意思,但是在国内特殊环境下,却发展的挺火热的,有时还成为了一道技术面试的门槛,可能这就是XXX特色吧,为什么会这样呢?

  • 第一个原因还是国内Android碎片化太严重,没有统一的应用分发市场,还有因为国内的信息政策,Google Play并不能起作用,也就谈不上对应用进行风险监测了;然后各大应用发布渠道良莠不齐,你懂的
  • 以前App是受到方法数的限制的(65535),通过插件化可以解决这一问题,但是Google后来推出了Multidex方案,即分包;如果你的应用仅仅只是为了突破65535,那不需要使用插件化,使用分包可以解决
  • 像上面说的支付宝微信,当然还有美团,滴滴等应用,它们的功能非常多,如果都将代码和资源都打包到一个APK中,显然这个APK的大小可能会突破用户承受的极限,如果将其中的很多功能通过插件动态下发可以解决这个问题
  • 动态控制功能使用情况,比如应用的某个功能模块突然出了bug或者因为什么政策需要停止使用,那就可以在线修改插件的使用权限,强制停止用户使用该插件的功能
  • 快速发布新功能,比如应用需要临时新增某项业务,这时候你的APP才刚升级,那再继续升级,显然对用户会是一个考验,同时该功能也不能及时的让用户使用到,使用插件化就可以做到
  • 可以按需加载不同的模块,实现灵活的功能配置,不同插件之间是相互独立的,可以很容易做到根据业务需求实现插件的热插拔

插件化的难点

  • 插件与宿主间通信
  • 插件Activity的生命周期管理和组件注册
  • 插件APK中资源与代码的加载
  • 插件APK与宿主APK资源引用的冲突

插件化需要掌握的技术

  • ClassLoader加载原理
  • Android资源加载与管理
  • Activity启动流程
  • 四大组件的加载与管理
  • Java反射原理
  • so库的加载原理
  • Gradle打包原理
  • 清单文件的合并处理

实践

这里在Andriod开发–如何实现组件化开发以及解决ButterKnife报错,了解一下文章的基础上继续开发;下面给出的插件化实现只是众多方案中的一种

场景介绍:首先用户安装了一个宿主APK,这里就仿微信了,在第四个tab页面,如下:
Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk_第3张图片
接着点击滴滴出行,这时候就需要去服务端下载滴滴APK到本地,然后加载对应页面

总体逻辑

接下来就进行实战了,首先以一幅图来展示下代码实现逻辑

Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk_第4张图片
工程目录如图

Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk_第5张图片
这里就把插件APK放在工程里一起开发了,主界面几个tab也是module,只不过是library形式

加载dex,res等资源文件

上图里说的很清楚了,加载一个APK需要加载dex文件,加载资源文件,所以就需要DexClassLoader,Resource,AssetManager等几个对象,所以就对封装一个APK加载对象,如下

public class PluginApk {

    private PackageInfo mPackageInfo;
    private DexClassLoader mClassLoader;
    private Resources mResources;
    private AssetManager mManager;

    public PluginApk(PackageInfo mPackageInfo, DexClassLoader mClassLoader, Resources mResources) {
        this.mPackageInfo = mPackageInfo;
        this.mClassLoader = mClassLoader;
        this.mResources = mResources;
        if (mResources != null) {
            mManager = mResources.getAssets();
        }
    }
}

接下来就需要创建PluginApk对象,定义一个插件管理类来实例化它

public class PluginManager {

    private static class Instance{
        static final PluginManager INSTANCE = new PluginManager();
    }

    private PluginManager() {
    }

    public static PluginManager getInstance(){
        return Instance.INSTANCE;
    }

    private Context mContext;
    private PluginApk mPluginApk;

    public void init(Context context){
        //避免单例对象引起内存泄漏
        mContext = context.getApplicationContext();
    }

    /**
     * 根据APK 路径实例化PluginApk对象
     * @param path
     */
    public void loadPluginApk(String path){

        PackageInfo packageInfo = mContext.getPackageManager().getPackageArchiveInfo(path,
                PackageManager.GET_ACTIVITIES | PackageManager.GET_SERVICES);
        if (packageInfo == null) {
            return;
        }

        DexClassLoader classLoader = createDexClassLoader(path);
        AssetManager assetManager;
        try {
            assetManager = createAssetManager(path);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

        Resources resources = createResource(assetManager);

        mPluginApk = new PluginApk(packageInfo,classLoader,resources);
    }

    public PluginApk getPluginApk(){
        return mPluginApk;
    }

    /**
     * 创建访问插件APK dex文件的类加载器
     * @param path
     * @return
     */
    private DexClassLoader createDexClassLoader(String path) {
        /**
         * 在宿主APK的内部存储中的data/data/包名 目录上创建一个文件夹,存放优化后的文件
         */
        File file = mContext.getDir("odex",Context.MODE_PRIVATE);
        return new DexClassLoader(path,file.getAbsolutePath(),null,mContext.getClassLoader());
    }


    private AssetManager createAssetManager(String path) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        /**
         * AssetManager的构造方和addAssetPath方法都是hide的,需要使用反射构造
         */
        AssetManager assetManager = AssetManager.class.newInstance();
        Method method = AssetManager.class.getDeclaredMethod("addAssetPath",String.class);
        method.invoke(assetManager,path);

        return assetManager;
    }

    /**
     * 创建访问插件APK资源的Resource
     * @param assetManager
     * @return
     */
    private Resources createResource(AssetManager assetManager) {
        Resources resources = mContext.getResources();
        return new Resources(assetManager,resources.getDisplayMetrics(),resources.getConfiguration());
    }

}

生命周期管理

接下来就是加载Activity了,这里通过代理的形式加载插件Activity

public class ProxyActivity extends AppCompatActivity {

    private String mActivityClassName;
    private PluginApk mPluginApk;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivityClassName = getIntent().getStringExtra("classname");
        mPluginApk = PluginManager.getInstance().getPluginApk();
        lunchActivity();
    }

    private void lunchActivity() {

        if (mPluginApk == null) {
            throw new NullPointerException("未获取到插件APK");
        }
        DexClassLoader classLoader = mPluginApk.getmClassLoader();
        try {
            Class clazz = classLoader.loadClass(mActivityClassName);
            //将Activity加载到内存中了
            Object o = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

但是这样加载进来的Activity并没有生命周期,所以就需要先定义一套规则,这样插件里的Activity才能进行生命周期方法的回调

规则如下

public interface IPluginActivity {

    //内部跳转
    int FORM_INTERNAL = 1;
    //外部跳转
    int FROM_EXTERNAL = 2;

    void attach(Activity proxyActivity);

    void onCreate(Bundle savedInstanceState);

    void onStart();

    void onRestart();

    void onResume();

    void onPause();

    void onStop();

    void onDestroy();

    void onActivityResult(int requestCode, int resultCode, Intent data)
}

这样ProxyActivity就可以这样写了

public class ProxyActivity extends AppCompatActivity {

    private String mActivityClassName;
    private PluginApk mPluginApk;
    private IPluginActivity mIPluginActivity;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivityClassName = getIntent().getStringExtra("classname");
        mPluginApk = PluginManager.getInstance().getPluginApk();
        lunchActivity();
    }

    private void lunchActivity() {

        if (mPluginApk == null) {
            throw new NullPointerException("未获取到插件APK");
        }
        DexClassLoader classLoader = mPluginApk.getmClassLoader();
        try {
            Class clazz = classLoader.loadClass(mActivityClassName);
            //将Activity加载到内存中了
            Object o = clazz.newInstance();
            //判断要跳转到的插件Activity是否实现了规则接口
            if (o instanceof IPluginActivity) {
                mIPluginActivity = (IPluginActivity) o;
                //赋予插件Activity上下文信息
                mIPluginActivity.attach(this);
                Bundle bundle = new Bundle();
                //表明是由宿主Activity跳转过去的
                bundle.putInt("from",IPluginActivity.FROM_INTERNAL);
                //回调插件Activity的onCreate方法,使其具有生命周期回调
                mIPluginActivity.onCreate(bundle);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onStart() {
        //回调插件Activity的onStart方法
        mIPluginActivity.onStart();
        super.onStart();
    }

    @Override
    protected void onRestart() {
        mIPluginActivity.onRestart();
        super.onRestart();
    }

    @Override
    protected void onResume() {
        mIPluginActivity.onResume();
        super.onResume();
    }

    @Override
    protected void onPause() {
        mIPluginActivity.onPause();
        super.onPause();
    }

    @Override
    protected void onStop() {
        mIPluginActivity.onStop();
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        mIPluginActivity.onDestroy();
        super.onDestroy();
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        mIPluginActivity.onActivityResult(requestCode,resultCode,data);
        super.onActivityResult(requestCode, resultCode, data);
    }

    /**
     * 下面这三个对象当前Activity是不具备的
     * 需要返回PluginApk对象的
     * @return
     */
    @Override
    public Resources getResources() {
        return mIPluginActivity == null ? super.getResources() : mPluginApk.getmResources();
    }

    @Override
    public AssetManager getAssets() {
        return mIPluginActivity == null ? super.getAssets() : mPluginApk.getmManager();
    }

    @Override
    public ClassLoader getClassLoader() {
        return mIPluginActivity == null ? super.getClassLoader() : mPluginApk.getmClassLoader();
    }
}

接下来还需要编写一个插件Activity的父类,以处理跳转过来的是宿主APK中的Activity还是插件APK中的Activity

public class PluginActivityImpl extends AppCompatActivity implements IPluginActivity {

    private int from = FROM_INTERNAL;
    //赋予当前Activity上下文
    private Activity mProxyActivity;

    @Override
    public void attach(Activity proxyActivity) {
        mProxyActivity = proxyActivity;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        if (savedInstanceState != null) {
            from = savedInstanceState.getInt("from");
        }
        if (from == FROM_INTERNAL) {
            super.onCreate(savedInstanceState);
            mProxyActivity = this;
        }

    }

    @Override
    public void setContentView(int layoutResID) {
        if (from == FROM_INTERNAL) {
            super.setContentView(layoutResID);
        } else {
            mProxyActivity.setContentView(layoutResID);
        }
    }

    @Override
    public View findViewById(int id) {
        if (from == FROM_INTERNAL) {
            return super.findViewById(id);
        } else {
            return mProxyActivity.findViewById(id);
        }
    }

    @Override
    public void onStart() {
        if (from == FROM_INTERNAL) {
            super.onStart();
        }
    }

    @Override
    public void onRestart() {
        if (from == FROM_INTERNAL) {
            super.onRestart();
        }
    }

    @Override
    public void onResume() {
        if (from == FROM_INTERNAL) {
            super.onResume();
        }
    }

    @Override
    public void onPause() {
        if (from == FROM_INTERNAL) {
            super.onPause();
        }
    }

    @Override
    public void onStop() {
        if (from == FROM_INTERNAL) {
            super.onStop();
        }
    }

    @Override
    public void onDestroy() {
        if (from == FROM_INTERNAL) {
            super.onDestroy();
        }
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (from == FROM_INTERNAL) {
            super.onActivityResult(requestCode,resultCode,data);
        }
    }
}

插件Activity编写

插件Activity需要继承PluginActivityImpl

package com.example.didi;

import android.os.Bundle;

import com.mango.library.plugin.PluginActivityImpl;

public class DidiActivity extends PluginActivityImpl {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

宿主Activity编写

正常情况下是通过服务器下载需要执行的插件APK,我这里就从Assets目录获取apk文件模拟下载了

public static String copyAssetFile2APPCache(Context context,String fileName){

        //获取应用内部存储中私有缓冲目录 data/data/包名/cache
        File cacheDir = context.getCacheDir();
        if (cacheDir.exists()) {
            cacheDir.mkdirs();
        }

        try {
            File outFile = new File(cacheDir,fileName);
            if (outFile.exists()) {
                return outFile.getAbsolutePath();
            } else {
                BufferedInputStream bis = new BufferedInputStream(context.getResources().getAssets().open(fileName));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(outFile));
                int len;
                byte[] buff = new byte[1024*8];
                while ((len = bis.read(buff)) != -1) {
                    bos.write(buff,0,len);
                }
                bos.flush();
                bis.close();
                bos.close();
                SharedPreferences sp = context.getSharedPreferences("APK",Context.MODE_PRIVATE);
                SharedPreferences.Editor editor = sp.edit();
                editor.putBoolean("load",true);
                editor.putString("path",outFile.getAbsolutePath());
                editor.commit();
                return outFile.getAbsolutePath();
            }
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

主要是将插件apk文件拷贝到私有缓存目录去,当然了也可以直接将插件apk放在SD卡上

然后在点击滴滴出行的时候再调用该方法

@Override
    public void onClick(View v) {
        super.onClick(v);
        SharedPreferences sp = getContext().getSharedPreferences("APK",Context.MODE_PRIVATE);
        boolean load = sp.getBoolean("load",false);
        if (load) {
            String path = sp.getString("path","");
            intentActivity(path);
        } else {
            //模拟下载过程
            new LoadApk().execute();
        }
    }

    class LoadApk extends AsyncTask{

        @Override
        protected String doInBackground(Void... voids) {
            return FileUtil.copyAssetFile2APPCache(getContext(),"didi.apk");
        }

        @Override
        protected void onPostExecute(String path) {
            super.onPostExecute(path);
            intentActivity(path);
        }
    }


    private void intentActivity(String path){
        Toast.makeText(getContext(),path,Toast.LENGTH_LONG).show();
        if (TextUtils.isEmpty(path)) {

        } else {
            PluginManager.getInstance()
                    .init(getContext())
                    .loadPluginApk(path);//如果插件APK是放在SD卡上,那这里的path就是文件路径,也就不需要上面的拷贝操作了

            Intent intent = new Intent(getContext(),ProxyActivity.class);
            intent.putExtra("classname","com.example.didi.DidiActivity");
            startActivity(intent);
        }
    }

接下来看看运行效果
Android使用代理+接口实现插件化 仿支付宝微信加载未安装的第三方应用apk_第6张图片

这样就从宿主APK成功加载一个未安装的APK中的Activity了

你可能感兴趣的:(【Android常用开发】)