Yuki Hook API

https://highcapable.github.io/YukiHookAPI/en
Admin
Yuki Hook API is an efficient Hook API and Xposed Module solution built in Kotlin, designed to...
Tokens:139,811
Snippets:1,806
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example: Get and Use Hook Instance

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/HookParam.html

Demonstrates how to retrieve the hook instance as an Activity type and call a method on it.

```kotlin
instance<Activity>().finish()
```

--------------------------------

### RemedyPlan - onFind method example

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/MethodFinder.html

Example of how to use the onFind method within a RemedyPlan to handle found methods.

```kotlin
method {
    // Your code here.
}.onFind {
    // Your code here.
}
```

--------------------------------

### Start Module Activity from Host Environment

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/host-inject.html

Start a registered Module Activity from anywhere in the Host environment that has a Context. This allows seamless integration of module activities.

```kotlin
val context: Context = ... // Assume this is your Context
context.startActivity(context, HostTestActivity::class.java)
```

--------------------------------

### Custom Application Setup with YukiHookAPI

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-using.html

Integrate YukiHookAPI into your custom Application class by adding the dependency and calling YukiHookAPI.encase in attachBaseContext. This is the standard setup for using YukiHookAPI.

```kotlin
class MyApplication : Application() {

    override fun attachBaseContext(base: Context?) {
        // Load Hook Framework
        //
        // Your code here.
        //
        // Configure YukiHookAPI
        YukiHookApi.configs {
            // Your code here.
        }
        // Load YukiHookAPI
        YukiHookAPI.encase(base) {
            // Your code here.
        }
        super.attachBaseContext(base)
    }
}
```

--------------------------------

### Example Usage of onFind

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Demonstrates how to use the onFind method within a constructor search to handle the results when a constructor is successfully located.

```kotlin
constructor {
    // Your code here.
}.onFind {
    // Your code here.
}
```

--------------------------------

### RemedyPlan - remedys method example

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/MethodFinder.html

Example demonstrating how to use the remedys method within a RemedyPlan to re-search for methods that might exist in different forms. This allows for adding multiple method bodies until success, without needing to catch exceptions.

```kotlin
method {
    // Your code here.
}.remedys {
    method {
        // Your code here.
    }
    method {
        // Your code here.
    }
}
```

--------------------------------

### Class Definitions for Migration Example

Source: https://highcapable.github.io/YukiHookAPI/en/guide/move-to-new-api.html

Defines base class B and derived class A for demonstrating reflection differences.

```java
public class B {
    public void test(String a) {
        // ...
    }
}

public class A extends B {
    // ...
}
```

--------------------------------

### Custom sourcePath Parameter Example

Source: https://highcapable.github.io/YukiHookAPI/en/config/xposed-using.html

Example of setting a custom sourcePath parameter for the InjectYukiHookWithXposed annotation. This is necessary if your project path deviates from the default 'src/main'.

```kotlin
@InjectYukiHookWithXposed(sourcePath = "src/custom")

```

--------------------------------

### Registering Module App Activities with Default Parameters

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-exception.html

Example of registering module app activities using default parameters. This is suitable for apps that have a declared startup entry Activity.

```kotlin
registerModuleAppActivities()
```

--------------------------------

### Getting All Matching Field Instances

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Demonstrates how to retrieve a list of all Field instances that match the current search criteria. The usage for each Field instance is similar to the 'get' method.

```kotlin
field {
    // Your code here.
}.all(instance).forEach { instance ->
    instance.self
}
```

--------------------------------

### Get Index Method

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/base/BaseFinder.html

Retrieves the bytecode index.

```kotlin
fun index(): IndexTypeConditionSort
```

--------------------------------

### Example of NoClassDefFoundError

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-exception.html

Demonstrates the usage of `toClass()` which can lead to a `NoClassDefFoundError` if the class is not found in the ClassLoader.

```kotlin
"com.demo.Test".toClass()
```

--------------------------------

### Example Usage of Field Re-finding with onFind Callback

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Demonstrates how to use the field re-finding mechanism with the onFind callback to handle successful field discoveries.

```kotlin
field {
    // Your code here.
}.onFind {
    // Your code here.
}
```

--------------------------------

### Module App: Notify and Send Listener

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/xposed-channel

Example of the Module App waiting for a notification and sending a listener key to the Host App.

```kotlin
dataChannel(packageName = "com.example.demo").wait(key = "listener_from_host") {
    // Your code here.
}
dataChannel(packageName = "com.example.demo").put(key = "listener_from_module")

```

--------------------------------

### Host App: Notify and Send Listener

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/xposed-channel

Example of the Host App waiting for a notification and sending a listener key to the Module App.

```kotlin
dataChannel.wait(key = "listener_from_module") {
    // Your code here.
}
dataChannel.put(key = "listener_from_host")

```

--------------------------------

### Example Usage of Result Lambda

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Shows how to use a lambda to create a Result class, enabling the configuration of listeners for all search results, remedies, and cases where no constructor is found.

```kotlin
constructor {
    // Your code here.
}.result {
    all()
    remedys {}
    onNoSuchConstructor {}
}
```

--------------------------------

### Missing Parameter in loadApp/loadZygote/loadSystem/withProcess

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-exception.html

Shows examples where the required parameter is missing for the loadApp, loadZygote, loadSystem, and withProcess methods.

```kotlin
// <Scenario 1>
loadApp()
// <Scenario 2>
loadZygote()
// <Scenario 3>
loadSystem()
// <Scenario 4>
withProcess()


```

--------------------------------

### resources

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Obtains the `YukiResources` object for the current Hook APP. To start hooking, call the `HookResources.hook` method.

```APIDOC
## resources

### Description
Gets the `YukiResources` object of the current Hook APP.
Please call the `HookResources.hook` method to start Hooking.

### Returns
- **HookResources** - The HookResources object.
```

