魅力程序猿

////输入一个数组,这里输入的是一个Boolean类型的数组
JNIEXPORT void JNICALL Java_com_aoaoyi_jnidemo_ChangeMethodFromJni_setArray
(JNIEnv *env, jobject, jbooleanArray ba)
{
    jboolean* pba = (env)->GetBooleanArrayElements(ba, 0 );
    jsize len = (env)->GetArrayLength(ba);
    int i=0;
    // change even array elements
    for( i=0; i < len; i+=2 )
    {
        pba[i] = JNI_FALSE;
        printf( "boolean = %s\n", (pba[i]==JNI_TRUE ? "true" : "false") );
    }
    (env)->ReleaseBooleanArrayElements(ba, pba, 0 );
}

////返回一个结构数组，返回一个硬盘信息的结构数组
JNIEXPORT jobjectArray JNICALL Java_com_aoaoyi_jnidemo_ChangeMethodFromJni_getStructArray
(JNIEnv *env, jobject _obj)
{
    //申明一个object数组 
    jobjectArray args = 0;
 
    //数组大小
    jsize        len = 5;
 
    //获取object所属类,一般为ava/lang/Object就可以了
    jclass objClass = (env)->FindClass("java/lang/Object");
 
    //新建object数组
    args = (env)->NewObjectArray(len, objClass, 0);
 
    /* 下面为获取到Java中对应的实例类中的变量*/
 
    //获取Java中的实例类
    jclass objectClass = (env)->FindClass("com/aoaoyi/jnidemo/DiskInfo");
 
    //获取类中每一个变量的定义
    //名字
    jfieldID str = (env)->GetFieldID(objectClass,"name","Ljava/lang/String;");
    //序列号
    jfieldID ival = (env)->GetFieldID(objectClass,"serial","I");
 
    //给每一个实例的变量付值，并且将实例作为一个object，添加到objcet数组中
    for(int  i=0; i < len; i++ )
    {
        //给每一个实例的变量付值
        jstring jstr = WindowsTojstring(env,"我的磁盘名字是 D:");
        //(env)->SetObjectField(_obj,str,(env)->NewStringUTF("my name is D:"));
        (env)->SetObjectField(_obj,str,jstr);
        (env)->SetShortField(_obj,ival,10);
 
        //添加到objcet数组中
        (env)->SetObjectArrayElement(args, i, _obj);
    }
    //返回object数组
    return args;
 
 }

struct _JNIEnv;
struct _JavaVM;
typedef const struct JNINativeInterface* C_JNIEnv;
#if defined(__cplusplus)  
typedef _JNIEnv JNIEnv;   //C++中的 JNIEnv 类型
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;  //C语言的 JNIEnv 类型
typedef const struct JNIInvokeInterface* JavaVM;
#endif

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);
	  //……定义了一系列关于 Java 操作的函数
}

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); }
    //……
}

javah -d cpp -jni  -classpath ..\..\build\intermediates\classes\debug com.aoaoyi.poker.jni.Jni

 //JNINativeMethod结构体
typedef struct {
    const char* name;       //Java中native方法的名字
    const char* signature;  //Java中native方法的描述符
    void*       fnPtr;      //对应JNI函数的指针
} JNINativeMethod;
/**
 * @param clazz java类名，通过 FindClass 获取
 * @param methods JNINativeMethod 结构体指针
 * @param nMethods 方法个数
 */
jint RegisterNatives(jclass clazz, const JNINativeMethod* methods, jint nMethods)
//JNI_OnLoad 
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved);

public class Jni2 {
 
    static {
        System.loadLibrary("aoaoyi-dynamic");
    }
 
    public static native String getBaseUrl();
    public static native String getReportUrl();
    public static native String getUserProfileUrl(int userId);
 
 
}

#include <jni.h>
#include <string>
#include <string.h>
#include <assert.h>
 
//char const *BASE_URL = "http://aoaoyi.com/api/";
std::string BASE_URL = "http://aoaoyi.com/api/";
 
#ifdef __cplusplus
extern "C"
{
#endif
 
jstring JNICALL getBaseUrl(
        JNIEnv * env,
        jobject) {
    return env->NewStringUTF(BASE_URL.c_str());
}
 
jstring JNICALL getReportUrl(
        JNIEnv * env,
        jobject) {
    std::string  reportUrl = BASE_URL;
    reportUrl += "report/";
    return env->NewStringUTF(reportUrl.c_str());
}
 
jstring JNICALL getUserProfileUrl(
        JNIEnv * env,
        jobject,
        jint pUserId) {
    std::string  profileUrl = BASE_URL;
    profileUrl += "profile/";
    profileUrl += std::to_string(pUserId);
    return (env)->NewStringUTF(profileUrl.c_str());
}
 
//指定要注册的类
#define JNI_REG_CLASS "com/aoaoyi/poker/jni/Jni2"
 
/**
 * 映射
 */
static JNINativeMethod gMethods[] = {
        { "getBaseUrl", "()Ljava/lang/String;", (void*)getBaseUrl },
        { "getReportUrl", "()Ljava/lang/String;", (void*)getReportUrl },
        { "getUserProfileUrl", "(I)Ljava/lang/String;", (void*)getUserProfileUrl },
 
};
 
/*
*
* 注册JNI函数
*/
static int registerNativeMethods(JNIEnv* env, const char* className,
                                 JNINativeMethod* gMethods, int numMethods)
{
    jclass clazz = NULL;
    clazz = env->FindClass(className);
    if (env->ExceptionCheck() || clazz == NULL) {
        env->ExceptionClear();
        clazz = NULL;
        return JNI_FALSE;
    }
    /**
     * RegisterNatives
     *
     * @param clazz java类名，通过 FindClass 获取
     * @param methods JNINativeMethod 结构体指针
     * @param nMethods 方法个数
     */
    int nRC = env->RegisterNatives(clazz, gMethods, numMethods);
    if (env->ExceptionCheck() || nRC < 0) {
        env->ExceptionClear();
        return JNI_FALSE;
    }
 
    return JNI_TRUE;
}
 
/*
* 注册给类成员函数
*/
int registerNatives(JNIEnv* env)
{
    if (NULL == env)
    {
        return JNI_FALSE;
    }
 
    if (!registerNativeMethods(env, JNI_REG_CLASS, gMethods,
                               sizeof(gMethods) / sizeof(gMethods[0])))
        return JNI_FALSE;
 
    return JNI_TRUE;
}
 
/*
* 反注册给类成员函数
*/
void unregisterNatives(JNIEnv* env)
{
    if (NULL == env)
    {
        return;
    }
 
    jclass clazz = NULL;
    clazz = env->FindClass(JNI_REG_CLASS);
    if (env->ExceptionCheck() || clazz == NULL) {
        env->ExceptionClear();
        clazz = NULL;
        return;
    }
 
    env->UnregisterNatives(clazz);
    if (env->ExceptionCheck())
    {
        env->ExceptionClear();
    }
}
 
/*
* 成功则返回JNI版本号，失败返回-1.
*/
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;
 
    if (vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK) {
        return -1;
    }
    assert(env != NULL);
    //注册
    if (!registerNatives(env)) {
        return -1;
    }
    /* 注册成功，返回JNI版本号 */
    result = JNI_VERSION_1_6;
 
    return result;
}
 
/*
* 解除注册
*/
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
    JNIEnv *env = NULL;
    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6))
        return;
    unregisterNatives(env);
    return;
}
 
#ifdef __cplusplus
}
#endif