音视频学习之路--JNI全面解析

前言

复习完C和C++的基础就可以来进行NDK相关的开发了,也就是又回到Java,但是用Java来调用C/C++。

所以本章先仔细学习一下JNI,在很久之前我做过有关JNI的开发,但是比较少,没有深入过,所以本篇文章就先介绍一下JNI。

在文章正式开始之前,先给大家分享一个B站上非常不错的视频教程,该视频教程从基础知识讲解再到直播推流实战,非常全面讲的也很细致,大家可以去看看。
音视频开发全系列教程:https://www.bilibili.com/video/BV1fb4y1d7JU?spm_id_from=333.999.0.0

正文

对于Java来说,因为是需要JVM来运行,所以性能上肯定没有C/C++这种语言高,所以Android就弥补了这个缺陷,使用了JNI特征,使用JNI可以让Java类的某些方法用原生实现,让调用原生(C/C++)方法能够像普通Java方法一样。

环境配置

这里我们就可以使用Android studio了,AS的配置就不用多说了,Android开发都十分熟悉,这里只需要在SDK Tools中勾选几个即可:

这里还是简单介绍一下子:

  • NDK,Native Development Kit,是一个开发工具包,作用就是快速开发C/C++,并自动将so和应用一起打包成APK。
  • JNI,Java Native Interface,通过JNIJava能调用C++。
  • CMake,运行开发者编写一种和平台无关的CMakeList.txt文件来定制整个编译流程,就是一种编译脚本。

既然这个txt是编译脚本,所以在app的gradle中需要把这个脚本加上即可:

这里的JNI项目可以直接在创建Android项目时选择C++即可生成一个native项目。

Hello World

还是传统,先来搞一个Hello World,Android studio默认创建的native项目,运行即是一个Hello World,这里看一下基本代码:

class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding

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

        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // Example of a call to a native method
        binding.sampleText.text = stringFromJNI()
    }

    /**
     * A native method that is implemented by the 'jnistudy' native library,
     * which is packaged with this application.
     */
    external fun stringFromJNI(): String

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

这里使用external就定义了一个native方法,然后再看一下这个native方法的实现:

#include 
#include 

using namespace std;

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

会发现虽然这只有几行代码,但是看起来还是有点晦涩,下面来单独分析一波。

extern "C"

看到这行代码,就有点不熟悉,下面是extern "C"的简单描述和使用:

其实这个还挺麻烦的,主要就是告诉编译器在C++代码中的C代码要使用C的编译方式来编译,不然源C代码定义的地方生成的文件和C++中编译的代码对不上。

比如上面的代码,应该就是那一行代码需要使用C来编译,而不能使用C++。

JNIEXPORT和JNICALL

虽然我们复习过C++文件,但是一看这个还是有点懵,虽然知道这2个是在头文件里define的,但是具体啥用呢?

  • JNIEXPORT在头文件中的定义:
#define JNIEXPORT  __attribute__ ((visibility ("default")))

Windows中需要生成动态库,并且需要将动态库交给其他项目使用,需要在方法前加入特殊标识,才能在外部程序代码中,调用该DLL动态库中定义的方法。

  • JNICALL在头文件中是个空定义:
#define JNICALL

这个就不说了,主要是在Windows系统中对函数参数的一种约定。

所以这里的代码就是返回一个jstring类型,通过JNIEXPORT来标识这个生成的库可以被别的程序调用,JNICALL暂时无用。

JNI类型--基本数据类型

再回顾一下刚刚的C++代码:

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

这里有个很奇怪的类型,就是这个jstring,这个是啥意思呢? 在Java代码中,我们肯定想要的是String类型,但是C++中只有string类型,那如何来进行一一对应呢,所以这里就有了JNI类型的概念。

对于Java那几种基本类型都好解决,就在Java基本类型前面加个j,就认为是JNI类型,比如Java中的boolean类型,就对应jboolean类型,那jboolean类型对应的就是C/C++的unsigned char类型,所以这里只要定义死,那基本类型转换在C和C++中就没啥问题了。

下面是jni.h中的定义:

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 */

其中这里的uint8_t等类型也是一个别名,最后都是对应着C/C++的基础类型:

typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;

所以啊,在C++函数中返回的是jboolean,其实就是返回的无符号8位整型,然后通过NDK的操作,这个jboolean就能返回到Java代码中是一个boolean类型。

