KavaRef

https://highcapable.github.io/KavaRef/en
Admin
KavaRef modernizes Java Reflection with a powerful, elegant, and fully compatible API built with...
Tokens:37,087
Snippets:289
Trust Score:8.3
Update:6 days ago
Show doc for...
Tokens:
Raw
### Use firstMethod to get first matching method

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Simplifies the previous example by using firstMethod to directly obtain the first matching MethodResolver, then sets the instance and invokes the method.

```kotlin
Test::class
    .resolve()
    // Use firstMethod directly to get the first matching
    // MethodResolver instance.
    .firstMethod {
        name = "doTask"
        parameters(String::class)
    }
    .of(test)
    .invoke("task_name")
```

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

### YukiReflection field access example

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Shows how to get a static field value in YukiReflection, which may have semantic conflicts with KavaRef.

```kotlin
MyClass::class.java
    .field { name = "content" } // Return FieldFinder.Result
    .get() // Cannot be omitted, return FieldFinder.Result.Instance
    .string() // value
```

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

### Java class used in migration examples

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Defines MyClass with a private method myMethod that prints a greeting. Used as the target class for reflection examples.

```java
public class MyClass {

    private void myMethod(String content) {
        System.out.println("Hello " + content + "!");
    }
}
```

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

### KavaRef: Complete example with optional of(null)

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Complete KavaRef example showing the optional `of(null)` call for static instances. The comment explains that `of(null)` can be omitted because the call is a static instance.

```kotlin
// Since the call is a static instance, "of(null)" can be omitted.
MyClass::class.resolve()
    .firstField { name = "content" } // It's already a call chain object FieldResolver<MyClass>
    .of(null) // Can be omitted and return to the call chain object FieldResolver<MyClass>
    .get<String>() // value
```

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

### BaseTest.java example class

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

A Java class used as a base for KavaRef examples. Contains a public constructor and a private method doBaseTask.

```java
package com.demo;

public class BaseTest {

    public BaseTest() {
        // ...
    }

    private void doBaseTask(String taskName) {
        // ...
    }
}

```

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

### KavaRef exception content with runtime condition markers

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

The printed exception content for the previous example. It shows the table with [!] and [-] markers and the stack trace for the throwing condition.

```text
No method found matching the condition for the current class.
+------------------------------------------------------+
| class com.demo                                       |
+----------------------------+-------------------------+
| returnTypeCondition        | [!] (Runtime Condition) |
| genericReturnTypeCondition | [-] (Runtime Condition) |
+----------------------------+-------------------------+
Suggestion: ...
[!] Exceptions thrown by runtime conditions:
[returnTypeCondition]
- public void com.demo.doTask(java.lang.String)
java.lang.NullPointerException: ...
    at ...
```

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

### Test.java example class extending BaseTest

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

A Java class extending BaseTest, demonstrating private fields and methods that KavaRef can resolve.

```java
package com.demo;

public class Test extends BaseTest {

    private Test() {
        // ...
    }

    private static TAG = "Test";

    private boolean isTaskRunning = false;

    private void doTask(String taskName) {
        // ...
    }

    private void release(String taskName, Function<boolean, String> task, boolean isFinish) {
        // ...
    }

    private void stop() {
        // ...
    }

    private String getName() {
        // ...
    }
}

```

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

### KavaRef: Get field value with get<T>()

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Shows how to resolve a class and get a field value using KavaRef's `get<T>()`. This is the direct way to obtain the value, unlike YukiReflection's `get(...)` which returns a `FieldFinder.Result.Instance` object.

```kotlin
MyClass::class.resolve()
    .firstField { name = "content" }  // Return FieldResolver<MyClass>
    .get<String>() // value
```

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

### XposedBridge Handler Usage Example

Source: https://highcapable.github.io/KavaRef/en/config/resolver-handlers.html

Shows how to use XposedOriginalMethodHandler to invoke the original method on a resolved method.

