之前面試百度，那個小哥哥問我，你知道安卓jni有幾種方式生成，是怎麼實現的，你知道實現的邏輯嗎？問題大概是這樣。我只回答了JNI怎麼實現，實現的邏輯沒有看過搭不上來。後面想想也是，隨便一個做安卓三年的JNI都可以用的很溜的，你想跟別人有點不一樣，還是要看看源碼，看看實現的邏輯。深入一點你會得到無限樂趣，不論在哪方面，別隻長了年紀沒長技能。
結合着chromium來看看安卓的JNI實現。
上一篇介紹過，在AwShellActivity onCreate的時候，會加載so，最後會調用到loadWithSystemLinkerAlreadyLocked函數，通過調用System.loadLibrary跟System.load進行加載，着兩個都是系統函數，先看看這兩個函數的區別。因爲我的debug板是安卓4.4.2的，所以看的安卓源碼是安卓4.4.2。以下涉及系統源碼的代碼路徑都是指安卓4.4.2下的路徑
private void loadWithSystemLinkerAlreadyLocked(ApplicationInfo appInfo, boolean inZygote) {
......
for (String library : NativeLibraries.LIBRARIES) {
if (!isInZipFile()) {
System.loadLibrary(library);
} else {
// Load directly from the APK.
boolean is64Bit = ApiHelperForM.isProcess64Bit();
String zipFilePath = appInfo.sourceDir;
boolean crazyPrefix = forceSystemLinker(); // See comment in this function.
String fullPath = zipFilePath + "!/"
+ makeLibraryPathInZipFile(library, crazyPrefix, is64Bit);
Log.i(TAG, "libraryName: %s", fullPath);
System.load(fullPath);
}
}
}
先看看System.loadLibrary跟System.load的實現：
/**
* Loads and links the library with the specified name. The mapping of the
* specified library name to the full path for loading the library is
* implementation-dependent.
*
* @param libName
* the name of the library to load.
* @throws UnsatisfiedLinkError
* if the library could not be loaded.
*/
public static void loadLibrary(String libName) {
Runtime.getRuntime().loadLibrary(libName, VMStack.getCallingClassLoader());
}
/**
* Loads and links the dynamic library that is identified through the
* specified path. This method is similar to {@link #loadLibrary(String)},
* but it accepts a full path specification whereas {@code loadLibrary} just
* accepts the name of the library to load.
*
* @param pathName
* the path of the file to be loaded.
*/
public static void load(String pathName) {
Runtime.getRuntime().load(pathName, VMStack.getCallingClassLoader());
}
代碼路徑：libcore/luni/src/main/java/java/lang/System.java
從註釋上看System.loadLibrary跟System.load的差別，是入參的差別，System.load的入參是全路徑，而System.loadLibrary跟的是so不含lib跟so的名稱，同樣加載libstandalonelibwebviewchromium.so，入參差別如下：
eg：System.loadLibrary(standalonelibwebviewchromium);
System.load(/data/app/org.chromium.android_webview.shell-2/lib/arm/libstandalonelibwebviewchromium.so);
System.loadLibrary函數和System.load函數僅僅在調用參數上有一些區別（java層的代碼實現上有一些差別），具體的底層函數實現是一樣的，System.loadLibrary函數和System.load函數最終底層都是調用的Native函數Runtime.nativeLoad來實現。兩者調用關係如 下，終究是殊途同歸。所以還是看看nativeLoad函數做了什麼。
可以在dalvik/vm/native/java_lang_Runtime.cpp文件找到nativeLoad函數對應的JNI函數。
const DalvikNativeMethod dvm_java_lang_Runtime[] = {
{ "freeMemory", "()J",
Dalvik_java_lang_Runtime_freeMemory },
{ "gc", "()V",
Dalvik_java_lang_Runtime_gc },
{ "maxMemory", "()J",
Dalvik_java_lang_Runtime_maxMemory },
{ "nativeExit", "(I)V",
Dalvik_java_lang_Runtime_nativeExit },
{ "nativeLoad", "(Ljava/lang/String;Ljava/lang/ClassLoader;Ljava/lang/String;)Ljava/lang/String;",
Dalvik_java_lang_Runtime_nativeLoad },
{ "totalMemory", "()J",
Dalvik_java_lang_Runtime_totalMemory },
{ NULL, NULL, NULL },
};
如果有興趣，可以根據下圖，看看dvm_java_lang_Runtime的註冊流程：
代碼路徑是：
dalvik/dalvikvm/main.cpp
dalvik/vm/Jni.cpp
dalvik/vm/Init.cpp
dalvik/vm/native/InternalNative.cpp
在dvmInternalNativeStartup進行了虛擬機的基本方法的註冊。
接着看nativeLoad幹什麼了
（1）取需要加載的so庫文件的絕對路徑；
（2）判斷加載的依賴so庫文件的文件目錄路徑是否爲空；
（3） 調用dvmLoadNativeCode函數加載目標so庫文件。dvmLoadNativeCode函數主要實現是先調用dlopen函數加載目標so庫文件，然後通過獲取的句柄，調用dlsym到處函數JNI_OnLoad，實現jni函數的註冊以及其他的初始化操作等。
static void Dalvik_java_lang_Runtime_nativeLoad(const u4* args,
JValue* pResult)
{
StringObject* fileNameObj = (StringObject*) args[0];
Object* classLoader = (Object*) args[1];
StringObject* ldLibraryPathObj = (StringObject*) args[2];
assert(fileNameObj != NULL);
char* fileName = dvmCreateCstrFromString(fileNameObj);
if (ldLibraryPathObj != NULL) {
char* ldLibraryPath = dvmCreateCstrFromString(ldLibraryPathObj);
void* sym = dlsym(RTLD_DEFAULT, "android_update_LD_LIBRARY_PATH");
if (sym != NULL) {
typedef void (*Fn)(const char*);
Fn android_update_LD_LIBRARY_PATH = reinterpret_cast<Fn>(sym);
(*android_update_LD_LIBRARY_PATH)(ldLibraryPath);
} else {
ALOGE("android_update_LD_LIBRARY_PATH not found; .so dependencies will not work!");
}
free(ldLibraryPath);
}
StringObject* result = NULL;
char* reason = NULL;
bool success = dvmLoadNativeCode(fileName, classLoader, &reason);
if (!success) {
const char* msg = (reason != NULL) ? reason : "unknown failure";
result = dvmCreateStringFromCstr(msg);
dvmReleaseTrackedAlloc((Object*) result, NULL);
}
free(reason);
free(fileName);
RETURN_PTR(result);
}
如下是dvmLoadNativeCode的實現
（1）判斷so是否已經加載過了，如果是，就直接return了；
（2）dlopen so獲取句柄，將so Entry添加到動態庫的哈希tab種；
（3）根據2中獲取的句柄，調用dlsym獲取JNI_OnLoad函數的地址，根據獲取的地址進行初始化。
到這也就可以明白，加載so是怎麼調用到JNI_OnLoad進而實現native函數的動態註冊的了。
bool dvmLoadNativeCode(const char* pathName, Object* classLoader,
char** detail)
{
SharedLib* pEntry;
void* handle;
bool verbose;
/* reduce noise by not chattering about system libraries */
verbose = !!strncmp(pathName, "/system", sizeof("/system")-1);
verbose = verbose && !!strncmp(pathName, "/vendor", sizeof("/vendor")-1);
if (verbose)
ALOGD("Trying to load lib %s %p", pathName, classLoader);
*detail = NULL;
/*
* See if we've already loaded it. If we have, and the class loader
* matches, return successfully without doing anything.
*/
pEntry = findSharedLibEntry(pathName);
if (pEntry != NULL) {
if (pEntry->classLoader != classLoader) {
ALOGW("Shared lib '%s' already opened by CL %p; can't open in %p",
pathName, pEntry->classLoader, classLoader);
return false;
}
if (verbose) {
ALOGD("Shared lib '%s' already loaded in same CL %p",
pathName, classLoader);
}
if (!checkOnLoadResult(pEntry))
return false;
return true;
}
/*
* Open the shared library. Because we're using a full path, the system
* doesn't have to search through LD_LIBRARY_PATH. (It may do so to
* resolve this library's dependencies though.)
*
* Failures here are expected when java.library.path has several entries
* and we have to hunt for the lib.
*
* The current version of the dynamic linker prints detailed information
* about dlopen() failures. Some things to check if the message is
* cryptic:
* - make sure the library exists on the device
* - verify that the right path is being opened (the debug log message
* above can help with that)
* - check to see if the library is valid (e.g. not zero bytes long)
* - check config/prelink-linux-arm.map to ensure that the library
* is listed and is not being overrun by the previous entry (if
* loading suddenly stops working on a prelinked library, this is
* a good one to check)
* - write a trivial app that calls sleep() then dlopen(), attach
* to it with "strace -p <pid>" while it sleeps, and watch for
* attempts to open nonexistent dependent shared libs
*
* This can execute slowly for a large library on a busy system, so we
* want to switch from RUNNING to VMWAIT while it executes. This allows
* the GC to ignore us.
*/
Thread* self = dvmThreadSelf();
ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
handle = dlopen(pathName, RTLD_LAZY);
dvmChangeStatus(self, oldStatus);
if (handle == NULL) {
*detail = strdup(dlerror());
ALOGE("dlopen(\"%s\") failed: %s", pathName, *detail);
return false;
}
/* create a new entry */
SharedLib* pNewEntry;
pNewEntry = (SharedLib*) calloc(1, sizeof(SharedLib));
pNewEntry->pathName = strdup(pathName);
pNewEntry->handle = handle;
pNewEntry->classLoader = classLoader;
dvmInitMutex(&pNewEntry->onLoadLock);
pthread_cond_init(&pNewEntry->onLoadCond, NULL);
pNewEntry->onLoadThreadId = self->threadId;
/* try to add it to the list */
SharedLib* pActualEntry = addSharedLibEntry(pNewEntry);
if (pNewEntry != pActualEntry) {
ALOGI("WOW: we lost a race to add a shared lib (%s CL=%p)",
pathName, classLoader);
freeSharedLibEntry(pNewEntry);
return checkOnLoadResult(pActualEntry);
} else {
if (verbose)
ALOGD("Added shared lib %s %p", pathName, classLoader);
bool result = true;
void* vonLoad;
int version;
vonLoad = dlsym(handle, "JNI_OnLoad");
if (vonLoad == NULL) {
ALOGD("No JNI_OnLoad found in %s %p, skipping init",
pathName, classLoader);
} else {
/*
* Call JNI_OnLoad. We have to override the current class
* loader, which will always be "null" since the stuff at the
* top of the stack is around Runtime.loadLibrary(). (See
* the comments in the JNI FindClass function.)
*/
OnLoadFunc func = (OnLoadFunc)vonLoad;
Object* prevOverride = self->classLoaderOverride;
self->classLoaderOverride = classLoader;
oldStatus = dvmChangeStatus(self, THREAD_NATIVE);
if (gDvm.verboseJni) {
ALOGI("[Calling JNI_OnLoad for \"%s\"]", pathName);
}
version = (*func)(gDvmJni.jniVm, NULL);
dvmChangeStatus(self, oldStatus);
self->classLoaderOverride = prevOverride;
if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4 &&
version != JNI_VERSION_1_6)
{
ALOGW("JNI_OnLoad returned bad version (%d) in %s %p",
version, pathName, classLoader);
/*
* It's unwise to call dlclose() here, but we can mark it
* as bad and ensure that future load attempts will fail.
*
* We don't know how far JNI_OnLoad got, so there could
* be some partially-initialized stuff accessible through
* newly-registered native method calls. We could try to
* unregister them, but that doesn't seem worthwhile.
*/
result = false;
} else {
if (gDvm.verboseJni) {
ALOGI("[Returned from JNI_OnLoad for \"%s\"]", pathName);
}
}
}
if (result)
pNewEntry->onLoadResult = kOnLoadOkay;
else
pNewEntry->onLoadResult = kOnLoadFailed;
pNewEntry->onLoadThreadId = 0;
/*
* Broadcast a wakeup to anybody sleeping on the condition variable.
*/
dvmLockMutex(&pNewEntry->onLoadLock);
pthread_cond_broadcast(&pNewEntry->onLoadCond);
dvmUnlockMutex(&pNewEntry->onLoadLock);
return result;
}
}
好了我們來看看chromium的JNI的實現吧，我看的是WebViewInstrumentation.apk也就以它爲例。
WebViewInstrumentation.apk的JNI_OnLoad在./android_webview/lib/webview_entry_point.cc文件中進行重寫。
// This is called by the VM when the shared library is first loaded.
// Most of the initialization is done in LibraryLoadedOnMainThread(), not here.
JNI_EXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
base::android::InitVM(vm);
#if defined(WEBVIEW_INCLUDES_WEBLAYER)
if (!weblayer::MaybeRegisterNatives())
return -1;
#endif
base::android::SetNativeInitializationHook(&NativeInit);
return JNI_VERSION_1_4;
}
看看JNI_OnLoad做了什麼有興趣的可以根據下圖去跟蹤，不同線程起來的時候也會有JNI的註冊，可以分線程去看。
