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

转载于 2023-06-14 15:06:10 发布 · 529 阅读

3 ·

CC 4.0 BY-SA版权

原文链接：https://www.dandelioncloud.cn/article/details/1497538516883181570

文章标签：

#java #开发语言

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

插件化

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

前言

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

想必大家能看出来，图一是支付宝的应用界面，图二是微信的应用界面，这两个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页面，如下：

接着点击滴滴出行，这时候就需要去服务端下载滴滴APK到本地，然后加载对应页面

总体逻辑

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

工程目录如图

这里就把插件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<Void,Void,String>{
@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);
}
}