JNI类型--引用数据类型

其实和基本类型一样,当Java代码需要某种类型时,这时只要通过NDK库的定义和C/C++约定好即可,不过与基本数据类型不同的是,引用类型在原生方法时是不透明的,也就是具体这个jxx类型对应的C/C++类型是啥是不知道,可以看代码:

typedef _jobject*       jobject;   //对应Java的Other object
typedef _jclass*        jclass;    //对应Java的java.lang.Class
typedef _jstring*       jstring;   //对应Java的Java.lang.String
typedef _jarray*        jarray;    //对应Java的Other array
typedef _jobjectArray*  jobjectArray;    //Object[]
typedef _jbooleanArray* jbooleanArray;   //boolean[]
typedef _jbyteArray*    jbyteArray;      //byte[]
typedef _jcharArray*    jcharArray;      //char[]
typedef _jshortArray*   jshortArray;     //short[]
typedef _jintArray*     jintArray;       //int[]
typedef _jlongArray*    jlongArray;      //long[]
typedef _jfloatArray*   jfloatArray;     //float[]
typedef _jdoubleArray*  jdoubleArray;    //double[]
typedef _jthrowable*    jthrowable;      //Java.lang.Throwable

这里对几种数组和string、throwable、class都做了特殊标识处理,但是对于具体的类型我们就哟个object的话那肯定不行,比如Java代码想返回一个Book类型,在C/C++代码中给我随便返回的jobject这肯定不行,所以下面继续看JNI类型的知识。

JNI类型--数据类型描述符

在前面我们说了问题,比如我想在C/C++代码中使用Java定义的一个类,肯定不能直接导包啥的,因为这就不能互通,但是当Java代码运行在JVM虚拟机中时,我们就可以根据JVM中保存的类的类型,来通过C/C++中有个findClass函数来找到这个类,然后创建这个类的对象,所以在JVM中数据类型是如何保存的很重要,这里不是使用我们定义的int、float这种。

看到这里就比较疑惑了,这到底是个啥,Java的所有类型都在这里的了但是这里我们还必须要能搞清楚,因为这个东西在后面C/C++代码中需要用到,那你就会问,比如我定义一个Book类,那需要凭空写这些描述符吗,当然不是。

比如有代码如下:

package com.zyh.jnistudy

data class Book(val author: String
    ,val name: String
    ,val price:Float)

点击build,在生成的class文件中,打开命令行界面,

输入javap -s xxx,然后查看:

复制出来,对于kotlin的数据类自动包含的方法熟悉Android开发的都知道,我们这里来简单分析一下子:

public final class com.zyh.jnistudy.Book {
    //构造函数 这里的构造函数返回值居然是V,也就是void
    //多个参数中间是没有分隔符的,这里的;是其他引用类型
  public com.zyh.jnistudy.Book(java.lang.String, java.lang.String, float);
    descriptor: (Ljava/lang/String;Ljava/lang/String;F)V

    //无参函数返回String
  public final java.lang.String getAuthor();
    descriptor: ()Ljava/lang/String;
    
    //无参函数返回String
  public final java.lang.String getName();
    descriptor: ()Ljava/lang/String;

//无参函数返回float
  public final float getPrice();
    descriptor: ()F

    //获取第一个成员变量
  public final java.lang.String component1();
    descriptor: ()Ljava/lang/String;

  public final java.lang.String component2();
    descriptor: ()Ljava/lang/String;

  public final float component3();
    descriptor: ()F

    //返回Book自己
  public final com.zyh.jnistudy.Book copy(java.lang.String, java.lang.String, float);
    descriptor: (Ljava/lang/String;Ljava/lang/String;F)Lcom/zyh/jnistudy/Book;

  public java.lang.String toString();
    descriptor: ()Ljava/lang/String;
    
    //返回int
  public int hashCode();
    descriptor: ()I

    //返回boolean
  public boolean equals(java.lang.Object);
    descriptor: (Ljava/lang/Object;)Z
}

通过上面注释我们能看出来所有方法的描述符,其实就是别扭而已,没啥东西,但是我个人认为还是需要注意几点:

  • 方法多个参数时,中间是没有分隔符的
  • 引用类型是 LXXX; 这里的 ; 不要忘了
  • 引用类型 LXXX; 的XXX具体值是通过 / 连接,而不是Java中的 . ,比如java.lang.String变成 了java/lang/String

