首页 > 代码库 > Android jni/ndk编程二:jni数据类型转换(primitive,String,array)

Android jni/ndk编程二:jni数据类型转换(primitive,String,array)

一.数据类型映射概述

从我们开始jni编程起,就不可能避开函数的参数与返回值的问题。java语言的数据类型和c/c++有很多不同的地方,所以我们必须考虑当在java层调用c/c++函数时,怎么正确的把java的参数传给c/c++函数,怎么正确的从c/c++函数获取正确的函数返回值;反之,当我们在c/c++中使用java的方法或属性时,如何确保数据类型能正确的在java和c/c++之间转换。 
回顾我们上一篇文章中的那个c函数:

#include <stdio.h>
#include <jni.h>
#include <stdlib.h>
JNIEXPORT jstring JNICALL Java_com_jinwei_jnitesthello_MainActivity_sayHello(JNIEnv * env, jobject obj){
    return (*env)->NewStringUTF(env,"jni say hello to you");
}

这个函数非常简单,它没有接受参数,但是它返回了一个字符串给java层。我们不能简单的使用return “jni say hello to you”;而是使用了NewStringUTF函数做了个转换,这就是数据类型的映射。 
普通的jni函数一般都会有两个参数:JNIEnv * env, jobject obj,第三个参数起才是该函数要接受的参数,所以这里说它没有接受参数。

1.1JNIEnv * env

JNIEnv是一个线程相关的结构体, 该结构体代表了 Java 在本线程的运行环境 。这意味不同的线程各自拥有各一个JNIEnv结构体,且彼此之间互相独立,互不干扰。NIEnv结构包括了JNI函数表,这个函数表中存放了大量的函数指针,每一个函数指针又指向了具体的函数实现,比如,例子中的NewStringUTF函数就是这个函数表中的一员。 
JVM,JNIEnv与native function的关系可用如下图来表述: 
技术分享

1.2 jobject obj

这个参数的意义取决于该方法是静态还是实例方法(static or an instance method)。 
当本地方法作为一个实例方法时,第二个参数相当于对象本身,即this. 当本地方法作为 
一个静态方法时,指向所在类. 在本例中,sayHello方法是实例方法,所以obj就相当于this指针。

二.基本数据类型的映射

在Java中有两类数据类型:primitive types,如,int, float, char;另一种为 
reference types,如,类,实例,数组。 
java基本类型与c/c++基本类型可以直接对应,对应方式由jni规范定义: 
技术分享 
JNI基本数据类型的定义在jni.h中:

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 */

也就是说jni.h中定义的数据类型已经是c/c++数据类型了,我们使用jint等类型的时候要明白其实使用的就是int 数据类型。

2.1实践

我们在上一篇博客中实现的程序的基础上进一步实验,现在给native_sayHello函数添加一个参数,c代码如下:

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



jstring native_sayHello(JNIEnv * env, jobject obj,jint num){
    char array[30];
    snprintf(array,30,"jni accept num : %d",num);
    return (*env)->NewStringUTF(env,array);
}

static JNINativeMethod gMethods[] = {  
{"sayHello", "(I)Ljava/lang/String;", (void *)native_sayHello},  
};  

JNIEXPORT jint  JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)  
{  
    JNIEnv* env = NULL; //注册时在JNIEnv中实现的,所以必须首先获取它
    jint result = -1;

    if((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_4) != JNI_OK) //从JavaVM获取JNIEnv,一般使用1.4的版本
      return -1;

    jclass clazz;
    static const char* const kClassName="com/jinwei/jnitesthello/MainActivity";

    clazz = (*env)->FindClass(env, kClassName); //这里可以找到要注册的类,前提是这个类已经加载到java虚拟机中。 这里说明,动态库和有native方法的类之间,没有任何对应关系。

    if(clazz == NULL)
    {
      printf("cannot get class:%s\n", kClassName);
      return -1;
    }

    if((*env)->RegisterNatives(env,clazz,gMethods, sizeof(gMethods)/sizeof(gMethods[0]))!= JNI_OK) //这里就是关键了,把本地函数和一个java类方法关联起来。不管之前是否关联过,一律把之前的替换掉!
    {
      printf("register native method failed!\n");
      return -1;
    } 

    return JNI_VERSION_1_4;  
}

这里还是使用动态的方式注册本地方法,相比较之前的代码,这里只做了两处修改: 
1.native_sayHello增加了一个参数jint num; 
2.函数签名也随之改变: “(I)Ljava/lang/String;”,之前是 “()Ljava/lang/String;” 
Android层的代码也随之改变:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.text);
        String hehe =  this.sayHello(12345);
        textView.setText(hehe);
    }
    public native  String sayHello(int num);

