JNI

JNI是Java Native Interface的缩写，通过使用 Java本地接口书写程序，可以确保代码在不同的平台上方便移植。

从Java1.1开始，JNI标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他编程语言，只要调用约定受支持就可以了。

使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的。

JNI的接口就是一些函数的API

JNI接口

Java语言发展到现在已经经历了20多年，其语言框架本身已经非常成熟，而且整个生态都保持得非常好，因而再与底层的C、甚至汇编进行辅助的话，那就能释放出更强大的威力来。而Java要与本地底层代码进行交互，则需要通过JNI(Java Native Interface)接口

JNI作用

JN接口是处在Java层和C/C++层之间，承担桥梁作用

1、通过JN接口实现Java层与 Native层相互调用
2、JNI接口中的类型

1、调用java层普通方法-CallObjectMethod
2、获取Java层实例字段的值-GetMethodID
3、获取Java层实例字段的值
4、设置Java层实例字段的值
5、调用Java层静态方法
6、获取Java层静态字段的值
7、设置Java层静态宇段的值
8、New开头的函数就是创建

get 获取
set 设置
call 调用

CallObjectMethod

调用一个方法，返回值是 Object

void是表示返回值为空！所以使用的方法就是构建参数后面三个参数

JNIEnv*

默认参数
动态调试经常用到，本地调用的一个接口，提供了大量的jni接口函数去调用
可以理解为JNI默认传入的参数型

jobject

也是默认参数

jmethodID

CallObjectMethod运行操作时的一个方法ID，用来获取java层方法的ID

在这之前 要先使用，使用GetMethodID方法获取方法ID，作为返回值

GetMethodID

它是获取Java层实例字段的值GetMethodID

jmethodID (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);

1、JNIEnv：默认参数！
2）jclass：一个 findclass引用
这里的返回值和jclass目的是一样的，jclass这个参数是由findclass返回值获取的

3、const char*：参数列表信息3）const char:Java层方法的名称
4、const char*：Java层方法的一个签名，是返回值+参数

获取Java层实例字段的值

jobject (*GetObjectField)(JNIEnv*, jobject, jfieldID);

获取jfieldID的获取

jfieldID (*GetFieldID)(JNIEnv*, jclass, const char*, const char*);

设置Java层实例字段的值

void (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject);

jfeldID是 GetFieldID的返回值！
jobject是一个java层实例字段设置的值！

NDK

Eclipse快速创建项目

这个 我们之前 有提到过

这里就快速过

静态注册(一)

在Java层使用jni接口获取C层定义的一个字符

定位MainActivity.java

上一节安卓学习思路方法总结（四）讲到JNI和c的联动

创建JNI的文件夹

然后三个文件：aaa.c、Application.mk、Android.mk

然后在JNI目录下进行：ndk-build编译

继续

这一块时安卓 后期界面的显示

先删掉

定义一个方法

public native CharSequence Getstring();

在java层使用JDG反编译的时候是看不到它的逻辑代码，只能看到空荡荡的一个方法名，而且这个方法的具体实现在java层是看不到的

掌握ndk开发的知识，在so程序找到它对应的一个.so文件，然后去分析它的一个逻辑

区分动态注册！

动态注册会使用到JNI_onload类里面有个注册函数；

这里已经定义了一个被native修饰的方法，那么修饰这个方法就要做一些操作，在java层用 Toast展示出来

Toast.makeTest(context,text,duration);

context:上下文text:弹出的内容字符duration:显示的一个时长

然后进行修改

context->this上下文text->方法Getstring()duration->Toast.LENGTH_SHORT

进行显示

.show()

Toast.makeText(this,Getstring(),Toast.LENGTH_SHORT).show();

获取src目录

D:\data\aaa\src

获取完整路径

被native修饰的一个方法 Getstring()所在的一个类的完整的路径

com.example.aaa.MainActivity

javah

使用javah命令

我们底层调用的头文件.h就是JNI样式的标头文件

javah -jni com.example.aaa.MainActivity

Refresh

在src目录生成.h的头文件

进行分析

JNIEXPORT->标识符jobject ->返回值JNICALL->标识符

万能表

#ifndef JNI_H_
#define JNI_H_
#include <sys/cdefs.h>
#include <stdarg.h>
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>  /* C99 */
//这个是JNI规范中定义的基本数据类型
//typedef 关键字，可以使用它来为类型取一个新的名字。
//举个例子：typedef unsigned char BYTE;在这个类型定义之后，标识符 BYTE 可作为类型 unsigned char 的缩写
typedef uint8_t jboolean;   /* unsigned 8 bits */
typedef int8_t  jbyte;  /* signed 8 bits */
typedef uint16_tjchar;  /* 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 */
#else
typedef unsigned char   jboolean;   /* unsigned 8 bits */
typedef signed char jbyte;  /* signed 8 bits */
typedef unsigned short  jchar;  /* unsigned 16 bits */
typedef short   jshort; /* signed 16 bits */
typedef int jint;   /* signed 32 bits */
typedef long long   jlong;  /* signed 64 bits */
typedef float   jfloat; /* 32-bit IEEE 754 */
typedef double  jdouble;/* 64-bit IEEE 754 */
#endif
/* "cardinal indices and sizes" */
typedef jintjsize;  //表示返回数组的大小
#ifdef __cplusplus
/*
 * Reference types, in C++  //与C++有关的定义
 */
