Android游戏开发执行(1)之NDK与JNI开发04

Android游戏开发实践(1)之NDK与JNI开发04

有了前边几篇NDK与JNI开发相关基础做铺垫,再来通过代码表明下那地点具体的操作以及部分关键的细节。那么,就继续NDK与JNI的求学总计。

小编:AlphaGL。版权全体,欢迎保留原作链接实行转发 🙂

传送门:
Android游戏开发实践(1)之NDK与JNI开发01
Android游戏开发实践(1)之NDK与JNI开发02
Android游戏开发执行(1)之NDK与JNI开发03

JavaVM和JNIEnv

jni.h头文件中定义了三种重庆大学的数据结构JavaVMJNIEnv,并且在C和C++中它们的兑现是例外的(通过#if defined(__cplusplus)宏定义达成)。本质都以指向封装了JNI函数列表的指针。

JavaVM

是java虚拟机在jni层的意味。在Android中1个JVM只允许有3个JavaVM对象。能够在线程间共享3个JavaVM对象。

JavaVM声明

在jni中针对C语言环境和C++语言环境的JavaVM完毕有所不一致。

C版的JavaVM声明为:

typedef const struct JNIInvokeInterface* JavaVM;

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++版的JavaVM声明为:

typedef _JavaVM JavaVM;

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*/
};
JavaVM获得格局

(1)jni动态注册的主意。在加载动态链接库的时候,JVM会调用JNI_OnLoad(JavaVM*
vm, void* reserved),并传入JavaVM指针:

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {

}

(2)在当地代码中通过调用jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*)来创建。

JNIEnv

简简单单的话,正是JNIEnv提供了全体JNI函数调用的接口。无法在线程间共享同一个JNIEnv变量,仅在创制它的线程有效,要是要在其它线程访问JVM,需求调用AttachCurrentThreadAttachCurrentThreadAsDaemon将近日线程与JVM绑定。再经过JavaVM对象的GetEnv来获取JNIEnv

JNIEnv声明

JavaVM类似,JNIEnv在C和C++语言中的证明也方枘圆凿。

C版的JavaVM声明为:

typedef const struct JNINativeInterface* JNIEnv;

struct JNINativeInterface {
        jint        (*GetVersion)(JNIEnv *);
        ···
}

C++版的JavaVM声明为:

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

    ...
}

jobject、jclass、jmethodID和jfieldID

jobject
是JNI对原始java.lang.Object的照耀。可以通过调用NewObject来收获多少个jobject对象。例如:

env->NewObject(jclass clazz, jmethodID methodID, ...)

jclass
是JNI对原始java.lang.Class的映射。能够通过调用FindClass来获得jclass对象。例如:

jclass intArrayClass = env->FindClass("[I");

jmethodID
获取对应类成员方法的艺术id。能够因而调用GetMethodID来获取。例如:

jmethodID myMethodId = env->(jclass clazz, const char *name, const char *sig);

jfieldID
获得对应类成员变量的字段id。能够透过调用GetFieldID来获得。例如:

jfieldID nameFieldId = env->GetFieldID(jclass clazz, const char *name, const char *sig)

本土库调用

JNI的加载本地库中的代码,步骤简述如下(同时,也是Android推荐的做法):
(1)在java类的静态块中调用System.loadLibrary来加载动态库,若动态库的名字为libcocos2dx.so,那么,调用为:

    static {
        System.loadLibrary("cocos2dx");
    }

(2)在地方代码中落到实处JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved);方法。

(3)在该JNI_OnLoad方法中,调用env->RegisterNatives(jclass clazz, const JNINativeMethod *methods, jint nMethods)注册全体地方的兑现方式。推荐将艺术注解为静态的,那样不会占有设备上的符号表的空间。

JNI通信

JNI的通讯进程,其实便是原生Java与底层C/C++数据传递的进度。那里差不多归纳下,数据传递分为以下这两种:

  • 传递基本数据类型(例如:int,float等)
  • 传送对象(例如:String,Object,自定义类MyObject等)
  • 传送数组(例如:int[], String[]等)
  • 传送集合对象(例如:ArrayList
    ,HashMap等)

而调用格局有能够分成:
(1)java调用native方法
(2)native调用java静态方法,非静态方法(成员方法),以及获得java类的分子变量。