这样就会在TextView中显示出jni accept num : 12345。 
这个实验验证了java基本类型可以直接对应到c/c++的基本类型。

三.字符串的转换

java的String与c/c++的字符串有很大不同,二者之间不能直接对应,其转换需要通过jni函数来实现。 
jni支持Unicode和utf-8两种编码格式的转换。Unicode代表的了16-bit字符集,utf-8则兼容ASCII码,java虚拟机使用的Unicode编码,c/c++则默认使用ASCII码。这因为jni支持Unicode和utfbain吗之间的转换,所以我们可以使用Jni规范提供的函数在java与c/c++之间转换数据类型。 
这一节我们从字符串说起,jni使用的字符串类型是jstring,我们先看看它的定义: 
c++中:

class _jobject {};
class _jstring : public _jobject {};
typedef _jstring*       jstring;

可见在c++中jstring是_jsting*类型的指针,_jstring是一个继承了_jobject类的类。 
c中:

typedef void*           jobject;
typedef jobject         jstring;

可见jstring就是一个void *类型的指针。

3.1 java->native

java虚拟机传递下来的字符串是存储在java虚拟机内部的字符串,这个字符串当然使用的是Unicode编码了,使用c编程的时候,传递下来的jstring类型是一个void *类型的指针,它指向java虚拟机内部的一个字符串,我们不能使用这个字符串,是因为它的编码方式是Unicode编码,我们需要把它转换为utf-8编码格式,这样我们就可以在c/c++中访问这个转换后的字符串了。 
我们可以使用jni规范提供的一下连个函数转换Unicode编码和utf-8编码:

    const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);

使用GetStringUTFChars函数时,要记得检测其返回值,因为调用该函数会有内存分配操作,失败后,该函数返回NULL,并抛OutOfMemoryError异常。 
调用完GetStringUTFChars函数后,我们还要调用ReleaseStringUTFChars函数释放在GetStringUTFChars中分配的内存。不释放的话就会出现内存泄漏了。

3.2 native->java

有了以上两个函数,我们就可以把java中的字符串转换为c/c++中使用的字符串了,而把c/c++使用的字符串转换为java使用的字符串这件事我们之前已经做过了,我们可以使用使用NewStringUTF构造java.lang.String;如果此时没有足够的内存,NewStringUTF将抛OutOfMemoryError异常,同时返回NULL。 
NewStringUTF定义如下:

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

可见它接受一个char 类型的指针,char 就是我们可以在c/c++中用来指向字符串的指针了。 
通过以上的学习,我们可以尝试使用这三个方法做个验证了,还是在原来的基础上修改.

3.3实站

这次实战,我们要开始使用android的logcat工具了,这个工具可以打印一些Log出来,方便我们使用。使用android logcat只需三步: 
1.包含头文件

#include <android/log.h>

2.配置Android.mk 
在Android.mk中添加: LOCAL_LDLIBS := -llog 
3.定义LOGI,LOGE等宏 
在使用前:

#define LOG_TAG   "HELLO_JNI"

#define  LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)

#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)

这样我们就可以使用LOGI,LOGE来打印我们的Log了。 
jni方法只是改为传递一个字符串进去:

jstring native_sayHello(JNIEnv * env, jobject obj,jstring str){
    LOGE("JNI: native_sayHello");
    char array[50];
    char array1[50];
    const char * local_str = (*env)->GetStringUTFChars(env,str,NULL);
    LOGE("local_str: %s,length:%d",local_str,strlen(local_str));
    strncpy(array,local_str,strlen(local_str)+1);
    (*env)->ReleaseStringUTFChars(env,str,local_str);
    LOGE("array: %s",array);
    snprintf(array1,sizeof(array),"jni : %s",array);
    LOGE("array1: %s",array1);
    return (*env)->NewStringUTF(env,array1);
}

我们只是做了轻微的改动,native_sayHello接受一个jstring类型的参数,我们把这个参数转换为utf-8格式的字符串,然后添加一点我们Local的信息,然后再返回给java层。假如我们在android中这样调用native方法: 
String hehe = this.sayHello(“Java say hello to jni”); 
此时,app就会显示: 
jni:java say hello to jni