class _jobject {};
class _jclass : public _jobject {};
class _jstring : public _jobject {};
class _jarray : public _jobject {};
class _jobjectArray : public _jarray {};
class _jbooleanArray : public _jarray {};
class _jbyteArray : public _jarray {};
class _jcharArray : public _jarray {};
class _jshortArray : public _jarray {};
class _jintArray : public _jarray {};
class _jlongArray : public _jarray {};
class _jfloatArray : public _jarray {};
class _jdoubleArray : public _jarray {};
class _jthrowable : public _jobject {};
//为C++的一些类型进行重新定义
typedef _jobject*   jobject;
typedef _jclass*jclass;
typedef _jstring*   jstring;
typedef _jarray*jarray;
typedef _jobjectArray*  jobjectArray;
typedef _jbooleanArray* jbooleanArray;
typedef _jbyteArray*jbyteArray;
typedef _jcharArray*jcharArray;
typedef _jshortArray*   jshortArray;
typedef _jintArray* jintArray;
typedef _jlongArray*jlongArray;
typedef _jfloatArray*   jfloatArray;
typedef _jdoubleArray*  jdoubleArray;
typedef _jthrowable*jthrowable;
typedef _jobject*   jweak;
#else /* not __cplusplus */
/*
 * Reference types, in C.   //与C有关的，继续为类型起新的名字；有arrary表示按JNI 标准定义的数组类型
 */ 
