¿Por qué algunos teléfonos Android hacen que nuestra aplicación para lanzar un java.lang.UnsatisfiedLinkError?

Tengo el mismo problema, y el UnsatisfiedLinkErrors viene en todas las versiones de Android-en los últimos 6 meses, para una aplicación que actualmente tiene más de 90000 instalaciones activas, tuve:

Android 4.2     36  57.1%
Android 4.1     11  17.5%
Android 4.3     8   12.7%
Android 2.3.x   6   9.5%
Android 4.4     1   1.6%
Android 4.0.x   1   1.6%

Y los usuarios informan que generalmente sucede justo después de la actualización de la aplicación. Esto es para una aplicación que obtiene alrededor de 200-500 nuevos usuarios por día.

Creo que se me ocurrió una solución más simple. Puedo averiguar dónde está el apk original de mi aplicación con este simple llamada:

    String apkFileName = context.getApplicationInfo().sourceDir;

Esto devuelve algo como "/data/app/com.ejemplo.pkgname-3.apk", el nombre exacto del archivo APK de mi aplicación. Este archivo es un archivo ZIP normal y es legible sin root. Por lo tanto, si cojo el java.lang.UnsatisfiedLinkError, puedo extraer y copiar mi biblioteca nativa, desde el interior de .apk (zip) lib/armeabi-v7a folder (o cualquier arquitectura en la que esté), a cualquier directorio donde pueda leer/escribir / ejecutar, y cargarlo con el Sistema.load (full_path).

Editar: parece funcionar

Actualización 1 de julio de 2014 desde el lanzamiento de una versión de mi producto con el código similar al que se muestra a continuación, el 23 de junio de 2014, no tenía ningún Error de Enlace Insatisfecho de mi biblioteca nativa.

Aquí está el código que usé:

public static void initNativeLib(Context context) {
    try {
        // Try loading our native lib, see if it works...
        System.loadLibrary("MyNativeLibName");
    } catch (UnsatisfiedLinkError er) {
        ApplicationInfo appInfo = context.getApplicationInfo();
        String libName = "libMyNativeLibName.so";
        String destPath = context.getFilesDir().toString();
        try {
            String soName = destPath + File.separator + libName;
            new File(soName).delete();
            UnzipUtil.extractFile(appInfo.sourceDir, "lib/" + Build.CPU_ABI + "/" + libName, destPath);
            System.load(soName);
        } catch (IOException e) {
            // extractFile to app files dir did not work. Not enough space? Try elsewhere...
            destPath = context.getExternalCacheDir().toString();
            // Note: location on external memory is not secure, everyone can read/write it...
            // However we extract from a "secure" place (our apk) and instantly load it,
            // on each start of the app, this should make it safer.
            String soName = destPath + File.separator + libName;
            new File(soName).delete(); // this copy could be old, or altered by an attack
            try {
                UnzipUtil.extractFile(appInfo.sourceDir, "lib/" + Build.CPU_ABI + "/" + libName, destPath);
                System.load(soName);
            } catch (IOException e2) {
                Log.e(TAG "Exception in InstallInfo.init(): " + e);
                e.printStackTrace();
            }
        }
    }
}

Desafortunadamente, si una mala actualización de la aplicación deja una versión antigua de la biblioteca nativa, o una copia de alguna manera dañado, que cargamos con el sistema.LoadLibrary ("MyNativeLibName"), no hay forma de descargarlo. Al enterarse de tal biblioteca desaparecida remanente que persiste en la carpeta de lib nativa de la aplicación estándar, por ejemplo, al llamar a uno de nuestros métodos nativos y descubrir que no está allí (UnsatisfiedLinkError de nuevo), podríamos almacenar una preferencia para evitar llamar al sistema estándar.LoadLibrary () en conjunto y confiando en nuestro propio código de extracción y carga en el próximo inicio de la aplicación.

Para completar, aquí está la clase UnzipUtil, que copié y modifiqué de esta Descompresión de CodeJava artículo:

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class UnzipUtil {
    /**
     * Size of the buffer to read/write data
     */

    private static final int BUFFER_SIZE = 4096;
    /**
     * Extracts a zip file specified by the zipFilePath to a directory specified by
     * destDirectory (will be created if does not exists)
     * @param zipFilePath
     * @param destDirectory
     * @throws java.io.IOException
     */
    public static void unzip(String zipFilePath, String destDirectory) throws IOException {
        File destDir = new File(destDirectory);
        if (!destDir.exists()) {
            destDir.mkdir();
        }
        ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath));
        ZipEntry entry = zipIn.getNextEntry();
        // iterates over entries in the zip file
        while (entry != null) {
            String filePath = destDirectory + File.separator + entry.getName();
            if (!entry.isDirectory()) {
                // if the entry is a file, extracts it
                extractFile(zipIn, filePath);
            } else {
                // if the entry is a directory, make the directory
                File dir = new File(filePath);
                dir.mkdir();
            }
            zipIn.closeEntry();
            entry = zipIn.getNextEntry();
        }
        zipIn.close();
    }

    /**
     * Extracts a file from a zip to specified destination directory.
     * The path of the file inside the zip is discarded, the file is
     * copied directly to the destDirectory.
     * @param zipFilePath - path and file name of a zip file
     * @param inZipFilePath - path and file name inside the zip
     * @param destDirectory - directory to which the file from zip should be extracted, the path part is discarded.
     * @throws java.io.IOException
     */
    public static void extractFile(String zipFilePath, String inZipFilePath, String destDirectory) throws IOException  {
        ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath));
        ZipEntry entry = zipIn.getNextEntry();
        // iterates over entries in the zip file
        while (entry != null) {
            if (!entry.isDirectory() && inZipFilePath.equals(entry.getName())) {
                String filePath = entry.getName();
                int separatorIndex = filePath.lastIndexOf(File.separator);
                if (separatorIndex > -1)
                    filePath = filePath.substring(separatorIndex + 1, filePath.length());
                filePath = destDirectory + File.separator + filePath;
                extractFile(zipIn, filePath);
                break;
            }
            zipIn.closeEntry();
            entry = zipIn.getNextEntry();
        }
        zipIn.close();
    }

    /**
     * Extracts a zip entry (file entry)
     * @param zipIn
     * @param filePath
     * @throws java.io.IOException
     */
    private static void extractFile(ZipInputStream zipIn, String filePath) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        byte[] bytesIn = new byte[BUFFER_SIZE];
        int read = 0;
        while ((read = zipIn.read(bytesIn)) != -1) {
            bos.write(bytesIn, 0, read);
        }
        bos.close();
    }
}

Greg