JNIEnv

这个是啥呢 我们会发现在生成C++函数里第一个参数就是这个,官方说明是JNIEnv标识Java调用native语言的环境,是一个封装了几乎全部JNI方法的指针。

那为什么要这个指针呢 比如看下面代码:

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

这里我需要返回的是jstring类型,那我直接返回一个字符串类型可以吗,把代码改成下面这种:

很显然是不可以的,所以这个JNIEnv最直接的用处就是根据函数返回值返回特定的JNI类型返回值。

还有一个特性就是JNIEnv只在创建它的线程中生效,不能跨线程传递,不同线程的JNIEnv独立,为什么是这种,我们也不得知道其原理,等后续再探究。

那直接来看一下这个JNIEnv的结构体:

typedef _JNIEnv JNIEnv;

这里是_JNIEnv结构体

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); }
    
    //这里有大概600多行

在这个_JNIEnv大概有6 700行代码,定义了我们常见的返回类型,最最主要的是返回类型都是JNI类型,所以我们目的是达到了,但是会发现其实这里都是用的JNINativeInterface这个类型的指针来完成这一大堆函数实现的,来看一下这个定义:

struct JNINativeInterface {
    void*       reserved0;
    void*       reserved1;
    void*       reserved2;
    void*       reserved3;

    jint        (*GetVersion)(JNIEnv *);

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

    jmethodID   (*FromReflectedMethod)(JNIEnv*, jobject);
    jfieldID    (*FromReflectedField)(JNIEnv*, jobject);
    /* spec doesn't show jboolean parameter */
    jobject     (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean);

    jclass      (*GetSuperclass)(JNIEnv*, jclass);
    jboolean    (*IsAssignableFrom)(JNIEnv*, jclass, jclass);

    /* spec doesn't show jboolean parameter */
    jobject     (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean);
    
    //省略几百行

这是啥,这就是著名的函数指针,那关于具体咋实现的,我们这里就不用管了,这里也没有给出实现的地方,就记住一句话即可,想要返回JNI类型就必须通过这个JNIEnv指针来完成。

JNI处理Java传递过来的基本数据类型

这里就是JNI的关键之处了,C/C++代码能够处理Java传递过来的参数,先从简单的说,看一下基本数据类型,直接在Java代码中定义一个函数,包含所有基本数据类型:

external fun testAll(b: Boolean
                     ,b1: Byte
                     ,c: Char
                     ,s: Short
                     ,l: Long
                     ,f: Float
                     ,d: Double)

然后在C++代码中:

extern "C"
JNIEXPORT void JNICALL
Java_com_zyh_jnistudy_MainActivity_testAll(JNIEnv *env
                                           , jobject thiz
                                           , jboolean b
                                           , jbyte b1
                                           , jchar c,
                                           jshort s
                                           , jlong l
                                           , jfloat f
                                           , jdouble d) {

    //接收boolean类型值
    unsigned char c_boolean = b;
    LOGD("boolean -> %d",c_boolean)
    //接收byte类型值
    signed char c_byte = b1;
    LOGD("byte -> %d",c_byte)
    //接收char类型值
    unsigned short c_char = c;
    LOGD("char -> %d",c_char)
    //接收short类型值
    short c_short = s;
    LOGD("short -> %d",c_short)
    //接收long类型值
    long long c_long = l;
    LOGD("long -> %lld",c_long)
    //接收float类型值
    float c_float = f;
    LOGD("float -> %f",c_float)
    //接收double类型值
    double c_double = d;
    LOGD("double -> %f",c_double)
}

这里其实没啥说的,如果记不住这些JNI类型对应的C/C++类型一点也不用怕,直接点击JNI类型就能找到对应的C/C++类型。

这里学个知识点是这个LOG的打印格式,之前都是使用printf或者cout,对于TAG查找很不方便,定义如下:

//导入Android的log包
#include 
//定义TAG
#define TAG "native-lib"
//这里的...代表多参数
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,TAG,__VA_ARGS__);

再来看一下这个log的定义:

int __android_log_print(int prio, const char* tag, const char* fmt, ...)

这里会发现第三个参数开始就是字符串和多参数,所以上面那个__VA_ARGS__代表多个参数,这种写法很巧妙,但是这里的LOGD和Android的一样,只能是一个字符串。

