LSPlant

https://lsposed.org/LSPlant
Admin
LSPlant is an Android ART hook library that provides Java method hook/unhook and inline...
Tokens:7,544
Snippets:83
Trust Score:6.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get Primitive Array Elements

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods to retrieve pointers to primitive array elements.

```cpp
jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
return functions->GetBooleanArrayElements(this,array,isCopy);
}
jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
return functions->GetByteArrayElements(this,array,isCopy);
}
jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
return functions->GetCharArrayElements(this,array,isCopy);
}
jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
return functions->GetShortArrayElements(this,array,isCopy);
}
jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
return functions->GetIntArrayElements(this,array,isCopy);
}
jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
return functions->GetLongArrayElements(this,array,isCopy);
}
jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
return functions->GetFloatArrayElements(this,array,isCopy);
}
jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
return functions->GetDoubleArrayElements(this,array,isCopy);
}
```

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

### Get Primitive Array Regions

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods to copy a region of a primitive array into a buffer.

```cpp
void GetBooleanArrayRegion(jbooleanArray array,
jsize start, jsize len, jboolean *buf) {
functions->GetBooleanArrayRegion(this,array,start,len,buf);
}
void GetByteArrayRegion(jbyteArray array,
jsize start, jsize len, jbyte *buf) {
functions->GetByteArrayRegion(this,array,start,len,buf);
}
void GetCharArrayRegion(jcharArray array,
jsize start, jsize len, jchar *buf) {
functions->GetCharArrayRegion(this,array,start,len,buf);
}
void GetShortArrayRegion(jshortArray array,
jsize start, jsize len, jshort *buf) {
functions->GetShortArrayRegion(this,array,start,len,buf);
}
void GetIntArrayRegion(jintArray array,
jsize start, jsize len, jint *buf) {
functions->GetIntArrayRegion(this,array,start,len,buf);
}
void GetLongArrayRegion(jlongArray array,
jsize start, jsize len, jlong *buf) {
functions->GetLongArrayRegion(this,array,start,len,buf);
}
void GetFloatArrayRegion(jfloatArray array,
jsize start, jsize len, jfloat *buf) {
functions->GetFloatArrayRegion(this,array,start,len,buf);
}
void GetDoubleArrayRegion(jdoubleArray array,
jsize start, jsize len, jdouble *buf) {
functions->GetDoubleArrayRegion(this,array,start,len,buf);
}
```

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

### Access Object Array Elements

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods to get and set elements within a jobjectArray.

```cpp
jobject GetObjectArrayElement(jobjectArray array, jsize index) {
return functions->GetObjectArrayElement(this,array,index);
}
void SetObjectArrayElement(jobjectArray array, jsize index,
jobject val) {
functions->SetObjectArrayElement(this,array,index,val);
}
```

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

### JNI Initialization and Lifecycle Functions

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Prototypes for JNI VM management and library lifecycle hooks.

```c
_JNI_IMPORT_OR_EXPORT_ jint JNICALL
JNI_GetDefaultJavaVMInitArgs(void *args);

_JNI_IMPORT_OR_EXPORT_ jint JNICALL
JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);

_JNI_IMPORT_OR_EXPORT_ jint JNICALL
JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);

/* Defined by native libraries. */
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void *reserved);

JNIEXPORT void JNICALL
JNI_OnUnload(JavaVM *vm, void *reserved);
```

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

### Init

Source: https://lsposed.org/LSPlant/namespacelsplant.html

Initializes LSPlant for hooking by prefetching symbols and hooking necessary functions.

```APIDOC
## bool Init(JNIEnv *env, const InitInfo &info)

### Description
Initialize LSPlant for the proceeding hook. It mainly prefetch needed symbols and hook some functions. The env should not have any restriction for accessing hidden APIs. You can obtain such a JNIEnv in JNI_OnLoad().

### Parameters
- **env** (JNIEnv *) - The JNI environment pointer.
- **info** (const InitInfo &) - Information and configuration needed for initialization.
```

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

### JNI_CreateJavaVM

Source: https://lsposed.org/LSPlant/jni_8h.html

Initializes a new Java Virtual Machine.

```APIDOC
## JNI_CreateJavaVM

### Description
Loads and initializes a Java VM. The current thread becomes the main thread.

### Signature
jint JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args)

### Parameters
- **pvm** (JavaVM **) - Pointer to the location where the resulting JavaVM interface pointer will be placed.
- **penv** (void **) - Pointer to the location where the JNI interface pointer for the main thread will be placed.
- **args** (void *) - Pointer to the VM initialization arguments.
```

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

### lsplant::v2::InitInfo

Source: https://lsposed.org/LSPlant/lsplant_8hpp_source.html

Configuration structure containing necessary components and callbacks for initializing the LSPlant library.

