Android JNI开发(2) Java ＜==＞ Native

最新推荐文章于 2024-07-04 16:27:20 发布
最新推荐文章于 2024-07-04 16:27:20 发布
阅读量228 收藏
点赞数
分类专栏： Android 文章标签： android jni native app java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hihan_5/article/details/118418175
版权

文章创建时间：2021-07-02，最后修改时间：2021-07-06

1、 静态注册与动态注册

前面一篇文章讲了Android JNI开发的简单Demo，但是可能还不能明白java层声明的方法，是怎么对应到jni函数的。这就要涉及到下面要讲的两种jni函数注册的方法了。

jni函数有两种注册方法：

  • 静态注册：
    先在Java层声明本地方法，然后在JNI层实现该声明方法；
  • 动态注册：
    先在JNI层重载JNI_OnLoad()实现本地方法，然后直接在Java层中调用本地方法。

上篇文章中Demo注册jni函数的途径是静态注册。

（1）静态注册

静态注册实现的大致流程：

当java虚拟机需要调用JAVA层声明一个本地方法，从加载的动态库中去寻找名字匹配特定格式的实现，找到了就建立关联，保存在函数指针中；找不到就报错。后面再访问java声明方法就直接调用到这个函数指针。

回顾一下上篇文章通过javah生成头文件的操作。

    // java中关于jni函数的声明
    public static native String getTextFromNDK();