--------------------------------

### Registering Module App Activities with Proxy

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-exception.html

Example of registering module app activities with a specified proxy. Ensure the proxy parameter is of an allowed type (String, CharSequence, Class).

```kotlin
registerModuleAppActivities(proxy = false)
```

--------------------------------

### Module App: Wait for and Send Data

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/xposed-channel

Example of how the Module App waits for data from the Host App and sends data to it using the dataChannel.

```kotlin
dataChannel(packageName = "com.example.demo").wait<String>(key = "key_from_host") { value ->
    // Your code here.
}
dataChannel(packageName = "com.example.demo").put(key = "key_from_module", value = "I am module")

```

--------------------------------

### Example Usage of Remedys

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Demonstrates using RemedyPlan to re-search constructors when the initial find might fail. It allows adding multiple constructor search attempts within the remedys block.

```kotlin
constructor {
    // Your code here.
}.remedys {
    constructor {
        // Your code here.
    }
    constructor {
        // Your code here.
    }
}
```

--------------------------------

### Example: Using onLoadClass with a custom ClassLoader

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/ReflectionFactory

Shows how to attach a class loading listener to a custom ClassLoader instance. This is useful when dealing with specific ClassLoader implementations.

```kotlin
val customClassLoader: ClassLoader? = ... // 假设这个就是你的 ClassLoader
customClassLoader?.onLoadClass { clazz ->
    // ...
}
```

--------------------------------

### Host App: Wait for and Send Data

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/xposed-channel

Example of how the Host App waits for data from the Module App and sends data to it using the dataChannel.

```kotlin
dataChannel.wait<String>(key = "key_from_module") { value ->
    // Your code here.
}
dataChannel.put(key = "key_from_host", value = "I am host")

```

--------------------------------

### Example: Using onLoadClass with appClassLoader

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/ReflectionFactory

Demonstrates how to use the onLoadClass method with the appClassLoader to perform operations when a specific class is loaded. Ensure you have a valid ClassLoader instance.

```kotlin
appClassLoader.onLoadClass { clazz ->
    // 得到 clazz 即加载对象
    clazz... // 这里进行你需要的操作
}
```

--------------------------------

### Registering Module App Activities with Specific Proxy

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-exception.html

Example of registering module app activities by specifying a particular Activity proxy. Ensure the specified Activity exists and extends Activity.

```kotlin
registerModuleAppActivities(proxy = "com.demo.test.TestActivity")
```

--------------------------------

### Hooking all methods using Legacy allMembers

Source: https://highcapable.github.io/YukiHookAPI/en/config/move-to-api-1-2-x.html

This example shows the legacy method for hooking all members of a specific type, in this case, all methods.

```kotlin
injectMembers {
    allMembers(MembersType.METHOD)
    afterHook {
        // Your code here.
    }
}

```

--------------------------------

### Getting HookResources

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Obtains the YukiResources object for the current Hook APP. Use HookResources.hook to start hooking.

```kotlin
fun resources(): HookResources
```

--------------------------------

### Hooking all constructors using Legacy allMembers

Source: https://highcapable.github.io/YukiHookAPI/en/config/move-to-api-1-2-x.html

This example shows the legacy method for hooking all members of a specific type, in this case, all constructors.

```kotlin
injectMembers {
    allMembers(MembersType.CONSTRUCTOR)
    afterHook {
        // Your code here.
    }
}

```

--------------------------------

### from

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/classes/DexClassFinder.html

Sets the search scope for the current Class within a specified package name. This improves search speed by only looking within package paths that start with the given name. For example, 'com.demo.test' or 'com.demo.test.demo'. It is recommended to specify this parameter to avoid slow searches when there are many Classes.

```APIDOC
## # from - method

### Description
Sets the search scope for the current Class within a specified package name. This improves search speed by only looking within package paths that start with the given name. For example, 'com.demo.test' or 'com.demo.test.demo'. It is recommended to specify this parameter to avoid slow searches when there are many Classes.

### Method
`fun from(vararg name: String): FromPackageRules`
```

--------------------------------

### Java Static Initializer Block Example

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/ReflectionFactory

Demonstrates the structure of a static initializer block in a Java class. This block is executed when the class is initialized.

```java
public class DemoClass {

    static {
        // Content of the static initializer block
    }

    public DemoClass() {
        // ...
    }
}
```

--------------------------------

### onHookingFailure Method for Hook Start Error

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/YukiMemberHookCreator

Listens for errors that occur when the hook starts. This is a first-version method.

```kotlin
fun onHookingFailure(result: (Throwable) -> Unit): Result
```

--------------------------------

### onInit Method for Configuration

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/proxy/IYukiHookXposedInit.html

Used to initialize YukiHookAPI configurations. Only configuration operations are allowed here; Hook operations are prohibited. This method is optional.

```kotlin
fun onInit()
```

--------------------------------

### Process - inline fun result example

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/MethodFinder.html

Example of creating a Result class using lambda syntax for method lookup processing.

```kotlin
method {
    // Your code here.
}.result {
    all()
    remedys {}
    onNoSuchMethod {}
}
```

--------------------------------

### Calling a Constructor instance

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Shows how to obtain a Constructor instance and immediately call it to create a new object. This is the most direct way to invoke a constructor.

```kotlin
constructor {
    // Your code here.
}.get().call()
```

--------------------------------

### Getting All Matching Method Instances

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/MethodFinder.html

Demonstrates how to retrieve a mutable list of all Method instances that match the specified criteria, allowing iteration and further actions.

```kotlin
method {
    // Your code here.
}.all(instance).forEach { instance ->
    instance.call(...)
}
```

--------------------------------