上边按照贯彻方式的两样组合以上要点,通过一个例证代码来表明下实际是如何落到实处的。
(1)静态注册的法子
工程协会如下:(那里只列举出第①表明的项)

JNISample1  
  │── build.gradle
  │── CMakeLists.txt 
  └── app 
      ├── build.gradle
      ├── CMakeLists.txt
      └── src 
          ├── cpp
          │    ├── JNIUtils.h
          │    └── JNIUtils.cpp
          └── com.alphagl.main
                    ├── JNIUtils.java
                    ├── MainActivity.Java
                    └── Person.java

代码如下:(那里做了下简化,去掉些注释以及单元测试部分的代码)
MainActivity.java

package com.alphagl.main;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends Activity {

    static {
        System.loadLibrary("native-lib");
    }

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Log.i("MainActivity", "getStringFromJNI ============= " + JNIUtils.getStringFromJNI());
        Log.i("MainActivity", "getIntArrayFromJNI ============= " + JNIUtils.getIntArrayFromJNI()[0] + "," + JNIUtils.getIntArrayFromJNI()[1]);
        JNIUtils.setPersonToJNI(new Person(18, "jobs"));
        Log.i("MainActivity", "getPersonFromJNI ============= " + JNIUtils.getPersonFromJNI().getAge()+ "," + JNIUtils.getPersonFromJNI().getName());
    }
}

Person.java:(封装的自定义对象)

package com.alphagl.main;

import android.util.Log;

public class Person {
    private int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void printPerson() {
        Log.d("MainActivity", "age ======== " + age + "," + "name ======== " + name);
    }
}

JNIUtils.java

package com.alphagl.main;

public class JNIUtils {
    public static native String getStringFromJNI();
    public static native int[] getIntArrayFromJNI();
    public static native void setPersonToJNI(Person person);
    public static native Person getPersonFromJNI();
}

JNIUtils.h

#include <jni.h>
#include <stdio.h>

#ifndef _Included_com_alphagl_main_JNIUtils
#define _Included_com_alphagl_main_JNIUtils
#ifdef __cplusplus
extern "C" {
#endif

JNIEXPORT jstring JNICALL Java_com_alphagl_main_JNIUtils_getStringFromJNI
  (JNIEnv *, jclass);


JNIEXPORT jintArray JNICALL Java_com_alphagl_main_JNIUtils_getIntArrayFromJNI
  (JNIEnv *, jclass);


JNIEXPORT void JNICALL Java_com_alphagl_main_JNIUtils_setPersonToJNI
  (JNIEnv *, jclass, jobject);


JNIEXPORT jobject JNICALL Java_com_alphagl_main_JNIUtils_getPersonFromJNI
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif

JNIUtils.cpp

#include "JNIUtils.h"
#include <android/log.h>

#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "MainActivity", __VA_ARGS__)
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "MainActivity", __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROE, "MainActivity", __VA_ARGS__)


JNIEXPORT jstring JNICALL Java_com_alphagl_main_JNIUtils_getStringFromJNI (JNIEnv *env, jclass jcls) {
    LOGD(" ====================== getStringFromJNI");
    // 构造一个String字符串
    return env->NewStringUTF("Hello from jni");
}


JNIEXPORT jintArray JNICALL Java_com_alphagl_main_JNIUtils_getIntArrayFromJNI (JNIEnv *env, jclass jcls) {
    LOGD(" ====================== getIntArrayFromJNI");
    // 构造一个int[]数组
    jintArray intArray = env->NewIntArray(2);
    int size[]={640, 960};
    // 给int[]数组赋值
    env->SetIntArrayRegion(intArray, 0, 2, size);

    return intArray;
}