typedef void*   jobject;
typedef jobject jclass;
typedef jobject jstring;
typedef jobject jarray;
typedef jarray  jobjectArray;
typedef jarray  jbooleanArray;
typedef jarray  jbyteArray;
typedef jarray  jcharArray;
typedef jarray  jshortArray;
typedef jarray  jintArray;
typedef jarray  jlongArray;
typedef jarray  jfloatArray;
typedef jarray  jdoubleArray;
typedef jobject jthrowable;
typedef jobject jweak;
#endif /* not __cplusplus */
//两个方法ID和字段ID
struct _jfieldID;   /* opaque structure */
typedef struct _jfieldID* jfieldID; /* field IDs */
struct _jmethodID;  /* opaque structure */
typedef struct _jmethodID* jmethodID;   /* method IDs */
//定义一个结构体JNIInvokeInterface，是一个调用接口的结构体
struct JNIInvokeInterface; 
//定义一个联合体jvalue，里面有各种类型
typedef union jvalue {
jbooleanz;
jbyte   b;
jchar   c;
jshort  s;
jinti;
jlong   j;
jfloat  f;
jdouble d;
jobject l;
} jvalue;
//定义一个枚举jobjectRefType，里面有各种枚举元素
typedef enum jobjectRefType {
JNIInvalidRefType = 0,
JNILocalRefType = 1,
JNIGlobalRefType = 2,
JNIWeakGlobalRefType = 3
} jobjectRefType;
//定义一个动态注册JNINativeMethod结构体，这个与动态注册有关，里面有三个元素
typedef struct {
const char* name; //第一个参数 name 是java 方法名；
const char* signature; //第二个参数 signature 用于描述方法的参数与返回值，也就是java方法签名信息，
void*   fnPtr; //第三个参数 fnPtr 是函数指针，指向 jni 函数；
} JNINativeMethod;
//  其中，第二个参数 signature 使用字符串记录方法的参数与返回值，具体格式形如“()V”、“(II)V”，其中分为两部分，括号内表示的是参数，括号右侧表示的是返回值；
struct _JNIEnv;
struct _JavaVM;
//定义一个JNINativeInterface结构体，表示原生调用接口的结构体
typedef const struct JNINativeInterface* C_JNIEnv;
#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
//这里有两个接口，一个是本地接口，一个是调用接口
typedef const struct JNINativeInterface* JNIEnv;//JNI本地接口
typedef const struct JNIInvokeInterface* JavaVM;//JNI调用接口
#endif
//本地接口结构体的定义
struct JNINativeInterface {
void*   reserved0;
void*   reserved1;
void*   reserved2;
void*   reserved3;
jint(*GetVersion)(JNIEnv *);//jint返回的是版本信息
//jclass，返回的是类  
jclass  (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,jsize);
jclass  (*FindClass)(JNIEnv*, const char*);
jmethodID   (*FromReflectedMethod)(JNIEnv*, jobject);
jfieldID(*FromReflectedField)(JNIEnv*, jobject);
jobject (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean);
jclass  (*GetSuperclass)(JNIEnv*, jclass);
jboolean(*IsAssignableFrom)(JNIEnv*, jclass, jclass);
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*);
jint(*PushLocalFrame)(JNIEnv*, jint);
jobject (*PopLocalFrame)(JNIEnv*, jobject);
jobject (*NewGlobalRef)(JNIEnv*, jobject);
void(*DeleteGlobalRef)(JNIEnv*, jobject);
void(*DeleteLocalRef)(JNIEnv*, jobject);
jboolean(*IsSameObject)(JNIEnv*, jobject, jobject);
jobject (*NewLocalRef)(JNIEnv*, jobject);
jint(*EnsureLocalCapacity)(JNIEnv*, jint);
//新建object
jobject (*AllocObject)(JNIEnv*, jclass);
jobject (*NewObject)(JNIEnv*, jclass, jmethodID, ...);
jobject (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list);
jobject (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*);
jclass  (*GetObjectClass)(JNIEnv*, jobject);
jboolean(*IsInstanceOf)(JNIEnv*, jobject, jclass);
jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
//调用方法
jobject (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...);
jobject (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jobject (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jboolean(*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);
jboolean(*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jboolean(*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jbyte   (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...);
jbyte   (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jbyte   (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jchar   (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...);
jchar   (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jchar   (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jshort  (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...);
jshort  (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jshort  (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jint(*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);
jint(*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jint(*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jlong   (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...);
jlong   (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list);
jlong   (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jfloat  (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...) __NDK_FPABI__;
jfloat  (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list) __NDK_FPABI__;
jfloat  (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*) __NDK_FPABI__;
jdouble (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...) __NDK_FPABI__;
jdouble (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list) __NDK_FPABI__;
jdouble (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*) __NDK_FPABI__;
void(*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
void(*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list);
void(*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
jobject (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass, jmethodID, ...);
jobject (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jobject (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
jboolean(*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
jboolean(*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jboolean(*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
jbyte   (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
jbyte   (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jbyte   (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
jchar   (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
jchar   (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jchar   (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass, jmethodID, jvalue*);
jshort  (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass, jmethodID, ...);
jshort  (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jshort  (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
jint(*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
jint(*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jint(*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
jlong   (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
jlong   (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
jlong   (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
jfloat  (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass,jmethodID, ...) __NDK_FPABI__;
jfloat  (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list) __NDK_FPABI__;
jfloat  (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass, jmethodID, jvalue*) __NDK_FPABI__;
jdouble (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass,jmethodID, ...) __NDK_FPABI__;
jdouble (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list) __NDK_FPABI__;
jdouble (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*) __NDK_FPABI__;
void(*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
void(*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass,jmethodID, va_list);
void(*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass,jmethodID, jvalue*);
//获取各种字段
jfieldID(*GetFieldID)(JNIEnv*, jclass, const char*, const char*);
jobject (*GetObjectField)(JNIEnv*, jobject, jfieldID);
jboolean(*GetBooleanField)(JNIEnv*, jobject, jfieldID);
jbyte   (*GetByteField)(JNIEnv*, jobject, jfieldID);
jchar   (*GetCharField)(JNIEnv*, jobject, jfieldID);
jshort  (*GetShortField)(JNIEnv*, jobject, jfieldID);
jint(*GetIntField)(JNIEnv*, jobject, jfieldID);
jlong   (*GetLongField)(JNIEnv*, jobject, jfieldID);
jfloat  (*GetFloatField)(JNIEnv*, jobject, jfieldID) __NDK_FPABI__;
jdouble (*GetDoubleField)(JNIEnv*, jobject, jfieldID) __NDK_FPABI__;
//设置各种字段，返回为空
void(*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject);
void(*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean);
void(*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte);
void(*SetCharField)(JNIEnv*, jobject, jfieldID, jchar);
void(*SetShortField)(JNIEnv*, jobject, jfieldID, jshort);
void(*SetIntField)(JNIEnv*, jobject, jfieldID, jint);
void(*SetLongField)(JNIEnv*, jobject, jfieldID, jlong);
void(*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat) __NDK_FPABI__;
void(*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble) __NDK_FPABI__;
jmethodID   (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*);
jobject (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...);
jobject (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list);
jobject (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jboolean(*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...);
jboolean(*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID,va_list);
jboolean(*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID,jvalue*);
jbyte   (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...);
jbyte   (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list);
jbyte   (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jchar   (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...);
jchar   (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list);
jchar   (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jshort  (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...);
jshort  (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list);
jshort  (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jint(*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...);
jint(*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list);
jint(*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jlong   (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...);
jlong   (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list);
jlong   (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jfloat  (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...) __NDK_FPABI__;
jfloat  (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list) __NDK_FPABI__;
jfloat  (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*) __NDK_FPABI__;
jdouble (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...) __NDK_FPABI__;
jdouble (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list) __NDK_FPABI__;
jdouble (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*) __NDK_FPABI__;
void(*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...);
void(*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list);
void(*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
jfieldID(*GetStaticFieldID)(JNIEnv*, jclass, const char*,const char*);
jobject (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID);
jboolean(*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID);
jbyte   (*GetStaticByteField)(JNIEnv*, jclass, jfieldID);
jchar   (*GetStaticCharField)(JNIEnv*, jclass, jfieldID);
jshort  (*GetStaticShortField)(JNIEnv*, jclass, jfieldID);
jint(*GetStaticIntField)(JNIEnv*, jclass, jfieldID);
jlong   (*GetStaticLongField)(JNIEnv*, jclass, jfieldID);
jfloat  (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID) __NDK_FPABI__;
jdouble (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID) __NDK_FPABI__;
void(*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject);
void(*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean);
void(*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte);
void(*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar);
void(*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort);
void(*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint);
void(*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong);
void(*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat) __NDK_FPABI__;
void(*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble) __NDK_FPABI__;
jstring (*NewString)(JNIEnv*, const jchar*, jsize);
jsize   (*GetStringLength)(JNIEnv*, jstring);
const jchar*(*GetStringChars)(JNIEnv*, jstring, jboolean*);
void(*ReleaseStringChars)(JNIEnv*, jstring, const jchar*);
jstring (*NewStringUTF)(JNIEnv*, const char*);
jsize   (*GetStringUTFLength)(JNIEnv*, jstring);
const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
void(*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);
jsize   (*GetArrayLength)(JNIEnv*, jarray);
jobjectArray(*NewObjectArray)(JNIEnv*, jsize, jclass, jobject);
jobject (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);
void(*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);
jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize);
jbyteArray(*NewByteArray)(JNIEnv*, jsize);
jcharArray(*NewCharArray)(JNIEnv*, jsize);
jshortArray   (*NewShortArray)(JNIEnv*, jsize);
jintArray (*NewIntArray)(JNIEnv*, jsize);
jlongArray(*NewLongArray)(JNIEnv*, jsize);
jfloatArray   (*NewFloatArray)(JNIEnv*, jsize);
jdoubleArray  (*NewDoubleArray)(JNIEnv*, jsize);
jboolean*   (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*);
jbyte*  (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*);
jchar*  (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*);
jshort* (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*);
jint*   (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*);
jlong*  (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*);
jfloat* (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*);
jdouble*(*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*);
void(*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray,jboolean*, jint);
void(*ReleaseByteArrayElements)(JNIEnv*, jbyteArray,jbyte*, jint);
void(*ReleaseCharArrayElements)(JNIEnv*, jcharArray,jchar*, jint);
void(*ReleaseShortArrayElements)(JNIEnv*, jshortArray,jshort*, jint);
void(*ReleaseIntArrayElements)(JNIEnv*, jintArray,jint*, jint);
void(*ReleaseLongArrayElements)(JNIEnv*, jlongArray,jlong*, jint);
void(*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray,jfloat*, jint);
void(*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray,jdouble*, jint);
void(*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray,jsize,jsize, jboolean*);
void(*GetByteArrayRegion)(JNIEnv*, jbyteArray,jsize, jsize,jbyte*);
void(*GetCharArrayRegion)(JNIEnv*, jcharArray, jsize, jsize,jchar*);
void(*GetShortArrayRegion)(JNIEnv*, jshortArray,jsize, jsize,jshort*);
void(*GetIntArrayRegion)(JNIEnv*, jintArray,jsize, jsize, jint*);
void(*GetLongArrayRegion)(JNIEnv*, jlongArray,jsize, jsize, jlong*);
void(*GetFloatArrayRegion)(JNIEnv*, jfloatArray,jsize, jsize, jfloat*);
void(*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray,jsize, jsize, jdouble*);
void(*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray,jsize, jsize, const jboolean*);
void(*SetByteArrayRegion)(JNIEnv*, jbyteArray,jsize, jsize, const jbyte*);
void(*SetCharArrayRegion)(JNIEnv*, jcharArray,jsize, jsize, const jchar*);
void(*SetShortArrayRegion)(JNIEnv*, jshortArray,jsize, jsize, const jshort*);
void(*SetIntArrayRegion)(JNIEnv*, jintArray,jsize, jsize, const jint*);
void(*SetLongArrayRegion)(JNIEnv*, jlongArray, jsize, jsize, const jlong*);
void(*SetFloatArrayRegion)(JNIEnv*, jfloatArray, jsize, jsize, const jfloat*);
void(*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray,jsize, jsize, const jdouble*);
jint(*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*,jint);
jint(*UnregisterNatives)(JNIEnv*, jclass);
jint(*MonitorEnter)(JNIEnv*, jobject);
jint(*MonitorExit)(JNIEnv*, jobject);
jint(*GetJavaVM)(JNIEnv*, JavaVM**);
void(*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*);
void(*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*);
void*   (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*);
void(*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint);
const jchar*(*GetStringCritical)(JNIEnv*, jstring, jboolean*);
void(*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);
jweak   (*NewWeakGlobalRef)(JNIEnv*, jobject);
void(*DeleteWeakGlobalRef)(JNIEnv*, jweak);
jboolean(*ExceptionCheck)(JNIEnv*);
jobject (*NewDirectByteBuffer)(JNIEnv*, void*, jlong);
void*   (*GetDirectBufferAddress)(JNIEnv*, jobject);
jlong   (*GetDirectBufferCapacity)(JNIEnv*, jobject);
jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject);
};
/*
 * C++ 
 */
//C++的JNI 本地接口结构体的调用
struct _JNIEnv {
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); }
jboolean IsAssignableFrom(jclass clazz1, jclass clazz2)
{ return functions->IsAssignableFrom(this, clazz1, clazz2); }
jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic)
{ return functions->ToReflectedField(this, cls, fieldID, isStatic); }
jint Throw(jthrowable obj)
{ return functions->Throw(this, obj); }
jint ThrowNew(jclass clazz, const char* message)
{ return functions->ThrowNew(this, clazz, message); }
jthrowable ExceptionOccurred()
{ return functions->ExceptionOccurred(this); }
void ExceptionDescribe()
{ functions->ExceptionDescribe(this); }
void ExceptionClear()
{ functions->ExceptionClear(this); }
void FatalError(const char* msg)
{ functions->FatalError(this, msg); }
jint PushLocalFrame(jint capacity)
{ return functions->PushLocalFrame(this, capacity); }
jobject PopLocalFrame(jobject result)
{ return functions->PopLocalFrame(this, result); }
jobject NewGlobalRef(jobject obj)
{ return functions->NewGlobalRef(this, obj); }
void DeleteGlobalRef(jobject globalRef)
{ functions->DeleteGlobalRef(this, globalRef); }
void DeleteLocalRef(jobject localRef)
{ functions->DeleteLocalRef(this, localRef); }
jboolean IsSameObject(jobject ref1, jobject ref2)
{ return functions->IsSameObject(this, ref1, ref2); }
jobject NewLocalRef(jobject ref)
{ return functions->NewLocalRef(this, ref); }
jint EnsureLocalCapacity(jint capacity)
{ return functions->EnsureLocalCapacity(this, capacity); }
jobject AllocObject(jclass clazz)
{ return functions->AllocObject(this, clazz); }
jobject NewObject(jclass clazz, jmethodID methodID, ...)
{
va_list args;
va_start(args, methodID);
jobject result = functions->NewObjectV(this, clazz, methodID, args);
va_end(args);
return result;
}
jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args)
{ return functions->NewObjectV(this, clazz, methodID, args); }
jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args)
{ return functions->NewObjectA(this, clazz, methodID, args); }
jclass GetObjectClass(jobject obj)
{ return functions->GetObjectClass(this, obj); }
jboolean IsInstanceOf(jobject obj, jclass clazz)
{ return functions->IsInstanceOf(this, obj, clazz); }
jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)
{ return functions->GetMethodID(this, clazz, name, sig); }
#define CALL_TYPE_METHOD(_jtype, _jname)\
__NDK_FPABI__   \
_jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...)   \
{   \
_jtype result;  \
va_list args;   \
va_start(args, methodID);   \
result = functions->Call##_jname##MethodV(this, obj, methodID,  \
args);  \
va_end(args);   \
return result;  \
}
#define CALL_TYPE_METHODV(_jtype, _jname)   \
__NDK_FPABI__   \
_jtype Call##_jname##MethodV(jobject obj, jmethodID methodID,   \
va_list args)   \
{ return functions->Call##_jname##MethodV(this, obj, methodID, args); }
#define CALL_TYPE_METHODA(_jtype, _jname)   \
__NDK_FPABI__   \
_jtype Call##_jname##MethodA(jobject obj, jmethodID methodID,   \
jvalue* args)   \
{ return functions->Call##_jname##MethodA(this, obj, methodID, args); }
#define CALL_TYPE(_jtype, _jname)   \
CALL_TYPE_METHOD(_jtype, _jname)\
CALL_TYPE_METHODV(_jtype, _jname)   \
CALL_TYPE_METHODA(_jtype, _jname)
CALL_TYPE(jobject, Object)
CALL_TYPE(jboolean, Boolean)
CALL_TYPE(jbyte, Byte)
CALL_TYPE(jchar, Char)
CALL_TYPE(jshort, Short)
CALL_TYPE(jint, Int)
CALL_TYPE(jlong, Long)
CALL_TYPE(jfloat, Float)
CALL_TYPE(jdouble, Double)
void CallVoidMethod(jobject obj, jmethodID methodID, ...)
{
va_list args;
va_start(args, methodID);
functions->CallVoidMethodV(this, obj, methodID, args);
va_end(args);
}
void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args)
{ functions->CallVoidMethodV(this, obj, methodID, args); }
void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue* args)
{ functions->CallVoidMethodA(this, obj, methodID, args); }
#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname)\
__NDK_FPABI__   \
_jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz,\
jmethodID methodID, ...)\
{   \
_jtype result;  \
va_list args;   \
va_start(args, methodID);   \
result = functions->CallNonvirtual##_jname##MethodV(this, obj,  \
clazz, methodID, args); \
va_end(args);   \
return result;  \
}
#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname)   \
__NDK_FPABI__   \
_jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz,   \
jmethodID methodID, va_list args)   \
{ return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz,   \
methodID, args); }
#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname)   \
__NDK_FPABI__   \
_jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz,   \
jmethodID methodID, jvalue* args)   \
{ return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz,   \
methodID, args); }
#define CALL_NONVIRT_TYPE(_jtype, _jname)   \
CALL_NONVIRT_TYPE_METHOD(_jtype, _jname)\
CALL_NONVIRT_TYPE_METHODV(_jtype, _jname)   \
CALL_NONVIRT_TYPE_METHODA(_jtype, _jname)
CALL_NONVIRT_TYPE(jobject, Object)
CALL_NONVIRT_TYPE(jboolean, Boolean)
CALL_NONVIRT_TYPE(jbyte, Byte)
CALL_NONVIRT_TYPE(jchar, Char)
CALL_NONVIRT_TYPE(jshort, Short)
CALL_NONVIRT_TYPE(jint, Int)
CALL_NONVIRT_TYPE(jlong, Long)
CALL_NONVIRT_TYPE(jfloat, Float)
CALL_NONVIRT_TYPE(jdouble, Double)
void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
jmethodID methodID, ...)
{
va_list args;
va_start(args, methodID);
functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args);
va_end(args);
}
void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
jmethodID methodID, va_list args)
{ functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); }
void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
jmethodID methodID, jvalue* args)
{ functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); }
jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
{ return functions->GetFieldID(this, clazz, name, sig); }
jobject GetObjectField(jobject obj, jfieldID fieldID)
{ return functions->GetObjectField(this, obj, fieldID); }
jboolean GetBooleanField(jobject obj, jfieldID fieldID)
{ return functions->GetBooleanField(this, obj, fieldID); }
jbyte GetByteField(jobject obj, jfieldID fieldID)
{ return functions->GetByteField(this, obj, fieldID); }
jchar GetCharField(jobject obj, jfieldID fieldID)
{ return functions->GetCharField(this, obj, fieldID); }
jshort GetShortField(jobject obj, jfieldID fieldID)
{ return functions->GetShortField(this, obj, fieldID); }
jint GetIntField(jobject obj, jfieldID fieldID)
{ return functions->GetIntField(this, obj, fieldID); }
jlong GetLongField(jobject obj, jfieldID fieldID)
{ return functions->GetLongField(this, obj, fieldID); }
__NDK_FPABI__
jfloat GetFloatField(jobject obj, jfieldID fieldID)
{ return functions->GetFloatField(this, obj, fieldID); }
__NDK_FPABI__
jdouble GetDoubleField(jobject obj, jfieldID fieldID)
{ return functions->GetDoubleField(this, obj, fieldID); }
void SetObjectField(jobject obj, jfieldID fieldID, jobject value)
{ functions->SetObjectField(this, obj, fieldID, value); }
void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value)
{ functions->SetBooleanField(this, obj, fieldID, value); }
void SetByteField(jobject obj, jfieldID fieldID, jbyte value)
{ functions->SetByteField(this, obj, fieldID, value); }
void SetCharField(jobject obj, jfieldID fieldID, jchar value)
{ functions->SetCharField(this, obj, fieldID, value); }
void SetShortField(jobject obj, jfieldID fieldID, jshort value)
{ functions->SetShortField(this, obj, fieldID, value); }
void SetIntField(jobject obj, jfieldID fieldID, jint value)
{ functions->SetIntField(this, obj, fieldID, value); }
void SetLongField(jobject obj, jfieldID fieldID, jlong value)
{ functions->SetLongField(this, obj, fieldID, value); }
__NDK_FPABI__
void SetFloatField(jobject obj, jfieldID fieldID, jfloat value)
{ functions->SetFloatField(this, obj, fieldID, value); }
__NDK_FPABI__
void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value)
{ functions->SetDoubleField(this, obj, fieldID, value); }
jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig)
{ return functions->GetStaticMethodID(this, clazz, name, sig); }
#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \
__NDK_FPABI__   \
_jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \
...)\
{   \
_jtype result;  \
va_list args;   \
va_start(args, methodID);   \
result = functions->CallStatic##_jname##MethodV(this, clazz,\
methodID, args);\
va_end(args);   \
return result;  \
}
#define CALL_STATIC_TYPE_METHODV(_jtype, _jname)\
__NDK_FPABI__   \
_jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID,\
va_list args)   \
{ return functions->CallStatic##_jname##MethodV(this, clazz, methodID,  \
args); }
#define CALL_STATIC_TYPE_METHODA(_jtype, _jname)\
__NDK_FPABI__   \
_jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID,\
jvalue* args)   \
{ return functions->CallStatic##_jname##MethodA(this, clazz, methodID,  \
args); }
#define CALL_STATIC_TYPE(_jtype, _jname)\
CALL_STATIC_TYPE_METHOD(_jtype, _jname) \
CALL_STATIC_TYPE_METHODV(_jtype, _jname)\
CALL_STATIC_TYPE_METHODA(_jtype, _jname)
CALL_STATIC_TYPE(jobject, Object)
CALL_STATIC_TYPE(jboolean, Boolean)
CALL_STATIC_TYPE(jbyte, Byte)
CALL_STATIC_TYPE(jchar, Char)
CALL_STATIC_TYPE(jshort, Short)
CALL_STATIC_TYPE(jint, Int)
CALL_STATIC_TYPE(jlong, Long)
CALL_STATIC_TYPE(jfloat, Float)
CALL_STATIC_TYPE(jdouble, Double)
void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...)
{
va_list args;
va_start(args, methodID);
functions->CallStaticVoidMethodV(this, clazz, methodID, args);
va_end(args);
}
void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args)
{ functions->CallStaticVoidMethodV(this, clazz, methodID, args); }
void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue* args)
{ functions->CallStaticVoidMethodA(this, clazz, methodID, args); }
jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig)
{ return functions->GetStaticFieldID(this, clazz, name, sig); }
jobject GetStaticObjectField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticObjectField(this, clazz, fieldID); }
jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticBooleanField(this, clazz, fieldID); }
jbyte GetStaticByteField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticByteField(this, clazz, fieldID); }
jchar GetStaticCharField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticCharField(this, clazz, fieldID); }
jshort GetStaticShortField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticShortField(this, clazz, fieldID); }
jint GetStaticIntField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticIntField(this, clazz, fieldID); }
jlong GetStaticLongField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticLongField(this, clazz, fieldID); }
__NDK_FPABI__
jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticFloatField(this, clazz, fieldID); }
__NDK_FPABI__
jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticDoubleField(this, clazz, fieldID); }
void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value)
{ functions->SetStaticObjectField(this, clazz, fieldID, value); }
void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value)
{ functions->SetStaticBooleanField(this, clazz, fieldID, value); }
void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value)
{ functions->SetStaticByteField(this, clazz, fieldID, value); }
void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value)
{ functions->SetStaticCharField(this, clazz, fieldID, value); }
void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value)
{ functions->SetStaticShortField(this, clazz, fieldID, value); }
void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value)
{ functions->SetStaticIntField(this, clazz, fieldID, value); }
void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value)
{ functions->SetStaticLongField(this, clazz, fieldID, value); }
__NDK_FPABI__
void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value)
{ functions->SetStaticFloatField(this, clazz, fieldID, value); }
__NDK_FPABI__
void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value)
{ functions->SetStaticDoubleField(this, clazz, fieldID, value); }
jstring NewString(const jchar* unicodeChars, jsize len)
{ return functions->NewString(this, unicodeChars, len); }
jsize GetStringLength(jstring string)
{ return functions->GetStringLength(this, string); }
const jchar* GetStringChars(jstring string, jboolean* isCopy)
{ return functions->GetStringChars(this, string, isCopy); }
void ReleaseStringChars(jstring string, const jchar* chars)
{ functions->ReleaseStringChars(this, string, chars); }
jstring NewStringUTF(const char* bytes)
{ return functions->NewStringUTF(this, bytes); }
jsize GetStringUTFLength(jstring string)
{ return functions->GetStringUTFLength(this, string); }
const char* GetStringUTFChars(jstring string, jboolean* isCopy)
{ return functions->GetStringUTFChars(this, string, isCopy); }
void ReleaseStringUTFChars(jstring string, const char* utf)
{ functions->ReleaseStringUTFChars(this, string, utf); }
jsize GetArrayLength(jarray array)
{ return functions->GetArrayLength(this, array); }
jobjectArray NewObjectArray(jsize length, jclass elementClass,
jobject initialElement)
{ return functions->NewObjectArray(this, length, elementClass,
initialElement); }
jobject GetObjectArrayElement(jobjectArray array, jsize index)
{ return functions->GetObjectArrayElement(this, array, index); }
void SetObjectArrayElement(jobjectArray array, jsize index, jobject value)
{ functions->SetObjectArrayElement(this, array, index, value); }
jbooleanArray NewBooleanArray(jsize length)
{ return functions->NewBooleanArray(this, length); }
jbyteArray NewByteArray(jsize length)
{ return functions->NewByteArray(this, length); }
jcharArray NewCharArray(jsize length)
{ return functions->NewCharArray(this, length); }
jshortArray NewShortArray(jsize length)
{ return functions->NewShortArray(this, length); }
jintArray NewIntArray(jsize length)
{ return functions->NewIntArray(this, length); }
jlongArray NewLongArray(jsize length)
{ return functions->NewLongArray(this, length); }
jfloatArray NewFloatArray(jsize length)
{ return functions->NewFloatArray(this, length); }
jdoubleArray NewDoubleArray(jsize length)
{ return functions->NewDoubleArray(this, length); }
jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy)
{ return functions->GetBooleanArrayElements(this, array, isCopy); }
jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy)
{ return functions->GetByteArrayElements(this, array, isCopy); }
jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy)
{ return functions->GetCharArrayElements(this, array, isCopy); }
jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy)
{ return functions->GetShortArrayElements(this, array, isCopy); }
jint* GetIntArrayElements(jintArray array, jboolean* isCopy)
{ return functions->GetIntArrayElements(this, array, isCopy); }
jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy)
{ return functions->GetLongArrayElements(this, array, isCopy); }
jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy)
{ return functions->GetFloatArrayElements(this, array, isCopy); }
jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy)
{ return functions->GetDoubleArrayElements(this, array, isCopy); }
void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems,
jint mode)
{ functions->ReleaseBooleanArrayElements(this, array, elems, mode); }
void ReleaseByteArrayElements(jbyteArray array, jbyte* elems,
jint mode)
{ functions->ReleaseByteArrayElements(this, array, elems, mode); }
void ReleaseCharArrayElements(jcharArray array, jchar* elems,
jint mode)
{ functions->ReleaseCharArrayElements(this, array, elems, mode); }
void ReleaseShortArrayElements(jshortArray array, jshort* elems,
jint mode)
{ functions->ReleaseShortArrayElements(this, array, elems, mode); }
void ReleaseIntArrayElements(jintArray array, jint* elems,
jint mode)
{ functions->ReleaseIntArrayElements(this, array, elems, mode); }
void ReleaseLongArrayElements(jlongArray array, jlong* elems,
jint mode)
{ functions->ReleaseLongArrayElements(this, array, elems, mode); }
void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems,
jint mode)
{ functions->ReleaseFloatArrayElements(this, array, elems, mode); }
void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems,
jint mode)
{ functions->ReleaseDoubleArrayElements(this, array, elems, mode); }
void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
jboolean* buf)
{ functions->GetBooleanArrayRegion(this, array, start, len, buf); }
void GetByteArrayRegion(jbyteArray array, jsize start, jsize len,
jbyte* buf)
{ functions->GetByteArrayRegion(this, array, start, len, buf); }
void GetCharArrayRegion(jcharArray array, jsize start, jsize len,
jchar* buf)
{ functions->GetCharArrayRegion(this, array, start, len, buf); }
void GetShortArrayRegion(jshortArray array, jsize start, jsize len,
jshort* buf)
{ functions->GetShortArrayRegion(this, array, start, len, buf); }
void GetIntArrayRegion(jintArray array, jsize start, jsize len,
jint* buf)
{ functions->GetIntArrayRegion(this, array, start, len, buf); }
void GetLongArrayRegion(jlongArray array, jsize start, jsize len,
jlong* buf)
{ functions->GetLongArrayRegion(this, array, start, len, buf); }
void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
jfloat* buf)
{ functions->GetFloatArrayRegion(this, array, start, len, buf); }
void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
jdouble* buf)
{ functions->GetDoubleArrayRegion(this, array, start, len, buf); }
void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
const jboolean* buf)
{ functions->SetBooleanArrayRegion(this, array, start, len, buf); }
void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
const jbyte* buf)
{ functions->SetByteArrayRegion(this, array, start, len, buf); }
void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
const jchar* buf)
{ functions->SetCharArrayRegion(this, array, start, len, buf); }
void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
const jshort* buf)
{ functions->SetShortArrayRegion(this, array, start, len, buf); }
void SetIntArrayRegion(jintArray array, jsize start, jsize len,
const jint* buf)
{ functions->SetIntArrayRegion(this, array, start, len, buf); }
void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
const jlong* buf)
{ functions->SetLongArrayRegion(this, array, start, len, buf); }
void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
const jfloat* buf)
{ functions->SetFloatArrayRegion(this, array, start, len, buf); }
void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
const jdouble* buf)
{ functions->SetDoubleArrayRegion(this, array, start, len, buf); }
jint RegisterNatives(jclass clazz, const JNINativeMethod* methods,
jint nMethods)
{ return functions->RegisterNatives(this, clazz, methods, nMethods); }
jint UnregisterNatives(jclass clazz)
{ return functions->UnregisterNatives(this, clazz); }
jint MonitorEnter(jobject obj)
{ return functions->MonitorEnter(this, obj); }
jint MonitorExit(jobject obj)
{ return functions->MonitorExit(this, obj); }
jint GetJavaVM(JavaVM** vm)
{ return functions->GetJavaVM(this, vm); }
void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf)
{ functions->GetStringRegion(this, str, start, len, buf); }
void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf)
{ return functions->GetStringUTFRegion(this, str, start, len, buf); }
void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy)
{ return functions->GetPrimitiveArrayCritical(this, array, isCopy); }
void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode)
{ functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); }
const jchar* GetStringCritical(jstring string, jboolean* isCopy)
{ return functions->GetStringCritical(this, string, isCopy); }
void ReleaseStringCritical(jstring string, const jchar* carray)
{ functions->ReleaseStringCritical(this, string, carray); }
jweak NewWeakGlobalRef(jobject obj)
{ return functions->NewWeakGlobalRef(this, obj); }
void DeleteWeakGlobalRef(jweak obj)
{ functions->DeleteWeakGlobalRef(this, obj); }
jboolean ExceptionCheck()
{ return functions->ExceptionCheck(this); }
jobject NewDirectByteBuffer(void* address, jlong capacity)
{ return functions->NewDirectByteBuffer(this, address, capacity); }
void* GetDirectBufferAddress(jobject buf)
{ return functions->GetDirectBufferAddress(this, buf); }
jlong GetDirectBufferCapacity(jobject buf)
{ return functions->GetDirectBufferCapacity(this, buf); }
/* added in JNI 1.6 */
jobjectRefType GetObjectRefType(jobject obj)
{ return functions->GetObjectRefType(this, obj); }
#endif /*__cplusplus*/
};
/*
 * JNI invocation interface.
 */