### Calling a Constructor instance with arguments

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Demonstrates how to execute a constructor and pass arguments to it using the `call` method. The arguments are passed as a vararg of Any?.

```kotlin
Instance(constructor).call(arg1, arg2)
```

--------------------------------

### Getting Class Instance via Java Literal

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/ReflectionFactory

Demonstrates how to get a Class object using Kotlin's built-in '.java' syntax.

```kotlin
DemoClass::class.java

```

--------------------------------

### Getting and Setting Field Instance

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Shows how to obtain a Field instance and use it to set the value of a field on a specific object instance.

```kotlin
field {
    // Your code here.
}.get(instance).set("something")
```

--------------------------------

### Custom modulePackageName Parameter Example

Source: https://highcapable.github.io/YukiHookAPI/en/config/xposed-using.html

Example of manually setting the modulePackageName parameter for the InjectYukiHookWithXposed annotation. This is used when the package name needs to be explicitly defined.

```kotlin
@InjectYukiHookWithXposed(modulePackageName = "com.example.demo")

```

--------------------------------

### Example: Hooking a specific class after loading

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/ReflectionFactory

Illustrates how to hook a specific class once it has been loaded by a custom ClassLoader. This allows you to apply modifications or intercept methods of the target class.

```kotlin
val customClassLoader: ClassLoader? = ... // 假设这个就是你的 ClassLoader
customClassLoader?.onLoadClass { clazz ->
    if(clazz.name == /** 你需要的 Class 名称 */) {
        clazz.hook {
            // ...
        }
    }
}
```

--------------------------------

### Vague Find Method by Start and End Strings

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

Locates a method based on its starting and ending characters. This is useful for identifying methods with predictable naming conventions.

```kotlin
// Assume this is an instance of this Class
val instance = Test()
// Call and execute using YukiHookAPI
Test::class.java.method {
    name {
        // Contains do at the beginning and Task at the end
        it.startsWith("do") && it.endsWith("Task")
    }
    param(StringClass)
}.get(instance).call("task_name")

```

--------------------------------

### Migrate Hook Entry Point with Rovo89 Xposed API

Source: https://highcapable.github.io/YukiHookAPI/en/guide/move-to-new-api.html

Implement `initZygote` for module initialization and `handleLoadPackage` for package-specific hooks. Resource hooking requires `handleInitPackageResources`.

```kotlin
private lateinit var moduleResources: XModuleResources

override fun initZygote(sparam: IXposedHookZygoteInit.StartupParam) {
    moduleResources = XModuleResources.createInstance(sparam.modulePath, null)
}

override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
    // Get the package name of the current Hook
    lpparam.packageName
    // Get the ApplicationInfo of the current Hook
    lpparam.applicationInfo
    // Get the system context object
    // There is no ready-made calling method in the Rovo89 Xposed API, you need to reflect ActivityThread to achieve it
    // Get the host Application lifecycle
    AndroidAppHelper.currentApplication()
    // Class Hook
    if(lpparam.packageName == "com.demo.test")
        XposedHelpers.findAndHookMethod(
            "com.demo.test.TestClass", lpparam.classLoader,
            "test", Boolean::class.java,
            object : XC_MethodHook() {
                override fun afterHookedMethod(param: MethodHookParam) {
                    // ...
                }
            }
        )
}

override fun handleInitPackageResources(resparam: XC_InitPackageResources.InitPackageResourcesParam) {
    // Get the package name of the current Hook
    resparam.packageName
    // Resources Hook
    resparam.res.setReplacement(
        "com.demo.test", "mipmap", "ic_launcher",
        moduleResources.fwd(R.mipmap.ic_launcher)
    )
}
```

--------------------------------

### Traditional Xposed Hook Implementation

Source: https://highcapable.github.io/YukiHookAPI/en/guide/home.html

Illustrates the conventional method of implementing Xposed hooks using XposedHelpers and XC_MethodHook. This serves as a comparison to the YukiHookAPI approach.

```java
class HookEntry : IXposedHookZygoteInit, IXposedHookLoadPackage {

    private lateinit var moduleResources: XModuleResources

    override fun initZygote(sparam: IXposedHookZygoteInit.StartupParam) {
        moduleResources = XModuleResources.createInstance(sparam.modulePath, null)
        XposedHelpers.findAndHookMethod(
                Activity::class.java.name,
                null, "onCreate",
                Bundle::class.java,
                object : XC_MethodHook() {
                    override fun beforeHookedMethod(param: MethodHookParam?) {
                        // Your code here.
                    }

                    override fun afterHookedMethod(param: MethodHookParam?) {
                        // Your code here.
                    }
                })
    }

    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
        if (lpparam.packageName == "com.android.browser")
            XposedHelpers.findAndHookMethod(
                Activity::class.java.name,
                lpparam.classLoader, "onCreate",
                Bundle::class.java,
                object : XC_MethodHook() {
                    override fun beforeHookedMethod(param: MethodHookParam?) {
                        // Your code here.
                    }

                    override fun afterHookedMethod(param: MethodHookParam?) {
                        // Your code here.
                    }
                })
    }
}


```

--------------------------------

### all Method

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Sets multiple Constructor instances that match all search conditions to the hookManager.

```APIDOC
## all Method

### Description
Sets multiple Constructor instances that match all search conditions to the hookManager.

### Signature
```kotlin
fun all(): Process
```

### Returns
* **Process** - The Process object for further handling.
```

--------------------------------

### Calling all matching Constructor instances

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Shows how to retrieve a list of all matching Constructor instances and iterate through them to perform actions, such as calling each one.

```kotlin
constructor {
    // Your code here.
}.all().forEach { instance ->
    instance.call(...)
}
```

--------------------------------

### Get Obfuscated Method by Order

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

