AAB, splits y contenedores

Antes conviene leer «Contenedor ZIP», «XML binario (AXML)», «Tabla de recursos»

referencia técnica · Actualizado el 9 de noviembre de 2026

1. Por qué existen los splits

El punto de partida es el APK universal: un solo fichero con todo. Dentro van las bibliotecas nativas de varias arquitecturas, los iconos de varias densidades de pantalla y las cadenas de muchos idiomas. Un split es lo contrario: un APK parcial que lleva solo una de esas piezas.

Cuánto sobra en un universal se ve rápido. En F-Droid, seis de cada diez APK con código nativo traen las cuatro arquitecturas vigentes: arm64-v8a, armeabi-v7a, x86 y x86_64. Y la tabla de recursos declara de media unas 6 densidades de pantalla y más de 80 idiomas.

Un teléfono arm64-v8a, en español y con pantalla xxhdpi, descargaba, instalaba y conservaba en disco el código x86, los iconos de las otras densidades y las traducciones a idiomas que no usa. Play reparte hoy las densidades en siete splits (ldpi, mdpi, tvdpi, hdpi, xhdpi, xxhdpi y xxxhdpi). Para repetir las cifras: MUESTRARIO_RAIZ=<copia del muestrario> python3 -I scripts/muestrario/cifras/zip_y_contenedores_4.py.

Repartirlo no era nuevo. Desde julio de 2011, Android Market —hoy Google Play— admite varios APK completos para una misma ficha, cada uno para un grupo de dispositivos (multiple APK), y desde Android 5.0 (API 21) la plataforma instala una aplicación repartida en varios split APK. Pero en el multiple APK cada APK lo construye y lo firma el desarrollador. En mayo de 2018, en el Google I/O, Google Play presentó el Android App Bundle y con él invirtió el modelo. El desarrollador ya no sube el fichero instalable: sube un contenedor intermedio, el .aab, y es Play quien genera los APK concretos para cada dispositivo. En agosto de 2021 pasó a ser obligatorio para las aplicaciones nuevas.

La consecuencia técnica es que una aplicación instalada ya no es un APK, sino un conjunto: un base.apk más los split que le correspondan a ese dispositivo. PackageManager los monta como una sola aplicación con un solo AssetManager. La consecuencia práctica para quien analiza es más incómoda: lo que llega depende de dónde se descargue la aplicación, y a menudo hay que averiguar qué es antes de poder abrirlo.

De las 1.027 apps de Google Play del muestrario, 460 llegaron en un contenedor (un ZIP de ZIPs: 388 .apkm de APKMirror y 72 .xapk, 71 de APKPure y 1 de APKCombo), 365 como carpeta de adb con los APK que tenía instalados un teléfono, y 202 como .apk suelto. Entre las más instaladas, la mayoría vino como .apkm; entre las del sorteo, casi todas como carpeta de adb.

Ninguno de los .apk sueltos viene partido en splits. Uno de cada cuatro lleva com.android.dynamic.apk.fused.modules, la marca de un APK único que bundletool fabrica a partir de un bundle. Las extensiones .apkm y .xapk las ponen los sitios de descargas: no son un formato de Android. En el muestrario, la extensión coincide siempre con la estructura («sección 6.3 · La comprobación sobre el muestrario»). Ojo con leer estos números como si fueran lo que entrega Play: la mezcla de formatos depende de qué sitio dio cada app. Tres ejemplos:

  • El .apkm de APKMirror de Google Keep, 5.26.411.03.97 (27 piezas).
  • El .xapk de APKPure de Telegram 13.1.0 (3 piezas).
  • El .apk suelto de Netflix 9.88.0 con fused.modules: un universal hecho a partir de un bundle.

Este documento cubre los tres niveles: el AAB que produce el desarrollador, el APK Set que produce bundletool, y los contenedores de terceros que produce cada sitio de descargas.

2. El Android App Bundle (.aab)

2.1 Estructura interna

Un .aab es un ZIP, pero no es un APK y no se instala. Su estructura se ve en fixture.aab, un bundle mínimo que generamos a propósito con bundletool build-bundle 1.18.3. No forma parte del «muestrario»: en él no hay ningún .aab, porque el .aab es lo que sube el desarrollador y no lo que llega al teléfono. Los volcados de esta sección, de la 2.3 y de la 8.1 salen de ese fixture local.

unzip -l fixture.aab
  Length      Date    Time    Name
---------  ---------- -----   ----
       10  01-01-2010 00:00   BundleConfig.pb
      114  01-01-2010 00:00   base/res/drawable-xxhdpi-v4/ic_fixture.png
      104  01-01-2010 00:00   base/res/drawable-xhdpi-v4/ic_fixture.png
      115  01-01-2010 00:00   base/res/drawable-mdpi-v4/ic_fixture.png
      100  01-01-2010 00:00   base/res/drawable-hdpi-v4/ic_fixture.png
     6492  01-01-2010 00:00   base/lib/armeabi-v7a/libtermux.so
     9008  01-01-2010 00:00   base/lib/arm64-v8a/libtermux.so
     9248  01-01-2010 00:00   base/lib/x86_64/libtermux.so
     1800  01-01-2010 00:00   base/dex/classes.dex
     1714  01-01-2010 00:00   base/manifest/AndroidManifest.xml
       68  01-01-2010 00:00   base/native.pb
     1083  01-01-2010 00:00   base/resources.pb

El mapa completo, incluyendo lo que este fixture mínimo no trae:

Entrada Contenido Formato
BundleConfig.pb Configuración del bundle: versión de bundletool, optimizaciones, compresión, locales protobuf android.bundle.BundleConfig
BUNDLE-METADATA/ Metadatos para herramientas y tiendas, un subdirectorio por espacio de nombres: com.android.tools.build.obfuscation/proguard.map (el mapping.txt de R8, con otro nombre), com.android.tools.build.libraries/dependencies.pb (las dependencias) y com.android.tools.build.gradle/app-metadata.properties (la versión de AGP), entre otros. No se empaquetan en los APK Variable
base/ El módulo base. Obligatorio Directorio
<feature>/ Un directorio por módulo de funcionalidad, con el nombre del atributo split de su manifiesto Directorio
<asset_pack>/ Un directorio por asset pack de Play Asset Delivery Directorio
<módulo>/manifest/AndroidManifest.xml El manifiesto del módulo, en un directorio aparte, a diferencia del APK protobuf aapt.pb.XmlNode, no AXML
<módulo>/dex/ Los classes*.dex del módulo, en un directorio aparte DEX
<módulo>/res/ Recursos con calificador, idénticos a los de un APK Ficheros de recurso
<módulo>/lib/<abi>/ Bibliotecas nativas ELF
<módulo>/assets/ Assets Cualquiera
<módulo>/root/ Ficheros que se reubican a la raíz del APK generado. Es donde acaban los recursos Java que se leen con Class.getResource() Cualquiera
<módulo>/resources.pb La tabla de recursos del módulo protobuf aapt.pb.ResourceTable
<módulo>/native.pb Descripción del código nativo del módulo protobuf
<módulo>/assets.pb Descripción de los assets del módulo, cuando hay asset packs protobuf

Tres diferencias con la estructura de un APK que se olvidan enseguida:

  • AndroidManifest.xml no está en la raíz del módulo, sino en <módulo>/manifest/.
  • Los .dex no están en la raíz, sino en <módulo>/dex/.
  • No hay resources.arsc, hay resources.pb. No es el mismo formato ni remotamente.

2.2 Por qué protobuf y no los formatos binarios del APK

resources.arsc está pensado para leerse en un teléfono: es un índice denso, mapeable, con los valores ya resueltos por configuración. Sus virtudes (compacto, acceso aleatorio, coste de análisis cero) solo importan en el dispositivo.

El AAB no se ejecuta nunca. Es la entrada de un proceso de compilación que corre en los servidores de Play y cuyo trabajo es justo dividir y recombinar la tabla: quedarse con los recursos de un idioma, tirar los de las demás densidades, fusionar módulos. Para eso el formato denso es un estorbo, porque toda edición reindexa el string pool y recalcula los offsets de todos los chunks (ver «Tabla de recursos», secciones «4» y «7»).

Protocol Buffers da lo contrario: campos con nombre, opcionales, extensibles hacia delante y hacia atrás, sin offsets absolutos y sin punteros. Un servicio puede añadir un campo sin romper a los lectores viejos. El coste es tamaño y velocidad de análisis, que ahí no importan.

Y la conversión alcanza también al manifiesto, cosa que se olvida: el manifiesto del módulo viaja en protobuf, no en AXML. Es un mensaje aapt.pb.XmlNode del mismo Resources.proto que define ResourceTable —XmlNode → XmlElement → XmlAttribute, con resource_id y compiled_item ya resueltos—, lo produce aapt2 link --proto-format y bundletool lo lee con XmlProtoNode, no con un parser de AXML. Sobre ese árbol proto añade Play los atributos de split de la «sección 4.2 · Los atributos del manifiesto». La conversión al formato binario va en sentido contrario, al materializar cada APK, y es una sola llamada a aapt2 convert --output-format binary por split: bundletool escribe un APK temporal en formato proto con el manifiesto, resources.pb y res/, y aapt2 devuelve a la vez el AndroidManifest.xml en AXML y el resources.arsc (Aapt2ResourceConverter.convertResourcesToBinary y Aapt2Command.convertApkProtoToBinary).

