Servicios Cómo trabajo Soluciones Blog Herramientas Contacto Hablemos de tu proyecto

Requisito de Google Play: compatibilidad con páginas de 16 KB en Android 15 — qué es y cómo adaptar tu app

Logo yanquirm.dev
Publicado el
Requisito de Google Play: compatibilidad con páginas de 16 KB en Android 15 — qué es y cómo adaptar tu app

Resumen rápido

Qué cambia: Android 15 añade soporte para páginas de memoria de 16 KB. Google Play pedirá que las apps compatibles con Android 15+ funcionen correctamente en dispositivos configurados con 16 KB.

Fechas clave: A partir del 1 de noviembre de 2025, todas las nuevas apps y actualizaciones que apunten a Android 15+ deberán soportar 16 KB. Google ha comunicado por email a algunos desarrolladores un segundo hito alrededor del 1 de mayo de 2026 para bloquear publicaciones de actualizaciones no compatibles; revisa tu consola porque la documentación pública destaca sobre todo el hito del 1 de noviembre de 2025.

¿Te afecta?

  • Apps solo Java/Kotlin: normalmente ya cumplen (aun así, prueba).
  • Apps con código nativo (NDK) o SDKs que incluyen .so: debes recompilar y alinear tus binarios para 16 KB y ajustar el empaquetado.

¿Qué es una “página de 16 KB” y por qué importa?

Android históricamente usó páginas de 4 KB. Con Android 15, AOSP permite dispositivos configurados con 16 KB para mejorar rendimiento (menos traducciones de memoria, mejores arranques, etc.). En pruebas de Google se observan lanzamientos de apps hasta un 3–30% más rápidos, menos consumo durante el arranque, cámara más veloz y arranque del sistema más rápido.

Traducción práctica: si tus binarios nativos asumen 4 KB o están mal alineados, tu app puede no instalarse o fallar en dispositivos 16 KB (presentes y futuros).

¿Quién debe hacer cambios?

Usas solo Java/Kotlin (sin NDK ni SDKs nativos): en principio nada que cambiar. Aun así, prueba en un entorno de 16 KB.

Usas NDK, librerías o motores que traen .so (Unity, Unreal, SDKs de terceros):

  • 1. verifica si tienes nativos,
  • 2. recompila/actualiza tu toolchain y dependencias,
  • 3. ajusta el empaquetado/zipalign,
  • 4. arregla código que “asume” 4 KB, y
  • 5. prueba y valida.

Paso 1 · Detecta si tu app está afectada

APK Analyzer (Android Studio → Build → Analyze APK…). Si ves .so en lib/, usas nativos. También te marca warnings de alineación.

Script/check manual de ELF: usa el script oficial check_elf_alignment.sh o readelf -l para comprobar que los segmentos LOAD estén a align 2**14 (16 KB).

zipalign de verificación:


zipalign -v -c -P 16 4 app-release.apk

Debe terminar en “Verification successful”.

Paso 2 · Actualiza toolchain y empaquetado

a) Android Gradle Plugin (AGP) y empaquetado

Recomendado: AGP ≥ 8.5.1 con librerías nativas sin comprimir; así Play puede zipalign a 16 KB correctamente. En AGP 8.3–8.5, bundletool no zipaligna por defecto y podrías ver que en local “funciona” pero falla tras construir desde el bundle en Play.

Si no puedes subir a 8.5.1 aún: cambia temporalmente a librerías comprimidas (legacy packaging) para evitar problemas de instalación desde Play:

Groovy:


android {
  packagingOptions {
    jniLibs { useLegacyPackaging true }
  }
}

Kotlin:


android {
  packagingOptions {
    jniLibs { useLegacyPackaging = true }
  }
}

Ten en cuenta que ocupa más espacio y puede aumentar fallos de instalación por almacenamiento insuficiente; lo ideal es migrar a AGP ≥ 8.5.1.

b) NDK y flags de enlace (ELF 16 KB)

NDK r28 o superior: ya compila 16 KB por defecto.

NDK r27: habilita “flexible page sizes” o añade flags de 16 KB:

ndk-build( Application.mk):

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

CMake (CMakeLists.txt):


target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384") 
target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,common-page-size=16384")

Gradle → externalNativeBuild (CMake):