Use this method to get a method based on its position within the class. Use with caution as order can be indeterminate. Assumes an instance of the class is available.

```kotlin
val instance = Test()
Test::class.java.method {
    order().index().last()
}.get(instance).call("test_string") // Get the last method of the current Class
```

--------------------------------

### Creating a typed instance with parameters

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Demonstrates creating a typed instance when the constructor requires arguments. All required parameters must be provided in the correct order.

```kotlin
constructor {
    // Your code here.
}.get().newInstance<TestClass>("param1", "param2")
```

--------------------------------

### Handling Multiple Package Names with Class Hookers

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-example.html

Example of loading a custom hooker within a specific app package when the hooker is defined as a class, not an object, to support multiple instantiations.

```kotlin
encase {
    // Assume this is the app package name and child Hooker you need to load
    loadApp("com.example.demo", YourCustomHooker)
}
```

--------------------------------

### Basic YukiBaseHooker Implementation

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-example.html

Extend `YukiBaseHooker` to create a custom hooker. The `onHook` method is where your hooking logic resides. Recommended to use singleton objects.

```kotlin
object CustomHooker : YukiBaseHooker() {

    override fun onHook() {
        // Your code here.
    }
}
```

--------------------------------

### absolute

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/classes/DexClassFinder.html

Sets the package name to match absolutely. For example, given the following package names: `com.demo.test.a`, `com.demo.test.a.b`, `com.demo.test.active`. If the package name condition is `com.demo.test.a`, absolute matching will only match the first one. Conversely, without the example, all will be matched.

```APIDOC
## absolute - method

### Description
Sets the package name to match absolutely. For example, given the following package names: `com.demo.test.a`, `com.demo.test.a.b`, `com.demo.test.active`. If the package name condition is `com.demo.test.a`, absolute matching will only match the first one. Conversely, without the example, all will be matched.

### Method
fun absolute()
```

--------------------------------

### Migrate Hook Entry Point with YukiHookAPI

Source: https://highcapable.github.io/YukiHookAPI/en/guide/move-to-new-api.html

Use `encase` for lambda-style hook entry points. Access package name, app info, and contexts directly within the `encase` block. Supports class and resource hooking.

```kotlin
override fun onHook() = encase {
    // Get the package name of the current Hook
    packageName
    // Get the ApplicationInfo of the current Hook
    appInfo
    // Get the system context object
    systemContext
    // Get the host Application lifecycle
    appContext
    // Hook specified app
    loadApp(name = "com.demo.test") {
        // Member Hook
        "com.demo.test.TestClass".toClass()
            .resolve()
            .firstMethod {
                name = "test"
                parameters(Boolean::class)
            }.hook {
                after {
                    // ...
                }
            }
        // Resources Hook (fixed usage)
        resources().hook {
            injectResource {
                conditions {
                    name = "ic_launcher"
                    mipmap()
                }
                replaceToModuleResource(R.mipmap.ic_launcher)
            }
        }
    }
}
```

--------------------------------

### Load Multiple System Hookers - Kotlin

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks the system framework with multiple YukiBaseHooker instances. This enables the efficient loading of several system hooks.

```kotlin
fun loadSystem(vararg hooker: YukiBaseHooker)
```

--------------------------------

### appInfo - field

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Gets the ApplicationInfo of the current Hook APP.

```APIDOC
## appInfo - field

```
val appInfo: ApplicationInfo
```

**Change Records**
`v1.0` `first`

**Function Illustrate**
> 获取当前 Hook APP 的 `ApplicationInfo`。

```

--------------------------------

### ignoredHookingFailure Method

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/YukiMemberHookCreator

Ignores errors that occur when the hook starts. This is a first-version method.

```kotlin
fun ignoredHookingFailure(): Result
```

--------------------------------

### Basic Hook Creation with encase

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-example.html

This sample demonstrates how to use the `encase` method to load an app and perform Hook operations on a specific method. It requires the `YukiHookAPI` object.

```kotlin
YukiHookAPI.encase {
    loadApp(name = "com.example.demo") {
        "$packageName.DemoClass".toClass()
            .resolve()
            .firstMethod {
                // Your code here.
            }.hook {
                // Your code here.
            }
    }
}
```

--------------------------------

### Chain Hooks for onCreate and onStart Methods

Source: https://highcapable.github.io/YukiHookAPI/en/guide/example.html

Chains hooks for both onCreate and onStart methods of Activity in the com.android.browser app using Kotlin's apply method. This demonstrates how to apply multiple hooks to the same class.

```kotlin
loadApp(name = "com.android.browser") {
    Activity::class.resolve().apply {
        firstMethod {
            name = "onCreate"
            parameters(Bundle::class)
        }.hook {
            after {
                AlertDialog.Builder(instance())
                    .setTitle("Hooked")
                    .setMessage("I am hook!")
                    .setPositiveButton("OK", null)
                    .show()
            }
        }
        firstMethod {
            name = "onStart"
            emptyParameters()
        }.hook {
            after {
                // Your code here.
            }
        }
    }
}
```

--------------------------------

### Get Field as Any

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Retrieves the current Field's value as Any. This is a general-purpose retrieval method.

```kotlin
fun any(): Any?
```

--------------------------------

### Xposed Framework Structure

Source: https://highcapable.github.io/YukiHookAPI/en/guide/knowledge.html

Illustrates the basic workings and principles of the Xposed Framework, showing how it interacts with an app's environment and hooks its operations.

```text
Xposed Framework
└── App's Environment
    └── Hooker (Hooked)
        ...
    App's Environment
    └── Hooker (Hooked)
        ...
    ...

```

--------------------------------

### processName

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Gets the process name of the currently hooked application. This field was available since v1.0.

```APIDOC
## # processName - field
```
val processName: String