```kotlin
// Suppose this is an instance of this Class.
val test: Test
// Invoke the original method.
Test::class.resolve()
    .firstMethod {
        name = "doTask"
        parameters(String::class)
    }.of(test)
    .withHandler(XposedOriginalMethodHandler())
    .invoke("task_name")
```

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

### KavaRef invoke example

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Shows how to use KavaRef to resolve a class, find a method by name and parameters, and invoke it on an instance. The `of(instance)` enforces type safety, and `invoke` replaces the old `call` method.

```kotlin
// Assume that's your MyClass instance.
val myClass: MyClass
// Using KavaRef to call and execute.
MyClass::class.resolve()
    .firstMethod {
        name = "myMethod"
        parameters(String::class)
    }
    // Only instances of type MyClass can be passed in.
    .of(myClass)
    .invoke("Hello, KavaRef!")
```

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

### libxposed Handler Usage Example

Source: https://highcapable.github.io/KavaRef/en/config/resolver-handlers.html

Shows how to use LibXposedMethodHandler and LibXposedConstructorHandler to invoke methods and constructors, including special invocation and subclass creation. Note that subclass instances do not call the subclass constructor.

```kotlin
// Suppose this is your XposedModule.
val module: XposedModule
// Suppose this is an instance of this Class.
val test: Test
// Get the method.
val doTask = Test::class.resolve()
    .firstMethod {
        name = "doTask"
        parameters(String::class)
    }.of(test)
// Invoke the original method.
doTask.withHandler(LibXposedMethodHandler(module))
    .invoke("task_name")
// Invoke the original method non-virtually, equivalent to super.doTask("task_name").
doTask.withHandler(LibXposedMethodHandler(module, special = true))
    .invoke("task_name")
// Get the constructor.
val constructor = Test::class.resolve()
    .firstConstructor { parameters(String::class) }
// Create an instance with the original constructor.
val newTest = constructor.withHandler(LibXposedConstructorHandler(module))
    .create("task_name")
// Create a SubTest instance, but only initialize it with the original constructor of Test.
val subTest = constructor.withHandler(LibXposedConstructorHandler(module, subclass = SubTest::class.java))
    .create("task_name")
```

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

### Java class with private method for KavaRef example

Source: https://highcapable.github.io/KavaRef/en

A simple Java class with a private method 'sayHello' that prints a greeting. This is the target class used in the KavaRef reflection example.

```java
public class World {

    private void sayHello(String content) {
        System.out.println("Hello " + content + "!");
    }
}
```

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

### KavaRef debug log output for missing method

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

KavaRef prints complete exception content for debugging. When using optional(), the exception is printed as a WARN level log. This is the example output.

```text
No method found matching the condition for the current class.
+------------------------------------------------+
| class com.demo                                 |
+------------+-----------------------------------+
| name       | doNonExistentMethod               |
| parameters | [class java.lang.String, boolean] |
+------------+-----------------------------------+
```

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

### Using PineOriginalMethodHandler to invoke original method

Source: https://highcapable.github.io/KavaRef/en/config/resolver-handlers.html

Example showing how to resolve a method named doTask with a String parameter and invoke it with PineOriginalMethodHandler. The comment indicates test is an instance of the class.

```kotlin
// Suppose this is an instance of this Class.
val test: Test
// Invoke the original method.
Test::class.resolve()
    .firstMethod {
        name = "doTask"
        parameters(String::class)
    }.of(test)
    .withHandler(PineOriginalMethodHandler())
    .invoke("task_name")
```

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

### Set SLF4J Logger in Normal Project

Source: https://highcapable.github.io/KavaRef/en/config/runtime-loggers.html

Sets the SLF4J logger for KavaRef when the application starts in a normal project.

```kotlin
fun main(args: Array<String>) {
    KavaRef.setLogger(Slf4jLogger())
    // Your application logic.
}
```

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

