Compatibilidad con tamaños de página de 16 KB

Requisito de compatibilidad con Google Play de 16 KB

A partir del 1 de noviembre de 2025, todas las apps nuevas y las actualizaciones de apps existentes que se envíen a Google Play y que tengan como objetivo dispositivos con Android 15 o versiones posteriores deberán admitir tamaños de página de 16 KB en dispositivos de 64 bits.

Más información →

Históricamente, Android solo admitió tamaños de página de memoria de 4 KB, lo que optimizó el rendimiento de la memoria del sistema para la cantidad promedio de memoria total que suelen tener los dispositivos Android. A partir de Android 15, el AOSP admite dispositivos configurados para usar un tamaño de página de 16 KB (dispositivos de 16 KB). Si tu app usa alguna biblioteca del NDK, ya sea directamente o a través de un SDK, deberás volver a compilarla para que funcione en estos dispositivos de 16 KB.

A medida que los fabricantes de dispositivos sigan creando dispositivos con mayores cantidades de memoria física (RAM), muchos de estos dispositivos adoptarán tamaños de página de 16 KB (y, con el tiempo, incluso mayores) para optimizar el rendimiento del dispositivo. Agregar compatibilidad con dispositivos con tamaño de página de 16 KB permite que tu app se ejecute en estos dispositivos y se beneficie de las mejoras de rendimiento asociadas. Sin recompilación, las apps no funcionarán en dispositivos de 16 KB en futuras versiones de Android.

Para ayudarte a agregar compatibilidad con tu app, te proporcionamos orientación sobre cómo comprobar si tu app se ve afectada, cómo volver a compilar tu app (si corresponde) y cómo probar tu app en un entorno de 16 KB con emuladores (incluidas las imágenes del sistema de Android 15 para Android Emulator).

Beneficios y mejoras en el rendimiento

Los dispositivos configurados con tamaños de página de 16 KB usan un poco más de memoria en promedio, pero también obtienen varias mejoras de rendimiento para el sistema y las apps:

• Tiempos de inicio de la app más bajos mientras el sistema está bajo presión de memoria: un 3.16% más bajo en promedio, con mejoras más significativas (hasta un 30%) para algunas apps que probamos
• Menor consumo de energía durante el lanzamiento de la app: Reducción promedio del 4.56%
• Inicio más rápido de la cámara: Inicios en caliente un 4.48% más rápidos en promedio y, en promedio, un 6.60% más rápidos en frío
• Mejor tiempo de inicio del sistema: se mejoró en un 8% (aproximadamente 950 milisegundos) en promedio.

Estas mejoras se basan en nuestras pruebas iniciales, y es probable que los resultados en los dispositivos reales difieran. Proporcionaremos análisis adicionales de posibles ganancias para las apps a medida que continuemos con las pruebas.

Verifica si tu app se ve afectada

Si tu app usa código nativo, debes recompilarla para que sea compatible con dispositivos de 16 KB. Si no sabes con seguridad si tu app usa código nativo, puedes usar el Analizador de APK para identificar si hay código nativo presente y, luego, verificar la alineación de los segmentos ELF de las bibliotecas compartidas que encuentres. Android Studio también proporciona funciones que te ayudan a detectar automáticamente problemas de alineación.

Si tu app solo usa código escrito en el lenguaje de programación Java o en Kotlin, incluidas todas las bibliotecas o SDKs, ya es compatible con dispositivos de 16 KB. Sin embargo, te recomendamos que pruebes tu app en un entorno de 16 KB para verificar que no haya regresiones inesperadas en el comportamiento de la app.

¿Tu app usa código nativo?

Tu app usa código nativo si se cumple alguna de las siguientes condiciones:

• Tu app usa cualquier código (nativo) C/C++. Si tu app usa el NDK de Android, significa que usa código nativo.
• Tu app se vincula con bibliotecas o dependencias nativas de terceros (como SDKs) que las usan.
• Tu app se compiló con un compilador de apps externo que usa bibliotecas nativas en el dispositivo.

Identifica bibliotecas nativas con el Analizador de APK

El Analizador de APK es una herramienta que te permite evaluar varios aspectos de un APK compilado. Para verificar si tu app usa código nativo (independientemente de si es compatible con 16 KB), haz lo siguiente:

1. Abre Android Studio, haz clic en File > Open y elige cualquier proyecto.

