AAB, splits y contenedores
Antes conviene leer «Contenedor ZIP», «XML binario (AXML)», «Tabla de recursos»
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
.apkmde APKMirror de Google Keep, 5.26.411.03.97 (27 piezas). - El
.xapkde APKPure de Telegram 13.1.0 (3 piezas). - El
.apksuelto de Netflix 9.88.0 confused.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.xmlno está en la raíz del módulo, sino en<módulo>/manifest/.- Los
.dexno están en la raíz, sino en<módulo>/dex/. - No hay
resources.arsc, hayresources.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. hasCodeno basta. Para saber si un módulo tiene código hay que mirar si traeDEX. Hay 30 módulos que declaranhasCode=falsey aun así lo llevan.- Asset packs. Todos llevan
<dist:delivery>con<dist:install-time/>, y ninguno llevaDEXniresources.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>, sinDEXy sinresources.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
.apkmde WhatsApp son módulos de idioma.
Ejemplos reales de cada tipo raro:
- Asset pack de Unity, 1,18 GB:
com.olzhas.carparking.multyplayer4.9.11 (.apkmde APKMirror), piezasplit_UnityDataAssetPack.apk. - Split de textura:
com.moonfrog.ludo.club2.6.65, piezasplit_UnityDataAssetPack.config.astc.apk. - Split de país:
com.mobile.legends2.2.16.12322, piezasplit_PlayAssetPack.config.countries_id.apk. - Asset pack de 391,5 MB en una carpeta de
adb:com.dmluh.lesmqxd, piezasplit_quandui.apk. - Módulo con
hasCode=falsey unDEX:com.zhiliaoapp.musically(TikTok) 47.4.16, piezasplit_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.
package, el nombre del paquete. Idéntico en todos.android:versionCode. Idéntico en todos. En el.apkmde Keep,220679628en el base y en cada uno de los 26 config splits (27 piezas, un solo certificado).- La firma. Todos los splits tienen que estar firmados con la misma clave, porque
PackageManagerlos 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 aapksignerelminSdkde 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,
apksignerverifica 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 badginglo muestra vacío.minSdkVersionen 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 sinminSdkVersion.minSdkVersionen 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
.sosin 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 4falla en 22 de 962 splits de.apkm, en 0 de 64 de.xapk, y en el sorteo en 25 de 282 carpetas deadby 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 salvoAPKM_installer.url, y en 2 (com.lemon.lvoverseasycom.telcel.contenedor) tampocoicon.png. El descriptor con la firmaPK\x07\x08se lee en los 460 contenedores.- Cabecera local rellena pese al bit. Ninguna entrada en los
.apkmy 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
.xapkde Sweet Selfie, de APKCombo, con la cabecera local rellena (20 entradas). - El
.xapkde Telegram 13.1.0: bit 3 en todas las entradas. - El
.apkmde Keep de la «sección 4.3 · Lo que todos los splits comparten obligatoriamente»: bit 3 en todas las entradas salvoAPKM_installer.url. - Un
APKsuelto 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
APKcompleto y unsplitsuelto.
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 clavesxapk_version,package_name,name,version_code,version_name,min_sdk_version,permissions,iconysplit_apksestán en los 72. Están en 71split_configs,total_sizeytarget_sdk_version, y en 35locales_name.xapk_versiones el número 2 en 70 y la cadena «2» en 2.- Los ficheros.
split_apkscoincide con los.apkpresentes en los 72, y el base se llama<paquete>.apken los 72. De los splits, 367 se llamanconfig.*y 11 son módulos o asset packs.icon.pngestá 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
APKpor.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.ª esobb_files. Las 17 sonaccent_color,apk_id,apk_title,apkm_version,app_name,arches,capabilities,dpis,languages,min_api,pname,post_date,release_id,release_title,release_version,variantyversioncode.apkm_versionvale 5 en los 388, ypnamecoincide con el paquete de la base en los 388.- Contenido.
base.apk,icon.pngyAPKM_installer.urlestá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.SFyAPKMIRRO.RSAestán en los 388, con un único certificado:CN=APKMirror.com, válido hasta 2119-06-30 (SHA-256 del certificado7b1a6d25e5e8711a6e79283df10c648b47a420c4e5413c2c51351a8ca508de25).
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, siemprexxhdpi. De idioma, nada,en, oenyes. Solo 21 carpetas traen módulos. - Nombres. Todas las piezas son
base.apkosplit_<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.pbcon el manifiesto enbase/manifest/, el.aab;info.jsoncon firma propia, el.apkm;xapk_version, el.xapk;meta.sai_v1.jsonometa.sai_v2.json, el.apksexportado por SAI;- varias entradas
*.apksin metadatos niAndroidManifest.xmlen la raíz, el ZIP plano; - y
AndroidManifest.xmlen la raíz, elAPKsuelto.
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
.apkmy 72.xapk). .apksueltos. 0 desajustes en 6.220: todos tienenAndroidManifest.xmlen la raíz.- Carpetas de
adb. 0 desajustes en 365: todas las entradas son.apk. Se clasifican sintoc.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,requiredSplitTypesysplitTypes, porque el resultado ya no es un conjunto. - Renumerar los
classes*.dexde 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.apkde Firefox: la versiónarm64-v8a.Bravearm64Universal.apkde Brave: laarm64Universal, que llevafused.modules.WhatsApp.apk: unAPKú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
- 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 directorioroot/y la separación demanifest/ydex/, con las citas literales. 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 deBuildApksResultde la «sección 3.2 · toc.pb: BuildApksResult» y la jerarquíaVariant→ApkSet→ApkDescriptioncon sus siete metadatos alternativos. Consultado de nuevo el 18 de octubre de 2026 en el commit586a43a(bundletool1.18.3): de aquí salen tambiénvariant_number,variant_properties(líneas 78-108), la prioridad entre variantes ysigning_description, campo 10 deApkDescription(líneas 245-275), todo en la «sección 3.2 · toc.pb: BuildApksResult».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 deBundleConfigy los valores deBundleTypede la «sección 2.3 · Los .proto relevantes».google/bundletool,src/main/proto/targeting.protoyfiles.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.protode la «sección 2.3 · Los .proto relevantes». Consultado de nuevo el 18 de octubre de 2026 en el commit586a43a: de aquí saleVariantTargetingcon susdk_version_targeting(líneas 10-17) de la «sección 3.1 · Qué es».frameworks/base/tools/aapt2/Resources.proto(etiquetaandroid-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=TEXTy decodificado. De aquí salen el paqueteaapt.pb, eljava_packagecom.android.aapty la jerarquíaResourceTable→Package→Type→Entry→ConfigValuede la «sección 2.3 · Los .proto relevantes».- 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-specyget-size totalde 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 conbundletooly la nota de que el universal solo incluye los módulos con<dist:fusing dist:include="true"/>(secciones «4.2» y «7»). - adb — documentación oficial — https://developer.android.com/tools/adb
Consultado el 12 de agosto de 2026. De aquí sale
adb install-multiplede 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. - 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».
services/core/java/com/android/server/pm/PackageInstallerSession.java(etiquetaandroid-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 queisSplitRequiredhace fallar la instalación conINSTALL_FAILED_MISSING_SPLIT(«sección 4.2 · Los atributos del manifiesto»).- 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 sinresources.arsc(«sección 6 · Detección por estructura, nunca por extensión»). - 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) ysrc/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_2y_3(«sección 3.1 · Qué es»), queBundleConfigpueda desactivar la inyección delminSdky la codificación dispersa (OptimizationsMerger.java; «sección 3.1 · Qué es»), y que el universal y los standalone solo funden los módulos condist:fusing include="true"salvo que--modulesdiga otra cosa o queBundleConfigpidaSEPARATE_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 destandalones/solo se generan si elminSdkdel base es menor que 21 y para dispositivos con API < 21 (BuildApksManager.java, líneas 453-456 y 584-599, conANDROID_L_API_VERSION = 21enmodel/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). - 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 conandroidtools/Aapt2Command.java(líneas 43-68) eio/ApkSerializerHelper.java(105-109). Consultado el 18 de octubre de 2026. De aquí sale que manifiesto,resources.pbyres/se convierten en una sola llamada aaapt2 convert(convertResourcesToBinary, líneas 120-166; «sección 2.2 · Por qué protobuf y no los formatos binarios del APK»). 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), conAPP_METADATA_FILE_NAMEenIncrementalPackager.javade la misma rama. Consultado el 18 de octubre de 2026. De aquí salen las rutas deproguard.map,dependencies.pbyapp-metadata.propertiesde la «sección 2.1 · Estructura interna».- bundletool 1.18.3 —
<meta-data>inyectados y sintaxis de entrega, commit586a43a— https://github.com/google/bundletool/blob/586a43a450712a1067f3d92cf7574dee68226302/src/main/java/com/android/tools/build/bundletool/model/utils/SplitsXmlInjector.java (líneas 38-48), conmodel/ManifestEditor.java(295-324),model/AndroidManifest.java(266-276 y 658-685) ymergers/ModuleSplitsToShardMerger.java(170-175). Consultado el 18 de octubre de 2026, con una búsqueda en todo el código decom.android.vending.derived.apk.id, sin resultado. De aquí salen las clavescom.android.vending.splits,com.android.vending.splits.requiredycom.android.dynamic.apk.fused.modulesy la convivencia dedist:onDemandcon<dist:delivery>(«sección 4.2 · Los atributos del manifiesto»). - 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 debundletool— y la sintaxis<dist:delivery><dist:on-demand/>de la «sección 4.2 · Los atributos del manifiesto». - 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
APKuniversal y que desde esa fecha admite variosAPKcompletos por ficha («sección 1 · Por qué existen los splits»). - 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
APKlo construye, lo firma y lo gestiona el desarrollador («sección 1 · Por qué existen los splits»). 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 soloAPKo repartidas en variossplit APK(«sección 1 · Por qué existen los splits»).