4.4 Native（本地）层
Java的Native函数与JNI函数是一一对应的关系，在Android中使用JNI NativeMethod的结构体来记录这种对应关系。在本节的内容中，将详细分析Mediascanner系统中的Native层的实现源码。
4.4.1 注册JNl函数
在Andoird系统中，使用了一种“特定”的方式来定义其Native函数，这与传统定义JavaJNI的方式有所差别。其中很重要的区别是在Andorid使用了一种Java和C函数的映射表数组，并在其中描述了函数的参数和返回值。这个数组的类型是JNINativeMethod，具体定义如下所示：
typedef struct {
const char＊ name; /＊Java中函数的名字＊/
const char＊ signature; /＊描述了函数的参数和返回值＊/
void＊ fnPtr; /＊函数指针，指向C函数＊/
} JNINativeMethod;
在上述代码中，比较难以理解的是第二个参数，例如：
"()V"
"(II)V"
"(Ljava/lang/String; Ljava/lang/String; )V"
实际上这些字符是与函数的参数类型一一对应的，具体说明如下所示。
“()”中的字符表示参数，后面的则代表返回值。例如“()V”就表示void Func()。
“(II)V"” 表示void Func(int, int)。
具体的每一个字符的对应关系如下所示：
而数组则以“[”开始，用两个字符表示：
上面的都是基本类型，如果Java函数的参数是class，则以“L”开头，以“; ”结尾，中间部分是用"/"隔开的包及类名。而其对应的C函数名的参数则为jobject．一个例外是String类，其对应的类为jstring，即：
Ljava/lang/String中的String jstring；
Ljava/net/Socket中的Socket jobject。
如果Java函数位于一个嵌入类，则使用$作为类名间的分隔符。例如：
(Ljava/lang/String; Landroid/os/FileUtils$FileStatus; )Z"
定义并注册JNINativeMethod数组，对应的实现代码如下所示：
/＊定义一个JNINativeMethod数组＊/
static JNINativeMethod gMethods[] = {
{
"processDirectory",
"(Ljava/lang/String; Landroid/media/MediaScannerClient; )V",
(void ＊)android_media_MediaScanner_processDirectory
},
{
"processFile",
"(Ljava/lang/String; Ljava/lang/String; Landroid/media/MediaScannerClient; )V",
(void ＊)android_media_MediaScanner_processFile
},
{
"setLocale",
"(Ljava/lang/String; )V",
(void ＊)android_media_MediaScanner_setLocale
},
{
"extractAlbumArt",
"(Ljava/io/FileDescriptor; )[B",
(void ＊)android_media_MediaScanner_extractAlbumArt
},
{
"native_init",
"()V",
(void ＊)android_media_MediaScanner_native_init
},
{
"native_setup",
"()V",
(void ＊)android_media_MediaScanner_native_setup
},
{
"native_finalize",
"()V",
(void ＊)android_media_MediaScanner_native_finalize
},
};
/＊注册JNINativeMethod数组＊/
int register_android_media_MediaScanner(JNIEnv ＊env)
{
return AndroidRuntime::registerNativeMethods(env,
kClassMediaScanner, gMethods, NELEM(gMethods));
}
4.4.2 完成注册工作
定义并注册数组JNINativeMethod后，接着需要调用函数registerNativeMethods来完成调用工作。函数registerNativeMethods在文件AndroidRuntime.cpp中实现，具体实现代码如下所示：
int AndroidRuntime::registerNativeMethods(JNIEnv＊ env,
const char＊ className, const JNINativeMethod＊ gMethods, int numMethods)
{
return jniRegisterNativeMethods(env, className, gMethods, numMethods);
}
在上述代码中，jniRegisterNativeMethods是Android为方便JNI使用而提供的一个帮助函数，此函数在文件JNIHelp.cpp中实现，具体实现代码如下所示：
extern "C" int jniRegisterNativeMethods(C_JNIEnv＊ env, const char＊ className,
const JNINativeMethod＊ gMethods, int numMethods)
{
JNIEnv＊ e = reinterpret_cast<JNIEnv＊>(env);
ALOGV("Registering %s natives", className);
scoped_local_ref<jclass> c(env, findClass(env, className));
if (c.get() == NULL) {
ALOGE("Native registration unable to find class '%s', aborting", className);
abort();
}
if ((＊env)->RegisterNatives(e, c.get(), gMethods, numMethods) < 0) {
ALOGE("RegisterNatives failed for '%s', aborting", className);
abort();
}
return 0;
}
通过上述代码可以了解函数registerNativeMethods的作用。应用层级的Java类别穿过VM呼叫到本地函数，这个过程通常是通过VM去寻找“*.so”格式库文件中的本地函数。如果需要连续呼叫很多次，则需要每次都寻找一遍，这会多花费很多时间。此时，组件开发人员可以自行向VM登记本地函数。例如，在Android的/system/lib/libmedia_jni.so档案里的代码片段如下所示：
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayer-JNI"
static JNINativeMethod gMethods[] = {
{"setDataSource", "(Ljava/lang/String; )V",
(void ＊)android_media_MediaPlayer_setDataSource},
{"setDataSource", "(Ljava/io/FileDescriptor; JJ)V",
(void ＊)android_media_MediaPlayer_setDataSourceFD},
{"prepare", "()V", (void ＊)android_media_MediaPlayer_prepare},
{"prepareAsync", "()V", (void ＊)android_media_MediaPlayer_prepareAsync},
{"_start", "()V", (void ＊)android_media_MediaPlayer_start},
{"_stop", "()V", (void ＊)android_media_MediaPlayer_stop},
{"getVideoWidth", "()I", (void ＊)android_media_MediaPlayer_getVideoWidth},
{"getVideoHeight", "()I", (void ＊)android_media_MediaPlayer_getVideoHeight},
{"seekTo", "(I)V", (void ＊)android_media_MediaPlayer_seekTo},
{"_pause", "()V", (void ＊)android_media_MediaPlayer_pause},
{"isPlaying", "()Z", (void ＊)android_media_MediaPlayer_isPlaying},
{"getCurrentPosition", "()I", (void ＊)android_media_MediaPlayer_getCurrentPosition},
{"getDuration", "()I", (void ＊)android_media_MediaPlayer_getDuration},
{"_release", "()V", (void ＊)android_media_MediaPlayer_release},
{"_reset", "()V", (void ＊)android_media_MediaPlayer_reset},
{"setAudioStreamType", "(I)V", (void ＊)android_media_MediaPlayer_setAudioStreamType},
{"setLooping", "(Z)V", (void ＊)android_media_MediaPlayer_setLooping},
{"setVolume", "(FF)V", (void ＊)android_media_MediaPlayer_setVolume},
{"getFrameAt", "(I)Landroid/graphics/Bitmap; ",
(void ＊)android_media_MediaPlayer_getFrameAt},
{"native_setup", "(Ljava/lang/Object; )V",
(void ＊)android_media_MediaPlayer_native_setup},
{"native_finalize", "()V", (void ＊)android_media_MediaPlayer_native_finalize},
};
static int register_android_media_MediaPlayer(JNIEnv ＊env){
return AndroidRuntime::registerNativeMethods(env,
"android/media/MediaPlayer", gMethods, NELEM(gMethods));
}
jint JNI_OnLoad(JavaVM＊ vm, void＊ reserved){
if (register_android_media_MediaPlayer(env) < 0) {
LOGE("ERROR: MediaPlayer native registration failed\n");
goto bail;
}
}
这样当VM载入libmedia_jni.so档案时，就会呼叫函数JNI_OnLoad()，然后JNI_OnLoad()呼叫函数register_android_media_MediaPlayer()。此时，就呼叫到函数AndroidRuntime::registerNativeMethods()，并向VM(即AndroidRuntime)登记数组gMethods[]表格所含的本地函数。由此可见，函数registerNativeMethods具备如下所示的两个功能。
更有效率地找到函数。
可以在执行期间进行抽换。因为gMethods[]是一个“<名称，函数指针>”格式的对照表，所以在执行程序时可以通过多次呼叫函数registerNativeMethods()的方式来更换本地函数之指针。
4.4.3 动态注册
当Java层通过System.loadLibrary加载完JNI动态库后，接着会查找函数JNI_OnLoad，通过调用函数JNI_OnLoad完成动态注册工作。函数JNI_OnLoad在文件android_media_MediaPlayer.cpp中实现，具体代码如下所示：
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("ERROR: GetEnv failed\n");
goto bail;
}
assert(env ! = NULL);
......
if (register_android_media_MediaScanner(env) < 0) {
ALOGE("ERROR: MediaScanner native registration failed\n");
goto bail;
}
.......
/＊成功—则返回有效的版本号＊/
result = JNI_VERSION_1_4;
bail:
return result;
}
函数JNI_OnLoad会回传JNI_VERSION_1_4的值给VM，这让VM能够知道所使用JNI的版本是什么。此外，它也做了一些初期的动作（可呼叫任何本地函数），例如下面的指令：
if (register_android_media_MediaPlayer(env) < 0) {
LOGE("ERROR: MediaPlayer native registration failed\n");
goto bail;
}
这样就将此组件提供的各个本地函数（Native Function）登记到VM里，以便能加快后续呼叫本地函数的效率。
函数JNI_OnUnload()与JNI_OnLoad()是相对应的。在载入C组件时会立即呼叫JNI_OnLoad()进行组件内的初期动作；而当VM释放该C组件时，则会呼叫JNI_OnUnload()函数来进行善后清除动作。当VM呼叫JNI_OnLoad()或JNI_Unload()函数时，都会将VM的指针（Pointer）传递给它们，其参数如下所示：
jint JNI_OnLoad(JavaVM＊ vm, void＊ reserved) { }
jint JNI_OnUnload(JavaVM＊ vm, void＊ reserved){ }
在JNI_OnLoad()函数里，就透过VM的指标而取得JNIEnv的指标值，并存入env指标变数里，如下述指令：
jint JNI_OnLoad(JavaVM＊ vm, void＊ reserved){
JNIEnv＊ env = NULL;
jint result = -1;
if (vm->GetEnv((void＊＊) &env, JNI_VERSION_1_4) ! = JNI_OK) {
LOGE("ERROR: GetEnv failed\n");
goto bail;
}
}
由于VM通常是多执行绪(Multi-threading)的执行环境。每一个执行绪在呼叫JNI_OnLoad()时，所传递进来的JNIEnv指标值都是不同的。为了配合这种多执行绪的环境，C组件开发者在撰写本地函数时，可借用由JNIEnv指标值的不同而避免执行绪的资料冲突问题，才能确保所写的本地函数能安全地在Android的多执行绪VM里安全地执行。基于这个理由，当在呼叫C组件的函数时，都会将JNIEnv指标值传递给它，对应代码如下所示：
jint JNI_OnLoad(JavaVM＊ vm, void＊ reserved)
{
JNIEnv＊ env = NULL;
if (register_android_media_MediaPlayer(env) < 0) {
}
}
这样当JNI_OnLoad()呼叫函数register_android_media_MediaPlayer(env)时，就将env指标值传递过去。这样函数register_android_media_MediaPlayer()就能借用该标识值来区别不同的执行，以便解决资料冲突的问题。
例如，在register_android_media_MediaPlayer()函数里，可以编写如下所示的指令：
if ((＊env)->MonitorEnter(env, obj) ! = JNI_OK) {
}
此时可以查看是否有其他执行程序进入此物件，如果没有，则此执行就进入该物件里执行了。并且也可以编写如下所示的指令：
if ((＊env)->MonitorExit(env, obj) ! = JNI_OK) {
}
这样便可以查看是否此执行正在此物件内执行，如果是，此执行就会立即离开。
4.4.4 处理路径参数
在文件frameworks/base/media/libmedia/MediaScanner.cpp中，函数processDirectory的功能是对路径参数进行了一些处理，调用doProcessDirectory。里面的参数“@extensions”可能包含多个扩展名，在扩展名之间用“, ”分隔开。具体实现代码如下所示：
status_t MediaScanner::processDirectory(
const char ＊path, const char ＊extensions,
MediaScannerClient &client,
ExceptionCheck exceptionCheck, void ＊exceptionEnv) {
int pathLength = strlen(path);
if (pathLength >= PATH_MAX) {
return UNKNOWN_ERROR;
}
char＊ pathBuffer = (char ＊)malloc(PATH_MAX + 1);
if (! pathBuffer) {
return UNKNOWN_ERROR;
}
int pathRemaining = PATH_MAX - pathLength;
strcpy(pathBuffer, path);
if (pathLength > 0 && pathBuffer[pathLength -1] ! = '/') {
pathBuffer[pathLength] = '/';
pathBuffer[pathLength + 1] = 0;
--pathRemaining;
}
client.setLocale(locale());
status_t result =
doProcessDirectory(
pathBuffer, pathRemaining, extensions, client,
exceptionCheck, exceptionEnv);
free(pathBuffer);
return result;
}
4.4.5 扫描文件
当收到扫描某个文件的请求时，会调用函数scanFile来扫描这个文件。函数scanFile的具体实现代码如下所示：
virtual bool scanFile(const char＊ path, long long lastModified, long long fileSize)
{
jstring pathStr;
if ((pathStr = mEnv->NewStringUTF(path)) == NULL) return false;
//调用Java里面mClient中的scanFile方法
mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified, fileSize);
mEnv->DeleteLocalRef(pathStr);
return (! mEnv->ExceptionCheck());
}
4.4.6 添加TAG信息
在文件\frameworks\av\media\libmedia\MediaScannerClient.cpp中，通过函数addStringTag添加TAG信息。这个MediaScannerClient是在opencore中的文件MediaScanner.cpp实现的，而文件android_media_MediaScanner.cpp中的MyMediaScannerClient是从MediaScannerClient派生下来的。函数addStringTag的具体实现代码如下所示：
status_t MediaScannerClient::addStringTag(const char＊ name, const char＊ value)
{
if (mLocaleEncoding ! = kEncodingNone) {
//不要缓存都是ASCII字符串
//呼叫handlestringtag直接代替
//查看值中是否有非ASCII字符，应该是UTF8）
bool nonAscii = false;
const char＊ chp = value;
char ch;
while ((ch = ＊chp++)) {
if (ch & 0x80) {
nonAscii = true;
break;
}
}
//判断name和value的编码是不是ASCII，不是则保存到mNames和mValues中
//save the strings for later so they can be used for native encoding detection
mNames->push_back(name);
mValues->push_back(value);
return OK;
}
//其他的失败情形
}
//如果字符编码是ASCII，则调用函数handleStringTag
return handleStringTag(name, value);
}
4.4.7 总结函数JNl_OnLoad()与函数JNl_OnUnload()的用途
当Android的VM(Virtual Machine)执行到System.loadLibrary()函数时，首先会去执行C组件里的JNI_OnLoad()函数，其用途有如下两点。
（1）告诉VM此C组件使用哪一个JNI版本。如果你的*.so档没有提供JNI_OnLoad()函数，VM会默认该*.so档是使用最老的JNI 1.1版本。由于新版的JNI做了许多扩充，如果需要使用JNI的新版功能，例如JNI 1.4的java.nio.ByteBuffer，就必须藉由JNI_OnLoad()函数来告知VM。
（2）由于VM执行到System.loadLibrary()函数时，就会立即先呼叫JNI_OnLoad()，所以C组件的开发者可以藉由JNI_OnLoad()来进行C组件内的初期值的设定(Initialization)。
例如，在Android的/system/lib/libmedia_jni.so档案里，就提供了JNI_OnLoad()函数，其代码片段如下所示：
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayer-JNI"
jint JNI_OnLoad(JavaVM＊ vm, void＊ reserved)
{
JNIEnv＊ env = NULL;
jint result = -1;
if (vm->GetEnv((void＊＊) &env, JNI_VERSION_1_4) ! = JNI_OK) {
LOGE("ERROR: GetEnv failed\n");
goto bail;
}
assert(env ! = NULL);
if (register_android_media_MediaPlayer(env) < 0) {
LOGE("ERROR: MediaPlayer native registration failed\n");
goto bail;
}
if (register_android_media_MediaRecorder(env) < 0) {
LOGE("ERROR: MediaRecorder native registration failed\n");
goto bail;
}
if (register_android_media_MediaScanner(env) < 0) {
LOGE("ERROR: MediaScanner native registration failed\n");
goto bail;
}
if (register_android_media_MediaMetadataRetriever(env) < 0) {
LOGE("ERROR: MediaMetadataRetriever native registration failed\n");
goto bail;
}
/＊ success -- return valid version number ＊/
result = JNI_VERSION_1_4;
bail:
return result;
}
此函数回传JNI_VERSION_1_4值给VM，于是VM便知道了其所使用的JNI的版本。
4.4.8 Java与JNl基本数据类型转换
Java与JNI基本数据类型转换信息如表4-1所示。
表4-1 基本数据类型的转换关系
数组类型的对应关系如表4-2所示。
表4-2 数组数据类型的对应关系
对象数据类型的对应关系如表4-3所示。
表4-3 对象数据类型的对应关系
引用数据类型的转换关系如图4-3所示。
图4-3 引用数据类型的转换关系
4.4.9 JNlEnv接口
JNIEnv是跟线程相关的，在Native Method（本地方法）中，JNIEnv作为第一个参数传入。JNIEnv的内部结构如图4-4所示。
图4-4 JNIEnv的内部结构
在JNIEnv不作为参数传入的时候，JNI提供了如下所示的两个函数以获得它。
（*jvm)->AttachCurrentThread(jvm, (void**)&env, NULL)。
（*jvm）->GetEnv(jvm, (void**)&env, JNI_VERSION_1_2)。
上述两个函数都利用JavaVM接口获得JNIEnv接口，并且JNI可以将获得的JNIEnv封装成一个函数。即：
JNIEnv＊ JNU_GetEnv()
{
JNIEnv＊ env;
(＊g_jvm)->GetEnv(g_jvm, (void＊＊)&env, JNI_VERSION_1_2);
return env;
}
Java通过JNI机制调用C/C++写的native程序，C/C++开发的Native程序需要遵循一定的JNI规范。例如下面的例子就是一个JNI函数声明：
JNIEXPORT jint JNICALL Java_jnitest_MyTest_test
(JNIEnv ＊ env, jobject obj, jint arg0);
JVM负责从Java Stack转入C/C++ Native Stack。当Java进入JNI调用，除了函数本身的参数(arg0)外会多出两个参数：JNIEnv指针和jobject指针。其中JNIEnv指针是JVM创建的，用于Native的C/C++方法操纵Java执行栈中的数据，比如Java Class, Java Method等。
首先，JNI对于JNIEnv的使用提供了两种语法，分别是C语法以及C++语法。其中C语法是：
jsize len = (＊env)->GetArrayLength(env, array);
C++语法是：
jsize len =env->GetArrayLength(array);
因为C语言并不支持对象的概念，所以C语法中需要把env作为第一个参数传入，这类似于C++的隐式参数this指针。
另外，在使用JNIEnv接口时，需要遵循如下所示的两个设计原则。
（1）JNIEnv指针被设计成了Thread Local Storage(TLS)变量，也就是说每一个Thread, JNIEnv变量都有独立的Copy。你不能把Thead#1使用的JNIEnv传给Thread#2使用。
（2）在JNIEnv中定义了一组函数指针，C/C++ Native程序是通过这些函数指针操纵Java数据。这样设计的好处是，C/C++程序不需要依赖任何函数库或者DLL。由于JVM可能由不同的厂商实现，不同厂商有自己不同的JNI实现，如果要求这些厂商暴露约定好的一些头文件和库，这不是灵活的设计。而且使用函数指针表的另外一个好处是，JVM可以根据启动参数动态替换JNI实现。
在jint JNI_OnLoad(JavaVM* vm, void* reserved)的整个进程只有一个JavaVM对象，可以保存并在任何地方使用。利用JavaVM中的AttachCurrentThread函数，就可以得到这个线程的JNIEnv结构体，利用DetachCurrnetThread释放相应资源。
4.4.10 JNl中的环境变量
在Android系统中的所有模块的JNI层的代码中，经常看到函数中有JNIEnv*类型的参数，例如文件frameworks/base/core/jni/android_hardware_Camera.c中的如下代码：
static void android_hardware_Camera_startPreview(JNIEnv ＊env, jobject thiz)
{
LOGV("startPreview");
sp<Camera> camera = get_native_camera(env, thiz, NULL);
if (camera == 0) return;
if (camera->startPreview() ! = NO_ERROR) {
jniThrowRuntimeException(env, "startPreview failed");
return;
}
}
在上述函数中，第一个参数为JNIEnv *Env，此处的JNIEnv *类型是一个指向JNI环境的指针，JNIEnv *类型在文件Jni.h中定义，在此结构体中包含了一些JNI中常用到的函数和一组函数指针，C/C++正是通过这些函数指针来操作Java函数的。JNIEnv结构体在文件jni.h中定义，具体实现代码如下所示：
struct _JNIEnv {
……
jint GetVersion()
{ return functions->GetVersion(this); }
……
jclass FindClass(const char＊ name)
{ return functions->FindClass(this, name); }
……
void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue＊ args)
{ functions->CallVoidMethodA(this, obj, methodID, args); }
……
jmethodID GetStaticMethodID(jclass clazz, const char＊ name, const char＊ sig)
{ return functions->GetStaticMethodID(this, clazz, name, sig); }
……
}
通过上述代码可以发现，正是通过使用这个JNIEnv指针才能够调用一些JNI环境中的方法。