• JNI的介绍

    文章目录

    1. JNI

    1.1. JNI实现步骤

    JNI：全名 Java Native Interface，是Java本地接口，属于Java体系

    1. 在Java中声明Native方法（需要调用的本地方法）
    2. 通过javac编译java源文件（生成.class文件）
    3. 通过javah生成头文件（生成.h头文件）
    4. 通过Native语言实现Java中声明的Native方法
    5. 编译.so库文件
    6. 通过java执行Java程序，最终实现java调用native本地代码（借助.so文件）

    1.2 NDK

    NDK：Native Development Kit，本地开发工具包，属于Android体系

    快速开发 C/C++ 动态库，自动将.so和应用一起打包成apk

    1. 配置NDK环境（下载NDK、CMake、LLDB）
    2. 创建Android项目，选择（C++ support）
    3. 在Java代码中声明 native方法
    4. 使用c/c++实现native方法
    5. 通过 ndk-build编译产生.so库文件

    在AndroidStudio中查看ProjectStructure中的 sdk location，发现 android ndk location 无法手动选择，通过local.properties文件添加 ndk 路径，再去查看 sdk location 发现 ndk location 已经有显示

    sdk.dir=D\:\\Android\\SDK
// 添加这样的配置
ndk.dir=D\:\\Android\\SDK\\ndk-bundle

    • 1
    • 2
    • 3

    进入gradle.properties文件下，添加对旧版本 ndk 的支持

    // 对旧版本的 ndk 支持
android.useDeprecatedNdk=true

    • 1
    • 2

    1.3 CMakeList.txt

    为本地库做一些配置，包括版本、名称、日志库关联

    # 设置用来构建本地库的CMake最低版本
