Xposed模块开发入门保姆级教程 - 狐言狐语和仙贝的魔法学习记录

介绍

介于网络上的Xposed开发教程过于破烂，所以狐狸狸决定自己写一篇教程来帮助各位想要开发/正在进行开发Xposed模块的开发者。

开始之前

在开始之前，你需要准备好：

一台可以安装Xposed框架的手机（推荐LSPosed、Android 10+）
一台可以编写代码并且装有jdk的电脑
一个名叫Android Studio的软件（当然你用IDEA也没问题就是了）
一个反编译软件，如：JADX
一个可以查看布局的App，如：开发者助手

其次，本文假定你已经学会以下内容：

会Java/Kotlin其中一种语言（强烈推荐Kotlin，对模块开发特别友好，为此我专门写了一个kotlin的Xposed模块开发用库来使用，能帮助开发者省下30%~50%甚至更多的代码量，注重模块本身逻辑的编写！不过本期教程不会使用就是了）
Java的反射
Android的基础套件（如Context、View等，其实这两个就足够了，已经能干很多了）

准备工作

创建项目 & 引入依赖

首先，我们打开Android Studio创建一个空项目，不需要任何Activity，语言凭个人喜好创建，反正我两种都会讲。
然后，我们需要引入Xposed的库，不过它并没有上传到MavenCentral上，所以我们需要在settings.gradle里修改一下(gradle 7.0+)

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url 'https://api.xposed.info/' }  // 添加这一行即可
    }
}

之后，进入我们app目录下的build.gradle引入xposed的依赖，当然你也可以移除所有依赖来让安装包变小

dependencies {
    compileOnly 'de.robv.android.xposed:api:82' 
    // compileOnly 'de.robv.android.xposed:api:82:sources' // 不要导入源码，这会导致idea无法索引文件，从而让语法提示失效
}

如果你移除了所有依赖只保留了Xposed，你就会发现，你的项目不能build，会直接报错！没关系，我们修复一下：

移除src/res/values/themes.xml里面的主题(注意还有个夜间模式，在values-night文件夹下)
移除AndroidManifest.xml文件里<application ... />中的android:theme="xxx"那一行移除之后就能build了。我们继续，我们需要创建一个模块作用域文件，在values目录下创建一个名叫arrays的资源文件，它的内容如下：

<resources>
    <string-array name="xposedscope" >
        <!-- 这里填写模块的作用域应用的包名，可以填多个。 -->
        <item>me.kyuubiran.xposedapp</item> 
    </string-array>
</resources>

最后，我们在Run那里编辑一下启动配置，勾选Always install with package manager并且将Launch Options改成Nothing

声明模块

做完上一步之后，我们需要声明它是一个Xposed模块，好让框架发现它，这样我们才能激活模块。
回到AndroidManifest.xml文件里，我们将<application ... />改成以下形式（注意，是改成！就是把结尾的/>换成> </application>）

<application ... > 
        <!-- 是否为Xposed模块 -->
        <meta-data
            android:name="xposedmodule"
            android:value="true"/>
        <!-- 模块的简介（在框架中显示） -->
        <meta-data
            android:name="xposeddescription"
            android:value="我是Xposed模块简介" />
        <!-- 模块最低支持的Api版本 一般填54即可 -->
        <meta-data 
            android:name="xposedminversion"     
            android:value="54"/>
        <!-- 模块作用域 -->
        <meta-data
            android:name="xposedscope"
            android:resource="@array/xposedscope"/>
</appication>

然后在src/main目录下创建一个文件夹名叫assets，并且创建一个文件叫xposed_init，注意，它没有后缀名！！。
接着我们需要创建一个入口类，名叫MainHook（或者随便你想取什么名字都行），创建好后回到我们的xposed_init里并用文本文件的方式打开它，输入我们刚刚创建的类的完整路径。如：me.kyuubiran.xposedtutorial.MainHook，同时注意大小写。
到这里，我们声明模块的部分就结束了！怎么样，接下去就到了我们激动人心的编写模块部分了！

模块编写

MainHook

来到我们的MainHook，首先我们需要实现以下Xposed的IXposedHookLoadPackage接口，以便执行Hook操作。具体操作如下
Java:

package me.kyuubiran.xposedtutorial;

import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.callbacks.XC_LoadPackage;

public class MainHook implements IXposedHookLoadPackage {
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
        // 过滤不必要的应用
        if (!lpparam.packageName.equals("me.kyuubiran.xposedapp")) return;
        // 执行Hook
        hook(lpparam);
    }

    private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
        // 具体流程
    }
}

Kotlin:

package me.kyuubiran.xposedtutorial

import de.robv.android.xposed.IXposedHookLoadPackage
import de.robv.android.xposed.callbacks.XC_LoadPackage

class MainHook : IXposedHookLoadPackage {
    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
        // 过滤不必要的应用
        if (lpparam.packageName != "me.kyuubiran.xposedapp") return
        // 执行Hook
        hook(lpparam)
    }

    private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
        // 具体流程
    }
}

到这里，我们的准备工作已经完成，安装模块并在框架中激活它！

启用模块