```APIDOC
## struct InitInfo

### Description
Information and configuration that are needed to call Init().

### Fields
- **inline_hooker** (InlineHookFunType) - Required - The inline hooker function.
- **inline_unhooker** (InlineUnhookFunType) - Required - The inline unhooker function.
- **art_symbol_resolver** (ArtSymbolResolver) - Required - The symbol resolver to libart.so.
- **art_symbol_prefix_resolver** (ArtSymbolPrefixResolver) - Required - The symbol prefix resolver to libart.so.
- **generated_class_name** (std::string_view) - Required - The generated class name.
- **generated_source_name** (std::string_view) - Optional - The generated source name.
- **generated_field_name** (std::string_view) - Required - The generated field name.
- **generated_method_name** (std::string_view) - Required - The generated method name.
- **executable_memory_allocator** (MemoryAllocator) - Optional - The memory allocator for executable code.
- **executable_memory_recycler** (MemoryRecycler) - Optional - The memory recycler for executable code.
```

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

### Java VM Configuration Structures

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Structures used for configuring and initializing the Java Virtual Machine.

```cpp
typedef struct JavaVMOption {
char *optionString;
void *extraInfo;
} JavaVMOption;
```

```cpp
typedef struct JavaVMInitArgs {
jint version;

jint nOptions;
JavaVMOption *options;
jboolean ignoreUnrecognized;
} JavaVMInitArgs;
```

```cpp
typedef struct JavaVMAttachArgs {
jint version;

char *name;
jobject group;
} JavaVMAttachArgs;
```

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

### JNI_CreateJavaVM

Source: https://lsposed.org/LSPlant/jni_8h.html

Initializes and creates a new Java Virtual Machine instance.

```APIDOC
## jint JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args)

### Description
Loads and initializes a Java VM. The function returns a pointer to the JavaVM interface and the JNIEnv interface for the current thread.

### Parameters
- **pvm** (JavaVM**) - Pointer to a location where the JavaVM interface pointer will be placed.
- **penv** (void**) - Pointer to a location where the JNIEnv interface pointer for the main thread will be placed.
- **args** (void*) - Pointer to the VM initialization arguments.
```

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

### JNI_GetDefaultJavaVMInitArgs

Source: https://lsposed.org/LSPlant/jni_8h.html

Retrieves the default initialization arguments for the Java Virtual Machine.

```APIDOC
## jint JNI_GetDefaultJavaVMInitArgs(void *args)

### Description
Returns the default configuration settings for the Java VM. This function is typically called before creating a VM instance.

### Parameters
- **args** (void*) - Pointer to a structure where the default VM initialization arguments will be stored.
```

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

### JNI_GetDefaultJavaVMInitArgs

Source: https://lsposed.org/LSPlant/jni_8h.html

Retrieves the default initialization arguments for the Java Virtual Machine.

```APIDOC
## JNI_GetDefaultJavaVMInitArgs

### Signature
jint JNI_GetDefaultJavaVMInitArgs(void *args)

### Description
Returns the default configuration for the Java VM initialization.
```

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

### LSPlant Initialization and Hooking API

Source: https://lsposed.org/LSPlant/lsplant_8hpp_source.html

The core API for initializing the LSPlant framework and managing Java method hooks.

```cpp
#pragma once

#include <jni.h>

#include <cstdint>
#include <functional>
#include <span>
#include <string_view>

namespace lsplant {

inline namespace v2 {
struct InitInfo {
 using InlineHookFunType = std::function<void *(void *target, void *hooker)>;
 using InlineUnhookFunType = std::function<bool(void *func)>;
 using ArtSymbolResolver = std::function<void *(std::string_view symbol_name)>;

 using ArtSymbolPrefixResolver = std::function<void *(std::string_view symbol_prefix)>;

 using MemoryAllocator = std::function<void *(std::span<const uint8_t> data)>;
 using MemoryRecycler = std::function<void(void *memory)>;

 InlineHookFunType inline_hooker;

 InlineUnhookFunType inline_unhooker;

 ArtSymbolResolver art_symbol_resolver;

 ArtSymbolPrefixResolver art_symbol_prefix_resolver;

 std::string_view generated_class_name = "LSPHooker_";

 std::string_view generated_source_name = "LSP";

 std::string_view generated_field_name = "hooker";

 std::string_view generated_method_name = "{target}";

 MemoryAllocator executable_memory_allocator;

 MemoryRecycler executable_memory_recycler;
};

[[nodiscard, maybe_unused, gnu::visibility("default")]] bool Init(JNIEnv *env,
 const InitInfo &info);

[[nodiscard, maybe_unused, gnu::visibility("default")]] jobject Hook(JNIEnv *env,
 jobject target_method,
 jobject hooker_object,
 jobject callback_method);

[[nodiscard, maybe_unused, gnu::visibility("default")]] bool UnHook(JNIEnv *env,
 jobject target_method);

[[nodiscard, maybe_unused, gnu::visibility("default")]] bool IsHooked(JNIEnv *env, jobject method);

[[nodiscard, maybe_unused, gnu::visibility("default")]] bool Deoptimize(JNIEnv *env,
 jobject method);

[[nodiscard, maybe_unused, gnu::visibility("default")]] void *GetNativeFunction(JNIEnv *env,
 jobject method);

[[nodiscard, maybe_unused, gnu::visibility("default")]] bool MakeClassInheritable(JNIEnv *env,
 jclass target);

[[nodiscard, maybe_unused, gnu::visibility("default")]] bool MakeDexFileTrusted(JNIEnv *env,
 jobject cookie);
} // namespace v2
} // namespace lsplant
```

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