```

**Change Records**
`v1.0` `first`
**Function Illustrate**
> 获取当前 Hook APP 的进程名称。
```

--------------------------------

### Get Float Preference

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/prefs/YukiHookPrefsBridge

Retrieves a Float preference value. Specify the key and a default value.

```kotlin
fun getFloat(key: String, value: Float): Float
```

--------------------------------

### Get Long Preference

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/prefs/YukiHookPrefsBridge

Retrieves a Long preference value. Specify the key and a default value.

```kotlin
fun getLong(key: String, value: Long): Long
```

--------------------------------

### Calling a Method with XposedHelpers

Source: https://highcapable.github.io/YukiHookAPI/en/guide/move-to-new-api.html

Demonstrates how to call a method using XposedHelpers, which automatically searches superclasses.

```java
val instance: A = ...
XposedHelpers.callMethod(instance, "test", "some string")
```

--------------------------------

### Get Integer Preference

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/prefs/YukiHookPrefsBridge

Retrieves an Integer preference value. Specify the key and a default value.

```kotlin
fun getInt(key: String, value: Int): Int
```

--------------------------------

### Get Boolean Preference

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/prefs/YukiHookPrefsBridge

Retrieves a Boolean preference value. Specify the key and a default value.

```kotlin
fun getBoolean(key: String, value: Boolean): Boolean
```

--------------------------------

### Override Default Value

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/prefs/data/PrefsData

Example of reading PrefsData and providing an overridden default value if the key is not found.

```kotlin
// 读取 - 此时 data 取到的默认值将会是 2 - 并不是模板提供的 0
val data = prefs.get(DataConst.TEST_KV_DATA_3, 2)
```

--------------------------------

### withProcess

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks the specified process of an APP. It accepts a process name and can be used with a lambda or by providing one or more YukiBaseHooker instances.

```APIDOC
## withProcess - method

### Description
Loads and hooks the specified process of an APP. The `name` parameter is the APP's process name. This method can be used with a lambda function or by directly loading a child Hooker.

### Overloads
```kotlin
inline fun withProcess(name: String, initiate: PackageParam.() -> Unit)
fun withProcess(name: String, hooker: YukiBaseHooker)
fun withProcess(vararg name: String, hooker: YukiBaseHooker)
fun withProcess(name: String, vararg hooker: YukiBaseHooker)
```

### Change Records
`v1.0.70` `added`
`v1.1.4` `modified` - Added two methods to load multiple processes and child Hookers simultaneously.
```

--------------------------------

### Get Last Argument

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/HookParam.html

Retrieves the last argument of the current Hook object's method or constructor.

```kotlin
fun last(): ArgsModifyer
```

--------------------------------

### Basic Hook Entry with YukiHookAPI

Source: https://highcapable.github.io/YukiHookAPI/en/guide/home.html

Demonstrates the fundamental structure for creating Xposed Modules using YukiHookAPI. It shows how to load Zygote and specific application packages for hooking.

```kotlin
@InjectYukiHookWithXposed
object HookEntry : IYukiHookXposedInit {

    override fun onHook() = encase {
        loadZygote {
            Activity::class.resolve().firstMethod {
                name = "onCreate"
                parameters(Bundle::class)
            }.hook {
                before {
                  // Your code here.
                }
                after {
                  // Your code here.
                }
            }
        }
        loadApp(name = "com.android.browser") {
            Activity::class.resolve().firstMethod {
                name = "onCreate"
                parameters(Bundle::class)
            }.hook {
                before {
                  // Your code here.
                }
                after {
                  // Your code here.
                }
            }
        }
    }
}

```

--------------------------------

### Basic Method Hooking with YukiHookAPI

Source: https://highcapable.github.io/YukiHookAPI/en/guide/example.html

Demonstrates the current method hooking syntax using YukiHookAPI. Use this for intercepting method calls and executing custom logic before or after the original method.

```kotlin
// KavaRef
TargetClass.resolve().firstMethod {
    // Your code here.
}.hook {
    before {
        // Your code here.
    }
    after {
        // Your code here.
    }
}

```

--------------------------------

### Get First Argument

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/HookParam.html

Retrieves the first argument of the current Hook object's method or constructor.

```kotlin
fun first(): ArgsModifyer
```

--------------------------------

### Instance Class Methods

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Provides methods to get, set, and cast field values of various types.

```APIDOC
## Instance Class

### Description
Represents an instance handler for `Field` objects, allowing direct manipulation and retrieval of field values.

### Methods

#### `current(ignored: Boolean): CurrentClass?`

##### Description
Gets the class operation object `CurrentClass` of the current `Field`'s own `self` instance.

##### Parameters
- `ignored` (Boolean) - Description not provided.

#### `current(ignored: Boolean, initiate: CurrentClass.() -> Unit): Any?`

##### Description
An inline function that gets the class operation object `CurrentClass` of the current `Field`'s own `self` instance and applies an initiation block.

##### Parameters
- `ignored` (Boolean) - Description not provided.
- `initiate` (CurrentClass.() -> Unit) - A lambda function to configure the `CurrentClass` instance.

#### `<T> cast(): T?`

##### Description
Retrieves the current `Field` instance, cast to a specified generic type `T`.

##### Type Parameters
- `T` - The target type to cast the field instance to.

#### `byte(): Byte?`

##### Description
Retrieves the current `Field` instance as a `Byte`.

#### `int(): Int`

##### Description
Retrieves the current `Field` instance as an `Int`.

#### `long(): Long`

##### Description
Retrieves the current `Field` instance as a `Long`.

#### `short(): Short`

##### Description
Retrieves the current `Field` instance as a `Short`.

#### `double(): Double`

##### Description
Retrieves the current `Field` instance as a `Double`.

#### `float(): Float`

##### Description
Retrieves the current `Field` instance as a `Float`.

#### `string(): String`

##### Description
Retrieves the current `Field` instance as a `String`.

#### `char(): Char`

##### Description
Retrieves the current `Field` instance as a `Char`.

#### `boolean(): Boolean`

##### Description
Retrieves the current `Field` instance as a `Boolean`.

#### `any(): Any?`

##### Description
Retrieves the current `Field` instance as a general `Any` object.

#### `<reified T> array(): Array<T>`

##### Description
Retrieves the current `Field` instance as an `Array` of a reified generic type `T`.

##### Type Parameters
- `T` - The type of elements in the array.

#### `<reified T> list(): List<T>`

##### Description
Retrieves the current `Field` instance as a `List` of a reified generic type `T`.

##### Type Parameters
- `T` - The type of elements in the list.

#### `set(any: Any?)`

##### Description
Sets the current `Field` instance to the provided `Any?` value.

##### Parameters
- `any` (Any?) - The value to set the field to.

#### `setTrue()`

##### Description
Sets the current `Field` instance to `true`. This method is applicable only when the field type is `Boolean`.

#### `setFalse()`

##### Description
Sets the current `Field` instance to `false`. This method is applicable only when the field type is `Boolean`.

#### `setNull()`

##### Description
Sets the current `Field` instance to `null`.
```