JNIEXPORT void JNICALL Java_com_alphagl_main_JNIUtils_setPersonToJNI (JNIEnv *env, jclass jcls, jobject jobj) {
    LOGD(" ====================== setPersonToJNI");
    jclass jperson = env->GetObjectClass(jobj);
    if (jperson != NULL) {
        // 获取Person对象的age字段id
        jfieldID ageFieldId = env->GetFieldID(jperson, "age", "I");
        // 获取Person对象的name字段id
        jfieldID nameFieldId = env->GetFieldID(jperson, "name", "Ljava/lang/String;");

        // 获取Person的age成员变量
        jint age = env->GetIntField(jobj, ageFieldId);
        // 获取Person的name成员变量
        jstring name = (jstring)env->GetObjectField(jobj, nameFieldId);

        const char *c_name = env->GetStringUTFChars(name, NULL);

        // 打印从Java传递过来的Person对象的age和name变量
        LOGD("age ===== %d, name ===== %s", age, c_name);
    }

    // 以下是从JNI构造Java对象,并调用Java类中的成员方法,仅用作演示
    // 获取Person对象的class
    jclass jstu = env->FindClass("com/alphagl/main/Person");
    // 获取Person对象的构造方法的方法id
    jmethodID personMethodId = env->GetMethodID(jperson, "<init>", "(ILjava/lang/String;)V");
    // 构造一个String字符串
    jstring name = env->NewStringUTF("bill");

    // 构造一个Person对象
    jobject  jPersonObj = env->NewObject(jstu, personMethodId, 30, name);
    // 获取Person对象的printPerson成员方法的方法id
    jmethodID jid = env->GetMethodID(jstu, "printPerson", "()V");
    // 调用java的printPerson方法
    env->CallVoidMethod(jPersonObj, jid);
}


JNIEXPORT jobject JNICALL Java_com_alphagl_main_JNIUtils_getPersonFromJNI(JNIEnv *env, jclass jcls) {
    LOGD(" ====================== getPersonFromJNI");
    // 获取Person对象的class
    jclass jstudent = env->FindClass("com/alphagl/main/Person");
    // 获取Person对象的构造方法的方法id
    jmethodID studentMethodId = env->GetMethodID(jstudent, "<init>", "(ILjava/lang/String;)V");
    // 构造一个String字符串
    jstring name = env->NewStringUTF("john");
    // 构造一个Person对象
    jobject  jstudentObj = env->NewObject(jstudent, studentMethodId, 20, name);

    return jstudentObj;
}

那边再提一下,如上`JNIUtils.java`类中定义好了native方法,如何依照目的的点子签名生成对应的C/C++方法的扬言。那有个别剧情在Android游戏开发执行(1)之NDK与JNI开发01
已经涉嫌过,大家能够凭借javah来依照编译后的.class变动对于的头文件。
万般做法是:
图片 1

在AndroidStudio中可以:
Tools-> External Tools -> 添加
图片 2
(1)javah所在的路线
(2)命令行参数
(3)头文件生成的路径

图片 3
在宣称了native方法的类,右键执行javah即可。

(2)动态注册的办法
工程组织如下:(那里只列举出主要表达的项)

JNISample2  
  │── build.gradle
  │── CMakeLists.txt 
  └── app 
      ├── build.gradle
      ├── CMakeLists.txt
      └── src 
          ├── cpp
          │   └── JNIUtils.cpp
          │    
          └── com.alphagl.main
                    ├── JNIUtils.java
                    ├── MainActivity.Java
                    └── Person.java

此处关键看下分歧的代码部分,即JNIUtils.cpp
JNIUtils.cpp

#include <jni.h>
#include <string>
#include <android/log.h>

#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "MainActivity", __VA_ARGS__)
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "MainActivity", __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROE, "MainActivity", __VA_ARGS__)

#define CLASSNAME "com/alphagl/main/JNIUtils"

static jstring getStringFromJNI_native(JNIEnv *env, jclass jcls) {
    LOGD(" ====================== getStringFromJNI");
    // 构造一个String字符串
    return env->NewStringUTF("Hello from jni");
}

static jarray getIntArrayFromJNI_native(JNIEnv *env, jclass jcls) {
    LOGD(" ====================== getIntArrayFromJNI");
    // 构造一个int[]数组
    jintArray intArray = env->NewIntArray(2);
    int size[]={640, 960};
    // 给int[]数组赋值
    env->SetIntArrayRegion(intArray, 0, 2, size);

    return intArray;
}

