NDK 入门（四）—— 静态缓存与 Native 异常

tmacfrank2024-05-02 15:19

NDK 入门系列主要介绍 JNI 的相关内容，目录如下：

NDK 入门（一）------ JNI 初探
NDK 入门（二）------ 调音小项目
NDK 入门（三）------ JNI 注册与 JNI 线程
NDK 入门（四）------ 静态缓存与 Native 异常

1、静态缓存

我们后续会接触到的 OpenCV、WebRTC 都大量使用了全局静态缓存，这里我们先做一个了解。

1.1 局部静态缓存的弊端

cpp 复制代码 
extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_localCache(JNIEnv *env, jclass clazz, jstring name) {
    static jfieldID f_id = nullptr;
    // 局部缓存，当该函数被多次调用时，每次都要走 if 判断并调用方法获取 id，影响性能
    if (f_id == nullptr) {
        f_id = env->GetStaticFieldID(clazz, "name1", "Ljava/lang/String;");
    } else {
        LOGD("获取静态FieldID失败")
    }
    env->SetStaticObjectField(clazz, f_id, name);

    // 验证存入的结果
    auto result = static_cast<jstring>(env->GetStaticObjectField(clazz, f_id));
    const char *resultString = env->GetStringUTFChars(result, nullptr);
    LOGD("从局部静态缓存中取出的值为：%s", resultString)
}

弊端就是注释中写到的，每次都需要调用 GetStaticFieldID() 影响性能。

1.2 全局静态缓存使用方法

全局静态缓存的生命周期分三步：初始化、使用与清除。先在上层声明这三个步骤对应的 Native 方法：

kotlin 复制代码 
	companion object {
    	// 初始化静态缓存
    	@JvmStatic
        external fun initStaticCache()

        // 使用静态缓存
        @JvmStatic
        external fun staticCache(name: String)

        // 清除静态缓存
        @JvmStatic
        external fun clearStaticCache()
	}

然后在类进行初始化时对全局静态缓存初始化，在点击按钮时给缓存存入值，在 Activity.onDestroy() 时清除全局静态缓存：

kotlin 复制代码 
	companion object {
        init {
            System.loadLibrary("env")
            // 初始化
            initStaticCache()
        }
        
        // 采用 JNI 全局静态缓存的变量
        var name2 = "T2"
    }

	override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding.btnStaticCache.setOnClickListener {
            // 存入缓存
            staticCache("777")
        }
    }

	// 双击 Back 不会立即回调，在后台管理器中杀掉时才立即回调
	override fun onDestroy() {
        super.onDestroy()
        // 清除缓存
        clearStaticCache()
    }

Native 实现：

cpp 复制代码 
// 全局静态缓存的 ID
static jfieldID f_name2_id = nullptr;

extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_initStaticCache(JNIEnv *env, jclass clazz) {
    // 初始化全局静态缓存 ID
    f_name2_id = env->GetStaticFieldID(clazz, "name2", "Ljava/lang/String;");
}

extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_staticCache(JNIEnv *env, jclass clazz, jstring name) {
    env->SetStaticObjectField(clazz, f_name2_id, name);
    // 取出存入 f_name2_id 内的值加以验证
    auto nameString = static_cast<jstring>(env->GetStaticObjectField(clazz, f_name2_id));
    const char *result = env->GetStringUTFChars(nameString, nullptr);
    LOGD("f_name2_id 存的值是：%s", result)
}

extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_clearStaticCache(JNIEnv *env, jclass clazz) {
    f_name2_id = nullptr;
    LOGD("静态缓存清除完毕")
}

实际上全局和局部静态缓存只不过就是放在函数外或内的区别，造成了易用性上的区别。

2、Native 异常捕获

主要有三种不同的异常出现的场景：

  1. Native 代码发生异常，直接在 Native 函数内补救
  2. Native 代码发生异常，抛给上层的 Java 或 Kotlin
  3. 上层方法发生异常，JNI 调用上层方法时，在 Native 函数中清除异常

先演示在 Native 发生异常的情况，上层代码：