反编译

终于到了我们反编译apk找hook点的时候了！我这里有一份猜拳游戏的apk，今天我我们要做的事情就是成为赌圣（
我们先打开jadx-gui，选择我们的guess.apk，等他加载完，说明反编译就完成了。
接下去，我们打开应用并且查看它当前布局是什么（我这里使用的是开发者助手专业版）

布局查看

如图所示，我们现在处于me.kyuubiran.xposedapp.MainActivity，接着回到我们的jadx中，依次展开并找到这个Activity，就像这样：

反编译

Hook activity

我们最基础的hook方式，就是使用Xposed自带的XposedHelpers.findAndHookMethod，使用方法如下：
Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    // 它有两个重载，区别是一个是填Class，一个是填ClassName以及ClassLoader
    // 第一种 填ClassName
    XC_MethodHook.Unhook unhook = XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.MainActivity",    // className
            lpparam.classLoader,    // classLoader 使用lpparam.classLoader
            "onCreate",             // 要hook的方法
            Bundle.class,           // 要hook的方法的参数表，如果有多个就用逗号隔开 
            new XC_MethodHook() {   // 最后一个填hook的回调
                @Override
                protected void beforeHookedMethod(MethodHookParam param) {} // Hook方法执行前  
                @Override
                protected void afterHookedMethod(MethodHookParam param) {} // Hook方法执行后
            });
    // 它返回一个unhook 在你不需要继续hook的时候可以调用它来取消Hook
    unhook.unhook();    // 取消空的Hook 

    // 第二种方式 填Class
    // 首先你得加载它的类 我们使用XposedHelpers.findClass即可 参数有两个 一个是类名 一个是类加载器
    Class<?> clazz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader);
    XposedHelpers.findAndHookMethod(clazz, "onCreate", Bundle.class, new XC_MethodHook() {
        @Override
        protected void afterHookedMethod(MethodHookParam param){
            // 由于我们需要在Activity创建之后再弹出Toast，所以我们Hook方法执行之后
            Toast.makeText((Activity) param.thisObject, "模块加载成功！", Toast.LENGTH_SHORT).show();
        }
    });
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    // 它有两个重载，区别是一个是填Class，一个是填ClassName以及ClassLoader
    // 第一种 填ClassName
    val unhook = XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.MainActivity",   // className
        lpparam.classLoader,        // classLoader 使用lpparam.classLoader
        "onCreate",                 // 要hook的方法
        Bundle::class.java          // 要hook的方法的参数表，如果有多个就用逗号隔开 
        object : XC_MethodHook() {  // 最后一个填hook的回调 
            override fun beforeHookedMethod(param: MethodHookParam) {} // Hook方法执行前
            override fun afterHookedMethod(param: MethodHookParam) {} // Hook方法执行后
        })
    // 它返回一个unhook 在你不需要继续hook的时候可以调用它来取消Hook
    unhook.unhook()    // 取消空的Hook
        
    // 第二种方式 填Class
    // 首先你得加载它的类 我们使用XposedHelpers.findClass即可 参数有两个 一个是类名 一个是类加载器
    val clazz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader)
    // 相当于合并了第一、第二两个参数，所以它的使用方式如下：
    XposedHelpers.findAndHookMethod(clazz,"onCreate", Bundle::class.java, object : XC_MethodHook() {
        override fun afterHookedMethod(param: MethodHookParam) {
          // 由于我们需要在Activity创建之后再弹出Toast，所以我们Hook方法执行之后
          Toast.makeText(param.thisObject as Activity, "模块加载成功！", Toast.LENGTH_SHORT).show()
        }
    })
}

其中，param.thisObject代表调用这个方法的对象（如果是静态方法的话可能是为null），我们hook的是Activity的onCreate方法，调用它的自然是这个Activity啦，所以我们把param.thisObject强制转换为Activity类型就能丢给Toast来makeText啦！
安装Xposed模块并且勾选它，如果弹出Toast了，说明你的模块已经生效了！

激活Toast

Hook 其他类

终于到了我们成为赌圣的时刻！我们需要先分析一下代码，可以看到MainActivity里面有个confirm方法，它里面包含了判断我们胜负的逻辑。

确认按钮

接着看，它在里面new了一个Guess对象，我们CTRL+鼠标左键点开Guess类看看。

Guess类

可以看到，里面有一个isDraw和isWin来判断我们的胜负和平局，接下去我们就需要hook这两个方法！ Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
            lpparam.classLoader,
            "isDraw",
            int.class,    // 如果参数是宿主的类，你可以使用findClass来加载那个类或是填写那个类的完整名称！
            new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) {
                    // 将返回值设置为false 表示我们不是平局
                    param.setResult(false);
                }
            });
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
            lpparam.classLoader,
            "isWin",
            int.class,
            boolean.class,
            new XC_MethodReplacement() {   // 另一种回调，将方法直接替换成你要执行的内容（其实就是包装过的beforeHook，基本用不到）
                @Override
                protected Object replaceHookedMethod(MethodHookParam param) {
                    return true;
                }
            });
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    XposedHelpers.findAndHookMethod(
        "me.kyuubiran.xposedapp.Guess",
        lpparam.classLoader,
        "isDraw",
        Int::class.java, // 如果参数是宿主的类，你可以使用findClass来加载那个类或是填写那个类的完整名称！
        object : XC_MethodHook() {
            override fun beforeHookedMethod(param: MethodHookParam) {
                // 将返回值设置为false 表示我们不是平局
                param.result = false
            }
        })
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
        lpparam.classLoader,
        "isWin",
        Int::class.java,
        object : XC_MethodReplacement() {   // 另一种回调，将方法直接替换成你要执行的内容（其实就是包装过的beforeHook，基本用不到）
            override fun replaceHookedMethod(param: MethodHookParam): Any {
                // 直接返回true
                return true
            }
        })
}

