NDK 系列（6）：说一下注册 JNI 函数的方式和时机

package com.xurui.hellojni;

public class HelloWorld {
    public native void sayHi();
}

...
JNIEXPORT void JNICALL Java_com_xurui_hellojni_HelloWorld_sayHi
(JNIEnv *, jobject);
...

// 共享库列表
std::unique_ptr<Libraries> libraries_;

// 搜索 native 对应 JNI 函数的函数指针
void* FindNativeMethod(Thread* self, ArtMethod* m, std::string& detail) {

    // 1、获取 native 方法对应的短名称与长名称
    std::string jni_short_name(m->JniShortName());
    std::string jni_long_name(m->JniLongName());

    // 2、在已经加载的 so 库中搜索
    void* native_code = FindNativeMethodInternal(self,
                                                 declaring_class_loader_allocator,
                                                 shorty,
                                                 jni_short_name,
                                                 jni_long_name);
    return native_code;
}

// 2、在已经加载的 so 库中搜索
void* FindNativeMethodInternal(Thread* self,
                               void* declaring_class_loader_allocator,
                               const char* shorty,
                               const std::string& jni_short_name,
                               const std::string& jni_long_name) {
    for (const auto& lib : libraries_) {
        SharedLibrary* const library = lib.second;

        // 2.1 检查是否为相同 ClassLoader
        if (library->GetClassLoaderAllocator() != declaring_class_loader_allocator) {
            continue;
        }

        // 2.2 先搜索短名称
        const char* arg_shorty = library->NeedsNativeBridge() ? shorty : nullptr;
        void* fn = dlsym(library, jni_short_name)

        // 2.3 再搜索长名称
        if (fn == nullptr) {
            fn = dlsym(library, jni_long_name)
        }
        if (fn != nullptr) {
            return fn;
        }
    }
    return nullptr;
}

// 1、获取 native 方法对应的短名称与长名称

// 短名称
std::string ArtMethod::JniShortName() {
    return GetJniShortName(GetDeclaringClassDescriptor(), GetName());
}

// 长名称
std::string ArtMethod::JniLongName() {
    std::string long_name;
    long_name += JniShortName();
    long_name += "__";

    std::string signature(GetSignature().ToString());
    signature.erase(0, 1);
    signature.erase(signature.begin() + signature.find(')'), signature.end());

    long_name += MangleForJni(signature);

    return long_name;
}

std::string GetJniShortName(const std::string& class_descriptor, const std::string& method) {
    // 此处为短名称的计算逻辑
}

struct JNINativeInterface {
  // 注册
  // 参数二：Java Class 对象的表示
  // 参数三：JNINativeMethod 结构体数组
  // 参数四：JNINativeMethod 结构体数组长度
  jint        (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*, jint);
  // 注销
  // 参数二：Java Class 对象的表示
    jint        (*UnregisterNatives)(JNIEnv*, jclass);
};

typedef struct {
    const char* name;      // Java 方法名
    const char* signature; // Java 方法描述符
    void*       fnPtr;     // JNI 函数指针
} JNINativeMethod;

// 需要注册的 Java 层类名
#define JNIREG_CLASS "com/xurui/MainActivity"

// JNINativeMethod 结构体数组
static JNINativeMethod gmethod[] = {
        {"onStart","()I",(void*)onStart}, // JNINativeMethod 结构体
};

// 加载 so 库的回调
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;
    }

    result = JNI_VERSION_1_6;

    return result;
}

// 动态注册
static int registerNatives(JNIEnv* env)
{
  // 调用工具方法完成注册
    if (!registerNativeMethods(env,JNIREG_CLASS, gmethod, sizeof(gmethod) / sizeof(gmethod[0])))
        return JNI_FALSE;

  // JNINativeMethod 结构体数组
    JNINativeMethod methods[] = {
            {"onStop","()V",(void*)onStop}, // JNINativeMethod 结构体
    };
  // 调用工具方法完成注册
    if (!registerNativeMethods(env,JNIREG_CLASS, smethod,sizeof(smethod) / sizeof(smethod[0])))
        return JNI_FALSE;
    return JNI_TRUE;
}

// 一个工具方法
static int registerNativeMethods(JNIEnv* env, const char* className, JNINativeMethod* gmethod, int numMethods)
{
  // 根据类名获取 jclass 对象
    jclass clazz = env->FindClass(className);
    if (clazz == NULL) {
        return JNI_FALSE;
    }
  // 调用 RegisterNatives()
    if (env->RegisterNatives(clazz, gmethod, numMethods) < 0) {
        return JNI_FALSE;
    }

    return JNI_TRUE;
}

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote) {
    ...
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\\n");
    }
    ...
}

// start -> startReg：
int AndroidRuntime::startReg(JNIEnv* env) {
    androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
    env->PushLocalFrame(200);
  // 执行 JNI 注册
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    env->PopLocalFrame(NULL);
    return 0;
}

// startReg->register_jni_procs：
static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env) {
  // 遍历二维数组
    for (size_t i = 0; i < count; i++) {
        // 执行 JNI 注册
        if (array[i].mProc(env) < 0) {
            return -1;
        }
    }
    return 0;
}

// JNINativeMethod 结构体数组的二维数组
static const RegJNIRec gRegJNI[] = {
    REG_JNI(register_com_android_internal_os_RuntimeInit),
    REG_JNI(register_com_android_internal_os_ZygoteInit_nativeZygoteInit),
    REG_JNI(register_android_os_SystemClock),
    REG_JNI(register_android_util_EventLog),
    ...
}

struct RegJNIRec {
    int (*mProc)(JNIEnv*);
}

// 返回值为 JNINativeMethod 结构体数组
int register_com_android_internal_os_RuntimeInit(JNIEnv* env)
{
    const JNINativeMethod methods[] = {
        { "nativeFinishInit", "()V",
            (void*) com_android_internal_os_RuntimeInit_nativeFinishInit },
        { "nativeSetExitWithoutCleanup", "(Z)V",
            (void*) com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup },
    };
    return jniRegisterNativeMethods(env, "com/android/internal/os/RuntimeInit",
        methods, NELEM(methods));
}