### Control lint rules via Gradle (disable and error)

Source: https://highcapable.github.io/KavaRef/en/config/lint-rules.html

Configure lint rules directly in the Gradle build file. The example disables ReplaceWithKavaRefExtension and sets UnsupportedExecutableCondition to error.

```kotlin
android {
    lint {
        disable += "ReplaceWithKavaRefExtension"
        error += "UnsupportedExecutableCondition"
    }
}
```

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

### KavaRef optional method invocation example

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Shows how to avoid exceptions when a method may not exist. The `optional()` declaration prevents exceptions, and `firstMethodOrNull` returns null instead of throwing Kotlin's `NoSuchElementException`.

```kotlin
// Assume that's your MyClass instance.
val myClass: MyClass
// Using KavaRef to call and execute.
MyClass::class.resolve()
    .optional() // Declare as optional, do not throw exceptions.
    // Use firstMethodOrNull instead of firstMethod,
    // because the NoSuchElementException of Kotlin itself will be thrown.
    .firstMethodOrNull {
        name = "doNonExistentMethod" // Assume that this method does not exist.
        parameters(String::class)
    }?.of(myClass)?.invoke("Hello, KavaRef!")
```

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

### Kotlin KavaRef reflection invocation example

Source: https://highcapable.github.io/KavaRef/en

Kotlin code using KavaRef to resolve the World class, find the 'sayHello' method by name and parameter type, and invoke it on an instance with the argument 'KavaRef'.

```kotlin
val myWorld = World()

World::class.resolve().firstMethod {
    name = "sayHello"
    parameters(String::class)
}.of(myWorld).invoke("KavaRef")
```

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

### Disable or adjust rules via lint.xml

Source: https://highcapable.github.io/KavaRef/en/config/lint-rules.html

Create a lint.xml file in the project root to disable a specific rule or change its severity. The example disables ReplaceWithKavaRefExtension and sets UnsupportedExecutableCondition to error. Common severity values are ignore, warning, error, and fatal.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<lint>
    <issue id="ReplaceWithKavaRefExtension" severity="ignore" />
    <issue id="UnsupportedExecutableCondition" severity="error" />
</lint>
```

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

### Set SLF4J Logger in Spring Boot Project

Source: https://highcapable.github.io/KavaRef/en/config/runtime-loggers.html

Sets the SLF4J logger for KavaRef before starting a Spring Boot application. Spring Boot includes SLF4J and Logback via spring-boot-starter-logging, so no additional dependencies are needed.

```kotlin
fun main(args: Array<String>) {
    KavaRef.setLogger(Slf4jLogger())
    runApplication<MyApplication>(*args)
}
```

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

### Using MethodHandleSpecialHandler to invoke method non-virtually

Source: https://highcapable.github.io/KavaRef/en/config/resolver-handlers.html

Example showing how to resolve a method named doTask with a String parameter and invoke it with MethodHandleSpecialHandler. The comment indicates test is an instance of a subclass that overrides doTask, and the invocation is equivalent to super.doTask("task_name").

```kotlin
// Suppose this is an instance of a subclass of Test that overrides the doTask method.
val test: Test
// Invoke the method in Test non-virtually, equivalent to super.doTask("task_name").
Test::class.resolve()
    .firstMethod {
        name = "doTask"
        parameters(String::class)
    }.of(test)
    .withHandler(MethodHandleSpecialHandler())
    .invoke("task_name")
```

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

### Create instance with firstConstructor and emptyParameters

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Creates a new Test instance by resolving the class, using firstConstructor with emptyParameters() to match the zero-parameter constructor, then calling create(). Note that emptyParameters() is required; parameters() adds no condition.

```kotlin
val test = Test::class.resolve()
    .firstConstructor {
        // For the zero parameter constructor,
        // the following condition can be used to filter.
        // It is equivalent to parameterCount = 0.
        // Do not write it as parameters(), it adds no condition without parameter types.
        emptyParameters()
    }.create() // Create a new Test instance.
