La tabla de recursos: resources.arsc
Antes conviene leer «XML binario (AXML)», «Contenedor ZIP»
Todos los enteros de este documento son little-endian, con dos excepciones que se señalan
en su fila: los campos language y country de ResTable_config, cuya disposición es
big-endian con independencia de la arquitectura.
Este documento no repite el sustrato de chunks ni el formato del string pool: viven en
«XML binario (AXML)», secciones «2» y «3», y son literalmente las mismas
estructuras binarias.
1. Qué problema resuelve
Una aplicación tiene un botón que dice «Guardar». En español dice «Guardar», en alemán «Speichern», en japonés «保存». Su icono existe en cinco densidades de pantalla. Su margen es uno en teléfono y otro en tableta. Y el código, que está compilado, tiene que referirse a todo eso con un solo número que no cambie nunca.
Ese número es el resource ID, un uint32_t con la forma 0xPPTTEEEE. R.string.save no es
una cadena: es la constante 0x7f120075 que el compilador incrustó en el DEX. Y
resources.arsc es la tabla que, en tiempo de ejecución y para la configuración concreta del
dispositivo, convierte ese número en el valor que toca.
resources.arsc
│
R.string.app_name_basic ─────►│ 0x7f110046
(0x7f110046) │ ├── () → "F-Droid Basic"
│ ├── (ca) → "F-Droid Bàsic"
│ ├── (fa) → "افدروید پایه"
│ └── (ga) → "F-Droid Bunúsach"
│
configuración del ────────┘
dispositivo
El diagrama enseña cuatro de los 46 valores de un recurso real: string/app_name_basic de
F-Droid 2.0.2 (org.fdroid.fdroid 2000052), tal y como lo
imprime aapt2 dump resources. aapt2 es la herramienta de Android que compila y vuelca los
recursos. En ese fichero el tipo string tiene 46 variantes de configuración: la de por
defecto y 45 idiomas, sin variantes por versión de API. La tabla entera tiene 80 configuraciones
distintas.
La alternativa sería resolver por nombre en tiempo de ejecución con un mapa de cadenas por idioma: más lento, más grande, y sin comprobación en compilación de que el recurso existe. La tabla paga ese precio por adelantado a cambio de un índice binario, mapeable, con búsqueda por número y filtrado por configuración.
Y es también la estructura que más cuesta escribir. Para leerla basta con recorrer sus chunks; para editarla —fusionar splits, renombrar entradas— hay que reconstruir pools y offsets (secciones «4» y «7») sin perder nada de lo que no se entiende («sección 13 · Qué entender y qué conservar en crudo»). Ese es el motivo de que este sea uno de los documentos más largos de esta documentación.
Un split es cada trozo en que Google Play reparte una app (por idioma, densidad de pantalla,
procesador o funcionalidad), y el base.apk es el trozo principal. Para repetir las medidas:
MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/recursos_1.py --salida <fichero.json>.
2. El árbol de chunks
Todo el fichero es un solo chunk RES_TABLE_TYPE con un árbol dentro:
RES_TABLE_TYPE (0x0002) ── el fichero entero
│
├── RES_STRING_POOL_TYPE (0x0001) pool global de valores
├── RES_TABLE_FLAG_LIST (0x0208) opcional, ver 12.5
│
├── RES_TABLE_PACKAGE_TYPE (0x0200) uno por paquete
│ ├── RES_STRING_POOL_TYPE typeStrings: "anim", "drawable", "string"…
│ ├── RES_STRING_POOL_TYPE keyStrings: "app_name", "abc_fade_in"…
│ │
│ ├── RES_TABLE_TYPE_SPEC_TYPE (0x0202) tipo 1: qué ejes hacen variar cada entrada
│ ├── RES_TABLE_FLAGGED (0x0207) opcional, ver 12.5
│ │ └── RES_TABLE_TYPE_TYPE (0x0201) valores tras un flag de lectura/escritura
│ ├── RES_TABLE_TYPE_TYPE (0x0201) tipo 1, configuración por defecto
│ ├── RES_TABLE_TYPE_TYPE (0x0201) tipo 1, configuración "es"
│ ├── RES_TABLE_TYPE_TYPE (0x0201) tipo 1, configuración "xhdpi"
│ ├── RES_TABLE_TYPE_SPEC_TYPE (0x0202) tipo 2
│ ├── RES_TABLE_TYPE_TYPE (0x0201) tipo 2, …
│ │ …
│ ├── RES_TABLE_LIBRARY_TYPE (0x0203) opcional
│ ├── RES_TABLE_OVERLAYABLE_TYPE (0x0204) opcional
│ │ └── RES_TABLE_OVERLAYABLE_POLICY_TYPE (0x0205)
│ └── RES_TABLE_STAGED_ALIAS_TYPE (0x0206) opcional
│
└── RES_TABLE_PACKAGE_TYPE (0x0200) siguiente paquete, si lo hay
Tres reglas de orden que AOSP sí impone y conviene tener presentes:
- Un
RES_TABLE_TYPE_TYPEtiene que venir después delRES_TABLE_TYPE_SPEC_TYPEde su mismoid.LoadedArsc.cppaborta conRES_TABLE_TYPE_TYPE with ID %02x found without preceding RES_TABLE_TYPE_SPEC_TYPE. - Si aparecen dos
RES_TABLE_TYPE_SPEC_TYPEcon el mismoid, el segundo se ignora con un aviso. - Con el flag de plataforma
resource_readwrite_flagsactivo («sección 12.5 · RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)»), elRES_TABLE_FLAG_LISTtiene que ir antes de los paquetes: cadaRES_TABLE_PACKAGE_TYPEse carga con la lista de flags leída hasta ese momento, y unRES_TABLE_FLAGGEDcuyo flag no esté en ella hace fallar la carga del paquete, y con ella la de la tabla, conRES_TABLE_FLAGGED sections contains flag with index %d not in RES_TABLE_FLAG_LIST.(LoadedArsc.cpp, líneas 942-998 y 678-685 enandroid-17.0.0_r1).
Fuera de eso, el orden es el que quiera el escritor. El resto de lo que LoadedArsc rechaza o
deja pasar —cabeceras cortas, más de 65.535 entradas, entradas desalineadas, dispersas
desordenadas—, con su mensaje y su línea, está en la «sección 9 de
Qué rechaza cada lector · LoadedArsc y AttributeResolution: los recursos».
3. RES_TABLE_TYPE / ResTable_header
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
header |
0x00 |
8 | ResChunk_header |
type = RES_TABLE_TYPE = 0x0002; size es el fichero entero |
packageCount |
0x08 |
4 | uint32_t |
Número de chunks ResTable_package que siguen |
headerSize, el campo que dice cuánto mide la cabecera del chunk, vale 12 en las 13.651 piezas con
resources.arsc del «muestrario», sin ninguna excepción. En
las cinco apps de protectores también vale 12.
Casi todos los APK tienen un solo paquete, packageCount = 1. Un paquete es un bloque de recursos
con su propio número (el PP de la «sección 11 · La estructura del resource ID: 0xPPTTEEEE»). Lo tienen 4.764 de las 4.766 piezas de F-Droid,
6.531 de 6.677 de Google Play (las más instaladas, el 98 %) y prácticamente todas las demás. El máximo
es de 24 paquetes, en dos piezas: com.android.bankabc 102 (mercado chino) y el base.apk de
Likee (video.like 5.66.0, de APKMirror). En F-Droid lo más alto son 6 paquetes, en MyExpenses
(org.totschnig.myexpenses 887), por sus módulos de funcionalidad («sección 12.1 · RES_TABLE_LIBRARY_TYPE (0x0203)»).
Ojo con un caso límite antes de escribir la primera línea de código: packageCount = 0 es
válido. 22 piezas del muestrario traen un resources.arsc de 40 bytes
exactos: los 12 de ResTable_header más los 28 de un RES_STRING_POOL_TYPE vacío, y ningún
paquete. Son 14 módulos de funcionalidad (trozos de la app que Play instala solo cuando hacen
falta), 7 splits de densidad de un módulo de id.dana y un APK completo; de 10 apps en total, con
21 piezas de Google Play y 1 de IzzyOnDroid. Dos ejemplos: split_dfm_ug.apk del módulo de funcionalidad de Kwai
(com.kwai.bulldog 13.9.10) y el APK completo de IzzyOnDroid
com.programminghoch10.AntiBrightnessChange (60). Es la tabla de recursos mínima
válida, y un lector que dé por supuesto que hay al menos un paquete falla con ella.
3.1 No todas las piezas llevan tabla de recursos
Los APK completos y los base.apk siempre la llevan, en todos los orígenes. Los splits de
densidad y de idioma casi siempre también (en Google Play, 1.522 de 1.522 de densidad y 4.406 de
4.412 de idioma). Los splits de procesador (ABI) nunca la llevan: 0 de 1.026 en Google Play y 0 de 285 en
el sorteo. Los asset packs (paquetes de recursos grandes, como las texturas de un juego) tampoco: 0 de 82 en
Google Play y 0 de 20 en el sorteo. Los módulos de funcionalidad, solo la mitad: 91 de 186 en Google Play y
0 de 4 en el sorteo. Un análisis que espere una tabla en cada pieza falla con los splits de ABI y con los asset packs.
En todo el muestrario, 13.656 piezas llevan tabla y 1.527 no (15.183 piezas).
3.2 Cómo se guarda en el ZIP
Desde targetSdkVersion 30 (Android 11), resources.arsc tiene que ir sin comprimir y con los
datos alineados a 4 bytes; si no, el APK no se instala. Casi todo el muestrario lo cumple: en la
pieza base o única de cada app, fallan solo seis apps de F-Droid y una en cada una de IzzyOnDroid,
Google Play y el mercado chino. Con targetSdk 30 o más y la tabla comprimida o sin alinear solo falla 1 de
las 4.109 apps de F-Droid: dudeofx.eval (102). Con targetSdk menor que 30, donde la regla no
obliga, hay 5 de 657 en F-Droid, 1 de 107 en IzzyOnDroid, 1 de 7 en Google Play y 1 de 3 en el mercado chino;
por ejemplo GO Launcher Themes & Wallpapers 7.31 (de APKPure; targetSdk 22, método deflate) y
com.lufax.android 8290100 (mercado chino, targetSdk 27, deflate). La regla completa está en
«Contenedor ZIP → §10.1 · resources.arsc sin comprimir y alineado a 4 bytes».
4. El string pool global
Justo detrás de la cabecera viene un RES_STRING_POOL_TYPE. Su formato es exactamente el
descrito en «XML binario, sección 3»,
con las dos codificaciones (UTF-8 y UTF-16, dos formas de guardar texto) y el doble campo de
longitud en UTF-8.
Este pool suele ser el mayor de la tabla. «Mayor» se mide aquí por número de cadenas. En
F-Droid 2.0.2 (org.fdroid.fdroid 2000052) tiene 20.646 cadenas y ocupa 1.035.008
bytes, la mitad (49,6 %) de los 2.087.752 de la tabla. Tiene más cadenas que cualquier otro pool de
la tabla, incluido el del manifiesto, en cuatro de cada cinco apps de F-Droid (3.914 de 4.766) y de
IzzyOnDroid (1.177 de 1.402), en algo más de la mitad de las de Google Play (378 de 658), en 131 de
369 del sorteo y en 40 de 100 del mercado chino. No siempre: en las apps con pocos textos, el pool de
claves o el del manifiesto pueden ser mayores. En F-Droid las excepciones son 852: el de claves tiene
más cadenas en 637 y el del manifiesto en 211. La mediana de cadenas del pool global es 4.180 en
F-Droid, 5.790 en IzzyOnDroid, 11.801 en Google Play, 1.506 en el sorteo y 12.861 en el mercado chino. El
mayor del muestrario es el de Samsung Health 7.1 (de APKMirror), con 1.069.577 cadenas y una tabla
de 179,0 MB. En F-Droid es el del teclado com.wasimaster.wmkeyboard (33), con 479.728 cadenas y una
tabla de 63,2 MB.
Contiene los valores de tipo cadena de toda la tabla: los textos traducidos y las rutas de
fichero de los recursos (res/layout/main.xml, res/vp1.xml). No contiene los nombres de
los tipos ni los de las entradas: esos viven en dos pools propios de cada paquete («sección 5 · ResTable_package»).
Un Res_value de tipo TYPE_STRING dentro de una entrada indexa este pool, no el del
paquete. Es un error frecuente al implementar.
En casi todas las tablas el pool global está en UTF-8: el 99 % de las de F-Droid (4.723 de 4.766) y
todas o casi todas las de los demás orígenes. Cada paquete trae otros dos pools («sección 5 · ResTable_package»):
typeStrings en UTF-16 y keyStrings en UTF-8. Así ocurre en 4.647 de las 4.764 tablas de un
paquete de F-Droid, en 1.384 de 1.401 de IzzyOnDroid y en 6.526 de 6.531 de Google Play. Los estilos
(negrita, cursiva) van en el pool global: lo llevan 792 de las 4.766 tablas de F-Droid (alrededor de
una de cada seis) y 1.992 de las 6.656 de Google Play (casi una de cada tres).
Un ejemplo normal es F-Droid 2.0.2: pool global en UTF-8, typeStrings en UTF-16 (20 cadenas, 400
bytes) y keyStrings en UTF-8 (4.809 cadenas). Una excepción es com.github.howeyc.crocgui (48, de
F-Droid), hecho con la herramienta de gomobile/Fyne: su pool global está en UTF-16.
net.ser1.forage (43) es igual.
5. ResTable_package
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
header |
0x00 |
8 | ResChunk_header |
type = RES_TABLE_PACKAGE_TYPE = 0x0200 |
id |
0x08 |
4 | uint32_t |
El PP del resource ID. 0 significa paquete dinámico: el runtime le asigna un ID al cargarlo |
name |
0x0c |
256 | uint16_t[128] |
Nombre del paquete en UTF-16, terminado en \0 y rellenado con ceros |
typeStrings |
0x10c |
4 | uint32_t |
Offset desde el inicio de este chunk al pool de nombres de tipo |
lastPublicType |
0x110 |
4 | uint32_t |
Campo heredado. aapt2 lo deja a 0; el aapt antiguo escribe el número de tipos del paquete. Ver debajo de la tabla |
keyStrings |
0x114 |
4 | uint32_t |
Offset desde el inicio de este chunk al pool de nombres de entrada |
lastPublicKey |
0x118 |
4 | uint32_t |
Campo heredado. aapt2 lo deja a 0; el aapt antiguo escribe el número de claves del paquete. Ver debajo de la tabla |
typeIdOffset |
0x11c |
4 | uint32_t |
Desplazamiento a sumar a los id de tipo («sección 11 · La estructura del resource ID: 0xPPTTEEEE»). 0 en todos los paquetes del muestrario |
headerSize vale 288 (0x120), que es exactamente sizeof(ResTable_package), en 13.901 paquetes.
En 9 paquetes de 5 piezas vale 284, la cabecera sin typeIdOffset de los productores anteriores a
ese campo: por ejemplo uk.org.boddie.android.weatherforecast (173, de F-Droid).
LoadedArsc.cpp acepta las dos y solo lee typeIdOffset si headerSize ≥ 288. En las 13.629
tablas con paquete del muestrario, typeStrings vale justo lo que mide la cabecera (0x120 con
288, 0x11c con 284): el pool de tipos empieza inmediatamente después de la cabecera.
lastPublicType y lastPublicKey dicen hasta qué índice llegan los nombres «públicos». En la
práctica no sirven para eso. El compilador moderno (aapt2) los deja a 0. El antiguo (aapt)
escribe el número total de tipos y de claves del paquete: lastPublicType es el número de
typeSpec en 153 de los 166 paquetes donde no vale 0, y lastPublicKey es el número de claves
en 162 de 167. Por pieza, lastPublicType es distinto de cero en 117 de 4.766 de F-Droid (en torno al
2,5 %), 18 de 1.401 de IzzyOnDroid, 3 de 6.656 de Google Play, 10 de 100 del mercado chino y ninguna
del sorteo ni de las webs de los autores. lastPublicKey lo es en las mismas piezas, salvo 4 de
Google Play. Las 148 piezas con lastPublicType distinto de cero (sin las de protectores) llevan
typesCount = 0 en todos sus typeSpec («sección 6 · ResTable_typeSpec»). Dos ejemplos: com.github.howeyc.crocgui (48),
con lastPublicType 2 (dos tipos: attr y mipmap) y lastPublicKey 1 (una clave, icon) en una
tabla de 616 bytes; y com.cgogolin.penandpdf (67, de IzzyOnDroid), con 15 y 1329, que coinciden
con las 15 cadenas de typeStrings y las 1329 de keyStrings. La excepción es com.android.bankabc
(102): en su paquete 0x22, lastPublicKey vale 117 y hay 221 claves. typeIdOffset vale 0 en
todos los paquetes del muestrario.
Los dos pools propios de cada paquete son la razón de que resolver un recurso por nombre exija tres pools distintos:
| Pool | Contiene | Indexado por |
|---|---|---|
| Global («sección 4 · El string pool global») | Valores de tipo cadena y rutas de fichero | Res_value.data cuando dataType = TYPE_STRING |
typeStrings |
"anim", "attr", "drawable", "string", "style"… |
ResTable_type.id - 1 y ResTable_typeSpec.id - 1 |
keyStrings |
"app_name", "abc_fade_in", "actionBarDivider"… |
ResTable_entry.key |
Los índices de tipo son base 1 y los pools base 0: el tipo id = 0x01 es
typeStrings[0]. id = 0 es inválido y LoadedArsc.cpp lo rechaza.
De Termux (com.termux 1022), el pool de tipos completo:
[1] anim [2] animator [3] attr [4] bool [5] color [6] dimen [7] drawable
[8] id [9] integer [10] interpolator [11] layout [12] menu [13] mipmap
[14] plurals [15] raw [16] string [17] style [18] ?18 [19] xml
El ?18 no es un error del volcador. Es la cadena literal "?18" que aapt2 escribe para
rellenar el hueco de un ID de tipo que el paquete no define. En Termux es el de styleable (o
macro), que no llegan al binario. No es el único caso: F-Droid 2.0.2 tiene 20 cadenas con dos
huecos, ?12 y ?19. En el split de densidad split_config.xhdpi.apk de VLC 3.7.2
(org.videolan.vlc, de APKMirror) solo existen drawable (id 8) y style (id 20): las otras 18 de
sus 20 cadenas salen como ?1 a ?7 y ?9 a ?19. Un lector tiene que tolerarlo.
6. ResTable_typeSpec
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
header |
0x00 |
8 | ResChunk_header |
type = RES_TABLE_TYPE_SPEC_TYPE = 0x0202 |
id |
0x08 |
1 | uint8_t |
Identificador de tipo, base 1. 0 es inválido |
res0 |
0x09 |
1 | uint8_t |
Debe ser 0 |
typesCount |
0x0a |
2 | uint16_t |
Antes reservado; si es > 0, número de ResTable_type de este tipo |
entryCount |
0x0c |
4 | uint32_t |
Número de máscaras uint32_t que siguen |
headerSize vale 16. Detrás vienen entryCount valores uint32_t, uno por entrada del tipo:
una máscara de bits de los ejes de configuración que hacen variar esa entrada, con las
constantes ResTable_config::CONFIG_* («sección 8.4 · Las banderas CONFIG_*»), más dos flags propios:
| Flag | Valor | Significado |
|---|---|---|
SPEC_PUBLIC |
0x40000000 |
La entrada es pública y otras aplicaciones pueden referenciarla |
SPEC_STAGED_API |
0x20000000 |
El resource ID de esta entrada puede cambiar en una compilación futura. Implica SPEC_PUBLIC |
Para qué sirve realmente: es el índice que dice qué se puede tirar. Si la máscara de la
entrada 5 del tipo string no tiene el bit CONFIG_LOCALE, esa entrada vale igual en todos los
idiomas y un split de idioma no necesita llevarla. bundletool no la usa para decidir qué
entra en config.es.apk: divide el resources.pb del bundle por los ConfigValue de cada
entrada, y las máscaras del typeSpec las calcula aapt2 después, al convertir cada split a
binario. Tampoco hace falta para saber si dos entradas de dos splits son la misma: en los splits de un mismo build, el mismo resource ID es la misma entrada
por construcción («Fusión de splits → §4.1 · El malentendido que hay que quitarse primero»). Lo que
un fusionador sí tiene que rehacer es la máscara. aapt2 la calcula uniendo los
ResTable_config::diff() de cada par de configuraciones de esa entrada en esa tabla
(TableFlattener.cpp, líneas 424-446 en android-17.0.0_r1), así que la de cada split solo ve
las configuraciones del propio split —es lo que enseña la receta 15.3—. Unir con OR las máscaras
de origen no basta: no recoge los ejes por los que difieren configuraciones que llegan de splits
distintos, como la () del base y la xhdpi de config.xhdpi.apk. Hay que recalcularla sobre la
tabla fusionada.
entryCount del typeSpec es el número total de entradas del tipo, que puede ser mucho
mayor que el entryCount de un ResTable_type concreto cuando este es disperso («sección 7.3 · FLAG_SPARSE y ResTable_sparseTypeEntry»).
En split_config.xhdpi.apk de VLC 3.7.2, el typeSpec del tipo 0x08 (drawable) declara
entryCount = 887. El ResTable_type de xhdpi que le sigue solo trae 72 entradas, y los otros dos
(ldrtl-xhdpi y anydpi) 1 y 34.
typesCount es el campo menos fiable de la estructura. La cabecera lo describe como «used to be
reserved» (antes reservado): los productores antiguos lo dejaban a cero y los modernos escriben el
número de ResTable_type del tipo. En el muestrario conviven los dos comportamientos, y casi
siempre dentro de una pieza es todo o nada. Vale cero en 25.717 de los 69.533 typeSpec de
F-Droid (37 %), 7.578 de 20.966 de IzzyOnDroid (36 %), 1.345 de 29.574 de Google Play (4,5 %), 719 de
7.400 del sorteo (10 %) y 1.723 de 2.044 del mercado chino (84 %). Por pieza: en F-Droid, 1.814
llevan todos a cero, 2.945 ninguno y 6 mezclan; en Google Play, 73, 6.581 y 2; en el mercado chino, 83
y 17. Es la marca de un compilador viejo (aapt, o herramientas que copian su formato), no de una
manipulación. Depende de cuándo se compiló: entre los APK únicos con targetSdk 24 o 25, 135 de 137
lo llevan a cero en todos sus typeSpec; con targetSdk 33 o más, 1.233 de 4.985 (una de cada
cuatro). Ejemplos: Termux (com.termux 1022) tiene los 18 typeSpec con typesCount = 0;
com.github.howeyc.crocgui (48) también todos; F-Droid 2.0.2 escribe el valor real, de 1 a 46 según
el tipo. Un lector no debe apoyarse en este campo —es información redundante con el recuento
efectivo de chunks—, pero un escritor que aspire al round-trip tiene que reemitir el valor que
leyó, incluido el cero.
7. ResTable_type
Es el chunk que de verdad contiene los datos: una configuración concreta y los valores de todas las entradas del tipo para esa configuración.
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
header |
0x00 |
8 | ResChunk_header |
type = RES_TABLE_TYPE_TYPE = 0x0201 |
id |
0x08 |
1 | uint8_t |
Identificador de tipo, base 1 |
flags |
0x09 |
1 | uint8_t |
FLAG_SPARSE = 0x01, FLAG_OFFSET16 = 0x02 |
reserved |
0x0a |
2 | uint16_t |
Debe ser 0 |
entryCount |
0x0c |
4 | uint32_t |
Número de entradas del array de offsets |
entriesStart |
0x10 |
4 | uint32_t |
Offset desde el inicio del chunk donde empiezan los ResTable_entry |
config |
0x14 |
var | ResTable_config |
La configuración. Debe ser siempre el último campo |
Ese «debe ser siempre el último campo» no es una recomendación: es un static_assert de
ResourceTypes.h, con el comentario «This poses a problem for extending ResTable_type in the
future, as ResTable_config is variable». En la práctica headerSize vale 84, que es
20 + 64: en casi todos los chunks ResTable_type (el 97 % en F-Droid, el 99 % en IzzyOnDroid, Google Play y
el mercado chino, todos en el sorteo y el 83 % en las webs de los autores). Baja con las
configuraciones más cortas: 76 para 56 bytes, 72 para 52, 68 para 48 y 56 para 36. Y headerSize y
config.size son campos independientes: en com.github.howeyc.crocgui (48) hay una configuración
que dice medir 52 bytes (config.size = 0x34) dentro de una cabecera de 56 (headerSize = 0x38).
En 17 piezas de ejemplo, headerSize = 20 + config.size en 2.720 de sus 2.721 chunks ResTable_type;
la excepción es esa. En todo el muestrario solo dos piezas de F-Droid tienen una configuración más
grande que su cabecera: esa y net.ser1.forage (43). Un lector no debe derivar un campo del otro:
LoadedArsc.cpp busca el array de offsets en headerSize (líneas 105, 268 y 412 en
android-17.0.0_r1) y lee la configuración según su propio config.size, hasta 64 bytes como
mucho (copyFromDeviceNoSwap, «sección 8.2 · El problema del size variable»).
La disposición completa:
+0x00 ┌──────────────────────────────────────────────────────────┐
│ ResTable_type (headerSize; en la práctica 84) │
+0x54 ├──────────────────────────────────────────────────────────┤
│ array de offsets: │
│ uint32_t[entryCount] si no hay flags │
│ uint16_t[entryCount] si FLAG_OFFSET16 │
│ ResTable_sparseTypeEntry[entryCount] si FLAG_SPARSE │
├──────────────────────────────────────────────────────────┤
│ relleno hasta múltiplo de 4 │
entriesStart ─────────────────────────────────────────────────────┤
│ ResTable_entry + Res_value o ResTable_map[] │
│ ResTable_entry + … │
│ … │
└──────────────────────────────────────────────────────────┘
entriesStart es relativo al inicio del chunk, y los offsets del array son relativos a
entriesStart. Confundir las dos bases es el segundo error más frecuente del formato, tras
el doble campo de longitud del string pool.
7.1 El array denso
Sin flags, el array son entryCount valores uint32_t. El valor NO_ENTRY = 0xFFFFFFFF
significa que esa entrada no está definida para esta configuración. De Termux (com.termux 1022),
tipo 0x04 (bool), configuración por defecto, leído con la clave
arsc.termux_tipo_bool de scripts/muestrario/cifras/ejemplos_1.py; el ResTable_type empieza en
+0x5e81c:
array de offsets (uint32_t):
[ 0] 0x00000000
[ 1] 0x00000010
[ 2] 0x00000020
[ 3] 0x00000030
entradas:
id=0x7f040000 size=8 flags=0x0000 key=1028('abc_action_bar_embed_tabs')
value: size=8 dataType=0x12 data=0xffffffff
id=0x7f040001 size=8 flags=0x0000 key=1029('abc_config_actionMenuItemAllCaps')
value: size=8 dataType=0x12 data=0xffffffff
Y el segundo ResTable_type del mismo tipo, para sw360dp (en +0x5e8c0), empieza con
NO_ENTRY y solo define la entrada 2: su array es 0xffffffff, 0xffffffff, 0x00000000, 0xffffffff.
7.2 FLAG_OFFSET16
Con FLAG_OFFSET16 = 0x02 el array es de uint16_t y el offset real es valor * 4; el valor
0xffff significa NO_ENTRY. La conversión está en una función de una línea de la cabecera:
static inline uint32_t offset_from16(uint16_t off16) {
return dtohs(off16) == 0xffffu ? ResTable_type::NO_ENTRY : dtohs(off16) * 4u;
}
Existe en ResourceTypes.h de la etiqueta android-17.0.0_r1 y aapt2 solo lo emite cuando ya está usando
entradas compactas (FLAG_COMPACT, «sección 10.2 · La entrada compacta: FLAG_COMPACT») y los offsets caben en 16 bits.
No lo hemos visto ni una sola vez en el muestrario: 0 de 1.179.780 chunks ResTable_type, en
las 13.651 piezas con resources.arsc (tampoco en las cinco de protectores).
7.3 FLAG_SPARSE y ResTable_sparseTypeEntry
Con FLAG_SPARSE = 0x01, entryCount deja de ser el número total de entradas del tipo y pasa
a ser el número de entradas realmente definidas. El array es de
ResTable_sparseTypeEntry, un uint32_t con dos mitades:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
idx |
0x00 |
2 | uint16_t |
Índice de la entrada (EEEE del resource ID) |
offset |
0x02 |
2 | uint16_t |
Offset desde entriesStart, dividido por 4 |
Las entradas están ordenadas por idx y AOSP hace std::lower_bound sobre ellas. Un
escritor que no las ordene produce un fichero que se lee mal sin dar error.
Es la variante que ahorra espacio cuando un split de configuración define pocas entradas de
un tipo con muchas. Del split config.xhdpi.apk de VLC 3.7.2:
+0x002750 RES_TABLE_TYPE_SPEC_TYPE headerSize=16 size=3564 id=0x08 typesCount=3 entryCount=887
+0x00353c RES_TABLE_TYPE_TYPE headerSize=84 size=1524 id=0x08 flags=0x01[FLAG_SPARSE]
entryCount=72 entriesStart=0x174 config.size=64
array de offsets (ResTable_sparseTypeEntry):
[ 0] raw=0x0000004b → idx=75 offset=0x0
[ 1] raw=0x00040050 → idx=80 offset=0x10
[ 2] raw=0x00080051 → idx=81 offset=0x20
[ 3] raw=0x000c0056 → idx=86 offset=0x30
0x00040050: la mitad baja 0x0050 = 80 es el índice, la alta 0x0004 × 4 = 0x10 es el
offset. El chunk ocupa 1.524 bytes en vez de los 887 × 4 = 3.548 que costaría solo el array
denso. (Los valores raw salen de la clave arsc.vlc_xhdpi_disperso de scripts/muestrario/cifras/ejemplos_1.py.)
Cuándo lo emite aapt2. De TableFlattener.cpp, cuatro condiciones simultáneas: que se
haya pedido con --enable-sparse-encoding (o, en aapt2 convert, con --force-sparse-encoding);
que minSdkVersion >= 32 (SDK_S_V2) o que no haya minSdk en el contexto y la codificación
sea forzada; que los offsets quepan en 16 bits, porque ResTable_sparseTypeEntry.offset es un
uint16_t que guarda el offset dividido entre 4 (values_buffer.size() / 4 < 65535, o sea
menos de unos 256 KiB de valores en el tipo); y que la proporción de entradas definidas esté por
debajo de kSparseEncodingThreshold = 60, o sea que menos del 60 % de las entradas del tipo
estén presentes. En el ejemplo, 72 de 887 es el 8,1 %: por debajo del umbral.
El comentario de ResourceTypes.h dice que la codificación dispersa «solo está disponible en
plataformas ≥ O» —API 26— y recomienda marcar esos tipos con el calificador v26. aapt2
exige 32 por defecto. La diferencia importa a quien fusione splits: reemitir como disperso un
tipo que venía denso, en una aplicación que admita versiones anteriores a Android 8, rompe en
ellas la resolución de recursos. El ResTable de Android 7.1 no conoce FLAG_SPARSE: compara el
entryCount de cada ResTable_type con el de su typeSpec —en un tipo disperso no coinciden—,
deja la tabla en error con ResTable_type entry count inconsistent y, desde ahí, toda consulta
de un recurso devuelve ese error (ResourceTypes.cpp, líneas 6370-6373 y 3992-3994 en
android-7.1.2_r36).
En el muestrario, ninguna aplicación con tipos dispersos admite versiones anteriores a Android 8
(API 26). De las 1.713 piezas con dispersos, 1.683 tienen minSdkVersion 32, que es lo que exige
aapt2 por defecto; 1 tiene 26, 1 tiene 34 y 28 tienen 36. La única con un minSdkVersion menor
que 32 es Baidu Search (com.baidu.searchbox 513934592, del mercado chino): su minSdkVersion es
26, justo el umbral del comentario de ResourceTypes.h.
La codificación dispersa aparece sobre todo en piezas de Google Play y en un caso chino. Tienen
algún tipo disperso 1.638 de las 6.656 piezas de Google Play (las más instaladas): una de cada
cuatro. En el sorteo, 74 de 961 (8 %); en el mercado chino, 1 de 100; en F-Droid, IzzyOnDroid y las
webs de los autores, ninguna. En Google Play, por papel de la pieza: únicas 1 de 204, bases 99 de 454
(22 %), splits de configuración 1.533 de 5.921 (26 %) y módulos 5 de 77. Por formato, apps con alguna
pieza dispersa: .apk 1 de 202, .apkm 90 de 388 (23 %) y .xapk 9 de 68 (13 %).
No es una marca de «viene de Play». El split_config.xhdpi.apk de Keep 5.26
(com.google.android.keep, de APKMirror) viene de Play y es denso (flags = 0x00). Tampoco
F-Droid 2.0.2 tiene dispersos: 0 en sus 159 ResTable_type. Es una marca de que se compiló con la
opción de codificación dispersa, que en la práctica es lo que hacen las variantes de bundletool
para la API 32 o más. El caso chino es Baidu Search, con 45 chunks dispersos.
8. ResTable_config
La estructura que describe una configuración de dispositivo. Es la más grande, la que más ha cambiado con las versiones de Android y la que rompe los parsers ingenuos.
8.1 La tabla completa
Offsets relativos al inicio de la estructura, con sizeof(ResTable_config) = 64 en la etiqueta
android-17.0.0_r1:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
size |
0x00 |
4 | uint32_t |
Tamaño de esta estructura. Ver 8.2 |
mcc |
0x04 |
2 | uint16_t |
Mobile country code de la SIM. 0 = cualquiera |
mnc |
0x06 |
2 | uint16_t |
Mobile network code. 0 = cualquiera |
language |
0x08 |
2 | char[2] |
Código de idioma. Big-endian. Ver 8.3 |
country |
0x0a |
2 | char[2] |
Código de región. Big-endian. Ver 8.3 |
orientation |
0x0c |
1 | uint8_t |
ANY=0, PORT=1, LAND=2, SQUARE=3 |
touchscreen |
0x0d |
1 | uint8_t |
ANY=0, NOTOUCH=1, STYLUS=2, FINGER=3 |
density |
0x0e |
2 | uint16_t |
Densidad en dpi. Ver 8.5 |
keyboard |
0x10 |
1 | uint8_t |
ANY=0, NOKEYS=1, QWERTY=2, 12KEY=3 |
navigation |
0x11 |
1 | uint8_t |
ANY=0, NONAV=1, DPAD=2, TRACKBALL=3, WHEEL=4 |
inputFlags |
0x12 |
1 | uint8_t |
MASK_KEYSHIDDEN = 0x03, MASK_NAVHIDDEN = 0x0c (SHIFT_NAVHIDDEN = 2) |
grammaticalInflection |
0x13 |
1 | uint8_t |
Género gramatical. MASK = 0b11. Antes inputFieldPad0 |
screenWidth |
0x14 |
2 | uint16_t |
Anchura en píxeles. 0 = cualquiera |
screenHeight |
0x16 |
2 | uint16_t |
Altura en píxeles. 0 = cualquiera |
sdkVersion |
0x18 |
2 | uint16_t |
Nivel de API mínimo. 0 = cualquiera. Es el -v26 de los calificadores |
minorVersion |
0x1a |
2 | uint16_t |
Versión menor del SDK. MINORVERSION_ANY = 0. Hasta Baklava (Android 16) siempre 0; ahora la fija el calificador -v<API>.<menor>. Ver debajo de la tabla |
screenLayout |
0x1c |
1 | uint8_t |
MASK_SCREENSIZE = 0x0f, MASK_SCREENLONG = 0x30, MASK_LAYOUTDIR = 0xc0 |
uiMode |
0x1d |
1 | uint8_t |
MASK_UI_MODE_TYPE = 0x0f, MASK_UI_MODE_NIGHT = 0x30 |
smallestScreenWidthDp |
0x1e |
2 | uint16_t |
El sw<N>dp del calificador |
screenWidthDp |
0x20 |
2 | uint16_t |
El w<N>dp |
screenHeightDp |
0x22 |
2 | uint16_t |
El h<N>dp |
localeScript |
0x24 |
4 | char[4] |
Código ISO-15924 del sistema de escritura (Latn, Hant) |
localeVariant |
0x28 |
8 | char[8] |
Subetiqueta de variante BCP-47, de 4 a 8 caracteres |
screenLayout2 |
0x30 |
1 | uint8_t |
MASK_SCREENROUND = 0x03 |
colorMode |
0x31 |
1 | uint8_t |
MASK_WIDE_COLOR_GAMUT = 0x03, MASK_HDR = 0x0c |
screenConfigPad2 |
0x32 |
2 | uint16_t |
Relleno reservado |
localeScriptWasComputed |
0x34 |
1 | bool |
Si es cierto, localeScript lo dedujo el sistema y no venía en el fuente |
localeNumberingSystem |
0x35 |
8 | char[8] |
Extensión BCP-47 de clave nu, de 3 a 8 caracteres |
endPadding |
0x3d |
3 | char[3] |
Relleno explícito hasta el múltiplo de 4 |
Varios de estos campos se agrupan en union con un nombre colectivo, que es el que usan las
funciones de comparación de la «sección 9 · Cómo elige Android qué entrada usar»: imsi (mcc + mnc), locale (language +
country), screenType (orientation + touchscreen + density), input, screenSize,
version, screenConfig, screenSizeDp y screenConfig2.
minorVersion llega a un .arsc real por el calificador de versión con punto. En
android-17.0.0_r1, parseVersion de ConfigDescription.cpp (líneas 632-696) acepta v36.1 y lo
reparte entre sdkVersion = 36 y minorVersion = 1; en android-16.0.0_r1 la misma función solo
admitía dígitos y dejaba minorVersion a 0. aapt2 2.20-15087165 de las build-tools 37.0.0 ya lo
hace: en un APK de prueba con res/values/ y res/values-v36.1/, aapt2 dump resources imprime
la segunda configuración como (v36.1) y su ResTable_config lleva sdkVersion = 36 y
minorVersion = 1 (comprobado el 18 de octubre de 2026). Al elegir entrada, es el último eje de
isBetterThan() («sección 9 · Cómo elige Android qué entrada usar»).
8.2 El problema del size variable
Este es EL detalle que rompe los parsers ingenuos. ResTable_config ha ido creciendo con
las versiones de Android, y un APK compilado con herramientas antiguas trae una estructura más corta que
la que espera un lector escrito hoy.
La regla, tomada literalmente de ResTable_config::copyFromDeviceNoSwap, que en
android-17.0.0_r1 está definida en línea en ResourceTypes.h:
void copyFromDeviceNoSwap(const ResTable_config& o) {
const auto o_size = dtohl(o.size);
if (o_size >= sizeof(ResTable_config)) [[likely]] {
*this = o;
} else {
memcpy(this, &o, o_size);
memset(((uint8_t*)this) + o_size, 0, sizeof(ResTable_config) - o_size);
}
this->size = sizeof(*this);
}
O sea:
Se leen exactamente
sizebytes y el resto de la estructura se rellena a cero. Sisizees mayor que la estructura conocida, se leen los campos conocidos y se ignora el exceso.
Nunca se lee sizeof de la propia struct. Y en el otro sentido —al escribir— hay que
reemitir size bytes, ni uno más, o el round-trip deja de ser byte-exacto.
La regla no tiene suelo: copia size bytes y pone a cero el resto sea cual sea size, así que
cubre todos los tamaños de la tabla de abajo, incluidos los 28 y 32 bytes de las primeras
versiones. LoadedArsc.cpp tampoco pone un mínimo al config.size: solo exige que la cabecera del
ResTable_type llegue hasta él (kResTableTypeMinSize, línea 474 en android-17.0.0_r1).
ResourceTypes.h define la constante que hace falta para leer con seguridad la cabecera de un
ResTable_type antes de saber cuánto ocupa su config:
constexpr size_t kResTableTypeMinSize =
sizeof(ResTable_type) - sizeof(ResTable_config) + sizeof(ResTable_config::size);
O sea, 20 + 4 = 24 bytes: lo justo para llegar a leer config.size.
El historial de tamaños, medido sobre ResourceTypes.h en cada etiqueta
de AOSP y, antes de la primera, en su historial:
size |
Último campo añadido | Presente desde |
|---|---|---|
| 28 | version (sdkVersion, minorVersion): la estructura original |
Android 1.0, en el Initial Contribution del 21 de octubre de 2008; sin etiqueta en AOSP |
| 32 | screenConfig (screenLayout; uiMode desde android-2.2_r1) |
android-1.6_r1 (commit 723738c del 26 de junio de 2009) |
| 36 | screenSizeDp |
android-3.2.4_r1 |
| 48 | localeScript, localeVariant |
android-5.0.0_r1 |
| 52 | screenConfig2 |
android-6.0.0_r1 |
| 56 | localeScriptWasComputed |
android-7.0.0_r1 |
| 64 | localeNumberingSystem |
android-9.0.0_r1 y posteriores, incluida android-17.0.0_r1 |
Los valores de la columna size los medimos compilando con clang la struct ResTable_config de cada etiqueta, solo con sus campos, para aarch64 y armv7a de Android: 28
en el Initial Contribution y en la importación de cupcake_rel de marzo de 2009 (Android 1.5),
que AOSP no etiqueta y que leímos en el historial del espejo de GitHub; 32 en android-1.6_r1,
android-2.2_r1 y android-2.3.7_r1 —Android 3.0 y 3.1, las API 11 y 12, no tienen etiqueta—; 36
de android-3.2.4_r1 a android-4.4_r1, 48 en android-5.0.0_r1 y android-5.1.0_r1, 52 en
android-6.0.0_r1, 56 de android-7.0.0_r1 a android-8.1.0_r1 —el colorMode de Android 8
ocupa un byte que era de relleno— y 64 en android-9.0.0_r1 y android-17.0.0_r1, que además
lo fija con static_assert(sizeof(ResTable_config) == 64).
En el muestrario aparecen cinco tamaños: 36, 48, 52, 56 y 64 bytes. Los de 28 y 32 no aparecen.
No son una rareza de un solo fichero, pero el de 64 domina en todos los orígenes: en F-Droid son
732.825 de 752.668 chunks ResTable_type (el 97 %), y en el sorteo de Google Play, todos los 41.585.
En IzzyOnDroid, Google Play y el mercado chino ronda el 99 %, y en las webs de los autores el 83 %.
Aun así, hay piezas con alguna configuración más corta que 64 bytes: en F-Droid, un 3,5 %. Depende
de cuándo se compiló la app. Entre los APK únicos de F-Droid, la tienen el 70 % de los de
targetSdk 24 o 25, la mitad de los de 26 o 27, y prácticamente ninguno desde 30. Un lector que
asuma 64 lee de más en cada una de esas configuraciones. Invade el array de offsets que viene
detrás y produce basura sin dar error.
Un ejemplo de cada tamaño:
- 36 bytes:
uk.org.boddie.android.weatherforecast(173, de F-Droid), en 7 de 7 configuraciones;targetSdk29. - 48 bytes: Netflix para televisión (
com.netflix.ninja13.2.1-27207, de APKMirror), en 151 de 151;targetSdk36. - 52 bytes:
com.cgogolin.penandpdf(67, de IzzyOnDroid), en 150 de 150;targetSdk25. - 56 bytes:
de.tobiasbielefeld.solitaire(71, de F-Droid), en 161 de 161;targetSdk25. - Mezcla:
com.android.bankabc(102, mercado chino), con 18 configuraciones de 36 bytes, 197 de 56 y el resto de 64, 543 en total.
8.3 language y country: el truco del bit alto
Los dos campos ocupan dos bytes y tienen que representar tres cosas: «cualquiera», un código
ISO-639-1 de dos letras, y un código ISO-639-2 de tres letras. La solución empaqueta tres
valores de 5 bits en los 16 disponibles y usa el bit alto como discriminador —
{1, t,t,t,t,t, s,s,s,s,s, f,f,f,f,f}, con las letras primera, segunda y tercera en los bits
0–4, 5–9 y 10–14—. «The layout is always big-endian irrespective of the runtime architecture»,
dice la cabecera. El desempaquetado real, de unpackLanguageOrRegion:
if (in[0] & 0x80) { // tres letras
const uint8_t first = in[1] & 0x1f;
const uint8_t second = ((in[1] & 0xe0) >> 5) + ((in[0] & 0x03) << 3);
const uint8_t third = (in[0] & 0x7c) >> 2;
out[0] = first + base; out[1] = second + base; out[2] = third + base;
return 3;
}
if (in[0]) { memcpy(out, in, 2); return 2; } // dos letras ASCII
return 0; // "cualquiera"
La base es 'a' para el idioma y '0' para la región, porque las regiones UN M.49 son
numéricas de tres dígitos.
Los dos casos, medidos sobre los ResTable_type del tipo string:
catalán config +0x00 40 00 00 00 00 00 00 00 63 61 00 00 … language = 'c','a' en ASCII
asturiano config +0x00 40 00 00 00 00 00 00 00 ce 40 00 00 … language = 0xce, 0x40
El primero es de F-Droid 2.0.2, que trae 45 idiomas, todos de dos letras (ca = 63 61, fa = 66 61, ga = 67 61). El segundo es de Wikipedia (org.wikipedia 50611, de F-Droid), con 197
idiomas, 52 de ellos de tres letras empaquetadas (ast = ce 40, ary = e2 20, ckb = 85 42,
kab = 84 0a, hsb = 86 47) y 5 con calificador b+ (isv-Latn, kk-Cyrl, sr-Latn,
tg-Cyrl, tt-Cyrl).
Para ce 40, 0xce & 0x80 ≠ 0, luego son tres letras:
first = 0x40 & 0x1f = 0 → 'a'+0 = 'a';
second = ((0x40 & 0xe0) >> 5) + ((0xce & 0x03) << 3) = 2 + 16 = 18 → 'a'+18 = 's';
third = (0xce & 0x7c) >> 2 = 19 → 'a'+19 = 't'. Resultado: ast, asturiano.
El filipino, fil-PH, sale igual: en Glucosio (org.glucosio.android 38, de F-Droid), que trae 304
idiomas con país, su language es ad 05 y su country son los bytes ASCII 50 48 («PH»).
first = 5 → 'f', second = 8 → 'i', third = 11 → 'l': fil, que es lo que aapt2 dump resources imprime como (fil). En esa misma pieza están también ast-ES (ce 40) y ceb-PH
(84 82).
Cuando el locale necesita más que idioma y región —escritura, variante, sistema de numeración—
se usan además localeScript, localeVariant y localeNumberingSystem, y el calificador de
directorio pasa de la forma es-rES a la forma BCP-47 extendida b+es+Latn+ES.
8.4 Las banderas CONFIG_*
Son las que aparecen en las máscaras del ResTable_typeSpec («sección 6 · ResTable_typeSpec») y las que devuelve
ResTable_config::diff(). ResourceTypes.h las define por indirección a las constantes
ACONFIGURATION_* de frameworks/native/include/android/configuration.h, donde están los
valores:
| Bandera | Valor | Bandera | Valor |
|---|---|---|---|
CONFIG_MCC |
0x0001 |
CONFIG_SCREEN_SIZE |
0x0200 |
CONFIG_MNC |
0x0002 |
CONFIG_VERSION |
0x0400 |
CONFIG_LOCALE |
0x0004 |
CONFIG_SCREEN_LAYOUT |
0x0800 |
CONFIG_TOUCHSCREEN |
0x0008 |
CONFIG_UI_MODE |
0x1000 |
CONFIG_KEYBOARD |
0x0010 |
CONFIG_SMALLEST_SCREEN_SIZE |
0x2000 |
CONFIG_KEYBOARD_HIDDEN |
0x0020 |
CONFIG_LAYOUTDIR |
0x4000 |
CONFIG_NAVIGATION |
0x0040 |
CONFIG_SCREEN_ROUND |
0x8000 |
CONFIG_ORIENTATION |
0x0080 |
CONFIG_COLOR_MODE |
0x10000 |
CONFIG_DENSITY |
0x0100 |
CONFIG_GRAMMATICAL_GENDER |
0x20000 |
La cabecera advierte de que estos valores deben coincidir con los de
android.content.pm.ActivityInfo y attrs_manifest.xml. La máscara 0x4000 que imprime
aapt2 dump chunks como layout_dir en la receta 15.3 es CONFIG_LAYOUTDIR.
8.5 Densidad
density no es un enumerado cerrado: es el valor en dpi. Los nombres son atajos.
| Constante | Valor | Calificador |
|---|---|---|
DENSITY_DEFAULT |
0 | — |
DENSITY_LOW |
120 | ldpi |
DENSITY_MEDIUM |
160 | mdpi |
DENSITY_TV |
213 | tvdpi |
DENSITY_HIGH |
240 | hdpi |
DENSITY_XHIGH |
320 | xhdpi |
DENSITY_XXHIGH |
480 | xxhdpi |
DENSITY_XXXHIGH |
640 | xxxhdpi |
DENSITY_ANY |
0xfffe |
anydpi |
DENSITY_NONE |
0xffff |
nodpi |
El split config.xhdpi.apk de Google Keep 5.26 trae density = 0x0140 = 320 en dos de sus tres
configuraciones (xhdpi y ldrtl-xhdpi), consistente con la tabla. La tercera, la de style, tiene
240 (hdpi). El de VLC 3.7.2 trae cuatro configuraciones, con 320, 320, 65534 (anydpi) y 240. No
son casos aislados: un split de densidad suele traer varias densidades, no solo la del nombre. Tienen
una sola 29 de los 1.522 splits de densidad de Google Play (menos del 2 %) y 3 de los 240 del sorteo.
Tienen entre tres y cinco 1.114 de los de Google Play (casi tres de cada cuatro) y 218 de los del
sorteo (más de nueve de cada diez). Un ejemplo con tres densidades distintas es el
split_config.xhdpi.apk de Brawl Stars (com.supercell.brawlstars 69.414). Al fusionar splits no
basta, por tanto, con la densidad del nombre del split.
Un detalle que muerde: mnc = 0 significa «cualquiera», así que la MNC real cero se codifica con
el valor centinela ACONFIGURATION_MNC_ZERO = 0xffff.
8.6 Cuántas configuraciones trae una app
Cuántos idiomas y densidades hay en una tabla depende de la app, medido sobre el resources.arsc
de la pieza base o única. La mediana de idiomas es 85 en F-Droid, 86 en IzzyOnDroid, 67 en Google Play y 88 en las
webs de los autores; en el mercado chino está entre 19 y 61, y en el sorteo es 0. En el sorteo es 0
porque en los .apkm y en las carpetas de adb de Play los idiomas van en splits de idioma y la base
no los trae («sección 16.3 · Splits de Play»). Tienen 10 idiomas o más casi nueve de cada diez apps de F-Droid (4.165 de
4.766) y de IzzyOnDroid (1.243 de 1.402), 393 de 658 de Google Play, 131 de 369 del sorteo y 54 de 100 del
mercado chino. Las densidades distintas por app son, en la mediana, 6 en F-Droid, IzzyOnDroid y el
sorteo, 7 en Google Play y 8 en el mercado chino.
Cuántas apps tienen variantes night, sw600dp, v31 o anydpi no lo hemos calculado (ver los
límites de la «sección 1 · Qué problema resuelve»). Solo sabemos de una: F-Droid 2.0.2 tiene 80 configuraciones distintas,
entre ellas night, sw480dp, sw600dp y watch.
9. Cómo elige Android qué entrada usar
Dado un resource ID y la configuración del dispositivo, AssetManager recorre todos los
ResTable_type del tipo correspondiente y aplica dos filtros en cadena.
Primero match(). Descarta las configuraciones incompatibles. La regla es asimétrica:
«A default piece of data will match every request but a request for the default should not
match odd specifics». Una entrada sin idioma sirve para cualquier petición; una entrada es no
sirve para una petición de; una entrada sw600dp no sirve para un dispositivo de 480 dp, pero
sí al revés.
Después isBetterThan(). Entre las supervivientes elige la mejor, comparando eje por eje
en un orden fijo y devolviendo en el primer eje que difiera:
mcc → mnc → locale → grammaticalInflection → layoutDirection →
smallestScreenWidthDp → screenWidthDp/screenHeightDp → screenSize (small/normal/large) →
screenLong → screenRound → wideColorGamut → HDR → orientation →
uiModeType → uiModeNight → density → touchscreen →
keysHidden → navHidden → keyboard → navigation →
screenWidth/screenHeight → sdkVersion → minorVersion
La regla general, del comentario de la cabecera: si la petición se interesa por un eje y las dos
candidatas difieren, una de las dos tiene que ser genérica —porque match() ya eliminó las
incompatibles—, así que gana la que no es genérica.
Tres ejes tienen lógica propia y son los que más sorprenden:
- Densidad. No gana la más parecida sino la que se pueda reducir en vez de ampliar:
gana la menor de las que llegan a la pedida, y si ninguna llega, la mayor. Un dispositivo
mdpiconxhdpiyxxxhdpidisponibles eligexhdpi; conldpiyxhdpi,xhdpi.DENSITY_ANYgana siempre. Si no se pide densidad, se asumeDENSITY_MEDIUM(160). - Dimensiones en dp. Gana la que minimiza la suma de
pedido - candidataen anchura y altura, asumiendo quematch()ya descartó las mayores que lo pedido. sdkVersion. Gana la mayor, no la más cercana:return (sdkVersion > o.sdkVersion). Es lo que hace que un recurso marcado-v31sustituya al-v21en un dispositivo moderno.
El locale tiene su propia función, isLocaleBetterThan(), con las reglas de fallback de
BCP-47 —idioma, escritura, región, variante— y una puntuación de importancia
(getImportanceScoreOfLocale).
Reproducir isBetterThan exactamente no hace falta para leer ni para reescribir la tabla;
hace falta para elegir qué splits fusionar y para el modo de fusión que descarta
configuraciones. Cuando haya que reproducirlo, la única referencia válida es el código:
ResTable_config::match() y ResTable_config::isBetterThan() en
libs/androidfw/ResourceTypes.cpp.
10. ResTable_entry, ResTable_map_entry y ResTable_map
10.1 La entrada normal
ResTable_entry es una union de dos formas. La normal, Full:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
size |
0x00 |
2 | uint16_t |
Tamaño de esta cabecera de entrada, no del valor |
flags |
0x02 |
2 | uint16_t |
Ver tabla |
key |
0x04 |
4 | ResStringPool_ref |
Índice en el keyStrings del paquete |
| Flag | Valor | Significado |
|---|---|---|
FLAG_COMPLEX |
0x0001 |
La entrada es un mapa: le siguen count ResTable_map en vez de un Res_value |
FLAG_PUBLIC |
0x0002 |
Declarada pública; otras bibliotecas pueden referenciarla |
FLAG_WEAK |
0x0004 |
Recurso débil, sustituible por uno fuerte del mismo nombre al enlazar |
FLAG_COMPACT |
0x0008 |
La entrada usa la forma compacta de 10.2 |
FLAG_USES_FEATURE_FLAGS |
0x0010 |
La entrada depende de flags de lectura/escritura de Android («sección 12.5 · RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)») |
Si FLAG_COMPLEX no está puesto, inmediatamente después de los size bytes de la cabecera
viene un Res_value de 8 bytes («XML binario, sección 5»).
size vale 8 en ese caso.
Si FLAG_COMPLEX sí está puesto, la cabecera es un ResTable_map_entry, que extiende a
Full:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
size, flags, key |
0x00 |
8 | ResTable_entry::Full |
Igual que arriba. size vale 16 |
parent |
0x08 |
4 | ResTable_ref |
resource ID del mapa del que se hereda, o 0. Se trata siempre como TYPE_DYNAMIC_REFERENCE |
count |
0x0c |
4 | uint32_t |
Número de pares nombre-valor que siguen |
Y a continuación count estructuras ResTable_map de 12 bytes:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
name |
0x00 |
4 | ResTable_ref |
resource ID del atributo que se define, o un valor especial ATTR_* |
value |
0x04 |
8 | Res_value |
El valor |
Los valores especiales de name se construyen con la macro
Res_MAKEINTERNAL(x) = 0x01000000 | (x & 0xFFFF):
| Nombre | Valor | Uso |
|---|---|---|
ATTR_TYPE |
0x01000000 |
Máscara de tipos admitidos por el atributo |
ATTR_MIN |
0x01000001 |
Valor mínimo para atributos enteros |
ATTR_MAX |
0x01000002 |
Valor máximo |
ATTR_L10N |
0x01000003 |
L10N_NOT_REQUIRED = 0, L10N_SUGGESTED = 1 |
ATTR_OTHER, ATTR_ZERO, ATTR_ONE, ATTR_TWO, ATTR_FEW, ATTR_MANY |
0x01000004 a 0x01000009 |
Las seis categorías de plural, en ese orden |
Y la máscara de tipos que acompaña a ATTR_TYPE:
| Nombre | Valor | Significado |
|---|---|---|
TYPE_ANY |
0x0000FFFF |
Sin restricción entre los tipos genéricos |
TYPE_REFERENCE |
1 << 0 |
Admite una referencia |
TYPE_STRING |
1 << 1 |
Admite una cadena |
TYPE_INTEGER |
1 << 2 |
Admite un entero |
TYPE_BOOLEAN |
1 << 3 |
Admite un booleano |
TYPE_COLOR |
1 << 4 |
Admite un color |
TYPE_FLOAT |
1 << 5 |
Admite un decimal |
TYPE_DIMENSION |
1 << 6 |
Admite una dimensión |
TYPE_FRACTION |
1 << 7 |
Admite una fracción |
TYPE_ENUM |
1 << 16 |
Enumerado; los valores vienen como entradas más del mapa |
TYPE_FLAGS |
1 << 17 |
Máscara de bits; los valores vienen como entradas más del mapa |
Hay dos casos en que name no es ni un atributo ni un metadato ATTR_*, aunque a veces lo
parezca:
- En un
<string-array>,<integer-array>o<array>cada elemento es una entrada del mapa ynamesolo da su posición, con un valor que depende del compilador. Elaaptantiguo nombraba el elemento i^index_i, yResTablelo traduce con la macro hermana deRes_MAKEINTERNAL,Res_MAKEARRAY(i) = 0x02000000 | (i & 0xFFFF)(ResourceTypes.h, línea 282;ResourceTypes.cpp, línea 5220).aapt2no la usa: escribeATTR_MIN + i, es decir0x01000001,0x01000002… (ResEntryWriter.cpp, línea 105), y al leer un array no mira la clave (BinaryResourceParser.cpp, líneas 723-731). Un lector tiene que aceptar las dos formas y no tomar un array deaapt2por un atributo porque sus claves coincidan conATTR_MIN,ATTR_MAX…: lo que dice qué es el mapa es el tipo de la entrada. - En un
<attr>con<enum>o<flag>, cada valor posible es una entrada más del mapa, y sunamees elresource IDde una entrada de tipoidcon el nombre del símbolo:aapt2crea una referencia a@id/<nombre>por cada<enum>o<flag>(ResourceParser.cpp, líneas 1482-1512) y la escribe como clave (ResEntryWriter.cpp, líneas 69-72). Es lo que se ve abajo enalphabeticModifiers:0x7f080005pertenece al tipo0x08, que en Termux esid.
Tres ejemplos reales de Termux (com.termux 1022), del tipo 0x03 (attr) y del 0x11 (style):
id=0x7f030000 size=16 flags=0x0005[COMPLEX,WEAK] key=58('actionBarDivider')
parent=0x00000000 count=1
map name=0x01000000 ATTR_TYPE value dataType=0x10 data=0x00000001 ← TYPE_REFERENCE
id=0x7f03002f key='alphabeticModifiers' parent=0x00000000 count=7
map name=0x01000000 ATTR_TYPE value dataType=0x10 data=0x00020000 ← TYPE_FLAGS (1<<17)
map name=0x7f080005 value dataType=0x11 data=0x00010000 ← un valor de la máscara
map name=0x7f080003 value dataType=0x11 data=0x00001000
id=0x7f110000 size=16 flags=0x0001[COMPLEX] key=2761('AlertDialog.AppCompat')
parent=0x7f110008 count=0 ← estilo que solo hereda
10.2 La entrada compacta: FLAG_COMPACT
Es la adición más reciente. Cuando está puesto FLAG_COMPACT = 0x0008, los 8 bytes de la
entrada contienen ya el valor y no hay Res_value detrás:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
key |
0x00 |
2 | uint16_t |
Índice en keyStrings, en 16 bits |
flags |
0x02 |
2 | uint16_t |
Byte bajo: los flags. Byte alto: el dataType del valor |
data |
0x04 |
4 | uint32_t |
El dato |
El campo flags está deliberadamente en el mismo offset que en la forma Full, con un
static_assert que lo garantiza, para poder decidir qué forma es antes de interpretar el
resto. El size de la entrada y el del valor se dan por supuestos: 8 bytes ambos.
aapt2 solo lo emite con --enable-compact-entries y minSdkVersion > 33, es decir Android 14
en adelante, y lo decide por cada ResTable_type —un tipo en una configuración—: lo usa si todas
las claves de ese chunk caben en 16 bits (UseCompactEntries, TableFlattener.cpp, líneas
144-152 en android-17.0.0_r1). Dentro de un chunk compacto, las entradas complejas se siguen
escribiendo en la forma Full de 10.1 (ResEntryWriter.cpp, líneas 216-217 y 227-236), así que
un lector decide entrada a entrada, mirando FLAG_COMPACT en flags, y no por chunk. No lo hemos
visto ni una vez en el muestrario: 0 entradas compactas en las 13.651 piezas con
resources.arsc (tampoco en las cinco de protectores). Tampoco aparecen entre las 58 apps con
minSdkVersion 34 o más (29 de F-Droid, 11 de IzzyOnDroid, 17 de Google Play y 1 del sorteo), que son las que aapt2
podría haber compilado con la opción --enable-compact-entries. El minSdkVersion más alto del
muestrario es 37, en el reloj de Samsung (com.sec.android.app.clockpackage 12.6.05.24, de APKMirror),
y tampoco tiene entradas compactas. Un lector escrito hoy tiene que soportarlo igualmente.
10.3 Lo que AOSP valida en cada entrada
De VerifyResTableEntry en LoadedArsc.cpp, y merece la pena copiarlo tal cual en un lector
propio: el offset debe estar alineado a 4; no puede desbordar al sumarle entriesStart; tiene
que quedar sitio para un ResTable_entry completo; entry->size() no puede ser menor que
sizeof(ResTable_entry) ni mayor que el chunk; si no es compleja, tiene que quedar sitio para
un Res_value cuyo size sea al menos 8; y si es compleja, los ResTable_map tienen que
empezar alineados a 4 y caber count de ellos en lo que queda de chunk.
11. La estructura del resource ID: 0xPPTTEEEE
| Parte | Bits | Significado |
|---|---|---|
PP |
31–24 | Paquete. Base 1: 0 no es un paquete real, sino la marca de un paquete dinámico cuyo ID asigna el runtime |
TT |
23–16 | Tipo dentro del paquete. Base 1: 0 es inválido |
EEEE |
15–0 | Entrada dentro del tipo. Base 0 |
Las macros de ResourceTypes.h lo dicen sin ambigüedad:
#define Res_MAKEID(package, type, entry) \
(((package+1)<<24) | (((type+1)&0xFF)<<16) | (entry&0xFFFF))
#define Res_GETPACKAGE(id) ((id>>24)-1)
#define Res_GETTYPE(id) (((id>>16)&0xFF)-1)
#define Res_GETENTRY(id) (id&0xFFFF)
Ojo: las macros toman los índices en base 0 y suman uno; los campos id de ResTable_package,
ResTable_typeSpec y ResTable_type guardan ya el valor en base 1, listo para meter en el
resource ID; en el caso del tipo, siempre que el typeIdOffset del paquete («sección 5 · ResTable_package») valga 0,
que es lo normal. Si no vale 0, el TT es id + typeIdOffset (LoadedArsc.cpp, líneas 250 y 453
en android-17.0.0_r1), mientras que PP y EEEE no cambian, y el cargador rechaza el
typeSpec cuya suma pase de 255 (líneas 631-635). Res_MAXPACKAGE y Res_MAXTYPE
valen 255, y EEEE de 16 bits impone el límite de 65.535 entradas por tipo, que
LoadedArsc.cpp comprueba explícitamente: rechaza un entryCount > 0xFFFF.
Los valores de PP:
PP |
Quién |
|---|---|
0x00 |
Paquete dinámico, sin identificador asignado: es lo que aapt2 link --shared-lib emite, y AssetManager2 le asigna uno real al cargar |
0x01 |
kFrameworkPackageId — el framework de Android, android.R |
0x02–0x7e |
Reservado históricamente. aapt2 solo lo permite con --allow-reserved-package-id, que existe para los antiguos feature splits previos a Android 8 |
0x7f |
kAppPackageId — la aplicación. Lo normal |
0x80–0xff |
Lo que AGP asigna a los módulos de funcionalidad (FeatureSetMetadata: 0x80, 0x81… con minSdk ≥ 26; por debajo, 0x7e hacia abajo con --allow-reserved-package-id). aapt2 --package-id acepta este rango sin más |
Link.cpp lo valida así, y el mensaje de error es la definición operativa del rango:
invalid package ID 0x%02x. Must be in the range 0x7f-0xff.
con la excepción documentada de que, antes de Android 8, el runtime trataba como inválido
cualquier ID con PP > 0x7f porque el resource ID se interpretaba como entero con signo. De
ahí la existencia del rango reservado 0x02–0x7e y del FeatureSplitSymbolTableDelegate que
reescribe identificadores cuando minSdkVersion < 26.
En el muestrario se ven los dos extremos. MyExpenses (org.totschnig.myexpenses 887, de F-Droid)
trae seis paquetes: 0x7f para la aplicación y 0x80, 0x83, 0x84, 0x85 y 0x86 para cinco
módulos de funcionalidad suyos (ocr, webdav, sqlcrypt, fints y onedrive; «sección 12.1 · RES_TABLE_LIBRARY_TYPE (0x0203)»). En
el otro extremo, org.matrix.chromext (16) y com.github.dan.NoStorageRestrict (7), dos módulos de
Xposed de IzzyOnDroid, tienen un solo paquete con PP = 0x45 y 0x23: no hay 0x7f, y un lector
que lo busque falla.
Por pieza, el paquete 0x7f está en todas las de F-Droid, el sorteo, el mercado chino y las webs de
los autores, en 1.399 de 1.401 de IzzyOnDroid y en 6.448 de 6.656 de Google Play (el 97 %). A Google
Play le faltan 208 piezas (3,1 %) y a IzzyOnDroid dos. Entre los 77 módulos de funcionalidad de Play,
64 usan el rango reservado 0x02–0x7e (con minSdk de 17 a 24 en 61 de ellos) y 13 usan 0x80 o
más (todos con minSdk 26 o más). No es una regla fija: 3 módulos con minSdk 32 siguen en el rango
reservado. Ningún paquete de ninguna pieza usa 0x00 ni 0x01.
12. Los chunks menos frecuentes
Un lector puede no entenderlos, pero tiene que conservarlos: si se pierden, la aplicación puede seguir arrancando y fallar en un caso concreto meses después. Esto último no lo podemos medir de forma estática. Lo que sí medimos es cuántas piezas llevan alguno de los chunks de 12.1 a 12.3, los que un lector ingenuo perdería: fuera de Google Play, casi ninguna; en Google Play, alrededor del 6 % (397 de 6.677).
12.1 RES_TABLE_LIBRARY_TYPE (0x0203)
Tabla de traducción de identificadores de paquete de bibliotecas compartidas dinámicas. El ID que una biblioteca tiene en tiempo de compilación no tiene por qué ser el que reciba al cargarse; este chunk permite traducirlos por nombre.
ResTable_lib_header: ResChunk_header (8 bytes) + count (uint32_t, offset 0x08).
headerSize = 12. Le siguen count estructuras ResTable_lib_entry de 260 bytes:
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
packageId |
0x00 |
4 | uint32_t |
ID asignado en tiempo de compilación. uint32_t solo por alineación |
packageName |
0x04 |
256 | uint16_t[128] |
Nombre del paquete en UTF-16, terminado en \0 |
De MyExpenses (org.totschnig.myexpenses 887), el chunk del tercer módulo (cuarto paquete):
RES_TABLE_LIBRARY_TYPE en +0x6d1338: headerSize=12 size=792 count=3
ResTable_lib_entry packageId=0x80 packageName='org.totschnig.myexpenses.ocr'
ResTable_lib_entry packageId=0x83 packageName='org.totschnig.myexpenses.webdav'
ResTable_lib_entry packageId=0x84 packageName='org.totschnig.myexpenses.sqlcrypt'
Cada paquete declara las bibliotecas de las que depende, así que el mismo nombre aparece en varios chunks. Hay 592 chunks de este tipo en el muestrario, 542 de ellos en Google Play. Por pieza, los lleva un 5 % de las de Google Play y casi ninguna del resto: casi todos son de Play, sobre todo en splits de idioma y de funcionalidad. Por app, la base de Google Play lleva el chunk en 25 de 658 apps (4 %).
12.2 RES_TABLE_OVERLAYABLE_TYPE (0x0204) y su política (0x0205)
Declara qué recursos pueden sobrescribir los Runtime Resource Overlays. Es lo que emite el
bloque <overlayable> del fuente.
ResTable_overlayable_header: ResChunk_header (8) + name (uint16_t[256], offset 0x08) +
actor (uint16_t[256], offset 0x208). headerSize = 1032, confirmado en los 118 chunks del muestrario.
Dentro vienen uno o más ResTable_overlayable_policy_header de headerSize 16: header
(0x00, 8 bytes), policy_flags (0x08, uint32_t) y entry_count (0x0c, uint32_t),
seguidos de entry_count estructuras ResTable_ref de 4 bytes.
Bandera de policy_flags |
Valor | Requisito que impone al overlay |
|---|---|---|
NONE |
0x00000000 |
— |
PUBLIC |
0x00000001 |
Cualquier overlay |
SYSTEM_PARTITION |
0x00000002 |
Residir en la partición system |
VENDOR_PARTITION |
0x00000004 |
Residir en vendor |
PRODUCT_PARTITION |
0x00000008 |
Residir en product |
SIGNATURE |
0x00000010 |
Estar firmado con la misma clave que el paquete objetivo |
ODM_PARTITION |
0x00000020 |
Residir en odm |
OEM_PARTITION |
0x00000040 |
Residir en oem |
ACTOR_SIGNATURE |
0x00000080 |
Estar firmado con la clave del actor declarado |
CONFIG_SIGNATURE |
0x00000100 |
Estar firmado con la clave de referencia de SystemConfig |
De split_config.et.apk de Google Text-to-Speech (com.google.android.tts, de APKMirror), el idioma
estonio:
RES_TABLE_OVERLAYABLE_TYPE +0x005b90 headerSize=1032 size=1096
name='car-ui-lib' actor=''
RES_TABLE_OVERLAYABLE_POLICY_TYPE headerSize=16 size=64
policy_flags=0x0000007e entry_count=12
ResTable_ref ident=0x7f14004f
ResTable_ref ident=0x7f140056
...
0x7e = SYSTEM_PARTITION | VENDOR_PARTITION | PRODUCT_PARTITION | SIGNATURE | ODM_PARTITION | OEM_PARTITION. El otro valor que aparece en los ejemplos es 0x01 (PUBLIC): la app de activación
por voz de Qualcomm (com.quicinc.voice.activation 6.1.3, de APKMirror) declara name='ModelPath'
con esa política y una sola referencia, 0x7f020002.
Hay 118 chunks de este tipo en el muestrario (116 en Google Play, 1 en F-Droid y 1 en las webs de los
autores). Están en 66 piezas de 18 descargas, que son 17 paquetes: Brave se descargó dos veces, una de
su web y otra de Play. Nueve de los 17 son de Google (firmante O=Google o paquete com.google.*).
Los otros ocho no: Yandex Start, Yandex Browser, Brave, Opera, Mi Browser, Pandora, Qualcomm y
TalkBack de F-Droid, que está firmado por F-Droid. Así que no es un rasgo exclusivo de Google ni de
Android Auto. Por papel, 48 de las 66 piezas son splits de idioma, 12 son bases y 6 son piezas únicas.
12.3 RES_TABLE_STAGED_ALIAS_TYPE (0x0206)
Reescribe identificadores staged —no finalizados— a sus equivalentes definitivos. Es un mecanismo del ciclo de desarrollo del framework.
ResTable_staged_alias_header: ResChunk_header (8) + count (uint32_t, offset 0x08).
Le siguen count ResTable_staged_alias_entry de 8 bytes: stagedResId en 0x00 y
finalizedResId en 0x04, ambos uint32_t.
No lo hemos visto en el muestrario: 0 chunks en las 13.656 piezas con resources.arsc (las
13.651 normales más las 5 de protectores). Aparece en el framework-res.apk de la plataforma, no en
aplicaciones.
12.4 RES_NULL_TYPE (0x0000)
Chunk de relleno. Un lector debe saltarlo por size como cualquier otro.
12.5 RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)
Son nuevos en android-17.0.0_r1 (ResourceTypes.h, líneas 264-265; la cabecera de
android-16.0.0_r1 no los define). Sirven para los recursos que dependen de un flag de
lectura/escritura de Android, cuyo valor solo se conoce en el dispositivo.
ResTable_flagged: ResChunk_header (8) + flag_name_index (ResStringPool_ref, offset
0x08) + flag_negated (bool, 0x0c) + 3 bytes de relleno. Va dentro del paquete, detrás
del RES_TABLE_TYPE_SPEC_TYPE, y contiene chunks RES_TABLE_TYPE_TYPE. LoadedArsc.cpp
los carga solo si el flag está activo —o inactivo, con flag_negated— y los pone por delante
de los no condicionados, así que ganan.
ResTable_flag_list: una ResChunk_header seguida de un array de ResStringPool_ref al pool
global con los nombres de todos los flags usados. Va una vez, en el nivel de RES_TABLE_TYPE,
detrás del pool global. Un RES_TABLE_FLAGGED cuyo flag no esté en la lista hace fallar la
carga del paquete.
Los dos se procesan solo con el flag de plataforma resource_readwrite_flags activo; sin él,
LoadedArsc.cpp los salta en silencio, sin mirar dentro (líneas 670-705 y 942-987 en
android-17.0.0_r1). Los buscamos en las 13.651 piezas con resources.arsc del muestrario, dentro
de los paquetes y en la raíz de la tabla, y en las cinco de protectores, que se cuentan aparte
(13.656 en total): ninguna contiene un 0x0207 ni un 0x0208, y tampoco ningún chunk de tipo
desconocido. La búsqueda cubre los .apk sueltos y las piezas de los .apkm, los .xapk y las
carpetas de adb.
13. Qué entender y qué conservar en crudo
Esto es lo que el formato le pide a quien escriba un lector o un fusionador.
El sustrato de chunks garantiza que se puede reemitir sin pérdida lo que no se entiende: la
cabecera lleva el tamaño total, así que un chunk desconocido es un bloque opaco de size bytes
que se copia tal cual. Eso permite dividir el formato en dos:
| Se modela tipado, se puede mutar | Se conserva en crudo, se reemite byte a byte |
|---|---|
RES_TABLE_TYPE — hay que recalcular size |
RES_TABLE_LIBRARY_TYPE mientras no se remapeen paquetes |
RES_STRING_POOL_TYPE — hay que añadir y renombrar cadenas |
RES_TABLE_OVERLAYABLE_TYPE y su política |
RES_TABLE_PACKAGE_TYPE — hay que fusionar paquetes |
RES_TABLE_STAGED_ALIAS_TYPE |
RES_TABLE_TYPE_SPEC_TYPE — hay que recalcular las máscaras al fusionar («sección 6 · ResTable_typeSpec») |
RES_NULL_TYPE y cualquier tipo futuro |
RES_TABLE_TYPE_TYPE — es donde viven los valores |
El reparto no es arbitrario: los cinco tipos de la izquierda son los que hay que tocar para fusionar dos tablas y para renombrar entradas, que son las dos únicas mutaciones que un fusionador necesita hacer. Todo lo demás se copia. Cómo se hace cada caso —config splits, módulos con paquete propio, la tabla vacía de 40 bytes— está en la «sección 4 de Fusión de splits · Fusión de las tablas de recursos».
Dos matices que el reparto no debe ocultar:
- Conservar en crudo no es ignorar. Si un fusionador reasigna el
PPde un paquete, losResTable_refque viven dentro de unRES_TABLE_OVERLAYABLE_POLICY_TYPEdejan de apuntar donde deben. No debería reescribirlos a ciegas, sino detectarlo y avisar a quien lo usa. - La completitud se puede medir. Un fusionador debería poder decir qué parte de los bytes de cada fichero reemite desde el modelo tipado y qué parte en crudo. Ese porcentaje convierte «¿se entiende el formato?» en un número comparable entre versiones de la herramienta, en vez de en una apuesta, y deja a la vista lo que se da por entendido sin estarlo.
14. Recursos ofuscados
Hay dos cosas distintas que se llaman «ofuscación de recursos», y la primera es mucho más frecuente que la segunda.
El acortamiento de rutas. Es lo que hace la optimización de recursos del Android Gradle
Plugin: res/layout/activity_main.xml pasa a llamarse res/vp1.xml dentro del ZIP, y la cadena
del pool global cambia en consecuencia. El nombre de la entrada —la key— no se toca.
El renombrado de claves. Sustituir app_name por a en el pool keyStrings. Es lo que
hacen herramientas como AndResGuard, y es mucho más destructivo porque no queda de dónde
recuperar el nombre.
El acortamiento de rutas es lo habitual; el renombrado de claves, no. Contamos sobre el
resources.arsc de la pieza base o única.
El acortamiento de rutas lo tienen casi nueve de cada diez apps de F-Droid e IzzyOnDroid, un
tercio de las de Google Play y algo más de la mitad de las del mercado chino. Cuenta una app con al
menos 20 rutas res/ cuando la mitad o más tienen un nombre de tres caracteres o menos.
El renombrado de claves, por cualquier esquema (claves cortas, nombres colapsados o con el
resource ID), es raro: ninguna app de F-Droid, un 4 % en Google Play y 12 de 100 en el mercado
chino, entre las apps con al menos 50 claves. Estos umbrales dejan fuera las apps con menos rutas o
claves (ver los límites de la «sección 1 · Qué problema resuelve»). Aquí se usa siempre la definición de tres caracteres o
menos.
Medido sobre trece piezas del muestrario, la diferencia entre ambos es grande. «Claves» cuenta las
cadenas del keyStrings; «Rutas res/», las del pool global que empiezan por res/; y «% de rutas
≤ 3 car.» mide de cada una el nombre del fichero sin directorio ni extensión, con la extensión contada
desde el primer punto: res/vp1.xml cuenta vp1, y res/8w.9.png, 8w. Cada fila es una app (una
pieza) elegida a mano, así que no son proporciones. Mira las columnas de porcentaje: cuatro piezas
tienen la mayoría de las claves cortas (WeChat de Play, WeChat chino, Douyin y TikTok) y ninguna del
resto.
| Pieza | Claves | % de claves ≤ 3 car. | Rutas res/ |
% de rutas ≤ 3 car. |
|---|---|---|---|---|
| Termux 1022 (F-Droid) | 3.557 | 0,4 % | 639 | 84,8 % |
| F-Droid 2.0.2 (F-Droid) | 4.809 | 0,4 % | 703 | 72,0 % |
| VLC 13070206 (F-Droid) | 10.146 | 0,3 % | 2.424 | 89,2 % |
VLC 3.7.2, base.apk (Google Play) |
10.042 | 0,3 % | 1.775 | 0,0 % |
Keep 5.26, base.apk (Google Play) |
6.927 | 0,2 % | 956 | 74,8 % |
WhatsApp 2.26.42.9, base.apk (Google Play) |
19.825 | 0,2 % | 9.579 | 99,99 % |
| Netflix 9.88, APK único (Google Play) | 14.543 | 0,02 % | 6.320 | 99,98 % |
Snapchat 14.29, base.apk (Google Play) |
20.176 | 0,04 % | 4.807 | 96,9 % |
Shazam 16.64, base.apk (Google Play) |
7.490 | 0,3 % | 1.183 | 0,0 % |
WeChat 8.0.79, base.apk (Google Play) |
34.155 | 88,3 % | 16.503 | 99,99 % |
| WeChat 3200 (mercado chino) | 35.842 | 88,8 % | 3.218 | 0,1 % |
| Douyin 400801 (mercado chino) | 59.257 | 92,0 % | 5 | 0,0 % |
TikTok 47.4.16, base.apk (Google Play) |
46.253 | 79,0 % | 22.210 | 99,9 % |
WeChat 3200 y Douyin guardan sus ficheros en una carpeta r/ (13.986 y 44.103 ficheros). Las
piezas de Google Play de la tabla se descargaron de APKMirror.
El acortamiento de rutas está en casi todas partes; las claves cortas, solo en la familia de
WeChat, Douyin y TikTok. Una misma app puede cambiar según quién la compile: VLC tiene el 89,2 %
de rutas cortas en su APK de F-Droid y el 0,0 % en el base.apk de Play. Pero eso no quiere decir
que las demás claves estén intactas: esta medida no detecta los otros dos esquemas de renombrado,
que sustituyen todos los nombres por una cadena fija o por el número. Los tres aparecen en el
muestrario (contando apps, base y splits; ninguna de las cinco de protectores los lleva):
(name removed)es la constanteRESOURCE_NAME_REMOVEDde Redex, el optimizador de Meta, no deaapt2. La llevan 7 de las 658 apps de Google Play (WhatsApp y las otras seis de Meta en Play: Facebook, Messenger, Pages, Instagram, Threads y WhatsApp Business), 4 de ellas en la mitad o más de sus entradas, y 1 de 7 de las webs de los autores.0_resource_name_obfuscatedes lo que escribeaapt2 optimize --collapse-resource-names. Está en 1 app de F-Droid, 5 de IzzyOnDroid, 4 de Google Play, 1 del mercado chino y 1 de las webs de los autores, y en la mitad o más de las entradas en 1, 5, 3, 1 y 1 de ellas. Van de Snapchat, Chrome y Brave a Shizuku y LSPatch.- El
resource IDen decimal (por ejemplo2131230841) es lo que se ve en Netflix, con DexGuard, como se mide en la «sección 2.9 de Ofuscadores comerciales · Ofuscación de recursos». Está en 5 de las 658 apps de Google Play (4 en la mitad o más de las entradas), entre ellas Netflix y PayPal, y en ninguna de los demás orígenes.
Casi todas las entradas de una app así comparten un nombre, pero el keyStrings puede seguir
teniendo miles de cadenas. En el base.apk de WhatsApp, 41.086 de sus 60.940 entradas se llaman
(name removed) y el keyStrings tiene 19.825 cadenas. En el de Snapchat, 16.984 de 37.168 entradas
se llaman 0_resource_name_obfuscated. En Netflix, 13.145 de 14.543 claves son el resource ID en
decimal, y en PayPal (base.apk) 29.770 de 29.977. Fuera de Play: Brave de su web tiene 19.071 de
23.750 entradas colapsadas, y Xiaohongshu (mercado chino, com.xingin.xhs 9510803), 67.095 de
77.570. Donde las claves no se han tocado, la información que hace falta para deshacer la
ofuscación de recursos sigue en el fichero.
El caso, tal como se ve en el volcado de aapt2 dump chunks de Termux (com.termux 1022):
[ResTable_type] id: 0x07 name: drawable flags: 0x00 (DENSE) entryCount: 162 config: xhdpi
[ResTable_entry] id: 0x0006 name: abc_ab_share_pack_mtrl_alpha keyIndex: 1694 size: 8
[Res_value] size: 8 dataType: 0x03 data: 0x00000224 ((file) res/8w.9.png type=PNG)
[ResTable_entry] id: 0x000b name: abc_btn_check_to_on_mtrl_000 keyIndex: 1699 size: 8
[Res_value] size: 8 dataType: 0x03 data: 0x00000232 ((file) res/Yh.png type=PNG)
El fichero se llama res/8w.9.png, pero la entrada sigue diciendo abc_ab_share_pack_mtrl_alpha
y el tipo sigue diciendo drawable. La ruta legible es reconstruible de forma determinista:
res/<tipo><calificadores>/<key>.<extensión>
│ │ │ └── del contenido, o del sufijo .9.png que sí se conserva
│ │ └── ResTable_entry.key → keyStrings
│ └── ResTable_type.config → calificador
└── ResTable_type.id → typeStrings
En el ejemplo: res/drawable-xhdpi-v4/abc_ab_share_pack_mtrl_alpha.9.png. aapt2 añade -v4 al
directorio cuando el calificador es de densidad: la configuración no lleva sdkVersion (vale 0),
pero el directorio sí. Es la misma ruta que tiene la entrada en el split_config.xhdpi.apk de VLC
3.7.2, que no acorta las rutas. Reconstruir
así la ruta es deofuscación determinista, al mismo nivel que aplicar un mapping.txt: la
información no se adivina, se lee de la propia tabla. Se puede hacer en las apps con rutas
acortadas y claves legibles: 3.723 de 4.328 en F-Droid (86 %), 1.161 de 1.292 en IzzyOnDroid (90 %),
190 de 654 en Google Play (29 %), 44 de 364 en el sorteo (12 %), 42 de 88 en el mercado chino (48 %) y 4
de 7 en las webs de los autores.
La receta solo vale si las claves están intactas. Con nombres colapsados, todas las entradas de
un tipo comparten la misma key y la receta genera la misma ruta para todas: un APK de prueba con
dos drawable pasado por aapt2 optimize --collapse-resource-names da dos veces
res/drawable/0_resource_name_obfuscated.xml. En ese caso hay que desambiguar, por ejemplo
añadiendo la parte EEEE del resource ID al nombre.
Las dos operaciones que exige son renombrar la entrada del ZIP y actualizar la cadena
correspondiente del pool global —no la del keyStrings, que ya está bien—, más los
AndroidManifest.xml y los res/*.xml que referencien la ruta por texto. Ninguna toca la
estructura de la tabla.
Algunas herramientas, como AndResGuard (de Tencent), no acortan las rutas: cambian los nombres de
los recursos por otros de una o dos letras, como a o ab, y mueven los ficheros a una carpeta
r/. El muestrario tiene tablas con esa forma, sobre todo del mercado chino. Se cuenta como
«claves cortas» la app con al menos 50 claves y la mitad o más de ellas con tres caracteres o
menos. Las tienen 11 de 100 apps del mercado chino, 11 de 654 de Google Play (menos del 2 %), 1 de
1.320 de IzzyOnDroid y ninguna de F-Droid, del sorteo ni de las webs de los autores. La carpeta r/ en la raíz del ZIP (20 ficheros o más, de cualquier extensión) la llevan 14 de 100
apps del mercado chino, 1 de 658 de Google Play, 1 de 1.402 de IzzyOnDroid, y ninguna de F-Droid, del
sorteo ni de las webs de los autores. Las dos señales a la vez: 5 de 100 del mercado chino, 1 de Google
Play y 1 de IzzyOnDroid. No son solo cosa de China: las 11 de Google Play son TikTok, TikTok Lite,
trill, WeChat de Play, Kwai, Kwai video, SHAREit, SHAREit Lite, Oplus Theme Store, MangaToon y GO
Launcher. Y hay apps con r/ y claves legibles (Kuaishou, Xiaohongshu). Con datos estáticos no se
puede demostrar que la herramienta sea AndResGuard: lo que medimos es la forma del resultado.
Ejemplos:
- WeChat 3200 (mercado chino): 13.986 entradas bajo
r/, 13.967 con extensión de recurso. - Douyin (
com.ss.android.ugc.aweme400801): 54.495 claves cortas de 59.257 y 44.103 ficheros bajor/. - Kugou (
com.kugou.android20869): 36.578 claves cortas de 62.383 (58,6 %), sin carpetar/. - Baidu Search (
com.baidu.searchbox513934592): la única pieza china con tipos dispersos; también tiener/, con 17.663 ficheros.
En las tablas que no renombran (apps con al menos 50 claves y claves legibles) la proporción de
claves de tres caracteres o menos es baja: la mediana ronda el 0,3–0,5 % en todos los orígenes, y
el percentil 90 no pasa del 1,7 %. Los nombres cortos que se ven son legítimos (add, all,
top, on, off). Hay valores altos en apps muy pequeñas: el máximo de F-Droid es 33,71 % en
eu.veldsoft.house.of.cards (1; 60 de 178 claves), y el del mercado chino, 26,55 % en
com.eastmoney.android.berlin (11005000; 7.166 de 26.988), sin llegar al 50 %. Por eso el umbral
pide al menos 50 claves y el 50 %. Los dos esquemas de renombrado que no se ven por longitud
—cadena centinela única y resource ID en decimal— tienen sus huellas en la «sección 2.9 de
Ofuscadores comerciales · Ofuscación de recursos».
15. Recetas
Máquina de referencia: macOS, aapt2 2.20-15087165 de las build-tools 37.0.0. Las piezas de los
ejemplos son Termux (com.termux 1022) y F-Droid 2.0.2 (org.fdroid.fdroid 2000052).
15.1 aapt2 dump resources
BT=~/Library/Android/sdk/build-tools/37.0.0
MUESTRAS=~/muestras-apk
$BT/aapt2 dump resources $MUESTRAS/com.termux_1022.apk | head -6
Binary APK
Package name=com.termux id=7f
type anim id=01 entryCount=32
resource 0x7f010000 anim/abc_fade_in
() (file) res/vp1.xml type=XML
resource 0x7f010001 anim/abc_fade_out
El () es la configuración por defecto. Con un recurso traducido se ve la lista entera; de
org.fdroid.fdroid_2000052.apk, el recurso 0x7f110046 tiene 46 valores, y estos son los
primeros:
resource 0x7f110046 string/app_name_basic
() "F-Droid Basic"
(ca) "F-Droid Bàsic"
(fa) "افدروید پایه"
(ga) "F-Droid Bunúsach"
(ja) "F-Droid Basic"
(nb) "F-Droid Basic"
15.2 aapt2 dump configurations
Lista las configuraciones de la tabla, ya traducidas a calificadores de directorio.
$BT/aapt2 dump configurations $MUESTRAS/org.fdroid.fdroid_2000052.apk | head -8
h480dp
h720dp
sw480dp
sw600dp
watch
night
large
La primera línea vacía es la configuración por defecto. El fichero tiene 80 configuraciones
distintas. Es el orden en que aapt2 las imprime, no el de la tabla.
15.3 aapt2 dump chunks
Es el volcador oficial del formato y el mejor oráculo diferencial para un lector propio.
$BT/aapt2 dump chunks /tmp/vlc/config.xhdpi.apk | sed -n '240,252p'
Aquí /tmp/vlc/config.xhdpi.apk es el split_config.xhdpi.apk sacado del .apkm de VLC 3.7.2
(org.videolan.vlc, de APKMirror). Los números de línea de sed valen para este volcado y esta
versión de aapt2.
[RES_TABLE_TYPE_SPEC_TYPE] chunkSize: 3564 headerSize: 16 id: 0x08 types: 3 entry configs: 887
Entry qualifier masks:
#0x88 = 0x4000: layout_dir
[ResTable_type] chunkSize: 1524 headerSize: 84 id: 0x08 name: drawable flags: 0x01 (SPARSE) entryCount: 72 entryStart: 372 config: xhdpi
[ResTable_entry] id: 0x004b name: abc_ab_share_pack_mtrl_alpha keyIndex: 0 size: 8 flags: 0x0000
[Res_value] size: 8 dataType: 0x03 data: 0x00000000 ((file) res/drawable-xhdpi-v4/abc_ab_share_pack_mtrl_alpha.9.png type=PNG)
Fíjate en la máscara del typeSpec: solo la entrada 0x88 de las 887 varía, y varía por
layout_dir. Ese es el índice de la «sección 6 · ResTable_typeSpec» en acción. En el split equivalente de Keep 5.26
(com.google.android.keep, de APKMirror) la máscara es #0x13e = 0x4000 y el
ResTable_type es denso: DENSE, entryCount: 714, entryStart: 2940.
15.4 Volcado de chunks propio
El mismo recorrido de «XML binario, sección 8.2»,
descendiendo por headerSize y avanzando por size, aplicado a RES_TABLE_TYPE y
RES_TABLE_PACKAGE_TYPE. Sobre Termux (com.termux 1022):
fichero: resources.arsc (785084 bytes)
+0x000000 RES_TABLE_TYPE headerSize=12 size=785084 packageCount=1
+0x00000c RES_STRING_POOL_TYPE headerSize=28 size=222944 stringCount=6360 UTF-8
+0x0366ec RES_TABLE_PACKAGE_TYPE headerSize=288 size=562128 id=0x7f
name='com.termux' typeStrings=0x120 keyStrings=0x2a0
+0x03680c RES_STRING_POOL_TYPE headerSize=28 size=384 stringCount=19 UTF-16
+0x03698c RES_STRING_POOL_TYPE headerSize=28 size=121800 stringCount=3557 UTF-8
+0x054554 RES_TABLE_TYPE_SPEC_TYPE headerSize=16 size=144 id=0x01 entryCount=32
+0x0545e4 RES_TABLE_TYPE_TYPE headerSize=84 size=724 id=0x01 flags=0x00
entryCount=32 entriesStart=0xd4 config.size=64
…
El fichero completo tiene 259 chunks: 1 tabla, 3 string pools, 1 paquete, 18 typeSpec y 236
ResTable_type (los offsets y los recuentos salen de la clave arsc.termux_arbol_de_chunks de
scripts/muestrario/cifras/ejemplos_1.py). El mismo recorrido, aplicado a las 13.651 piezas con
resources.arsc (sin las cinco de protectores), da las cifras de las secciones «7.2», «7.3», «8.2», «12.1»,
«12.2» y «12.3». Resumido, sobre el total del muestrario: casi todos los ResTable_type llevan una
configuración de 64 bytes (más de un millón), ninguno usa FLAG_OFFSET16, los que usan FLAG_SPARSE
son 20.426 en Google Play, 2.151 en el sorteo y 45 en el mercado chino, y no hay ninguno en F-Droid,
IzzyOnDroid ni las webs de los autores. Los string pools están en UTF-8 aproximadamente el doble de
veces que en UTF-16 (por ejemplo, 9.596 frente a 4.714 en F-Droid), porque el pool global y el de
claves van en UTF-8 y solo el de tipos va en UTF-16. En cuanto a los chunks menos frecuentes: 542
RES_TABLE_LIBRARY_TYPE y 116 RES_TABLE_OVERLAYABLE_TYPE en Google Play, 37 y ninguno en el mercado
chino, y ningún RES_TABLE_STAGED_ALIAS_TYPE en ninguna parte.
15.5 apktool
apktool d -f -o salida $MUESTRAS/com.termux_1022.apk
ls salida/res | head -4
head -4 salida/res/values/strings.xml
anim
animator
color
color-night
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="abc_action_bar_home_description">Navigate home</string>
<string name="abc_action_bar_up_description">Navigate up</string>
Con -r, apktool copia resources.arsc en crudo y no decodifica nada:
apktool d -r -f -o salida-r $MUESTRAS/com.termux_1022.apk
I: Copying raw resources.arsc...
I: Baksmaling classes.dex...
I: Copying raw AndroidManifest.xml...
Lo verificamos con apktool 3.0.3 el 31 de octubre de 2026 sobre tres piezas del muestrario: Termux
(com.termux 1022), F-Droid 2.0.2 (org.fdroid.fdroid 2000052) y
com.programminghoch10.AntiBrightnessChange (60, de IzzyOnDroid). Dos consecuencias de -r que
no son obvias y que muerden:
- El manifiesto tampoco se decodifica. Lo dice la tercera línea: queda como
AXMLbinario, no como XML de texto, porque resolver sus referencias exige la tabla que-rno ha leído. - El
apktool.ymlsale con datos distintos, y peor. En Termux, sin-rdeclaraminSdkVersion: 24ytargetSdkVersion: 28; con-r,minSdkVersion: 25y ningúntargetSdkVersion. El valor real, contrastado conaapt2 dump badging, es 24 y 28. Tampoco es siempre «uno más»: en F-Droid 2.0.2 el valor real es 24 y 37, y-rescribe 25 y ningúntargetSdkVersion; encom.programminghoch10.AntiBrightnessChangeel real es 33 y 33, y-rescribe 29. En modo-rel dato es sencillamente incorrecto, y quien reconstruya desde ahí obtiene unAPKcon unminSdkVersionque no es el del original. Son tres piezas elegidas, no una proporción.
16. Cómo son las tablas reales
Una tabla de recursos va de unos cientos de bytes a decenas de megabytes. Esta sección dice cómo son en el muestrario, para que quien escriba un lector sepa qué tamaños y qué formas esperar.
16.1 Tamaño
Mediana del tamaño de la tabla (pieza base o única): 548.356 bytes en F-Droid, 709.540 en
IzzyOnDroid, 2.000.514 en Google Play, 577.092 en el sorteo, 2.813.508 en el mercado chino y 9.017.384
en las webs de los autores. La mayor de cada origen: 63.214.260 en F-Droid (el teclado
com.wasimaster.wmkeyboard), 16.883.020 en IzzyOnDroid, 179.023.448 en Google Play (Samsung Health 7.1, con
1.069.577 cadenas), 4.344.916 en el sorteo, 32.998.656 en el mercado chino y 39.125.040 en las webs de los
autores. La menor de F-Droid mide 384 bytes y no tiene entradas (pro.rudloff.search_to_browser, 2); la
menor de IzzyOnDroid mide 40 bytes, la tabla vacía de la «sección 3 · RES_TABLE_TYPE / ResTable_header» (com.programminghoch10.AntiBrightnessChange).
Los tipos por tabla tienen una mediana de 16 en F-Droid y en IzzyOnDroid, y entre 18 y 20 en los demás
orígenes. Los ResTable_type por tabla, una mediana de 145 en F-Droid, 150 en IzzyOnDroid, 155 en
Google Play, 71 en el sorteo, 140 en el mercado chino y 332 en las webs de los autores.
16.2 Marcos multiplataforma
Un marco multiplataforma (Flutter, React Native, Unity…) es una biblioteca que permite escribir una app una vez para varios sistemas. Cambia la forma de la tabla. «Sin marco» quiere decir que no se detectó ninguno, por la biblioteca nativa y la estructura de la app. Mira las dos últimas columnas: en F-Droid, Flutter, Godot y libGDX dejan tablas pequeñas, y React Native una grande.
| Origen | Marco | Apps | Mediana de entradas presentes | Mediana de bytes de la tabla |
|---|---|---|---|---|
| F-Droid | Flutter | 509 | 897 | 191.596 |
| F-Droid | React Native | 96 | 5.361 | 1.179.820 |
| F-Droid | Capacitor | 72 | 1.342 | 284.654 |
| F-Droid | Cordova | 23 | 1.179 | 230.400 |
| F-Droid | Kotlin / Compose Multiplatform | 127 | 1.652 | 692.656 |
| F-Droid | Godot | 40 | 275 | 57.522 |
| F-Droid | libGDX | 41 | 8 | 3.184 |
| F-Droid | sin marco | 2.380 | 3.383 | 713.684 |
| Google Play | Flutter | 33 | 7.990 | 1.507.748 |
| Google Play | React Native | 50 | 18.975 | 2.797.156 |
| Google Play | Unity | 110 | 5.291 | 1.473.688 |
| Google Play | Kotlin Multiplatform | 23 | 16.224 | 2.182.516 |
| Google Play | sin marco | 184 | 7.440 | 1.753.476 |
| Sorteo de Google Play | Flutter | 66 | 1.544 | 143.748 |
| Sorteo de Google Play | React Native | 37 | 5.619 | 641.780 |
| Sorteo de Google Play | Unity | 84 | 1.873 | 586.604 |
| Sorteo de Google Play | sin marco | 116 | 5.558 | 716.386 |
En una app de Flutter casi todo va en assets/ y en bibliotecas nativas: la mediana es de 897
entradas y 191.596 bytes en F-Droid, frente a 3.383 entradas y 713.684 bytes en las apps sin marco. En
libGDX la mediana es de 8 entradas y 3.184 bytes. Por eso quien busque los textos de una app de
Flutter en resources.arsc suele buscar en el sitio equivocado.
16.3 Splits de Play
Cifras de piezas de Play. Los 1.522 splits de densidad llevan tipos drawable en 1.515, style en
1.066, dimen en 628 e integer en 156, y suelen tener de tres a cinco densidades distintas («sección
8.5 · Densidad»). Tienen tipos dispersos 430 de los 1.522 de densidad (más de uno de cada cuatro), 1.103 de
los 4.406 de idioma (una cuarta parte) y 5 de los 91 módulos con tabla. De los splits de
idioma, llevan el tipo string 4.380, plurals 3.779, array 2.792 y drawable 283. Cada split
de idioma trae pocos idiomas: una mediana de 1 en Google Play (percentil 90: 3; máximo 206) y de 5 en el
sorteo (máximo 10). Los idiomas de la base dependen de cómo se descargó la app: mediana de 0 en los
.apkm (percentil 90: 105; máximo 212; 388 apps), 1 en los .xapk (percentil 90: 107; máximo 238;
68 apps), 92 en los .apk sueltos (percentil 90: 139; 202 apps) y 0 en las carpetas de adb
(percentil 90: 91; máximo 121; 365 apps).
16.4 F-Droid frente a IzzyOnDroid
Hay 218 pares de piezas del mismo paquete: una versión solo en F-Droid y otra solo en IzzyOnDroid.
Ningún par tiene tipos dispersos, configuraciones de menos de 64 bytes ni claves cortas. Las rutas
acortadas están en las dos versiones de 199 pares, solo en la de F-Droid en 3, solo en la de
IzzyOnDroid en 3 y en ninguna en 13. typesCount = 0 en todos los typeSpec de las dos versiones
ocurre en 42 pares, solo en la de F-Droid en 4 y en ninguna en 172. Dos ejemplos de la misma app
compilada de forma distinta: AppManager 451, con 1.181 de 1.443 rutas cortas en F-Droid y 0 de 1.444
en IzzyOnDroid, y Farebot, con 4 de 696 en F-Droid (versión 3920) y 696 de 784 en IzzyOnDroid
(versión 4842).
16.5 Protectores
Un protector (APKiD 3.1.0 los detecta) casi nunca toca los recursos; es lo que dice «Packers y protectores». Contando apps, base o única, llevan protector 53 de 653 de Google Play (8 %), 40 de 98 del mercado chino (41 %), 2 de 367 del sorteo, 1 de 4.766 de F-Droid y ninguna de IzzyOnDroid ni de las webs de los autores. Entre las apps con protector, tienen las rutas acortadas 17 de 53 de Google Play (32 %) frente a 199 de 600 sin protector (33 %), y 23 de 40 del mercado chino (57 %) frente a 25 de 58 (43 %). Tienen claves cortas 0 de 53 de Google Play y 0 de 40 del mercado chino, frente a 11 de 600 de Google Play y 11 de 58 del mercado chino sin protector. Entre las 36 apps de Google Play que APKiD etiqueta como DexGuard (una etiqueta con falsos positivos), 6 tienen las claves colapsadas. Tienen alguna anomalía en la tabla («sección 17 · Tablas que rompen a los lectores») 4 de las 40 del mercado chino con protector y 0 de las 53 de Google Play; sin protector, 2 de las 4.765 de F-Droid (las de Fyne).
17. Tablas que rompen a los lectores
De las 13.651 tablas del muestrario, 6 tienen algo que un lector estricto no acepta. Ninguna es de las cinco de protectores, y el lector propio de este documento no falló en ninguna.
Dos de F-Droid, hechas con Fyne. com.github.howeyc.crocgui (48, tabla de 616 bytes) y
net.ser1.forage (43) declaran una configuración de 52 bytes dentro de una cabecera de 56 («sección
7 · ResTable_type»). apktool d falla en las dos con «Could not decode arsc file», y el error de fondo es «Illegal
backwards jump from 616 to 600» (BinaryResourceParser). aapt2 dump resources las lee sin quejarse
y devuelve el código 0.
Cuatro del mercado chino, con el protector NetEase. Son com.weipaitang.wpt (801),
com.youdao.translator (20260903), com.babycloud.hanju (8391) y com.yek.android.kfc.activitys
(63700). Cada una tiene una entrada que Android no puede leer, porque está desalineada, no cabe o
tiene un valor de menos de 8 bytes: la última entrada del tipo id trae un Res_value de 3 bytes en
vez de 8. En la primera es el paquete 0x7f, tipo 0x09, índice 7222 (zxingview); en la segunda,
el tipo 0x0a. Aquí aapt2 dump resources también devuelve el código 0 y sin error, pero lista dos
ids seguidos con el mismo nombre: en com.yek.android.kfc.activitys, 0x7f0a0b85 y 0x7f0a0b86 son
los dos id/zoom. apktool d termina con el código 0 y sin aviso, pero 0x7f0a0b86 no aparece en
public.xml: la entrada rota se pierde. NetEase está en 6 apps del muestrario. Las otras dos, de
Play, no tienen la entrada mala: com.block.juggle (10.9.0, pieza base.apk) y com.doomsday.shelter11 (pieza base.apk).
Con las mismas herramientas sobre una submuestra de 112 apps (25 de F-Droid, 15 de IzzyOnDroid, 25
de Google Play, 20 del sorteo, 20 del mercado chino y las 7 de las webs de los autores; 117 con las cinco de
protectores), apktool d falla en 1, una del mercado chino (Douyin Lite, con un NullPointerException),
y en ninguna de las demás. apktool b falla en 1 de 25 de Google Play, 1 de 20 del sorteo, 2 de 19 del
mercado chino y 1 de 7 de las webs de los autores. jadx no da ningún error de recursos. No sabemos
cuántas piezas del muestrario entero rompen apktool d o jadx: solo tenemos esta submuestra.
Fuentes
frameworks/base/libs/androidfw/include/androidfw/ResourceTypes.h(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/include/androidfw/ResourceTypes.h Consultado el 25 de septiembre de 2026, descargado con?format=TEXTy decodificado. De aquí salen íntegras las tablas de campos de las secciones «3», «5», «6», «7», «8.1», «10», «11», «12.1», «12.2», «12.3» y «12.5», las constantesSPEC_*,FLAG_*,ATTR_*,TYPE_*,PolicyFlags, las macrosRes_MAKEID/Res_GETPACKAGE/Res_GETTYPE/Res_GETENTRY,kResTableTypeMinSize,offset_from16,ResTable_config::copyFromDeviceNoSwap(«sección 8.2 · El problema del size variable») y losstatic_assertde queResTable_configva al final deResTable_typey de que ocupa 64 bytes. Consultado de nuevo el 18 de octubre de 2026: de aquí salen tambiénRes_MAKEARRAY(línea 282) de la «sección 10.1 · La entrada normal»,MINORVERSION_ANY(línea 1190) de la 8.1 y las constantesRES_TABLE_FLAGGEDyRES_TABLE_FLAG_LIST(líneas 264-265) de la 12.5, que la misma cabecera enandroid-16.0.0_r1—https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/libs/androidfw/include/androidfw/ResourceTypes.h, consultada el mismo día— no define.frameworks/base/libs/androidfw/ResourceTypes.cpp(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/ResourceTypes.cpp Consultado el 25 de septiembre de 2026. De aquí salenunpackLanguageOrRegionypackLanguageOrRegion(«sección 8.3 · language y country: el truco del bit alto»), yResTable_config::match(),isBetterThan(),isLocaleBetterThan()eisMoreSpecificThan()(«sección 9 · Cómo elige Android qué entrada usar»).frameworks/base/libs/androidfw/LoadedArsc.cpp(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/LoadedArsc.cpp Consultado el 25 de septiembre de 2026. De aquí salenVerifyResTableType,VerifyResTableEntry(«sección 10.3 · Lo que AOSP valida en cada entrada»),GetEntryOffsetcon la búsqueda binaria sobre las entradas dispersas («sección 7.3 · FLAG_SPARSE y ResTable_sparseTypeEntry»), el límite de 65.535 entradas por tipo («sección 11 · La estructura del resource ID: 0xPPTTEEEE»), las reglas de orden entretypeSpecytypede la «sección 2 · El árbol de chunks» y la carga deRES_TABLE_FLAGGEDyRES_TABLE_FLAG_LIST(«sección 12.5 · RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)»). Consultado de nuevo el 18 de octubre de 2026: de aquí sale que el único mínimo eskResTableTypeMinSize(línea 474), sin suelo paraconfig.size(«sección 8.2 · El problema del size variable»), la tercera regla de orden de la «sección 2 · El árbol de chunks» (líneas 942-998 y 678-685), que el array de offsets se busca enheaderSize(líneas 105, 268 y 412; «sección 7 · ResTable_type») y el papel detypeIdOffseten elTT(líneas 250, 453, 565-570 y 631-635; «sección 11 · La estructura del resource ID: 0xPPTTEEEE»).frameworks/base/tools/aapt2/Resource.h(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/Resource.h Consultado el 25 de septiembre de 2026. De aquí salenkAppPackageId = 0x7f,kFrameworkPackageId = 0x01y la descripción canónica de0xPPTTEEEEde la «sección 11 · La estructura del resource ID: 0xPPTTEEEE».frameworks/base/tools/aapt2/cmd/Link.cpp(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/cmd/Link.cpp Consultado el 25 de septiembre de 2026. De aquí salen la validación del rango de--package-id, el0x00que asigna--shared-lib, el rango reservado0x02–0x7ede--allow-reserved-package-idy la explicación del comportamiento previo a Android 8, todo en la «sección 11 · La estructura del resource ID: 0xPPTTEEEE».frameworks/base/tools/aapt2/format/binary/TableFlattener.cppyTableFlattener.h(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/format/binary/TableFlattener.cpp Consultado el 25 de septiembre de 2026. De aquí salen las condiciones exactas con queaapt2emiteFLAG_SPARSE,FLAG_OFFSET16yFLAG_COMPACT, y la constantekSparseEncodingThreshold = 60de las secciones «7.2», «7.3» y «10.2», y dónde escribe los chunks de la «sección 12.5 · RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)». La opción--force-sparse-encodingde la «sección 7.3 · FLAG_SPARSE y ResTable_sparseTypeEntry» está entools/aapt2/cmd/Convert.h, en la misma etiqueta. Consultado de nuevo el 18 de octubre de 2026: de aquí salen el cálculo de las máscaras deltypeSpec(líneas 424-446) de la «sección 6 · ResTable_typeSpec» y que la forma compacta se decide por cadaResTable_type(UseCompactEntries, líneas 144-152) de la «sección 10.2 · La entrada compacta: FLAG_COMPACT».- AOSP —
ResourceTypes.hdeandroid-3.2.4_r1aandroid-17.0.0_r1— https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-3.2.4_r1/include/utils/ResourceTypes.h y la misma cabecera en cada etiqueta, eninclude/androidfw/desdeandroid-4.1.1_r1y enlibs/androidfw/include/androidfw/desdeandroid-8.0.0_r1. Consultado el 12 de agosto de 2026 enandroid-4.4_r1,android-5.0.0_r1,android-6.0.0_r1,android-7.1.2_r36,android-9.0.0_r1yandroid-11.0.0_r1, y el 25 de septiembre de 2026 en dieciséis etiquetas deandroid-3.2.4_r1aandroid-17.0.0_r1. De aquí salen el historial de campos y el de tamaños deResTable_configde la «sección 8.2 · El problema del size variable», este medido conclang++ -fsyntax-onlyparaaarch64yarmv7ade Android. - apktool — parámetros de la CLI — https://apktool.org/docs/cli-parameters Consultado el 12 de agosto de 2026. De aquí sale la sintaxis de la receta 15.5.
- apktool 3.0.3 — instalado y ejecutado el 31 de octubre de 2026 sobre
Termux, F-Droid 2.0.2 y
com.programminghoch10.AntiBrightnessChange, con y sin-r. De aquí salen las dos salidas de la «sección 15.5 · apktool» y la discrepancia medida deminSdkVersionentre los dos modos, contrastada conaapt2 dump badging. frameworks/base/libs/androidfw/LoadedArsc.cpp,AssetManager2.cppytools/aapt2/format/binary/TableFlattener.cpp(etiquetaandroid-16.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/libs/androidfw/AssetManager2.cpp Consultado el 25 de septiembre de 2026. De aquí salen elheaderSizede 284 sintypeIdOffset(«sección 5 · ResTable_package»), el literal?Ncon queaapt2rellena el hueco destyleableymacro(«sección 5 · ResTable_package»), el tratamiento dePP = 0como paquete dinámico y el límite deentryCount ≤ 0xFFFF(«sección 11 · La estructura del resource ID: 0xPPTTEEEE»).FeatureSetMetadata.ktdel Android Gradle Plugin (ramamirror-goog-studio-main) — 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/featuresplit/FeatureSetMetadata.kt Consultado el 25 de septiembre de 2026. De aquí sale la asignación dePPa los módulos de funcionalidad a partir deBASE_ID = 0x7F(«sección 11 · La estructura del resource ID: 0xPPTTEEEE»).- bundletool 1.18.3 —
LanguageResourcesSplitter.java— https://github.com/google/bundletool/blob/6b51fd7641fd3496d2d88f7619696c8c3d71935f/src/main/java/com/android/tools/build/bundletool/splitters/LanguageResourcesSplitter.java Consultado el 25 de septiembre de 2026. De aquí sale quebundletooldivide los recursos por losConfigValuedelresources.pb(«sección 6 · ResTable_typeSpec»). aapt2 optimize --collapse-resource-namesde lasbuild-tools37.0.0 — ejecutado el 25 de septiembre de 2026 sobre un APK de prueba con dosdrawable. De aquí sale la ruta repetida de la receta de la «sección 14 · Recursos ofuscados».include/utils/ResourceTypes.hantes y en las primeras etiquetas de AOSP — espejoaosp-mirror/platform_frameworks_basede GitHub, commits54b6cfa(Initial Contribution, 21 de octubre de 2008),1059253(importación decupcake_rel, 19 de marzo de 2009) y723738c(Expand support for different screen sizes, 26 de junio de 2009) — https://github.com/aosp-mirror/platform_frameworks_base/blob/54b6cfa9a9e5b861a9930af873580d6dc20f773c/include/utils/ResourceTypes.h —, y la misma ruta en Gitiles enandroid-1.6_r1,android-2.2_r1yandroid-2.3.7_r1. Consultado el 18 de octubre de 2026. De aquí salen los tamaños de 28 y 32 bytes de la «sección 8.2 · El problema del size variable», medidos con el mismo método que la fuente 7.frameworks/base/tools/aapt2/format/binary/ResEntryWriter.cpp,BinaryResourceParser.cppytools/aapt2/ResourceParser.cpp(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/format/binary/ResEntryWriter.cpp Consultado el 18 de octubre de 2026. De aquí salen las clavesATTR_MIN + ide los arrays (ResEntryWriter.cpp, línea 105), que el lector deaapt2no mira la clave de un array (BinaryResourceParser.cpp, líneas 723-731) y que los valores de<enum>y<flag>se escriben con la clave de un recursoid(ResourceParser.cpp, líneas 1482-1512, yResEntryWriter.cpp, líneas 69-72), en la «sección 10.1 · La entrada normal»; y que una entrada compleja nunca se escribe en forma compacta (ResEntryWriter.cpp, líneas 216-217 y 227-236), en la 10.2.frameworks/base/tools/aapt/ResourceTable.cppylibs/androidfw/ResourceTypes.cpp(etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt/ResourceTable.cpp Consultado el 18 de octubre de 2026. De aquí sale que elaaptantiguo nombra^index_Na los elementos de un array (línea 1575) y queResTableconvierte ese nombre enRes_MAKEARRAY(N)(ResourceTypes.cpp, línea 5220), en la «sección 10.1 · La entrada normal».frameworks/base/libs/androidfw/ConfigDescription.cpp(etiquetasandroid-16.0.0_r1yandroid-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/ConfigDescription.cpp Consultado el 18 de octubre de 2026. De aquí saleparseVersioncon y sin versión menor (líneas 632-696 enandroid-17.0.0_r1), en la «sección 8.1 · La tabla completa».aapt22.20-15087165 de lasbuild-tools37.0.0 — ejecutado el 18 de octubre de 2026 conaapt2 compileyaapt2 link, contra elandroid.jardeandroid-36, sobre unAPKde prueba con una cadena enres/values/y otra enres/values-v36.1/, y leído conaapt2 dump resourcesy un recorrido propio delresources.arsc. De aquí sale elminorVersion = 1de la «sección 8.1 · La tabla completa».- Redex —
libredex/RedexResources.h— https://github.com/facebook/redex/blob/f02f9ab50d5639c0829f96cb4055283c5dc3425c/libredex/RedexResources.h Consultado el 18 de octubre de 2026. De aquí sale la constanteRESOURCE_NAME_REMOVEDcon el valor(name removed)(línea 31) de la «sección 14 · Recursos ofuscados». frameworks/base/libs/androidfw/ResourceTypes.cpp(etiquetaandroid-7.1.2_r36) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-7.1.2_r36/libs/androidfw/ResourceTypes.cpp Consultado el 18 de octubre de 2026, descargado con?format=TEXTy decodificado. De aquí sale que elResTablede Android 7.1 rechaza unResTable_typecuyoentryCountno coincide con el de sutypeSpec(líneas 6370-6373) y que, con la tabla en error,getResourcedevuelve ese error (líneas 3992-3994), en la «sección 7.3 · FLAG_SPARSE y ResTable_sparseTypeEntry».- Recuento de claves y rutas cortas sobre trece piezas del muestrario —
Termux, F-Droid 2.0.2 y VLC (13070206) de F-Droid, y diez de Play y del mercado chino,
descargadas entre el 19 y el 27 de octubre de 2026. Ejecutado con
python3 -I scripts/muestrario/cifras/recursos_1.py. De aquí sale la definición de «% de rutas ≤ 3 car.» y la tabla de la «sección 14 · Recursos ofuscados». - El muestrario — descrito en «El muestrario».
Las cifras de las «secciones 3 · RES_TABLE_TYPE / ResTable_header» a 17 salen de
scripts/muestrario/cifras/recursos_1.py, salvo las que lo dicen: el pool global mayor («sección 4 · El string pool global») y las apps con más de un paquete, demanifiesto_2.py; los nombres centinela de la «sección 14 · Recursos ofuscados», deofuscacion_y_protectores_5.py; los splits y el ZIP de la «sección 3 · RES_TABLE_TYPE / ResTable_header», dezip_y_contenedores_5.py; los chunks sin atribuir de la «sección 12.3 · RES_TABLE_STAGED_ALIAS_TYPE (0x0206)», deframeworks_y_bibliotecas_2.py; y los fallos deapktoolyjadxde la «sección 17 · Tablas que rompen a los lectores», deherramientas_2.py. Para repetirlas:MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/recursos_1.py --salida <fichero.json>(y lo mismo con cada script). Los offsets de los ejemplos de las secciones «7.1» y «7.3» y el árbol de la «sección 15.4 · Volcado de chunks propio» salen de las clavesarsc.termux_tipo_bool,arsc.vlc_xhdpi_dispersoyarsc.termux_arbol_de_chunksdescripts/muestrario/cifras/ejemplos_1.py, que se ejecuta de la misma manera. Medidas hechas entre el 19 y el 27 de octubre de 2026.