上面代码打印如下:

对于基本数据类型是可以正常解析的。

JNI处理Java传递过来的引用数据类型

对于基本数据类型还是很easy的,所以现在来看一下引用数据类型,先看数组,数组我们可以大概分为基本数据类型的数组和自定义类型的数组,比如下面代码:

external fun testAll2(intArray: IntArray
                      ,stringArray: Array
                      ,string: String
                      ,book: Book
                      ,bookList: ArrayList)

基本类型数组

这里先看一下intArray,在C++文件中的解析:

extern "C"
JNIEXPORT void JNICALL
Java_com_zyh_jnistudy_MainActivity_testAll2(JNIEnv *env
                                            , jobject thiz
                                            , jintArray int_array
                                            , jobjectArray string_array
                                            , jstring string
                                            , jobject book,
                                            jobject book_list) {

    //解析int数组 引用类型前面也说了,没有直接对应的基本数据类型,被隐藏起来了
    jint *intArray = env->GetIntArrayElements(int_array,NULL);
    //拿到数组长度
    jsize intArraySize = env->GetArrayLength(int_array);
    for (int i = 0; i < intArraySize; ++i) {
        LOGD("int数组是 -> %d",intArray[i]);
    }
    //释放数组
    env->ReleaseIntArrayElements(int_array,intArray,0);
}

这里在前面也说了,对于非基本类型的JNI类型是被隐藏实现的,所以必须要使用JNIEnv来获取,关于处理XXX类型的数组,这里也是有迹可循,也就是上面的3步,不同类型对应不同的API,大概总结如下:

string数组

其实处理基本类型数组也非常的简单,接着看一下处理这个String数组,直接看一下代码:

//解析string数组,这里会发现类型是jobjectArray了,不是具体类型了
//这里就不能按照前面的步骤来了,因为可以想一下,这个类型不固定,所以不存在jobject指针来指出数组
//jobject *stringArray = env->GetObjectArrayElement(string_array,NULL);
jsize stringArraySize = env->GetArrayLength(string_array);
for (int i = 0; i < stringArraySize; ++i) {
    jobject jobject1 = env->GetObjectArrayElement(string_array,i);
    //强转
    jstring stringArrayData = static_cast(jobject1);
    //把jstring转成C/C++类型
    const char *stringData = env->GetStringUTFChars(stringArrayData, NULL);
    LOGD("string数组值是 -> %s",stringArrayData)
    env->ReleaseStringUTFChars(stringArrayData,stringData);
}

从上面的方法参数我们看见是jobjectArray类型,而不是预期的jstringArray类型当然也没有,从我们学习Java的角度来说,jobject是基类,肯定不能直接返回一个object数组,不符合正常思路,所以这里先获取数组长度进行遍历。

拿到一个jobect后,对于常理来说,肯定要转成一个具体的JNI类型,所以这里先转成了jstring,再由jstring转成了C/C++的字符串类型。

看个简单总结:

其他非数组引用数据类型

其实在前面我们说Java方法描述符时就说了一个概念,也就是方法签名,同时在JNI库中只有findClass方法来获取jclass文件,所以我们就可以通过这个来解析自定义数据类型:

//解析自定义类
//先获取字节码
char *book_class_str = "com/zyh/jnistudy/Book";
//通过类签名 获取jni的jclass
jclass book_class = env->FindClass(book_class_str);
//拿到方法签名 先是获取作者的方法
char *book_getAuthor_sign = "()Ljava/lang/String;";
//根据签名获取方法jmethod
jmethodID getAuthor = env->GetMethodID(book_class,"getAuthor", "()Ljava/lang/String;");
//调用方法 返回jobject
jobject obj_author = env->CallObjectMethod(book,getAuthor);
//老办法 jobject强转为jstring
jstring string_author = static_cast(obj_author);
//根据jstring 获取C/C++字符串
const char *author = env->GetStringUTFChars(string_author,NULL);
LOGD("book的数组是 -> %s",author);
env->DeleteLocalRef(book_class);
env->DeleteLocalRef(book);

其实通过上面注释我们也可以看出基本规律了,对于引用类型都是先找到这个引用类型的签名,也就是包名+类名,使用 / 连接,然后通过findClass获取jclass,拿到jclass后就好做了,通过方法签名调用jclass中的方法,得到我们想要的返回值即可。最后不能忘记了删除本地变量。