--------------------------------

### IYukiHookXposedInit.configs

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/YukiHookFactory

Configures the YukiHookAPI.Configs within the IYukiHookXposedInit context. This extension function allows for lambda-based initialization of configuration settings.

```APIDOC
## IYukiHookXposedInit.configs - ext-method
```kotlin
inline fun IYukiHookXposedInit.configs(initiate: YukiHookAPI.Configs.() -> Unit)
```
### Description
Configures the YukiHookAPI.Configs within the IYukiHookXposedInit context. This extension function allows for lambda-based initialization of configuration settings.
### Method
Extension Function
### Endpoint
N/A
### Parameters
* **initiate** (YukiHookAPI.Configs.() -> Unit) - Required - A lambda function to configure YukiHookAPI.Configs.
```

--------------------------------

### Get Current Process Name

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/YukiHookFactory

Access the current process name using this extension field on Context.

```kotlin
val Context.processName: String
```

--------------------------------

### loadApp

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks the specified, or all, package names of the APP. The `name` parameter is the APP's package name. The subsequent parameters can be used as a lambda method body or directly load a Hooker. If no `name` parameter is specified, this method body will filter all hookable APPs in the current system by default. If you want to filter out the module itself from all hookable APPs, you only need to add `isExcludeSelf = true`. You can load multiple APPs that need to be hooked by using the following method. You can load multiple sub-hookers by using the following method, but only one APP that needs to be hooked can be specified at this time.

```APIDOC
## loadApp

### Description
Loads and hooks the specified, or all, package names of the APP.

### Overloads
1. `inline fun loadApp(name: String, initiate: PackageParam.() -> Unit)`
2. `fun loadApp(name: String, hooker: YukiBaseHooker)`
3. `inline fun loadApp(vararg name: String, initiate: PackageParam.() -> Unit)`
4. `fun loadApp(name: String, vararg hooker: YukiBaseHooker)`
5. `inline fun loadApp(isExcludeSelf: Boolean, initiate: PackageParam.() -> Unit)`
6. `fun loadApp(isExcludeSelf: Boolean, hooker: YukiBaseHooker)`
7. `fun loadApp(isExcludeSelf: Boolean, vararg hooker: YukiBaseHooker)`

### Parameters
#### Overload 1 & 2
- **name** (String) - Required - The package name of the APP to hook.
- **initiate** (PackageParam.() -> Unit) - Required (for overload 1) - A lambda function to define the hook.
- **hooker** (YukiBaseHooker) - Required (for overload 2) - An instance of YukiBaseHooker to apply.

#### Overload 3
- **name** (vararg String) - Required - Multiple package names of the APPs to hook.
- **initiate** (PackageParam.() -> Unit) - Required - A lambda function to define the hook.

#### Overload 4
- **name** (String) - Required - The package name of the APP to hook.
- **hooker** (vararg YukiBaseHooker) - Required - Multiple instances of YukiBaseHooker to apply.

#### Overload 5
- **isExcludeSelf** (Boolean) - Required - If true, excludes the module itself from being hooked.
- **initiate** (PackageParam.() -> Unit) - Required - A lambda function to define the hook.

#### Overload 6
- **isExcludeSelf** (Boolean) - Required - If true, excludes the module itself from being hooked.
- **hooker** (YukiBaseHooker) - Required - An instance of YukiBaseHooker to apply.

#### Overload 7
- **isExcludeSelf** (Boolean) - Required - If true, excludes the module itself from being hooked.
- **hooker** (vararg YukiBaseHooker) - Required - Multiple instances of YukiBaseHooker to apply.

### Function Example
```kotlin
// Using lambda with a specific app
loadApp(name = "com.example.test") {
    // Your code here.
}

// Using Hooker with a specific app
loadApp(name = "com.example.test", CustomHooker)

// Using lambda without specifying app name (hooks all hookable apps)
loadApp {
    // Your code here.
}

// Using Hooker without specifying app name
loadApp(hooker = CustomHooker)

// Excluding self using lambda
loadApp(isExcludeSelf = true) {
    // Your code here.
}

// Excluding self using Hooker
loadApp(isExcludeSelf = true, hooker = CustomHooker)

// Loading multiple apps with lambda
loadApp("com.example.test", "com.example.next") {
    // Your code here.
}

// Loading multiple Hookers for a single app
loadApp("com.example.test", CustomHooker1, CustomHooker2)
```

### Note
- If `name` is not specified, this method defaults to filtering all hookable APPs in the current system.
- If you want to hook system frameworks, use `loadSystem`.
- If you want to hook Zygote events, use `loadZygote`.
```