2. En la barra de menú, haz clic en Build > Analyze APK…

   

3. Elige el APK que quieras analizar.

4. Busca en la carpeta lib, que aloja archivos de objetos compartidos (.so) si hay alguno. Si hay archivos de objetos compartidos, tu app usa código nativo. En la columna Alineación, se muestran mensajes de advertencia para los archivos que tienen problemas de alineación. Si no hay archivos de objetos compartidos o no hay una carpeta lib, tu app no usa código nativo.

   

Detecta problemas de alineación con verificaciones automáticas

Android Studio te advierte de forma proactiva si tus bibliotecas o APKs prediseñados no cumplen con los 16 KB. Usa la herramienta APK Analyzer para revisar qué bibliotecas deben actualizarse o si se requieren cambios en el código.

Lint en Android Studio también destaca las bibliotecas nativas que no están alineadas en 16 KB.

Verifica la alineación de los segmentos ELF para las bibliotecas compartidas

En el caso de las bibliotecas compartidas, verifica que los segmentos ELF de las bibliotecas compartidas estén alineados correctamente con una alineación de ELF de 16 KB. Si desarrollas en Linux o macOS, puedes usar la secuencia de comandos check_elf_alignment.sh como se describe en la siguiente sección. También puedes usar las herramientas de línea de comandos directamente.

Usa la secuencia de comandos check_elf_alignment.sh (Linux o macOS)

Sigue estos pasos para verificar la alineación de los segmentos ELF con la secuencia de comandos check_elf_alignment.sh:

1. Guarda la secuencia de comandos check_elf_alignment.sh en un archivo.

2. Ejecuta la secuencia de comandos en el archivo APK de tu app:

   check_elf_alignment.sh APK_NAME.apk
   

   La secuencia de comandos genera ALIGNED o UNALIGNED para todas las bibliotecas compartidas de arm64-v8a.

3. Si alguna biblioteca compartida arm64-v8a o x86_64 es UNALIGNED, deberás actualizar el empaquetado de esas bibliotecas, luego volver a compilar tu app y volver a realizar las pruebas siguiendo los pasos de esta sección.

Usa herramientas de línea de comandos directamente

Sigue estos pasos para verificar la alineación de los segmentos ELF directamente con herramientas de línea de comandos:

1. Asegúrate de que la versión 35.0.0 o posterior de las herramientas de compilación del SDK de Android y el NDK de Android estén instalados con el SDK Manager en Android Studio o la herramienta de línea de comandos sdkmanager.

2. Sigue estos pasos para extraer el archivo APK de tu app:

   Linux o macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

   Expand-Archive -Path .\APK_NAME.apk -DestinationPath ~\tmp\my_apk_out
   

3. En el directorio temporal en el que extrajiste el archivo APK, verifica el contenido del directorio lib para ver si hay archivos de objetos compartidos (.so). Estos son los mismos archivos de objetos compartidos que habrías visto mientras identificabas bibliotecas nativas con el Analizador de APK. Ejecuta el siguiente comando en cada archivo de objeto compartido:

   Linux o macOS

   SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-objdump -p SHARED_OBJECT_FILE.so | grep LOAD
   

   Windows (PowerShell)

   SDK_ROOT_LOCATION\Android\sdk\ndk\NDK_VERSION\toolchains\llvm\prebuilt\windows-x86_64\bin\llvm-objdump.exe -p SHARED_OBJECT_FILE.so | Select-String -Pattern "LOAD"
   

   Aquí, SDK_ROOT_LOCATION es la ruta de acceso al directorio en el que instalaste el SDK de Android, SHARED_OBJECT_FILE es el nombre del archivo de objeto compartido que estás verificando y NDK_VERSION es la versión del NDK de Android que instalaste (por ejemplo, 28.0.12433566). El resultado será similar al siguiente para cada archivo que verifiques:

   LOAD off    0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**14
   LOAD off    0x0000000000042a90 vaddr 0x0000000000043a90 paddr 0x0000000000043a90 align 2**14
   LOAD off    0x0000000000046230 vaddr 0x0000000000048230 paddr 0x0000000000048230 align 2**14
   

4. Verifica las líneas de salida para asegurarte de que los segmentos de carga no tengan valores inferiores a 2**14. Si algún segmento de carga tiene valores de 2**13, 2**12 o inferiores, deberás actualizar el empaquetado de esas bibliotecas y, luego, volver a compilar tu app y realizar pruebas nuevamente siguiendo los pasos de esta sección.