cmake_minimum_required(VERSION 3.18.1)
# 设置本地库名字、分享类型、本地库的路径
add_library(CPP SHARED src/main/cpp/native-lib.cpp)
# 定义一个路径变量，log-lib这个变量中的值就是Android中Log库的路径
find_library(log-lib log)
# 将本地库与日志库关联，这样就能在本地库中使用log库方法
target_link_libraries(CPP ${log-lib})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.4 HelloWorld

    通过 AndroidStudio 新建一个项目（CPlusPlusApp），选择最底部的 Native C++，一直 next 等待编译完成后，运行项目

    当然手动创建也是可以的

    1. 在 src\main 目录下新建 cpp目录

    2. 在 src\main\cpp 下新建 CMakeLists.txt，按照上面说的格式新建一份

    3. 在module下的 build.gradle 配置 externalNativeBuild

      android{
    externalNativeBuild {
        cmake {
            path file('src/main/cpp/CMakeLists.txt')
            version '3.18.1'
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

    4. 在应用中初始化库文件，并创建 native 方法，选择合适的地方调用该方法运行即可

      compaion object{
    init{
        // CMakeLists.txt中声明的库名称
        Syste.loadLibrary(libname:"cpp")
    }
}

// 创建完成后，编译器会自动提示需要在创建一个与之对应的 c++ 方法
external fun stringFromJni():String

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    5. 创建native-lib.cpp标准文件，上述定义的本地方法，可以按照编辑器提示，自动创建实现方法

      具体的实现方法遵循的方法名称是规定好的，可以参考以下例子

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    2. native-lib.cpp

    来分析分析这个cpp文件

    // src\main\cpp\native-lib.cpp
#inlcude <jni.h> // 定义了 jni 所支持的类型与接口
#inlcude <string>

extern "C"
JNIEXPORT jstring JNICALL// 这里的 jstring 类似于java中方法返回值，这里表示该c++方法返回的是字符串
Java_com_monk_cpp_ActMain_stringFromJni(JNIEnv *env, jobject thiz) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    其中JNIEXPORT jstring JNICALL语句，表示的c++函数的返回，其中jstring与java声明的native 方法是对应关系，这里也表面java中的对应函数返回的也是string

    2.1 调用java静态方法

    // src\main\java\com\monk\cpp\ActMain.kt 
override fun initData(savedInstanceState: Bundle?) {
        mBinding.test.text = "${stringFromJni()}\n" +
                "${callJavaStaticMethod()}\n"   
    }
 external fun callJavaStaticMethod(): String
 companion object {
        init {
            System.loadLibrary("cpp")
        }

        @JvmStatic
        fun staticMethod(cppStr: String): String {
            Toast.makeText(App.INSTANCE, "i am java static method: $cppStr", Toast.LENGTH_LONG).show()
            return "i am java static method: $cppStr"
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    对应的 c++ 函数

    // src\main\cpp\nativ-lib.cpp
// 演示 c++ 调用 java 静态方法
extern "C"
JNIEXPORT jstring JNICALL
Java_com_monk_cpp_ActMain_callJavaStaticMethod(JNIEnv *env, jobject thiz) {
    // 找到对应的类
    jclass cls_main = env->FindClass("com/monk/cpp/ActMain");
    // 获取methodId,kotlin需要@JvmStatic才能识别，最后一个参数是字节码中的显示，例如String的字节码为：(Ljava/lang/string;)V
    jmethodID method_static_id = env->GetStaticMethodID(cls_main, "staticMethod", "(Ljava/lang/String;)Ljava/lang/String;");
    // 构建String 变量
    jstring str = env->NewStringUTF("来自c++的字符串");
    // 调用java的static方法
    env->CallStaticObjectMethod(cls_main, method_static_id, str);
    //释放
    env->DeleteLocalRef(cls_main);
//    env->DeleteLocalRef(str);
    return str;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    c++如何调用 java 静态方法，使用GetStaticMethodID函数获取java的静态方法，使用CallStaticObjectMethod调用java静态方法

    img

    2.2 调用java实例方法

    // src\main\java\com\monk\cpp\ActMain.kt 
override fun initData(savedInstanceState: Bundle?) {
    mBinding.test.text = "${stringFromJni()}\n" +
    "${callJavaStaticMethod()}\n"+
    "${callJavaMethod("monk", 24)}\n"
}
external fun callJavaMethod(name: String, age: Int): Any

// src\main\java\com\monk\cpp\JavaBean.kt 
data class JavaBean(val name: String, val age: Int){
    override fun toString(): String {
        return "JavaBean(name='$name', age=$age)"
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    对应的 c++ 代码

    // src\main\cpp\native-lib.cpp
extern "C"
JNIEXPORT jobject JNICALL
Java_com_monk_cpp_ActMain_callJavaMethod(JNIEnv *env, jobject thiz,jstring name, jint age) {
    jclass java_bean = env->FindClass("com/monk/cpp/JavaBean");
    // 获取构造方法
    jmethodID init = env->GetMethodID(java_bean, "", "(Ljava/lang/String;I)V");
    // 调用构造方法
    jobject bean = env->NewObject(java_bean, init, name, age);
    //获取 toString 方法
    jmethodID to_string = env->GetMethodID(java_bean, "toString", "()Ljava/lang/String;");
    // 调用toString 方法
    jobject result = env->CallObjectMethod(bean, to_string);
    // 回收
    env->DeleteLocalRef(java_bean);
//    env->DeleteLocalRef(to_string);
    return result;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    img

    2.3 创建引用

    引用上面例子中进行解释

    // src\main\cpp\native-lib.cpp
extern "C"
JNIEXPORT jobject JNICALL
Java_com_monk_cpp_ActMain_callJavaMethod(JNIEnv *env, jobject thiz,jstring name, jint age) {
    ...
    // 调用toString 方法，这里使用一个 jobjcet 创建一个局部引用
    jobject result = env->CallObjectMethod(bean, to_string);
   	
    return result;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    当然也可以将局部引用转成全局引用，在成员中声明即可

    3. CMake

    CMake 是一个跨平台的安装（编译）工具，可以用简单的语句来描述所有平台的安装(编译过程)。

    以前做 NDK 开发都是基于 Android.mk、Application.mk 来构建项目的，但从 AS 2.2 之后便开始采用CMake 的这种方式来构建，采用 CMake 相比与之前的 Android.mk、Application.mk 方便简单了许多

    具体语法不过多涉及

  • 相关阅读:
    Leetcode刷题解析——最大连续1的个数
    摸鱼神器老板告警
    SonarQube代码质量检查平台
    Linux基本常用命令大全（附案例实战）
    动态库.lib与.dll关系、visual studio工程库路径配置浅析
    Three.js入门学习笔记
    算法分析与设计 | 递归（数的计数）
    醒悟的日子，我是怎么一步一步走向软件测试的道路
    数据结构 - 顺序表
    LNMP环境部署（CentOS7）
  • 原文地址：https://blog.csdn.net/qq_37776700/article/details/127841216