android - play - Pasos para crear el archivo de expansión APK

play store max apk size

Question

Desarrollé la aplicación y trabajo con éxito.

He utilizado la función de Licencia de aplicación en mi aplicación. Y ahora voy a subir una aplicación en google play.

Por favor, hágamelo saber los pasos, ¿Cómo usar la licencia de la aplicación y cómo crear el archivo de expansión APK?

Answer 1

Alguna información útil para las personas que terminan aquí en esta publicación ya que hay algunas cosas que cambiaron en la forma en que funcionan las expansiones de apk y también si está usando Android Studio para hacer que las bibliotecas funcionen.

NOTA 1

Ya no puede usar borradores porque el enlace para obtener el archivo de expansión aún no estará activo. Tienes que subir una versión a Alpha o Beta primero con el archivo de expansión. (Agregar un archivo de expansión solo es posible desde la segunda aplicación que cargues o subas). Asegúrate de ver el archivo de expansión apk en la lista cuando haces clic en los detalles en la sección de publicación del desarrollador en APK.

NOTA 2

Si está usando android studio y desea hacer uso de la biblioteca de descarga, no solo copie el nombre del paquete y los archivos java en su propio directorio src de la aplicación. Importe la biblioteca de descarga en eclipse y elija export => gradle build files. Luego puede importar la biblioteca como un módulo en el estudio de Android.

NOTA 3

No estoy seguro de esto, pero también creo que es necesario descargar la aplicación al menos una vez a través de Play Store y tener acceso a ella con la cuenta en su dispositivo de prueba. Por lo tanto, si está trabajando con alfa, cree un grupo de prueba de google + y añádase usted u otros dispositivos de prueba.

Por cierto

Con estas bibliotecas es bastante fácil implementar la descarga de la expansión apk, solo asegúrate de:

1. su actividad (aquella en la que desea implementar la descarga del paquete de expansión cuando la descarga no se ha realizado automáticamente) implementa IDownloaderClient.

2. configura el servicio y el receptor y los configura en su manifiesto.

3. El BASE64_PUBLIC_KEY en la clase de servicio es correcto. Suba el primer apk => en Servicios y API en la consola de desarrollador en su aplicación => Código de licencia para esta aplicación.

Este código se usa para ver si el archivo de expansión se puede encontrar en el dispositivo:

boolean expansionFilesDelivered() {
    for (XAPKFile xf : xAPKS) {
        String fileName = Helpers.getExpansionAPKFileName(this, xf.mIsMain, xf.mFileVersion);
        Log.i(TAG, "Expansion filename " +fileName);
        if (!Helpers.doesFileExist(this, fileName, xf.mFileSize, false))
            return false;
    }
    return true;
}

Utiliza la clase XAPKS que representa un archivo de expansión, ya sea un archivo principal o de parche, que tiene un cierto tamaño de archivo (bytes) y está asociado con una versión apk (la que se agregó por primera vez).

private static class XAPKFile {
        public final boolean mIsMain; // true
        public final int mFileVersion; //example 4
        public final long mFileSize; //example 126515695L
        // example => main expansion that was first introduced in apk version 4 and is 126515695 bytes in size

        XAPKFile(boolean isMain, int fileVersion, long fileSize) {
            mIsMain = isMain;
            mFileVersion = fileVersion;
            mFileSize = fileSize;
        }
    }

También es bastante fácil leer archivos de películas y otras cosas directamente desde el archivo de expansión utilizando las herramientas zip que Google ha proporcionado (com.android.vending.zipfile).

Primero obtenga el archivo de expansión usando los métodos provistos en la biblioteca, los parámetros son números enteros que representan la versión principal de su apk de expansión (la versión apk donde primero se agregó el paquete de expansión que necesita) y la versión del apk del parche.

ZipResourceFile expansionFile = APKExpansionSupport.getAPKExpansionZipFile(context, APKX_MAIN_APK, APKX_PATCH_APK);

Vídeo

Para reproducir video directamente desde este zipresourcefile:

AssetFileDescriptor a = expansionFile.getAssetFileDescriptor(pathToFileInsideZip);

Ahora desde este assetFileDescriptor puede obtener un FileDescriptor y usarlo en su reproductor de medios, la sintaxis correcta para que su reproductor de medios reproduzca el video también necesita el segundo y el tercer parámetro ... Sea el inicio y duración que puede obtener del AssetFileDescriptor.

player.setDataSource(a.getFileDescriptor(), a.getStartOffset(), a.getLength());

Otro

Para todas las otras cosas (como imágenes), puedes obtener un inputstream del zipresourcefile:

expansionFile.getInputStream(pathToFileInsideZip);`

TAMBIÉN asegúrese de no comprimir los videos en el zip para que esto funcione. por ejemplo, no comprimir archivos .mp4:

zip -n .mp4 -r zipfile.zip . -x ".*" -x "*/.*"

Answer 2

En Eclipse su proyecto, haga clic con el botón derecho del ratón, siga los pasos: Herramientas de Android-> Exportar paquete de aplicación firmado-> ....

Answer 3

En primer lugar, suponga que migra usando un helloworld.jpg de /assets/helloworld.jpg a su expansión

1. crea un archivo zip pero con el siguiente patrón de archivo, terminando la extensión de archivo .obb:
   

 `[main|patch].{expansion-version}.{package-name}.obb`

Por ejemplo, si su nombre de paquete es "com.earth.helloworld" y versión = 1

entonces su nombre de archivo de extensión de salida debería ser: patch.1.com.earth.helloworld.obb
que es un archivo zip que contiene helloworld.jpg
después de crear el archivo zip, tenga en cuenta el tamaño del archivo: 2. luego crea esta carpeta en tu tarjeta sd si no existe:
/ mnt / sdcard / Android / obb / {su nombre de paquete} /
es decir, /mnt/sdcard/Android/obb/com.earth.helloworld/

3. luego suba su archivo obb a su tarjeta SD, por ejemplo /mnt/sdcard/Android/obb/com.earth.helloworld/patch.1.com.earth.helloworld.obb

4. Luego crea un método para obtener el archivo de extensión

   public ZipResourceFile getExpansionFile() {
   
   String fileName = Helpers.getExpansionAPKFileName(this, false, 1);
   
           int filesize = 445461159;
   if (Helpers.doesFileExist(this, fileName, , false)) {
   
       try {
           return APKExpansionSupport.getAPKExpansionZipFile(
                   getBaseContext(), 1, 1);
   
       } catch (IOException e) {
           // TODO Auto-generated catch block
   
           e.printStackTrace();
       }
   }
   return null;       }

5. Finalmente usa estas dos líneas para obtener el helloworld.jpg
   InputStream istr = getExpansionFile().getInputStream(strName);

   Bitmap bitmap = BitmapFactory.decodeStream(istr);

Answer 4

Los archivos de expansión eliminan la restricción de subir más de 50MB de tamaño apk. Estos archivos deben adjuntarse al cargar apk. Cada aplicación puede proporcionar hasta 4 GB (2 GB, principal, 2 GB, parche) de datos adicionales para cada APK.

Hay una convención de nombres que debe seguir al crear archivos de expansión

[main|patch].<expansion-version>.<package-name>.obb

Nota:

1. main - son esos archivos sin esto, tu aplicación no se ejecutará
2. patch - son aquellos archivos que son adicionales, sin esto su aplicación puede ejecutarse
3. expansion-version - versión que le está dando a su apk, para que los archivos de expansión de diferentes versiones no entren en conflicto
4. package-name este es su nombre único de paquete

.obb no .obb , se agregará implícitamente por Google durante la carga

supongamos que tiene todo el contenido en su directorio actual así que simplemente seleccione todo el contenido y main.2.com.xyz.abc.zip un zip con el nombre main.2.com.xyz.abc.zip y conéctelo mientras carga el apk.

Esta es una parte de carga, ahora descarga parte

En primer lugar, debe descargar el paquete adicional de Google haciendo clic en SDK-Manager.

Ahora crea un nuevo proyecto desde la fuente existente e importa market_licensing , play_apk_expansion desde la ruta sdk-path / extras / google

Recuerde: la aplicación gratuita no requiere licencias, pero se requiere un concepto de expansión, solo no necesita molestarse dando la referencia de market_licensing a su proyecto que administrará implícitamente.

play_apk_expansion contiene tres proyectos downloader_library , zip_file , downloader_sample .

downloader_library tiene la referencia de Market_licensing.

Ahora solo necesita concentrarse en downloader_sample primero cambie el nombre del paquete (para probar) a su nombre de paquete (packagename igual que apk cargado)

Muy importante

En SampleDownloaderActivity navegue a ...

private static final XAPKFile[] xAPKS = {
            new XAPKFile(
                    true, // true signifies a main file
                    2, // the version of the APK that the file was uploaded
                       // against
                    xxxxxxxxxxxL // the length of the zipfile in bytes right click on you expansion file and get the size in bytes, size must be same as zip size
            ),

    };

Ahora esta actividad descargará el archivo de expansión y lo almacenará en sdcard/Android/obb/[main|patch].<expansion-version>.<package-name>.obb Expansion sdcard/Android/obb/[main|patch].<expansion-version>.<package-name>.obb ignora sdcard/Android/obb/[main|patch].<expansion-version>.<package-name>.obb , solo descomprime este archivo donde quieras ( sdcard/Android/data recommended porque se elimina cuando la aplicación se desinstala).

Hay un dispositivo más reciente que descarga archivos de expansión directamente desde Play Store y se almacena en sdcard/Android/obb/ por lo que debe tener mucho cuidado de verificar todos los casos

1. Obb ya descargado
2. Memoria disponible
3. descargado pero no descomprimido
4. Memoria para seleccionar (ver Casos de memoria)

Casos de memoria:

si toma cualquier dispositivo nuevo o por ej. funbook de micromax, entonces tiene tres memorias

• / data / data / (memoria interna del teléfono) getFilesDirectory ()
• / mnt / sdcard / (tarjeta sd interna del teléfono) Environment.getExternalStorageDirectory ()
• / mnt / extsd / (Tarjeta sd externa) / mnt / extsd

Espero que esto lo ayude y cumpla con sus requisitos.

Y una cosa más usar este ZipHelper a continuación para descomprimir el contenido.

ZipHelper.java

public class ZipHelper
{
    boolean zipError=false;

    public boolean isZipError() {
        return zipError;
    }

    public void setZipError(boolean zipError) {
        this.zipError = zipError;
    }

    public void unzip(String archive, File outputDir)
    {
        try {
            Log.d("control","ZipHelper.unzip() - File: " + archive);
            ZipFile zipfile = new ZipFile(archive);
            for (Enumeration e = zipfile.entries(); e.hasMoreElements(); ) {
                ZipEntry entry = (ZipEntry) e.nextElement();
                unzipEntry(zipfile, entry, outputDir);

            }
        }
        catch (Exception e) {
            Log.d("control","ZipHelper.unzip() - Error extracting file " + archive+": "+ e);
            setZipError(true);
        }
    }

    private void unzipEntry(ZipFile zipfile, ZipEntry entry, File outputDir) throws IOException
    {
        if (entry.isDirectory()) {
            createDirectory(new File(outputDir, entry.getName()));
            return;
        }

        File outputFile = new File(outputDir, entry.getName());
        if (!outputFile.getParentFile().exists()){
            createDirectory(outputFile.getParentFile());
        }

        Log.d("control","ZipHelper.unzipEntry() - Extracting: " + entry);
        BufferedInputStream inputStream = new BufferedInputStream(zipfile.getInputStream(entry));
        BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(outputFile));

        try {
            IOUtils.copy(inputStream, outputStream);
        }
        catch (Exception e) {
            Log.d("control","ZipHelper.unzipEntry() - Error: " + e);
            setZipError(true);
        }
        finally {
            outputStream.close();
            inputStream.close();
        }
    }

    private void createDirectory(File dir)
    {
        Log.d("control","ZipHelper.createDir() - Creating directory: "+dir.getName());
        if (!dir.exists()){
            if(!dir.mkdirs()) throw new RuntimeException("Can''t create directory "+dir);
        }
        else Log.d("control","ZipHelper.createDir() - Exists directory: "+dir.getName());
    }
}

Answer 5

Solo quiero agregar algunas cosas que aprendí en el proceso de implementación de esto:

1) A partir de ahora, no necesita implementar la biblioteca de descarga y todo el material de XAPKFile, todo lo que necesita hacer es copiar / pegar todos los permisos que se enumeran en https://developer.android.com/google/play/expansion-files.html en su archivo de manifiesto. Tal vez solía hacerlo, pero Google Play Store maneja la descarga y la instalación por usted. La única razón por la que necesitaría manejar la descarga real en su código fuente es si el usuario ingresó manualmente a Android / obb y eliminó sus archivos de expansión.

2) Cuando cargue su archivo .zip, no tiene que nombrarlo a la convención main.version.package.obb. Simplemente cargue su archivo .zip con su nombre original, y se le cambiará el nombre independientemente.

3) Para acceder al archivo comprimido, vaya a Archivo> Nuevo> Importar módulo e importe la biblioteca zip_file que se encuentra en el mismo directorio que las bibliotecas de descarga y licencias. Asegúrese de agregar a sus dependencias en el archivo build.gradle para su aplicación: compile project ('': zip_file''). Esto lo hace para que pueda importar esas bibliotecas en su proyecto.

Espero que sea de ayuda. Básicamente pasé horas tratando de implementar el código de biblioteca de descarga (complicado) que figura en el sitio, y al final lo eliminé todo y solo guardé los permisos en el manifiesto, y funciona bien.