//调用接口结构体JNIInvokeInterface的定义
struct JNIInvokeInterface {
void*   reserved0;
void*   reserved1;
void*   reserved2;
jint(*DestroyJavaVM)(JavaVM*);
jint(*AttachCurrentThread)(JavaVM*, JNIEnv**, void*);
jint(*DetachCurrentThread)(JavaVM*);
jint(*GetEnv)(JavaVM*, void**, jint);
jint(*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);
};
/*
 * C++ version.
 */
struct _JavaVM {
const struct JNIInvokeInterface* functions;
#if defined(__cplusplus)
jint DestroyJavaVM()
{ return functions->DestroyJavaVM(this); }
jint AttachCurrentThread(JNIEnv** p_env, void* thr_args)
{ return functions->AttachCurrentThread(this, p_env, thr_args); }
jint DetachCurrentThread()
{ return functions->DetachCurrentThread(this); }
jint GetEnv(void** env, jint version)
{ return functions->GetEnv(this, env, version); }
jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)
{ return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }
#endif /*__cplusplus*/
};
struct JavaVMAttachArgs {
jintversion;/* must be >= JNI_VERSION_1_2 */
const char* name;   /* NULL or name of thread as modified UTF-8 str */
jobject group;  /* global ref of a ThreadGroup object, or NULL */
};
typedef struct JavaVMAttachArgs JavaVMAttachArgs;
/*
 * JNI 1.2+ initialization.  (As of 1.6, the pre-1.2 structures are no
 * longer supported.)
 */