### Java VM Management Functions

Source: https://lsposed.org/LSPlant/jni_8h.html

Functions for creating and retrieving Java Virtual Machine instances.

```c
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM  | ( | JavaVM **  | _pvm_ ,   
---|---|---|---  
|  | void **  | _penv_ ,   
|  | void *  | _args_  
| ) | |
```

```c
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs  | ( | JavaVM **  | ,   
---|---|---|---  
|  | jsize | ,   
|  | jsize *  |   
| ) | |
```

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

### JNI Header Guard and Includes

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Standard header guard and necessary system includes for JNI functionality.

```c
#ifndef _JAVASOFT_JNI_H_
#define _JAVASOFT_JNI_H_

#include <stdio.h>
#include <stdarg.h>

/* jni_md.h contains the machine-dependent typedefs for jbyte, jint
 and jlong */

#include "jni_md.h"
```

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

### Create Primitive Arrays

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods to instantiate new primitive arrays of various types.

```cpp
jbooleanArray NewBooleanArray(jsize len) {
return functions->NewBooleanArray(this,len);
}
jbyteArray NewByteArray(jsize len) {
return functions->NewByteArray(this,len);
}
jcharArray NewCharArray(jsize len) {
return functions->NewCharArray(this,len);
}
jshortArray NewShortArray(jsize len) {
return functions->NewShortArray(this,len);
}
jintArray NewIntArray(jsize len) {
return functions->NewIntArray(this,len);
}
jlongArray NewLongArray(jsize len) {
return functions->NewLongArray(this,len);
}
jfloatArray NewFloatArray(jsize len) {
return functions->NewFloatArray(this,len);
}
jdoubleArray NewDoubleArray(jsize len) {
return functions->NewDoubleArray(this,len);
}
```

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

### Include JNI Header Dependencies

Source: https://lsposed.org/LSPlant/jni_8h.html

Standard includes required for JNI functionality.

```c
#include <stdio.h>
#include <stdarg.h>
#include "jni_md.h"
```

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

### CallNonvirtualShortMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual short methods using variable arguments, va_list, or jvalue arrays.

```cpp
jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jshort result;
 va_start(args,methodID);
 result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualShortMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualShortMethodA(this,obj,clazz,
 methodID,args);
 }
```

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

### Include LSPlant Headers

Source: https://lsposed.org/LSPlant/lsplant_8hpp.html

Required headers for utilizing LSPlant functionality in a C++ JNI environment.

```cpp
#include <jni.h>
#include <cstdint>
#include <functional>
#include <span>
#include <string_view>
```

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

### JNI Status and Version Constants

Source: https://lsposed.org/LSPlant/jni_8h.html

Macros representing JNI return codes and version identifiers.

```c
#define JNI_EVERSION (-3) /* JNI version error */
```

```c
#define JNI_FALSE 0
```

```c
#define JNI_OK 0 /* success */
```

```c
#define JNI_TRUE 1
```

```c
#define JNI_VERSION_10 0x000a0000
```

```c
#define JNI_VERSION_1_1 0x00010001
```

```c
#define JNI_VERSION_1_2 0x00010002
```

```c
#define JNI_VERSION_1_4 0x00010004
```

```c
#define JNI_VERSION_1_6 0x00010006
```

```c
#define JNI_VERSION_1_8 0x00010008
```

```c
#define JNI_VERSION_9 0x00090000
```

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

### Include JNI Header

Source: https://lsposed.org/LSPlant/structJNIEnv__.html

Include the jni.h header file to access JNI structures.

```cpp
#include <jni.h>
```

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

### lsplant::v2 Namespace Functions

Source: https://lsposed.org/LSPlant/namespacemembers_func.html

A list of functions available in the lsplant::v2 namespace for managing hooks and runtime modifications.

```APIDOC
## lsplant::v2 Namespace Functions

### Functions
- **Deoptimize()** - Deoptimizes a method.
- **GetNativeFunction()** - Retrieves a native function pointer.
- **Hook()** - Applies a hook to a target method.
- **Init()** - Initializes the LSPlant library.
- **IsHooked()** - Checks if a method is currently hooked.
- **MakeClassInheritable()** - Modifies class inheritance properties.
- **MakeDexFileTrusted()** - Marks a DEX file as trusted.
- **UnHook()** - Removes an existing hook from a method.
```

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