以上我们对java字符串和c/c++之间字符串的转换做了简单的学习和尝试。jni规范还提供了许多用于字符串处理的函数:

    jsize       (*GetStringLength)(JNIEnv*, jstring);
    const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*);

这三个函数用于操作unicode字符串。当jstring指向一个unicode字符串时,我们可以使用GetStringLength获取这个unicode字符串的长度。unicode字符串不同于utf-8格式的字符串,utf-8格式的字符串一‘\0’结尾,unicode编码的字符串则不同,因此,我们需要GetStringLength来获得unicode字符串的长度。 
GetStringChars与ReleaseStringChars用来获取和释放unicode编码的字符串,一般不怎么用,但如果操作系统支持unicode编码的话,这两个函数会很有用。 
GetStringChars与GetStringUTFChars的第三个参数需要做进一步解释。如果我们使用他们中的某一个函数从JVM中获得一个字符串,我们不知道这个字符串是指向JVM中的原始字符串还是是一份原始字符串的拷贝,但我们可以通过第三个参数来得知这一信息。这一信息是有用的,我们知道JVM中的字符串是不能更改的,如果获得的字符串是JVM中的原始字符串,第三个参数就为JNI_FALSE,那我们不可以修改它,但如果它是一份拷贝,第三个参数就为JNI_TRUE,则意味着我们可以修改它。 
通常我们不关心它,只需要把第三个参数置为NULL即可。

四.jdk 1.2中新的字符串操作函数

4.1Get/RleaseStringCritical

为尽可能的避免内存分配,返回指向java.lang.String内容的指针,Java 2 SDKrelease 1.2提供了:Get/RleaseStringCritical. 这对函数有严格的使用原则。当使用这对函数时,这对函数间的代码应被当做临界区(critical region). 在该代码区,不要调用任何会阻塞当前线程和分配对象的JNI函数,如IO之类的操作。上述原则,可以避免JavaVM执行GC。因为在执行Get/ReleaseStringCritical区的代码 
时,GC被禁用了,如果因某些原因在其他线程中引发了JavaVM执行GC操作,VM有死锁的危险:当前线程A进入Get/RelaseStringCritical区,禁用了GC,如果其他线程B中有GC请求,因A线程禁用了GC,所以B线程被阻塞了;而此时,如果B线程被阻塞时已经获得了一个A线程执行后续工作时需要的锁;死锁发生了。 
jni不支持Get/RleaseStringUTFCritical这样的函数,因为一旦涉及到字符串编码的转换,便使java虚拟机产生对数据的赋值行为,这样无法避免没存分配。 
为避免死锁,此时应尽量避免调用其他JNI方法。

4.2GetStringRegion/GetStringUTFRegion

这两个函数的作用是向准备好的缓冲区写数据进去。

    void        (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*);
    void        (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*);

简单用法举例:

char outbuf[128];
int len = (*env)->GetStringLength(env, prompt);
(*env)->GetStringUTFRegion(env, prompt, 0, len, outbuf);

其中prompt是java层传下来的字符串。这个函数可以直接把jstring类型的字符串写入到outbuf中。这个函数有三个参数:第一个是outbuf的其实位置,第二个是写入数据的长度,第三个参数是outbuf。注意,数据的长度是unicode编码的字符串长度,我们需要使用GetStringLength来获取。

注:GetStringLength/GetStringUTFLength这两个函数,前者是Unicode编码长度,后者 
是UTF编码长度。

五.jni字符串操作函数总结

且看下图: 
技术分享

六.jni字符串操作函数总结

对于小尺寸字串的操作,首选Get/SetStringRegion和Get/SetStringUTFRegion,因为栈 
上空间分配,开销要小的多;而且没有内存分配,就不会有out-of-memory exception。如 
果你要操作一个字串的子集,这两个函数函数的starting index和length正合要求。

GetStringCritical/ReleaseStringCritical函数的使用必须非常小心,他们可能导致死锁。

七.访问数组

JNI处理基本类型数组和对象数组的方式是不同的。

7.1访问基本类型数组

JNI支持通过Get/ReleaseArrayElemetns返回Java数组的一个拷贝(实现优良的 
VM,会返回指向Java数组的一个直接的指针,并标记该内存区域,不允许被GC)。 
jni.h中的定义如下:

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

GetArrayRegion函数可以把获得的数组写入一个提前分配好的缓冲区中。 
SetArrayRegion可以操作这一缓冲区。 
其定义如下:

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

    /* spec shows these without const; some jni.h do, some don‘t */
    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*);