typedef struct JavaVMOption {
const char* optionString;
void*   extraInfo;
} JavaVMOption;
typedef struct JavaVMInitArgs {
jintversion;/* use JNI_VERSION_1_2 or later */
jintnOptions;
JavaVMOption* options;
jbooleanignoreUnrecognized;
} JavaVMInitArgs;
#ifdef __cplusplus
extern "C" {
#endif
/*
 * VM initialization functions.
 *
 * Note these are the only symbols exported for JNI by the VM.
 */
#if 0  /* In practice, these are not exported by the NDK so don't declare them */
jint JNI_GetDefaultJavaVMInitArgs(void*);
jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*);
jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*);
#endif
#define JNIIMPORT
#define JNIEXPORT  __attribute__ ((visibility ("default")))
#define JNICALL __NDK_FPABI__
/*
 * Prototypes for functions exported by loadable shared libs.  These are
 * called by JNI, not provided by JNI.
 */
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved);
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved);
#ifdef __cplusplus
}
#endif
/*
 * Manifest constants.
 */
#define JNI_FALSE   0
#define JNI_TRUE1
#define JNI_VERSION_1_1 0x00010001
#define JNI_VERSION_1_2 0x00010002
#define JNI_VERSION_1_4 0x00010004
#define JNI_VERSION_1_6 0x00010006
#define JNI_OK  (0) /* no error */
#define JNI_ERR (-1)/* generic error */
#define JNI_EDETACHED   (-2)/* thread detached from the VM */
#define JNI_EVERSION(-3)/* JNI version error */
#define JNI_COMMIT  1   /* copy content, do not free buffer */
#define JNI_ABORT   2   /* free buffer w/o copying back */
#endif  /* JNI_H_ */

