在 framework 的学习过程中，JNI 的使用是必不可少的，而且整个安卓系统的核心可以理解就是 JNI 的调用过程（Linux 系统 + 虚拟机），这一章节就来学习一下 framework 下 JNI 方面的知识；

首先，简单介绍一下 JNI，它是 Java Native Interface 的缩写（java 本地接口、Natvie 一般指 C/C++），是 java 和 C/C++ 之间的桥梁，通过 JNI 技术, java 和 C/C++ 可以实现互相调用。JNI 方法注册分为静态注册和动态注册，其中静态注册多用于 NDK 开发，而动态注册多用于 framework 中，本章节中重点探讨动态注册；

1. 动态注册

在 framework 中动态注册是有两种方式进行注册的，并不是某些文章中说无论静态注册还是动态注册都会调用 System.loadLibrary("xxx") 这个方法，这一点还需要注意一下；

1.1 AndroidRuntime ::start() 时开始注册
在之前的文章中介绍过 Zygote 的启动过程，在内部会先启动虚拟机(JNI环境)，然后开始方法的注册，如果还不清楚 Zygote 的启动流程，请参考 知识点1 framework 线程类；

// 在 zygote 的启动过程中会调用到 AndroidRuntime的 start 方法：
void AndroidRuntime::start(const char* className, const Vector<String8>& options)
{
    // ... 
    // 创建一个虚拟机的实例
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    // JNI 方法注册
    if (startReg(env) < 0) {  // ********* 此处为下面的关注点 *********
        ALOGE("Unable to register all android natives\n");
        return;
    }
}

// 步骤（1）：AndroidRuntime.cpp 中 startReg()
/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
    androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
    env->PushLocalFrame(200);
    // 注册
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    env->PopLocalFrame(NULL);
    return 0;
}

static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
{
    // 循环注册，传入的参数 gRegJNI 是重点
    for (size_t i = 0; i < count; i++) {
        if (array[i].mProc(env) < 0) {  // 是一层封装，调用数组元素的mProc函数 
            return -1;
        }
    }
    return 0;
}

static const RegJNIRec gRegJNI[] = {  // 参数 gRegJNI
    REG_JNI(register_com_android_internal_os_RuntimeInit),
    REG_JNI(register_android_os_SystemClock),
    REG_JNI(register_android_util_EventLog),
    REG_JNI(register_android_util_Log),
    REG_JNI(register_android_util_FloatMath),
    REG_JNI(register_android_content_AssetManager),
    REG_JNI(register_android_content_StringBlock),
    ...
    REG_JNI(register_android_app_ActivityThread),
    REG_JNI(register_android_app_NativeActivity),
    REG_JNI(register_android_view_InputChannel),
    REG_JNI(register_android_view_InputEventReceiver),
    REG_JNI(register_android_view_InputEventSender),
    REG_JNI(register_android_view_InputQueue),
    REG_JNI(register_android_view_KeyEvent),
    REG_JNI(register_android_view_MotionEvent),
    ...
    REG_JNI(register_com_android_internal_net_NetworkStatsFactory),
};

// 步骤（2）：以 AndroidRuntime.cpp 中 register_com_android_internal_os_RuntimeInit() 为例
int register_com_android_internal_os_RuntimeInit(JNIEnv* env)
{
    return jniRegisterNativeMethods(env, "com/android/internal/os/RuntimeInit",
        gMethods, NELEM(gMethods));
}


// 步骤（3）：JNIHelp.cpp 中 jniRegisterNativeMethods()
extern "C" 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));
    if (c.get() == NULL) {
        char* msg;
        asprintf(&msg, "Native registration unable to find class '%s'; aborting...", className);
        e->FatalError(msg);
    }
    // 最终调用 RegisterNatives() 方法
    if ((*env)->RegisterNatives(e, c.get(), gMethods, numMethods) < 0) {
        char* msg;
        asprintf(&msg, "RegisterNatives failed for '%s'; aborting...", className);
        e->FatalError(msg);
    }

    return 0;
}

最终通过 (*env)->RegisterNatives() 完成注册；

1.2 SystemServer.java 中的 run() 方法中
Zygote 启动后，会 fork 出 SystemServer 进程，执行它的 run() 方法：

//SystemServer.java
private void run() {
    // ...
    // 加载libandroid_servers.so库，执行JNI_Onload()函数（在JNI_Onload()函数中注册JNI本地函数）
    System.loadLibrary("android_servers");
    nativeInit();

    // Start services.
    try {
        startBootstrapServices();
        startCoreServices();
        startOtherServices(); 
    } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
    }
    // ...
}


// libandroid_servers.so 文件的生成是在 frameworks/base/services/Android.mk 中定义的：
include $(CLEAR_VARS)
LOCAL_SRC_FILES :=
LOCAL_SHARED_LIBRARIES :=

# include all the jni subdirs to collect their sources
include $(wildcard $(LOCAL_PATH)/jni/Android.mk)
LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES -DGL_GLEXT_PROTOTYPES

