在 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& 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(env);
ALOGV("Registering %s's %d native methods...", className, numMethods);
scoped_local_ref 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
/* 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 方法时需要建立关联，影响效率。