JNI返回Java对象

上面一小节我们分析了Java传递各种类型到C++来处理,其实捋一下还是很简单的,主要就是分为2类,基本数据类型和引用数据类型,引用数据类型分为数组类型和非数组类型,上面都有介绍。那现在来讨论一下JNI也就是C/C++返回数据给Java使用,对于基本数据类型没啥说的了,这里说一下引用数据类型。

首先还是在Java代码中定义函数返回Book:

//JNI返回Book对象
external fun getBook():Book

然后在C/C++代码中就有对象的方法了,直接看下面实现,都有注释也非常好理解:

extern "C"
JNIEXPORT jobject JNICALL
Java_com_zyh_jnistudy_MainActivity_getBook(JNIEnv *env, jobject thiz) {

    //这里返回jobject对象
    //先拿到Java类的全路径
    char *book_java = "com/zyh/jnistudy/Book";
    //找到Java对象class
    jclass book_class = env->FindClass(book_java);
    //拿到构造方法,这里必须这样写
    //char *method = "";
    //拿到构造方法
    jmethodID construcotr_methor = env->GetMethodID(book_class,"", "(Ljava/lang/String;Ljava/lang/String;F)V");
    //创建对象
    jstring author = env->NewStringUTF("guo");
    jstring name = env->NewStringUTF("第一行代码");
    jfloat price = 55;
    jobject book_obj = env->NewObject(book_class,construcotr_methor
                                      ,name
                                      ,author
                                      ,price);
    return book_obj;
}

这里可以看到返回一个book对象,对于这几行代码还是可以总结一下:

  • 当需要返回基本数据类型时就不用说了,都是jint等,和C/C++都有对象,直接返回即可。

  • 对于返回string类型,这里JNI有个特殊处理,就是NewStringUTF函数,使用这个也是可以返回String类型。

  • 对于基本数据的数组,JNI中有NewXXXArray的函数,用来返回基本类型数组。

  • 对于其他引用类型,有newObject函数可以创建对象。这里也分为下面几步:

  1. 先拿到类型的全路径,通过findClass函数得到class对象。
  2. 构造函数一定是,然后传入签名。
  3. 调用构造函数,这里IDE会自动生成,然后多参数按构造函数顺序传入即可。

JNI动态注册和静态注册

对于JNI有2种注册方式,分别是静态注册和动态注册,在Android studio自己创建native项目,这个属于静态注册,而还有一种动态注册的方式。

静态注册

在cpp文件中的静态注册方法是:

从这个名字我们就可以看出,这个方法是MainActivity1这个类中注册的,所以问题就是当包名或者类名改了之后,这个方法名也需要改,所以比较麻烦。

动态注册

对于动态注册就稍微复杂点,但是逻辑很清晰。

首先我们得明白一点,就是不管是动态注册还是静态注册,在Java文件中是不变的,就是必须得声明本地方法已经加载so,也就是下面代码必不可少:

//JNI返回Book对象
external fun getBook():Book

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

然后呢,想一下如何动态注册,顾名思义就是C++文件中的名字就不会和静态注册一样和Java类名想关联的,也就是独立开来了,代码如下:

extern "C"
JNIEXPORT jobject JNICALL
getBook(JNIEnv *env, jobject thiz) {

    //这里返回jobject对象
    //先拿到Java类的全路径
    char *book_java = "com/zyh/jnistudy/Book";
    //找到Java对象class
    jclass book_class = env->FindClass(book_java);
    //拿到构造方法,这里必须这样写
    //char *method = "";
    //拿到构造方法
    jmethodID construcotr_methor = env->GetMethodID(book_class,"", "(Ljava/lang/String;Ljava/lang/String;F)V");
    //创建对象
    jstring author = env->NewStringUTF("guo");
    jstring name = env->NewStringUTF("第一行代码");
    jfloat price = 55;
    jobject book_obj = env->NewObject(book_class,construcotr_methor
                                      ,author
                                      ,name
                                      ,price);
    return book_obj;
}

然后呢,就要注册关系了,也就是对应关系,Java中定义的方法名 <-> C/C++中定义的方法名,这里也就需要一个JNINativeMethod类型的数组来构建这一关联关系:

