Android JNI/NDK 入门从一到二

港控/mmm° 2024-04-25 20:23 68阅读 0赞

#### 1. 前言 ####

最基础的创建`JNI`接口的操作，可以直接看这篇文章 : [第一个Android JNI工程][Android JNI]，  
本文会基于`掌握创建JNI接口的操作`的基础之上，来入门`JNI/NDK`。

#### 2. 在JNI中打印日志 ####

##### 2.1 添加log模块 #####

记得`CMake`中有`log`模块，不然编译不过

target_link_libraries(
    		#...省略
            android
            log)

##### 2.2 添加头文件 #####

#include <android/log.h>

##### 2.3 定义Log方法 #####

#define LOG_TAG "CPPLOG"
    #define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG , __VA_ARGS__) // 定义LOGD类型
    #define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG , __VA_ARGS__) // 定义LOGE类型
    #define LOGI(...)  __android_log_print(ANDROID_LOG_INFO, LOG_TAG , __VA_ARGS__) // 定义LOGE类型

##### 2.4 进行调用 #####

LOGD("java int value is %p", value);

#### 3. 基础类型转换 ####

`JNI`和`Java`基础类型可以直接进行转换  
在`jni.h`中我们可以看到`JNI`的基础类型有这些，比如`jint`其实就是对应`C++`中的`int32_t`类型

/* Primitive types that match up with Java equivalents. */
    typedef uint8_t  jboolean; /* unsigned 8 bits */
    typedef int8_t   jbyte;    /* signed 8 bits */
    typedef uint16_t jchar;    /* unsigned 16 bits */
    typedef int16_t  jshort;   /* signed 16 bits */
    typedef int32_t  jint;     /* signed 32 bits */
    typedef int64_t  jlong;    /* signed 64 bits */
    typedef float    jfloat;   /* 32-bit IEEE 754 */
    typedef double   jdouble;  /* 64-bit IEEE 754 */

> 在C++中，\_t是一种命名约定，表示某个类型。通常在命名中使用\_t作为类型的后缀，以便区分该名称是一个类型而不是其他实体（例如变量或函数）。

我把它整理成了一个表格，`Java`基础类型和`JNI`基础类型相对应

<table> 
 <thead> 
  <tr> 
   <th>Java</th> 
   <th>Native</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>jboolean</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>jbyte</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>jchar</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>jshort</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>jint</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>jlong</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>jfloat</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>jdouble</td> 
  </tr> 
 </tbody> 
</table>

##### 3.1 编写JNI方法 #####

在Java类中编写JNI方法

external fun callNativeInt(value:Int) : Int
    
    external fun callNativeByte(value:Byte) : Byte
    
    external fun callNativeChar(value:Char) : Char
    
    external fun callNativeLong(value:Long) : Long
    
    external fun callNativeFloat(value:Float) : Float
    
    external fun callNativeDouble(value:Double) : Double

##### 3.2 C++中编写对应的方法 #####

extern "C"
    JNIEXPORT jint JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeInt(JNIEnv *env, jobject thiz, jint value) {
        
        LOGD("value:%d", value);
        return value + 1;
    }
    extern "C"
    JNIEXPORT jbyte JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeByte(JNIEnv *env, jobject thiz, jbyte value) {
        
        LOGD("value:%d", value);
        return value + 1;
    }
    extern "C"
    JNIEXPORT jchar JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeChar(JNIEnv *env, jobject thiz, jchar value) {
        
        LOGD("value:%d", value);
        return value + 1;
    }
    extern "C"
    JNIEXPORT jlong JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeLong(JNIEnv *env, jobject thiz, jlong value) {
        
        LOGD("value:%d", value);
        return value + 1;
    }
    extern "C"
    JNIEXPORT jfloat JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeFloat(JNIEnv *env, jobject thiz, jfloat value) {
        
        LOGD("value:%f", value);
        return value + 1.0;
    }
    extern "C"
    JNIEXPORT jdouble JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeDouble(JNIEnv *env, jobject thiz,
                                                               jdouble value) {
        
        LOGD("value:%f", value);
        return value + 1.0;
    }