static void setJniPerson_native(JNIEnv *env, jclass jcls, jobject jobj) {
    LOGD(" ====================== setPersonToJNI");
    jclass jperson = env->GetObjectClass(jobj);
    if (jperson != NULL) {
        // 获取Person对象的age字段id
        jfieldID ageFieldId = env->GetFieldID(jperson, "age", "I");
        // 获取Person对象的name字段id
        jfieldID nameFieldId = env->GetFieldID(jperson, "name", "Ljava/lang/String;");

        // 获取Person的age成员变量
        jint age = env->GetIntField(jobj, ageFieldId);
        // 获取Person的name成员变量
        jstring name = (jstring)env->GetObjectField(jobj, nameFieldId);

        const char *c_name = env->GetStringUTFChars(name, NULL);

        // 打印从Java传递过来的Person对象的age和name变量
        LOGD("age ===== %d, name ===== %s", age, c_name);
    }

    // 以下是从JNI构造Java对象,并调用Java类中的成员方法,仅用作演示
    // 获取Person对象的class
    jclass jstu = env->FindClass("com/alphagl/main/Person");
    // 获取Person对象的构造方法的方法id
    jmethodID personMethodId = env->GetMethodID(jperson, "<init>", "(ILjava/lang/String;)V");
    // 构造一个String字符串
    jstring name = env->NewStringUTF("bill");

    // 构造一个Person对象
    jobject  jPersonObj = env->NewObject(jstu, personMethodId, 30, name);
    // 获取Person对象的printPerson成员方法的方法id
    jmethodID jid = env->GetMethodID(jstu, "printPerson", "()V");
    // 调用java的printPerson方法
    env->CallVoidMethod(jPersonObj, jid);
}

static jobject getJniPerson_native(JNIEnv *env, jclass jcls) {
    LOGD(" ====================== getPersonFromJNI");
    // 获取Person对象的class
    jclass jstudent = env->FindClass("com/alphagl/main/Person");
    // 获取Person对象的构造方法的方法id
    jmethodID studentMethodId = env->GetMethodID(jstudent, "<init>", "(ILjava/lang/String;)V");
    // 构造一个String字符串
    jstring name = env->NewStringUTF("john");
    // 构造一个Person对象
    jobject  jstudentObj = env->NewObject(jstudent, studentMethodId, 20, name);

    return jstudentObj;
}

static JNINativeMethod gMethods[] = {
        {"getStringFromJNI", "()Ljava/lang/String;", (void*)getStringFromJNI_native},
        {"getIntArrayFromJNI", "()[I", (void*)getIntArrayFromJNI_native},
        {"setPersonToJNI", "(Lcom/alphagl/main/Person;)V", (void*)setJniPerson_native},
        {"getPersonFromJNI", "()Lcom/alphagl/main/Person;", (void*)getJniPerson_native}
};

static jint registerNativeMethods(JNIEnv *env, const char* className, JNINativeMethod *gMethods, int numMethods) {
    jclass jcls;
    jcls = env->FindClass(className);
    if (jcls == NULL) {
        return JNI_FALSE;
    }

    if (env->RegisterNatives(jcls, gMethods, numMethods) < 0) {
        return JNI_FALSE;
    }

    return JNI_TRUE;
}

static jint registerNative(JNIEnv *env) {
    return registerNativeMethods(env, CLASSNAME, gMethods, sizeof(gMethods) / sizeof(gMethods[0]));
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv *env = NULL;
    if ((vm->GetEnv((void**)&env, JNI_VERSION_1_6)) != JNI_OK) {
        return JNI_ERR;
    }

    if (!registerNative(env)) {
        return JNI_ERR;
    }

    return JNI_VERSION_1_6;
}

最终的履行结果为:
图片 4

二种完毕格局相比:
(1)动态注册中,能够不用申明形如Java_packageName_className_methodName格式的法门。
(2)动态注册中,要重写JNI_OnLoad主意,手动调用RegisterNatives来注册本地点法,以及表明在JNINativeMethod中。
(3)动态注册,显然那种措施更灵活,但对代码须求更高,推荐应用那种艺术。

上述示例代码都已上传Github,有须求的能够自动查看。
https://github.com/cnsuperx/android-jni-example

JNI调试

若果设置了LLVM环境的话,间接将Jni
Debuggable选项打开即可。环境搭建可以参照Android游戏开发执行(1)之NDK与JNI开发03
图片 5

继而直接在C或C++代码中安装断点即可。

技术交流QQ群:528655025
作者:AlphaGL
出处:http://www.cnblogs.com/alphagl/
版权全数,欢迎保留原版的书文链接举行转载 🙂