浅析Android插件化
前言
Android P preview版本中，已限制对@hide api的反射调用，具体的原理能够阅读Android P调用隐藏API限制原理这篇文章。因为最近团队分享也在分享插件化、热修复相关的东西。所以，写一篇文章，好好记录一下。android
准备知识
- 反射、动态代理
- Android中的几个相关的ClassLoader,注意PathClassLoader在ART虚拟机上是能够加载未安装的APK的，Dalvik虚拟机则不能够。
- Android中四大组件的相关原理
- PackageManagerServer
- 资源加载、资源打包
- 其余
文章中所涉及到的代码均经过Nexus 5(dalvik虚拟机) Android 6.0版本的测试git
文章中所涉及到的一切资源都在这个仓库下github
特别说明，本博客不会特别解释过多原理性的东西。若是读者不具有相关的知识储备，建议先阅读weishu和gityuan两位大神的博客,资源打包的知识能够阅读 老罗的博客。api
Activity的插件化
首先须要说明一点的是，启动一个彻底没有在AndroidManifest注册的Activity是不可能的。由于在启动的过程当中，存在一个校验的过程，而这个校验则是由PMS来完成的，这个咱们没法干预。所以，Activity的插件化方案大多使用占坑的思想。不一样的是如何在检验以前替换，在生成对象的时候还原。就目前来看，有两种比较好方案：bash
- Hook Instrumentation方案
- 干预startActivity等方法，干预ClassLoader findClass的方案
这里说一下Hook Instrumentation方法。根据上面提到的想法，咱们须要在先绕过检查，那么，咱们如何绕过检查呢？经过分析Activity的启动流程会发现，在Instrumentation#execStartActivity中，会有个checkStartActivityResult的方法去检查错误，所以，咱们能够复写这个方法，让启动参数能经过系统的检查。那么，咱们如何作呢？首先，咱们须要检查要启动的Intent能不能匹配到，匹配不到的话，将ClassName修改成咱们预先在AndroidManifest中配置的占坑Activity，而且吧当前的这个ClassName放到当前intent的extra中，以便后续作恢复，看下代码。架构
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
List<ResolveInfo> infos = mPackageManager.queryIntentActivities(intent, PackageManager.MATCH_ALL);
if (infos == null || infos.size() == 0) {
//没查到，要启动的这个没注册
intent.putExtra(TARGET_ACTIVITY, intent.getComponent().getClassName());
intent.setClassName(who, "com.guolei.plugindemo.StubActivity");
}
Class instrumentationClz = Instrumentation.class;
try {
Method execMethod = instrumentationClz.getDeclaredMethod("execStartActivity",
Context.class, IBinder.class, IBinder.class, Activity.class, Intent.class, int.class, Bundle.class);
return (ActivityResult) execMethod.invoke(mOriginInstrumentation, who, contextThread, token,
target, intent, requestCode, options);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
复制代码
咱们绕过检测了，如今须要解决的问题是还原，咱们知道，系统启动Activity的最后会调用到ActivityThread里面，在这里，会经过Instrumentation#newActivity方法去反射构造一个Activity的对象，所以，咱们只须要在这里还原便可。代码以下：app
@Override
public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException,
IllegalAccessException, ClassNotFoundException {
if (!TextUtils.isEmpty(intent.getStringExtra(TARGET_ACTIVITY))) {
return super.newActivity(cl, intent.getStringExtra(TARGET_ACTIVITY), intent);
}
return super.newActivity(cl, className, intent);
}
复制代码
一切准备就绪，咱们最后的问题是，如何替换掉系统的Instrumentation。要替换掉也简单，替换掉ActivityThread中的mInstrumentation字段便可。ide
private void hookInstrumentation() {
Context context = getBaseContext();
try {
Class contextImplClz = Class.forName("android.app.ContextImpl");
Field mMainThread = contextImplClz.getDeclaredField("mMainThread");
mMainThread.setAccessible(true);
Object activityThread = mMainThread.get(context);
Class activityThreadClz = Class.forName("android.app.ActivityThread");
Field mInstrumentationField = activityThreadClz.getDeclaredField("mInstrumentation");
mInstrumentationField.setAccessible(true);
mInstrumentationField.set(activityThread,
new HookInstrumentation((Instrumentation) mInstrumentationField.get(activityThread),
context.getPackageManager()));
} catch (Exception e) {
e.printStackTrace();
Log.e("plugin", "hookInstrumentation: error");
}
}
复制代码
这样，咱们就能启动一个没有注册在AndroidManifest文件中的Activity了，可是这里要注意一下，因为咱们这里使用的ClassLoader是宿主的ClassLoader，这样的话，咱们须要将插件的dex文件添加到咱们宿主中。这一点很重要。有一些多ClassLoader架构的实现，这里的代码须要变下。测试
Service的插件化
启动一个未注册的Service，并不会崩溃退出，只不过有点警告。而且，service启动直接由ContextImpl交给AMS处理了，咱们看下代码。ui
private ComponentName startServiceCommon(Intent service, UserHandle user) {
try {
validateServiceIntent(service);
service.prepareToLeaveProcess(this);
ComponentName cn = ActivityManagerNative.getDefault().startService(
mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
getContentResolver()), getOpPackageName(), user.getIdentifier());
if (cn != null) {
if (cn.getPackageName().equals("!")) {
throw new SecurityException(
"Not allowed to start service " + service
+ " without permission " + cn.getClassName());
} else if (cn.getPackageName().equals("!!")) {
throw new SecurityException(
"Unable to start service " + service
+ ": " + cn.getClassName());
}
}
return cn;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
复制代码
而且建立对象的过程不禁Instrumentation来建立了，而直接在ActivityThread#handleCreateService反射生成。那么，Activity的思路咱们就不能用了，怎么办呢？既然咱们没法作替换还原，那么，咱们能够考虑代理，咱们启动一个真实注册了的Service，咱们启动这个Service，并让这个Service，就按照系统服务Service的处理，原模原样的处理咱们插件的Service。
说作就作，咱们以startService为例。咱们首先要作的是，hook掉AMS，由于AMS启动service的时候，假如要启动插件的Service，咱们须要怎么作呢？把插件service替换成真是的代理Service，这样，代理Service就启动起来了，咱们在代理Service中，构建插件的Service，并调用attach、onCreate等方法。
Hook AMS代码以下：
private void hookAMS() {
try {
Class activityManagerNative = Class.forName("android.app.ActivityManagerNative");
Field gDefaultField = activityManagerNative.getDeclaredField("gDefault");
gDefaultField.setAccessible(true);
Object origin = gDefaultField.get(null);
Class singleton = Class.forName("android.util.Singleton");
Field mInstanceField = singleton.getDeclaredField("mInstance");
mInstanceField.setAccessible(true);
Object originAMN = mInstanceField.get(origin);
Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class[]{Class.forName("android.app.IActivityManager")},
new ActivityManagerProxy(getPackageManager(),originAMN));
mInstanceField.set(origin, proxy);
Log.e(TAG, "hookAMS: success" );
} catch (Exception e) {
Log.e(TAG, "hookAMS: " + e.getMessage());
}
}
复制代码
咱们在看一下ActivityManagerProxy这个代理。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals("startService")) {
Intent intent = (Intent) args[1];
List<ResolveInfo> infos = mPackageManager.queryIntentServices(intent, PackageManager.MATCH_ALL);
if (infos == null || infos.size() == 0) {
intent.putExtra(TARGET_SERVICE, intent.getComponent().getClassName());
intent.setClassName("com.guolei.plugindemo", "com.guolei.plugindemo.StubService");
}
}
return method.invoke(mOrigin, args);
}
复制代码
代码很清晰、也很简单，不须要在作多余的了，那么，咱们看下代理Service是如何启动而且调用咱们的插件Service的。
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.e(TAG, "onStartCommand: stub service ");
if (intent != null && !TextUtils.isEmpty(intent.getStringExtra(TARGET_SERVICE))) {
//启动真正的service
String serviceName = intent.getStringExtra(TARGET_SERVICE);
try {
Class activityThreadClz = Class.forName("android.app.ActivityThread");
Method getActivityThreadMethod = activityThreadClz.getDeclaredMethod("getApplicationThread");
getActivityThreadMethod.setAccessible(true);
//获取ActivityThread
Class contextImplClz = Class.forName("android.app.ContextImpl");
Field mMainThread = contextImplClz.getDeclaredField("mMainThread");
mMainThread.setAccessible(true);
Object activityThread = mMainThread.get(getBaseContext());
Object applicationThread = getActivityThreadMethod.invoke(activityThread);
//获取token值
Class iInterfaceClz = Class.forName("android.os.IInterface");
Method asBinderMethod = iInterfaceClz.getDeclaredMethod("asBinder");
asBinderMethod.setAccessible(true);
Object token = asBinderMethod.invoke(applicationThread);
//Service的attach方法
Class serviceClz = Class.forName("android.app.Service");
Method attachMethod = serviceClz.getDeclaredMethod("attach",
Context.class, activityThreadClz, String.class, IBinder.class, Application.class, Object.class);
attachMethod.setAccessible(true);
Class activityManagerNative = Class.forName("android.app.ActivityManagerNative");
Field gDefaultField = activityManagerNative.getDeclaredField("gDefault");
gDefaultField.setAccessible(true);
Object origin = gDefaultField.get(null);
Class singleton = Class.forName("android.util.Singleton");
Field mInstanceField = singleton.getDeclaredField("mInstance");
mInstanceField.setAccessible(true);
Object originAMN = mInstanceField.get(origin);
Service targetService = (Service) Class.forName(serviceName).newInstance();
attachMethod.invoke(targetService, this, activityThread, intent.getComponent().getClassName(), token,
getApplication(), originAMN);
//service的oncreate方法
Method onCreateMethod = serviceClz.getDeclaredMethod("onCreate");
onCreateMethod.setAccessible(true);
onCreateMethod.invoke(targetService);
targetService.onStartCommand(intent, flags, startId);
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, "onStartCommand: " + e.getMessage());
}
}
return super.onStartCommand(intent, flags, startId);
}
复制代码
代码较长，逻辑以下：
- 检测到须要启动插件Service
- 构建插件Service attach方法须要的参数
- 构造一个插件Service
- 调用插件Service的attach方法
- 调用插件Service的onCreate方法
这样，一个插件Service就启动起来了。
BroadcastReceiver的插件化
BroadcastReceiver分为两种，静态注册，和动态注册。静态注册的是PMS在安装或者系统启动的时候扫描APK，解析配置文件，并存储在PMS端的，这个咱们没法干预，而且，咱们的插件因为未安装，静态注册的是没法经过系统正常行为装载的。而动态注册的，因为没有检测这一步，所以，也不须要咱们干预。咱们如今须要解决的问题就是，怎么能装载插件中静态注册的。
咱们能够经过解析配置文件，本身调用动态注册的方法去注册这个。
代码这里就不贴了，和下面ContentProvider的一块儿贴。
ContentProvider的插件化
和其余三个组件不同的是，ContentProvider是在进程启动入口，也就是ActivityThread中进行安装的。那么咱们能够按照这个思路，本身去进行安装的操做。
代码以下。
Field providersField = packageClz.getDeclaredField("providers");
providersField.setAccessible(true);
ArrayList providers = (ArrayList) providersField.get(packageObject);
Class providerClz = Class.forName("android.content.pm.PackageParser$Provider");
Field providerInfoField = providerClz.getDeclaredField("info");
providersField.setAccessible(true);
List<ProviderInfo> providerInfos = new ArrayList<>();
for (int i = 0; i < providers.size(); i++) {
ProviderInfo providerInfo = (ProviderInfo) providerInfoField.get(providers.get(i));
providerInfo.applicationInfo = getApplicationInfo();
providerInfos.add(providerInfo);
}
Class contextImplClz = Class.forName("android.app.ContextImpl");
Field mMainThread = contextImplClz.getDeclaredField("mMainThread");
mMainThread.setAccessible(true);
Object activityThread = mMainThread.get(this.getBaseContext());
Class activityThreadClz = Class.forName("android.app.ActivityThread");
Method installContentProvidersMethod = activityThreadClz.getDeclaredMethod("installContentProviders", Context.class, List.class);
installContentProvidersMethod.setAccessible(true);
installContentProvidersMethod.invoke(activityThread, this, providerInfos);
复制代码
贴一下总体的代码,这里的代码，包括Multidex方法加dex，BroadcastReceiver的插件化以及ContentProvider的插件化。
private void loadClassByHostClassLoader() {
File apkFile = new File("/sdcard/plugin_1.apk");
ClassLoader baseClassLoader = this.getClassLoader();
try {
Field pathListField = baseClassLoader.getClass().getSuperclass().getDeclaredField("pathList");
pathListField.setAccessible(true);
Object pathList = pathListField.get(baseClassLoader);
Class clz = Class.forName("dalvik.system.DexPathList");
Field dexElementsField = clz.getDeclaredField("dexElements");
dexElementsField.setAccessible(true);
Object[] dexElements = (Object[]) dexElementsField.get(pathList);
Class elementClz = dexElements.getClass().getComponentType();
Object[] newDexElements = (Object[]) Array.newInstance(elementClz, dexElements.length + 1);
Constructor<?> constructor = elementClz.getConstructor(File.class, boolean.class, File.class, DexFile.class);
File file = new File(getFilesDir(), "test.dex");
if (file.exists()) {
file.delete();
}
file.createNewFile();
Object pluginElement = constructor.newInstance(apkFile, false, apkFile, DexFile.loadDex(apkFile.getCanonicalPath(),
file.getAbsolutePath(), 0));
Object[] toAddElementArray = new Object[]{pluginElement};
System.arraycopy(dexElements, 0, newDexElements, 0, dexElements.length);
// 插件的那个element复制进去
System.arraycopy(toAddElementArray, 0, newDexElements, dexElements.length, toAddElementArray.length);
dexElementsField.set(pathList, newDexElements);
AssetManager assetManager = getResources().getAssets();
Method method = assetManager.getClass().getDeclaredMethod("addAssetPath", String.class);
method.invoke(assetManager, apkFile.getPath());
// PackageInfo packageInfo = getPackageManager().getPackageArchiveInfo(apkFile.getAbsolutePath(), PackageManager.GET_RECEIVERS);
// if (packageInfo != null) {
// for (ActivityInfo info : packageInfo.receivers) {
// Log.e(TAG, "loadClassByHostClassLoader: " + info.name );
//
// }
// }
Class packageParseClz = Class.forName("android.content.pm.PackageParser");
Object packageParser = packageParseClz.newInstance();
Method parseMethod = packageParseClz.getDeclaredMethod("parsePackage", File.class, int.class);
parseMethod.setAccessible(true);
Object packageObject = parseMethod.invoke(packageParser, apkFile, 1 << 2);
Class packageClz = Class.forName("android.content.pm.PackageParser$Package");
Field receiversField = packageClz.getDeclaredField("receivers");
receiversField.setAccessible(true);
ArrayList receives = (ArrayList) receiversField.get(packageObject);
Class componentClz = Class.forName("android.content.pm.PackageParser$Component");
Field intents = componentClz.getDeclaredField("intents");
intents.setAccessible(true);
Field classNameField = componentClz.getDeclaredField("className");
classNameField.setAccessible(true);
for (int i = 0; i < receives.size(); i++) {
ArrayList<IntentFilter> intentFilters = (ArrayList<IntentFilter>) intents.get(receives.get(i));
String className = (String) classNameField.get(receives.get(i));
registerReceiver((BroadcastReceiver) getClassLoader().loadClass(className).newInstance(), intentFilters.get(0));
}
// 安装ContentProvider
Field providersField = packageClz.getDeclaredField("providers");
providersField.setAccessible(true);
ArrayList providers = (ArrayList) providersField.get(packageObject);
Class providerClz = Class.forName("android.content.pm.PackageParser$Provider");
Field providerInfoField = providerClz.getDeclaredField("info");
providersField.setAccessible(true);
List<ProviderInfo> providerInfos = new ArrayList<>();
for (int i = 0; i < providers.size(); i++) {
ProviderInfo providerInfo = (ProviderInfo) providerInfoField.get(providers.get(i));
providerInfo.applicationInfo = getApplicationInfo();
providerInfos.add(providerInfo);
}
Class contextImplClz = Class.forName("android.app.ContextImpl");
Field mMainThread = contextImplClz.getDeclaredField("mMainThread");
mMainThread.setAccessible(true);
Object activityThread = mMainThread.get(this.getBaseContext());
Class activityThreadClz = Class.forName("android.app.ActivityThread");
Method installContentProvidersMethod = activityThreadClz.getDeclaredMethod("installContentProviders", Context.class, List.class);
installContentProvidersMethod.setAccessible(true);
installContentProvidersMethod.invoke(activityThread, this, providerInfos);
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, "loadClassByHostClassLoader: " + e.getMessage());
}
}
复制代码
到这里，四大组件的插件化方案介绍了一点点，虽然每种组件只介绍了一种方法。上面的内容忽略了大部分源码细节。这部份内容须要你们本身去补。
资源的插件化方案
资源的插件化方案，目前有两种
- 合并资源方案
- 各个插件构造本身的资源方案
今天，咱们介绍第一种方案，合并资源方案，合并资源方案，咱们只须要往现有的AssetManager中调用addAsset添加一个资源便可，固然，存在比较多适配问题，咱们暂时忽略。合并资源方案最大的问题就是资源冲突。要解决资源冲突，有两种办法。
- 修改AAPT，能自由修改PP段
- 干预编译过程，修改ASRC和R文件
为了简单演示，我直接只用VirtualApk的编译插件去作。实际上VirtualApk的编译插件来自以Small的编译插件。只要对文件格式熟悉，这个仍是很好写的。
AssetManager assetManager = getResources().getAssets();
Method method = assetManager.getClass().getDeclaredMethod("addAssetPath", String.class);
method.invoke(assetManager, apkFile.getPath());
复制代码
咱们只须要上面简单的代码，就能完成资源的插件化。固然，这里忽略了版本差别。
SO的插件化方案
so的插件化方案，我这里介绍修改dexpathlist的方案。咱们要作的是什么呢？只须要往nativeLibraryPathElements中添加SO的Element，而且往nativeLibraryDirectories添加so路径就能够了。 代码以下。
Method findLibMethod = elementClz.getDeclaredMethod("findNativeLibrary",String.class);
findLibMethod.setAccessible(true);
// Object soElement = constructor.newInstance(new File("/sdcard/"), true, apkFile, DexFile.loadDex(apkFile.getCanonicalPath(),
// file.getAbsolutePath(), 0));
// findLibMethod.invoke(pluginElement,System.mapLibraryName("native-lib"));
ZipFile zipFile = new ZipFile(apkFile);
ZipEntry zipEntry = zipFile.getEntry("lib/armeabi/libnative-lib.so");
InputStream inputStream = zipFile.getInputStream(zipEntry);
File outSoFile = new File(getFilesDir(), "libnative-lib.so");
if (outSoFile.exists()) {
outSoFile.delete();
}
FileOutputStream outputStream = new FileOutputStream(outSoFile);
byte[] cache = new byte[2048];
int count = 0;
while ((count = inputStream.read(cache)) != -1) {
outputStream.write(cache, 0, count);
}
outputStream.flush();
outputStream.close();
inputStream.close();
// 构造Element
Object soElement = constructor.newInstance(getFilesDir(), true, null, null);
// findLibMethod.invoke(soElement,System.mapLibraryName("native-lib"));
// 将soElement填充到nativeLibraryPathElements中,
Field soElementField = clz.getDeclaredField("nativeLibraryPathElements");
soElementField.setAccessible(true);
Object[] soElements = (Object[]) soElementField.get(pathList);
Object[] newSoElements = (Object[]) Array.newInstance(elementClz, soElements.length + 1);
Object[] toAddSoElementArray = new Object[]{soElement};
System.arraycopy(soElements, 0, newSoElements, 0, soElements.length);
// 插件的那个element复制进去
System.arraycopy(toAddSoElementArray, 0, newSoElements, soElements.length, toAddSoElementArray.length);
soElementField.set(pathList, newSoElements);
//将so的文件夹填充到nativeLibraryDirectories中
Field libDir = clz.getDeclaredField("nativeLibraryDirectories");
libDir.setAccessible(true);
List libDirs = (List) libDir.get(pathList);
libDirs.add(getFilesDir());
libDir.set(pathList,libDirs);
复制代码
总结
在前人的精心研究下，插件化方案已经很成熟了。插件化方案的难点主要在适配方面。其余倒还好。
PS:热修复的相关知识，PPT已经写好了，下篇应该会浅析一下热修复。
相关文章
- 1. Android插件化
- 2. Android 插件化
- 3. android插件化
- 4. 组件化浅析
- 5. Android 插件化原理解析
- 6. Android插件化原理解析
- 7. Android之序列化浅析
- 8. Android插件化(二):OpenAtlas插件安装过程分析
- 9. Android 插件化原理解析——插件加载机制
- 10. Android 组件化，模块化，插件化
- 更多相关文章...
- • Maven 插件 - Maven教程
- • Eclipse 安装插件 - Eclipse 教程
- • IntelliJ IDEA安装代码格式化插件
- • IntelliJ IDEA代码格式化设置
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Android插件化
- 2. Android 插件化
- 3. android插件化
- 4. 组件化浅析
- 5. Android 插件化原理解析
- 6. Android插件化原理解析
- 7. Android之序列化浅析
- 8. Android插件化(二):OpenAtlas插件安装过程分析
- 9. Android 插件化原理解析——插件加载机制
- 10. Android 组件化，模块化，插件化