kotlin 复制代码 
	companion object {
        @JvmStatic
        external fun testException1()
        @JvmStatic
        external fun testException2()
    }

当在 Native 层尝试获取一个上层不存在的属性时，就会抛出异常：

cpp 复制代码 
extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_testException1(JNIEnv *env, jclass clazz) {
    // 上层并没有 name666 属性，因此会抛出异常
    jfieldID f_id = env->GetStaticFieldID(clazz, "name666", "Ljava/lang/String;");
}

异常信息跟 Java 的很像：

text 复制代码 
FATAL EXCEPTION: main                                                                              Process: com.jni.env, PID: 23090
java.lang.NoSuchFieldError: no "Ljava/lang/String;" field "name666" in class "Lcom/jni/env/MainActivity;" or its superclasses
at com.jni.env.MainActivity.testException1(Native Method)
at com.jni.env.MainActivity$Companion.testException1(Unknown Source:0)
at com.jni.env.MainActivity.onCreate$lambda$2(MainActivity.kt:26)

JNI 本身就是 JVM 的，异常信息很像 Java 是合理的。解决方法有两种，一是直接在 Native 层直接处理，二是向上层抛给 Java 或 Kotlin：

cpp 复制代码 
/**
* 直接在 Native 层清除异常状态并重新获取属性
*/
extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_testException1(JNIEnv *env, jclass clazz) {
    // 上层并没有 name666 属性，因此会抛出异常
    jfieldID f_id = env->GetStaticFieldID(clazz, "name666", "Ljava/lang/String;");
    // 检测本次函数执行，是否有异常
    jthrowable throwable = env->ExceptionOccurred();
    if (throwable) {
        LOGD("JNI 层发生异常")
        // 清除异常状态，运行时就不会再抛异常了
        env->ExceptionClear();
        // 接下来可以重新获取属性，比如获取 name1
        f_id = env->GetStaticFieldID(clazz, "name1", "Ljava/lang/String;");
    }
}

/**
* 在 Native 清除异常状态，但是把异常抛给上层
*/
extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_testException2(JNIEnv *env, jclass clazz) {
    jfieldID f_id = env->GetStaticFieldID(clazz, "name666", "Ljava/lang/String;");
    jthrowable throwable = env->ExceptionOccurred();
    if (throwable) {
        LOGD("JNI 层发生异常")
        // 清除异常状态，运行时就不会再抛异常了
        env->ExceptionClear();
        jclass noSuchFieldClass = env->FindClass("java/lang/NoSuchFieldException");
        env->ThrowNew(noSuchFieldClass, "Native 层获取属性失败，请检查属性名");
    }
}

上层在调用 testException2() 时需要通过 try-catch 捕获异常：

kotlin 复制代码 
		binding.btnException.setOnClickListener {
            testException1()
            try {
                testException2()
            } catch (e: NoSuchFieldException) {
                e.printStackTrace()
                Log.d(TAG, "Native 抛给我的异常被捕获了")
            }
            testException3()
        }

最后来看 Native 通过 JNI 调用上层方法，但是上层方法运行出现异常的处理方式。其实还是通过 ExceptionClear() 清除异常状态。

示例代码，上层方法故意制造一个异常：

kotlin 复制代码 
		@JvmStatic
        fun show() {
            Log.d(TAG, "show: 111")
            throw NullPointerException("上层方法抛出的异常")
        }

Native 调用并处理：

cpp 复制代码 
extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_testException3(JNIEnv *env, jclass clazz) {
    jmethodID showID = env->GetStaticMethodID(clazz, "show", "()V");
    env->CallStaticVoidMethod(clazz, showID);

    LOGD("native 层，异常后仍在执行1...")
    LOGD("native 层，异常后仍在执行2...")
    LOGD("native 层，异常后仍在执行3...")

    if (env->ExceptionCheck()) {
        env->ExceptionDescribe();
        env->ExceptionClear();
    }
}

上层调用 testException3() 运行的 Log 如下：

text 复制代码 
show: 111
native 层，异常后仍在执行1...
native 层，异常后仍在执行2...
native 层，异常后仍在执行3...
java.lang.NullPointerException: 上层方法抛出的异常
...