### JNI Weak Reference and Exception Management

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Utilities for managing weak global references and checking for pending exceptions.

```cpp
jweak NewWeakGlobalRef(jobject obj) {
return functions->NewWeakGlobalRef(this,obj);
}
```

```cpp
void DeleteWeakGlobalRef(jweak ref) {
functions->DeleteWeakGlobalRef(this,ref);
}
```

```cpp
jboolean ExceptionCheck() {
return functions->ExceptionCheck(this);
}
```

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

### lsplant::v2 Namespace Members

Source: https://lsposed.org/LSPlant/namespacemembers.html

A list of available functions within the lsplant::v2 namespace for library interaction.

```APIDOC
## Namespace Members: lsplant::v2

### Functions
- **Deoptimize()** - Deoptimizes a method.
- **GetNativeFunction()** - Retrieves a native function pointer.
- **Hook()** - Hooks a target method.
- **Init()** - Initializes the LSPlant library.
- **IsHooked()** - Checks if a method is currently hooked.
- **MakeClassInheritable()** - Modifies class inheritance properties.
- **MakeDexFileTrusted()** - Marks a DEX file as trusted.
- **UnHook()** - Removes an existing hook from a method.
```

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

### JNI Global Functions

Source: https://lsposed.org/LSPlant/globals_func.html

A list of JNI-related global functions available for use within the LSPlant framework.

```APIDOC
## Global Functions

- **JNI_CreateJavaVM()** : Defined in jni.h
- **JNI_GetCreatedJavaVMs()** : Defined in jni.h
- **JNI_GetDefaultJavaVMInitArgs()** : Defined in jni.h
- **JNI_OnLoad()** : Defined in jni.h
- **JNI_OnUnload()** : Defined in jni.h
```

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

### bool lsplant::v2::MakeDexFileTrusted(JNIEnv *env, jobject cookie)

Source: https://lsposed.org/LSPlant/namespacelsplant_1_1v2.html

Makes a DexFile trustable to allow access to hidden APIs, which is necessary when hooking system methods.

```APIDOC
## bool lsplant::v2::MakeDexFileTrusted(JNIEnv *env, jobject cookie)

### Description
Make a DexFile trustable so that it can access hidden APIs. This is useful because we likely need to access hidden APIs when hooking system methods.

### Parameters
- **env** (JNIEnv *) - Required - The Java environment.
- **cookie** (jobject) - Required - The cookie of the DexFile.

### Returns
- **bool** - Indicate whether the operation has succeeded.
```

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

### JNI_OnLoad

Source: https://lsposed.org/LSPlant/jni_8h.html

Callback function invoked when a native library is loaded by the Java VM.

```APIDOC
## jint JNI_OnLoad(JavaVM *vm, void *reserved)

### Description
This function is called by the VM when the native library is loaded. It is used to register native methods or perform library-specific initialization.

### Parameters
- **vm** (JavaVM*) - Pointer to the JavaVM instance.
- **reserved** (void*) - Reserved for future use.
```

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

### Static Short Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for calling static methods that return a short.

```cpp
jshort CallStaticShortMethod(jclass clazz,
jmethodID methodID, ...) {
va_list args;
jshort result;
va_start(args,methodID);
result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
va_end(args);
return result;
}
jshort CallStaticShortMethodV(jclass clazz,
jmethodID methodID, va_list args) {
return functions->CallStaticShortMethodV(this,clazz,methodID,args);
}
jshort CallStaticShortMethodA(jclass clazz,
jmethodID methodID, const jvalue *args) {
return functions->CallStaticShortMethodA(this,clazz,methodID,args);
}
```

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

### JNI_OnLoad

Source: https://lsposed.org/LSPlant/jni_8h.html

Called when the native library is loaded by the Java VM.

```APIDOC
## JNI_OnLoad

### Signature
jint JNI_OnLoad(JavaVM *vm, void *reserved)

### Description
This function is invoked when the native library is loaded. It is typically used to register native methods.
```

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

### JavaVM Structure and C++ Wrapper

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Defines the JavaVM structure and provides a C++ wrapper for invoking JNI functions.

```c
struct JavaVM_ {
 const struct JNIInvokeInterface_ *functions;
#ifdef __cplusplus

 jint DestroyJavaVM() {
 return functions->DestroyJavaVM(this);
 }
 jint AttachCurrentThread(void **penv, void *args) {
 return functions->AttachCurrentThread(this, penv, args);
 }
 jint DetachCurrentThread() {
 return functions->DetachCurrentThread(this);
 }

 jint GetEnv(void **penv, jint version) {
 return functions->GetEnv(this, penv, version);
 }
 jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
 return functions->AttachCurrentThreadAsDaemon(this, penv, args);
 }
#endif
};
```

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