--------------------------------

### Define Data Constants

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/prefs/data/PrefsData

Example of defining constants for key-value data using PrefsData for different data types.

```kotlin
object DataConst {

    val TEST_KV_DATA_1 = PrefsData("test_data_1", "defalut value")
    val TEST_KV_DATA_2 = PrefsData("test_data_2", false)
    val TEST_KV_DATA_3 = PrefsData("test_data_3", 0)
}
```

--------------------------------

### Getting String Array Type with YukiHookAPI

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

This demonstrates the simplified YukiHookAPI method for obtaining the type of a String array.

```kotlin
ArrayClass(StringClass)
```

--------------------------------

### YukiHookAPI for Constructor Invocation with Arguments

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

Demonstrates creating a new instance of a class using a specific constructor with arguments via YukiHookAPI. This simplifies object instantiation through reflection.

```kotlin
Test::class.java.constructor {
    param(BooleanType)
}.get().call(true) // Can create a new instance
```

--------------------------------

### Get Hook Framework API Level

Source: https://highcapable.github.io/YukiHookAPI/en/guide/example.html

Retrieve the API Level of the current Hook Framework using `YukiHookAPI.Status.Executor.apiLevel`.

```kotlin
val frameworkApiLevel = YukiHookAPI.Status.Executor.apiLevel
```

--------------------------------

### Getting Class Instance via classOf

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/ReflectionFactory

Demonstrates obtaining a Class object using the 'classOf' inline function.

```kotlin
classOf<DemoClass>()

```

--------------------------------

### Configure YukiHookAPI.Configs

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/factory/YukiHookFactory

Use this extension method within IYukiHookXposedInit to configure YukiHookAPI settings.

```kotlin
inline fun IYukiHookXposedInit.configs(initiate: YukiHookAPI.Configs.() -> Unit)
```

--------------------------------

### fullName

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/classes/DexClassFinder.html

Sets the full name of the Class. It will only find Classes that match Class.getName. For example, 'com.demo.Test' needs to be filled in as 'com.demo.Test'.

```APIDOC
## # fullName - method

### Description
Sets the full name of the Class. It will only find Classes that match Class.getName. For example, 'com.demo.Test' needs to be filled in as 'com.demo.Test'.

### Method
`fun fullName(value: String): ClassNameRules`
```

--------------------------------

### Getting String Array Type with Reflection

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

This shows the standard Java reflection approach to obtain the type for a String array.

```java
java.lang.reflect.Array.newInstance(String::class.java, 0).javaClass
```

--------------------------------

### onHandleInitPackageResources

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/bridge/event/YukiXposedEvent

Sets up a listener for the handleInitPackageResources event, which is called when a package's resources are initialized.

```APIDOC
## # onHandleInitPackageResources - method

```
fun onHandleInitPackageResources(result: (InitPackageResourcesParam) -> Unit)
```

**Function Illustrate**
> 设置 handleInitPackageResources 事件监听。
(Sets the handleInitPackageResources event listener.)
```

--------------------------------

### Get Hook Framework Name

Source: https://highcapable.github.io/YukiHookAPI/en/guide/example.html

Retrieve the name of the current Hook Framework (e.g., Xposed, TaiChi) using `YukiHookAPI.Status.Executor.name`.

```kotlin
val frameworkName = YukiHookAPI.Status.Executor.name
```

--------------------------------

### mainProcessName

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Gets the main process name of the currently hooked application, which corresponds to its package name. This field was added in v1.0.70.

```APIDOC
## # mainProcessName - field
```
val mainProcessName: String

```

**Change Records**
`v1.0.70` `added`
**Function Illustrate**
> 获取当前 Hook APP 的主进程名称。
其对应的就是 `packageName`。
```

--------------------------------

### Load System Hooks with Hooker - Kotlin

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks the system framework by directly providing a YukiBaseHooker instance. This method is for applying hooks to system components using a specific hooker class.

```kotlin
fun loadSystem(hooker: YukiBaseHooker)
```

--------------------------------

### Specifying Method Parameter Type with Bundle

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

This example shows how to specify the Bundle class as a parameter type for a method using YukiHookAPI.

```kotlin
method {
    name = "onCreate"
    param(BundleClass)
}
```

--------------------------------

### Create AppCompat Theme Dialog

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/host-inject.html

Use applyModuleTheme to create a theme resource in the current Module App and then use this context to create a MaterialAlertDialogBuilder.

```kotlin
resolve().firstMethod {
    name = "onCreate"
    parameters(Bundle::class)
}.hook {
    after {
        // Use applyModuleTheme to create a theme resource in the current Module App
        val appCompatContext = instance<Activity>().applyModuleTheme(R.style.Theme_AppCompat)
        // Directly use this Context that wraps the Module App's theme to create a dialog
        MaterialAlertDialogBuilder(appCompatContext)
            .setTitle("AppCompat Theme Dialog")
            .setMessage("I am an AppCompat theme dialog displayed in the Host App.")
            .setPositiveButton("OK", null)
            .show()
    }
}

```

--------------------------------

### onHandleLoadPackage

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/bridge/event/YukiXposedEvent

Sets up a listener for the handleLoadPackage event, which is invoked when a package is loaded by Xposed.

```APIDOC
## # onHandleLoadPackage - method

```
fun onHandleLoadPackage(result: (LoadPackageParam) -> Unit)
```

**Function Illustrate**
> 设置 handleLoadPackage 事件监听。
(Sets the handleLoadPackage event listener.)
```

--------------------------------

### ConstructorFinder.Instance.newInstance

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Executes the constructor to create a target instance, specifying the target instance type.