可以看到 Native 调用的上层方法发生异常后，Native 代码还是在继续运行了一段时间，没有立即抛出异常，这是因为：

当通过 JNI 调用 Java 方法时，如果 Java 方法运行出现异常，JNI 并不会立即停止运行。这是因为 JNI 提供了一种机制来处理 Java 异常，并允许继续执行 JNI 代码。

当发生 Java 异常时，JNI 将异常信息存储在 JNI 的环境中，并将控制权返回给 JNI 代码。JNI 代码可以检测异常状态并采取相应的处理措施。通常，在 JNI 代码中可以使用以下方法来处理 Java 异常：

  1. ExceptionCheck()：这个方法用于检查当前 JNI 环境中是否有挂起的异常。你可以在适当的位置调用 ExceptionCheck() 方法来检查是否有异常，然后根据情况采取适当的处理措施。

  2. ExceptionOccurred()：这个方法用于获取当前 JNI 环境中的挂起异常对象。如果 ExceptionCheck() 返回 true，你可以调用 ExceptionOccurred() 获取异常对象的引用，然后根据需要进行处理。

  3. ExceptionClear()：这个方法用于清除当前 JNI 环境中的异常状态。如果你已经处理了异常或者决定不处理异常，可以调用 ExceptionClear() 来清除异常状态。

由于 JNI 允许在 Java 异常发生后继续执行 JNI 代码，因此在发生异常时，JNI 可能会尝试完成当前的 JNI 方法或代码段，以便在适当的时机处理异常并采取相应的措施。这样的设计使得 JNI 在异常处理方面更加灵活，可以根据具体的需求和策略进行异常处理。

3、其他知识点

都是一些小知识点或代码示例放在本节中。

3.1 借助 NDK 进行数组排序

上层：

kotlin 复制代码 
	private fun sort() {
        val intArray = intArrayOf(11, 22, -3, 2, 4, 6, -15)
        jniSort(intArray)
        intArray.forEach { Log.d(TAG, it.toString()) }
    }

    private external fun jniSort(intArray: IntArray)

Native 层：

