【Android】Android插件开发 —— 打开插件的Activity（Hook系统方法）

最新推荐文章于 2022-01-22 14:23:36 发布
最新推荐文章于 2022-01-22 14:23:36 发布
阅读量3k 收藏 2
点赞数 3
分类专栏： 安卓 文章标签： android 插件 安卓插件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H28496/article/details/52534027
版权
本文介绍了Android插件开发中如何利用Instrumentation注入来打开未注册的插件Activity，详细阐述了Activity实例化过程、绕过注册校验的方法以及如何替换系统newActivity方法。
摘要由CSDN通过智能技术生成

Android打开插件中Activity的实现原理

摘要

Android打开插件Activity的方式有很多种，类名固定的可以使用预注册的方式。代理也是一种很好的方式，同时代理的方式也可以用于打开插件中的Service。这两种方式在之前的博客中都有分享：

这两种方式都有一些弊端，这篇文章要分享的是如何更好地打开插件中的Activity，采用Instrumentation注入的方式。
其大致步骤为：

  1. 在创建Intent时，目标Activity为已注册的Activity（设为ActivityA）；
  2. 在 intent 中 put 插件Activity的信息（设为PluginActivity）；
  3. 继承Instrumentation，实现子类（设为InstrumentationHook），重写newActivity()方法，使得要实例化ActivityA时，实例化PluginActivity；
  4. 在Application的onCreate()方法中，利用反射，通过ActivityThread的currentActivityThread()方法获得ActivityThread的实例（该实例会传递给后续创建的所有Activity）；
  5. 通过反射的方式，替换ActivityThread实例中的mInstrumentation变量（原类型是Instrumentation，替换为子类InstrumentationHook的变量）

1. Activity是如何被实例化的

1.1 在哪一个类、哪一个方法中实例化的

当开发者实现一个Activity时，不能自己添加一个带参数的构造方法。如果添加了，也需要实现一个无参构造方法。原因是在调用Context#startActivity(…)后，系统会利用反射的方式根据activityClass实例化一个Activity对象:

Activity activity = (Activity)clazz.newInstance();

其中clazz就是传入的Activity的子类。这一行代码在Instrumentaion.java中的newActivity(…)方法中。可以看出，Activity的实例化是在Instrumentation这个类里面，通过反射的方式进行的。

1.2 谁持有了Instrumentation的引用

每个Activity对象都持有了一个mInstrumentation的变量，该变量是由ActivityThread传递给Activity的。在ActivityThread中，有了一个名为mInstrumentation的变量。

2. 如何偷梁换柱打开插件的Activity

2.1 Activity是否在AndroidManifest.xml注册的校验

如果一个Activity没有注册，想要打开它，会抛出异常：

Unable to find explicit activity class XXXXActivity have you declared this activity in your AndroidManifest.xml?

这个异常是Instrumentation的checkStartActivityResult方法抛出的：

/** @hide */
public static void checkStartActivityResult(int res, Object intent) {
    if (res >= ActivityManager.START_SUCCESS) {
        return;
    }

    switch (res) {
        case ActivityManager.START_INTENT_NOT_RESOLVED:
        case ActivityManager.START_CLASS_NOT_FOUND:
            if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
                throw new ActivityNotFoundException(
                        "Unable to find explicit activity class "
                        + ((Intent)intent).getComponent().toShortString()
                        + "; have you declared this activity in your AndroidManifest.xml?");
            throw new ActivityNotFoundException(
                    "No Activity found to handle " + intent);
        ...（以下省略）
    }
}

很明显，插件中的Activity是没有在AndroidManifest.xml中注册的，直接打开肯定抛异常崩溃。同时由于checkStartActivityResult方法是静态方法，所以不能通过重写这个方法绕过校验。

2.2 如何绕过Activity的注册校验

在Instrumentation中，checkStartActivityResult(…)方法 是在 newActivity(…)方法之前执行的。由于：
1. 当开发者使用一个已经注册过的Activity去接受校验时，肯定能通过校验；
2. 实例化出来的Activity不一定是经过校验的那一个Activity。

让我们看一下Instrumentation#newActivity(…)方法的具体实现(有两个重载实现)：
第一个：