##### 3.3. 进行调用 #####

Log.i(TAG, "result:${
          nativeLib.callNativeInt(1)}")
    Log.i(TAG, "result:${
          nativeLib.callNativeByte(2)}")
    Log.i(TAG, "result:${
          nativeLib.callNativeChar('c')}")
    Log.i(TAG, "result:${
          nativeLib.callNativeLong(4)}")
    Log.i(TAG, "result:${
          nativeLib.callNativeFloat(5F)}")
    Log.i(TAG, "result:${
          nativeLib.callNativeDouble(6.0)}")

##### 3.4 运行项目 #####

打印日志如下

10:16:36.815  D  value:1
    10:16:36.815  I  result:2
    10:16:36.815  D  value:2
    10:16:36.815  I  result:3
    10:16:36.815  D  value:99
    10:16:36.815  I  result:d
    10:16:36.815  D  value:4
    10:16:36.815  I  result:5
    10:16:36.815  D  value:5.000000
    10:16:36.815  I  result:6.0
    10:16:36.816  D  value:6.000000
    10:16:36.816  I  result:7.0

#### 4. 字符串 ####

`Java`字符串转成`Native`的字符串，并不能直接做转换，需要调用`env->GetStringUTFChars()`，  
对应的，需要调用`env->ReleaseStringUTFChars()`来释放资源。

> 默认情况下，Java都是UTF编码，如果不是UTF编码，则需要调用`env->GetStringChars()`

##### 4.1 Java/Native字符串转换 #####

external fun callNativeString(value:String) : String

extern "C"
    JNIEXPORT jstring JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeString(JNIEnv *env, jobject thiz,
                                                               jstring value) {
        
        //Java字符串转成Native的字符串，并不能直接做转换
        const char *str = env->GetStringUTFChars(value, NULL); //Java的字符串是UTF编码的
        //env->GetStringChars(); //如果不是UTF编码，就用这个
        LOGD("str:%s", str);
        env->ReleaseStringUTFChars(value, str);
    
        jstring result = env->NewStringUTF("hello world!");
        return result;
    }

进行调用

Log.i(TAG, "result:${
          nativeLib.callNativeString("你好呀")}")
    nativeLib.stringMethod("hello world!")

执行结果

10:45:45.849  D  str:你好呀
    10:45:45.849  I  result:hello world!

##### 4.2 C++ 字符串的使用 #####

定义`JNI`接口

external fun stringMethod(value:String)

实现`C++`方法

extern "C"
    JNIEXPORT void JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_stringMethod(JNIEnv *env, jobject thiz, jstring value) {
        
        const char *str = env->GetStringUTFChars(value, 0);
    
        int length = env->GetStringLength(value);
        LOGD("length:%d", length);
    
        char buf[256];
        env->GetStringUTFRegion(value, 0, length, buf); //拷贝字符串数据到char[]中
        LOGD("text:%s", buf);
    
        env->ReleaseStringUTFChars(value, str);
    }

进行调用

Log.i(TAG, "result:${
          nativeLib.callNativeString("你好呀")}")
    nativeLib.stringMethod("hello world!")

执行结果

10:45:45.849  D  length:12
    10:45:45.849  D  text:hello world!

#### 5. 引用类型的使用 ####

这里列出了`Java`引用类型和`JNI`应用类型的对应关系。  
值得注意的是，不是所有的`Java`引用类型都有对应的`JNI`的引用类型。  
比如`Java`中的字符串数组`String[]`，就没有相对应的`JNI`的引用类型，这种情况下，都会统一归类为`jobject`。

