HighCapable/YukiHookAPI
5
0
Fork 0
mirror of https://github.com/HighCapable/YukiHookAPI.git synced 2025-09-06 10:45:47 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Modify move HookParamWrapper to YukiHookCallback.Param

Browse Source
This commit is contained in:
fankesyooni
2022-08-26 22:27:43 +08:00
parent fa352c7c7c
commit 25e3dd2d59
6 changed files with 202 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
docs/api/public/HookParam.md
View File

@@ -1,13 +1,17 @@
## HookParam *- class* ## HookParam *- class*
```kotlin ```kotlin
class HookParam internal constructor(private val createrInstance: YukiMemberHookCreater, private var wrapper: HookParamWrapper?) class HookParam internal constructor(private val createrInstance: YukiMemberHookCreater, private var param: YukiHookCallback.Param?)
``` ```
**变更记录** **变更记录**
`v1.0` `添加` `v1.0` `添加`
`v1.0.93` `修改`
移动 `HookParamWrapper` 到 `YukiHookCallback.Param`
**功能描述** **功能描述**
> Hook 方法、构造方法的目标对象实现类。 > Hook 方法、构造方法的目标对象实现类。
@@ -26,6 +30,8 @@ val args: Array<Any?>
> 获取当前 Hook 对象 `member` 或 `constructor` 的参数对象数组。 > 获取当前 Hook 对象 `member` 或 `constructor` 的参数对象数组。
这里的数组每项类型默认为 `Any`，你可以使用 `args` 方法来实现 `ArgsModifyer.cast` 功能。
### ~~firstArgs *- field*~~ <!-- {docsify-ignore} --> ### ~~firstArgs *- field*~~ <!-- {docsify-ignore} -->
**变更记录** **变更记录**

35
yukihookapi/src/api/kotlin/com/highcapable/yukihookapi/hook/core/YukiMemberHookCreater.kt
View File

