此文已由作者尹彬彬授權網易雲社群釋出。
歡迎訪問網易雲社群，瞭解更多網易技術產品運營經驗。
0X0 前言
在Android系統中，當我們安裝apk檔案的時候，lib目錄下的so檔案會被解壓到app的原生庫目錄，一般來說是放到/data/data/<package-name>/lib目錄下，而根據系統和CPU架構的不同，其拷貝策略也是不一樣的，在我們測試過程中發現不正確地配置了so檔案,比如某些app使用第三方的so時，只配置了其中某一種CPU架構的so，可能會造成app在某些機型上的適配問題。所以這篇文章主要介紹一下在不同版本的Android系統中，安裝apk時，PackageManagerService選擇解壓so庫的策略，並給出一些so檔案配置的建議。
0x1 Android4.0以前
當apk被安裝時，執行路徑雖然有差別，但最終要呼叫到的一個核心函式是copyApk,負責拷貝apk中的資源。
參考2.3.6的android原始碼，它的copyApk其內部函式一段選取原生庫so邏輯：
public static int listPackageNativeBinariesLI(ZipFile zipFile,
List> nativeFiles) throws ZipException, IOException {
String cpuAbi = Build.CPU_ABI; int result = listPackageSharedLibsForAbiLI(zipFile, cpuAbi, nativeFiles); /*
* Some architectures are capable of supporting several CPU ABIs
* for example, 'armeabi-v7a' also supports 'armeabi' native code
* this is indicated by the definition of the ro.product.cpu.abi2
* system property.
*
* only scan the package twice in case of ABI mismatch
*/
if (result == PACKAGE_INSTALL_NATIVE_ABI_MISMATCH) { final String cpuAbi2 = SystemProperties.get("ro.product.cpu.abi2", null); if (cpuAbi2 != null) {
result = listPackageSharedLibsForAbiLI(zipFile, cpuAbi2, nativeFiles);
} if (result == PACKAGE_INSTALL_NATIVE_ABI_MISMATCH) {
Slog.w(TAG, "Native ABI mismatch from package file"); return PackageManager.INSTALL_FAILED_INVALID_APK;
} if (result == PACKAGE_INSTALL_NATIVE_FOUND_LIBRARIES) {
cpuAbi = cpuAbi2;
}
} /*
* Debuggable packages may have gdbserver embedded, so add it to
* the list to the list of items to be extracted (as lib/gdbserver)
* into the application's native library directory later.
*/
if (result == PACKAGE_INSTALL_NATIVE_FOUND_LIBRARIES) {
listPackageGdbServerLI(zipFile, cpuAbi, nativeFiles);
} return PackageManager.INSTALL_SUCCEEDED;
}複製程式碼這段程式碼中的Build.CPU_ABI和“ro.product.cpu.abi2”分別為手機支援的主abi和次abi屬性字串，abi為手機支援的指令集所代表的字串，比如armeabi-v7a、armeabi、x86、mips等，而主abi和次abi分別表示手機支援的第一指令集和第二指令集。程式碼首先呼叫listPackageSharedLibsForAbiLI來遍歷主abi目錄。當主abi目錄不存在時，才會接著呼叫listPackageSharedLibsForAbiLI遍歷次abi目錄。
/*
* Find all files of the form lib//lib.so in the .apk
* and add them to a list to be installed later.
*
* NOTE: this method may throw an IOException if the library cannot
* be copied to its final destination, e.g. if there isn't enough
* room left on the data partition, or a ZipException if the package
* file is malformed.
*/
private static int listPackageSharedLibsForAbiLI(ZipFile zipFile,
String cpuAbi, List> libEntries) throws IOException,
ZipException { final int cpuAbiLen = cpuAbi.length(); boolean hasNativeLibraries = false; boolean installedNativeLibraries = false; if (DEBUG_NATIVE) {
Slog.d(TAG, "Checking " + zipFile.getName() + " for shared libraries of CPU ABI type "
+ cpuAbi);
}
Enumeration entries = zipFile.entries(); while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement(); // skip directories
if (entry.isDirectory()) { continue;
}
String entryName = entry.getName(); /*
* Check that the entry looks like lib//lib.so
* here, but don't check the ABI just yet.
*
* - must be sufficiently long
* - must end with LIB_SUFFIX, i.e. ".so"
* - must start with APK_LIB, i.e. "lib/"
*/
if (entryName.length() < MIN_ENTRY_LENGTH || !entryName.endsWith(LIB_SUFFIX)
|| !entryName.startsWith(APK_LIB)) { continue;
} // file name must start with LIB_PREFIX, i.e. "lib"
int lastSlash = entryName.lastIndexOf('/'); if (lastSlash < 0
|| !entryName.regionMatches(lastSlash + 1, LIB_PREFIX, 0, LIB_PREFIX_LENGTH)) { continue;
}
hasNativeLibraries = true; // check the cpuAbi now, between lib/ and /lib.so
if (lastSlash != APK_LIB_LENGTH + cpuAbiLen
|| !entryName.regionMatches(APK_LIB_LENGTH, cpuAbi, 0, cpuAbiLen)) continue; /*
* Extract the library file name, ensure it doesn't contain
* weird characters. we're guaranteed here that it doesn't contain
* a directory separator though.
*/
String libFileName = entryName.substring(lastSlash+1); if (!FileUtils.isFilenameSafe(new File(libFileName))) { continue;
}
installedNativeLibraries = true; if (DEBUG_NATIVE) {
Log.d(TAG, "Caching shared lib " + entry.getName());
}
libEntries.add(Pair.create(entry, libFileName));
} if (!hasNativeLibraries) return PACKAGE_INSTALL_NATIVE_NO_LIBRARIES; if (!installedNativeLibraries) return PACKAGE_INSTALL_NATIVE_ABI_MISMATCH; return PACKAGE_INSTALL_NATIVE_FOUND_LIBRARIES;
}複製程式碼listPackageSharedLibsForAbiLI中判斷當前遍歷的apk中檔案的entry名是否符合so命名的規範且包含相應abi字串名。如果符合則規則則將so的entry名加入list，如果遍歷失敗或者規則不匹配則返回相應錯誤碼。
拷貝so策略：
遍歷apk中檔案，當apk中lib目錄下主abi子目錄中有so檔案存在時，則全部拷貝主abi子目錄下的so；只有當主abi子目錄下沒有so檔案的時候即PACKAGE_INSTALL_NATIVE_ABI_MISMATCH的情況，才會拷貝次ABI子目錄下的so檔案。
策略問題：
當so放置不當時，安裝apk時會導致拷貝不全。比如apk的lib目錄下存在armeabi/libx.so,armeabi/liby.so,armeabi-v7a/libx.so這3個so檔案,那麼在主ABI為armeabi-v7a且系統版本小於4.0的手機上，apk安裝後，按照拷貝策略，只會拷貝主abi目錄下的檔案即armeabi-v7a/libx.so，當載入liby.so時就會報找不到so的異常。另外如果主abi目錄不存在，這個策略會遍歷2次apk，效率偏低。
0x2 Android 4.0-Android 4.0.3
參考4.0.3的android原始碼，同理，找到處理so拷貝的核心邏輯（native層）：
static install_status_titerateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2,
iterFunc callFunc, void* callArg) { ScopedUtfChars filePath(env, javaFilePath); ScopedUtfChars cpuAbi(env, javaCpuAbi); ScopedUtfChars cpuAbi2(env, javaCpuAbi2);
ZipFileRO zipFile; if (zipFile.open(filePath.c_str()) != NO_ERROR) {
LOGI("Couldn't open APK %s\n", filePath.c_str()); return INSTALL_FAILED_INVALID_APK;
} const int N = zipFile.getNumEntries(); char fileName[PATH_MAX]; for (int i = 0; i < N; i++) { const ZipEntryRO entry = zipFile.findEntryByIndex(i); if (entry == NULL) { continue;
} // Make sure this entry has a filename.
if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) { continue;
} // Make sure we're in the lib directory of the ZIP.
if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) { continue;
} // Make sure the filename is at least to the minimum library name size.
const size_t fileNameLen = strlen(fileName); static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN; if (fileNameLen < minLength) { continue;
} const char* lastSlash = strrchr(fileName, '/');
LOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName); // Check to make sure the CPU ABI of this file is one we support.
const char* cpuAbiOffset = fileName + APK_LIB_LEN; const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset;
LOGV("Comparing ABIs %s and %s versus %s\n", cpuAbi.c_str(), cpuAbi2.c_str(), cpuAbiOffset); if (cpuAbi.size() == cpuAbiRegionSize
&& *(cpuAbiOffset + cpuAbi.size()) == '/'
&& !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) {
LOGV("Using ABI %s\n", cpuAbi.c_str());
} else if (cpuAbi2.size() == cpuAbiRegionSize
&& *(cpuAbiOffset + cpuAbi2.size()) == '/'
&& !strncmp(cpuAbiOffset, cpuAbi2.c_str(), cpuAbiRegionSize)) {
LOGV("Using ABI %s\n", cpuAbi2.c_str());
} else {
LOGV("abi didn't match anything: %s (end at %zd)\n", cpuAbiOffset, cpuAbiRegionSize); continue;
} // If this is a .so file, check to see if we need to copy it.
if ((!strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN)
&& !strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN)
&& isFilenameSafe(lastSlash + 1))
|| !strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) {
install_status_t ret = callFunc(env, callArg, &zipFile, entry, lastSlash + 1); if (ret != INSTALL_SUCCEEDED) {
LOGV("Failure for entry %s", lastSlash + 1); return ret;
}
}
} return INSTALL_SUCCEEDED;
}複製程式碼拷貝so策略：
遍歷apk中所有檔案，如果符合so檔案的規則，且為主ABI目錄或者次ABI目錄下的so，就解壓拷貝到相應目錄。
策略問題：
存在同名so覆蓋，比如一個app的armeabi和armeabi-v7a目錄下都包含同名的so，那麼就會發生覆蓋現象，覆蓋的先後順序根據so檔案對應ZipFileR0中的hash值而定，考慮這樣一個例子，假設一個apk同時有armeabi/libx.so和armeabi-v7a/libx.so，安裝到主ABI為armeabi-v7a的手機上，拷貝so時根據遍歷順序，存在一種可能即armeab-v7a/libx.so優先遍歷並被拷貝，隨後armeabi/libx.so被遍歷拷貝，覆蓋了前者。本來應該載入armeabi-v7a目錄下的so，結果按照這個策略拷貝了armeabi目錄下的so。
apk中檔案entry的雜湊計算函式如下：
/*
* Simple string hash function for non-null-terminated strings.
*//*static*/ unsigned int ZipFileRO::computeHash(const char* str, int len)
{
unsigned int hash = 0; while (len--)
hash = hash * 31 + *str++; return hash;
}/*
* Add a new entry to the hash table.
*/void ZipFileRO::addToHash(const char* str, int strLen, unsigned int hash)
{ int ent = hash & (mHashTableSize-1); /*
* We over-allocate the table, so we're guaranteed to find an empty slot.
*/
while (mHashTable[ent].name != NULL)
ent = (ent + 1) & (mHashTableSize-1);
mHashTable[ent].name = str;
mHashTable[ent].nameLen = strLen;
}複製程式碼0x3 Android 4.0.4以後
以4.1.2系統為例，遍歷選擇so邏輯如下：
static install_status_titerateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2,
iterFunc callFunc, void* callArg) { ScopedUtfChars filePath(env, javaFilePath); ScopedUtfChars cpuAbi(env, javaCpuAbi); ScopedUtfChars cpuAbi2(env, javaCpuAbi2);
ZipFileRO zipFile; if (zipFile.open(filePath.c_str()) != NO_ERROR) {
ALOGI("Couldn't open APK %s\n", filePath.c_str()); return INSTALL_FAILED_INVALID_APK;
} const int N = zipFile.getNumEntries(); char fileName[PATH_MAX];
bool hasPrimaryAbi = false; for (int i = 0; i < N; i++) { const ZipEntryRO entry = zipFile.findEntryByIndex(i); if (entry == NULL) { continue;
} // Make sure this entry has a filename.
if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) { continue;
} // Make sure we're in the lib directory of the ZIP.
if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) { continue;
} // Make sure the filename is at least to the minimum library name size.
const size_t fileNameLen = strlen(fileName); static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN; if (fileNameLen < minLength) { continue;
} const char* lastSlash = strrchr(fileName, '/');
ALOG_ASSERT(lastSlash != NULL, "last slash was null somehow for %s\n", fileName); // Check to make sure the CPU ABI of this file is one we support.
const char* cpuAbiOffset = fileName + APK_LIB_LEN; const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset;
ALOGV("Comparing ABIs %s and %s versus %s\n", cpuAbi.c_str(), cpuAbi2.c_str(), cpuAbiOffset); if (cpuAbi.size() == cpuAbiRegionSize
&& *(cpuAbiOffset + cpuAbi.size()) == '/'
&& !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) {
ALOGV("Using primary ABI %s\n", cpuAbi.c_str());
hasPrimaryAbi = true;
} else if (cpuAbi2.size() == cpuAbiRegionSize
&& *(cpuAbiOffset + cpuAbi2.size()) == '/'
&& !strncmp(cpuAbiOffset, cpuAbi2.c_str(), cpuAbiRegionSize)) { /*
* If this library matches both the primary and secondary ABIs,
* only use the primary ABI.
*/
if (hasPrimaryAbi) {
ALOGV("Already saw primary ABI, skipping secondary ABI %s\n", cpuAbi2.c_str()); continue;
} else {
ALOGV("Using secondary ABI %s\n", cpuAbi2.c_str());
}
} else {
ALOGV("abi didn't match anything: %s (end at %zd)\n", cpuAbiOffset, cpuAbiRegionSize); continue;
} // If this is a .so file, check to see if we need to copy it.
if ((!strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN)
&& !strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN)
&& isFilenameSafe(lastSlash + 1))
|| !strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) {
install_status_t ret = callFunc(env, callArg, &zipFile, entry, lastSlash + 1); if (ret != INSTALL_SUCCEEDED) {
ALOGV("Failure for entry %s", lastSlash + 1); return ret;
}
}
} return INSTALL_SUCCEEDED;
}複製程式碼拷貝so策略：
遍歷apk中檔案，當遍歷到有主Abi目錄的so時，拷貝並設定標記hasPrimaryAbi為真，以後遍歷則只拷貝主Abi目錄下的so，當標記為假的時候，如果遍歷的so的entry名包含次abi字串，則拷貝該so。
策略問題：
經過實際測試，so放置不當時，安裝apk時存在so拷貝不全的情況。這個策略想解決的問題是在4.0~4.0.3系統中的so隨意覆蓋的問題，即如果有主abi目錄的so則拷貝，如果主abi目錄不存在這個so則拷貝次abi目錄的so，但程式碼邏輯是根據ZipFileR0的遍歷順序來決定是否拷貝so，假設存在這樣的apk，lib目錄下存在armeabi/libx.so,armeabi/liby.so,armeabi-v7a/libx.so這三個so檔案，且hash的順序為armeabi-v7a/libx.so在armeabi/liby.so之前，則apk安裝的時候liby.so根本不會被拷貝，因為按照拷貝策略，armeabi-v7a/libx.so會優先遍歷到，由於它是主abi目錄的so檔案，所以標記被設定了，當遍歷到armeabi/liby.so時，由於標記被設定為真，liby.so的拷貝就被忽略了,從而在載入liby.so的時候會報異常。
0x4 64位系統支援
Android在5.0之後支援64位ABI，以5.1.0系統為例：
public static int copyNativeBinariesWithOverride(Handle handle, File libraryRoot,
String abiOverride) { try { if (handle.multiArch) { // Warn if we've set an abiOverride for multi-lib packages..
// By definition, we need to copy both 32 and 64 bit libraries for
// such packages.
if (abiOverride != null && !CLEAR_ABI_OVERRIDE.equals(abiOverride)) {
Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
} int copyRet = PackageManager.NO_NATIVE_LIBRARIES; if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
copyRet = copyNativeBinariesForSupportedAbi(handle, libraryRoot,
Build.SUPPORTED_32_BIT_ABIS, true /* use isa specific subdirs */); if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES &&
copyRet != PackageManager.INSTALL_FAILED_NO_MATCHING_ABIS) {
Slog.w(TAG, "Failure copying 32 bit native libraries; copyRet=" +copyRet); return copyRet;
}
} if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
copyRet = copyNativeBinariesForSupportedAbi(handle, libraryRoot,
Build.SUPPORTED_64_BIT_ABIS, true /* use isa specific subdirs */); if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES &&
copyRet != PackageManager.INSTALL_FAILED_NO_MATCHING_ABIS) {
Slog.w(TAG, "Failure copying 64 bit native libraries; copyRet=" +copyRet); return copyRet;
}
}
} else {
String cpuAbiOverride = null; if (CLEAR_ABI_OVERRIDE.equals(abiOverride)) {
cpuAbiOverride = null;
} else if (abiOverride != null) {
cpuAbiOverride = abiOverride;
}
String[] abiList = (cpuAbiOverride != null) ? new String[] { cpuAbiOverride } : Build.SUPPORTED_ABIS; if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && cpuAbiOverride == null &&
hasRenderscriptBitcode(handle)) {
abiList = Build.SUPPORTED_32_BIT_ABIS;
} int copyRet = copyNativeBinariesForSupportedAbi(handle, libraryRoot, abiList, true /* use isa specific subdirs */); if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
Slog.w(TAG, "Failure copying native libraries [errorCode=" + copyRet + "]"); return copyRet;
}
} return PackageManager.INSTALL_SUCCEEDED;
} catch (IOException e) {
Slog.e(TAG, "Copying native libraries failed", e); return PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
}
}複製程式碼copyNativeBinariesWithOverride分別處理32位和64位so的拷貝，內部函式copyNativeBinariesForSupportedAbi首先會根據abilist去找對應的abi。
public static int copyNativeBinariesForSupportedAbi(Handle handle, File libraryRoot,
String[] abiList, boolean useIsaSubdir) throws IOException {
createNativeLibrarySubdir(libraryRoot); /*
* If this is an internal application or our nativeLibraryPath points to
* the app-lib directory, unpack the libraries if necessary.
*/
int abi = findSupportedAbi(handle, abiList); if (abi >= 0) { /*
* If we have a matching instruction set, construct a subdir under the native
* library root that corresponds to this instruction set.
*/
final String instructionSet = VMRuntime.getInstructionSet(abiList[abi]); final File subDir; if (useIsaSubdir) { final File isaSubdir = new File(libraryRoot, instructionSet);
createNativeLibrarySubdir(isaSubdir);
subDir = isaSubdir;
} else {
subDir = libraryRoot;
} int copyRet = copyNativeBinaries(handle, subDir, abiList[abi]); if (copyRet != PackageManager.INSTALL_SUCCEEDED) { return copyRet;
}
} return abi;
}複製程式碼findSupportedAbi內部實現是native函式，首先遍歷apk，如果so的全路徑中包含abilist中的abi字串，則記錄該abi字串的索引，最終返回所有記錄索引中最靠前的，即排在abilist中最前面的索引。
static int findSupportedAbi(JNIEnv *env, jlong apkHandle, jobjectArray supportedAbisArray) { const int numAbis = env->GetArrayLength(supportedAbisArray);
VectorsupportedAbis; for (int i = 0; i < numAbis; ++i) {
supportedAbis.add(new ScopedUtfChars(env,
(jstring) env->GetObjectArrayElement(supportedAbisArray, i)));
}
ZipFileRO* zipFile = reinterpret_cast(apkHandle); if (zipFile == NULL) { return INSTALL_FAILED_INVALID_APK;
} UniquePtr it(NativeLibrariesIterator::create(zipFile)); if (it.get() == NULL) { return INSTALL_FAILED_INVALID_APK;
}
ZipEntryRO entry = NULL; char fileName[PATH_MAX]; int status = NO_NATIVE_LIBRARIES; while ((entry = it->next()) != NULL) { // We're currently in the lib/ directory of the APK, so it does have some native
// code. We should return INSTALL_FAILED_NO_MATCHING_ABIS if none of the
// libraries match.
if (status == NO_NATIVE_LIBRARIES) {
status = INSTALL_FAILED_NO_MATCHING_ABIS;
} const char* fileName = it->currentEntry(); const char* lastSlash = it->lastSlash(); // Check to see if this CPU ABI matches what we are looking for.
const char* abiOffset = fileName + APK_LIB_LEN; const size_t abiSize = lastSlash - abiOffset; for (int i = 0; i < numAbis; i++) { const ScopedUtfChars* abi = supportedAbis[i]; if (abi->size() == abiSize && !strncmp(abiOffset, abi->c_str(), abiSize)) { // The entry that comes in first (i.e. with a lower index) has the higher priority.
if (((i < status) && (status >= 0)) || (status < 0) ) {
status = i;
}
}
}
} for (int i = 0; i < numAbis; ++i) {
delete supportedAbis[i];
} return status;
}複製程式碼舉例說明，在某64位測試手機上的abi屬性顯示如下，它有2個abilist，分別對應該手機支援的32位和64位abi的字串組。
當處理32位so拷貝時，findSupportedAbi索引返回之後，若返回為0，則拷貝armeabi-v7a目錄下的so，如果為1，則拷貝armeabi目錄下so。
拷貝so策略：
分別處理32位和64位abi目錄的so拷貝，abi由遍歷apk結果的所有so中符合abilist列表的最靠前的序號決定，然後拷貝該abi目錄下的so檔案。
策略問題：
策略假定每個abi目錄下的so都放置完全的，這是和2.3.6一樣的處理邏輯，存在遺漏拷貝so的可能。
0x5 建議
針對android系統的這些拷貝策略的問題，我們給出了一些配置so的建議：
1）針對armeabi和armeabi-v7a兩種ABI
方法1：由於armeabi-v7a指令集相容armeabi指令集，所以如果損失一些應用的效能是可以接受的，同時不希望保留庫的兩份拷貝，可以移除armeabi-v7a目錄和其下的庫檔案，只保留armeabi目錄；比如apk使用第三方的so只有armeabi這一種abi時，可以考慮去掉apk中lib目錄下armeabi-v7a目錄。
方法2：在armeabi和armeabi-v7a目錄下各放入一份so；
2）針對x86
目前市面上的x86機型，為了相容arm指令，基本都內建了libhoudini模組，即二進位制轉碼支援，該模組負責把ARM指令轉換為X86指令，所以如果是出於apk包大小的考慮，並且可以接受一些效能損失，可以選擇刪掉x86庫目錄，x86下配置的armeabi目錄的so庫一樣可以正常載入使用；
3）針對64位ABI
如果app開發者打算支援64位，那麼64位的so要放全，否則可以選擇不單獨編譯64位的so，全部使用32位的so，64位機型預設支援32位so的載入。比如apk使用第三方的so只有32位abi的so，可以考慮去掉apk中lib目錄下的64位abi子目錄，保證apk安裝後正常使用。
0x6 備註
其實本文是因為在Android的so載入上遇到很多坑，相信很多朋友都遇到過UnsatisfiedLinkError這個錯誤，反應在使用者的機型上也是千差萬別，但是有沒有想過，可能不是apk邏輯的問題，而是Android系統在安裝APK的時候，由於PackageManager的問題，並沒有拷貝相應的SO呢？可以參考下面第4個連結，作者給出瞭解決方案，就是當出現UnsatisfiedLinkError錯誤時，手動拷貝so來解決的。
參考文章：
android原始碼：https://android.googlesource.com/platform/frameworks/base
apk安裝過程及原理說明：http://blog.csdn.net/hdhd588/article/details/6739281
UnsatisfiedLinkError的錯誤及解決方案：
更多網易技術、產品、運營經驗分享請點選。
相關文章：
【推薦】 快速上手JS-SDK自動化測試
【推薦】 2017年內容安全十大事件盤點