```

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

### Configure KavaRef BOM with Traditional Method

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-bom.html

Adds the KavaRef BOM and its modules using direct string coordinates in build.gradle.kts. Replace <version> with the version shown at the top of the document.

```kotlin
implementation(platform("com.highcapable.kavaref:kavaref-bom:<version>"))

implementation("com.highcapable.kavaref:kavaref-core")

// Choose the appropriate base module according to your project type (choose one).
implementation("com.highcapable.kavaref:kavaref-android")
implementation("com.highcapable.kavaref:kavaref-jvm")

implementation("com.highcapable.kavaref:kavaref-extension")
```

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

### Configure KavaRef BOM with Version Catalog

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-bom.html

Adds the KavaRef BOM and its modules via a version catalog. The TOML block defines the BOM version and library aliases; the Kotlin block adds the platform and module dependencies. Replace <version> with the version shown at the top of the document.

```toml
[versions]
kavaref-bom = "<version>"

[libraries]
kavaref-bom = { module = "com.highcapable.kavaref:kavaref-bom", version.ref = "kavaref-bom" }
kavaref-core = { module = "com.highcapable.kavaref:kavaref-core" }
kavaref-android = { module = "com.highcapable.kavaref:kavaref-android" }
kavaref-jvm = { module = "com.highcapable.kavaref:kavaref-jvm" }
kavaref-extension = { module = "com.highcapable.kavaref:kavaref-extension" }
```

```kotlin
implementation(platform(libs.kavaref.bom))

implementation(libs.kavaref.core)

// Choose the appropriate base module according to your project type (choose one).
implementation(libs.kavaref.android)
implementation(libs.kavaref.jvm)

implementation(libs.kavaref.extension)
```

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

### Target Java class for reflection example

Source: https://highcapable.github.io/KavaRef/en/about/future.html

Java class that serves as the target for reflection in the automatic generation example.

```java
package com.example.test;

public class MyClass {
    
    private String myField = "test";

    public MyClass() {
        //...
    }

    private String myMethod1(String var1, int var2) {
        //...
    }

    private void myMethod2() {
        //...
    }

    private void myMethod3(String var1) {
        //...
    }
}
```

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

### Enable DEBUG Logs with slf4j-simple System Property

Source: https://highcapable.github.io/KavaRef/en/config/runtime-loggers.html

System property to enable DEBUG level logs for the 'KavaRef' logger when using slf4j-simple.

```bash
-Dorg.slf4j.simpleLogger.log.KavaRef=debug
```

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

### KavaRef reflection usage

Source: https://highcapable.github.io/KavaRef/en/config/migration.html

Shows how to use KavaRef to resolve and invoke a method on an instance, using firstMethod and asResolver.

```kotlin
// Assume that's your MyClass instance.
val myClass: MyClass
// Call and execute using KavaRef.
MyClass::class.resolve().firstMethod {
    name = "myMethod"
    parameters(String::class)
}.of(myClass).invoke("Hello, KavaRef!")
// Direct reference to instance.
myClass.asResolver().firstMethod {
    name = "myMethod"
    parameters(String::class)
}.invoke("Hello, KavaRef!")
```

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

### Get field value with firstField

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Uses asResolver() on an instance to get the isTaskRunning field via firstField with name and type conditions, then retrieves its value as Boolean.

```kotlin
// Suppose this is an instance of this Class.
val test: Test
// Call and execute with KavaRef.
val isTaskRunning = test.asResolver()
    .firstField {
        name = "isTaskRunning"
        type = Boolean::class
    }.get<Boolean>()
```

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

### Add kavaref-jvm dependency to version catalog (gradle/libs.versions.toml)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-jvm.html

Add the kavaref-jvm version and library entries to the version catalog file. Replace <version> with the version displayed at the top of the document.

```toml
[versions]
kavaref-jvm = "<version>"