/*
 * Class:     com_howie_ndkdemo_NDKTools
 * Method:    getTextFromNDK
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_howie_ndkdemo_NDKTools_getTextFromNDK
  (JNIEnv *, jclass);

根据上面的头文件，我们可以看出来静态注册的jni函数的特定格式为：

JNIEXPORT + 返回值 + JNICALL + Java_包名_类名_方法名 + 参数JNIEnv + 参数jobject + 参数other

这里注意的是，java包名的的"."都会替换为"_"；如果在Java中声明的方法是"static"，则jni函数也是static。

如果我们尝试将头文件和cpp文件中Java_com_howie_ndkdemo_NDKTools_getTextFromNDK改成Java_com_howie_ndkdemo_NDKTools_getTextFromNDKs，即不满足上述的特定格式，这时候再编译运行app，点击按钮后，会报如下的error：

2021-07-03 12:45:06.762 22626-22626/com.howie.ndkdemo E/m.howie.ndkdem: No implementation found for java.lang.String com.howie.ndkdemo.NDKTools.getTextFromNDK() (tried Java_com_howie_ndkdemo_NDKTools_getTextFromNDK and Java_com_howie_ndkdemo_NDKTools_getTextFromNDK__)
2021-07-03 12:45:06.762 22626-22626/com.howie.ndkdemo D/AndroidRuntime: Shutting down VM
2021-07-03 12:45:06.762 22626-22626/com.howie.ndkdemo E/AndroidRuntime: FATAL EXCEPTION: main
    Process: com.howie.ndkdemo, PID: 22626
    java.lang.UnsatisfiedLinkError: No implementation found for java.lang.String com.howie.ndkdemo.NDKTools.getTextFromNDK() (tried Java_com_howie_ndkdemo_NDKTools_getTextFromNDK and Java_com_howie_ndkdemo_NDKTools_getTextFromNDK__)
        at com.howie.ndkdemo.NDKTools.getTextFromNDK(Native Method)
        at com.howie.ndkdemo.MainActivity$1.onClick(MainActivity.java:30)
        at android.view.View.performClick(View.java:7515)
        at com.google.android.material.button.MaterialButton.performClick(MaterialButton.java:1119)
        at android.view.View.performClickInternal(View.java:7492)
        at android.view.View.access$3600(View.java:847)
        at android.view.View$PerformClick.run(View.java:28742)
        at android.os.Handler.handleCallback(Handler.java:938)
        at android.os.Handler.dispatchMessage(Handler.java:99)
        at android.os.Looper.loop(Looper.java:236)
        at android.app.ActivityThread.main(ActivityThread.java:8145)
        at java.lang.reflect.Method.invoke(Native Method)
        at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:656)
        at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:967)
2021-07-03 12:45:06.765 22626-22626/com.howie.ndkdemo D/OOMEventManagerFK: checkEventAndDumpForJE: 0
2021-07-03 12:45:06.784 22626-22626/com.howie.ndkdemo I/Process: Sending signal. PID: 22626 SIG: 9

（2）动态注册

动态注册不需要像静态注册一样，jni函数的名字必须是特定格式，否则jvm会找不到对应的jni函数。动态注册其实是通过一个方法jniRegisterNativeMethods，将java层的声明与jni层中的函数实现映射起来。

先看这个函数的实现

int jniRegisterNativeMethods(C_JNIEnv* env, const char* className,
    const JNINativeMethod* gMethods, int numMethods)
{
    JNIEnv* e = reinterpret_cast<JNIEnv*>(env);

    ALOGV("Registering %s's %d native methods...", className, numMethods);

    scoped_local_ref<jclass> c(env, findClass(env, className));
    ALOG_ALWAYS_FATAL_IF(c.get() == NULL,
                         "Native registration unable to find class '%s'; aborting...",
                         className);

    int result = e->RegisterNatives(c.get(), gMethods, numMethods);
    ALOG_ALWAYS_FATAL_IF(result < 0, "RegisterNatives failed for '%s'; aborting...",
                         className);

    return 0;
}

先看传进来的第一个参数C_JNIEnv，是函数指针表。

typedef const struct JNINativeInterface* C_JNIEnv;

/*
 * Table of interface function pointers.
 */
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);

    jint        (*Throw)(JNIEnv*, jthrowable);
    jint        (*ThrowNew)(JNIEnv *, jclass, const char *);
    jthrowable  (*ExceptionOccurred)(JNIEnv*);
    void        (*ExceptionDescribe)(JNIEnv*);
    void        (*ExceptionClear)(JNIEnv*);
    void        (*FatalError)(JNIEnv*, const char*);

    jint        (*PushLocalFrame)(JNIEnv*, jint);
    jobject     (*PopLocalFrame)(JNIEnv*, jobject);

    jobject     (*NewGlobalRef)(JNIEnv*, jobject);
    void        (*DeleteGlobalRef)(JNIEnv*, jobject);
    void        (*DeleteLocalRef)(JNIEnv*, jobject);
    jboolean    (*IsSameObject)(JNIEnv*, jobject, jobject);

    jobject     (*NewLocalRef)(JNIEnv*, jobject);
    jint        (*EnsureLocalCapacity)(JNIEnv*, jint);

    jobject     (*AllocObject)(JNIEnv*, jclass);
    jobject     (*NewObject)(JNIEnv*, jclass, jmethodID, ...);
    jobject     (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list);
    jobject     (*NewObjectA)(JNIEnv*, jclass, jmethodID, const jvalue*);

    jclass      (*GetObjectClass)(JNIEnv*, jobject);
    jboolean    (*IsInstanceOf)(JNIEnv*, jobject, jclass);
    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, const jvalue*);
    jboolean    (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);
    jboolean    (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jboolean    (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jbyte       (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...);
    jbyte       (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jbyte       (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jchar       (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...);
    jchar       (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jchar       (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jshort      (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...);
    jshort      (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jshort      (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jint        (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);
    jint        (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jint        (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jlong       (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...);
    jlong       (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jlong       (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jfloat      (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...);
    jfloat      (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jfloat      (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    jdouble     (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...);
    jdouble     (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    jdouble     (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);
    void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
    void        (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list);
    void        (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, const jvalue*);

    jobject     (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jobject     (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jobject     (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jboolean    (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jboolean    (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass,
                         jmethodID, va_list);
    jboolean    (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass,
                         jmethodID, const jvalue*);
    jbyte       (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jbyte       (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jbyte       (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jchar       (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jchar       (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jchar       (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jshort      (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jshort      (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jshort      (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jint        (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jint        (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jint        (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jlong       (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jlong       (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jlong       (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jfloat      (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jfloat      (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jfloat      (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    jdouble     (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    jdouble     (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    jdouble     (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);
    void        (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass,
                        jmethodID, ...);
    void        (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass,
                        jmethodID, va_list);
    void        (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass,
                        jmethodID, const jvalue*);

    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);
    jdouble     (*GetDoubleField)(JNIEnv*, jobject, jfieldID);

    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);
    void        (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble);

    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, const jvalue*);
    jboolean    (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...);
    jboolean    (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID,
                        va_list);
    jboolean    (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jbyte       (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...);
    jbyte       (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jbyte       (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jchar       (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...);
    jchar       (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jchar       (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jshort      (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...);
    jshort      (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jshort      (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jint        (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...);
    jint        (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jint        (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jlong       (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...);
    jlong       (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jlong       (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jfloat      (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...);
    jfloat      (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jfloat      (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    jdouble     (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...);
    jdouble     (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    jdouble     (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);
    void        (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...);
    void        (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list);
    void        (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, const jvalue*);

    jfieldID    (*GetStaticFieldID)(JNIEnv*, jclass, const char*,
                        const char*);

    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);
    jdouble     (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID);

    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);
    void        (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble);

    jstring     (*NewString)(JNIEnv*, const jchar*, jsize);
    jsize       (*GetStringLength)(JNIEnv*, jstring);
    const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*);
    jstring     (*NewStringUTF)(JNIEnv*, const char*);
    jsize       (*GetStringUTFLength)(JNIEnv*, jstring);
    /* JNI spec says this returns const jbyte*, but that's inconsistent */
    const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);
    jsize       (*GetArrayLength)(JNIEnv*, jarray);
    jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject);
    jobject     (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);
    void        (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);

    jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize);
    jbyteArray    (*NewByteArray)(JNIEnv*, jsize);
    jcharArray    (*NewCharArray)(JNIEnv*, jsize);
    jshortArray   (*NewShortArray)(JNIEnv*, jsize);
    jintArray     (*NewIntArray)(JNIEnv*, jsize);
    jlongArray    (*NewLongArray)(JNIEnv*, jsize);
    jfloatArray   (*NewFloatArray)(JNIEnv*, jsize);
    jdoubleArray  (*NewDoubleArray)(JNIEnv*, jsize);

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

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

    jint        (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*,
                        jint);
    jint        (*UnregisterNatives)(JNIEnv*, jclass);
    jint        (*MonitorEnter)(JNIEnv*, jobject);
    jint        (*MonitorExit)(JNIEnv*, jobject);
    jint        (*GetJavaVM)(JNIEnv*, JavaVM**);

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

    void*       (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*);
    void        (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint);

    const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*);
    void        (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);

    jweak       (*NewWeakGlobalRef)(JNIEnv*, jobject);
    void        (*DeleteWeakGlobalRef)(JNIEnv*, jweak);

    jboolean    (*ExceptionCheck)(JNIEnv*);

    jobject     (*NewDirectByteBuffer)(JNIEnv*, void*, jlong);
    void*       (*GetDirectBufferAddress)(JNIEnv*, jobject);
    jlong       (*GetDirectBufferCapacity)(JNIEnv*, jobject);

    /* added in JNI 1.6 */
    jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject);
};

第三个参数，JNINativeMethod

typedef struct {
    const char* name;
    const char* signature;
    void*       fnPtr;
} JNINativeMethod;

这三个参数分别代表java层方法名；参数和返回值；函数指针。

jniRegisterNativeMethods通过findClass(env, className)找到声明的native方法，通过e->RegisterNatives(c.get(), gMethods, numMethods)将注册函数的Java类，以及注册函数的数组，以及个数注册在一起，这样就实现了绑定。

那怎样会调用到jniRegisterNativeMethods呢？

可以在JNI_OnLoad函数中实现。

/*
 * Prototypes for functions exported by loadable shared libs.  These are
 * called by JNI, not provided by JNI.
 */
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved);
JNIEXPORT void JNI_OnUnload(JavaVM* vm, void* reserved);

到这，需要实现的函数已经介绍了，我们接下来看一下Demo怎么改写成动态注册。

先把之前javah生成的头文件com_howie_ndkdemo_NDKTools.h删除掉，然后修改com_howie_ndkdemo_NDKTools.cpp。

#include <jni.h>

static const char *howieclassName = "com/howie/ndkdemo/NDKTools";

static jstring jni_sayHello(JNIEnv* jniEnv, jclass clazz) {
    return jniEnv -> NewStringUTF("Hello, Howie");
}

static JNINativeMethod howieMethods[] = {
        {"getTextFromNDK", "()Ljava/lang/String;", (jstring*) jni_sayHello},
};

static int register_howie_jni_native_methods(JNIEnv* env, const char* className,
        const JNINativeMethod* gMethods, int numMethods) {
    jclass clazz;
    clazz = env -> FindClass(className);
    if (clazz == nullptr) {
        return JNI_FALSE;
    }
    jint result = env -> RegisterNatives(clazz, gMethods, numMethods);
    if (result < 0) {
        return JNI_FALSE;
    }
    return JNI_TRUE;
}

jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env = nullptr;
    jint result = -1;
    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        return result;
    }
    register_howie_jni_native_methods(env, howieclassName, howieMethods, ((int) (sizeof(howieMethods) / sizeof((howieMethods)[0]))));
    return JNI_VERSION_1_4;
}

2、 Native ==> Java

先前讲的都是从Java层调用Native层的方法，那怎样从native调用Java层的代码呢？其实实现原理差不多。

  • 获取类实例
  • 获得构造函数
  • 创建对象
  • 获得方法ID
  • 调用方法

直接看代码。我们先在java层实现一个获取当前时间的方法

    public String getCurrentTime() {
        long mNow = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(mNow);
        sb.append(String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c));
        return sb.toString();
    }

然后在JNI层添加一个函数调用它。

jstring jni_getCurrentTime(JNIEnv* jniEnv) {
    // 获取类实例
    jclass clazz = jniEnv -> FindClass(howieclassName);
    if (clazz == nullptr) {
        return jniEnv -> NewStringUTF("error!");
    }
    // 获得构造函数
    jmethodID jmethodId = jniEnv -> GetMethodID(clazz, "<init>", "()V");
    // 创建对象
    jobject obj =  jniEnv -> NewObject(clazz, jmethodId);
    // 获取方法id
    jmethodID jmethodId1 = jniEnv -> GetMethodID(clazz, "getCurrentTime", "()Ljava/lang/String;");
    // 调用方法
    auto str = (jstring)jniEnv ->CallObjectMethod(obj, jmethodId1);
    return str;
}

现在我们想看一下效果，得有个函数调用jni_getCurrentTime，没想到什么好方法，就在java再注册一个方法来调用吧。

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String text = NDKTools.getInstance().main();
                Log.i("NDK Demo ","text=" + text);
                textView.setText(text);

            }
        });
package com.howie.ndkdemo;

import java.util.Calendar;

public class NDKTools {

    private static NDKTools ndkTools;

    static {
        System.loadLibrary("hello-howie-jni");
    }

    public static NDKTools getInstance() {
        if (ndkTools == null) {
            ndkTools = new NDKTools();
        }
        return ndkTools;
    }

    private NDKTools() {}

    public native String getTextFromNDK();

    public native String callgetCurrentTime();

    public String getCurrentTime() {
        long mNow = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(mNow);
        sb.append(String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c));
        return sb.toString();
    }

    public static String main() {
        return getInstance().callgetCurrentTime();
    }

}
jstring jni_call_getCurrentTime(JNIEnv* jniEnv, jclass clazz) {
    return jni_getCurrentTime(jniEnv);
}

static JNINativeMethod howieMethods[] = {
        {"getTextFromNDK", "()Ljava/lang/String;", (jstring*) jni_sayHello},
        {"callgetCurrentTime", "()Ljava/lang/String;", (jstring*) jni_call_getCurrentTime},
};

这样就完成了一个native调用java的demo，看一下效果。

jni中函数的更多用处在C_JNIEnv这个函数指针表中，这里不去过多介绍，需要用到的时候去使用对应的函数即可。

3、Demo下载

https://download.csdn.net/download/hihan_5/20041272

参考文章：

[1] https://www.jianshu.com/p/b71aeb4ed13d

[2] https://www.jianshu.com/p/80fe5d2e1412

阅后即奋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
android jni开发总结,Android JNI开发摘录（二）之JNI数组处理
weixin_36124888的博客
05-27 520
一． JNI中的数组1. 基本类型对应的本地数组基本数据类型 本地数组boolean jbooleanArraybyte jbyteArraychar jcharArrayshort jshortArrayint jintArraylong jlongArrayfloat jfloatArrayobject jobjectArraydouble jdoubl...
Android JNI开发详解(3)-JavaVM和JNIEnv
^_虫虫_^的专栏
05-24 574
原文出处：http://www.ccbu.cc/index.php/android/android-jni-jnivm-jnienv.html JavaVM 和 JNIEnv JNI 定义了两个关键数据结构，即JavaVM和JNIEnv。两者本质上都是指向函数表的二级指针。在 C++ 版本中，它们是一些类，这些类具有指向函数表的指针，并具有每个通过该函数表间接调用的 JNI 函数的成员函数。 1. JavaVM JavaVM是虚拟机在JNI中的表示，一个JVM中只有一个JavaVM对象，这个对象是线程共享的
解决运行无异常点击功能闪退java.lang.NoClassDefFoundError: Class not found using the boot class loader
li13462791273的博客
12-24 2535
java.lang.NoClassDefFoundError: Class not found using the boot class loader java.lang.NoClassDefFoundError: Class not found using the boot class loader; no stack trace available 2021-12-24 09:28:16.276 3931-4078/? E/OOMEventManager: oom event not support t
Android Java try catch 失效
阿饱同学
12-24 3201
android java try catch 失效 不管用, try catch 不能捕获子线程 异常 Exception
Android 系统奔溃触发WatchDog分析
程序员Android
08-03 1818
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、前言二、场景介绍三、分析trace文件一、前言作为一个Android开发者，不管是App或者...
java native 开发_无Java开发Android应用(NativeActivity) 你会吗
weixin_36209030的博客
02-16 149
#include#include#include#include#include#include#include#defineLOGI(...)((void)__android_log_print(ANDROID_LOG_INFO,"native-activity",__VA_ARGS__))#defineLOGW(...)((void)__android_log_pri...
Android JNI 开发
qq_37565670的博客
01-19 2837
①：NDK与JNI简介 NDK：Native Development Kit，是Android的一种开发工具包，能够快速开发C,C++的动态库，并自动将so和应用打包成APK。而NDK的使用场景就是通过NDK在Android中使用JNI。 JNI：Java Native Interface的缩写，即Java的本地接口，JNI可以使得Java与C，C++语言进行交互。 NDK优点： 1.APK的Java层代码很容易被反编译，而C/C++库反编译难度较大 2.将要求高性能的应用逻辑使用C开发，从而提高
Android JNI native调用 java层demo TESTJNI.zip
04-28
在Android开发中，JNI（Java Native Interface）是一个关键的组件，它允许Java代码与其他语言写的代码进行交互，尤其是C和C++。JNI在许多场景下非常有用，例如优化性能、利用硬件特性、接入第三方库等。本文将深入...
NativeActivity通过jni调用java层的Android API
01-03
1. 继承Nativity，打通native和java层 public class MyNativeActivity extends NativeActivity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.v...
android JNI开发演示（串口收发）
07-02
Android JNI（Java Native Interface）开发是一种技术，允许Java代码与其他编程语言（如C++或C）编写的代码进行交互。这种交互通常是出于性能考虑，因为原生代码在处理密集型计算或系统级操作时通常比Java更高效。在...
hello-jni.rar_android开发_Java_
08-11
在Android开发中，Java语言是主要的编程工具，但有时为了优化性能或利用C/C++的库，开发者会使用JNI（Java Native Interface）技术。"hello-jni.rar"这个压缩包很可能包含了一个基础的Android JNI示例项目，帮助...
JNI_HelloWorld.rar_android开发_Java_
08-11
2. JNI头文件：在使用JNI时，我们需要包含特定的头文件`<jni.h>`，它定义了JNI函数和类型。 二、创建JNI工程 1. 创建Android Studio项目，添加NDK支持。在`build.gradle`文件中，确保`externalNativeBuild`部分已...
c 调用java_JNI开发学习之C反射调用java方法
weixin_30472793的博客
02-18 282
前面记录了调用C的学习笔记，现在来记录一下C反射调用Java的笔记。JNI开发学习之调用C方法Android开发中调用一个类中没有公开的方法，可以进行反射调用，而JNI开发中C调用java的方法也是反射调用。C代码回调Java方法步骤：①获取字节码对象(jclass (FindClass)(JNIEnv, const char*);)②通过字节码对象找到方法对象(jmethodID ...
Android 下 JNI 开发
尚硅谷铁杆粉丝的博客
12-03 82
5.C调用java中的带两个int参数的方法-C语言的代码如下 /**  * C回调Java中JNI.java中的add方法  */JNIEXPORT void JNICALL Java_com_atguigu_callbackjavamethod_JNI_callbackAdd( JNIEnv *env, jobject obj) { //用反射 //1.首先得到字节码 jclass...
Android Camera 二 JNI JAVA和C/CPP图像数据传输流程分析
转载和创作优秀的博客
12-22 1094
Android Camera 一 源码路径 Android Camera 二 JNI JAVA和C/CPP图像数据传输流程分析 Android Camera 三 CameraService 和 Client 链接到 HAL Android Camera 四 Camera HAL 分析 Android Camera 五 Camera HAL v1 Linux v4l2 一 应用层 Linux v4l2 二 驱动和 usb 摄像头 android7 源码文件列表 frameworks/ba
JNI接口检查试验
halem100的博客
03-08 295
jni初始化时，检测java层和native层的接口是否对应
JNI学习笔记——（三）动态注册、线程
miyuexingchen的专栏
12-19 874
注：编码工具是Android Studio。 目录 动态注册 线程 错误案例 用JavaVM和GlobalRef 动态注册 用Java_包名_类名_函数名形式声明JNI函数的方式是静态注册。 除了静态注册，还可以用动态注册方式实现JNI函数，具体方式是在JNI的JNI_OnLoad函数用JNIEnv.registerNatives函数注册JNI函数，JNI_OnLoad函数会在Java代码调用System.loadLibrary方法时调用。 JniActiv...
NDK开发之JNI基础
以后会多把工作中总结的知识、问题处理思路和方法通过博客分享出来,欢迎大家关注和共同探讨!
06-01 448
jni开发基础和常用接口总结
Android-卷积神经网络（Convolutional Neural Network, CNN）
最新发布
zhuhai0613的博客
07-04 605
卷积神经网络是一种深度学习模型，通过卷积层、池化层和全连接层构成，用于提取图像特征并进行分类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阅后即奋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值