修改代码之后我们重新安装模块并且启动app，这时我们发现，无论是我们本应该输或者平局，它都算我们胜利！
虽然这么做你赢了游戏，但是别人一眼就看出来了！接下去我来教你如何让对手“配合”你一起演戏！

首先，我们观察点击猜拳按钮的代码，发现isDraw是先被执行的，而且Guess里面的answer是类被实例化之后就创建好了的，并且它也没有方法给我们hook，此时就要出动我们的反射了！
由于isDraw是先被执行的，我们需要在isDraw被执行之前就得使用反射进行“偷梁换柱”，不多bb了上代码！
Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
            lpparam.classLoader,
            "isDraw",
            int.class,
            new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) {
                    try {                        
                        // 首先 我们要拿到他的字段
                        Field fAnswer = param.thisObject.getClass().getDeclaredField("answer");
                        // 并且让它可访问 否则会报非法访问的错误
                        fAnswer.setAccessible(true);
                        int win = 0;
                        // 根据猜拳应用的逻辑 0是石头 1是剪刀 2是布
                        switch ((int) param.args[0]) {  // 首先我们拿到方法的第一个参数 他是int类型
                            case 0:         // 石头->剪刀
                                win = 1;
                                break;
                            case 1:         // 剪刀->布
                                win = 2;
                                break;
                            case 2:         // 布->石头
                                win = 0;
                                break;
                        }
                        // 最后设置answer的值让对手根据我们的出拳来“演戏”
                        fAnswer.set(param.thisObject, win);
                    } catch (Exception ignored) {
                    }
                }
            });
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    XposedHelpers.findAndHookMethod(
        "me.kyuubiran.xposedapp.Guess",
        lpparam.classLoader,
        "isDraw",
        Int::class.java,
        object : XC_MethodHook() {
            override fun beforeHookedMethod(param: MethodHookParam) {
                // 首先 我们要拿到他的字段
                val fAnswer = param.thisObject.javaClass.getDeclaredField("answer")
                // 并且让它可访问 否则会报非法访问的错误
                fAnswer.isAccessible = true
                // 根据猜拳应用的逻辑 0是石头 1是剪刀 2是布
                val win = when (param.args[0] as Int) { // 首先我们拿到方法的第一个参数 他是Int类型 就是我们的出拳
                    0 -> 1         // 石头->剪刀
                    1 -> 2         // 剪刀->布
                    2 -> 0         // 布->石头
                    else -> 0
                }
                // 最后设置answer的值让对手根据我们的出拳来“演戏”
                fAnswer.set(param.thisObject, win)
            }
        })
}

重新安装运行，完美！现在对手会配合我们出拳来故意让我们取得胜利！从此，你就是赌圣！

另一种方式

Xposed其实还提供了另一种方式进行Hook，就是使用XposedBridge.hookMethod。
其实基本上没有太大区别，只不过方法是你自己寻找罢了，举个例子：
Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    Class<?> clz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader);
    for (Method m : clz.getDeclaredMethods()) {
        if (m.getName().equals("onCreate")) {
            XposedBridge.hookMethod(m, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) {
                    Toast.makeText((Activity) param.thisObject, "我又Hook了MainActivity的onCreate方法！", Toast.LENGTH_SHORT).show();
                }
            });
        }
    }
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    val clz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader)
    for (m in clz.declaredMethods) {
        if (m.name == "onCreate") {
            XposedBridge.hookMethod(m,object : XC_MethodHook() {
                override fun afterHookedMethod(param: MethodHookParam) {
                    Toast.makeText(param.thisObject as Activity,"我又Hook了MainActivity的onCreate方法！",Toast.LENGTH_SHORT).show()
                }
            })
        }
    }
}

结束

以上便是Xposed入门教程了，应该是目前最友好的教程了，该讲的基本都讲了（虽然废话可能有点多）剩下就看造化了（

Q & A

Q1: 什么时候用beforeHook，什么时候用afterHook，它们的区别是什么？
A1: 你可以把before当成方法第一行执行之前，after当成方法最后一行执行完毕准备返回。如果你要修改参数，那就用before，如果你要修改返回值，那就用after，如果你不需要方法执行直接结束方法，那就用before，当然他俩是可以同时使用的，看具体情况。综合上述，基本用before就行了。

上篇kotlin lambda入门

下篇Steam挂刀教程以及个人经验