[libraries]
kavaref-jvm = { module = "com.highcapable.kavaref:kavaref-jvm", version.ref = "kavaref-jvm" }

```

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

### TypeRef.type and TypeRef.rawType

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Properties of TypeRef to get the stored type and its raw type.

```APIDOC
## TypeRef.type and TypeRef.rawType

### Description
Properties of `TypeRef` to get the stored type and its raw type.

### Method
Properties on `TypeRef`

### Properties
- **type** (`Type`) - The stored type, e.g., `List<? extends String>`.
- **rawType** (`Class<*>`) - The raw type, e.g., `List`. Supports generic arrays and preserves array dimensions.

### Example
```kotlin
val listStringType = typeRef<List<String>>()
val type = listStringType.type
val rawType = listStringType.rawType
```
```

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

### genericSuperclassTypeArguments on Class

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Gets the generic parameter array of the superclass. Returns an empty array if acquisition fails or cannot be retrieved.

```kotlin
val myClass: Class<*>
// Get the generic parameter array of myClass superclass.
// If the acquisition fails or cannot be retrieved, the empty array will be returned.
val arguments = myClass.genericSuperclassTypeArguments()
```

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

### createInstance

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Creates an instance of a class using the constructor that best matches the given arguments, following Java's overload resolution rules. Results are cached for performance and thread safety.

```APIDOC
## createInstance

### Description
Creates an instance of a class using the constructor that best matches the given arguments, following Java's overload resolution rules. Results are cached for performance and thread safety.

### Method
Kotlin extension function

### Signature
`fun KClass<T>.createInstance(vararg args: Any?): T`

### Parameters
- `args` (vararg Any?) - The arguments to pass to the constructor. If a parameter is `null`, it is treated as a vague condition, which may reduce matching accuracy. All parameters cannot be `null`.

### Behavior
- If multiple constructors can accept the parameters, the one that matches without unboxing is preferred, then the one with the most specific parameter types.
- If no single constructor is most specific (e.g., due to `null` parameters making multiple constructors indistinguishable), an exception is thrown.
- Results are cached after first successful match; the cache is thread-safe and does not prevent the `Class` and its `ClassLoader` from being collected.

### Example
```kotlin
// Assume that MyClass has both MyClass(Object) and MyClass(String) constructors.
// MyClass(String) will be used here.
val myClass = MyClass::class.createInstance("Hello")
```

### Exceptions
- Throws an exception if all parameters are `null` (completely vague conditions).
- Throws an exception if there is no single most specific constructor.
```

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

### toClass on GenericArrayType

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Converts a GenericArrayType to a Class, preserving array dimensions. Example shows List<String>[] becomes java.util.List[].

```kotlin
// Assume this is the Type of List<String>[].
val genericArrayType: GenericArrayType
// This will be java.util.List[].
val arrayClass = genericArrayType.toClass()
```

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

### createInstance

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Creates a new instance of a Class by passing constructor parameters. Filters public constructors by default; can be set to use non-public constructors.

```APIDOC
## createInstance

### Description
Creates a new instance of a `Class` by passing constructor parameters. Filters public constructors by default; can be set to use non-public constructors.

### Method
Extension function on `KClass`

### Parameters
- **vararg args** (`Any?`) - Required - Constructor arguments.
- **isPublic** (`Boolean`) - Optional - Whether to only use public constructors. Default is `true`. Set to `false` to allow non-public constructors.

### Request Example
```kotlin
val myClass = MyClass::class.createInstance("Hello", 123)
val myClassOrNull = MyClass::class.createInstanceOrNull("Hello", 123)
val myClassWithPrivateConstructor = MyClass::class.createInstance("Private!", isPublic = false)
```