5. A continuación, ejecuta la herramienta de línea de comandos de zipalign en el archivo APK de tu app:

   Linux o macOS

   SDK_ROOT_LOCATION/Android/sdk/build-tools/35.0.0/zipalign -v -c -P 16 4 APK_NAME.apk
   

   Windows (PowerShell)

   SDK_ROOT_LOCATION\Android\sdk\build-tools\35.0.0\zipalign.exe -v -c -P 16 4 APK_NAME.apk
   

   Aquí, SDK_ROOT_LOCATION es la ruta de acceso al directorio en el que instalaste el SDK de Android y APK_NAME es el nombre del archivo APK de tu app. La última línea del resultado indicará "Verification successful" si todas las bibliotecas compartidas están alineadas correctamente.

   Si la verificación falló, algunas bibliotecas compartidas deben realinearse, por lo que deberás actualizar el empaquetado de esas bibliotecas, luego volver a compilar tu app y volver a probarla siguiendo los pasos de esta sección.

Compila tu app para que sea compatible con dispositivos de 16 KB

Si tu app usa código nativo, completa los pasos que se describen en las siguientes secciones para asegurarte de que admita dispositivos de 16 KB:

1. Actualiza el empaquetado de tus bibliotecas compartidas
2. Compila tu app con una alineación ELF de 16 KB
3. Cómo corregir el código y resolver problemas de tiempo de ejecución
4. Cómo verificar si los SDKs admiten 16 KB

Actualiza el empaquetado de tus bibliotecas compartidas

Te recomendamos que actualices a la versión 8.5.1 o posterior de AGP y que uses bibliotecas compartidas sin comprimir.

AGP versión 8.5.1 o posterior

Los dispositivos de 16 KB requieren que las apps que se entregan con bibliotecas compartidas sin comprimir las alineen en un límite alineado con zip de 16 KB. Para ello, debes actualizar a la versión 8.5.1 o una posterior del complemento de Android para Gradle (AGP). Consulta la sección Asistente de actualización del complemento de Gradle para Android para obtener detalles sobre el proceso de actualización.

AGP versión 8.5 o anterior

Si no puedes actualizar AGP a la versión 8.5.1 o posterior, la alternativa es cambiar a bibliotecas compartidas comprimidas. Actualiza tu configuración de Gradle para que Gradle comprima tus bibliotecas compartidas cuando empaquete tu app y, así, evitar problemas de instalación de la app con bibliotecas compartidas no alineadas.

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging true
      }
  }
}

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

Compila tu app con una alineación ELF de 16 KB

Los dispositivos de 16 KB requieren que los segmentos ELF de las bibliotecas compartidas se alineen correctamente con la alineación de ELF de 16 KB para que se ejecute tu app.

Si eres desarrollador de juegos y tu juego se ejecuta sobre el motor de juegos de Unity, consulta la guía de Unity. Si tu juego se ejecuta sobre el motor de juegos de Unreal, consulta la guía de Unreal. Para los motores de juegos nativos, continúa con esta guía.

Para compilar tu app con una alineación de ELF de 16 KB, completa los pasos de una de las siguientes secciones según la versión del NDK de Android que uses.

NDK de Android r28 y versiones posteriores

Las versiones r28 y posteriores del NDK se compilan de forma predeterminada con una alineación de 16 KB.

NDK de Android r27

Para admitir la compilación de bibliotecas compartidas alineadas en 16 KB con la versión r27 y posteriores del NDK de Android, debes actualizar las marcas de ndk-build, build.gradle, build.gradle.kts o del vinculador de la siguiente manera:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments += listOf("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON")
      }
    }
  }
}

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

NDK de Android r26 y versiones anteriores

Para admitir la compilación de bibliotecas compartidas alineadas en 16 KB con la versión r26 o una anterior del NDK de Android, debes actualizar tu configuración de ndk-build o cmake de la siguiente manera:

LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"

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

NDK de Android r22 y versiones anteriores

Además del paso que se describe para NDK r26 y versiones anteriores, debes establecer common-page-size=16384 si usas NDK r22 o una versión anterior. Es necesario configurar common-page-size=16384 debido a errores en versiones anteriores de los vinculadores GNU ld y LLVM lld. Sin embargo, te recomendamos que actualices tus herramientas a una versión más reciente para evitar estos errores por completo.

