public static native void logout();

   #if(CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
   #include "jni.h"
   #include "jni/JniHelper.h"
    //定义Jni函数信息结构体
    JniMethodInfo minfo;
    bool isHave = JniHelper::getStaticMethodInfo(minfo,"org.cocos2dx.testcp.TestCpp","logout", "()V");
    if(isHave){
        CCLOG("logout function exist");
        minfo.env->CallStaticObjectMethod(minfo.classID, minfo.methodID);
        CCLOG("java logout function called");
    }else{
        CCLOG("logout function not exist");
    }
    #endif

在C和C++中是没有对应java中String的类型，但是可以通过反射技术，把char*转换为String。

char* Jstr2Cstr(JNIEnv * env, jstring str) {
	char* cstr = NULL;
	//找到Java的String类
	jclass clazz = (*env)->FindClass(env, "java/lang/String");
	//找到String的getBytes(charset)方法
	jmethodID method = (*env)->GetMethodID(env, clazz, "getBytes", "(Ljava/lang/String;)[B");
	jstring charset = (*env)->NewStringUTF(env,"UTF-8");
	//调用String.getBytes(charset)方法得到byte数组
	jbyteArray byteArr = (jbyteArray)(*env)->CallObjectMethod(env, str, method, charset);
	//得到byte数组的长度，申请一块内存空间
    int length =  (*env)->GetArrayLength(env,byteArr);
	if (length>0) {
		cstr = malloc(length+1);//最后一个位置放"\0"
		//把byte数组中的数据copy到新建申请的内存空间中
		 char* elements = (*env)->GetByteArrayElements(env,byteArr, 0);

		 strncpy(cstr, elements, length);
		 cstr[length] = 0;//表示字符串的结尾（\0）

		//释放内存并返回
		(*env)->ReleaseByteArrayElements(env, byteArr, elements, 0);
	}
	 return cstr;
}

char* Jstr2Cstr(JNIEnv * env, jstring jstr) {
    char * rtn = NULL;
    jclass clsstring = env->FindClass("java/lang/String");
    jstring strencode = env->NewStringUTF("UTF-8");
    jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
    jbyteArray barr= (jbyteArray)env->CallObjectMethod(jstr,mid,strencode);
    jsize alen = env->GetArrayLength(barr);
    jbyte * ba = env->GetByteArrayElements(barr,JNI_FALSE);
    if(alen > 0)
    {
        rtn = (char*)malloc(alen+1); //new char[alen+1];
        memcpy(rtn,ba,alen);
        rtn[alen]=0;
    }
    env->ReleaseByteArrayElements(barr,ba,0);
    
    return rtn;
}

(*env)->NewStringUTF(env,"Hello");

env->NewStringUTF("hello")

C与C++中JNI实现的区别

JNIEnv

我们使用javah生成头文件时候至少会生成2个参数，JNIEnv*和jobject（如果是静态方法是jclass）

比如：JNIEXPORT jint JNICALL Java_com_test_Test (JNIEnv *, jobject);
如果java的native定义的方法中的签名有参数,那么参数则会跟在jobject后面。

在C中，看到JNIEnv 我们实质是取得了JNINativeInterface* （JNIEnv指针的指针），我们得使用**env获取结构体，从而才能使用结构体里面的方法。

在C++中，看到JNIEnv我们实质是取得了JNIEnv*（JNIEnv结构体的指针），我们可以直接使用env->使用结构体里面的方法。

方法调用的区别

C++方法调用的区别：
1.调用JNI函数时，不需要传递env
2.(*env)->调用方法简化成env->

//c语言的实现
 return   (*env)->NewStringUTF(env,"hello from c");
//c++实现
 return env->NewStringUTF("hello in c");

绕过JNI直接调用C函数

//在Java代码中调用Linux下的二进制文件：
Process process = Runtime.getRuntime().exec(“二进制文件全路径名”);
//得到输入流
InputStream is = process.getInputStream();
//包装输入流
DataInputStream dis = new DataInputStream(is);
//读取输入流
StringBuild builder = new StingBuilder();
for(String result ; (result=dis.readLine())!=null ;){
	builder.append(result);
	builder.append(“\n”);
}
//打印信息
System.out.println(builder.toString());

注册jni函数这个动作作用是建立java层的native方法与jni层的native函数之间的关联。

它们之间的关联主要是用一个结构体JNINativeMethod来完成的，结构体定义如下：

typedef struct {

   const char* name;                     //Java层的native方法名称

   const char* signature;              //Java层的native方法的签名（javap –s –p ClassName）

   void*       fnPtr;                   //jni层实现函数的函数指针

} JNINativeMethod;

在jni层会建立一个JNINativeMethod数组用于记录java层与jni层的方法调用关系。

接着该JNINativeMethod数组会被用作JNIEnv中函数jint RegisterNativeMethod(jclass,JNINativeMethods, len)的第二个参数执行注册动作，jclass是java层定义了native方法的类。

实现步骤：

1.编写Java代码，定义native方法，编译生成.class文件；

2.使用javah工具，如javah –o output packageName.className，这样它会生成一个output.h的JNI层头文件；

3.把头文件添加到工程jni目录，在C/C++代码中引用头文件并实现相关函数；

java层中的native方法是如果找到jni层的实现函数的？
当Java层调用xxx方法时，它会从对应的JNI库中寻找Java_packageName_xxx函数，如果没有就会报错。如果找到，则会为这个xxx方法和Java_packageName_xxx函数建立一个关联关系，其实就是保存JNI层函数的函数指针。以后再调用xxx方法时，直接使用这个函数指针就可以了。这项工作是由虚拟机完成的。

静态注册是根据函数名来建立Java方法与JNI函数之间的关联关系的。这种方法有几个弊端：

1.需要编译所有声明了native方法的Java类，每个所生成的class文件都得用javah生成一个头文件；

2.javah生成的JNI层函数名特别长，书写起来不方便；

3.初次调用native方法时要根据函数名字搜索对应的JNI层函数来建立关联关系，这样会影响运行效率。

在代码中建立java层native方法与jni层实现函数之间的关联。直接让native方法知道JNI层对应函数的函数指针。

JNI_Onload函数是在动态库被加载完成时调用，动态注册必须实现JNI_Onload函数。

//在模块被加载时，建立java层native方法与native层的native方法的关联关系
jint JNI_OnLoad(JavaVM* vm, void* reserved){
	LOGI("loaded mode and call JNI_Onload method");

	//创建关联结构数组
	JNINativeMethod nativeMethods[] = {
			{
					"test",			     //Java层的native方法名
					"()Ljava/lang/String;",	//Java层的native方法名的签名
					(void*)test	         //native层方法的指针
			}
	};
	LOGI("native methods array is created.");

	//动态注册
    //1.得到JNIEnv*
	JNIEnv* env = NULL;
    vm->GetEnv((void**)&env, JNI_VERSION_1_2);
    LOGI("find class is finish.");

//2.注册native方法
//查找java层定义了native方法的类
    jclass clazz = env->FindClass("com/example/jnidynamicreg/MainActivity");
    jint result = env->RegisterNatives( clazz, nativeMethods, 1);
LOGI("after register natives result is %d",result);

   return  JNI_VERSION_1_2;	//注意这里一定要返回JNI_VERSION，不然会报异常
}