### Response
Returns a new instance of the class (or `null` for OrNull variant).
```

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

### TypeRef rawType for generic arrays

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

rawType supports generic arrays and preserves array dimensions. Examples show List<String>[] and List<String>[][].

```kotlin
// This will be java.util.List[].
val arrayRawType = typeRef<Array<List<String>>>().rawType
// Multidimensional arrays work too, this will be java.util.List[][].
val nestedArrayRawType = typeRef<Array<Array<List<String>>>>().rawType
```

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

### Add kavaref-android dependency via Version Catalog (libs.versions.toml)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-android.html

Adds the kavaref-android version and library entries to the project's gradle/libs.versions.toml file. Replace <version> with the version displayed at the top of the document.

```toml
[versions]
kavaref-android = "<version>"

[libraries]
kavaref-android = { module = "com.highcapable.kavaref:kavaref-android", version.ref = "kavaref-android" }

```

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

### Box.java generic class example

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

A generic Java class with a public method print, used to illustrate KavaRef's handling of generic types.

```java
public class Box<T> {

    public void print(T item, String str) {
        // ...
    }
}

```

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

### TypeRef with reified generics for Gson

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Implements an extension method using reified generics to pass Type to Gson. Usage example serializes a list to JSON.

```kotlin
val gson = Gson()

inline fun <reified T> T.toJson(): String = gson.toJson(this, typeRef<T>().type)

// Usage
val json = listOf("KavaRef", "is", "awesome").toJson()
```

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

### Complete manual reflection with MemberCondition.Configuration

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Manually implements the entire reflection process by creating a MemberCondition.Configuration and building resolvers. Allows fine-grained control over superclass filtering and optional conditions.

```kotlin
// Suppose this is an example of this Class.
val test: Test
// Create MethodCondition manually.
val condition = MethodCondition<Test>()
condition.name = "doTask"
condition.parameters(String::class)
// Create MemberCondition.Configuration manually.
val configuration = Test::class.java.createConfiguration(
    memberInstance = test, // Setting up instance.
    processorResolver = null, // Use the default resolver, refer to the "Custom Resolver" below.
    // Whether to filter in superclass, applies to all conditions using this configuration.
    // NO means not to filter, NORMAL is the same as superclass(),
    // INCLUDE_INTERFACES is the same as superclass(interfaces = true).
    superclass = MemberCondition.Configuration.Superclass.NO,
    optional = MemberCondition.Configuration.Optional.NO // Configure optional conditions.
)
// Create and start filtering.
val resolvers = condition.build(configuration)
// Get the first result.
val resolver = resolvers.first()
// Execute the method.
resolver.invoke("task_name")
```

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

### Check only specific lint rules via Gradle (checkOnly)

Source: https://highcapable.github.io/KavaRef/en/config/lint-rules.html

Use checkOnly in the Gradle lint configuration to check only a subset of rules. The example checks only ReplaceWithKavaRefExtension and UnsupportedExecutableCondition.

```kotlin
android {
    lint {
        checkOnly += setOf(
            "ReplaceWithKavaRefExtension",
            "UnsupportedExecutableCondition"
        )
    }
}
```

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

### KavaRef optional() with firstMethodOrNull

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

When using optional(), use methods with the OrNull suffix to get a single result safely. Without optional(), these methods still throw exceptions when there is no result.

```kotlin
Test::class.resolve()
    // Set optional conditions.
    .optional()
    .firstMethodOrNull {
        name = "doNonExistentMethod"
    } // Return MethodResolver or null.
```

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

### libxposed Method and Constructor Handler Classes

Source: https://highcapable.github.io/KavaRef/en/config/resolver-handlers.html

Defines MethodResolver.Handler and ConstructorResolver.Handler implementations using XposedInterface.getInvoker. Supports type, special invocation, and subclass creation. Bypasses access checks.

```kotlin
class LibXposedMethodHandler(
    private val xposed: XposedInterface,
    private val type: XposedInterface.Invoker.Type = XposedInterface.Invoker.Type.ORIGIN,
    private val special: Boolean = false
) : MethodResolver.Handler() {

    // The invoker of libxposed bypasses access checks, no need to make the member accessible.
    override fun requireAccessible(member: Method) = Unit

    override fun invoke(method: Method, instance: Any?, args: Array<out Any?>): Any? {
        val invoker = xposed.getInvoker(method).setType(type)

        return if (special)
            invoker.invokeSpecial(
                requireNotNull(instance) {
                    "An instance is required for special invocation."
                }, *args
            )
        else invoker.invoke(instance, *args)
    }
}