### JNI String and Buffer Operations

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods for accessing string regions and direct byte buffers.

```cpp
void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
functions->GetStringRegion(this,str,start,len,buf);
}
```

```cpp
void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
functions->GetStringUTFRegion(this,str,start,len,buf);
}
```

```cpp
jobject NewDirectByteBuffer(void* address, jlong capacity) {
return functions->NewDirectByteBuffer(this, address, capacity);
}
```

```cpp
void* GetDirectBufferAddress(jobject buf) {
return functions->GetDirectBufferAddress(this, buf);
}
```

```cpp
jlong GetDirectBufferCapacity(jobject buf) {
return functions->GetDirectBufferCapacity(this, buf);
}
```

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

### JNI Short Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking short methods using variadic arguments, va_list, or jvalue arrays.

```cpp
971 jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
972 va_list args;
973 jshort result;
974 va_start(args,methodID);
975 result = functions->CallShortMethodV(this,obj,methodID,args);
976 va_end(args);
977 return result;
978 }
979 jshort CallShortMethodV(jobject obj, jmethodID methodID,
980 va_list args) {
981 return functions->CallShortMethodV(this,obj,methodID,args);
982 }
983 jshort CallShortMethodA(jobject obj, jmethodID methodID,
984 const jvalue * args) {
985 return functions->CallShortMethodA(this,obj,methodID,args);
986 }
```

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

### Include LSPlant header

Source: https://lsposed.org/LSPlant/structlsplant_1_1v2_1_1InitInfo.html

Include the primary header file to access LSPlant structures and functions.

```cpp
#include <lsplant.hpp>
```

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

### String and Array Manipulation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods for creating and accessing Java strings and arrays.

```cpp
1602 jstring NewString(const jchar *unicode, jsize len) {
1603 return functions->NewString(this,unicode,len);
1604 }
1605 jsize GetStringLength(jstring str) {
1606 return functions->GetStringLength(this,str);
1607 }
1608 const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1609 return functions->GetStringChars(this,str,isCopy);
1610 }
1611 void ReleaseStringChars(jstring str, const jchar *chars) {
1612 functions->ReleaseStringChars(this,str,chars);
1613 }
1614
1615 jstring NewStringUTF(const char *utf) {
1616 return functions->NewStringUTF(this,utf);
1617 }
1618 jsize GetStringUTFLength(jstring str) {
1619 return functions->GetStringUTFLength(this,str);
1620 }
1621 const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1622 return functions->GetStringUTFChars(this,str,isCopy);
1623 }
1624 void ReleaseStringUTFChars(jstring str, const char* chars) {
1625 functions->ReleaseStringUTFChars(this,str,chars);
1626 }
1627
1628 jsize GetArrayLength(jarray array) {
1629 return functions->GetArrayLength(this,array);
1630 }
1631
1632 jobjectArray NewObjectArray(jsize len, jclass clazz,
1633 jobject init) {
1634 return functions->NewObjectArray(this,len,clazz,init);
1635 }
```

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

### CallNonvirtualIntMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual int methods using variable arguments, va_list, or jvalue arrays.

```cpp
jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jint result;
 va_start(args,methodID);
 result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualIntMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualIntMethodA(this,obj,clazz,
 methodID,args);
 }
```

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

### JNIEnv C++ Methods

Source: https://lsposed.org/LSPlant/jni_8h_source.html

A collection of methods available on the JNIEnv structure for managing Java objects, classes, and method execution.

```APIDOC
## JNIEnv C++ Methods

### Description
These methods are provided as inlined C++ wrappers for the underlying JNI functions, enabling direct interaction with the Java Virtual Machine.

### Methods
- **FindClass(const char *name)**: Returns a jclass object for the specified class name.
- **Throw(jthrowable obj)**: Throws a Java exception.
- **ThrowNew(jclass clazz, const char *msg)**: Constructs and throws a new exception.
- **ExceptionOccurred()**: Returns the pending exception if one exists.
- **ExceptionClear()**: Clears any pending exception.
- **NewGlobalRef(jobject lobj)**: Creates a new global reference to a Java object.
- **DeleteGlobalRef(jobject gref)**: Deletes a global reference.
- **DeleteLocalRef(jobject obj)**: Deletes a local reference.
- **GetObjectClass(jobject obj)**: Returns the class of the specified object.
- **GetMethodID(jclass clazz, const char *name, const char *sig)**: Returns the method ID for a class method.
```

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

### CallNonvirtualBooleanMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual boolean methods using variable arguments, va_list, or jvalue arrays.

```cpp
jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jboolean result;
 va_start(args,methodID);
 result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
 methodID, args);
 }
```

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

### Static Object Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for calling static methods that return an object.

```cpp
result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
va_end(args);
return result;
}
jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
va_list args) {
return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
}
jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
const jvalue *args) {
return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
}
```

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

### CallNonvirtualByteMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual byte methods using variable arguments, va_list, or jvalue arrays.

```cpp
jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jbyte result;
 va_start(args,methodID);
 result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualByteMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualByteMethodA(this,obj,clazz,
 methodID,args);
 }
```

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

### CallNonvirtualFloatMethod variants

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual float methods using variable arguments, va_list, or jvalue arrays.

```cpp
jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
jmethodID methodID, ...) {
va_list args;
jfloat result;
va_start(args,methodID);
result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
methodID,args);
va_end(args);
return result;
}
```

```cpp
jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
jmethodID methodID,
va_list args) {
return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
methodID,args);
}
```

```cpp
jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
jmethodID methodID,
const jvalue * args) {
return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
methodID,args);
}
```

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

### JNI_GetCreatedJavaVMs

Source: https://lsposed.org/LSPlant/jni_8h.html

Returns all Java virtual machines that have been created.

```APIDOC
## JNI_GetCreatedJavaVMs

### Description
Returns all Java virtual machines that have been created. All created VMs are written into the buffer provided by the caller.

### Signature
jint JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs)

### Parameters
- **vmBuf** (JavaVM **) - Pointer to the buffer where the VM structures will be placed.
- **bufLen** (jsize) - The length of the buffer.
- **nVMs** (jsize *) - Pointer to an integer where the number of created VMs will be placed.
```

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

### Static Method Accessors

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Methods for retrieving static method IDs and invoking static object methods.

```cpp
jmethodID GetStaticMethodID(jclass clazz, const char *name,
const char *sig) {
return functions->GetStaticMethodID(this,clazz,name,sig);
}
```

```cpp
jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
...) {
va_list args;
jobject result;
va_start(args,methodID);
```

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

### Static Char Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for calling static methods that return a char.

```cpp
jchar CallStaticCharMethod(jclass clazz,
jmethodID methodID, ...) {
va_list args;
jchar result;
va_start(args,methodID);
result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
va_end(args);
return result;
}
jchar CallStaticCharMethodV(jclass clazz,
jmethodID methodID, va_list args) {
return functions->CallStaticCharMethodV(this,clazz,methodID,args);
}
jchar CallStaticCharMethodA(jclass clazz,
jmethodID methodID, const jvalue *args) {
return functions->CallStaticCharMethodA(this,clazz,methodID,args);
}
```

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

### CallNonvirtualCharMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual char methods using variable arguments, va_list, or jvalue arrays.

```cpp
jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jchar result;
 va_start(args,methodID);
 result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualCharMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualCharMethodA(this,obj,clazz,
 methodID,args);
 }
```

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

### MakeDexFileTrusted

Source: https://lsposed.org/LSPlant/namespacelsplant.html

Grants a DexFile access to hidden APIs.

```APIDOC
## bool MakeDexFileTrusted(JNIEnv *env, jobject cookie)

### Description
Make a DexFile trustable so that it can access hidden APIs. This is useful because we likely need to access hidden APIs when hooking system methods.
```

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

### Static Byte Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for calling static methods that return a byte.

```cpp
jbyte CallStaticByteMethod(jclass clazz,
jmethodID methodID, ...) {
va_list args;
jbyte result;
va_start(args,methodID);
result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
va_end(args);
return result;
}
jbyte CallStaticByteMethodV(jclass clazz,
jmethodID methodID, va_list args) {
return functions->CallStaticByteMethodV(this,clazz,methodID,args);
}
jbyte CallStaticByteMethodA(jclass clazz,
jmethodID methodID, const jvalue *args) {
return functions->CallStaticByteMethodA(this,clazz,methodID,args);
}
```

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

### lsplant::v2::MakeDexFileTrusted

Source: https://lsposed.org/LSPlant/lsplant_8hpp.html

Grants a DexFile trust to access hidden APIs.

```APIDOC
## bool lsplant::v2::MakeDexFileTrusted(JNIEnv *env, jobject cookie)

### Description
Make a DexFile trustable so that it can access hidden APIs. This is useful because we likely need to access hidden APIs when hooking system methods.
```

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

### Static Int Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for calling static methods that return an int.

```cpp
jint CallStaticIntMethod(jclass clazz,
jmethodID methodID, ...) {
va_list args;
jint result;
va_start(args,methodID);
result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
va_end(args);
return result;
}
jint CallStaticIntMethodV(jclass clazz,
jmethodID methodID, va_list args) {
return functions->CallStaticIntMethodV(this,clazz,methodID,args);
}
jint CallStaticIntMethodA(jclass clazz,
jmethodID methodID, const jvalue *args) {
return functions->CallStaticIntMethodA(this,clazz,methodID,args);
}
```

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

### Hook

Source: https://lsposed.org/LSPlant/namespacelsplant.html

Hooks a Java method using a target method, a context object, and a callback method.

