2. 程式人生 > >Android jni/ndk編程三：native訪問java

Android jni/ndk編程三：native訪問java

阿新 • • 發佈：2017-05-23
efi pan exp exc save protect uil arm 註冊方法

一.訪問靜態字段

Java層的field和method，不管它是public，還是package、private和protected，從
JNI都可以訪問到，Java面向語言的封裝性不見了。
靜態字段和非靜態的字段訪問方式不同，jni規範提供了一系列帶static標示的訪問靜態字段的函數：

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

訪問流程：

  1. 獲得java層的類：jclass cls = (*env)->GetObjectClass(env, obj);
  2. 獲得字段的ID:jfieldID fid = (*env)->GetStaticFieldID(env, cls, “s”, “Ljava/lang/String;”);
  3. 獲得字段的值：jstring jstr = (*env)->GetStaticObjectField(env, cls, fid);
  4. 設置字段的值：(*env)->SetStaticObjectField(env, cls, fid, jstr);

按照以上的流程，參照上面訪問靜態字段的函數定義，寫如下測試代碼：


void  native_accessJava(JNIEnv * env, jobject obj){
    LOGE("lstr:native_accessJava");
    //1. 獲得java層的類：jclass cls = (*env)->GetObjectClass(env, obj);
    jclass cls = (*env)->GetObjectClass(env, obj);
    //2. 獲得字段的ID:jfieldID fid = (*env)->GetStaticFieldID(env, cls, "s", "Ljava/lang/String;");
    jfieldID fid = (*env)->GetStaticFieldID(env, cls, "s", "Ljava/lang/String;");
    if (fid == NULL) {
        LOGE("get feild id error");
        return; /* failed to find the field */
    }
    //3. 獲得字段的值：jstring jstr = (*env)->GetStaticObjectField(env, cls, fid);
    jstring jstr = (*env)->GetStaticObjectField(env, cls, fid);
    LOGE("lstr:native_accessJava");
    const char * lstr = (*env)->GetStringUTFChars(env,jstr,NULL);
    LOGE("lstr: %s",lstr);
    (*env)->ReleaseStringUTFChars(env,jstr,lstr);
    //4. 設置字段的值：(*env)->SetStaticObjectField(env, cls, fid, jstr);
    jstr = (*env)->NewStringUTF(env, "jni set");
    if (jstr == NULL) {
        return; /* out of memory */
    }
    (*env)->SetStaticObjectField(env, cls, fid, jstr);
}

註冊方法的數組：

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

java中訪問的代碼：

public class MainActivity extends AppCompatActivity {
    TextView textView = null;
    static String s = "java str";
    static {
        System.loadLibrary("hello");
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.text);
        accessJava();
        textView.setText(s);
    }
    public native  int sayHello(int []arr);
    public native String[] arrayTry(String [] arr);
    public native void accessJava();
}

在jni代碼所在目錄執行adk-build命令，把編譯生成的libhello.so文件拷貝到Android工程的jniLibs目錄下，運行android程序即可看到現象。

二.訪問實例字段

有了訪問靜態字段的經歷，在去寫訪問實例字段的代碼就簡單多了，這裏總結下使用流程：

  1. 獲得java層的類：jclass cls = (*env)->GetObjectClass(env, obj);
  2. 獲得字段的ID:jfieldID fid = (*env)->GetFieldID(env, cls, “ss”, “Ljava/lang/String;”);
  3. 獲得字段的值：jstring jstr = (*env)->GetObjectField(env, obj, fid);
  4. 設置字段的值：(*env)->SetObjectField(env, obj, fid, jstr);

在寫代碼之前，先看一下jni.h中定義的訪問實例字段的函數：

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

可以看到訪問實例字段的函數和訪問靜態字段的函數在名字上就有區別，而且一定要註意的是，訪問實例字段函數的第三個參數是jobject，是一個對象，而訪問靜態字段的第三個參數是jclass，是一個類。