Para compilar bibliotecas compartidas compatibles con 16 KB con la versión r22 o anterior del NDK de Android, actualiza tu configuración de ndk-build o cmake de la siguiente manera:

LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"
LOCAL_LDFLAGS += "-Wl,-z,common-page-size=16384"

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")

Corrige el código y resuelve problemas de tiempo de ejecución

Incluso si tu app está alineada con 16 KB, puede tener errores si hay lugares en tu código que suponen que un dispositivo usa un tamaño de página específico. Para evitar esto, completa los siguientes pasos:

1. Quita cualquier dependencia codificada de forma rígida que haga referencia a la constante PAGE_SIZE o a instancias en la lógica de tu código que supongan que el tamaño de página de un dispositivo es de 4 KB (4096).

   En su lugar, usa getpagesize() o sysconf(_SC_PAGESIZE).

2. Busca usos de mmap() y otras APIs que requieran argumentos alineados con la página, y reemplázalos por alternativas cuando sea necesario.

En algunos casos, si tu app usa PAGE_SIZE como un valor conveniente que no está vinculado al tamaño de página subyacente, esto no provocará que la app deje de funcionar cuando se use en el modo de 16 KB. Sin embargo, si este valor se pasa al kernel con mmap sin MAP_FIXED, el kernel sigue usando una página completa, lo que desperdicia algo de memoria. Por estos motivos, PAGE_SIZE no está definido cuando el modo de 16 KB está habilitado en NDK r27 y versiones posteriores.

Si tu app usa PAGE_SIZE de esta manera y nunca pasa este valor directamente al kernel, en lugar de usar PAGE_SIZE, crea una variable nueva con un nombre nuevo para reflejar que se usa para otros fines y no refleja una página de memoria real.

Verifica si los SDK admiten 16 KB

Muchos SDKs son compatibles con tamaños de página de 16 KB, en especial si los compilas tú mismo o obtienes compilaciones previas recientes. Sin embargo, como algunas versiones o compilaciones previas del SDK no son compatibles con 16 KB, debes consultar el sitio web de cada proveedor del SDK para determinar qué versión usar con 16 KB.

Prueba tu app en un entorno de 16 KB

Después de compilar tu app para que sea compatible con dispositivos de 16 KB, te recomendamos que la pruebes en un entorno de 16 KB para ver si experimenta alguna regresión. Para hacerlo, sigue estos pasos:

1. Configura el SDK de Android 15.

2. Configura uno de los siguientes entornos de prueba:

   • Configura Android Emulator con una imagen del sistema Android 15 basada en 16 KB
     • Cómo usar Cuttlefish con un tamaño de página de 16 KB en ARM64
     • Cómo simular Cuttlefish con un tamaño de página de 16 KB en x86-64
   • Cómo habilitar el modo de 16 KB en un dispositivo con las opciones para desarrolladores

3. Enciende el dispositivo de prueba y, luego, ejecuta el siguiente comando para verificar que esté usando un entorno de 16 KB:

   adb shell getconf PAGE_SIZE
   

   El comando debería devolver un valor de 16384.

4. Ejecuta el siguiente comando de zipalign para verificar que tu app esté alineada en 16 KB, donde APK_NAME es el nombre del archivo APK de tu app:

   zipalign -c -P 16 -v 4 APK_NAME.apk
   

5. Prueba tu app a fondo y enfócate en las áreas que podrían verse afectadas por el cambio de instancias de código que hacen referencia a tamaños de página específicos.

Configura Android Emulator con una imagen del sistema Android 15 basada en 16 KB

Para configurar un entorno de 16 KB con el emulador de Android, sigue estos pasos:

1. Las imágenes del sistema del emulador de Android 15 basadas en 16 KB son compatibles con Android Studio Jellyfish | 2023.3.1 o versiones posteriores. Sin embargo, para obtener la mejor experiencia cuando trabajes con dispositivos de 16 KB, usa Android Studio Ladybug | 2024.2.1 o versiones posteriores.

   Siempre estamos trabajando en nuevas funciones, así que considera descargar versiones más recientes o la versión preliminar más reciente de Android Studio a medida que estén disponibles.

   Recuerda que no es necesario desinstalar la versión actual que tienes de Android Studio, ya que puedes tener varias versiones instaladas al mismo tiempo.

2. En Android Studio, haz clic en Tools > SDK Manager.