```APIDOC
## jobject Hook(JNIEnv *env, jobject target_method, jobject hooker_object, jobject callback_method)

### Description
Hook a Java method by providing the target_method together with the context object hooker_object and its callback callback_method.
```

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

### JNI Int Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking int methods using variadic arguments, va_list, or jvalue arrays.

```cpp
988 jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
989 va_list args;
990 jint result;
991 va_start(args,methodID);
992 result = functions->CallIntMethodV(this,obj,methodID,args);
993 va_end(args);
994 return result;
995 }
996 jint CallIntMethodV(jobject obj, jmethodID methodID,
997 va_list args) {
998 return functions->CallIntMethodV(this,obj,methodID,args);
999 }
1000 jint CallIntMethodA(jobject obj, jmethodID methodID,
1001 const jvalue * args) {
1002 return functions->CallIntMethodA(this,obj,methodID,args);
1003 }
```

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

### lsplant::v2::Hook

Source: https://lsposed.org/LSPlant/lsplant_8hpp.html

Hooks a target Java method with a provided hooker object and callback method.

```APIDOC
## jobject lsplant::v2::Hook(JNIEnv *env, jobject target_method, jobject hooker_object, jobject callback_method)

### Description
Hook a Java method by providing the target_method together with the context object hooker_object and its callback callback_method.
```

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

### CallNonvirtualVoidMethod variants

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual void methods using variable arguments, va_list, or jvalue arrays.

```cpp
void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
jmethodID methodID, ...) {
va_list args;
va_start(args,methodID);
functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
va_end(args);
}
```

```cpp
void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
jmethodID methodID,
va_list args) {
functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
}
```

```cpp
void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
jmethodID methodID,
const jvalue * args) {
functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
}
```

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

### JNI_GetCreatedJavaVMs

Source: https://lsposed.org/LSPlant/jni_8h.html

Retrieves a list of all Java Virtual Machines that have been created in the current process.

```APIDOC
## jint JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs)

### Description
Returns the number of Java VMs that have been created and fills the provided buffer with their pointers.

### Parameters
- **vmBuf** (JavaVM**) - Buffer to store the pointers to the created JavaVMs.
- **bufLen** (jsize) - The length of the buffer.
- **nVMs** (jsize*) - Pointer to an integer where the total number of created VMs will be stored.
```

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

### Static Float Method Invocation

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for calling static methods that return a float.

```cpp
jfloat CallStaticFloatMethod(jclass clazz,
jmethodID methodID, ...) {
va_list args;
jfloat result;
va_start(args,methodID);
result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
va_end(args);
return result;
}
jfloat CallStaticFloatMethodV(jclass clazz,
jmethodID methodID, va_list args) {
return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
}
jfloat CallStaticFloatMethodA(jclass clazz,
jmethodID methodID, const jvalue *args) {
return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
}
```

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

### C++ JNIEnv Wrapper Methods

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Inlined C++ methods for the JNIEnv_ structure that simplify JNI calls by implicitly passing the JNIEnv pointer.