我們使用上面給出的函數和我們總結的使用流程寫如下代碼：

void  native_accessinstanceJava(JNIEnv * env, jobject obj){
    LOGE("lstr:native_accessinstanceJava");
    //1. 獲得java層的類：jclass cls = (*env)->GetObjectClass(env, obj);
    jclass cls = (*env)->GetObjectClass(env, obj);
    //2. 獲得字段的ID:jfieldID fid = (*env)->GetFieldID(env, cls, "ss", "Ljava/lang/String;");
    jfieldID fid = (*env)->GetFieldID(env, cls, "ss", "Ljava/lang/String;");
    if (fid == NULL) {
        LOGE("get feild id error");
        return; /* failed to find the field */
    }
    //3. 獲得字段的值：jstring jstr = (*env)->GetObjectField(env, cls, fid);
    jstring jstr = (*env)->GetObjectField(env, obj, fid);
    const char * lstr = (*env)->GetStringUTFChars(env,jstr,NULL);
    LOGE("lstr: %s",lstr);
    (*env)->ReleaseStringUTFChars(env,jstr,lstr);
    //4. 設置字段的值：(*env)->SetObjectField(env, cls, fid, jstr);
    jstr = (*env)->NewStringUTF(env, "jni set");
    if (jstr == NULL) {
        return; /* out of memory */
    }
    (*env)->SetObjectField(env, obj, fid, jstr);
}

註冊方法的數組：

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

};

JNI_OnLoad等方法請參考之前的博客。
java層調用很非常簡單，這裏就不貼了。

三.訪問靜態方法

靜態方法的訪問總結為兩步：
? 首先通過GetStaticMethodID在給定類中查找方法
如：jmethodID mid = (*env)->GetStaticMethodID(env,cls,”changeStr”,”()V”);
? 通過CallStaticMethod調用
如：(*env)->CallStaticVoidMethod(env, cls, mid);
jni中定義的訪問靜態方法的函數有如下一些：

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

結合上面總結的流程和jni.h中定義的函數，寫如下測試代碼：
代碼功能：調用java層的靜態方法，修改靜態字段的值，把修改後的字段的值使用TextView顯示出來。

void  native_staticMethod(JNIEnv * env, jobject obj){
    LOGE("native_staticMethod");
    //1.獲得類中方法id
    jclass cls = (*env)->GetObjectClass(env, obj);
    jmethodID mid = (*env)->GetStaticMethodID(env,cls,"changeStr","()V");
    if (mid == NULL) {
        LOGE("GetStaticMethodID error");
        return; /* method not found */
    }
    LOGE("GetStaticMethodID sucess");

    //2.調用CallStatic<ReturnValueType>Method函數調用對應函數.
    (*env)->CallStaticVoidMethod(env, cls, mid);
}

註冊方法的數組：

static JNINativeMethod gMethods[] = {  
{"sayHello", "([I)I", (void *)native_sayHello},  
{"arrayTry","([Ljava/lang/String;)[Ljava/lang/String;",(void *)native_arrayTry},
{"accessJava","()V",(void *)native_accessJava},
{"accessinstanceJava","()V",(void *)native_accessinstanceJava},
{"staticMethod","()V",(void *)native_staticMethod},
};

添加了staticMethod方法的註冊。
java層的調用：

public class MainActivity extends AppCompatActivity {
    TextView textView = null;
    static String s = "java str";
    String ss = "instance str";
    static {
        System.loadLibrary("hello");
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.text);
        staticMethod();
        textView.setText(s);
    }
    public native  int sayHello(int []arr);
    public native String[] arrayTry(String [] arr);
    public native void accessJava();
    public native void accessinstanceJava();
    public native void staticMethod();
    public static void changeStr(){
        s = "chang str";
    }
}

四.訪問實例方法

訪問實例方法與訪問靜態方法類似，要註意的主要是：實例方法是屬於對象jobject的，而靜態方法是屬於類的。