GetArrayLength函数可以获得数组中元素个数,其定义如下:

    jsize       (*GetArrayLength)(JNIEnv*, jarray);

jni操作原始类型数组的函数总结如下: 
技术分享

7.2实战尝试

我们修改之前的native_sayHello函数,让它接受数组作为参数:

jint native_sayHello(JNIEnv * env, jobject obj,jintArray arr){
    jint *carr;
    jint i, sum = 0;
    carr = (*env)->GetIntArrayElements(env, arr, NULL);
    if (carr == NULL) {
    return 0; /* exception occurred */
    }
    jint length = (*env)->GetArrayLength(env,arr);
    for (i=0; i<length; i++) {
        LOGE("carr[%d]=%d",i,carr[i]);
    sum += carr[i];
    }
    (*env)->ReleaseIntArrayElements(env, arr, carr, 0);
    return sum;

}

不要忘记修改函数签名:

static JNINativeMethod gMethods[] = {  
{"sayHello", "([I)I", (void *)native_sayHello},  
};  

java层调用如下:

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.text);
        int a[] = {1,2,3,4,5,6,7,8,9};
        String hehe =  "num: "+String.valueOf(this.sayHello(a));
        textView.setText(hehe);
    }
    public native  int sayHello(int [] arr);

打印如下:

09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[0]=1
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[1]=2
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[2]=3
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[3]=4
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[4]=5
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[5]=6
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[6]=7
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[7]=8
09-22 12:17:54.365 28093-28093/com.jinwei.jnitesthello E/HELLO_JNI: carr[8]=9

7.3访问对象数组

对于对象数组的访问,使用Get/SetObjectArrayElement,对象数组只提供针对数组的每 
个元素的Get/Set,不提供类似Region的区域性操作。 
对象数组的操作主要有如下三个函数:

 jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject);
    jobject     (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);
    void        (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);

这三个方法的使用通过下面的实战来讲解。

7.4实战体验

我们在下面的实战中作如下尝试: 
1.java层传入一个String a[] = {“hello1”,”hello2”,”hello3”,”hello4”,”hello5”}; 
2.native打印出每一个值。 
3.native创建一个String数组, 
4.返回给java,java显示出这个字符串数组的所有成员 
native实现方法: 
我们新增一个函数来实现上面要求。

jobjectArray native_arrayTry(JNIEnv * env, jobject obj,jobjectArray arr){
    jint length = (*env)->GetArrayLength(env,arr);
    const char * tem ;
    jstring larr;
    jint i=0;
    for(i=0;i<length;i++){
        //1.获得数组中一个对象
        larr = (*env)->GetObjectArrayElement(env,arr,i);
        //2.转化为utf-8字符串
        tem = (*env)->GetStringUTFChars(env,larr,NULL);
        //3.打印这个字符串
        LOGE("arr[%d]=%s",i,tem);
        (*env)->ReleaseStringUTFChars(env,larr,tem);
    }
    jobjectArray result;
    jint size = 5;
    char buf[20];

    //1.获取java.lang.String Class
    jclass intArrCls = (*env)->FindClass(env,"java/lang/String");
    if (intArrCls == NULL) {
        return NULL; /* exception thrown */
    }
    //2. 创建java.lang.String数组
    result = (*env)->NewObjectArray(env, size, intArrCls, NULL);
    if (result == NULL) {
        return NULL; /* out of memory error thrown */
    }
    //3.设置数组中的每一项,分别为jni0,jni1,jni2,jni3,jni4
    for (i = 0; i < size; i++) {
        larr =  (*env)->GetObjectArrayElement(env,result,i);
        snprintf(buf,sizeof(buf),"jni%d",i);
        (*env)->SetObjectArrayElement(env, result, i,(*env)->NewStringUTF(env,buf) );
    }
    //4.返回array
    return result;

}

方法签名:

static JNINativeMethod gMethods[] = {  
{"sayHello", "([I)I", (void *)native_sayHello},  
{"arrayTry","([Ljava/lang/String;)[Ljava/lang/String;",(void *)native_arrayTry},
};  

java层调用:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.text);
        String a[] = {"hello1","hello2","hello3","hello4","hello5"};
        String []strings = this.arrayTry(a);
        StringBuilder stringBuilder = new StringBuilder();
        for(String s:strings){
            stringBuilder.append(s);
        }
        textView.setText(stringBuilder.toString());
    }
    public native  int sayHello(int []arr);
    public native String[] arrayTry(String [] arr);
}

Android jni/ndk编程二:jni数据类型转换(primitive,String,array)