cpp 复制代码 
int compare(const jint *number1, const jint *number2) {
    return *number1 - *number2;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_jni_env_MainActivity_jniSort(JNIEnv *env, jobject thiz, jintArray int_array) {
    int arrayLength = env->GetArrayLength(int_array);
    // 将 jintArray 这个数组对象转换成可被 qsort() 接收的类型 jint *
    jint *intArray = env->GetIntArrayElements(int_array, nullptr);

    // 参数依次为：数组首地址、数组长度、数组元素大小、比较器（负责比较的函数指针）
    qsort(intArray, arrayLength, sizeof(int),
          reinterpret_cast<int (*)(const void *, const void *)>(compare));
    env->ReleaseIntArrayElements(int_array, intArray, 0);
}

就是把上层的数组在 Native 层进行排序，然后刷新回上层。相关的知识前面已经有过介绍，不再赘述。

3.2 C++ 异常简介

两个简单例子，抛什么类型的异常，catch 中就捕获什么类型：

cpp 复制代码 
#include <iostream>
#include <string>

using namespace std;

void exceptionMethod01() {
    throw "我报废了";
}

// 更加简单的写法 自定义异常
class Student {
public:
    char *getInfo() {
        return "自定义";
    }
};

void exceptionMethod02() {
    Student s;
    throw s;
}

int main() {
    try {
        // 抛的是 const char *，因此捕获也是这种类型
        exceptionMethod01();
    } catch (const char *&msg) {
        cout << "捕获到异常信息:" << msg << endl;
    }
    try {
        // 抛出 Student，捕获也是 Student 类型
        exceptionMethod02();
    } catch (Student &s) {
        cout << "捕获到异常信息：" << s.getInfo() << endl;
    }
    return 0;
}

3.3 手写 JNIEnv

JNIEnv（Java Native Interface Environment）是 Java Native Interface（JNI）的一部分，它是用于在 Java 和本地代码之间进行通信的接口。

JNIEnv 的实现是由底层的 JNI 实现提供的，这个实现是与特定的 Java 虚拟机（JVM）和操作系统相关的。不同的 JVM 和操作系统可能有不同的实现方式，但它们都遵循 JNI 规范。

在大多数情况下，JNIEnv 的实现是由 JVM 在运行时动态创建的。当你调用 JNI 函数并传递 JNIEnv 指针时，实际上是将对应的实现指针传递给本地代码。本地代码可以使用 JNIEnv 指针来调用 JNI 提供的各种函数，以访问 Java 对象、调用 Java 方法、处理异常等。

JNIEnv 提供了一组函数，使本地代码能够与 Java 交互。这些函数包括创建和操作 Java 对象、调用 Java 方法、访问对象的字段、抛出异常等。JNIEnv 还提供了线程本地存储（Thread Local Storage）的机制，以确保针对每个线程的独立环境。

需要注意的是，JNIEnv 是一个抽象的接口，具体的实现由 JVM 和底层的 JNI 实现提供。因此，JNIEnv 的具体实现细节可能会因 JVM 和操作系统的不同而有所差异。如果你对特定 JVM 或操作系统的 JNIEnv 实现感兴趣，可以查阅相关文档或参考相关的 JNI 实现细节。

我们的目的是通过手写 JNIEnv 内一个方法的实现来了解它的实现原理。当然要先来看一下源码中它的实现机制。

JNIEnv 的声明

JNIEnv 实际上只是结构体的别名。它的本体在 C++ 中是 _JNIEnv，在 C 中是 JNINativeInterface*：

cpp 复制代码 
struct _JNIEnv;
struct _JavaVM;

#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;
typedef const struct JNIInvokeInterface* JavaVM;
#endif

JNINativeInterface 内声明了 300+ 个函数指针，而 C++ 的 _JNIEnv 则是对 JNINativeInterface 的封装，通过 JNINativeInterface 调用 C 内的函数：

cpp 复制代码 
/*
 * Table of interface function pointers.
 */
struct JNINativeInterface {
	...
    jint        (*GetVersion)(JNIEnv *);

    jclass      (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,
                        jsize);
    jclass      (*FindClass)(JNIEnv*, const char*);
    ...
}

/*
 * C++ object wrapper.
 *
 * This is usually overlaid on a C struct whose first element is a
 * JNINativeInterface*.  We rely somewhat on compiler behavior.
 */
struct _JNIEnv {
    /* do not rename this; it does not seem to be entirely opaque */
    const struct JNINativeInterface* functions;

#if defined(__cplusplus)

    jint GetVersion()
    { return functions->GetVersion(this); }

    jclass DefineClass(const char *name, jobject loader, const jbyte* buf,
        jsize bufLen)
    { return functions->DefineClass(this, name, loader, buf, bufLen); }

    jclass FindClass(const char* name)
    { return functions->FindClass(this, name); }
    ...
}

模拟实现

cpp 复制代码 
/**
 * 模拟 JNIEnv 的实现
 */

#include <iostream>
#include <string>

using namespace std;

// 以 C 语言结构体指针的方式实现
typedef const struct JNINativeInterface *JNIEnv;

struct JNINativeInterface {
    // 以其中一个函数指针为例
    char *(*NewStringUTF)(JNIEnv *, char *);
};

// 简化的类型声明
typedef char *jstring;
typedef char *jobject;

// 函数指针实现，极简写法
jstring NewStringUTF(JNIEnv *env, char *c_str) {
    return c_str;
}

extern "C" jstring Java_com_jni_env_MainActivity_getStringPwd(JNIEnv *env, jobject thiz) {
    return (*env)->NewStringUTF(env, "9527");
}

// 测试，模拟 JNIEnv 内部执行的过程
int main() {
    // 构建 JNIEnv* 对象
    struct JNINativeInterface nativeInterface;
    // 给结构方法指针进行赋值
    nativeInterface.NewStringUTF = NewStringUTF;
    // 传给 getStringPwd() 的参数是 JNIEnv*
    JNIEnv env = &nativeInterface;
    JNIEnv *jniEnv = &env;

    //  把 jniEnv 对象传给 getStringPwd() 的 Java 层
    char *jstring = Java_com_jni_env_MainActivity_getStringPwd(jniEnv, "com/jni/env/MainActivity");
    // jstring 通过 JNIEnv 桥梁传给 Java 层 （这个过程也省略了．．． 直接打印了）
    printf("Java层就拿到了 C++ 给我们的 jstring = %s", jstring);
    return 0;
}

3.4 上层获取 Native 对象

这里介绍一种上层获取 Native 对象的常用方式，是借鉴自 OpenCV。

在 OpenCV 中，在 Java 层通常会保存 Native 对象的指针，这样在需要使用 Native 函数时，可以直接通过这个指针进行操作。

OpenCV 源码参考 GitHub，我看的是 4.8 版本。

比如在 modules/core/misc/java/src/java/core+Mat.java 文件中：

java 复制代码 
public class Mat {

    // Native 对象的地址
    public final long nativeObj;

    // 构造方法直接赋予地址
    public Mat(long addr) {
        if (addr == 0)
            throw new UnsupportedOperationException("Native object address is NULL");
        nativeObj = addr;
    }
    
    // 空参构造方法通过 Native 的 n_Mat() 获取 nativeObj
    public Mat() {
        nativeObj = n_Mat();
    }

    private static native long n_Mat();
    ...
}

n_Mat() 这个 Native 方法在 modules/java/generator/src/cpp/Mat.cpp 中：

cpp 复制代码 
JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__DDI
  (JNIEnv* env, jclass, jdouble size_width, jdouble size_height, jint type);

JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__DDI
  (JNIEnv* env, jclass, jdouble size_width, jdouble size_height, jint type)
{
    static const char method_name[] = "Mat::n_1Mat__DDI()";
    try {
        LOGD("%s", method_name);
        Size size((int)size_width, (int)size_height);
        // new 出一个 Native 的 Mat 对象，然后强转成地址返回给 Java 层
        return (jlong) new Mat( size, type );
    } catch(const std::exception &e) {
        throwJavaException(env, &e, method_name);
    } catch (...) {
        throwJavaException(env, 0, method_name);
    }

    return 0;
}

因此我们能看到，上层拿到的 nativeObj 就是 Native 层对象的指针，也就是对象的地址，后续想使用 Native 层的功能时，就可以使用该地址转换成 Native 对象，并执行相应操作。

3.5 Parcel 源码简析

Parcelable 要比 Serializable 性能高，因为它是直接在 C++ 层写入/读取数据，而 Serializable 是通过 IO 流读写数据的。

初始化

先从 Java 层开始看（API 33）：

java 复制代码 
	@NonNull
    public static Parcel obtain() {
        // res 实际上也是 Native 对象的地址
        Parcel res = null;
        synchronized (sPoolSync) {
            if (sOwnedPool != null) {
                res = sOwnedPool;
                sOwnedPool = res.mPoolNext;
                res.mPoolNext = null;
                sOwnedPoolSize--;
            }
        }

        if (res == null) {
            // 池子里没拿到就调用构造方法创建一个 Parcel
            res = new Parcel(0);
        } else {
            res.mReadWriteHelper = ReadWriteHelper.DEFAULT;
        }
        return res;
    }

	private Parcel(long nativePtr) {
        ...
        init(nativePtr);
    }

	private void init(long nativePtr) {
        if (nativePtr != 0) {
            // 传入的地址不为 0，直接把地址给 mNativePtr
            mNativePtr = nativePtr;
            mOwnsNativeParcelObject = false;
        } else {
            // 否则用 nativeCreate() 创建一个，该方法是一个 Native
            // 方法，返回指针
            mNativePtr = nativeCreate();
            mOwnsNativeParcelObject = true;
        }
    }

进入 Native，nativeCreate() 采用动态注册，在 android_os_Parcel.cpp 中，可以查到该方法在 Native 中是通过 register_android_os_Parcel() 内的 RegisterMethodsOrDie() 注册的：

cpp 复制代码 
int register_android_os_Parcel(JNIEnv* env)
{
    jclass clazz = FindClassOrDie(env, kParcelPathName);

    gParcelOffsets.clazz = MakeGlobalRefOrDie(env, clazz);
    gParcelOffsets.mNativePtr = GetFieldIDOrDie(env, clazz, "mNativePtr", "J");
    gParcelOffsets.obtain = GetStaticMethodIDOrDie(env, clazz, "obtain", "()Landroid/os/Parcel;");
    gParcelOffsets.recycle = GetMethodIDOrDie(env, clazz, "recycle", "()V");

    return RegisterMethodsOrDie(env, kParcelPathName, gParcelMethods, NELEM(gParcelMethods));
}

看 gParcelMethods 数组可以查到对应关系：

cpp 复制代码 
static const JNINativeMethod gParcelMethods[] = {
    ...
    {"nativeCreate",              "()J", (void*)android_os_Parcel_create},
    ...
};

再看 android_os_Parcel_create()：

cpp 复制代码 
static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
{
    // 创建 Native 的 Parcel 对象，返回 Parcel 指针
    Parcel* parcel = new Parcel();
    // 将 Parcel 指针强转为 jlong
    return reinterpret_cast<jlong>(parcel);
}

你会发现 Parcel 与 OpenCV 类似，都是在 Java 层持有 Native 层对象指针，以便后续进行 Native 操作。

写入数据

我们以 Parcel.writeInt() 为例：

java 复制代码 
	public final void writeInt(int val) {
        int err = nativeWriteInt(mNativePtr, val);
        if (err != OK) {
            nativeSignalExceptionForError(err);
        }
    }

nativeWriteInt() 对应的是 android_os_Parcel_writeInt()：

cpp 复制代码 
static int android_os_Parcel_writeInt(jlong nativePtr, jint val) {
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    return (parcel != NULL) ? parcel->writeInt32(val) : OK;
}

再进入 /frameworks/native/libs/binder/Parcel.cpp 看 writeInt32()：

cpp 复制代码 
status_t Parcel::writeInt32(int32_t val)
{
    return writeAligned(val);
}

template<class T>
status_t Parcel::writeAligned(T val) {
    // 当前的数据位置 + 要写入的数据大小没有达到数据最大容量就写入数据
    if ((mDataPos+sizeof(val)) <= mDataCapacity) {
restart_write:
        memcpy(mData + mDataPos, &val, sizeof(val));
        return finishWrite(sizeof(val));
    }

    status_t err = growData(sizeof(val));
    if (err == NO_ERROR) goto restart_write;
    return err;
}

从这里能看出，为什么 Parcel 要求写入数据和读取数据的顺序要一致，因为写入数据时在内存地址中是有顺序的。finishWrite() 会检查 val 的大小是否超出限制，如果没有则更新存入数据后的数据位置 mDataPos：

cpp 复制代码 
status_t Parcel::finishWrite(size_t len)
{
    if (len > INT32_MAX) {
        return BAD_VALUE;
    }

    mDataPos += len;
    if (mDataPos > mDataSize) {
        mDataSize = mDataPos;
    }
    return NO_ERROR;
}

读取数据的 readInt() 也是类似的过程。

3.6 Parcel 的简单实现

当做练习，自定义 MyParcel 实现写入和读取 Int 类型数据的功能。上层要保存一个 Native 层 MyParcel 对象的指针：

kotlin 复制代码 
// MyParcel.kt
class MyParcel(nativePtr: Long) {

    // 保存 Native 的 MyParcel 对象的首地址
    private var mNativePtr: Long = 0

    init {
        mNativePtr = if (nativePtr == 0L) {
            nativeCreate()
        } else {
            nativePtr
        }
    }

    // 上层方法直接调用 Native 方法
    fun writeInt(value: Int) = nativeWriteInt(mNativePtr, value)
    fun readInt() = nativeReadInt(mNativePtr)
    fun setDataPosition(position: Int) = nativeSetDataPosition(mNativePtr, position)

    // Native 方法
    private external fun nativeCreate(): Long
    private external fun nativeSetDataPosition(mNativePtr: Long, position: Int)
    private external fun nativeWriteInt(mNativePtr: Long, int: Int)
    private external fun nativeReadInt(mNativePtr: Long): Int

    companion object {
        init {
            System.loadLibrary("parcel")
        }

        // obtain() 直接获取默认的 MyParcel 对象
        fun obtain(): MyParcel {
            return MyParcel(0)
        }
    }
}

Native 层要实现上层声明的 Native 方法：

cpp 复制代码 
// native-lib.cpp
extern "C"
JNIEXPORT jlong JNICALL
Java_com_jni_parcel_MyParcel_nativeCreate(JNIEnv *env, jobject thiz) {
    auto *myParcel = new MyParcel;
    return reinterpret_cast<jlong>(myParcel);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_jni_parcel_MyParcel_nativeSetDataPosition(JNIEnv *env, jobject thiz, jlong m_native_ptr,
                                                   jint position) {
    auto *myParcel = reinterpret_cast<MyParcel *>(m_native_ptr);
    myParcel->setDataPosition(position);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_jni_parcel_MyParcel_nativeWriteInt(JNIEnv *env, jobject thiz, jlong m_native_ptr,
                                            jint intValue) {
    auto *myParcel = reinterpret_cast<MyParcel *>(m_native_ptr);
    myParcel->writeInt(intValue);
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_jni_parcel_MyParcel_nativeReadInt(JNIEnv *env, jobject thiz, jlong m_native_ptr) {
    auto *myParcel = reinterpret_cast<MyParcel *>(m_native_ptr);
    return myParcel->readInt();
}

MyParcel 在 Native 的声明与实现：

cpp 复制代码 
// my_parcel.h
class MyParcel {
private:
    // 保存的数据首地址
    int *mData = 0;

    // 数据当前的位置
    int mDataPosition = 0;

    // 修改数据位置
    void changePosition(int value);

    long *stringObj = nullptr;
public:
    MyParcel();

    virtual ~MyParcel();

    void writeInt(int value);

    jint readInt();

    // 设置数据位置
    void setDataPosition(int position);
};

// my_parcel.cpp
MyParcel::MyParcel() {
    // 默认分配 1KB 大小
    mData = static_cast<int *>(malloc(1024));
}

MyParcel::~MyParcel() {
    if (mData) {
        free(mData);
    }

    if (mDataPosition) {
        mDataPosition = NULL;
    }
}

void MyParcel::writeInt(int value) {
    // 如果加入 int 类型的数据没有超过预设的 1024 kB 才存入数据
    if (mDataPosition + sizeof(int) <= 1024) {
        *(mData + mDataPosition) = value;
    }
    // 更新数据位置指针 mDataPosition
    changePosition(sizeof(int));
}

void MyParcel::changePosition(int value) {
    mDataPosition += value;
}

jint MyParcel::readInt() {
    jint result = *(mData + mDataPosition);
    // 读数据的时候是从 0 位置开始读的，因此读完一个数据要
    // 更新位置时也是采用加法
    changePosition(sizeof(int));
    return result;
}

void MyParcel::setDataPosition(int position) {
    mDataPosition = position;
}
相关推荐
捕鲸叉5 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer5 小时前
【C++】vector 类深度解析：探索动态数组的奥秘
开发语言·c++·算法
Peter_chq5 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
青花瓷7 小时前
C++__XCode工程中Debug版本库向Release版本库的切换
c++·xcode
幺零九零零8 小时前
【C++】socket套接字编程
linux·服务器·网络·c++
捕鲸叉8 小时前
MVC（Model-View-Controller）模式概述
开发语言·c++·设计模式
Dola_Pan9 小时前
C++算法和竞赛：哈希算法、动态规划DP算法、贪心算法、博弈算法
c++·算法·哈希算法
yanlou2339 小时前
KMP算法，next数组详解（c++）
开发语言·c++·kmp算法
小林熬夜学编程9 小时前
【Linux系统编程】第四十一弹---线程深度解析：从地址空间到多线程实践
linux·c语言·开发语言·c++·算法
阿洵Rain10 小时前
【C++】哈希
数据结构·c++·算法·list·哈希算法
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play