安裝APK時SO庫的選擇策略

網易雲社群發表於2018-10-31

此文已由作者尹彬彬授權網易雲社群釋出。

歡迎訪問網易雲社群,瞭解更多網易技術產品運營經驗。


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的字串組。

安裝APK時SO庫的選擇策略

當處理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的錯誤及解決方案:

medium.com/keepsafe-en…


免費體驗雲安全(易盾)內容安全、驗證碼等服務

更多網易技術、產品、運營經驗分享請點選




相關文章:
【推薦】 快速上手JS-SDK自動化測試
【推薦】 2017年內容安全十大事件盤點


相關文章