<table> 
 <thead> 
  <tr> 
   <th>Java Reference</th> 
   <th>Native</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>All objects</td> 
   <td>jobject</td> 
  </tr> 
  <tr> 
   <td>java.lang.Class</td> 
   <td>jclass</td> 
  </tr> 
  <tr> 
   <td>java.lang.String</td> 
   <td>jstring</td> 
  </tr> 
  <tr> 
   <td>Object[]</td> 
   <td>jobjectArray</td> 
  </tr> 
  <tr> 
   <td>boolean[]</td> 
   <td>jbooleanArray</td> 
  </tr> 
  <tr> 
   <td>byte[]</td> 
   <td>jbyteArray</td> 
  </tr> 
  <tr> 
   <td>java.lang.Throwable</td> 
   <td>jthrowable</td> 
  </tr> 
  <tr> 
   <td>char[]</td> 
   <td>jcharArray</td> 
  </tr> 
  <tr> 
   <td>short[]</td> 
   <td>jshortArray</td> 
  </tr> 
  <tr> 
   <td>int[]</td> 
   <td>jintArray</td> 
  </tr> 
  <tr> 
   <td>long[]</td> 
   <td>jlongArray</td> 
  </tr> 
  <tr> 
   <td>float[]</td> 
   <td>jfloatArray</td> 
  </tr> 
  <tr> 
   <td>double[]</td> 
   <td>jdoubleArray</td> 
  </tr> 
 </tbody> 
</table>

##### 5.1 传递字符串数据 #####

Java层传递一个字符串数组，然后`C++`层接收到后，获取这个字符串数组的第一个字符串，并打印出来。

定义`JNI`接口

external fun callNativeStringArray(array:Array<String>)

实现`C++`方法，这里因为是字符串数组，JNI中没有相对应的类型，所以需要先通过`env->GetObjectArrayElement()`获取到`Object`数组中的第一个索引的`Object`，再将其强转为`jstring`类型。  
如果是`JNI`有对应类型的，按直接调用相关`API`就可以了，比如`env->GetIntArrayElements()`、`env->GetFloatArrayElements()`

extern "C"
    JNIEXPORT void JNICALL
    Java_com_heiko_myopencvtest2023_NativeLib_callNativeStringArray(JNIEnv *env, jobject thiz,
                                                                    jobjectArray array) {
        
        int len = env->GetArrayLength(array);
        LOGD("len:%d",len);
        //env->GetIntArrayElements() //获取Int数组
        //env->GetFloatArrayElements() //获得Float数组
        //env->GetObjectArrayElement() //获得JNI数组
        jstring result = static_cast<jstring>(env->GetObjectArrayElement(array, 0)); //获取index为0的值
        const char * str = env->GetStringUTFChars(result,NULL);
        LOGD("text[0]:%s",str);
        env->ReleaseStringUTFChars(result,str);
    }

> `static_cast`是进行类型的强转

进行调用

val array = arrayOf("ABC", "DEF", "GHI", "JKL", "MNO")
    nativeLib.callNativeStringArray(array)

执行结果

13:27:06.865  D  len:5
    13:27:06.865  D  text[0]:ABC

#### 6. 传递Bitmap ####

这里我们以镜像`Bitmap`图片为例，传递`Bitmap`图片到`JNI`层，然后进行镜像操作，并将镜像后的`Bitmap`图片返回给`Java`层

##### 6.1 获取Bitamp的信息 #####

调用`AndroidBitmap_getInfo()`，用来获取Bitmap的信息。

AndroidBitmapInfo bitmapInfo;
    AndroidBitmap_getInfo(env, bitmap, &bitmapInfo);

##### 6.2 获取Bitmap像素内容 #####

调用`AndroidBitmap_lockPixels()`，用来获取`Bitmap`的像素内容。  
同时，记得需要调用`AndroidBitmap_unlockPixels()`来释放资源，这两个`API`是配对使用的。

//拿到像素内容
    void *bitmapPixels;
    AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels);
    
    //释放资源
    AndroidBitmap_unlockPixels(env, bitmap);

##### 6.3 JNI中创建Bitamp #####

直接复制这个封装好的方法，进行调用就好

