【Android NDK 开发】JNI 方法解析 ( JNIEnv *env 参数 )

I . JNI 方法解析

---

1 . JNI 方法定义 :

① 在 Android 的 Java 层定义方法 : 在 MainActivity 类中定义 如下 Native 方法 ;

public native String stringFromJNI();

② Native 方法实现 : 下面是一个 Native 方法实现的示例 ;

extern "C"
JNIEXPORT jstring JNICALL
Java_kim_hsl_jni_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {

    // 创建 C++ 字符串
    std::string hello = "Hello from C++";

    // 返回 jstring 类型的字符串
    return env->NewStringUTF(hello.c_str());
}

2 . 分析上述 JNI 方法 :

① extern “C” : 表示 C 语言 和 C++ 的兼容 ;

② JNIEXPORT jstring JNICALL : 这是两个宏定义 , 在 Linux 和 Windows 中分别有不同的表示 ; 其中的 jstring 表示返回值类型是 Java 中的 String 类型 ;

关于 JNIEXPORT 与 JNICALL 宏定义 , 参考下面的博客 :
【Android NDK 开发】JNIEXPORT 与 JNICALL 宏定义作用

③ JNIEnv *env : 其中第一个参数 JNIEnv *env 代表了 JNI 环境 ;

④ jobject 参数 : 该 Native 方法定义在 MainActivity 类中 ;

• 1> 非静态方法 : 如果该方法是非静态方法 , 那么 jobject 参数表示 MainActivity 类的对象 ;

• 2> 静态方法 : 如果该方法是静态方法 , 那么 jobject 参数表示 MainActivity.class ( Class 对象 ) ;

II . JNIEnv *env 参数解析

---

在 C 语言 和 C++ 中 , JNIEnv 代表着不同的含义 ;

1 . JNIEnv 类型声明 :

#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;
typedef const struct JNIInvokeInterface* JavaVM;
#endif

由上面的代码可知 , JNIEnv 是通过 typedef 将其它的类型定义为 JNIEnv 类型的 ;

__cplusplus 是 C++ 编译器中定义的宏 , C 语言编译器中没有定义该宏 , 通过该宏定义 , 可以区分当前是 C++ 环境还是 C语言环境 ;

#if defined(__cplusplus) 分支中声明的是 C++ 环境下的 JNIEnv 类型 ;

#else 分支中声明的是 C 语言环境下的 JNIEnv 类型 ;

2 . 两种 typedef 声明别名的含义

① C 语言别名 : C 语言中 将 JNINativeInterface 结构体指针 类型 声明为 JNIEnv 类型 ;

typedef const struct JNINativeInterface* JNIEnv;

② C ++ 别名 : C ++ 中 , 将 _JNIEnv 结构体类型声明为 JNIEnv 类型 ;

typedef _JNIEnv JNIEnv;

III . C 语言 环境中 JNIEnv *env 参数解析

---

1 . JNIEnv 类型 : C 语言环境中 , 系统将 JNINativeInterface* 类型 声明为 JNIEnv 别名 ;

2 . JNINativeInterface 结构体 : JNINativeInterface 是结构体类型 , 其中定义了 229 个函数指针 , 用于处理 Java 层 与 Native 层的数据交互信息 ;

3 . C 语言环境中 , 调用 JNINativeInterface 结构体中的函数指针 :

① 类型转换 : 给定的参数是 JNIEnv *env 类型的 , 即 JNINativeInterface ** env 类型 , 是一个 JNINativeInterface 结构体边来那个的二级指针 ;

② 通过 JNINativeInterface 指针调用 ( 推荐) : 首先要 解引用 ( *env ) , 该变量就变成了 JNINativeInterface 结构体变量的 一级指针 , 使用 -> 即可调用指定方法 , ( *env ) -> NewStringUTF( “Hello World !” );

③ 通过 JNINativeInterface 结构体调用 ( 不常用 ) : ( **env ).NewStringUTF( “Hello World !” ) , 相当于将上面的 -> 操作符变成 * . 操作符 ;

4 . JNINativeInterface 结构体部分代码示例 : 该结构体定义在 jni.h 头文件中 ;

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);

    jint        (*Throw)(JNIEnv*, jthrowable);
    jint        (*ThrowNew)(JNIEnv *, jclass, const char *);
    jthrowable  (*ExceptionOccurred)(JNIEnv*);
    void        (*ExceptionDescribe)(JNIEnv*);
    void        (*ExceptionClear)(JNIEnv*);
    void        (*FatalError)(JNIEnv*, const char*);
	
	...
	jstring     (*NewStringUTF)(JNIEnv*, const char*);
	...
};

JNINativeInterface 是结构体类型 , 其中定义了 229 个函数指针 , 用于处理 Java 层 与 Native 层的数据交互信息

IV . C ++ 环境中 JNIEnv *env 参数解析

---

1 . C++ 环境中 _JNIEnv 类型 : 在 C++ 中 , 将 _JNIEnv 结构体类型 通过 typedef 为其声明别名 JNIEnv ;

2 . _JNIEnv 结构体 : 该结构体中封装了一个 JNINativeInterface 结构体类型指针 , _JNIEnv 结构体中也封装了 229 个 方法 , 每个方法都调用 对应的 JNINativeInterface* functions 中的函数指针 ;

3 . C ++ 语言环境中 , 调用 _JNIEnv 结构体中的函数 :

① 类型转换 : 给定的参数是 JNIEnv *env 类型的 , 即 _JNIEnv * env 类型 ;

② 通过 _JNIEnv 指针调用 ( 推荐) : 直接使用 -> 符号访问该方法即可 , env-> NewStringUTF( “Hello World !” );

_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); }

    jclass FindClass(const char* name)
    { return functions->FindClass(this, name); }

    jmethodID FromReflectedMethod(jobject method)
    { return functions->FromReflectedMethod(this, method); }

    jfieldID FromReflectedField(jobject field)
    { return functions->FromReflectedField(this, field); }

    jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic)
    { return functions->ToReflectedMethod(this, cls, methodID, isStatic); }

    jclass GetSuperclass(jclass clazz)
    { return functions->GetSuperclass(this, clazz); }

    ...
    jstring NewStringUTF(const char* bytes)
    { return functions->NewStringUTF(this, bytes); }
	...
}