Se comprueba en un solo paso: unzip -p app.aab base/manifest/AndroidManifest.xml | xxd | head -1 devuelve 0a… —etiqueta de campo protobuf—, no 0300 0800, que es lo que sí aparece en el AndroidManifest.xml de cualquiera de los splits/*.apk de fixture.apks.

2.3 Los .proto relevantes

Las definiciones están publicadas en el repositorio de bundletool, bajo src/main/proto/, y en AOSP para las de aapt2. Los cuatro que hacen falta para leer un bundle o un APK Set:

Fichero Paquete proto Java Mensaje raíz Describe
config.proto android.bundle com.android.bundle BundleConfig BundleConfig.pb del .aab
commands.proto android.bundle com.android.bundle BuildApksResult toc.pb del .apks
targeting.proto android.bundle com.android.bundle ApkTargeting, VariantTargeting A qué dispositivos aplica cada APK
files.proto android.bundle com.android.bundle — native.pb, assets.pb
Resources.proto aapt.pb com.android.aapt ResourceTable resources.pb de cada módulo

BundleConfig tiene nueve campos de primer nivel: bundletool, optimizations, compression, master_resources, apex_config, unsigned_embedded_apk_config, asset_modules_config, type —REGULAR, APEX o ASSET_ONLY— y locales. El de fixture.aab ocupa 10 bytes, porque solo lleva la versión de bundletool:

java -jar ~/herramientas/bundletool.jar dump config --bundle fixture.aab
{
  "bundletool": {
    "version": "1.18.3"
  }
}

Resources.proto de aapt2 define la jerarquía equivalente a la de resources.arsc: ResourceTable → Package → Type → Entry → ConfigValue, con PackageId, TypeId y EntryId como mensajes propios. Es una traducción campo a campo de las estructuras del documento «Tabla de recursos», no un formato distinto.

3. El APK Set (.apks)

3.1 Qué es

Es lo que produce bundletool build-apks a partir de un .aab: un ZIP con todos los APK que Play podría llegar a generar, más una tabla de contenidos que dice cuál va a cada dispositivo. No se instala directamente; se le extrae el subconjunto que toca.

De fixture.apks, generado localmente con bundletool (no es del muestrario):

toc.pb
splits/base-master.apk        splits/base-master_2.apk      splits/base-master_3.apk
splits/base-arm64_v8a.apk     splits/base-armeabi_v7a.apk   splits/base-x86_64.apk
splits/base-de.apk            splits/base-es.apk            splits/base-fr.apk
splits/base-ldpi.apk          splits/base-mdpi.apk          splits/base-hdpi.apk
splits/base-tvdpi.apk         splits/base-xhdpi.apk         splits/base-xxhdpi.apk
splits/base-xxxhdpi.apk

El listado está abreviado. El APK Set tiene 43 ficheros para una aplicación de una sola actividad: toc.pb y tres juegos de 14 splits. Cada juego lleva el maestro, tres ABI, tres idiomas y siete densidades. Arriba solo aparece entero el primero, más los maestros de los otros dos.

Los sufijos _2 y _3 marcan las variantes. Una variante es un juego completo de splits para un rango de versiones de Android. bundletool genera una por cada rango que pide un empaquetado distinto, y toc.pb dice cuál corresponde a cada nivel de API.

Lo que separa una variante de otra es su VariantTargeting, y en la práctica su sdk_version_targeting: el nivel de API desde el que se aplica. bundletool abre una variante en cada umbral a partir del cual compensa empaquetar distinto. La tabla recoge los umbrales; fíjate en la columna «Desde la API», que es donde empieza cada variante.

Desde la API Qué cambia Cuándo se aplica
23 Bibliotecas nativas sin comprimir Por defecto. Sube a la 24 si el módulo puede tener actividades nativas y a la 28 si la aplicación se puede instalar en almacenamiento externo
29 DEX sin comprimir Por defecto desde bundletool 1.16.0. Sube a la 31 o a la 33 si BundleConfig lo pide
32 Tabla de recursos dispersa Solo si están activas a la vez la codificación dispersa y la inyección del minSdk
La que se indique Firma con rotación de clave v3 Opcional

La codificación dispersa y la inyección del minSdk se piden con --enable-sparse-encoding e --inject-min-sdk, o en las optimizaciones de BundleConfig. En un bundle hecho con bundletool 1.18.3, como fixture.aab, vienen activadas por defecto. BundleConfig puede desactivar cualquiera de las dos (inject_min_sdk_setting o sparse_encoding en DISABLED). Cada Variant de toc.pb declara cuáles aplica («sección 3.2 · toc.pb: BuildApksResult»).

El sufijo no codifica nada. ApkPathManager añade _2, _3… cuando el nombre propuesto ya está ocupado, y los nombres se reparten recorriendo las variantes de menor a mayor nivel de API. bundletool recorta cada umbral al rango de API de la aplicación. Con minSdkVersion 24 («sección 8.1 · bundletool validate y dump sobre un .aab»), el umbral de las bibliotecas nativas sin comprimir (23) queda absorbido por el propio minSdk. Salen así tres variantes: 24, 29 (DEX sin comprimir) y 32 (tablas dispersas). Sin sufijo va la de 24, _2 es la de 29 y _3 la de 32. Esta última es la que extract-apks elige en la «sección 8.2 · Extraer los splits de un dispositivo concreto» para un dispositivo con API 34.

Los directorios que puede traer un APK Set:

Directorio Contenido
splits/ Los split APK de instalación por Play, agrupados por variante
standalones/ APK monolíticos completos para dispositivos con API < 21 (anteriores a Android 5.0), que no soportan splits. Solo se generan si el minSdk del base es menor que 21
instant/ Los splits de la versión instant, si el bundle la declara
system/ APK para preinstalación en la imagen del sistema
asset-slices/ Las porciones de los asset packs
(raíz) universal.apk cuando se generó con --mode=universal

El modo universal produce un APK Set degenerado: una tabla de contenidos de 90 bytes y un solo APK con todo dentro. Es la vía oficial para obtener un instalable único a partir de un bundle. El listado es el de fixture.universal.apks, también local:

Archive:  fixture.universal.apks
       90  toc.pb
    66347  universal.apk

En el muestrario hay APK sueltos que son universales de este tipo, sin su .apks. El de Netflix 9.88.0 (282,6 MB) lleva en el manifiesto com.android.dynamic.apk.fused.modules y las cuatro arquitecturas en un solo fichero. Otro es el de Firefox 158.0.2, de APKPure. Que fused.modules indique un universal de bundletool es una lectura del nombre del meta-data, no algo que el muestrario demuestre. Entre los APK únicos de las apps más instaladas de Google Play lo lleva uno de cada cuatro; fuera de Play es raro.

3.2 toc.pb: BuildApksResult

El fichero toc.pb en la raíz es la firma estructural del formato y un mensaje protobuf android.bundle.BuildApksResult. Sus campos:

Campo Nº Tipo Contenido
variant 1 repeated Variant Las variantes generadas
bundletool 2 Bundletool La versión de bundletool que lo produjo
asset_slice_set 3 repeated AssetSliceSet Porciones de asset packs
package_name 4 string El nombre del paquete
local_testing_info 5 LocalTestingInfo Modo de prueba local
asset_modules_info 6 AssetModulesInfo Metadatos de bundles de solo assets
default_targeting_value 7 repeated DefaultTargetingValue Valores por defecto de las dimensiones
permanently_fused_modules 8 repeated PermanentlyFusedModule Módulos fusionados en base en todas las variantes
device_group_config 9 DeviceGroupConfig Grupos de dispositivos y conjuntos de países

Y la jerarquía: BuildApksResult (toc.pb) → Variant (una por rango de API) → ApkSet (uno por módulo) → ApkDescription (uno por APK: ruta, a qué dispositivos va, de qué tipo es). Cada Variant lleva su VariantTargeting (campo 1), sus ApkSet (2), un variant_number (3) y unas variant_properties (4) que dicen si sus DEX y sus bibliotecas nativas van sin comprimir y si su tabla de recursos es dispersa; un dispositivo recibe la variante que le corresponda de número más alto. ApkSet lleva un ModuleMetadata —nombre del módulo, tipo, modo de entrega, dependencias— y cada ApkDescription lleva su ApkTargeting, su path dentro del ZIP y uno de los siete metadatos posibles: split_apk_metadata (con split_id y is_master_split), standalone_apk_metadata, instant_apk_metadata, system_apk_metadata, asset_slice_metadata, apex_apk_metadata o archived_apk_metadata. Fuera de esa alternativa va el campo 10, signing_description, que solo dice si el APK se firma con la clave rotada (signed_with_rotated_key).

Decodificando el toc.pb de fixture.apks con un lector genérico de wire format, sin biblioteca de protobuf, se ve exactamente esa estructura. Una herramienta equivalente es protoc --decode_raw. Es un fichero local: en el muestrario no hay ningún toc.pb en los 460 contenedores.

toc.pb: 3250 bytes
  campo 1 (length-delimited) x3   ← tres Variant
  campo 2 (length-delimited) x1   ← Bundletool: b'\x12\x061.18.3'
  campo 4 (length-delimited) x1   ← package_name: b'com.ejemplo.fixture'
  campo 5 (length-delimited) x1   ← local_testing_info, vacío

Variant[0] → ApkSet[0] → 14 ApkDescription
  path = splits/base-ldpi.apk
  path = splits/base-mdpi.apk
  path = splits/base-hdpi.apk
  path = splits/base-xhdpi.apk

Tres Variant, que es el origen de los sufijos _2 y _3 del listado de 3.1.

4. Taxonomía de splits

4.1 Los cuatro tipos

Las piezas de un conjunto son de cuatro tipos, y cada tipo se reconoce por su manifiesto. En las apps de Play del muestrario que llegan partidas hay unos 8.000 splits, y más de la mitad son de idioma.

Tipo Nombre habitual Qué lleva
Base base.apk, o <paquete>.apk en los .xapk El manifiesto completo, los classes*.dex, resources.arsc y los recursos sin calificador
Config split config.<abi>, config.<densidad>, config.<idioma> o split_config.* Solo lo de esa configuración. Nunca lleva código: ninguno de los 7.846 que miramos tiene DEX
Feature module split_<nombre> o <nombre>.apk Un módulo que se entrega aparte. Puede llevar código (casi dos de cada tres), o ser solo idiomas, como los 17 i18n_* de WhatsApp
Asset pack split_UnityDataAssetPack.apk, split_install_time_asset_pack.apk… Datos pesados (en los juegos, la mayor parte de assets/). Sin código ni tabla de recursos. Los 102 del muestrario son de instalación (install-time)

Un asset pack puede tener a su vez config splits de textura (config.astc, config.etc2) o de país (config.countries_id).

Cuatro precisiones:

  • Módulos con código. Unos dos de cada tres módulos llevan DEX, y la mitad, resources.arsc.
  • hasCode no basta. Para saber si un módulo tiene código hay que mirar si trae DEX. Hay 30 módulos que declaran hasCode=false y aun así lo llevan.
  • Asset packs. Todos llevan <dist:delivery> con <dist:install-time/>, y ninguno lleva DEX ni resources.arsc. Hay al menos uno en cerca de una de cada diez apps más instaladas de Play. Es una clasificación por inferencia: un asset pack es un split con <dist:module>, sin <uses-sdk>, sin DEX y sin resources.arsc.
  • Módulos de funcionalidad. Son poco frecuentes: aparecen en menos de una de cada diez apps. Y un módulo ya no equivale a una funcionalidad: 17 de las 29 piezas del .apkm de WhatsApp son módulos de idioma.

Ejemplos reales de cada tipo raro:

  • Asset pack de Unity, 1,18 GB: com.olzhas.carparking.multyplayer 4.9.11 (.apkm de APKMirror), pieza split_UnityDataAssetPack.apk.
  • Split de textura: com.moonfrog.ludo.club 2.6.65, pieza split_UnityDataAssetPack.config.astc.apk.
  • Split de país: com.mobile.legends 2.2.16.12322, pieza split_PlayAssetPack.config.countries_id.apk.
  • Asset pack de 391,5 MB en una carpeta de adb: com.dmluh.lesmqxd, pieza split_quandui.apk.
  • Módulo con hasCode=false y un DEX: com.zhiliaoapp.musically (TikTok) 47.4.16, pieza split_df_m2_player_combo.apk.

Un config split puede pertenecer a un módulo de funcionalidad, y entonces lleva los dos nombres. El .apkm de Tencent WeChat 8.0.79 del muestrario lo muestra. El listado es parcial: el .apkm trae 24 idiomas, 7 densidades y 2 módulos.

base.apk
split_config.arm64_v8a.apk            ← config split del base
split_config.es.apk  split_config.ja.apk  …
split_delivery.apk                    ← feature module
split_delivery.config.arm64_v8a.apk   ← config split de un feature module

Las piezas son split_delivery.apk y split_delivery.config.arm64_v8a.apk, con configForSplit="delivery" y splitTypes="delivery__abi".

Y un módulo no tiene por qué ser una funcionalidad. El .apkm de WhatsApp 2.26.42.9 lleva 29 APK: el base, 4 de arquitectura, 7 de densidad y 17 módulos (split_i18n_bn.apk, split_i18n_ca.apk…). Son idiomas que se entregan según el país del usuario.

4.2 Los atributos del manifiesto

Todo se decide en AndroidManifest.xml. La tabla dice en qué elemento aparece cada atributo y qué significa. Los identificadores (Resource ID) se reproducen con aapt2 dump xmltree (aapt2 37.0.0) sobre piezas del muestrario.

Atributo Resource ID Dónde aparece Significado
split — (sin namespace) En el <manifest> de todo split; en ninguna de las 773 bases El identificador del split: config.es, delivery, config.armeabi_v7a
android:isFeatureSplit 0x0101055b Solo en módulos de funcionalidad y asset packs (292 de 292 piezas; 0 de 7.846 config splits) true
android:isSplitRequired 0x01010591 En <application> de la base (24 piezas del muestrario, ninguna en <manifest>) Es el mecanismo antiguo. Con él, el sistema rechaza la instalación (INSTALL_FAILED_MISSING_SPLIT) si faltan splits
android:requiredSplitTypes 0x0101064e En la base, y también en algunos módulos de funcionalidad (105 de 190) Lista de tipos de split obligatorios, separados por comas
android:splitTypes 0x0101064f En casi todo split (7.950 de 8.138) Los tipos que ese split aporta. Cadena vacía si no aporta ninguno. No lo llevan los 102 asset packs, 82 config splits ni 4 módulos
android:hasCode 0x0101000c En <application> de los config splits false (7.846 de 7.846)

El atributo splitTypes vale cadena vacía en casi todos los splits de idioma. Las 24 piezas con isSplitRequired son 22 bases y 2 APK únicos de fuera de Play; ninguna es un módulo. Lo que sabemos es dónde está escrito el atributo; dónde lo lee el instalador no lo hemos medido (recuadro de la «sección 1 · Por qué existen los splits»).

Hay dos formas de decir que un conjunto necesita todos sus splits, y conviven. La antigua es android:isSplitRequired y la moderna, requiredSplitTypes/splitTypes. Un fusionador tiene que tratar las dos, como detalla la «sección 5.2 de Fusión de splits · Hay dos mecanismos, y el muestrario solo tiene el moderno». La moderna es la normal: la usan el 98 % de las apps partidas más instaladas y el 94 % de las del sorteo. La antigua solo aparece en 22 bases, y siempre escrita en <application>:

BT=~/Library/Android/sdk/build-tools/37.0.0
$BT/aapt2 dump xmltree --file AndroidManifest.xml base.apk | grep isSplitRequired
        A: http://schemas.android.com/apk/res/android:isSplitRequired(0x01010591)=true

Es la base de org.fixer.martiallaw (carpeta de adb). Otra base con el mismo atributo es com.manddprojectconsultant.screencam. Fuera de Play hay dos APK únicos que lo llevan sin tener splits: com.tortillum.signalid (IzzyOnDroid) y com.kugou.android.lite (mercado chino).

Algunas bases escriben además requiredSplitTypes con otro namespace. En org.fixer.martiallaw está con el namespace http://schemas.android.com/apk/distribution y sin identificador de recurso. Un lector que busque solo android:requiredSplitTypes no lo verá. Tres bases del sorteo llevan los dos mecanismos a la vez: por eso firma_4.py cuenta 302 de 319 con requiredSplitTypes, y 299 son las que lo usan como único mecanismo.

El mecanismo moderno, sobre el base.apk de air.conectagames.tute (carpeta de adb), sacado del teléfono con adb:

E: manifest (line=2)
  A: android:versionCode(0x0101021b)=6022225
  A: android:versionName(0x0101021c)="6.22.225"
  A: android:requiredSplitTypes(0x0101064e)="base__abi,base__density"
  A: android:splitTypes(0x0101064f)=""
  A: package="air.conectagames.tute"

Y su split_config.arm64_v8a.apk:

E: manifest (line=0)
  A: android:versionCode(0x0101021b)=6022225
  A: android:splitTypes(0x0101064f)="base__abi"
  A: package="air.conectagames.tute"
  A: split="config.arm64_v8a"
    E: application (line=0)
      A: android:hasCode(0x0101000c)=false

El base declara que necesita alguien que aporte base__abi y base__density; cada config split declara qué aporta. El par base__abi,base__density es el más frecuente, en unas dos de cada tres bases. Le sigue base__abi solo y, mucho más atrás, base__density solo. En ningún conjunto del muestrario falta un tipo requerido. El instalador comprueba que el conjunto es completo antes de aceptarlo. Esa es la razón número uno por la que instalar splits sueltos falla: sin el base, con INSTALL_FAILED_INVALID_APK: Full install must include a base package; con el base y el conjunto incompleto, con INSTALL_FAILED_MISSING_SPLIT: Missing split for <paquete>. Los dos están reproducidos en la «sección 2.5 de Diagnóstico de fallos · Lo que responde adb install, reproducido».

Los volcados de esta sección están abreviados. A versionName, por ejemplo, aapt2 le añade (Raw: …).

Un módulo de funcionalidad añade además el namespace dist. Todos llevan <dist:fusing>, y casi nueve de cada diez declaran también <dist:delivery>. De split_i18n_en.apk de WhatsApp, en la forma actual, con elemento:

N: dist=http://schemas.android.com/apk/distribution
  E: dist:module
    A: dist:title=@0x7f1253c9
      E: dist:delivery
        E: dist:on-demand
        E: dist:install-time
          E: dist:removable   A: dist:value=true
          E: dist:conditions → dist:user-countries → dist:country code="US", "GB", "AU"…
      E: dist:fusing   A: dist:include=false

Los puntos suspensivos y la flecha abrevian el volcado real. De split_delivery.apk de WeChat, en la forma heredada, con atributo:

  E: dist:module
    A: dist:onDemand=true
    A: dist:title=@0x7f1012f9
      E: dist:fusing   A: dist:include=true

La pieza de WeChat declara además requiredSplitTypes="delivery__abi" y splitTypes="delivery__module". En el módulo de WhatsApp la instalación es condicional: se instala sola en ciertos países y se descarga bajo demanda en los demás.

dist:fusing include=true es la marca de que ese módulo se funde en los APK monolíticos que genera bundletool: los de standalones/, para dispositivos con API < 21 (anteriores a Android 5.0), y también el universal.apk de --mode=universal («sección 7 · Instalar sin fusionar frente a fusionar»). Con include="false" queda fuera de los dos. Y dist:onDemand="true" es la sintaxis heredada para la entrega bajo demanda; la vigente es un elemento, <dist:delivery><dist:on-demand/></dist:delivery>, dentro de <dist:module>. bundletool acepta las dos y, si encuentra el elemento, manda el elemento (AndroidManifest.isDeliveryTypeDeclared); el split_delivery.apk de WeChat usa la heredada. No hemos contado dist:onDemand por separado: los 21 módulos sin <dist:delivery> pueden ser de la forma heredada, pero no lo hemos comprobado.

El manifiesto de un conjunto generado por bundletool —y por tanto por Play— lleva además <meta-data> dentro de <application> que no escribe el desarrollador. La tabla dice dónde está cada clave en el muestrario. Qué hacer con ellas al fusionar está en la «sección 5.4 de Fusión de splits · Los <meta-data> que dejan bundletool y Play».

Clave Dónde aparece Para qué
com.android.vending.splits En todas las bases de Play que llegan partidas (773 de 773, con res/xml/splits0.xml). En ningún split. En APK únicos de Play: 61 de los 204 de las más instaladas, ninguno de los del sorteo Apunta a res/xml/splits0.xml, un recurso con el mapa de idioma a split que se inyecta en el split maestro del base (SplitsXmlInjector)
com.android.vending.splits.required En casi todas las bases (773 de 773 salvo 5 de las más instaladas). En módulos: algo más de la mitad de los de las más instaladas y los 4 del sorteo. En config splits y asset packs, en ninguno Un booleano que, según el comentario del código de bundletool, el sistema no lee (ManifestEditor.setSplitsRequired). Esta columna es lo que dice el código, no una medida
com.android.dynamic.apk.fused.modules En APK únicos hechos a partir de un bundle: uno de cada cuatro de los de las más instaladas, ninguno de los del sorteo. También en 27 de las 773 bases partidas. En splits, en ninguno La lista de módulos fundidos en ese APK (ModuleSplitsToShardMerger)
com.android.vending.derived.apk.id En 772 de las 773 bases. En todos los splits de ABI, densidad e idioma Un número entero (2 o 3 en las piezas leídas con aapt2); ver abajo

fused.modules no está solo en los APK standalone y universales: también aparece en 27 de las 773 bases de conjuntos partidos, con módulos fundidos en la base.

com.android.vending.derived.apk.id no está en el código de bundletool (commit 586a43a) ni en la documentación oficial consultada. Pero en Play está en todas partes: en todas las bases partidas menos una, en sus splits de ABI, densidad e idioma y en casi todos los módulos. Fuera de Play solo sale en una pieza de IzzyOnDroid (com.tortillum.signalid). La única base de Play que no lo lleva es la de com.heytap.themestore, que tampoco lleva sello ni frosting. Lo más probable es que lo añada Play, pero el muestrario no lo demuestra (recuadro de la «sección 1 · Por qué existen los splits»).

La base de air.conectagames.tute lleva los cinco <meta-data> de Play (com.android.vending.splits.required, com.android.stamp.source, com.android.stamp.type, com.android.vending.splits y com.android.vending.derived.apk.id), y su split_config.arm64_v8a.apk lleva derived.apk.id con valor 3.

4.3 Lo que todos los splits comparten obligatoriamente

Tres cosas, y las tres son invariantes que un fusionador tiene que comprobar antes de empezar. En las 773 apps de Play que llegan partidas se cumplen siempre: el mismo paquete, el mismo versionCode y el mismo certificado en todas las piezas, tanto en los .apkm y .xapk como en las carpetas de adb. En las 773 hay una sola base y ningún nombre de split repetido.

  1. package, el nombre del paquete. Idéntico en todos.
  2. android:versionCode. Idéntico en todos. En el .apkm de Keep, 220679628 en el base y en cada uno de los 26 config splits (27 piezas, un solo certificado).
  3. La firma. Todos los splits tienen que estar firmados con la misma clave, porque PackageManager los trata como una sola aplicación. Ver «Esquemas de firma».

El .apkm de Keep del muestrario es la compilación para Wear OS (el reloj), no la de móvil (minSdk 30, android.hardware.type.watch).

apksigner verify no acepta todos los splits sueltos. Acepta cada pieza por separado en casi todas las apps, pero rechaza 127 piezas aunque cada conjunto sea válido. Un split suelto no es la unidad que apksigner está pensada para revisar. Las dos causas que encontramos son de la herramienta:

  • 93 piezas dan «Missing META-INF/MANIFEST.MF». Son de 6 apps de Microsoft y Xiaomi y ninguna declara minSdkVersion. Al pasar a apksigner el minSdk de su base con --min-sdk-version (33 en 55 piezas y 30 en 38), las 93 verifican con la firma v3.
  • 34 piezas llevan un bloque de firma v3.2. Con Java 25.0.5, apksigner verifica las 34 (de 9 apps).

Un ejemplo de pieza que apksigner rechaza sola aunque el conjunto es válido: la pieza split_lenssampledoc.apk del .apkm de Microsoft Office (com.microsoft.office.officehubrow 16.0.20611.20024).

Lo que no comparten es versionName, minSdkVersion y, evidentemente, el contenido:

  • versionName. Falta en todos los config splits. Los módulos sí lo traen. aapt2 dump badging lo muestra vacío.
  • minSdkVersion en los config splits. Unos seis de cada diez no declaran <uses-sdk>, y los demás repiten el de la base. Ninguno lo cambia, y ninguna app mezcla config splits con y sin minSdkVersion.
  • minSdkVersion en los módulos. Todos declaran <uses-sdk>. En TikTok, los valores declarados por las piezas del conjunto no coinciden (23 y 26).

No hemos visto que un config split declare un minSdkVersion distinto del de su base. Las variantes de un APK Set («sección 3.1 · Qué es») sí pueden declararlo, pero el muestrario no tiene ninguna.

4.4 Lo que Play añade a lo que genera

Un conjunto que sale de Play lleva marcas que no escribe el desarrollador. Las que van en el manifiesto están en la «sección 4.2 · Los atributos del manifiesto». Esta sección suma las que van en la firma y en el ZIP. Dos términos: el sello (source stamp) es una firma de la tienda de origen, y el frosting es un bloque del APK Signing Block que solo lleva Play.

Marca Dónde está En qué piezas
<meta-data> com.android.stamp.source y stamp.type AndroidManifest.xml, solo en la base Prácticamente todas las bases de Play (772 de 773). En ningún split
Fichero stamp-cert-sha256 y bloque 0x6dff800d (sello de la tienda) Todo el conjunto Cerca del 98 % de las piezas de las apps más instaladas de Play y el 97 % de las del sorteo; 6 piezas de IzzyOnDroid. En F-Droid, mercado chino y webs de autores, ninguna
Bloque «frosting» 0x2146444e APK Signing Block, solo en la base o en el APK único Casi todas las bases (763 de 773) y todos los APK únicos del sorteo; unos 56 de 204 APK únicos de las más instaladas. En splits, ninguno
Fecha 1981-01-01 01:01:02 en las entradas Central Directory Todas las bases y splits de Play. También en nueve de cada diez APK de F-Droid

El sello usa siempre un único certificado (SHA-256 3257d599a49d2c961a471ca9843f59d341a405884583fc087df4237b733bbd6d). El frosting aparece en tres de cada cuatro apps más instaladas de Play y en casi todas las del sorteo; fuera de Play, en una sola pieza, de IzzyOnDroid. La fecha de las entradas no es exclusiva de Play.

Estas marcas separan lo que dejó Play de lo que añade un sitio de descargas, pero el muestrario no dice quién las escribe: solo dónde están. Ejemplo: la base de air.conectagames.tute lleva sello, frosting y los cinco <meta-data>, y com.tortillum.signalid (IzzyOnDroid) es la única pieza fuera de Play con frosting. El significado del campo 4 del frosting sigue abierto (recuadro de la «sección 1 · Por qué existen los splits»).

4.5 Dónde acaban los marcos (Flutter, Unity, React Native)

En una app partida el código no está en un solo sitio, y qué pieza hay que abrir depende del marco de desarrollo.

La regla general: el DEX va entero en el base y las .so, en los splits de ABI. Se cumple en nueve de cada diez apps o más.

Marco Qué va en el split de ABI Qué va en el base Cifras
Flutter libflutter.so y libapp.so (el código de la app) flutter_assets/ libflutter.so y libapp.so en el split de ABI en todas las apps que miramos. flutter_assets/ en el base en todas menos una
Unity libunity.so y libil2cpp.so global-metadata.dat; los datos de juego, en la mayoría libunity.so y libil2cpp.so en el split de ABI en todas. global-metadata.dat en el base en 90 de 92 de las más instaladas y en todas las del sorteo
React Native libhermes.so, casi siempre El paquete de JavaScript (assets/*.android.bundle) libhermes.so en un split de ABI: 32 de 37 de las más instaladas y todas las del sorteo. Paquete JS en el base: en todas

Los datos de Unity merecen aparte. Lo normal es que vayan solo en el base (siete de cada diez apps entre las más instaladas, nueve de cada diez en el sorteo). Casi todas las demás los reparten entre el base y un asset pack. No hemos contado Unity sin splits (las apps de un solo APK) ni Xamarin.

Ejemplo: la app Unity com.olzhas.carparking.multyplayer 4.9.11, con base.apk de 104,9 MB. Sus datos van en split_UnityDataAssetPack.apk y la ABI en split_config.arm64_v8a.apk. Un .xapk con todo el DEX en el base y las .so en el split de ABI: 99acres Buy Rent Sell Property 16.0.36 (APKPure), pieza com.nnacres.app.apk. Las cifras salen de frameworks_y_bibliotecas_2.py.

4.6 Alineación a 16 KiB en los splits de ABI

Las bibliotecas nativas viven en los splits de ABI. Muchos las llevan sin comprimir (con extractNativeLibs="false") para que el sistema las mapee directamente. Entonces cada .so tiene que empezar en un múltiplo del tamaño de página. La regla de las páginas de 16 KiB y el comando de comprobación están en «Alineación y zipalign → §3 · La regla de las páginas de 16 KiB».

Lo que vemos en los splits de ABI:

  • Unos seis de cada diez llevan alguna .so sin comprimir (610 de 1.026 en las más instaladas y 192 de 285 en el sorteo).
  • De esas, casi todas están en múltiplo de 16 KiB dentro del ZIP (588 de 610 y 166 de 192), y todas en múltiplo de 4 KiB.
  • zipalign -c -P 16 4 falla en 22 de 962 splits de .apkm, en 0 de 64 de .xapk, y en el sorteo en 25 de 282 carpetas de adb y 1 de 3 .xapk.

Dos mediciones distintas conviven y no se mezclan. Los 588 y los 166 miden el desplazamiento de los datos de cada .so en el ZIP (zip_y_contenedores_4.py). zipalign mide además el p_align del ELF (alineacion_y_16k_2.py). Las dos cuadran: cumplen 754 de 802 splits, que son justo los 802 menos los 22 y los 26 que fallan. Ejemplos que fallan: el .apkm de com.football.soccer.league 0.2.18, con las piezas split_config.arm64_v8a.apk (21 .so sin alinear) y split_config.armeabi_v7a.apk (19 .so).

5. Contenedores de terceros

Un contenedor de terceros es el ZIP con el que un sitio de descargas empaqueta los APK de una app. Ninguno de estos formatos está especificado. Lo que sigue lo hemos medido sobre el «muestrario».

Los contenedores se escriben de una sola pasada, sin volver atrás. Como el programa no sabe cuánto ocupa cada fichero hasta terminarlo, apunta el tamaño detrás, en un bloque llamado data descriptor, y lo avisa con una marca en la cabecera: el bit 3. Las cifras, por entrada del ZIP:

  • .xapk. El bit 3 está en las 581 entradas de los 72 contenedores.
  • .apkm. Está en 9.228 de 9.618 entradas. En 386 de los 388 contenedores lo llevan todas las entradas salvo APKM_installer.url, y en 2 (com.lemon.lvoverseas y com.telcel.contenedor) tampoco icon.png. El descriptor con la firma PK\x07\x08 se lee en los 460 contenedores.
  • Cabecera local rellena pese al bit. Ninguna entrada en los .apkm y 20 de 581 en los .xapk, todas del de Sweet Selfie, que se llama «APKPure» pero viene de APKCombo.

Por eso hay que leerlos por el índice del final del ZIP (Central Directory) y no fiarse de la cabecera de cada fichero; lo mide la «sección 7.3 de Contenedor ZIP · Qué aparece de verdad en el muestrario». Ojo, no es algo exclusivo de los contenedores: también lo llevan muchos APK sueltos del mercado chino (más de un tercio) y algunos de F-Droid. En Play, ninguna base ni split lo lleva; solo APK únicos. No hemos medido qué herramienta escribió cada uno de los APK sueltos. Ejemplos:

  • El .xapk de Sweet Selfie, de APKCombo, con la cabecera local rellena (20 entradas).
  • El .xapk de Telegram 13.1.0: bit 3 en todas las entradas.
  • El .apkm de Keep de la «sección 4.3 · Lo que todos los splits comparten obligatoriamente»: bit 3 en todas las entradas salvo APKM_installer.url.
  • Un APK suelto del mercado chino con el bit: com.tencent.tmgp.aceracer.

Esta sección y la 6 solo resumen. La estructura de cada contenedor de terceros, sus metadatos, cómo se identifica y qué se hace con él están en «Formatos y extensiones», «secciones 3 · Los formatos, uno a uno» a 6, que cubren además la exportación de SAI y la distinción entre un APK completo y un split suelto.

5.1 .xapk — APKPure

Un .xapk es un ZIP plano con el base —que se llama <paquete>.apk— y los config splits en la raíz, sin el prefijo split_. Lleva un manifest.json cuya clave xapk_version identifica el formato y cuya lista split_apks da el id de cada fichero, así que el contenedor se describe solo. El de Telegram 13.1.0 trae org.telegram.messenger.apk, config.arm64_v8a.apk y config.xxhdpi.apk.

Lo que medimos sobre los 72 .xapk (71 de APKPure y 1 de APKCombo):

  • manifest.json. Las claves xapk_version, package_name, name, version_code, version_name, min_sdk_version, permissions, icon y split_apks están en los 72. Están en 71 split_configs, total_size y target_sdk_version, y en 35 locales_name. xapk_version es el número 2 en 70 y la cadena «2» en 2.
  • Los ficheros. split_apks coincide con los .apk presentes en los 72, y el base se llama <paquete>.apk en los 72. De los splits, 367 se llaman config.* y 11 son módulos o asset packs. icon.png está en 58 de 72 y se declara sin fichero en 14. Las piezas van sin comprimir en 447 casos y comprimidas en 3.
  • Tamaño. Mediana de 3 APK por .xapk (p10 2; p90 20; máx. 22): 2 en 17, 3 en 21 y 4 en 15.

Lo importante es que casi todos traen solo el recorte de un dispositivo: entre los .xapk con splits de ABI, 60 de 62 traen una sola arquitectura, frente a uno de cada cinco .apkm. Por eso un .xapk casi nunca sirve para reconstruir una app universal. Las cifras salen de zip_y_contenedores_4.py y de zip_y_contenedores_1.py. El listado, un manifest.json real y el nombrado están en la «sección 3.4 de Formatos y extensiones · .xapk — APKCombo y APKPure».

5.2 .apkm — APKMirror

Un .apkm es un ZIP con el base y los splits en la raíz, un info.json y su propia firma JAR sobre el contenedor, que es de APKMirror y no de la aplicación (ver «Esquemas de firma»). Lo que medimos sobre los 388 .apkm, todos de APKMirror:

  • info.json. Tiene 17 claves en 386 y 18 en 2, donde la 18.ª es obb_files. Las 17 son accent_color, apk_id, apk_title, apkm_version, app_name, arches, capabilities, dpis, languages, min_api, pname, post_date, release_id, release_title, release_version, variant y versioncode. apkm_version vale 5 en los 388, y pname coincide con el paquete de la base en los 388.
  • Contenido. base.apk, icon.png y APKM_installer.url están en la raíz en los 388. La mediana es de 12 piezas por .apkm (p10 3; p90 36; máx. 125).
  • Firma exterior. META-INF/MANIFEST.MF, APKMIRRO.SF y APKMIRRO.RSA están en los 388, con un único certificado: CN=APKMirror.com, válido hasta 2119-06-30 (SHA-256 del certificado 7b1a6d25e5e8711a6e79283df10c648b47a420c4e5413c2c51351a8ca508de25).

El nombre del fichero dice qué trae. com.whatsapp_2.26.42.9-264200903_4arch_7dpi_17feat_…apkm son 4 arquitecturas, 7 densidades y 17 módulos. El patrón Narch_Ndpi_Nlang_Nfeat coincide con las piezas en los 386 que lo siguen; los 2 ficheros que terminan en «(1)» (una descarga repetida) no lo siguen.

Un .apkm puede ser parcial (1arch_1dpi) o ser la versión para reloj o televisión. Entre los 388, 11 son de ese tipo: 5 de Wear OS y 6 de Android TV. El de Keep del muestrario (nombre 1arch_1dpi_24lang) es el de Wear OS. Antes de citar un .apkm como ejemplo de app de móvil, hay que mirar capabilities en info.json. Ejemplo con 18 claves y un .obb en la raíz: el de Plants vs. Zombies 2 (com.ea.game.pvz2) 13.5.1. El listado, las claves con sus valores y lo que acredita esa firma están en la «sección 3.5 de Formatos y extensiones · .apkm — APKMirror».

5.3 SAI — Split APKs Installer

SAI es un instalador de splits. Su exportación más simple es un ZIP plano con los .apk y nada más, sin metadatos ni firma propia; esa ausencia es lo que lo define. El muestrario no contiene ninguno. Los 460 contenedores se reconocen por info.json más APKMIRRO.RSA (388) o por un manifest.json con xapk_version (72), y ninguno cae en la regla del ZIP plano. Lo más parecido es una carpeta sacada con adb («sección 5.5 · Lo que hay en el teléfono (carpetas de adb)»), que tampoco lleva metadatos. SAI exporta además un .apks con metadatos propios («sección 3.3 de Formatos y extensiones · .apks — cuatro cosas distintas con el mismo nombre»); el muestrario tampoco tiene ninguno. El formato SAI queda, por tanto, sin respaldo en el muestrario (recuadro de la «sección 1 · Por qué existen los splits»).

5.4 Los OBB heredados

Los expansion files de antes del AAB: hasta dos ficheros .obb de 2 GB que viajan fuera del APK, superados desde agosto de 2021. Todavía aparecen. Dos de los 388 .apkm del muestrario llevan un .obb en la raíz y declaran su nombre en la clave obb_files de info.json. Ningún .xapk lleva Android/obb/ y ninguna de las 365 carpetas de adb trae un .obb. Esto último no significa que esas apps no los usen: solo miramos el primer nivel, y las instrucciones de descarga excluían los .obb.

La descarga pesa mucho más que el APK. Plants vs. Zombies 2 baja 934,0 MB frente a 65,7 MB de APK (el .obb es main.1063.com.ea.game.pvz2_row.obb). Scary Teacher (hellgame), 1,10 GB frente a 105,0 MB (.obb main.221.com.zakg.scaryteacher.hellgame.obb). El nombrado, la ruta de instalación y cuándo siguen apareciendo están en la «sección 3.7 de Formatos y extensiones · .obb — el heredado».

5.5 Lo que hay en el teléfono (carpetas de adb)

Una app de Play también se puede obtener del propio teléfono. El sistema guarda los APK que instaló, y adb los copia a una carpeta; la receta está en la «sección 8.4 · Sacar los APK de un teléfono con adb». Es lo que Play entregó de verdad, pero solo para ese dispositivo: un split de arquitectura, uno de densidad y uno o dos de idioma.

En el muestrario hay 365 carpetas con 1.225 piezas, el tercer formato más numeroso. Lo que medimos:

  • Piezas por carpeta. Lo normal son 4, y nunca más de 7. Hay 50 carpetas con solo el base.
  • Tamaño. Mediana de 51,4 MB; la mayor pasa de 4 GB.
  • Qué trae. Cuando hay split de ABI es siempre arm64_v8a, y el de densidad, siempre xxhdpi. De idioma, nada, en, o en y es. Solo 21 carpetas traen módulos.
  • Nombres. Todas las piezas son base.apk o split_<atributo split>.apk.
  • Frosting. Lo llevan todas las bases menos una («sección 4.4 · Lo que Play añade a lo que genera»).

Todas las carpetas parecen salir de un mismo tipo de teléfono (arm64-v8a, xxhdpi, inglés y español). Eso lo deducimos de los splits; no lo sabemos como dato.

Ejemplo: air.conectagames.tute. Sus cinco piezas son base.apk (51,6 MB), split_config.arm64_v8a.apk (5,3 MB), split_config.en.apk (41 KB), split_config.es.apk (29 KB) y split_config.xxhdpi.apk (987 KB).

6. Detección por estructura, nunca por extensión

6.1 El principio

La extensión no es una prueba. La pone quien empaqueta, y quien reempaqueta puede cambiarla. En el muestrario coincide con la estructura en los 460 contenedores, pero el nombre sí engaña («sección 6.3 · La comprobación sobre el muestrario»). La única fuente fiable es el Central Directory del ZIP, que se lee sin descomprimir nada (solo el .xapk obliga a abrir además su manifest.json). Cada formato deja en él una evidencia que ningún otro comparte:

  • toc.pb, el APK Set;
  • BundleConfig.pb con el manifiesto en base/manifest/, el .aab;
  • info.json con firma propia, el .apkm;
  • xapk_version, el .xapk;
  • meta.sai_v1.json o meta.sai_v2.json, el .apks exportado por SAI;
  • varias entradas *.apk sin metadatos ni AndroidManifest.xml en la raíz, el ZIP plano;
  • y AndroidManifest.xml en la raíz, el APK suelto.

Ojo: a un APK suelto no se le reconoce por resources.arsc. No lo llevan los splits de ABI, ni los asset packs, ni los de textura y país, ni la mitad de los módulos, ni seis splits de idioma (como split_config.id y split_config.he de TikTok). AndroidManifest.xml, en cambio, está en la raíz de todos los .apk sueltos y de ningún contenedor. La tabla de evidencias, con el porqué de cada una, está en la «sección 4 de Formatos y extensiones · Cómo saber en diez segundos qué tienes delante».

6.2 El orden de precedencia

Como las evidencias se solapan —un .apkm también tiene *.apk en la raíz; un APK Set, splits/*.apk—, se comprueban de la más específica a la más genérica. El orden, paso a paso y con su porqué, es la tabla de la «sección 4 de Formatos y extensiones · Cómo saber en diez segundos qué tienes delante». Y cuando la estructura contradice a la extensión, manda la estructura y se deja constancia del desajuste: ni se rechaza el fichero ni se calla la discrepancia, que es lo contrario del fallo silencioso que caracteriza al sector.

6.3 La comprobación sobre el muestrario

Clasificados por su Central Directory, los 388 .apkm llevan info.json y META-INF/APKMIRRO.RSA, y los 72 .xapk, un manifest.json con la clave xapk_version. Ninguno de los 460 lleva toc.pb ni BundleConfig.pb: en el muestrario no hay .apks ni .aab. Los dos .apks y el .aab de los ejemplos de este documento son locales. El resto de la comprobación, por tipo de fichero:

  • Contenedores. 0 desajustes entre extensión y estructura en 460 (388 .apkm y 72 .xapk).
  • .apk sueltos. 0 desajustes en 6.220: todos tienen AndroidManifest.xml en la raíz.
  • Carpetas de adb. 0 desajustes en 365: todas las entradas son .apk. Se clasifican sin toc.pb, porque no son un ZIP.
  • Ilegibles. 0 ZIP ilegibles.

Lo que sí engaña es el nombre. El .xapk de Sweet Selfie se llama «APKPure» y viene de APKCombo (consta en el manifiesto del muestrario y trae APKComboInstaller.url). El .apkm de Keep se clasifica por info.json más APKMIRRO.RSA, y el .xapk de Telegram, por su manifest.json. La regla «nunca por extensión» se sostiene como práctica, no por una cifra. Para repetir la clasificación: MUESTRARIO_RAIZ=<copia del muestrario> python3 -I scripts/muestrario/cifras/zip_y_contenedores_4.py. La función de detección está en la «sección 5 de Formatos y extensiones · La extensión no es una prueba, y está medido».

7. Instalar sin fusionar frente a fusionar

Hay dos maneras de llevar un conjunto de splits a un dispositivo, y hacen cosas distintas.

Instalar sin fusionar. El sistema recibe los APK por separado y los monta como una sola aplicación. Es lo que hace Play y lo que preserva el comportamiento original. A mano se hace con adb install-multiple.

bundletool hace lo mismo pero eligiendo él los splits. La salida de este comando, como la de las secciones «8.1» y «8.2», es de fixture.apks, un fichero local que no es del muestrario:

java -jar bundletool.jar install-apks --apks=fixture.apks
The APKs have been extracted in the directory: /var/folders/lk/…/8598555168175782903

install-apks consulta el toc.pb, interroga al dispositivo conectado y extrae solo los splits que le corresponden. Es lo correcto siempre que haya un dispositivo. También acepta --device-id=<serie> cuando hay más de uno.

Instalar el conjunto no es instalar los ficheros que uno le pasa. El sistema los renombra según el atributo split de cada manifiesto, no según el nombre del fichero de entrada: entra config.es.apk y queda split_config.es.apk. Los nombres del muestrario lo confirman. En el .xapk de Telegram el split se llama config.xxhdpi.apk, sin prefijo. En las carpetas sacadas del teléfono, que conservan lo que dejó el sistema, el nombre lleva siempre el prefijo: todas las piezas son base.apk o split_ más el atributo (split_config.xxhdpi.apk). Los .apkm también lo llevan siempre, y los .xapk, nunca.

Los dos fallos que salen a la primera son INSTALL_FAILED_MISSING_SPLIT —falta algún split del conjunto— e INSTALL_FAILED_NO_MATCHING_ABIS —el config.<abi> no corresponde a la arquitectura del dispositivo—. La sesión completa con su salida literal —el Success con los splits de Telegram, los dos fallos y el pm path que enseña el renombrado— está en las secciones «3.1» y «6.2» de «Formatos y extensiones». Esa sesión procede de otra versión de Telegram: el .xapk actual es la 13.1.0, y los nombres de los dos errores no hemos podido comprobarlos sin ejecutar nada (recuadro de la «sección 1 · Por qué existen los splits»).

Fusionar. Producir un único APK instalable con todo dentro. Es lo que hace falta cuando no hay adb, cuando el objetivo es analizar la aplicación como una unidad, o cuando se va a modificar y volver a firmar. Exige mucho más que concatenar ZIPs:

  • Unir las tablas de recursos de todos los splits en una sola, resolviendo las colisiones de identificador (ver «Tabla de recursos» y «Fusión de splits»).
  • Sanear el manifiesto: quitar split, isFeatureSplit, requiredSplitTypes y splitTypes, porque el resultado ya no es un conjunto.
  • Renumerar los classes*.dex de los módulos de funcionalidad que tengan código propio.
  • Seleccionar qué configuraciones se conservan y cuáles se descartan.
  • Realinear y volver a firmar, porque la firma original ya no vale.

Lo que no se puede hacer es fusionar un AAB directamente: hay que pasar antes por bundletool build-apks, porque el .aab no contiene ningún resources.arsc, solo resources.pb. La vía oficial es --mode=universal, que produce el universal.apk de la «sección 3.1 · Qué es».

Y el universal no lo junta todo. bundletool solo funde en él —y en los APK de standalones/— el base y los módulos con <dist:fusing dist:include="true"/> (BuildApksManager.modulesToFuse): un módulo bajo demanda con include="false" queda fuera, y lo que aporta no existe en el resultado. Para meterlo hay que nombrarlo en --modules, que en los modos universal y system dice qué módulos incluir. La excepción es un BundleConfig con standalone_config.feature_modules_mode en SEPARATE_FEATURE_MODULES —el modo que genera un APK aparte por módulo en las variantes con minSdk menor que 21—: con él, modulesToFuse no filtra por dist:fusing y devuelve todos los módulos. Cuenta también al usar el universal como referencia de una fusión («Fusión de splits», secciones «5.3» y «10.3»): un módulo que no aparece en él puede faltar por su dist:fusing, no por un error.

Un protector no impide partir la app, y obliga a mirar todas las piezas. En Play, más de la mitad de las apps empaquetadas llegan partidas, y todas las que usan PairIP (el protector que ofrece Google Play, que contamos aparte). En el mercado chino es al revés: más de un tercio salen empaquetadas, pero ninguna viene partida. La heurística es la de nucleo_codigo, y coincide con APKiD en 93 de 98 apps chinas. La conclusión práctica: si la app está protegida y partida, analizar solo base.apk se queda corto. Ejemplo: el .apkm de com.block.juggle 10.9.0 (37 piezas). Las cifras salen de zip_y_contenedores_4.py.

8. Recetas

Máquina de referencia: macOS, bundletool 1.18.3 en ~/herramientas/bundletool.jar, aapt2 2.20-15087165 de las build-tools 37.0.0, OpenJDK 21. Las recetas 8.1 y 8.2 se ejecutan sobre fixture.aab y fixture.apks, ficheros locales que no son del muestrario (recuadro de la «sección 1 · Por qué existen los splits»). Sus salidas son las de bundletool 1.18.3 y no se pueden contrastar con el muestrario.

8.1 bundletool validate y dump sobre un .aab

Los subcomandos dump y validate solo aceptan --bundle. Invocarlos con --apks falla:

BTOOL=~/herramientas/bundletool.jar
java -jar $BTOOL dump manifest --apks fixture.apks
[BT:1.18.3] Error: Missing the required --bundle flag.
com.android.tools.build.bundletool.flags.Flag$RequiredFlagNotSetException: …

Sobre el bundle sí funcionan:

java -jar $BTOOL validate --bundle fixture.aab | head -12
App Bundle information
------------
Feature modules:
	Feature module: base
		File: res/drawable-xxhdpi-v4/ic_fixture.png
		File: res/drawable-xhdpi-v4/ic_fixture.png
		File: res/drawable-mdpi-v4/ic_fixture.png
		File: res/drawable-hdpi-v4/ic_fixture.png
		File: lib/armeabi-v7a/libtermux.so
		File: lib/arm64-v8a/libtermux.so
		File: lib/x86_64/libtermux.so
		File: dex/classes.dex
java -jar $BTOOL dump manifest --bundle fixture.aab | head -6
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:compileSdkVersion="36" android:compileSdkVersionCodename="16" android:versionCode="1" android:versionName="1.0" package="com.ejemplo.fixture" platformBuildVersionCode="36" platformBuildVersionName="16">

  <uses-sdk android:minSdkVersion="24" android:targetSdkVersion="36"/>

  <uses-permission android:name="android.permission.INTERNET"/>

  <application android:extractNativeLibs="false" android:icon="@drawable/ic_fixture" android:label="@string/app_name"/>

dump resources --values lee el resources.pb de los módulos y lo presenta con la misma forma que aapt2 dump resources presenta un resources.arsc:

java -jar $BTOOL dump resources --bundle fixture.aab --values
Package 'com.ejemplo.fixture':
0x7f010000 - drawable/ic_fixture
	density: 160 - [FILE] res/drawable-mdpi-v4/ic_fixture.png
	density: 240 - [FILE] res/drawable-hdpi-v4/ic_fixture.png
	density: 320 - [FILE] res/drawable-xhdpi-v4/ic_fixture.png
	density: 480 - [FILE] res/drawable-xxhdpi-v4/ic_fixture.png
0x7f020000 - string/app_name
	(default) - [STR] "Ejemplo Fixture"
	locale: "de" - [STR] "Ejemplo Beispiel"
	locale: "fr" - [STR] "Echantillon Ejemplo"
	locale: "es" - [STR] "Muestra Ejemplo"

8.2 Extraer los splits de un dispositivo concreto

Sin dispositivo conectado se puede escribir la especificación a mano:

cat > /tmp/dev.json <<'EOF'
{"supportedAbis":["arm64-v8a"],"supportedLocales":["es"],"screenDensity":420,"sdkVersion":34}
EOF
java -jar $BTOOL extract-apks --apks fixture.apks \
     --output-dir ./extracted --device-spec /tmp/dev.json
ls extracted
The APKs have been extracted in the directory: ./extracted
base-arm64_v8a_3.apk
base-es_3.apk
base-master_3.apk
base-xxhdpi_3.apk

Cuatro APK de los 43: el maestro, la ABI, el idioma y la densidad, todos de la variante _3, que es la que corresponde a sdkVersion 34. Es exactamente lo que instalaría Play.

Es también lo que recibe un teléfono real. En el muestrario, air.conectagames.tute trae cinco APK sacados con adb: base.apk (51.584.785 bytes), split_config.arm64_v8a.apk (5.330.067), split_config.en.apk (41.369), split_config.es.apk (29.081) y split_config.xxhdpi.apk (986.838). La mediana de las carpetas de adb es de 4 piezas, entre 1 y 7.

Y el tamaño de descarga por combinación:

java -jar $BTOOL get-size total --apks fixture.apks \
     --dimensions=ABI,LANGUAGE | head -5
ABI,LANGUAGE,MIN,MAX
arm64-v8a,de,14549,14703
x86_64,de,14933,15080
x86_64,es,14928,15074
x86_64,fr,14937,15083

8.3 Inspeccionar el manifiesto de un split

Sobre split_config.es.apk de air.conectagames.tute (carpeta de adb):

BT=~/Library/Android/sdk/build-tools/37.0.0
$BT/aapt2 dump badging split_config.es.apk | head -4
package: name='air.conectagames.tute' versionCode='6022225' versionName='' split='config.es'
application: label='' icon=''

versionName vacío y split='config.es': la marca inequívoca de un config split. aapt2 dump badging también lista los locales y densidades que aporta:

locales: 'es' 'es-ES' 'es-US'
densities: '160'

Un solo config.es.apk cubre tres locales, porque es-ES y es-US son variantes regionales del español que Play agrupa en el mismo split. La densidad 160 es la de los recursos sin calificador (mdpi) en un split sin recursos de pantalla. El split no declara <uses-sdk>. Los tres locales coinciden con las tres configuraciones de su resources.arsc. No siempre es así: lo normal es un solo locale por split de idioma, pero los de español e inglés suelen traer varios (una mediana de 3 y de 5). No sabemos qué regiones agrupa Play: solo lo que medimos en cada pieza.

8.4 Sacar los APK de un teléfono con adb

Para obtener lo que el sistema tiene instalado de una app, se pide la lista de rutas y se copia cada una:

adb shell pm path <paquete>
adb pull <ruta de cada línea> .

pm path imprime una línea package:<ruta> por cada APK del conjunto: el base y los splits del dispositivo. Es la receta de las carpetas de la «sección 5.5 · Lo que hay en el teléfono (carpetas de adb)». No la hemos ejecutado para este documento, así que conviene contrastarla con la documentación oficial de «adb» antes de depender de ella.

9. Cuántas apps llegan partidas, y qué pasa fuera de Play

9.1 Cuántas apps de Play llegan partidas

Una app «llega partida» si lo descargado trae un base y al menos un split. Lo de arriba («una aplicación instalada ya no es un APK, sino un conjunto») se puede medir.

Fuente Apps Parten Según cómo se descargó
Google Play, más instaladas 658 454 (69 %) .apk 0 de 202; .apkm 386 de 388; .xapk 68 de 68
Google Play, sorteo 369 319 (86 %) Carpetas de adb 315 de 365; .xapk 4 de 4

Más de dos de cada tres apps más instaladas de Google Play llegan partidas, y casi nueve de cada diez del sorteo. Entre las más instaladas la cifra mezcla vías de descarga: un .apkm trae todas las variantes, un .xapk un recorte y un .apk suelto ninguna. En el sorteo es lo que Play instaló en un teléfono.

La app mediana de las partidas trae 10 splits entre las más instaladas (p10 2; p90 35; máx. 124) y 3 en el sorteo (p10 1; p90 4; máx. 19). Una carpeta de adb solo trae lo que instaló ese teléfono. Entre las apps partidas, traen al menos un split de:

  • ABI: 421 de 454 y 281 de 319 (el 93 % y el 88 %).
  • Densidad: 325 de 454 y 240 de 319 (el 72 % y el 75 %).
  • Idioma: 220 de 454 y 219 de 319 (el 48 % y el 69 %).
  • Módulo de funcionalidad: 43 de 454 y 4 de 319.
  • Asset pack: 51 de 454 y 18 de 319.
  • Textura: 2 de 454 y 1 de 319.

El base.apk pesa, en la mediana, el 64 % de los bytes de la app entre las más instaladas (p10 22 %; p90 92 %) y el 74 % en el sorteo (p10 29 %; p90 99 %). La app partida más grande es el .apkm de com.olzhas.carparking.multyplayer 4.9.11: 2,48 GB en 5 piezas (base, 2 de ABI y 2 asset packs de Unity). Las cifras salen de zip_y_contenedores_4.py.

9.2 Fuera de Play: el APK único sigue vivo

Fuera de Google Play no hay AAB ni splits: ninguna app del muestrario llega partida. F-Droid, IzzyOnDroid, las tiendas chinas y las webs de los autores entregan un APK completo por app (en el mercado chino, un paquete con dos ficheros).

Eso no quiere decir que todo vaya en un solo APK universal. Entre los que llevan código nativo, traen una sola arquitectura uno de cada cuatro en F-Droid y dos de cada tres en el mercado chino. Recuerda al multiple APK de la «sección 1 · Por qué existen los splits»: un APK por grupo de dispositivos. Del muestrario solo descargamos un fichero por paquete en F-Droid, IzzyOnDroid y las webs, así que no demostramos que F-Droid reparta un APK por arquitectura: vemos que hay APK de una sola, no que haya varios del mismo paquete. Ejemplos de las webs de los autores:

  • fenix-158.0.1.multi.android-arm64-v8a.apk de Firefox: la versión arm64-v8a.
  • Bravearm64Universal.apk de Brave: la arm64Universal, que lleva fused.modules.
  • WhatsApp.apk: un APK único.

En el mercado chino hay otra forma de repartir variantes de un mismo APK sin recurrir a splits: un identificador de canal en el bloque de firma. Casi un tercio de los APK chinos lo llevan, con el ID 0x71777777 (canal Walle, de Meituan) o el 0x881155ff (VasDolly, de Tencent). Un ejemplo: com.kugou.android.lite. En cambio, com.android.dynamic.apk.fused.modules es raro fuera de Play, y en el mercado chino no aparece nunca. Las cifras salen de zip_y_contenedores_4.py.

Fuentes

  1. Formato del Android App Bundle — https://developer.android.com/guide/app-bundle/app-bundle-format Consultado el 12 de agosto de 2026. De aquí sale la tabla de estructura interna de la «sección 2.1 · Estructura interna», incluidos BUNDLE-METADATA/, el directorio root/ y la separación de manifest/ y dex/, con las citas literales.
  2. google/bundletool, src/main/proto/commands.proto — https://raw.githubusercontent.com/google/bundletool/master/src/main/proto/commands.proto Consultado el 12 de agosto de 2026. De aquí sale íntegra la tabla de campos de BuildApksResult de la «sección 3.2 · toc.pb: BuildApksResult» y la jerarquía Variant → ApkSet → ApkDescription con sus siete metadatos alternativos. Consultado de nuevo el 18 de octubre de 2026 en el commit 586a43a (bundletool 1.18.3): de aquí salen también variant_number, variant_properties (líneas 78-108), la prioridad entre variantes y signing_description, campo 10 de ApkDescription (líneas 245-275), todo en la «sección 3.2 · toc.pb: BuildApksResult».
  3. google/bundletool, src/main/proto/config.proto — https://raw.githubusercontent.com/google/bundletool/master/src/main/proto/config.proto Consultado el 12 de agosto de 2026. De aquí salen los nueve campos de BundleConfig y los valores de BundleType de la «sección 2.3 · Los .proto relevantes».
  4. google/bundletool, src/main/proto/targeting.proto y files.proto — https://raw.githubusercontent.com/google/bundletool/master/src/main/proto/targeting.proto Consultado el 12 de agosto de 2026. De aquí sale la fila correspondiente de la tabla de .proto de la «sección 2.3 · Los .proto relevantes». Consultado de nuevo el 18 de octubre de 2026 en el commit 586a43a: de aquí sale VariantTargeting con su sdk_version_targeting (líneas 10-17) de la «sección 3.1 · Qué es».
  5. frameworks/base/tools/aapt2/Resources.proto (etiqueta android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/Resources.proto Consultado el 25 de septiembre de 2026, descargado con ?format=TEXT y decodificado. De aquí salen el paquete aapt.pb, el java_package com.android.aapt y la jerarquía ResourceTable → Package → Type → Entry → ConfigValue de la «sección 2.3 · Los .proto relevantes».
  6. bundletool — documentación oficial — https://developer.android.com/tools/bundletool Consultado el 12 de agosto de 2026. De aquí sale la sintaxis de build-apks, install-apks, extract-apks, get-device-spec y get-size total de las secciones «7» y «8», y la definición del APK Set. Consultado de nuevo el 18 de octubre de 2026 (la página se actualizó el 28 de agosto): de aquí salen también que Play genera los APK con bundletool y la nota de que el universal solo incluye los módulos con <dist:fusing dist:include="true"/> (secciones «4.2» y «7»).
  7. adb — documentación oficial — https://developer.android.com/tools/adb Consultado el 12 de agosto de 2026. De aquí sale adb install-multiple de la «sección 7 · Instalar sin fusionar frente a fusionar» y la confirmación de que la documentación no publica su sintaxis completa de parámetros.
  8. APK expansion files (OBB) — https://developer.android.com/google/play/expansion-files Consultado el 12 de agosto de 2026. De aquí salen el límite de 2 GB y el estado de obsolescencia del resumen de la «sección 5.4 · Los OBB heredados».
  9. services/core/java/com/android/server/pm/PackageInstallerSession.java (etiqueta android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/pm/PackageInstallerSession.java Consultado el 25 de septiembre de 2026. De aquí sale que isSplitRequired hace fallar la instalación con INSTALL_FAILED_MISSING_SPLIT («sección 4.2 · Los atributos del manifiesto»).
  10. bundletool — ModuleSplit.java — https://github.com/google/bundletool/blob/e5819d7dfd8feb9b6f3d9d3ec2ca216c43efde6f/src/main/java/com/android/tools/build/bundletool/model/ModuleSplit.java Consultado el 25 de septiembre de 2026. De aquí sale que los splits de bibliotecas nativas se crean sin tabla de recursos (forNativeLibraries, setResourceTable = false), y por tanto sin resources.arsc («sección 6 · Detección por estructura, nunca por extensión»).
  11. bundletool 1.18.3 — generación de variantes y de APK monolíticos, commit 586a43a — https://github.com/google/bundletool/blob/586a43a450712a1067f3d92cf7574dee68226302/src/main/java/com/android/tools/build/bundletool/commands/BuildApksManager.java y, en el mismo commit, splitters/NativeLibsCompressionVariantGenerator.java (líneas 41-70), splitters/DexCompressionVariantGenerator.java (41-62), splitters/SparseEncodingVariantGenerator.java (37-44), splitters/SigningConfigurationVariantGenerator.java, splitters/ApkGenerationConfiguration.java (81-92), optimizations/ApkOptimizations.java (120-134 y 173-193), optimizations/OptimizationsMerger.java (132-151), io/ApkPathManager.java (123-140), commands/BuildApksCommand.java (1578-1584) y src/main/proto/config.proto (279-290). Consultado el 18 de octubre de 2026. De aquí salen los umbrales de las variantes, las condiciones de la variante dispersa (BuildApksManager.java, líneas 334-339) y el origen de los sufijos _2 y _3 («sección 3.1 · Qué es»), que BundleConfig pueda desactivar la inyección del minSdk y la codificación dispersa (OptimizationsMerger.java; «sección 3.1 · Qué es»), y que el universal y los standalone solo funden los módulos con dist:fusing include="true" salvo que --modules diga otra cosa o que BundleConfig pida SEPARATE_FEATURE_MODULES (BuildApksManager.java, líneas 158-168, 235-240 y 403-415; config.proto; secciones «4.2» y «7»). Consultado de nuevo el mismo día: de aquí salen también que los APK de standalones/ solo se generan si el minSdk del base es menor que 21 y para dispositivos con API < 21 (BuildApksManager.java, líneas 453-456 y 584-599, con ANDROID_L_API_VERSION = 21 en model/utils/Versions.java; secciones «3.1» y «4.2»), y el reparto de variantes del fixture de la «sección 3.1 · Qué es»: cada umbral se recorta al rango de API de la aplicación (splitters/PerModuleVariantTargetingGenerator.java, líneas 51-79; model/targeting/TargetingUtils.java, líneas 158-165, 173-185 y 193-216), las variantes se ordenan por su API mínima (model/VariantKey.java, líneas 53-62; model/targeting/TargetingComparators.java, líneas 83-84) y en ese orden reciben número y nombre de fichero (io/ApkSerializerManager.java, líneas 257-288).
  12. bundletool 1.18.3 — conversión de proto a binario, commit 586a43a — https://github.com/google/bundletool/blob/586a43a450712a1067f3d92cf7574dee68226302/src/main/java/com/android/tools/build/bundletool/io/Aapt2ResourceConverter.java con androidtools/Aapt2Command.java (líneas 43-68) e io/ApkSerializerHelper.java (105-109). Consultado el 18 de octubre de 2026. De aquí sale que manifiesto, resources.pb y res/ se convierten en una sola llamada a aapt2 convert (convertResourcesToBinary, líneas 120-166; «sección 2.2 · Por qué protobuf y no los formatos binarios del APK»).
  13. BUNDLE-METADATA/: bundletool y Android Gradle Plugin — https://github.com/google/bundletool/blob/586a43a450712a1067f3d92cf7574dee68226302/src/main/java/com/android/tools/build/bundletool/model/BundleMetadata.java (líneas 38-45) y https://android.googlesource.com/platform/tools/base/+/refs/heads/mirror-goog-studio-main/build-system/gradle-core/src/main/java/com/android/build/gradle/internal/tasks/PackageBundleTask.kt (líneas 356-386), con APP_METADATA_FILE_NAME en IncrementalPackager.java de la misma rama. Consultado el 18 de octubre de 2026. De aquí salen las rutas de proguard.map, dependencies.pb y app-metadata.properties de la «sección 2.1 · Estructura interna».
  14. bundletool 1.18.3 — <meta-data> inyectados y sintaxis de entrega, commit 586a43a — https://github.com/google/bundletool/blob/586a43a450712a1067f3d92cf7574dee68226302/src/main/java/com/android/tools/build/bundletool/model/utils/SplitsXmlInjector.java (líneas 38-48), con model/ManifestEditor.java (295-324), model/AndroidManifest.java (266-276 y 658-685) y mergers/ModuleSplitsToShardMerger.java (170-175). Consultado el 18 de octubre de 2026, con una búsqueda en todo el código de com.android.vending.derived.apk.id, sin resultado. De aquí salen las claves com.android.vending.splits, com.android.vending.splits.required y com.android.dynamic.apk.fused.modules y la convivencia de dist:onDemand con <dist:delivery> («sección 4.2 · Los atributos del manifiesto»).
  15. Play Feature Delivery — Android Developers — https://developer.android.com/guide/playcore/feature-delivery y https://developer.android.com/guide/playcore/feature-delivery/on-demand Consultado el 18 de octubre de 2026; las dos páginas se actualizaron el 16 de octubre. De aquí salen el alcance de <dist:fusing dist:include> —los multi-APK para Android 4.4 (API 20) o anteriores y el universal de bundletool— y la sintaxis <dist:delivery><dist:on-demand/> de la «sección 4.2 · Los atributos del manifiesto».
  16. Multiple APK Support in Android Market — Android Developers Blog — https://android-developers.googleblog.com/2011/07/multiple-apk-support-in-android-market.html Publicado el 21 de julio de 2011. Consultado el 18 de octubre de 2026. De aquí sale que hasta entonces cada ficha de Android Market llevaba un solo APK universal y que desde esa fecha admite varios APK completos por ficha («sección 1 · Por qué existen los splits»).
  17. Multiple APK support — Android Developers — https://developer.android.com/google/play/publishing/multiple-apks Consultado el 18 de octubre de 2026 (actualizada el 21 de julio de 2025). De aquí sale que en el multiple APK cada APK lo construye, lo firma y lo gestiona el desarrollador («sección 1 · Por qué existen los splits»).
  18. PackageInstaller — referencia de la API de Android — https://developer.android.com/reference/android/content/pm/PackageInstaller Consultado el 18 de octubre de 2026 (actualizada el 3 de agosto de 2026). De aquí sale que la clase existe desde el nivel de API 21 e instala aplicaciones en un solo APK o repartidas en varios split APK («sección 1 · Por qué existen los splits»).