jobject generateBitmap(JNIEnv *env, uint32_t width, uint32_t height) {
        
        // 获取Bitmap类引用
        jclass bitmapCls = env->FindClass("android/graphics/Bitmap");
        // 获取Bitmap构造方法的引用
        jmethodID createBitmapFunction = env->GetStaticMethodID(bitmapCls, "createBitmap",
                                                                "(IILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;");
    
        jstring configName = env->NewStringUTF("ARGB_8888");
        jclass bitmapConfigClass = env->FindClass("android/graphics/Bitmap$Config");
        jmethodID valueOfBitmapConfigFunction = env->GetStaticMethodID(
                bitmapConfigClass, "valueOf", "(Ljava/lang/String;)Landroid/graphics/Bitmap$Config;"
        );
        jobject bitmapConfig = env->CallStaticObjectMethod(bitmapConfigClass,
                                                           valueOfBitmapConfigFunction, configName);
        jobject newBitmap = env->CallStaticObjectMethod(bitmapCls, createBitmapFunction, width, height,
                                                        bitmapConfig);
        return newBitmap;
    }

##### 6.4 实现Bitmap镜像操作 #####

定义`JNI`

external fun mirrorBitmap(bitmap: Bitmap) : Bitmap

实现`C++`代码

extern "C"
    JNIEXPORT jobject JNICALL
    Java_com_heiko_myncnnlib_NcnnNativeLib_mirrorBitmap(JNIEnv *env, jobject thiz, jobject bitmap) {
        
        AndroidBitmapInfo bitmapInfo;
        AndroidBitmap_getInfo(env, bitmap, &bitmapInfo);
        __android_log_print(ANDROID_LOG_DEBUG, "jniBitmap", "width:%d,height:%d", bitmapInfo.width,
                            bitmapInfo.height);
    
        //拿到像素内容
        void *bitmapPixels;
        AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels);
    
        uint32_t newWidth = bitmapInfo.width;
        uint32_t newHeight = bitmapInfo.height;
    
        uint32_t *newBitmapPixels = new uint32_t[newWidth * newHeight];
        int index = 0;
        //遍历Bitmap像素，将左右的像素进行互换 (镜像操作)
        for (int y = 0; y < newHeight; y++) {
        
            for (int x = newWidth - 1; x >= 0; x--) {
        
                uint32_t pixel = ((uint32_t *) bitmapPixels)[index++];
                newBitmapPixels[newWidth * y + x] = pixel;
            }
        }
    
        AndroidBitmap_unlockPixels(env, bitmap);
    	
    	//生成新的Bitmap
        jobject newBitmap = generateBitmap(env, newWidth, newHeight);
        void *resultBitmapPixels;
        AndroidBitmap_lockPixels(env, newBitmap, &resultBitmapPixels);
        //拷贝
        memcpy((uint32_t *)resultBitmapPixels, newBitmapPixels, sizeof(uint32_t) * newWidth * newHeight);
        AndroidBitmap_unlockPixels(env,newBitmap);
    
        delete [] newBitmapPixels;
        return newBitmap;
    }

进行调用

var bitmap = BitmapFactory.decodeResource(resources,R.drawable.img_test)
    binding.img1.setImageBitmap(bitmap)
    
    binding.btnMirrorImage.setOnClickListener {
        
        bitmap = nativeLib.mirrorBitmap(bitmap)
        binding.img1.setImageBitmap(bitmap)
    }

进行程序，点击`Button`，可以发现图片执行了**镜像**操作。

![在这里插入图片描述][a080054ab8574a9cb67022db15113ea5.png]

#### 7. 其他 ####

##### 7.1 CMake #####

关于`CMake`可以看我的另一篇博客 : [Android NDK CMakeLists.txt 常用命令说明][Android NDK CMakeLists.txt]

##### 7.2 参考 #####

感谢 [Android CMake以及NDK实践基础][Android CMake_NDK]

[Android JNI]: https://juejin.cn/post/6844904025662423053?searchId=20231027150549F2E8825D5F76A1BC3D45
[a080054ab8574a9cb67022db15113ea5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/c60f5c6d42af4d158305351ef13e1aba.png
[Android NDK CMakeLists.txt]: https://blog.csdn.net/EthanCo/article/details/126542287
[Android CMake_NDK]: https://www.imooc.com/learn/1212