public Activity newActivity(Class<?> clazz, Context context, 
        IBinder token, Application application, Intent intent, ActivityInfo info, 
        CharSequence title, Activity parent, String id,
        Object lastNonConfigurationInstance) throws InstantiationException, 
        IllegalAccessException {

    Activity activity = (Activity)clazz.newInstance();
    ActivityThread aThread = null;
    activity.attach(context, aThread, this, token, 0, application, intent,
            info, title, parent, id,
            (Activity.NonConfigurationInstances)lastNonConfigurationInstance,
            new Configuration(), null);
    return activity;
}

第二个：

public Activity newActivity(ClassLoader cl, String className,
        Intent intent)
        throws InstantiationException, IllegalAccessException,
        ClassNotFoundException {
    return (Activity)cl.loadClass(className).newInstance();
}

注意参数列表中有一个 Intent intent 参数，这个参数就是我们在startActivity(Intent intent);传入的那个intent。两个重载方法的参数列表中都包含了这个intent。
所以绕过注册验证的思路大致就出来了：

  1. 第一步：
    Intent intent = new Intent(this, 某个已经注册的ActivityA);
    intent.putString(“插件中的的Activity的类名”);
  2. 系统在接受startActivity后，校验”已经注册Activity”是否注册，结果肯定是已经注册，顺利通过；
  3. 接着来到newActivity(…)方法准备实例化Activity
    我们通过反射的方式，事先替换掉newActivity(…)方法，改为我们自己的方法。在我们自己的newActivity方法中做以下工作：
Created with Raphaël 2.1.0 开始 从intent中获得通过校验的Activity的类，赋值给replyActivityClass A == ActivityA ？ 从intent中获得插件中的Activity的类名，赋值给pluginActivityClassName 根据类名反射获得对应的类, pluginActivityClass 由C实例化出插件Activity对象pluginActivity 返回 说明并不是要打开插件中的Activity 结束 yes no

最后将pluginActivity就打开我们插件中的Activity了。修改后的代码如下：
其中，SonaInner.getRelayActivity() 就是事先约定好的中继Activity，也就是上面说得ActivityA。
另外，PluginManager.loadClassFromPlugin(…) 方法可以简单理解为是Class.forName()。具体代码见文末。

package com.mzdxl.sona.hooks;

import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.os.Bundle;
import android.os.IBinder;
import android.view.ContextThemeWrapper;

import com.mzdxl.sona.Log;
import com.mzdxl.sona.PluginManager;
import com.mzdxl.sona.SonaInner;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author 郑海鹏
 * @since 2016/5/16 21:57
 */
public class InstrumentationHook extends android.app.Instrumentation{

    /* -------------------------------------------------------------
                                              Fields
    ------------------------------------------------------------- */
    public static final String PLUGIN_ACTIVITY_NAME = "plugin_activity";
    public static final String PLUGIN_PATH = "plugin_path";

    protected String pluginPath;


    /* -------------------------------------------------------------
                      System Override / Implements Methods
    ------------------------------------------------------------- */
    @Override
    public Activity newActivity(Class<?> clazz, Context context,
                                IBinder token, Application application, Intent intent, ActivityInfo info,
                                CharSequence title, Activity parent, String id,
                                Object lastNonConfigurationInstance) throws InstantiationException,
            IllegalAccessException {
        Log.i("CustomInstrumentation#newActivity 执行了！code 1");

        Activity handleResult = createActivity(intent);
        if (handleResult != null){
            return handleResult;
        }

        return super.newActivity(clazz, context, token, application, intent, info, title, parent, id, lastNonConfigurationInstance);
    }