@@ -43,7 +43,6 @@ import com.highcapable.yukihookapi.hook.log.yLoggerW
import com.highcapable.yukihookapi.hook.param.HookParam import com.highcapable.yukihookapi.hook.param.HookParam
import com.highcapable.yukihookapi.hook.param.PackageParam import com.highcapable.yukihookapi.hook.param.PackageParam
import com.highcapable.yukihookapi.hook.param.type.HookEntryType import com.highcapable.yukihookapi.hook.param.type.HookEntryType
import com.highcapable.yukihookapi.hook.param.wrapper.HookParamWrapper
import com.highcapable.yukihookapi.hook.type.java.* import com.highcapable.yukihookapi.hook.type.java.*
import com.highcapable.yukihookapi.hook.utils.await import com.highcapable.yukihookapi.hook.utils.await
import com.highcapable.yukihookapi.hook.xposed.bridge.YukiHookBridge import com.highcapable.yukihookapi.hook.xposed.bridge.YukiHookBridge
@@ -554,20 +553,20 @@ class YukiMemberHookCreater(@PublishedApi internal val packageParam: PackagePara
/** 定义替换 Hook 回调方法体 */ /** 定义替换 Hook 回调方法体 */
val replaceMent = object : YukiMemberReplacement(priority) { val replaceMent = object : YukiMemberReplacement(priority) {
override fun replaceHookedMember(wrapper: HookParamWrapper) = override fun replaceHookedMember(param: Param) =
replaceHookParam.assign(wrapper).let { param -> replaceHookParam.assign(param).let { assign ->
try { try {
replaceHookCallback?.invoke(param).also { replaceHookCallback?.invoke(assign).also {
checkingReturnType((wrapper.member as? Method?)?.returnType, it?.javaClass) checkingReturnType((param.member as? Method?)?.returnType, it?.javaClass)
if (replaceHookCallback != null) onHookLogMsg(msg = "Replace Hook Member [${this@hook}] done [$tag]") if (replaceHookCallback != null) onHookLogMsg(msg = "Replace Hook Member [${this@hook}] done [$tag]")
HookParam.invoke() HookParam.invoke()
} }
} catch (e: Throwable) { } catch (e: Throwable) {
onConductFailureCallback?.invoke(param, e) onConductFailureCallback?.invoke(assign, e)
onAllFailureCallback?.invoke(e) onAllFailureCallback?.invoke(e)
if (onConductFailureCallback == null && onAllFailureCallback == null) onHookFailureMsg(e) if (onConductFailureCallback == null && onAllFailureCallback == null) onHookFailureMsg(e)
/** 若发生异常则会自动调用未经 Hook 的原始方法保证 Hook APP 正常运行 */ /** 若发生异常则会自动调用未经 Hook 的原始方法保证 Hook APP 正常运行 */
wrapper.member?.also { wrapper.invokeOriginalMember(it, wrapper.args) } param.member?.also { member -> param.invokeOriginalMember(member, param.args) }
} }
} }
} }
@@ -580,33 +579,33 @@ class YukiMemberHookCreater(@PublishedApi internal val packageParam: PackagePara
/** 定义前后 Hook 回调方法体 */ /** 定义前后 Hook 回调方法体 */
val beforeAfterHook = object : YukiMemberHook(priority) { val beforeAfterHook = object : YukiMemberHook(priority) {
override fun beforeHookedMember(wrapper: HookParamWrapper) { override fun beforeHookedMember(param: Param) {
beforeHookParam.assign(wrapper).also { param -> beforeHookParam.assign(param).also { assign ->
runCatching { runCatching {
beforeHookCallback?.invoke(param) beforeHookCallback?.invoke(assign)
checkingReturnType((wrapper.member as? Method?)?.returnType, wrapper.result?.javaClass) checkingReturnType((param.member as? Method?)?.returnType, param.result?.javaClass)
if (beforeHookCallback != null) onHookLogMsg(msg = "Before Hook Member [${this@hook}] done [$tag]") if (beforeHookCallback != null) onHookLogMsg(msg = "Before Hook Member [${this@hook}] done [$tag]")
HookParam.invoke() HookParam.invoke()
}.onFailure { }.onFailure {
onConductFailureCallback?.invoke(param, it) onConductFailureCallback?.invoke(assign, it)
onAllFailureCallback?.invoke(it) onAllFailureCallback?.invoke(it)
if (onConductFailureCallback == null && onAllFailureCallback == null) onHookFailureMsg(it) if (onConductFailureCallback == null && onAllFailureCallback == null) onHookFailureMsg(it)
if (isOnFailureThrowToApp) wrapper.throwable = it if (isOnFailureThrowToApp) param.throwable = it
} }
} }
} }
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
afterHookParam.assign(wrapper).also { param -> afterHookParam.assign(param).also { assign ->
runCatching { runCatching {
afterHookCallback?.invoke(param) afterHookCallback?.invoke(assign)
if (afterHookCallback != null) onHookLogMsg(msg = "After Hook Member [${this@hook}] done [$tag]") if (afterHookCallback != null) onHookLogMsg(msg = "After Hook Member [${this@hook}] done [$tag]")
HookParam.invoke() HookParam.invoke()
}.onFailure { }.onFailure {
onConductFailureCallback?.invoke(param, it) onConductFailureCallback?.invoke(assign, it)
onAllFailureCallback?.invoke(it) onAllFailureCallback?.invoke(it)
if (onConductFailureCallback == null && onAllFailureCallback == null) onHookFailureMsg(it) if (onConductFailureCallback == null && onAllFailureCallback == null) onHookFailureMsg(it)
if (isOnFailureThrowToApp) wrapper.throwable = it if (isOnFailureThrowToApp) param.throwable = it
} }
} }
} }

40
yukihookapi/src/api/kotlin/com/highcapable/yukihookapi/hook/param/HookParam.kt
View File

@@ -33,7 +33,7 @@ import com.highcapable.yukihookapi.hook.core.YukiMemberHookCreater
import com.highcapable.yukihookapi.hook.core.YukiMemberHookCreater.MemberHookCreater import com.highcapable.yukihookapi.hook.core.YukiMemberHookCreater.MemberHookCreater
import com.highcapable.yukihookapi.hook.factory.classOf import com.highcapable.yukihookapi.hook.factory.classOf
import com.highcapable.yukihookapi.hook.log.yLoggerE import com.highcapable.yukihookapi.hook.log.yLoggerE
import com.highcapable.yukihookapi.hook.param.wrapper.HookParamWrapper import com.highcapable.yukihookapi.hook.xposed.bridge.factory.YukiHookCallback
import java.lang.reflect.Constructor import java.lang.reflect.Constructor
import java.lang.reflect.Member import java.lang.reflect.Member
import java.lang.reflect.Method import java.lang.reflect.Method
@@ -41,9 +41,9 @@ import java.lang.reflect.Method
/** /**
* Hook 方法、构造方法的目标对象实现类 * Hook 方法、构造方法的目标对象实现类
* @param createrInstance [YukiMemberHookCreater] 的实例对象 * @param createrInstance [YukiMemberHookCreater] 的实例对象
* @param wrapper [HookParam] 的参数包装类实例 * @param param Hook 结果回调接口
*/ */
class HookParam internal constructor(private val createrInstance: YukiMemberHookCreater, private var wrapper: HookParamWrapper? = null) { class HookParam internal constructor(private val createrInstance: YukiMemberHookCreater, private var param: YukiHookCallback.Param? = null) {
internal companion object { internal companion object {
@@ -57,20 +57,22 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
} }
/** /**
* 在回调中设置 [HookParam] 使用的 [HookParamWrapper] * 在回调中设置 [HookParam] 使用的 [YukiHookCallback.Param]
* @param wrapper [HookParamWrapper] 实例 * @param param Hook 结果回调接口
* @return [HookParam] * @return [HookParam]
*/ */
internal fun assign(wrapper: HookParamWrapper): HookParam { internal fun assign(param: YukiHookCallback.Param): HookParam {
this.wrapper = wrapper this.param = param
return this return this
} }
/** /**
* 获取当前 Hook 对象 [method] or [constructor] 的参数对象数组 * 获取当前 Hook 对象 [method] or [constructor] 的参数对象数组
*
* 这里的数组每项类型默认为 [Any] - 你可以使用 [args] 方法来实现 [ArgsModifyer.cast] 功能
* @return [Array] * @return [Array]
*/ */
val args get() = wrapper?.args ?: arrayOf(0) val args get() = param?.args ?: arrayOf(0)
/** /**
* 获取当前 Hook 实例的对象 * 获取当前 Hook 实例的对象
@@ -79,13 +81,13 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
* @return [Any] * @return [Any]
* @throws IllegalStateException 如果对象为空 * @throws IllegalStateException 如果对象为空
*/ */
val instance get() = wrapper?.instance ?: error("HookParam instance got null! Is this a static member?") val instance get() = param?.instance ?: error("HookParam instance got null! Is this a static member?")
/** /**
* 获取当前 Hook 实例的类对象 * 获取当前 Hook 实例的类对象
* @return [Class] * @return [Class]
*/ */
val instanceClass get() = wrapper?.instance?.javaClass ?: createrInstance.instanceClass val instanceClass get() = param?.instance?.javaClass ?: createrInstance.instanceClass
/** /**
* 获取当前 Hook 对象的 [Member] * 获取当前 Hook 对象的 [Member]
@@ -94,7 +96,7 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
* @return [Member] * @return [Member]
* @throws IllegalStateException 如果 [member] 为空 * @throws IllegalStateException 如果 [member] 为空
*/ */
val member get() = wrapper?.member ?: error("Current hooked Member is null") val member get() = param?.member ?: error("Current hooked Member is null")
/** /**
* 获取当前 Hook 对象的方法 * 获取当前 Hook 对象的方法
@@ -115,22 +117,22 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
* @return [Any] or null * @return [Any] or null
*/ */
var result: Any? var result: Any?
get() = wrapper?.result get() = param?.result
set(value) { set(value) {
wrapper?.result = value param?.result = value
} }
/** /**
* 判断是否存在设置过的方法调用抛出异常 * 判断是否存在设置过的方法调用抛出异常
* @return [Boolean] * @return [Boolean]
*/ */
val hasThrowable get() = wrapper?.hasThrowable val hasThrowable get() = param?.hasThrowable
/** /**
* 获取设置的方法调用抛出异常 * 获取设置的方法调用抛出异常
* @return [Throwable] or null * @return [Throwable] or null
*/ */
val throwable get() = wrapper?.throwable val throwable get() = param?.throwable
/** /**
* 向 Hook APP 抛出异常 * 向 Hook APP 抛出异常
@@ -146,7 +148,7 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
* @throws Throwable * @throws Throwable
*/ */
fun Throwable.throwToApp() { fun Throwable.throwToApp() {
wrapper?.throwable = this param?.throwable = this
yLoggerE(msg = message ?: "$this", e = this) yLoggerE(msg = message ?: "$this", e = this)
} }
@@ -183,7 +185,7 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
* @param args 参数实例 * @param args 参数实例
* @return [T] * @return [T]
*/ */
fun <T> Member.invokeOriginal(vararg args: Any?) = wrapper?.invokeOriginalMember(member = this, *args) as? T? fun <T> Member.invokeOriginal(vararg args: Any?) = param?.invokeOriginalMember(member = this, *args) as? T?
/** /**
* 设置当前 Hook 对象方法的 [result] 返回值为 true * 设置当前 Hook 对象方法的 [result] 返回值为 true
@@ -349,7 +351,7 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
if (index < 0) error("HookParam Method args index must be >= 0") if (index < 0) error("HookParam Method args index must be >= 0")
if (args.isEmpty()) error("HookParam Method args is empty, mabe not has args") if (args.isEmpty()) error("HookParam Method args is empty, mabe not has args")
if (index > args.lastIndex) error("HookParam Method args index out of bounds, max is ${args.lastIndex}") if (index > args.lastIndex) error("HookParam Method args index out of bounds, max is ${args.lastIndex}")
wrapper?.setArgs(index, any) param?.setArgs(index, any)
} }
/** /**
@@ -376,5 +378,5 @@ class HookParam internal constructor(private val createrInstance: YukiMemberHook
override fun toString() = "Args of index $index" override fun toString() = "Args of index $index"
} }
override fun toString() = "HookParam by $wrapper" override fun toString() = "HookParam by $param"
} }

118
yukihookapi/src/api/kotlin/com/highcapable/yukihookapi/hook/param/wrapper/HookParamWrapper.kt
View File

@@ -1,118 +0,0 @@
/*
* YukiHookAPI - An efficient Kotlin version of the Xposed Hook API.
* Copyright (C) 2019-2022 HighCapable
* https://github.com/fankes/YukiHookAPI
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* This file is Created by fankes on 2022/2/9.
*/
package com.highcapable.yukihookapi.hook.param.wrapper
import com.highcapable.yukihookapi.annotation.YukiPrivateApi
import com.highcapable.yukihookapi.hook.param.HookParam
import com.highcapable.yukihookapi.hook.xposed.bridge.factory.YukiHookHelper
import de.robv.android.xposed.XC_MethodHook
import java.lang.reflect.Member
/**
* 用于包装 [HookParam]
*
* - ❗这是一个私有 API - 请不要在外部使用
* @param baseParam 对接 [XC_MethodHook.MethodHookParam]
*/
@YukiPrivateApi
class HookParamWrapper internal constructor(private var baseParam: XC_MethodHook.MethodHookParam? = null) {
/**
* 在回调中设置 [HookParamWrapper] 使用的 [XC_MethodHook.MethodHookParam]
* @param baseParam 对接 [XC_MethodHook.MethodHookParam]
* @return [HookParamWrapper]
*/
internal fun assign(baseParam: XC_MethodHook.MethodHookParam): HookParamWrapper {
this.baseParam = baseParam
return this
}
/**
* [Member] 实例
* @return [Member] or null
*/
val member: Member? get() = baseParam?.method
/**
* 当前实例对象
* @return [Any] or null
*/
val instance: Any? get() = baseParam?.thisObject
/**
* 方法、构造方法数组
* @return [Array] or null
*/
val args: Array<Any?>? get() = baseParam?.args
/**
* 获取、设置方法结果
* @return [Any] or null
*/
var result: Any?
get() = baseParam?.result
set(value) {
baseParam?.result = value
}
/**
* 判断是否存在设置过的方法调用抛出异常
* @return [Boolean]
*/
val hasThrowable get() = baseParam?.hasThrowable() ?: false
/**
* 获取、设置方法调用抛出的异常
* @return [Throwable] or null
* @throws Throwable
*/
var throwable: Throwable?
get() = baseParam?.throwable
set(value) {
baseParam?.throwable = value
}
/**
* 设置方法参数
* @param index 数组下标
* @param any 参数对象实例
*/
fun setArgs(index: Int, any: Any?) = baseParam?.args?.set(index, any)
/**
* 执行原始 [Member]
*
* 未进行 Hook 的 [Member]
* @param member 实例
* @param args 参数实例
* @return [Any] or null
*/
fun invokeOriginalMember(member: Member, vararg args: Any?): Any? = YukiHookHelper.invokeOriginalMember(member, instance, args)
override fun toString() = "HookParamWrapper[$baseParam]"
}

167
yukihookapi/src/api/kotlin/com/highcapable/yukihookapi/hook/xposed/bridge/factory/YukiBridgeFactory.kt
View File

@@ -33,7 +33,6 @@ import com.highcapable.yukihookapi.hook.core.finder.ConstructorFinder
import com.highcapable.yukihookapi.hook.core.finder.MethodFinder import com.highcapable.yukihookapi.hook.core.finder.MethodFinder
import com.highcapable.yukihookapi.hook.core.finder.base.BaseFinder import com.highcapable.yukihookapi.hook.core.finder.base.BaseFinder
import com.highcapable.yukihookapi.hook.log.yLoggerE import com.highcapable.yukihookapi.hook.log.yLoggerE
import com.highcapable.yukihookapi.hook.param.wrapper.HookParamWrapper
import com.highcapable.yukihookapi.hook.xposed.bridge.YukiHookBridge import com.highcapable.yukihookapi.hook.xposed.bridge.YukiHookBridge
import de.robv.android.xposed.XC_MethodHook import de.robv.android.xposed.XC_MethodHook
import de.robv.android.xposed.XposedBridge import de.robv.android.xposed.XposedBridge
@@ -114,9 +113,9 @@ internal object YukiHookHelper {
return when { return when {
member == null -> Pair(null, false) member == null -> Pair(null, false)
YukiHookBridge.hasXposedBridge -> YukiHookBridge.hasXposedBridge ->
YukiMemberHook.Unhook.wrapper(XposedBridge.hookMethod(member, callback.compat())).let { XposedBridge.hookMethod(member, callback.compat()).compat().let { memberUnhook ->
YukiHookedMembers.hookedMembers.add(it) YukiHookedMembers.hookedMembers.add(memberUnhook)
Pair(it, false) Pair(memberUnhook, false)
} }
else -> Pair(null, false) else -> Pair(null, false)
} }
@@ -135,105 +134,189 @@ internal object YukiHookHelper {
member?.let { XposedBridge.invokeOriginalMethod(it, instance, args) } member?.let { XposedBridge.invokeOriginalMethod(it, instance, args) }
else null else null
/**
* 兼容对接已 Hook 的 [Member] 接口
* @return [YukiMemberHook.Unhook]
*/
private fun XC_MethodHook.Unhook.compat() = object : YukiMemberHook.Unhook() {
override val member get() = hookedMethod
override fun unhook() = this@compat.unhook()
}
/** /**
* 兼容对接 Hook 回调接口 * 兼容对接 Hook 回调接口
* @return [XC_MethodHook] 原始接口 * @return [XC_MethodHook] 原始接口
*/ */
private fun YukiHookCallback.compat() = object : XC_MethodHook(priority) { private fun YukiHookCallback.compat() = object : XC_MethodHook(priority) {
/** 创建 Hook 前 [HookParamWrapper] */
private val beforeHookWrapper = HookParamWrapper()
/** 创建 Hook 后 [HookParamWrapper] */
private val afterHookWrapper = HookParamWrapper()
override fun beforeHookedMethod(param: MethodHookParam?) { override fun beforeHookedMethod(param: MethodHookParam?) {
if (param == null) return if (param == null) return
if (this@compat !is YukiMemberHook) error("Invalid YukiHookCallback type") if (this@compat !is YukiMemberHook) error("Invalid YukiHookCallback type")
if (this@compat is YukiMemberReplacement) if (this@compat is YukiMemberReplacement)
param.result = replaceHookedMember(beforeHookWrapper.assign(param)) param.result = replaceHookedMember(param.compat())
else beforeHookedMember(beforeHookWrapper.assign(param)) else beforeHookedMember(param.compat())
} }
override fun afterHookedMethod(param: MethodHookParam?) { override fun afterHookedMethod(param: MethodHookParam?) {
if (param == null) return if (param == null) return
if (this@compat !is YukiMemberHook) error("Invalid YukiHookCallback type") if (this@compat !is YukiMemberHook) error("Invalid YukiHookCallback type")
afterHookedMember(afterHookWrapper.assign(param)) afterHookedMember(param.compat())
} }
} }
/**
* 兼容对接 Hook 结果回调接口
* @return [YukiHookCallback.Param]
*/
private fun XC_MethodHook.MethodHookParam.compat() = object : YukiHookCallback.Param {
override val member get() = this@compat.method
override val instance get() = this@compat.thisObject
override val args get() = this@compat.args
override val hasThrowable get() = this@compat.hasThrowable()
override var result
get() = this@compat.result
set(value) {
this@compat.result = value
}
override var throwable
get() = this@compat.throwable
set(value) {
this@compat.throwable = value
}
override fun setArgs(index: Int, any: Any?) {
this@compat.args[index] = any
}
override fun invokeOriginalMember(member: Member, vararg args: Any?) =
YukiHookHelper.invokeOriginalMember(member, this@compat.thisObject, args)
}
} }
/** /**
* Hook 替换方法回调接口 * Hook 替换方法回调接口抽象类
* @param priority Hook 优先级- 默认 [YukiHookPriority.PRIORITY_DEFAULT] * @param priority Hook 优先级- 默认 [YukiHookPriority.PRIORITY_DEFAULT]
*/ */
internal abstract class YukiMemberReplacement(override val priority: Int = YukiHookPriority.PRIORITY_DEFAULT) : YukiMemberHook(priority) { internal abstract class YukiMemberReplacement(override val priority: Int = YukiHookPriority.PRIORITY_DEFAULT) : YukiMemberHook(priority) {
override fun beforeHookedMember(wrapper: HookParamWrapper) { override fun beforeHookedMember(param: Param) {
wrapper.result = replaceHookedMember(wrapper) param.result = replaceHookedMember(param)
} }
override fun afterHookedMember(wrapper: HookParamWrapper) {} override fun afterHookedMember(param: Param) {}
/** /**
* 拦截替换为指定结果 * 拦截替换为指定结果
* @param wrapper 包装实例 * @param param Hook 结果回调接口
* @return [Any] or null * @return [Any] or null
*/ */
abstract fun replaceHookedMember(wrapper: HookParamWrapper): Any? abstract fun replaceHookedMember(param: Param): Any?
} }
/** /**
* Hook 方法回调接口 * Hook 方法回调接口抽象类
* @param priority Hook 优先级 - 默认 [YukiHookPriority.PRIORITY_DEFAULT] * @param priority Hook 优先级 - 默认 [YukiHookPriority.PRIORITY_DEFAULT]
*/ */
internal abstract class YukiMemberHook(override val priority: Int = YukiHookPriority.PRIORITY_DEFAULT) : YukiHookCallback(priority) { internal abstract class YukiMemberHook(override val priority: Int = YukiHookPriority.PRIORITY_DEFAULT) : YukiHookCallback(priority) {
/** /**
* 在方法执行之前注入 * 在方法执行之前注入
* @param wrapper 包装实例 * @param param Hook 结果回调接口
*/ */
open fun beforeHookedMember(wrapper: HookParamWrapper) {} open fun beforeHookedMember(param: Param) {}
/** /**
* 在方法执行之后注入 * 在方法执行之后注入
* @param wrapper 包装实例 * @param param Hook 结果回调接口
*/ */
open fun afterHookedMember(wrapper: HookParamWrapper) {} open fun afterHookedMember(param: Param) {}
/** /**
* 已经 Hook 且可被解除 Hook 的 [Member] 实现类 * 已经 Hook 且可被解除 Hook 的 [Member] 实现接口抽象类
* @param instance 对接 [XC_MethodHook.Unhook]
*/ */
internal class Unhook private constructor(private val instance: XC_MethodHook.Unhook) { internal abstract class Unhook internal constructor() {
internal companion object {
/**
* 从 [XC_MethodHook.Unhook] 创建 [Unhook] 实例
* @param instance [XC_MethodHook.Unhook] 实例
* @return [Unhook]
*/
internal fun wrapper(instance: XC_MethodHook.Unhook) = Unhook(instance)
}
/** /**
* 当前被 Hook 的 [Member] * 当前被 Hook 的 [Member]
* @return [Member] or null * @return [Member] or null
*/ */
internal val member: Member? get() = instance.hookedMethod internal abstract val member: Member?
/** 解除 [instance] 的 Hook 并从 [YukiHookedMembers.hookedMembers] 缓存数组中移除 */ /** 解除 Hook */
internal abstract fun unhook()
/** 解除 Hook 并从 [YukiHookedMembers.hookedMembers] 缓存数组中移除 */
internal fun remove() { internal fun remove() {
if (YukiHookBridge.hasXposedBridge.not()) return if (YukiHookBridge.hasXposedBridge.not()) return
instance.unhook() unhook()
runCatching { YukiHookedMembers.hookedMembers.remove(this) } runCatching { YukiHookedMembers.hookedMembers.remove(this) }
} }
} }
} }
/** /**
* Hook 回调接口父类 * Hook 回调接口抽象类
* @param priority Hook 优先级 * @param priority Hook 优先级
*/ */
internal abstract class YukiHookCallback(open val priority: Int) internal abstract class YukiHookCallback(open val priority: Int) {
/**
* Hook 结果回调接口
*/
internal interface Param {
/**
* [Member] 实例
* @return [Member] or null
*/
val member: Member?
/**
* 当前实例对象
* @return [Any] or null
*/
val instance: Any?
/**
* 方法、构造方法数组
* @return [Array] or null
*/
val args: Array<Any?>?
/**
* 获取、设置方法结果
* @return [Any] or null
*/
var result: Any?
/**
* 判断是否存在设置过的方法调用抛出异常
* @return [Boolean]
*/
val hasThrowable: Boolean
/**
* 获取、设置方法调用抛出的异常
* @return [Throwable] or null
* @throws Throwable
*/
var throwable: Throwable?
/**
* 设置方法参数
* @param index 数组下标
* @param any 参数对象实例
*/
fun setArgs(index: Int, any: Any?)
/**
* 执行原始 [Member]
*
* 未进行 Hook 的 [Member]
* @param member 实例
* @param args 参数实例
* @return [Any] or null
*/
fun invokeOriginalMember(member: Member, vararg args: Any?): Any?
}
}

65
yukihookapi/src/api/kotlin/com/highcapable/yukihookapi/hook/xposed/parasitic/AppParasitics.kt
View File

@@ -44,7 +44,6 @@ import com.highcapable.yukihookapi.hook.factory.*
import com.highcapable.yukihookapi.hook.log.yLoggerE import com.highcapable.yukihookapi.hook.log.yLoggerE
import com.highcapable.yukihookapi.hook.log.yLoggerW import com.highcapable.yukihookapi.hook.log.yLoggerW
import com.highcapable.yukihookapi.hook.param.type.HookEntryType import com.highcapable.yukihookapi.hook.param.type.HookEntryType
import com.highcapable.yukihookapi.hook.param.wrapper.HookParamWrapper
import com.highcapable.yukihookapi.hook.type.android.* import com.highcapable.yukihookapi.hook.type.android.*
import com.highcapable.yukihookapi.hook.type.java.BooleanType import com.highcapable.yukihookapi.hook.type.java.BooleanType
import com.highcapable.yukihookapi.hook.type.java.IntType import com.highcapable.yukihookapi.hook.type.java.IntType
@@ -133,24 +132,24 @@ internal object AppParasitics {
internal fun hookModuleAppRelated(loader: ClassLoader?, type: HookEntryType) { internal fun hookModuleAppRelated(loader: ClassLoader?, type: HookEntryType) {
if (YukiHookAPI.Configs.isEnableHookSharedPreferences && type == HookEntryType.PACKAGE) if (YukiHookAPI.Configs.isEnableHookSharedPreferences && type == HookEntryType.PACKAGE)
YukiHookHelper.hook(ContextImplClass.method { name = "setFilePermissionsFromMode" }, object : YukiMemberHook() { YukiHookHelper.hook(ContextImplClass.method { name = "setFilePermissionsFromMode" }, object : YukiMemberHook() {
override fun beforeHookedMember(wrapper: HookParamWrapper) { override fun beforeHookedMember(param: Param) {
if ((wrapper.args?.get(0) as? String?)?.endsWith(suffix = "preferences.xml") == true) wrapper.args?.set(1, 1) if ((param.args?.get(0) as? String?)?.endsWith(suffix = "preferences.xml") == true) param.setArgs(index = 1, any = 1)
} }
}) })
if (YukiHookAPI.Configs.isEnableHookModuleStatus) classOf<YukiHookModuleStatus>(loader).apply { if (YukiHookAPI.Configs.isEnableHookModuleStatus) classOf<YukiHookModuleStatus>(loader).apply {
if (type != HookEntryType.RESOURCES) { if (type != HookEntryType.RESOURCES) {
YukiHookHelper.hook(method { name = YukiHookModuleStatus.IS_ACTIVE_METHOD_NAME }, object : YukiMemberReplacement() { YukiHookHelper.hook(method { name = YukiHookModuleStatus.IS_ACTIVE_METHOD_NAME }, object : YukiMemberReplacement() {
override fun replaceHookedMember(wrapper: HookParamWrapper) = true override fun replaceHookedMember(param: Param) = true
}) })
YukiHookHelper.hook(method { name = YukiHookModuleStatus.GET_XPOSED_TAG_METHOD_NAME }, object : YukiMemberReplacement() { YukiHookHelper.hook(method { name = YukiHookModuleStatus.GET_XPOSED_TAG_METHOD_NAME }, object : YukiMemberReplacement() {
override fun replaceHookedMember(wrapper: HookParamWrapper) = YukiHookBridge.executorName override fun replaceHookedMember(param: Param) = YukiHookBridge.executorName
}) })
YukiHookHelper.hook(method { name = YukiHookModuleStatus.GET_XPOSED_VERSION_METHOD_NAME }, object : YukiMemberReplacement() { YukiHookHelper.hook(method { name = YukiHookModuleStatus.GET_XPOSED_VERSION_METHOD_NAME }, object : YukiMemberReplacement() {
override fun replaceHookedMember(wrapper: HookParamWrapper) = YukiHookBridge.executorVersion override fun replaceHookedMember(param: Param) = YukiHookBridge.executorVersion
}) })
} else } else
YukiHookHelper.hook(method { name = YukiHookModuleStatus.HAS_RESOURCES_HOOK_METHOD_NAME }, object : YukiMemberReplacement() { YukiHookHelper.hook(method { name = YukiHookModuleStatus.HAS_RESOURCES_HOOK_METHOD_NAME }, object : YukiMemberReplacement() {
override fun replaceHookedMember(wrapper: HookParamWrapper) = true override fun replaceHookedMember(param: Param) = true
}) })
} }
} }
@@ -164,56 +163,56 @@ internal object AppParasitics {
runCatching { runCatching {
if (AppLifecycleCallback.isCallbackSetUp) { if (AppLifecycleCallback.isCallbackSetUp) {
YukiHookHelper.hook(ApplicationClass.method { name = "attach"; param(ContextClass) }, object : YukiMemberHook() { YukiHookHelper.hook(ApplicationClass.method { name = "attach"; param(ContextClass) }, object : YukiMemberHook() {
override fun beforeHookedMember(wrapper: HookParamWrapper) { override fun beforeHookedMember(param: Param) {
runCatching { runCatching {
(wrapper.args?.get(0) as? Context?)?.also { AppLifecycleCallback.attachBaseContextCallback?.invoke(it, false) } (param.args?.get(0) as? Context?)?.also { AppLifecycleCallback.attachBaseContextCallback?.invoke(it, false) }
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
runCatching { runCatching {
(wrapper.args?.get(0) as? Context?)?.also { AppLifecycleCallback.attachBaseContextCallback?.invoke(it, true) } (param.args?.get(0) as? Context?)?.also { AppLifecycleCallback.attachBaseContextCallback?.invoke(it, true) }
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
}) })
YukiHookHelper.hook(ApplicationClass.method { name = "onTerminate" }, object : YukiMemberHook() { YukiHookHelper.hook(ApplicationClass.method { name = "onTerminate" }, object : YukiMemberHook() {
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
runCatching { runCatching {
(wrapper.instance as? Application?)?.also { AppLifecycleCallback.onTerminateCallback?.invoke(it) } (param.instance as? Application?)?.also { AppLifecycleCallback.onTerminateCallback?.invoke(it) }
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
}) })
YukiHookHelper.hook(ApplicationClass.method { name = "onLowMemory" }, object : YukiMemberHook() { YukiHookHelper.hook(ApplicationClass.method { name = "onLowMemory" }, object : YukiMemberHook() {
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
runCatching { runCatching {
(wrapper.instance as? Application?)?.also { AppLifecycleCallback.onLowMemoryCallback?.invoke(it) } (param.instance as? Application?)?.also { AppLifecycleCallback.onLowMemoryCallback?.invoke(it) }
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
}) })
YukiHookHelper.hook(ApplicationClass.method { name = "onTrimMemory"; param(IntType) }, object : YukiMemberHook() { YukiHookHelper.hook(ApplicationClass.method { name = "onTrimMemory"; param(IntType) }, object : YukiMemberHook() {
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
runCatching { runCatching {
val self = wrapper.instance as? Application? ?: return val self = param.instance as? Application? ?: return
val type = wrapper.args?.get(0) as? Int? ?: return val type = param.args?.get(0) as? Int? ?: return
AppLifecycleCallback.onTrimMemoryCallback?.invoke(self, type) AppLifecycleCallback.onTrimMemoryCallback?.invoke(self, type)
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
}) })
YukiHookHelper.hook(ApplicationClass.method { name = "onConfigurationChanged" }, object : YukiMemberHook() { YukiHookHelper.hook(ApplicationClass.method { name = "onConfigurationChanged" }, object : YukiMemberHook() {
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
runCatching { runCatching {
val self = wrapper.instance as? Application? ?: return val self = param.instance as? Application? ?: return
val config = wrapper.args?.get(0) as? Configuration? ?: return val config = param.args?.get(0) as? Configuration? ?: return
AppLifecycleCallback.onConfigurationChangedCallback?.invoke(self, config) AppLifecycleCallback.onConfigurationChangedCallback?.invoke(self, config)
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
}) })
} }
if (YukiHookAPI.Configs.isEnableDataChannel || AppLifecycleCallback.isCallbackSetUp) if (YukiHookAPI.Configs.isEnableDataChannel || AppLifecycleCallback.isCallbackSetUp)
YukiHookHelper.hook(InstrumentationClass.method { name = "callApplicationOnCreate" }, object : YukiMemberHook() { YukiHookHelper.hook(InstrumentationClass.method { name = "callApplicationOnCreate" }, object : YukiMemberHook() {
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
runCatching { runCatching {
(wrapper.args?.get(0) as? Application?)?.also { (param.args?.get(0) as? Application?)?.also {
hostApplication = it hostApplication = it
AppLifecycleCallback.onCreateCallback?.invoke(it) AppLifecycleCallback.onCreateCallback?.invoke(it)
AppLifecycleCallback.onReceiversCallback.takeIf { e -> e.isNotEmpty() }?.forEach { (_, e) -> AppLifecycleCallback.onReceiversCallback.takeIf { e -> e.isNotEmpty() }?.forEach { (_, e) ->
@@ -226,7 +225,7 @@ internal object AppParasitics {
} }
runCatching { YukiHookDataChannel.instance().register(it, packageName) } runCatching { YukiHookDataChannel.instance().register(it, packageName) }
} }
}.onFailure { wrapper.throwable = it } }.onFailure { param.throwable = it }
} }
}) })
} }
@@ -240,9 +239,9 @@ internal object AppParasitics {
internal fun hookClassLoader(loader: ClassLoader?, result: (clazz: Class<*>, resolve: Boolean) -> Unit) { internal fun hookClassLoader(loader: ClassLoader?, result: (clazz: Class<*>, resolve: Boolean) -> Unit) {
runCatching { runCatching {
YukiHookHelper.hook(JavaClassLoader.method { name = "loadClass"; param(StringType, BooleanType) }, object : YukiMemberHook() { YukiHookHelper.hook(JavaClassLoader.method { name = "loadClass"; param(StringType, BooleanType) }, object : YukiMemberHook() {
override fun afterHookedMember(wrapper: HookParamWrapper) { override fun afterHookedMember(param: Param) {
if (wrapper.instance?.javaClass?.name == loader?.javaClass?.name) if (param.instance?.javaClass?.name == loader?.javaClass?.name)
(wrapper.result as? Class<*>?)?.also { result(it, wrapper.args?.get(1) as? Boolean ?: false) } (param.result as? Class<*>?)?.also { result(it, param.args?.get(1) as? Boolean ?: false) }
} }
}) })
}.onFailure { yLoggerW(msg = "Try to hook ClassLoader failed: $it") } }.onFailure { yLoggerW(msg = "Try to hook ClassLoader failed: $it") }