3. En la pestaña SDK Platforms, marca Show Package Details y, luego, expande la sección Android VanillaIceCream o una posterior, y selecciona una o ambas de las siguientes imágenes del sistema del emulador, según los dispositivos virtuales que quieras crear:

   • Imagen del sistema ARM 64 v8a de tamaño de página de 16 KB experimental de las APIs de Google
   • Imagen del sistema Google APIs Experimental 16 KB Page Size Intel x86_64 Atom

   

4. Haz clic en Aplicar > Aceptar para descargar las imágenes del sistema que seleccionaste.

5. Sigue los pasos para configurar un dispositivo virtual para Android 15 y, cuando se te solicite que selecciones una imagen del sistema, elige la imagen del sistema de 16 KB que descargaste. Si no se recomienda automáticamente, puedes encontrar la imagen del sistema de 16 KB en la pestaña Otras imágenes.

   

Pasos adicionales para algunas versiones del emulador y algunas imágenes del sistema

Para las versiones del emulador de Android de la 35.1.5 a la 35.1.20, y antes de la revisión 4 de las imágenes del sistema de tamaño de página de 16 KB de Android 15.0 que se ofrecen en el SDK Manager, para simular un entorno de 16 KB en sistemas x86_64, también debes completar los siguientes pasos. Estos pasos no son necesarios después de la versión 35.1.21 y con la revisión 4 de las imágenes del sistema de tamaño de página de 16 KB de Android 15.0 o versiones posteriores.

1. En el Administrador de dispositivos, haz clic en los 3 puntos junto a la imagen de 16 KB y, luego, en Mostrar en el disco.
2. En esta carpeta, busca el archivo config.ini.

3. Agrega la siguiente línea al archivo config.ini y guarda los cambios:

   kernel.parameters = androidboot.page_shift=14
   

4. Para verificar los cambios, ejecuta el siguiente comando, que debería devolver 16384:

   adb shell getconf PAGE_SIZE
   

Inicia el emulador

Después de terminar de configurar el emulador de Android y los dispositivos virtuales, inicia el emulador desde el menú del dispositivo de destino o desde la línea de comandos.

Habilita el modo de 16 KB en un dispositivo con las opciones para desarrolladores

Activa la opción para desarrolladores Iniciar con tamaño de página de 16 KB para iniciar un dispositivo en el modo de 16 KB.

A partir de Android 15 QPR1, puedes usar la opción para desarrolladores disponible en ciertos dispositivos para iniciar el dispositivo en modo de 16 KB y realizar pruebas en el dispositivo. Antes de usar la opción para desarrolladores, ve a Configuración > Sistema > Actualizaciones de software y aplica las actualizaciones disponibles.

Esta opción para desarrolladores está disponible en los siguientes dispositivos:

• Pixel 8 y 8 Pro (con Android 15 QPR1 o versiones posteriores)

  Advertencia: Debido a un problema conocido con la versión beta 3 de QPR2 de Android 15, la pantalla táctil no funciona en los dispositivos Pixel 8 después de instalar la versión beta 3 de QPR2 de Android 15 y arrancar el dispositivo en modo de 16 KB. Este problema no afecta a los dispositivos Pixel 8 Pro.

• Pixel 8a (con Android 15 QPR1 o versiones posteriores)

  Advertencia: Debido a un problema conocido con la versión beta 3 de QPR2 de Android 15, la pantalla táctil no funciona en los dispositivos Pixel 8a después de instalar la versión beta 3 de QPR2 de Android 15 y de iniciar el dispositivo en modo de 16 KB.

• Pixel 9, 9 Pro y 9 Pro XL (con Android 15 QPR2 Beta 2 o versiones posteriores)

Requisito de compatibilidad con Google Play

A medida que los fabricantes de dispositivos equipan los dispositivos con más RAM para optimizar el rendimiento, muchos adoptarán tamaños de página más grandes, como 16 KB. Para prepararse para el lanzamiento de estos próximos dispositivos, Google Play presenta un nuevo requisito de compatibilidad: a partir del 1 de noviembre de 2025, todas las apps nuevas y las actualizaciones de las apps existentes que se envíen a Google Play y que tengan como objetivo dispositivos que ejecuten Android 15 (nivel de API 35) y versiones posteriores deberán admitir tamaños de página de 16 KB.

Para obtener más información sobre este requisito de compatibilidad, consulta esta entrada de blog.