externalNativeBuild {
  cmake { arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON" }
}


externalNativeBuild {
  cmake { arguments += listOf("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON") }
}

Otros build systems: añade el linker flag:

-Wl,-z,max-page-size=16384

Para NDK más antiguos podrían requerirse también common-page-size=16384 (mejor actualiza NDK).

c) Actualiza SDKs/engines de terceros

Unity/Unreal: siguen guías específicas para 16 KB; revisa la versión recomendada por cada motor.

React Native / Flutter y otros frameworks: las versiones recientes ya se declaran compatibles, pero verifica que tus módulos nativos y SDKs estén reconstruidos para 16 KB.

Aquí te dejo un artículo donde te explico más a detalle que cambios realizar en un proyecto con Flutter: Cómo solucionar el problema de compatibilidad de 16 KB en Flutter.

Paso 3 · Corrige código que “asume” 4 KB

Aunque tus .so estén alineados, puede fallar si usas constantes que suponen un tamaño de página fijo (4 KB).

Evita usar PAGE_SIZE (se vuelve indefinido en modo 16 KB en NDK r27+).

Usa getpagesize() o sysconf(_SC_PAGESIZE) para obtenerlo en tiempo de ejecución.

Revisa usos de mmap() y APIs que requieren alineación a página.

Paso 4 · Prueba en un entorno de 16 KB

Emulador con imagen de Android 15 (16 KB) desde el SDK Manager.

Dispositivo físico (algunos Pixel/Samsung permiten activar 16 KB en opciones de desarrollador) o laboratorios remotos.

Comprueba el entorno:

adb shell getconf PAGE_SIZE # Debe devolver 16384

Valida empaquetado con zipalign -c -P 16 4 ... y prueba flujos críticos.

Errores típicos y cómo resolverlos

“Mi app funciona en local pero falla al instalar desde Play”

Suele ser por APK no zipalineado a 16 KB al generarse desde el App Bundle. Actualiza a AGP ≥ 8.5.1 o usa temporalmente useLegacyPackaging.

“Uso un SDK de terceros y no puedo recompilarlo”

Pide al proveedor una versión 16 KB-compatible (prebuilt actualizado) o reorganiza dependencias para evitar ese binario.

“Mi código usa PAGE_SIZE o alinea buffers manualmente”

Cambia a getpagesize() o sysconf(_SC_PAGESIZE) y revisa los usos de mmap().

Checklist de cumplimiento (copiable)

  • Actualizado a AGP ≥ 8.5.1 (o useLegacyPackaging temporal).
  • Compilas con NDK r28+ (o r27 con flags/argumentos para 16 KB).
  • Todos tus .so (incluidos terceros) están alineados a 16 KB.
  • No hay asunciones de 4 KB en el código; usas getpagesize()/sysconf.
  • zipalign OK (-P 16) y pruebas superadas en emulador/dispositivo 16 KB.

Fechas y qué pasa si no cumples

Desde el 1 de noviembre de 2025: Google Play rechazará nuevas apps/actualizaciones que apunten a Android 15+ si no soportan 16 KB en dispositivos de 64 bits.

Comunicaciones de Play hablan además de un bloqueo de actualizaciones hacia mayo de 2026 para apps que sigan sin soporte; consulta tu Play Console y los emails de Play para tu caso.

Preguntas frecuentes

¿Y si mi app no targetea Android 15 aún?

El requisito bloquea publicaciones cuando apuntas a Android 15+ desde noviembre de 2025. Aun así, migre cuanto antes, porque los dispositivos 16 KB ya existen y futuras versiones de Android se apoyarán en ello.

¿Afecta a 32-bit?

El requisito de Play se menciona para dispositivos de 64 bits. De todas formas, el ecosistema Android ya impulsa 64-bit y conviene tenerlo todo actualizado.

¿Qué beneficio real verán mis usuarios?

Mejoras de rendimiento y energía (arranques de app más rápidos, cámara más ágil, boot del sistema más corto). Los resultados concretos varían por dispositivo.

Conclusión

No es “otro cambio de Play” sin más: 16 KB mejora la base de rendimiento de Android y tus binarios nativos deben adaptarse. Si actualizas AGP/NDK, recompilas con alineación 16 KB, ajustas empaquetado y pruebas en 16 KB, cumplirás sin sustos en revisión y te asegurarás compatibilidad futura.

Fuentes clave y guías oficiales