ifeq ($(WITH_MALLOC_LEAK_CHECK),true)
    LOCAL_CFLAGS += -DMALLOC_LEAK_CHECK
endif

LOCAL_MODULE:= libandroid_servers
include $(BUILD_SHARED_LIBRARY)


// 接下来具体看一下frameworks/base/services/core/jni/Android.mk的内容
LOCAL_SRC_FILES += \
    $(LOCAL_REL_DIR)/com_android_server_AlarmManagerService.cpp \
    $(LOCAL_REL_DIR)/com_android_server_am_BatteryStatsService.cpp \
    $(LOCAL_REL_DIR)/com_android_server_am_ActivityManagerService.cpp \
    $(LOCAL_REL_DIR)/com_android_server_SystemServer.cpp \
    ......
    $(LOCAL_REL_DIR)/onload.cpp  // 这个类中

LOCAL_C_INCLUDES += \
    $(JNI_H_INCLUDE) \
    frameworks/base/services \
    frameworks/base/libs \
    frameworks/base/libs/hwui \
    // ..
LOCAL_SHARED_LIBRARIES += \
    libandroid_runtime \
    libandroidfw \
    libbinder \
    libcutils 
    // ..

这个 mk 文件中引入了很多相关的库文件和 cpp 文件，这些文件中的方法会与 Java 中的本地方法关联起来。前面提到的 JNI_Onload() 函数中注册 JNI 的本地函数，这个 JNI_OnLoad() 方法就在 onload.cpp 文件中：

// 步骤（1）：OnLoad.cpp 中：
extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;

    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        ALOGE("GetEnv failed!");
        return result;
    }
    ALOG_ASSERT(env, "Could not retrieve the env!");

    register_android_server_PowerManagerService(env);
    register_android_server_SerialService(env);
    register_android_server_InputApplicationHandle(env);
    register_android_server_InputWindowHandle(env);
    register_android_server_InputManager(env);
    register_android_server_LightsService(env);
    register_android_server_AlarmManagerService(env);
    register_android_server_UsbDeviceManager(env);
    register_android_server_UsbHostManager(env);
    register_android_server_VibratorService(env);
    register_android_server_SystemServer(env); // 以这个为例
    // ...

    return JNI_VERSION_1_4;
}

// 步骤（2）com_android_server_SystemServer.cpp 中
int register_android_server_SystemServer(JNIEnv* env)
{
    return jniRegisterNativeMethods(env, "com/android/server/SystemServer",
            gMethods, NELEM(gMethods));
}

// 步骤（3）：JNIHelp.cpp 中 jniRegisterNativeMethods()，与 1.1 中的步骤（3）一致

当 Android 的虚拟机执行 C 组件(即 so 文件)里的 System.loadLibrary() 函数时，首先会去执行 C 组件里的 JNI_OnLoad() 函数，会有两个作用：
（1）告诉虚拟机此 C 组件使用那一个 JNI 版本。如果 .so 文件没有提供 JNI_OnLoad() 函数，虚拟机会默认该 .so 使用最老的 JNI 1.1 版本。但由于新版的 JNI 做了许多扩充，如果需要使用 JNI 的新版功能，就会通过 JNI_OnLoad() 函数返回给虚拟机。
（2）当执行到 System.loadLibrary() 函数时，可以通过该 so 库中的 JNI_OnLoad() 来执行一些任务。

2. 静态注册

在AS中新建一个Java Library名为 test，Test.java，如下所示：

package com.example;
public class Test{
    static {
        System.loadLibrary("test_jni");
        native_init();
    }

    private static native final void native_init();
    public native void start() throws IllegalStateException;
}

接着进入项目的media/src/main/java目录中执行如下命令：
javac com.example.Test.java
javah com.example.Test
第二个命令会在当前目录中（test/src/main/java）生成com_example_Test.h文件:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_example_Test */

#ifndef _Included_com_example_Test
#define _Included_com_example_Test
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_Test
 * Method:    native_init
 * Signature: ()V
 */
// 方法名多了一个"1"，这是因为 native_init 方法有一个"_"，它会在转换为 JNI 方法时变成"_1"
JNIEXPORT void JNICALL Java_com_example_Test_native_1init
  (JNIEnv *, jclass);

/*
 * Class:     com_example_Test
 * Method:    start
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_example_Test_start
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

其中JNIEnv * 是一个指向全部JNI方法的指针，该指针只在创建它的线程有效，不能跨线程传递。
在 Java中 调用 native_init 方法时，就会从 JNI 中寻找 Java_com_example_Test_native_1init 方法，如果没有就会报错，如果找到就会为 native_init 和 Java_com_example_Test_native_1init 建立关联，其实是保存JNI的方法指针，这样再次调用native_init方法时就会直接使用这个方法指针就可以了。
静态注册就是根据方法名，将Java方法和JNI方法建立关联，但是它有一些缺点：
（1）JNI 层的方法名称很长。
（2）声明 Native 方法的类需要用 javah 生成头文件。
（3）初次调用 JIN 方法时需要建立关联，影响效率。