4.1普通實例方法

訪問普通的實例方法的步驟還是總結為兩步：
? 首先通過GetMethodID在給定類中查找方法
如：jmethodID mid = (*env)->GetMethodID(env,cls,”changeStr”,”()V”);
? 通過CallMethod調用
如：(*env)->CallStaticVoidMethod(env, obj, mid);

jni.h中定義的訪問實例方法的相關函數有：

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

4.2被子類覆蓋的父類方法

我們看到了很多Nonvirtual方法，這是jni提供用來訪問被子類賦給的父類的方法的，使用步驟如下：
調用被子類覆蓋的父類方法: JNI支持用CallNonvirtualMethod滿足這類需求:
? GetMethodID獲得method ID
? 調用CallNonvirtualVoidMethod, CallNonvirtualBooleanMethod
上述，等價於如下Java語言的方式：
super.f();
CallNonvirtualVoidMethod可以調用構造函數

4.3構造函數

你可以像調用實例方法一樣，調用構造方法，只是此時構造函數的名稱叫做””.

綜合上面三個知識點，我們設計如下代碼時間這些知識：
1.在c函數中調用String類的構造函數新建一個字符串對象。
2.調用java的實例方法，傳入我們1中構建的字符串對象，修改TextView的內容。
代碼如下：

void  native_instanceMethod(JNIEnv * env, jobject obj){
    LOGE("native_instanceMethod");
    //1.使用String類的構造函數構造String
    //1.1找到String類
    jclass  stringClass = (*env)->FindClass(env, "java/lang/String");
    if (stringClass == NULL) {
        LOGE("FindClass error");
        return;
    }
    //1.2找到String類的構造函數
    jmethodID cid = (*env)->GetMethodID(env, stringClass, "<init>", "([C)V");
    if (cid == NULL) {
        LOGE("GetMethodID <init> error");
        return; /* exception thrown */
    }
    //1.3創建字符數組
    jint len = 10;
    jcharArray elemArr = (*env)->NewCharArray(env, len);
    if (elemArr == NULL) {
        LOGE("NewCharArray  error");
        return; /* exception thrown */
    }
    jchar java_char[]={97,98,99,100,101,102,103,104,105,106};//abcdefghij
    //1.4設置字符數組
    (*env)->SetCharArrayRegion(env, elemArr, 0, len, java_char);
    //1.5 創建一個字符串對象
    jstring result = (*env)->NewObject(env, stringClass, cid, elemArr);
    //2.獲得類中方法id
    jclass cls = (*env)->GetObjectClass(env, obj);
    jmethodID mid = (*env)->GetMethodID(env,cls,"changeTextView","(Ljava/lang/String;)V");
    if (mid == NULL) {
        LOGE("GetMethodID error");
        return; /* method not found */
    }
    LOGE("GetMethodID sucess");

    //2.調用Call<ReturnValueType>Method函數調用對應函數.
    (*env)->CallVoidMethod(env, obj, mid,result);
}

註冊方法的數組：

static JNINativeMethod gMethods[] = {  
{"sayHello", "([I)I", (void *)native_sayHello},  
{"arrayTry","([Ljava/lang/String;)[Ljava/lang/String;",(void *)native_arrayTry},
{"accessJava","()V",(void *)native_accessJava},
{"accessinstanceJava","()V",(void *)native_accessinstanceJava},
{"staticMethod","()V",(void *)native_staticMethod},
{"instanceMethod","()V",(void *)native_instanceMethod},

};

java層調用：

static JNINativeMethod gMethods[] = {  
{"sayHello", "([I)I", (void *)native_sayHello},  
{"arrayTry","([Ljava/lang/String;)[Ljava/lang/String;",(void *)native_arrayTry},
{"accessJava","()V",(void *)native_accessJava},
{"accessinstanceJava","()V",(void *)native_accessinstanceJava},
{"staticMethod","()V",(void *)native_staticMethod},
{"instanceMethod","()V",(void *)native_instanceMethod},

};