const char *classPath = "com/zyh/jnistudy/MainActivity1";
//这里是个数组,而类型是JNINativeMethod类型
static const JNINativeMethod jniNativeMethod[] = {
        {
            "getBook"
            ,"()Lcom/zyh/jnistudy/Book;"
            ,(void *)(getBook)
        }
};

然后既然有了对应关系,那就需要把这个关系注册到JNI系统中即可,这里就会有一个回调方法,叫做JNI_OnLoad,通过这个方法就可以把这个关系给注册到JNI中:

JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved){
    //这里可以创建新的JNIEnv
    JNIEnv *jniEnv = nullptr;
    jint result = vm->GetEnv(reinterpret_cast(&jniEnv),JNI_VERSION_1_6);
    if (result != JNI_OK){
        return JNI_ERR;
    }
    jclass mainActivityClass = jniEnv->FindClass(classPath);
    jniEnv->RegisterNatives(mainActivityClass
                            ,jniNativeMethod
            ,sizeof (jniNativeMethod) / sizeof (JNINativeMethod));
    return JNI_VERSION_1_6;
}

其中前几行代码是写死的哈,主要就是调用RegisterNatives函数即可,但是这个函数第一个参数是Java类的Class文件,所以当有多个类都需要动态注册,就需要多次调用RegisterNatives方法即可,然后不要忘了也要定义多个该类中的本地方法影视关系数组。

JNI的异常处理

关于Java的异常处理大家都很熟悉了,当出现异常时,JVM会停止该代码的执行,然后看你try catch代码块中有没有捕获该异常的代码,然后进行处理异常。

不过在C/C++代码就不一样了,因为在Java中调用原生代码,原生代码不是执行在JVM中,所以这时发生了异常,C/C++代码不会停止,所以就需要在JNI即C/C++代码中也可以捕获异常和处理异常。

下面我们写个例子,在Java中定义一个方法,会抛出异常,然后在C++中调用,然后捕获异常:

//JNI返回Book对象 在getBook中会发生Java异常
external fun getBook():Book

fun testException(){
    throw NullPointerException("testException函数发生了空指针异常")
}

然后在getBook的C++方法里调用这个会抛出异常的函数,具体如何调用也是非常简单,找到class,找到方法:

extern "C"
JNIEXPORT jobject JNICALL
getBook(JNIEnv *env, jobject thiz) {
    //这里的thiz其实就是注册的MainActivity
    jclass clazz = env->GetObjectClass(thiz);
    //方法
    jmethodID testEx = env->GetMethodID(clazz,"testException","()V");
    //调用Java方法
    env->CallVoidMethod(thiz,testEx);
    //判断是否发生异常
    jthrowable exc = env->ExceptionOccurred();
    if (exc){
        env->ExceptionDescribe();
        env->ExceptionClear();
        jclass newExcCls = env->FindClass("java/lang/IllegalArgumentException");
//        env->ThrowNew(newExcCls,"JNI返回了一个异常");
    }

    //这里返回jobject对象
    //先拿到Java类的全路径
    char *book_java = "com/zyh/jnistudy/Book";
    //找到Java对象class
    jclass book_class = env->FindClass(book_java);
    //拿到构造方法,这里必须这样写
    //char *method = "";
    //拿到构造方法
    jmethodID construcotr_methor = env->GetMethodID(book_class,"", "(Ljava/lang/String;Ljava/lang/String;F)V");
    //创建对象
    jstring author = env->NewStringUTF("guo");
    jstring name = env->NewStringUTF("第一行代码");
    jfloat price = 55;
    jobject book_obj = env->NewObject(book_class,construcotr_methor
                                      ,author
                                      ,name
                                      ,price);
    return book_obj;
}

上面C++代码中关于异常的其实就3个函数:

  • ExceptionOccurred:有没有异常发生

  • ExceptionDescirbe:异常的描述信息

  • ExceptionClear: 清除异常

由于在C/C++代码中对Java的异常不是自动捕获和处理的,所以需要显示的手动判断进行处理,这样处理的话Java代码中虽然会抛出异常,但不会终止程序运行了。

总结

其实关于JNI还有许多东西要说,比如JNI的线程操作、JNI的布局引用、全局引用等,这些知识点等后续具体项目中有用到再说,本章就介绍一些JNI的通用知识。

本文转自 https://juejin.cn/post/7022875228690710565,如有侵权,请联系删除。

你可能感兴趣的:(音视频学习之路--JNI全面解析)