掌握 Android JNI 基础

写在前面

最近在看一些底层源码，发现 JNI 这块还是有必要系统的看一下，索性就写一写博客，加深加深印象🍻

本文重点聊一聊一些干货，避免长篇大论

JNI 概述

JNI 是什么？

定义：Java Native Interface ，即 Java 本地接口 作用：使得 Java 与本地其他类型语言（如 C、C++ ）进行交互

注意：

• JNI 是 Java 调用 Native 语言的一种特性

• JNI 是属于 Java 的，与 Android 平台无直接关系

以 Java 8 为例，JNI 最新在线 API： https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/jniTOC.html

为什么会有 JNI ？

实际的使用中，Java 需要与本地代码进行交互，因为 Java 项目具备跨平台的特点，所以 Java 与本地代码交互的能力非常弱，采用 JNI 特性，增强 Java 与本地代码交互的能力

JNI 和 NDK 的关系

JNI 是 Java 平台提供的一套非常强大的框架 Java Native Interface，用于与本地代码进行相互调用

NDK 是 Android 平台提供的 Native 开发工具集，Native Development Kit的缩写。NDK 其中包含了 JNI 并对其进行了封装

关于 JNI 的入口头文件会有两份，分别在 JDK 和 NDK 中，进一步说明 Android 的 NDK 对 JDK 的 JNI 进行了二次封装

常见所在目录：

• JDK: JAVA_HOME/include/jni.h

• NDK: ~/Library/Android/sdk/ndk/26.1.10909125/toolchains/llvm/prebuilt/darwin-x86_64/sysroot/usr/include/jni.h

环境准备

• Android Studio 版本：Android Studio Hedgehog | 2023.1.1 Patch 1

• Gradle 版本：gradle-8.0

• targetSdk：33

Android Studio 安装相关工具：

创建示例

File -> New，选择 Native++ 模板：

检查 NDK 相关配置是否正常：

native-lib.cpp C++ 示例代码：

MainActivity.java 示例代码：

CMake 构建

在 Android 开发中，CMake 用于编译 C/C++ 代码。从 Android Studio 2.2 版本开始，Google 引入了对 CMake 的支持，使得开发者可以通过 CMake 和 NDK 将 C/C++ 代码编译成底层的库，然后再配合 Gradle 的编译将库打包到 APK 中

CMake 具体的配置信息如下：

# cmake最低版本要求
cmake_minimum_required(VERSION 3.22.1)

# 配置库生成路径
# CMAKE_CURRENT_SOURCE_DIR是指 cmake库的源路径，通常是build/.../cmake/
# /../jniLibs/是指与CMakeList.txt所在目录的同级目录：jniLibs (如果没有会新建)
# ANDROID_ABI 生成库文件时，采用gradle配置的ABI策略（即：生成哪些平台对应的库文件）
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})

# 添加库
add_library( # 库名
        native-lib

        # 类型：
        # SHARED 是指动态库，对应的是.so文件
        # STATIC 是指静态库，对应的是.a文件
        # 其他类型:略
        SHARED

        # native类路径
        native-lib.cpp)

# 查找依赖库
find_library(
        # 依赖库别名
        log-lib

        # 希望加到本地的NDK库名称，log指NDK的日志库
        log)


# 链接库，建立关系（ 此处就是指把log-lib 链接给native-lib使用 ）
target_link_libraries(
        # 目标库名称（native-lib就是咱们要生成的so库）
        native-lib

        # 要链接的库（上面查找的log库）
        ${log-lib})

摘自： https://www.cnblogs.com/qixingchao/p/11911787.html

默认 so 的目录（注意 AS 版本，不同版本不一致）：

安装包反编译 so 路径位置：

示例解读

#include <jni.h>
#include <string>

extern "C" JNIEXPORT jstring

JNICALL
Java_org_lulu_jnilearning_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "这是 C++ 中的代码";
    char * str = "这是 C++ 中的代码";

    return env->NewStringUTF(str);
}

• extern "C"：避免按照 C++ 的方式去编译 C 函数

  为什么需要使用它呢？ 这是因为 C++ 支持函数重载，所以编译器在编译函数时会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名。而 C 语言并不支持函数重载，因此编译 C 语言代码的函数时不会带上函数的参数类型，一般只包括函数名

• JNIEXPORT ：用来表示该函数是否可导出（宏定义）

• JNICALL：（可以缺少）jni call 约束函数入栈顺序和堆栈内存清理规则，在 Linux 中置空

• jstring：代表 Java 中的 String

• JNIEnv：C 和 Java 相互调用的桥梁，代表 Java 环境，内部包含了众多函数（后续详细介绍）

• jobject：（ Java 侧声明的 native 方法为非静态，传递时为 jobject）Java 传递过来的示例对象，即当前 Java 类的对象，示例中 MainActivity.this 就是它

• jclass：（ Java 侧声明的 native 方法为静态，传递时为 jclass）Java 传递过来的类对象，即当前 Java 类的 Class 对象，示例中 MainActivity.class 就是它

JNIEnv

C 和 Java 相互调用的桥梁，代表 Java 环境

通过 JNIEnv 就可以对 Java 端的代码进行操作：

• 创建 Java 对象

• 调用 Java 对象方法

• 获取 Java 对象的属性

• ...