    @Override
    public Activity newActivity(ClassLoader cl, String fromClassName, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Log.i("CustomInstrumentation#newActivity 执行了！code 2");

        Activity handleResult = createActivity(intent);
        if (handleResult != null){
            handleResult.attach(context, null, this, token, 0, application, intent,
                info, title, parent, id,
                (Activity.NonConfigurationInstances)lastNonConfigurationInstance,
                new Configuration(), null);
            return handleResult;
        }`

        return super.newActivity(cl, fromClassName, intent);
    }

    @Override
    public void callActivityOnCreate(Activity activity, Bundle icicle) {
        super.callActivityOnCreate(activity, icicle);
        injectResources(activity);
    }

    /* -------------------------------------------------------------
                                           Methods
    ------------------------------------------------------------- */
    /**
     * 根据Intent中的class判断是否存在中继Activity，如果目标Activity是中继Activity则打开插件
     */
    @SuppressWarnings("unchecked")
    protected Activity createActivity(Intent intent){
        SonaInner.checkInit();

        // 获得Intent中要打开的Activity
        String className = intent.getComponent().getClassName();

        // 判断该Activity是否是中继Activity
        if (SonaInner.getRelayActivity().getName().equals(className)) {
            // 如果是中继Activity，取出真实想启动的插件的Activity的类名、插件的位置
            String pluginActivityName = intent.getStringExtra(PLUGIN_ACTIVITY_NAME);
            pluginPath = intent.getStringExtra(PLUGIN_PATH);
            // 实例化Activity
            Class<? extends Activity> PluginActivity;
            try {
                if (pluginPath == null){
                    // 如果插件保存地址为null，不从插件中找
                    PluginActivity = (Class<? extends Activity>) Class.forName(pluginActivityName);
                }else{
                    PluginActivity = PluginManager.loadClassFromPlugin(getContext(), pluginPath, pluginActivityName);
                }
                return PluginActivity == null ? null : PluginActivity.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
                Log.e("Intent中传入的插件的Class名无法实例化， 或者Class名不是一个Activity的类名，或者对应插件中不包含这个Activity。");
            }
        }
        return null;
    }

    /**
     * 注入插件的资源
     */
    protected void injectResources(Activity activity){
        if (pluginPath == null){
            return;
        }

        // 获取Activity的Resource资源
        Resources hostResource = activity.getApplication().getResources();

        // 获取插件的Resource
        try {
            // 获得系统assetManager
            AssetManager assetManager = AssetManager.class.newInstance();
            // 将插件地址添加到资源地址
            Method method_addAssetPath = AssetManager.class.getDeclaredMethod("addAssetPath", String.class);
            method_addAssetPath.setAccessible(true);
            method_addAssetPath.invoke(assetManager, pluginPath);

            // 获得新的完整的资源
            Resources resources = new Resources(assetManager, hostResource.getDisplayMetrics(), hostResource.getConfiguration());
            Field field_mResources = ContextThemeWrapper.class.getDeclaredField("mResources");
            field_mResources.setAccessible(true);
            field_mResources.set(activity, resources);
        } catch (Exception e) {
            e.printStackTrace();
            Log.e("复制插件Resource时出现异常");
        }
    }
}

2.3 如何用自己的newActivity方法替换系统方法

在1.2中已经提到了，Instrumentation的对象是保存在ActivityThread里的。很不幸，ActivityThread对象我们无法直接获得到，同时连ActivityThread这个类我们在代码中都不能直接调用。ActivityThread有一个静态方法：

public static ActivityThread currentActivityThread() {
    return sCurrentActivityThread;
}

该方法返回了当前的ActivityThread。
我们可以通过反射的方式，先获得ActivityThread，再获得currentActivityThread方法，最后调用这个方法就可以获得ActivityThread的变量（设为activityThread）了。最后把我们自己的Instrumentation对象替换掉activityThread里的mInstrumentation就可以了。代码如下：
其中：

  • ActivityThread_method_currentActivityThread 就是ActivityThread的currentActivityThread方法；
  • activityThread就是当前的ActivityThread。
  • InstrumentationHook 是我们自定义的Instrumentaion，修改了系统的newActivity。
package com.mzdxl.sona;

import android.content.res.AssetManager;

import com.mzdxl.sona.hooks.InstrumentationHook;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author 郑海鹏
 * @since 2016/5/17 10:25
 */
public class HookManager {
    /* -------------------------------------------------------------
                                              Fields
    ------------------------------------------------------------- */
    static Class<?> ActivityThread;
    static Method ActivityThread_method_currentActivityThread;
    static Object obj_activityThread;
    static Method AssetManager_method_addAssetPath;


    /* -------------------------------------------------------------
                                        Static Methods
    ------------------------------------------------------------- */
    /**
     * 初始化操作，获得一些基本的类、变量、方法等。
     */
    public static void init() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        // 获得ActivityThread类
        ActivityThread = Class.forName("android.app.ActivityThread");

        // 获得ActivityThread#currentActivityThread()方法
        ActivityThread_method_currentActivityThread = ActivityThread.getDeclaredMethod("currentActivityThread");

        // 根据currentActivityThread方法获得ActivityThread对象
        obj_activityThread = ActivityThread_method_currentActivityThread.invoke(ActivityThread);

        // 获得AssetManager#addAssetPath()方法
        AssetManager_method_addAssetPath = AssetManager.class.getDeclaredMethod("addAssetPath", String.class);
        AssetManager_method_addAssetPath.setAccessible(true);
    }

    /**
     * 注入Sona的Instrumentation
     */
    public static void injectInstrumentation() throws NoSuchFieldException, IllegalAccessException {
        Log.i("开始注入Sona的Instrumentation。");
        // 获得ActivityThread类中的Instrumentation字段
        Field field_instrumentation = obj_activityThread.getClass().getDeclaredField("mInstrumentation");
        field_instrumentation.setAccessible(true);
        // 创建出一个新的Instrumentation
        InstrumentationHook obj_custom_instrumentation = new InstrumentationHook();
        // 用Instrumentation字段注入Sona的Instrumentation变量
        field_instrumentation.set(obj_activityThread, obj_custom_instrumentation);
    }

}

最后我们需要在自己Application中的onCreate()方法中调用HookManager.init() 和 HookManager.injectInstrumentation()就可以替换为我们自己的Instrumentation了。

如果读者不太清楚如何加载插件中的类到内存中等细节，可以参考前面两篇文章。

附录

PluginManager的实现

package com.mzdxl.sona;

import android.content.Context;

import java.io.File;
import java.util.LinkedHashMap;
import java.util.Map;

import dalvik.system.DexClassLoader;

/**
 * @author 郑海鹏
 * @since 2016/5/17 11:16
 */
public class PluginManager {
    /* -------------------------------------------------------------
                                              Fields
    ------------------------------------------------------------- */
    static Map<String, DexClassLoader> classLoaderMap = new LinkedHashMap<>();


    /* -------------------------------------------------------------
                                           Methods
    ------------------------------------------------------------- */
    /**
     * 加载一个插件
     */
    /*package*/ static DexClassLoader loadPlugin(Context context, String pluginPath){
        boolean isPluginExist = new File(pluginPath).exists();
        if (!isPluginExist){
            Log.e("指定位置不存在插件文件。");
            return null;
        }
        String dexSaveFolder = context.getDir("sona", 0).getAbsolutePath();
        DexClassLoader dexClassLoader = new DexClassLoader(pluginPath, dexSaveFolder, null, context.getClassLoader());
        classLoaderMap.put(pluginPath, dexClassLoader);
        return dexClassLoader;
    }

    /**
     * 从一个插件中获取到一个类
     * @param pluginPath 插件路径
     * @param className 要加载的类的类名
     */
    public static Class loadClassFromPlugin(Context context, String pluginPath, String className) throws ClassNotFoundException {
        DexClassLoader dexClassLoader = classLoaderMap.get(pluginPath);
        if (dexClassLoader == null){
            dexClassLoader = loadPlugin(context, pluginPath);
        }
        if (dexClassLoader != null){
            return dexClassLoader.loadClass(className);
        }
        return null;
    }

}
木质的旋律
关注
专栏目录
【Android】Android插件开发 —— 打开插件的Activity（代理方式）
木质的旋律
12-28 2913
用代理的方式打开插件Activity的整体思想 1. 插件中的Activity由于没有在宿主的AndroidManifest.xml中注册，因此不能直接由宿主程序打开。但是，我们仍然可以通过DexClassLoader去获取到插件中的Activity，并且执行它的各种方法,只不过这时的Activity就只是一个普通的类了，没有了各种生命周期，无法被当作Activity启动。 2. 那无法被当作正常
android插件开发-就是你了！启动吧！插件的activity（一）
何以诚的专栏
04-14 5605
通过之前的例子例子，我们学习了如何寻找hook点，并且做一些非常无聊的事情。比如是的粘贴板放一句无聊的句子，或者让系统在启动一个activity时打印一句话。这些看似无聊的事情其实都是为了本节做铺垫。 这一节会把之前的知识都贯穿起来——启动插件中的activity，不过这篇博客比较长，所以我分开成为两部分了第二部分启动插件的activity还是非常难的一件事，因为在android中，所有的acti
Activity Hook
Jack的博客
07-31 619
1, Activity Hook Activity，Service等组件是有生命周期的，它们统一由系统服务AMS管理; Activity的详细启动流程在此就不论述了。主要步骤如下, 1, 从App进程调用startActivity等一系列方法; 2, 通过IPC调用进入系统进程system_server,完成Activity管理以及一些校检工作; 3, 回到APP进程完成真正的Act
插件化-插件Activity的启动
weixin_43887839的博客
01-25 225
在上一节分析中，我们已经知道宿主已经加载了插件的资源、类。也就是说在宿主中是可以使用插件中的类的。但是对于启动Activity这件事就比较特殊了: 在Android中一个Activity必须在AndroidManifest.xml中注册才可以被启动，可是很明显的是插件中的Activity是不可能提前在宿主的manifest文件中注册的。也就是说直接在宿主中启动一个插件的Acitvity必定失败。...
Android插件化之启动Activity
weixin_33853794的博客
05-15 243
在上一篇文章Android插件化之ClassLoader中，我们已经可以成功加载apk，但是还没有办法启动插件中的Activity。我们知道，如果要启动一个Activity，那么这个Activity必须在AndroidManifest.xml中注册。因此，如果我们要启动插件中的Activity，那么这个Activity事先必须在宿主的AndroidManifest.xml中预注册。这样一来就会有两...
Android 插件化开发——对startActivity方法进行hook（一）
lmq121210的博客
07-20 673
本篇博客主要讲述一下对startActivity进行hook，对于Android开发来说，跳转一个新的Activity页面，最常见的无非两种了， 方法一： Intent intent = new Intent(MainActivity.this, NewActivity.class); startActivity(intent); 方法二： Intent intent = new Intent(...
Android 插件化开发（三）—— hook式插件化开发
明天的增加的博客
08-21 764
原理： startActivity —> PluginActivity – （Hook ProxyActivity）（AMS）检测，当前要启动的Activity是否注册了）ok —》 ActivityThread（即将加载启动Activity）----(要把这个ProxyActivity 换回来 --> PluginActivity) 这里使用了两次Hook，最后启动PluginActivity的时候也会报错，因为插件并没有安装，这时候就需要将插件和宿主app合在一起加载，所以需要三部 1、绕
Android 插件化开发——启动没有在ActivityManifest中声明的Activity（二）
lmq121210的博客
07-27 926
要解决这个问题，首先回顾一下启动一个新的Activity的流程： 要启动ActivityB，将要启动的ActivityB信息告诉AMS； AMS收到信息后，记录下ActivityB的相关信息，同时检查Manifest中是否已经注册了ActivityB，如果一切正常，则回传消息给ActivityThread：我接收到了！你可以paused了！ ActivityA进入Paused状态，再告诉AMS：...
Android插件化——高手必备的Hook技术，看看这篇文章吧
m0_66264169的博客
01-22 469
3、Binder Hook（Hook 系统服务） 上面通过Hook技术修改了活动的启动过程，属于应用程序的Hook，下面尝试Hook Android的系统服务，修改系统的功能，在Hook之前还是先了解一下系统服务的获取过程，并尝试寻找Hook点； 3.1、系统获取服务的原理 ContextImpl.getSystemService(String name) @Override public Object getSystemService(String name) { return SystemServi
Android插件化——高手必备的Hook技术，这些面试官常问的开发面试题你都掌握好了吗
flutter001的博客
12-27 461
Hook分类 根据Hook的API语言划分，分为Hook Java 和 Hook Native 根据Hook进程划分，分为应用进程Hook 和 全局 Hook 代理模式 代理模式是Hook模式的基础原型，代理模式指为某个类的操作提供代理执行 代理模式的意义在于无需修改原来的程序结构，增加或扩展程序的功能 代理类的实现：声明一个功能接口，代理类和真实类都实现这个功能接口，在代理类中保存真实类的对象，当调用代理类执行方法时，内部调用真实对象执行； interface Func.
Android代码-AndroidHookStartActivity
08-06
AndroidHookStartActivity AMSHook 两行代码实现动态启动未注册的Activity。 1.application标签里配置一个壳Activity         2.注册一下其中this为context AMSHookUtil.hookStartActivity(this); 3.以后就可以按照标准的Intent启动为那些未被注册的Activity。 Intent intent = new Intent(MainActivity.this, OtherActivity.class); startActivity(intent); 原理详解：http://www.jianshu.com/p/2ad105f54d07 更新 1.修复多次hook的问题 2.修复Activity无需和包名一致也能启动
Android Hook Activity 启动劫持
02-27
如何利用动态代理技术Hook掉系统的AMS服务，来实现拦截Activity的启动流程。
Hook StartActivity Demo
11-17
Hook StartActivity Demo
android hook截取其他程序的按钮事件_Hook技术
weixin_39678304的博客
11-27 338
概述 Hook，英文直译是”钩子“的意思。在程序中将其理解为”劫持“可能会更好理解，我们可以通过hook技术来劫持某个对象，从而控制它与其他对象的交互。Hook技术分类根据Hook的API语言划分，分为Hook Java和Hook Native。 Hook Java主要通过反射和代理来实现，用于在SDK开发环境中修改Java代码。 Hook Native则应用于在NDK开发环境和系统开发中修改Na...
HOOK技术四-插件中Activity启动实战
吓成一坨兔子
12-28 339
说明 上篇文章中,我们已经分析了, 如果要启动插件中的Activity, 就需要将插件的element与宿主的element融合成一个整的element，然后设置给BaseDexClassLoader。这里还有有一个问题，虽然说Activity的class可以通过这样的方式加载，但是资源文件却不行，资源文件的加载是靠AssetManager和Resource加载的，所以插件中使用AssetMana...
【Android】Android插件开发 —— 打开插件的Activity（预注册方式）
木质的旋律
11-21 2748
Android宿主程序打开插件的Activity有预注册方式、代理Activity等方式。本篇博客介绍如何用预注册的方式打开插件中的Activity。
（4.6.29.2）插件化之代码加载：启动Activity
JAVA成长之路
06-23 551
一、代理Activity模式 1.1 用反射调用插件Activity相应生命周期 1.2 把插件Activity的生命周期抽象成接口，在ProxyActivity的生命周期里调用 二、动态创建Activity 2.1 dexmaker 和 asmdex 动态生成类 2.1.1 使用dexmaker动态创建一个类 2.2 修改需要启动的目标Activity 2.3 动态类创建Activi...
Android插件化开发之Hook StartActivity方法
热门推荐
码莎拉蒂
11-18 1万+
第一步、先爆项目demo照片，代码不多，不要怕 第二步、应该知道Java反射相关知识 如果不知道或者忘记的小伙伴请猛搓这里，Android插件化开发基础之Java反射机制研究 http://blog.csdn.net/u011068702/article/details/49863931 第三步、应该知道Java静态代理知识 如果不知道或者忘记的小伙伴请猛搓这
Android开发；Activity-Hook你了解多少？一起来debug
m0_57081562的博客
06-13 219
享学课堂特邀作者：周周 转载请声明出处！ 前言 手把手讲解系列文章，是我写给各位看官，也是写给我自己的。文章可能过分详细，但是这是为了帮助到尽量多的人，毕竟工作5,6年，不能老吸血，也到了回馈开源的时候。 这个系列的文章： 1、用通俗易懂的讲解方式，讲解一门技术的实用价值 2、详细书写源码的追踪，源码截图，绘制类的结构图，尽量详细地解释原理的探索过程 3、提供Github 的 可运行的Demo工程,但是我所提供代码，更多是提供思路，抛砖引玉，请酌情cv 4、集合整理原理探索过程中的一些坑，或者demo.
360手机助手的DroidPlugin：无需安装的Android插件运行机制
DroidPlugin是360手机助手团队为Android系统设计的一种创新插件机制，它旨在简化大型应用的开发和维护流程，实现多团队间的高效协作。这种机制的核心在于无需用户安装或修改APK文件即可运行，这使得开发者能够灵活地...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值