深入分析Android加载so文件源码

System.load(String pathName)
System.loadLibraray(String libName)

System.load("/data/local/tmp/libHello.so");
System.loadLibrary("Hello");

public static void load(String pathName) {
    Runtime.getRuntime().load(pathName,VMStack.getCallingClassLoader());
  }

  /**
   * See {@link Runtime#loadLibrary}.
   */
  public static void loadLibrary(String libName) {
    Runtime.getRuntime().loadLibrary(libName,VMStack.getCallingClassLoader());
  }

 public static Runtime getRuntime() {
    return mRuntime;
  }

public void loadLibrary(String nickName) {
    loadLibrary(nickname,VMStack.getCallingClassLoader());
  }
  
   void loadLibrary(String libraryName,ClassLoader loader) {
    if (loader != null) {
      String filename = loader.findLibrary(libraryName);
      if (filename == null) {
        // It's not necessarily true that the ClassLoader used
        // System.mapLibraryName,but the default setup does,and it's
        // misleading to say we didn't find "libMyLibrary.so" when we
        // actually searched for "liblibMyLibrary.so.so".
        throw new UnsatisfiedLinkError(loader + " Couldn't find \"" +
                        System.mapLibraryName(libraryName) + "\"");
      }
      String error = doLoad(filename,loader);
      if (error != null) {
        throw new UnsatisfiedLinkError(error);
      }
      return;
    }

    String filename = System.mapLibraryName(libraryName);
    List<String> candidates = new ArrayList<String>();
    String lastError = null;
    for (String directory : mLibPaths) {
      String candidate = directory + filename;
      candidates.add(candidatE);

      if (IoUtils.canOpenReadOnly(candidatE)) {
        String error = doLoad(candidate,loader);
        if (error == null) {
          return; // We successfully loaded the library. Job done.
        }
        lastError = error;
      }
    }

    if (lastError != null) {
      throw new UnsatisfiedLinkError(lastError);
    }
    throw new UnsatisfiedLinkError("Library " + libraryName + " not found; tried " + candidates);
}

 private String doLoad(String name,ClassLoader loader) {
 String ldLibraryPath = null;
    String dexPath = null;
    if (loader == null) {
      // We use the given library path for the boot class loader. This is the path
      // also used in loadLibraryName if loader is null.
      ldLibraryPath = System.getProperty("java.library.path");
    } else if (loader instanceof BaseDexClassLoader) {
      BaseDexClassLoader dexClassLoader = (BaseDexClassLoader) loader;
      ldLibraryPath = dexClassLoader.getLdLibraryPath();
    }
    // nativeLoad should be synchronized so there's only one LD_LIBRARY_PATH in use regardless
    // of how many ClassLoaders are in the system,but dalvik doesn't support synchronized
    // internal natives.
    synchronized (this) {
      return nativeLoad(name,loader,ldLibraryPath);
    }
  }

static jString Runtime_nativeLoad(jnienv* env,jclass,jString javaFilename,jobject javaLoader,jString javaLdLibraryPathJstr) {
 ScopedUtfChars filename(env,javaFileName);
 if (filename.c_str() == nullptr) {
  return nullptr;
 }

 SetLdLibraryPath(env,javaLdLibraryPathJstr);

 std::string error_msg;
 {
  JavaVMExt* vm = Runtime::Current()->GetJavaVM();
  bool success = vm->LoadNativeLibrary(env,filename.c_str(),javaLoader,&error_msg);
  if (success) {
   return nullptr;
  }
 }

 // Don't let a pending exception from JNI_OnLoad cause a checkJNI issue with NewStringUTF.
 env->ExceptionClear();
 return env->NewStringUTF(error_msg.c_str());
}

bool JavaVMExt::LoadNativeLibrary(jnienv* env,const std::string& path,jobject class_loader,std::string* error_msg) {
...
const char* path_str = path.empty() ? nullptr : path.c_str();
 void* handle = dlopen(path_str,RTLD_Now);

...
 if (needs_native_bridgE) {
  library->SetNeedsNativeBridge();
  sym = library->FindSymbolWithNativeBridge("JNI_OnLoad",nullptr);
 } else {
  sym = dlsym(handle,"JNI_OnLoad");
 }
 if (sym == nullptr) {
  VLOG(jni) << "[No JNI_OnLoad found in \"" << path << "\"]";
  was_successful = true;
 } else {