class LibXposedConstructorHandler(
    private val xposed: XposedInterface,
    private val type: XposedInterface.Invoker.Type = XposedInterface.Invoker.Type.ORIGIN,
    private val subclass: Class<*>? = null
) : ConstructorResolver.Handler() {

    // The invoker of libxposed bypasses access checks, no need to make the member accessible.
    override fun requireAccessible(member: Constructor<*>) = Unit

    override fun <T> newInstance(constructor: Constructor<T>, args: Array<out Any?>): T {
        val invoker = xposed.getInvoker(constructor).setType(type)

        @Suppress("UNCHECKED_CAST")
        return if (subclass != null)
            invoker.newInstanceSpecial(subclass, *args) as T
        else invoker.newInstance(*args)
    }
}
```

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

### Filter method parameter with string type

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Use string types to pass full class names in conditions like parameters. The example filters a method with a String parameter.

```kotlin
// Suppose this is an example of this Class.
val test: Test
// Call and execute with KavaRef.
Test::class.resolve()
    .firstMethod {
        name = "doTask"
        // Pass the full class name using string type.
        parameters("java.lang.String")
    }.of(test).invoke("task_name")
```

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

### Configure repositories in build.gradle.kts

Source: https://highcapable.github.io/KavaRef/en/guide/quick-start.html

Adds Maven Central and the optional HighCapable public repository to your project's build.gradle.kts. The public repository is a backup when Sonatype-OSS fails to publish dependencies.

```kotlin
repositories {
    google()
    mavenCentral()
    // (Optional) You can add this URL to use our public repository
    // When Sonatype-OSS fails and cannot publish dependencies, this repository is added as a backup
    // For details, please visit: https://github.com/HighCapable/maven-repository
    maven("https://raw.githubusercontent.com/HighCapable/maven-repository/main/repository/releases")
}
```

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

### Current reflective calls using KavaRef API

Source: https://highcapable.github.io/KavaRef/en/about/future.html

Shows how to reflectively call the target class using the current KavaRef API.

```kotlin
MyClass().resolve().apply {
    // Call myField.
    val value = firstField { name = "myField" }.get<String>()
    // Call myMethod1.
    val methodValue = firstMethod { name = "myMethod1" }.invoke<String>("test", 0)
    // Call myMethod2.
    firstMethod { name = "myMethod2" }.invoke()
    // Call myMethod3.
    firstMethod { name = "myMethod3" }.invoke("test")
}
```

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

### Add kavaref-core dependency in gradle/libs.versions.toml

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Defines the kavaref-core version and library entry in the version catalog. Replace <version> with the version displayed at the top of the document.

```toml
[versions]
kavaref-core = "<version>"

[libraries]
kavaref-core = { module = "com.highcapable.kavaref:kavaref-core", version.ref = "kavaref-core" }

```

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

### KavaRef method resolution throwing NoSuchMethodException

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

By default, KavaRef throws an exception when a member is not found during a reflection call. This example shows a method lookup for a non-existent method, which will throw NoSuchMethodException.

```kotlin
Test::class.resolve()
    .method {
        name = "doNonExistentMethod"
    } // NoSuchMethodException will be thrown here.