```cpp
struct JNIEnv_ {
 const struct JNINativeInterface_ *functions;
#ifdef __cplusplus

 jint GetVersion() {
 return functions->GetVersion(this);
 }
 jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
 jsize len) {
 return functions->DefineClass(this, name, loader, buf, len);
 }
 jclass FindClass(const char *name) {
 return functions->FindClass(this, name);
 }
 jmethodID FromReflectedMethod(jobject method) {
 return functions->FromReflectedMethod(this,method);
 }
 jfieldID FromReflectedField(jobject field) {
 return functions->FromReflectedField(this,field);
 }

 jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
 return functions->ToReflectedMethod(this, cls, methodID, isStatic);
 }

 jclass GetSuperclass(jclass sub) {
 return functions->GetSuperclass(this, sub);
 }
 jboolean IsAssignableFrom(jclass sub, jclass sup) {
 return functions->IsAssignableFrom(this, sub, sup);
 }

 jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
 return functions->ToReflectedField(this,cls,fieldID,isStatic);
 }

 jint Throw(jthrowable obj) {
 return functions->Throw(this, obj);
 }
 jint ThrowNew(jclass clazz, const char *msg) {
 return functions->ThrowNew(this, clazz, msg);
 }
 jthrowable ExceptionOccurred() {
 return functions->ExceptionOccurred(this);
 }
 void ExceptionDescribe() {
 functions->ExceptionDescribe(this);
 }
 void ExceptionClear() {
 functions->ExceptionClear(this);
 }
 void FatalError(const char *msg) {
 functions->FatalError(this, msg);
 }

 jint PushLocalFrame(jint capacity) {
 return functions->PushLocalFrame(this,capacity);
 }
 jobject PopLocalFrame(jobject result) {
 return functions->PopLocalFrame(this,result);
 }

 jobject NewGlobalRef(jobject lobj) {
 return functions->NewGlobalRef(this,lobj);
 }
 void DeleteGlobalRef(jobject gref) {
 functions->DeleteGlobalRef(this,gref);
 }
 void DeleteLocalRef(jobject obj) {
 functions->DeleteLocalRef(this, obj);
 }

 jboolean IsSameObject(jobject obj1, jobject obj2) {
 return functions->IsSameObject(this,obj1,obj2);
 }

 jobject NewLocalRef(jobject ref) {
 return functions->NewLocalRef(this,ref);
 }
 jint EnsureLocalCapacity(jint capacity) {
 return functions->EnsureLocalCapacity(this,capacity);
 }

 jobject AllocObject(jclass clazz) {
 return functions->AllocObject(this,clazz);
 }
 jobject NewObject(jclass clazz, jmethodID methodID, ...) {
 va_list args;
 jobject result;
 va_start(args, methodID);
 result = functions->NewObjectV(this,clazz,methodID,args);
 va_end(args);
 return result;
 }
 jobject NewObjectV(jclass clazz, jmethodID methodID,
 va_list args) {
 return functions->NewObjectV(this,clazz,methodID,args);
 }
 jobject NewObjectA(jclass clazz, jmethodID methodID,
 const jvalue *args) {
 return functions->NewObjectA(this,clazz,methodID,args);
 }

 jclass GetObjectClass(jobject obj) {
 return functions->GetObjectClass(this,obj);
 }
 jboolean IsInstanceOf(jobject obj, jclass clazz) {
 return functions->IsInstanceOf(this,obj,clazz);
 }

 jmethodID GetMethodID(jclass clazz, const char *name,
 const char *sig) {
 return functions->GetMethodID(this,clazz,name,sig);
 }

 jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
 va_list args;
 jobject result;
 va_start(args,methodID);
 result = functions->CallObjectMethodV(this,obj,methodID,args);
 va_end(args);
 return result;
 }
 jobject CallObjectMethodV(jobject obj, jmethodID methodID,
 va_list args) {
 return functions->CallObjectMethodV(this,obj,methodID,args);
 }
 jobject CallObjectMethodA(jobject obj, jmethodID methodID,
```

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

### Static Method Invocation Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking static methods on Java classes using various argument passing conventions.

```cpp
1505 result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1506 va_end(args);
1507 return result;
1508 }
1509 jdouble CallStaticDoubleMethodV(jclass clazz,
1510 jmethodID methodID, va_list args) {
1511 return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1512 }
1513 jdouble CallStaticDoubleMethodA(jclass clazz,
1514 jmethodID methodID, const jvalue *args) {
1515 return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1516 }
1517
1518 void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1519 va_list args;
1520 va_start(args,methodID);
1521 functions->CallStaticVoidMethodV(this,cls,methodID,args);
1522 va_end(args);
1523 }
1524 void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1525 va_list args) {
1526 functions->CallStaticVoidMethodV(this,cls,methodID,args);
1527 }
1528 void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1529 const jvalue * args) {
1530 functions->CallStaticVoidMethodA(this,cls,methodID,args);
1531 }
```

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

### JNI Type Definitions

Source: https://lsposed.org/LSPlant/jni_8h.html

Standard JNI type aliases for primitive and object types.

```c
typedef enum _jobjectType jobjectRefType
```

```c
typedef short jshort
```

```c
typedef jarray jshortArray
```

```c
typedef jint jsize
```

```c
typedef jobject jstring
```

```c
typedef jobject jthrowable
```

```c
typedef union jvalue jvalue
```

```c
typedef jobject jweak
```

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

### JNI Primitive Type Definitions

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Definitions for basic JNI types used across the interface.

```c
#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H

typedef unsigned char jboolean;
typedef unsigned short jchar;
typedef short jshort;
typedef float jfloat;
typedef double jdouble;

typedef jint jsize;
```

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

### CallNonvirtualObjectMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual object methods using variable arguments, va_list, or jvalue arrays.

```cpp
jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jobject result;
 va_start(args,methodID);
 result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
 methodID,args);
 }
```

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

### CallNonvirtualLongMethod Wrappers

Source: https://lsposed.org/LSPlant/jni_8h_source.html

Wrappers for invoking nonvirtual long methods using variable arguments, va_list, or jvalue arrays.

```cpp
jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
 jmethodID methodID, ...) {
 va_list args;
 jlong result;
 va_start(args,methodID);
 result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
 methodID,args);
 va_end(args);
 return result;
 }
```

```cpp
jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
 jmethodID methodID, va_list args) {
 return functions->CallNonvirtualLongMethodV(this,obj,clazz,
 methodID,args);
 }
```

```cpp
jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
 jmethodID methodID, const jvalue * args) {
 return functions->CallNonvirtualLongMethodA(this,obj,clazz,
 methodID,args);
 }
```
Tokens:
Raw