然后我们继续

返回值、方法名称、参数类型

创建jni文件夹

MainActivity.h

把MainActivity.h更名 拖入jni文件夹

一个.c文件两个.mk文件

.c文件的头文件进行调用.h文件

写函数

返回值 参数 方法体 三个类型

只有两个参数

补充参数

回显内容：return

目的：c层返回一个字符串给java层

借助JNI接口NewStringUTF

查万能表

jstring (*NewStringUTF)(JNIEnv*, const char*);

返回的是一个字符串 使用str接收

使用JNI指针类型指出

jstring str = *aaa->NewStringUTF(JNIEnv*, const char*);return bbb;

需要使用的话还需要定义一个参数，不然 return的返回值 bbb无法从C层回到java层

bbb是个字符串，那么可以使用str，接受后使用JNI(day)指针类型指出

然后使用JNIEnv类型去定义参数，再放入返回值

然后再把我们涉及到的两个.mk文件搞过来

Android.mk

LOCAL_PATH := $(call my-dir)include $(CLEAR_VARS)LOCAL_MODULE := JNI_Aaa #模块名称LOCAL_SRC_FILES := JNI_Aaa.c #源文件LOCAL_ARM_MODE := arm #编译后的指令集armLOCAL_LDLIBS += -llog #依赖库include $(BUILD_SHARED_LIBRARY) #指定的编译文件类型

注：我们之前要编译的是EXE文件类型 所以使用的是：include $(BUILD_HARED_LIBRARY)

今天编译的是so库，所以使用的是：include $(BUILD_SHARED_LIBRARY)

Application.mk

APP_ABI := x86 armeabi-v7a

中文乱码问题

修改为UTF-8即可

全部保存后进行编译

编译

去jni包所在的目录

进行编译

Eclipse进行刷新(F5)

so库文件在obj目录下

我们的返回值bbb在obj的目录下

那么回到java层 把返回值 带回来即可

stati