【Android】之【NDK】【JNI】

一、简介

1. JNI 是什么

JNI 是 Java Native Interface 的缩写，即 Java 的本地接口。
目的是使得 Java 与本地其他语言（如 C/C++）进行交互。
JNI 是属于 Java 的，与 Android 无直接关系。

2. NDK 是什么

NDK 是 Native Development Kit 的缩写，是 Android 的工具开发包，也是Android SDK的一个扩展集，用来扩展SDK的功能。
作用是快速开发 C/C++ 的动态库，并自动将动态库与应用一起打包到 apk。
NDK 是属于 Android 的，与 Java 无直接关系。

3. JNI 与 NDK 的关系

JNI 是实现的目的，NDK 是 Android 中实现 JNI 的手段。

4、使用场景

• 1.为了提升这些模块的性能，对图形，视频，音频等计算密集型应用，将复杂模块计算封装在.so或者.a文件中处理。
• 2.使用的是C/C++进行编写的第三方库移植。如ffmppeg，OpenGl等。
• 3.某些情况下为了提高数据安全性，也会封装so来实现。毕竟使用纯Java开发的app是有很多逆向工具可以破解的。

二、注册方式

2.1静态注册

1. 定义

通过 JNIEXPORT 和 JNICALL 两个宏定义声明，在虚拟机加载 so 时发现上面两个宏定义的函数时就会链接到对应的 native 方法。

2. 对应规则

Java + 包名 + 类名 + 方法名

其中使用下划线将每部分隔开，包名也使用下划线隔开。

示例（包名：com.afei.jnidemo，类名：MainActivity）：

// Java native method（java）
public native String stringFromJNI();

// JNI method (C++)
JNIEXPORT jstring JNICALL
Java_com_afei_jnidemo_MainActivity_stringFromJNI( JNIEnv *env, jobject instance);

如果名称中本来就包含下划线，将使用下划线加数字替换。

// Java native method
public native String stringFrom_JNI();

// JNI method 
JNIEXPORT jstring JNICALL
Java_com_afei_jnidemo_MainActivity_stringFrom_1JNI(JNIEnv *env, jobject instance);

3. 优点

• 简单明了

4. 缺点

• 必须遵循注册规则
• 名字过长
• 运行时去找效率不高

2.2 动态注册

1. 定义

通过 RegisterNatives 方法手动完成 native 方法和 so 中的方法的绑定，这样虚拟机就可以通过这个函数映射表直接找到相应的方法了。

2. 注册过程示例

a. 假设有两个 native 方法如下：

public native String stringFromJNI(); 
public static native int add(int a, int b);

b. 通常我们在 JNI_OnLoad 方法中完成动态注册，native-lib.cpp 如下：

#include 
#include 
#include "log.hpp"
 
extern "C" {
	jstring stringFromJNI(JNIEnv *env, jobject instance) {
	    std::string hello = "Hello from C++";
	    return env->NewStringUTF(hello.c_str());
	}
	 
	jint add(JNIEnv *env, jclass clazz, jint a, jint b) {
	    return a + b;
	}
 
	jint RegisterNatives(JNIEnv *env) {
	    jclass clazz = env->FindClass("com/afei/jnidemo/MainActivity");
	    if (clazz == NULL) {
	        LOGE("con't find class: com/afei/jnidemo/MainActivity");
	        return JNI_ERR;
	    }
	    JNINativeMethod methods_MainActivity[] = {
	            {"stringFromJNI", "()Ljava/lang/String;", (void *) stringFromJNI},
	            {"add",           "(II)I",                (void *) add}
	    };
	    // int len = sizeof(methods_MainActivity) / sizeof(methods_MainActivity[0]);
	    return env->RegisterNatives(clazz, methods_MainActivity,
	                                sizeof(methods_MainActivity) / sizeof(methods_MainActivity[0]));
	}
 
	jint JNI_OnLoad(JavaVM *vm, void *reserved) {
	    JNIEnv *env = NULL;
	    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
	        return JNI_ERR;
	    }
	    jint result = RegisterNatives(env);
	    LOGD("RegisterNatives result: %d", result);
	    return JNI_VERSION_1_6;
	}
 
}

c. 分析
如上，我们不再使用 JNIEXPORT 和 JNICALL 两个宏定义声明指定的方法，也不用依照固定的命名规则命名方法（不过通常 jni 里的方法名还是保持和 native 方法的方法名一致，见名思义），而是通过了一个 RegisterNatives 方法完成了动态注册。

3. RegisterNatives 方法解析

定义： jint RegisterNatives(jclass clazz, const JNINativeMethod* methods, jint nMethods)

参数：

• clazz：指定的类，即 native 方法所属的类
• methods：方法数组，这里需要了解一下 JNINativeMethod 结构体
• nMethods：方法数组的长度

JNINativeMethod：

typedef struct {
    const char* name; // native 的方法名
    const char* signature; // 方法签名，例如 ()Ljava/lang/String;
    void*       fnPtr; // 函数指针
} JNINativeMethod;

返回值：成功则返回 JNI_OK (0)，失败则返回一个负值。

三、简单实践

4.1 新建Native C++工程

4.2 生成的代码工程如下

MainActivity.java代码

package com.example.demojni;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import com.example.demojni.databinding.ActivityMainBinding;

public class MainActivity extends AppCompatActivity {

private ActivityMainBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

     binding = ActivityMainBinding.inflate(getLayoutInflater());
     setContentView(binding.getRoot());

        // Example of a call to a native method
        TextView tv = binding.sampleText;
        tv.setText(stringFromJNI());
    }

    /**
     * A native method that is implemented by the 'demojni' native library,
     * which is packaged with this application.
     */
    public native String stringFromJNI();

    // Used to load the 'demojni' library on application startup.
    static {
        System.loadLibrary("demojni");
    }
}

native-lib.cpp 代码

#include 
#include 

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_demojni_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

CMakeLists.txt

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.22.1)

# Declares and names the project.

project("demojni")

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

add_library( # Sets the name of the library.
             demojni

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             native-lib.cpp )

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
              log-lib

              # Specifies the name of the NDK library that
              # you want CMake to locate.
              log )

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
                       demojni

                       # Links the target library to the log library
                       # included in the NDK.
                       ${log-lib} )

4.3 运行结果

如果生成工程的时候有报错，按照如下解决（需要设置下JDK版本）
Android Studio Electric Eel提示Gradle插件报错问题的解决方法

四、参考

• Android NDK 简介及环境配置（一）
• NDK开发第一课：环境配置与第一个JNI程序
• AndroidStudio3.x开发调试Android-NDK的C++代码
• CMakeLists.txt 语法介绍与实例演练
• JNI 静态注册和动态注册
• 【NDK】聊聊NDK开发那些事