```

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

### Create instance with overload resolution using createInstance

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

KavaRef's createInstance follows Java overload rules, preferring constructors that match without unboxing and then the most specific parameter types. The result is cached after the first successful match, and the cache is thread-safe and does not prevent garbage collection of the Class or its ClassLoader. Passing null parameters makes matching vague and may reduce accuracy; all-null parameters or ambiguous matches throw an exception.

```kotlin
// Assume that MyClass has both MyClass(Object) and MyClass(String) constructors.
// MyClass(String) will be used here.
val myClass = MyClass::class.createInstance("Hello")
```

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

### Configure kavaref-jvm dependency in build.gradle.kts using traditional method

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-jvm.html

Add the kavaref-jvm dependency directly with the module coordinates. Replace <version> with the version displayed at the top of the document.

```kotlin
implementation("com.highcapable.kavaref:kavaref-jvm:<version>")

```

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

### Filter static field with modifiers(Modifiers.STATIC)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Use modifiers(Modifiers.STATIC) or modifiers { it.contains(Modifiers.STATIC) } to filter fields with static descriptors. The example retrieves the content of a static variable TAG.

```kotlin
val tag = Test::class.resolve()
    .firstField {
        name = "TAG"
        type = String::class
        // Create descriptor filtering.
        modifiers(Modifiers.STATIC)
        // Or.
        modifiers {
            it.contains(Modifiers.STATIC)
        }
    }.get<String>() // Get field content.
```

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

### Configure kavaref-android dependency in build.gradle.kts (Traditional Method)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-android.html

Adds the kavaref-android dependency using the traditional string notation. Replace <version> with the version displayed at the top of the document.

```kotlin
implementation("com.highcapable.kavaref:kavaref-android:<version>")

```

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

### Use custom resolver per reflection with processor()

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Set a custom resolver during a specific reflection process using a chain call. The example shows resolving a method and invoking it with a custom resolver.

```kotlin
// Create resolver.
val myResolver = MyMemberProcessorResolver()
// Suppose this is an instance of this Class.
val test: Test
// Call and execute using KavaRef.
Test::class.resolve()
    // Set custom resolver.
    .processor(myResolver)
    .firstMethod {
        name = "doTask"
        parameters(String::class)
    }.of(test).invoke("task_name")
```

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

### Configure kavaref-extension dependency in build.gradle.kts (version catalog)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-extension.html

Adds the kavaref-extension dependency using the version catalog reference. This is the recommended method after defining the library in libs.versions.toml.

```kotlin
implementation(libs.kavaref.extension)

```

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

### Resolve and invoke method with MethodCondition

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Reflects the doTask method of Test using Test::class.resolve(), builds a MethodCondition with name and parameters, gets the first MethodResolver, sets the instance with of(test), and invokes with a parameter.

```kotlin
// Suppose this is an instance of this Class.
val test: Test
// Reflect it by instantiating Class.
// In KavaRef you don't need to convert it to `java.lang.Class`,
// it will automatically call KClass.java.
Test::class
    // Create KavaRef reflections.
    .resolve()
    // Create method condition.
    .method {
        // Set method name.
        name = "doTask"
        // Set method parameter type.
        parameters(String::class)
    }
    // After the condition is executed, the matching List<MethodResolver>
    // instance will be returned.
    // Here we get the first filtering result.
    .first()
    // Set an instance of Test on MethodResolver.
    .of(test)
    // Call the method and pass in parameters.
    .invoke("task_name")
```

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

### Add kavaref-core dependency in build.gradle.kts (version catalog)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Adds the kavaref-core dependency using the version catalog reference. Requires the version catalog entry defined in gradle/libs.versions.toml.

```kotlin
implementation(libs.kavaref.core)

```

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

### Add kavaref-core dependency in build.gradle.kts (traditional method)

Source: https://highcapable.github.io/KavaRef/en/library/kavaref-core.html

Adds the kavaref-core dependency using the traditional string notation. Replace <version> with the version displayed at the top of the document.

```kotlin
implementation("com.highcapable.kavaref:kavaref-core:<version>")

```
Tokens:
Raw