訪問實例方法的實驗到此結束。

五.性能與優化

5.1緩存Field 和 Method IDs

每次獲得Field和Method IDS都比較耗時，如果我們需要多次獲取他們，那就應該把它們緩存起來，這樣以後用的時候就可以直接用了，從而節約了時間。
緩存的方式可以使用局部static字段緩存，也可以在類的初始化時，一次性緩存好全部的Field 和 Method IDs。
上述第一次使用緩存的方式，每次都有與NULL的判斷，並且可能有一個無害的競爭條件。
而初始化類時，同時初始化JNI層對該類成員的緩存，可以彌補上述缺憾。

5.2影響jni回調性能的因素

首先比較Java/native和Java/Java
前者因下述原因可能會比後者慢：
? Java/native與Java/Java的調用約定不同. 所以，VM必須在調用前，對參數和調用
棧做特殊準備
? 常用的優化技術是內聯. 相比Java/Java調用，Java/native創建內聯方法很難
粗略估計：執行一個Java/native調用要比Java/Java調用慢2-3倍. 也可能有一些VM實
現，Java/native調用性能與Java/Java相當。(此種虛擬機，Java/native使用Java/Java
相同的調用約定)。
其次比較native/Java與Java/Java
native/Java調用效率可能與Java/Java有10倍的差距，因為VM一般不會做Callback的
優化。

Android jni/ndk編程三：native訪問java

相關推薦

Android jni/ndk編程三：native訪問java

efi pan exp exc save protect uil arm 註冊方法 一.訪問靜態字段 Java層的field和method，不管它是public，還是package、private和protected，從 JNI都可以訪問到，Java面向語言的封裝性不見了。

Android問題集錦轉載之三：Javah 常見錯誤記錄-NDK與JNI除錯

測試檔案：hello-jni/src/com/example/hellojni/HelloJni.java/** * 該檔案來自 Android NDK Sample - HelloJni， 為了便於說明問題，我作了一些修改。 */ package com.example

java並發編程實戰：第三章----對象的共享

AS -h -- 可變 分享 array 方法 ava thread 我們不僅僅希望防止某個線程使用某個狀態時，另一個線程在修改它；我們還希望某個線程修改了某個狀態後，其他線程能夠看到狀態的變化。 一、可見性 重排序：在沒有同步的情況下，編譯器、處理器可能對代碼的執行順

【Java並發編程】：守護線程與線程阻塞的四種情況

情況 字節 lin eight 業務 普通 sta dsta state 守護線程 JAVA中有兩類線程：User Thread(用戶線程)、Daemon Thread(守護線程) 用戶線程即運行在前臺的線程，而守護線程是運行在後臺的線程。 守護線程作用是

詳解C# 網絡編程系列：實現類似QQ的即時通信程序

並且 會話 hat chat .sh odin unicode 情況 plist 引言： 前面專題中介紹了UDP、TCP和P2P編程，並且通過一些小的示例來讓大家更好的理解它們的工作原理以及怎樣.Net類庫去實現它們的。為了讓大家更好的理解我們平常中常見的軟件QQ的工作原理

怎樣自學編程——“三遍讀書法”

pop 不但 margin idt 它的 互聯 family article width 子以前曰過：天下武功，唯快不破。互聯網是個充滿挑戰和刺激的行業，知識更新和叠代之快。幾家歡喜幾家愁。 對於知識的更新速度，一些程序猿直呼：臣妾跟不上啊！！！ 而對於有的程序猿。他們

Android框架式編程之BufferKnife

there binder them fine eve 簡化 include nds support Android 開發過程中，我們需要寫大量的findViewById()和setonclicktListener()等事件， 那麽現在有一個框架可以很好的解決這個問題 ---