C++ 中 JNIEnv 指向_JNIEnv，而_JNIEnv是定义的一个结构体，包裹了 JNINativeInterface，而在 C 中JNIEnv就是 JNINativeInterface

常用的方法：

Java、JNI、C/C++ 基本类型映射

Java 、C/C++都有一些常用的数据类型，分别是如何与JNI类型对应的呢？做以下整理：

JNI描述符（签名）

JNI 开发时，我们除了写本地C/C++实现，还可以通过JNIEnv *env 调用 Java 层代码，如获得某个字段、获取某个函数、执行某个函数等：

//获得某类中定义的字段id
jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
    { return functions->GetFieldID(this, clazz, name, sig); }

//获得某类中定义的函数id
jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)
    { return functions->GetMethodID(this, clazz, name, sig); }

以上函数和 Java 的反射比较类似，参数说明：

• clazz：类的 class 对象

• name：字段名称、函数名称

• sig：字段描述符（字段签名），函数描述符（函数签名）

特别的，对 sig 进行解释：

1. 如果是字段，表示字段类型的描述符

2. 如果是函数，表示函数结构的描述符，即：每个参数类型描述符 + 返回值类型描述符

后面会结合实际案例进一步说明

整理字段类型签名：

整理函数类型签名：

如何通过指令获取当前 class 的签名：

找到此目录： 执行以下命令：

javap -s -p MainActivity.class 

相关描述符信息如下：

Compiled from "MainActivity.kt"
public final class org.lulu.jnilearning.MainActivity extends androidx.appcompat.app.AppCompatActivity {
  //...
  private java.lang.String nonStaticField;
    descriptor: Ljava/lang/String;
  private static java.lang.String staticField;
    descriptor: Ljava/lang/String;
    //...
}

Java和C++交互示例

我们以从 Native 侧修改 Java 侧非静态字段和静态字段为例，编写一段简单 Java 和 C++ 交互的示例：

修改非静态字段：

MainActivity.kt

private const val TAG = "MainActivity"

class MainActivity : AppCompatActivity() {
    /**
     * 待修改的非静态字段
     */
    private var nonStaticField = "Java 非静态字段"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
  //...
        Log.d(TAG, "changeNonStaticField before: $nonStaticField")
        changeNonStaticField()
        Log.d(TAG, "changeNonStaticField after: $nonStaticField")
    }

 /**
     * 修改非静态字段的 Native 方法
     */
    external fun changeNonStaticField()

    companion object {
        // Used to load the 'jnilearning' library on application startup.
        init {
            System.loadLibrary("jnilearning")
        }
    }
    //...
}

native-lib.cpp

extern "C"
JNIEXPORT void JNICALL
Java_org_lulu_jnilearning_MainActivity_changeNonStaticField(JNIEnv *env, jobject thiz) {
    //1. 获取当前实例的类对象，即 MainActivity.class
    //   有两种方式
    // 1.1 jclass FindClass(const char* name)
    //jclass clazz = env->FindClass("org/lulu/jnilearning/MainActivity");
    // 1.2 【推荐】jclass GetObjectClass(jobject obj)
    jclass clazz = env->GetObjectClass(thiz);
    //2. 获取要修改的非静态字段 Id
    //jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
    jfieldID nonStaticFieldId = env->GetFieldID(clazz, "nonStaticField", "Ljava/lang/String;");
    //3. 创建一个新的 jstring，准备赋值
    //jstring NewStringUTF(const char* bytes)
    jstring jstr = env->NewStringUTF("Java 非静态字段，C++ 已修改");
    //4. 这是这个新的 jstring 给 nonStaticField 字段
    //void SetObjectField(jobject obj, jfieldID fieldID, jobject value)
    env->SetObjectField(thiz, nonStaticFieldId, jstr);
}

代码执行结果如下：

changeNonStaticField before: Java 非静态字段
changeNonStaticField after: Java 非静态字段，C++ 已修改

静态变量的修改类似，仅贴出C++代码：

extern "C"
JNIEXPORT void JNICALL
Java_org_lulu_jnilearning_MainActivity_changeStaticField(JNIEnv *env, jobject thiz) {
    //1. 获取当前实例的类对象，即 MainActivity.class
    //   有两种方式
    // 1.1 jclass FindClass(const char* name)
    //jclass clazz = env->FindClass("org/lulu/jnilearning/MainActivity");
    // 1.2 【推荐】jclass GetObjectClass(jobject obj)
    jclass clazz = env->GetObjectClass(thiz);
    //2. 获取要修改的静态字段 Id
    //jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig)
    jfieldID staticFieldId = env->GetStaticFieldID(clazz, "staticField", "Ljava/lang/String;");
    //3. 创建一个新的 jstring，准备赋值
    //jstring NewStringUTF(const char* bytes)
    jstring jstr = env->NewStringUTF("Java 静态字段，C++ 已修改");
    //4. 这是这个新的 jstring 给 staticField 字段
    //void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value)
    env->SetStaticObjectField(clazz, staticFieldId, jstr);
}

最后

这篇文章就到这里了，希望大家能够学到一些有用的知识，也欢迎你们在评论区留言交流。如果你觉得这篇文章有趣或者有帮助，不妨给我点个赞或者分享给你的朋友。感谢你们的阅读，我们下次再见！