共计 7169 个字符，预计需要花费 18 分钟才能阅读完成。
请点赞关注，你的反对对我意义重大。
🔥 Hi，我是小彭。本文已收录到 GitHub · Android-NoteBook 中。这里有 Android 进阶成长常识体系，有气味相投的敌人，关注公众号 [彭旭锐] 带你建设外围竞争力。
前言
在上一篇文章中，咱们提到了注册 JNI 函数（建设 Java native 办法和 JNI 函数的映射关系）有两种形式：动态注册和动静注册。明天咱们来具体说下这 2 种注册形式的应用办法和实现原理。
这篇文章是 NDK 系列文章第 6 篇，专栏文章列表：
一、语言根底：
- 1、NDK 学习路线：怎么学 & 我的教训
- 2、C 语言根底
- 3、C ++ 语言根底
- 4、C/C++ 编译过程：从源码到程序运行
二、NDK 开发：
- 1、JNI 根底：Java 与 Native 交互
- 2、注册 JNI 函数：动态注册 & 动静注册（本文）
- 3、NDK 根底：ndk-build & CMake
- 4、so 文件加载过程剖析：了解 Android 中 loadLibrary() 的执行流程
- 5、so 文件适配 64 位架构：Gradle 插件一键检索未适配项
- 6、so 文件动态化：动静下载
- 7、so 文件体积优化：文件精简
三、基础理论
- 1、视频基础理论
- 2、音频基础理论
- 3、H.264 视频压缩编码
- 4、音频压缩编码
- 5、FFMPEG 根底
- 6、OPENSL ES 根底
- 7、PNG 图片：无损压缩编码
四、计算机根底
- 1、字符编码：ASCII、Unicode、UTF-8、UTF-16、UTF-32
1. 动态注册 JNI 函数
1.1 动态注册应用办法
动态注册采纳的是基于「约定」的命名规定，通过 javah 能够主动生成 native 办法对应的函数申明（IDE 会智能生成，不须要手动执行命令）。例如：
HelloWorld.java
package com.xurui.hellojni;
public class HelloWorld {public native void sayHi();
} 执行命令：javac -h . HelloWorld.java（将 javac 和 javah 合并），对应的 JNI 函数：
com_xurui_hellojni_HelloWorld.h
...
JNIEXPORT void JNICALL Java_com_xurui_hellojni_HelloWorld_sayHi
(JNIEnv *, jobject);
...动态注册的命名规定分为「无重载」和「有重载」2 种状况：无重载时采纳「短名称」规定，有重载时采纳「长名称」规定。
- 短名称规定（short name）：
Java_[类的全限定名 ( 带下划线)]_[办法名]，其中类的全限定名中的.改为_； - 长名称规定（long name）： 在短名称的根底上后追加两个下划线（
__）和参数描述符，以辨别函数重载。
这里解释下为什么有重载的时候要拼接参数描述符的形式来呢？因为 C 语言是没有函数重载的，无奈依据参数来辨别函数重载，所以才须要拼接后缀来打消重载。
1.2 动态注册原理剖析
当初，咱们来剖析下动态注册匹配 JNI 函数的执行过程。因为没有找到间接相干的材料和函数调用入口，我是以 loadLibrary() 加载 so 库的执行流程为线索进行剖析的，最终定位到 FindNativeMethod() 这个办法，从内容看应该没错。
java_vm_ext.cc
// 共享库列表
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;
}art_method.cc
// 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;
}
descriptors_names.cc
std::string GetJniShortName(const std::string& class_descriptor, const std::string& method) {// 此处为短名称的计算逻辑}下面的代码曾经十分简化了，次要流程如下：
- 1、计算 native 办法的短名称和长名称；
- 2、确定定义 native 办法类的类加载器，在曾经加载的 so 库
libraries_中搜寻 JNI 函数。如果当时没有加载 so 库，则天然无奈搜寻到，将抛出UnsatisfiedLinkError异样； - 3、建设外部数据结构，建设 Java native 办法与 JNI 函数的函数指针的映射关系；
- 4、后续调用 native 办法，则间接调用已记录的函数指针。
对于加载 so 库的流程在 4、so 文件加载过程剖析 这篇文章里讲过，加载后的共享库就是存储在 libraries_ 表中。
2. 动静注册 JNI 函数
动态注册是在首次调用 Java native 办法时搜寻对应的 JNI 函数，而动静注册则是提前手动建设映射关系，并且不须要恪守动态注册的 JNI 函数命名规定。
2.1 动静注册应用办法
动静注册须要应用 RegisterNatives(...) 函数，其定义在 jni.h 文件中：
jni.h
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;
}代码不简单，简略解释一下：
- 1、
registerNativeMethods只是一个工具函数，简化了 FindClass 这一步； - 2、
methods是一个 JNINativeMethod 构造体数组，定义了 Java native 办法与 JNI 函数的映射关系，须要记录 Java 办法名、Java 办法描述符、JNI 函数指针； - 3、
RegisterNatives函数是最终的注册函数，须要传递 jclass、JNINativeMethod 构造体数组和数组长度。
2.2 动静注册原理剖析
RegisterNatives 形式的实质是间接通过构造体指定映射关系，而不是等到调用 native 办法时搜寻 JNI 函数指针，因而动静注册的 native 办法调用效率更高。此外，还能缩小生成 so 库文件中导出符号的数量，则可能优化 so 库文件的体积。更多信息见 Android 对 so 体积优化的摸索与实际 中“精简动静符号表”章节。
3. 注册 JNI 函数的机会
总结一下注册 JNI 函数的机会，次要分为 3 种：
| 注册机会 | 注册形式 | 形容 |
|---|---|---|
| 1、在第一次调用该 native 办法时 | 动态注册 | 虚构机会在 JNI 函数库中搜寻函数指针并记录下来，后续调用不须要反复搜寻 |
| 2、加载 so 库时 | 动静注册 | 加载 so 库时会主动回调 JNI_OnLoad 函数，在其中调用 RegisterNatives 注册 |
| 3、提前注册 | 动静注册 | 在加载 so 库后，调用该 native 办法前，通过动态注册的 native 函数触发 RegisterNatives 注册。例如在 App 启动时，很多零碎源码会提前做一次注册 |
以 Android 虚拟机源码为例：在 App 过程启动流程中，在创立虚拟机后会执行一次 JNI 函数注册。咱们在很多 Framework 源码中能够看到 native 办法，但找不到调用 System.loadLibrary(...) 的中央，其实是因为在虚拟机启动时就曾经注册实现了。
AndroidRuntime.cpp
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));
}4. 总结
总结一下动态注册和动静注册的区别：
- 1、动态注册基于命名约定建设映射关系，而动静注册通过
JNINativeMethod构造体建设映射关系； - 2、动态注册在首次调用该 native 办法搜寻并建设映射关系，而动静注册会在调用该 native 办法前建设映射关系；
- 3、动态注册须要将所有 JNI 函数裸露到动静符号表，而动静注册不须要裸露到动静符号表，能够精简 so 文件体积。
参考资料
- JNI 编程指南
- JNI 提醒 —— Android 官网文档
- Java 原生接口标准 —— Java 官网文档
- Android 对 so 体积优化的摸索与实际 —— 洪凯 常强（美团技术团队）著
你的点赞对我意义重大！微信搜寻公众号 [彭旭锐]，心愿大家能够一起探讨技术，找到气味相投的敌人，咱们下次见！
正文完