```APIDOC
## fun <T> newInstance(vararg args: Any?): T?

### Description

Executes the constructor to create a target instance, specifying the target instance type `T`. This method provides type safety by allowing you to cast the created instance to a specific class.

### Parameters

- `args` (Any?...) - Variable number of arguments to be passed to the constructor.

### Type Parameters

- `T` - The expected type of the instance to be created.

### Returns

- `T?` - The created instance of type `T`, or null if the constructor could not be invoked.

### Example

```kotlin
constructor {
    // Your code here.
}.get().newInstance<TestClass>()

constructor {
    // Your code here.
}.get().newInstance<TestClass>("param1", "param2")
```
```

--------------------------------

### Loading App with Hooker

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks a specified app using a provided YukiBaseHooker. The app is identified by its package name.

```kotlin
fun loadApp(name: String, hooker: YukiBaseHooker)
```

```kotlin
// 使用 Hooker
loadApp(name = "com.example.test", CustomHooker)
```

--------------------------------

### String to Class Conversion with Initialization

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Demonstrates how to convert a String class name to a Class instance and automatically execute its default static initializer block. This is controlled by the 'initialize' parameter.

```kotlin
"com.example.demo.DemoClass".toClass(initialize = true)
```

--------------------------------

### Getting String Array Type with YukiHookAPI Shortcut

Source: https://highcapable.github.io/YukiHookAPI/en/api/special-features/reflection.html

This shows a direct shortcut provided by YukiHookAPI for the common String array type.

```kotlin
StringArrayClass
```

--------------------------------

### YukiXposedEvent onHandleLoadPackage Listener

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/xposed/bridge/event/YukiXposedEvent

Sets up a listener for the handleLoadPackage event. This is invoked when a package is loaded.

```kotlin
fun onHandleLoadPackage(result: (LoadPackageParam) -> Unit)
```

--------------------------------

### Loading Hookers via YukiHookAPI encase

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-example.html

Load multiple hookers directly using the `YukiHookAPI.encase` method with a list of hooker instances.

```kotlin
object HookEntry : IYukiHookXposedInit {

    override fun onHook() =
        YukiHookAPI.encase(FirstHooker, SecondHooker, ThirdHooker ...)
}
```

--------------------------------

### Get Method/Constructor Result

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/HookParam.html

Retrieves the return value of the hooked method or constructor. Use this when you need to access the result of the operation being hooked.

```kotlin
inline fun <reified T> result(): T?
```

--------------------------------

### Creating a Result instance using lambda

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/ConstructorFinder.html

Demonstrates how to create a Result instance using a lambda expression. This is useful for setting up constructor search criteria and defining actions.

```kotlin
constructor {
    // Your code here.
}.result {
    get().call()
    all()
    remedys {}
    onNoSuchConstructor {}
}
```

--------------------------------

### Get Field as Boolean

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Retrieves the current Field's value as a Boolean. Ensure the field's type is compatible with Boolean.

```kotlin
fun boolean(): Boolean
```

--------------------------------

### Get Field as Char

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Retrieves the current Field's value as a Char. Ensure the field's type is compatible with Char.

```kotlin
fun char(): Char
```

--------------------------------

### Correct Member Injection Syntax

Source: https://highcapable.github.io/YukiHookAPI/en/config/api-exception.html

Demonstrates the correct syntax for injecting members, ensuring that search conditions for methods and constructors are properly set.

```kotlin
injectMember {
    // There are no search conditions for methods and constructors that require hooks
    after {
        // ...
    }
}
```

```kotlin
injectMember {
    // ✅ Examples of correct usage
    method {
        // Your code here.
    }
    after {
        // ...
    }
}
```

--------------------------------

### Get Field as String

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Retrieves the current Field's value as a String. Ensure the field's type is compatible with String.

```kotlin
fun string(): String
```

--------------------------------

### Loading App with Multiple Hookers

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks a specified app using multiple provided YukiBaseHookers. The app is identified by its package name.

```kotlin
fun loadApp(name: String, vararg hooker: YukiBaseHooker)
```

```kotlin
// 同时装载多个子 Hooker
loadApp("com.example.test", CustomHooker1, CustomHooker2)
```

--------------------------------

### Loading All Apps with Hooker (Excluding Self)

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks all hookable apps in the system, excluding the module itself, using a provided YukiBaseHooker.

```kotlin
fun loadApp(isExcludeSelf: Boolean, hooker: YukiBaseHooker)
```

```kotlin
// 使用 Hooker
loadApp(isExcludeSelf = true, hooker = CustomHooker)
```

--------------------------------

### Get Field as Float

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Retrieves the current Field's value as a Float. Ensure the field's type is compatible with Float.

```kotlin
fun float(): Float
```

--------------------------------

### Get Field as Double

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/core/finder/members/FieldFinder.html

Retrieves the current Field's value as a Double. Ensure the field's type is compatible with Double.

```kotlin
fun double(): Double
```

--------------------------------

### loadSystem

Source: https://highcapable.github.io/YukiHookAPI/en/api/public/com/highcapable/yukihookapi/hook/param/PackageParam.html

Loads and hooks the system framework. Similar to loadZygote, this can be used with a lambda or by providing YukiBaseHooker instances.

```APIDOC
## loadSystem - method

### Description
Loads and hooks the system framework. This method can be used with a lambda function or by directly loading a child Hooker.

### Overloads
```kotlin
inline fun loadSystem(initiate: PackageParam.() -> Unit)
fun loadSystem(hooker: YukiBaseHooker)
fun loadSystem(vararg hooker: YukiBaseHooker)
```

### Change Records
`v1.0.82` `added`
`v1.1.4` `modified` - Added method to load multiple child Hookers simultaneously.
```
Tokens:
Raw