ufldl學習筆記與編程作業：Linear Regression（線性回歸）

cal bug war 環境 art link 行數 ear sad ufldl學習筆記與編程作業：Linear Regression（線性回歸） ufldl出了新教程，感覺比之前的好。從基礎講起。系統清晰，又有編程實踐。在deep learning高質量群裏

漫談並發編程(五)：線程之間的協作

版本 處理 clas ext edr locking throws try-catch [] 編寫多線程程序須要進行線程協作。前面介紹的利用相互排斥來防止線程競速是來解決線程協作的衍生危害的。編寫線程協作程序的關鍵是解決線程之間的協調問題，在這些任務中，某些能

Netty的http服務器編程(三)

socket mil sts 第一個 group eof pool nbsp last Netty提供的handler：HttpServerCodec http 請求編解碼處理類 第一個netty的例子，，server服務端的編寫，客戶端使用 curl ： ht

linux--shell編程(三)條件判斷及算術運算

寫一個腳本 head bsp 如何 cut inittab 引用 有用 color 練習：寫一個腳本判斷當前系統上是否有用戶的默認shell為bash； 如果有，就顯示有多少個這類用戶；否則，就顯示沒有這類用戶； #!/bin/bash # grep ‘\<ba

python開發編程基礎：函數定義，返回值，參數

pan span true 調用 odin pwd 括號 問題 pre 一，函數的定義 1，函數mylen叫做函數名　 #函數名　 #必須由字母下劃線數字組成，不能是關鍵字，不能是數字開頭　 #函數名還是要有一定的意義能夠簡單說明函數的功能2，def是關鍵字 （defi

Android網絡編程（一）HTTP協議原理

客戶 獲取版本 接口 開發人員 linu 系統 拒絕 sts inter 相關文章 Android網絡編程（一）HTTP協議原理 Android網絡編程（二）HttpClient與HttpURLConnection Android網絡編程（三）V

編程樂趣：身份證號碼驗證的方法

adl substring track content else if ont article name out 隨著如今互聯網的發展，越來越多的註冊用戶的地方都用到了身份證。那麽對於輸入的身份證怎樣驗證呢？看以下的代碼，事實上非常easy。主要註意的是，眼下的身份證分

異步編程(三)

pro c# back 之前 ack .cn href image manage 4. c#4.x Task的新特性 Async && Await這種編程方式是對之前Task的補充和擴展，簡化了異步編程，讓喜歡用同步編程的同學，使用起來更順手：static

android ——網絡編程

ins blog tco vertica ani n) exe lns amr 一、WebView 這個View就是一個瀏覽器，用於展示網頁的。 布局文件： 1 <LinearLayout xmlns:android="http://schemas.android

實驗吧編程題：字典

replace cti 分鐘 nbsp python line open pytho ict python編程實現 原題：包含ctf的單詞的總字符有多少？ 代碼： 1 list = [] 2 for line in open(‘dictionary/dictionary.

實驗吧編程題：百米

-c 第一次用 列表 color entry 網頁 www php -1 第一次用python寫關於表單自動提交的程序，不是特別簡練 題目是這樣的： 經過觀察，只有數字是變動的，運算符是不變的，這就容易很多了 思路： 抓取網頁內容 通過正則表達式提取數字內容 通過特定的

實驗吧編程題：雙基回文數

。。 進位 return for str print == 兩個 至少 原題： 計算大於正整數1600000的最小雙基回文數 格式：CTF{ } 雙基回文數：如果一個正整數n至少在兩個不同的進位制b1和b2下都是回文數（2<=b1,b2<=10），則稱n 是雙基

實驗吧編程題：Hashkill

island pen log lan iges col lag 下劃線 spa 原題：6ac66ed89ef9654cf25eb88c21f4ecd0是flag的MD5碼，（格式為ctf{XXX_XXXXXXXXXXX_XXXXX}）由一個0-1000的數字，下劃線，紐約的