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

Requisito de compatibilidad de 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 se segmenten para dispositivos con Android 15 o versiones posteriores deben admitir tamaños de página de 16 KB en dispositivos de 64 bits.

Más información →

Android 过去仅支持 4 KB 内存页面大小， 优化了系统内存性能，以针对 Android 设备通常具备的功能。从 Android 15 开始，AOSP 支持 配置为使用 16 KB (16 KB) 页面大小的设备 设备）。如果您的应用使用任何 NDK 库，请直接使用 或者通过 SDK 间接创建，那么，您需要重新构建自己的应用 支持这些 16KB 设备。

随着设备制造商不断打造出 物理内存 (RAM)，许多此类设备都会采用 16KB（以及 页面大小以优化设备的性能。正在添加 支持 16 KB 页面大小的设备，可使您的应用在这些设备上运行 并有助于您的应用从相关的广告效果中获益 改进。如果不重新编译，应用可能无法在 16KB 设备上运行 在未来的 Android 版本中正式推出。

为帮助您为应用添加支持，我们提供了有关如何检查 如果您的应用受到影响 重新构建您的应用（如果适用），以及如何在 Google Play 中 使用模拟器（包括 Android 15）的 16 KB 环境 系统映像）。

Beneficios y mejoras de rendimiento

配置为使用 16 KB 页面大小的设备平均会使用略多一些的内存，但系统和应用的性能也会得到各种提升：

• 缩短了系统内存压力时的应用启动时间：平均降低了 3.16%；对于我们测试的某些应用而言，改进幅度更大（最高可达 30%）
• 应用启动期间的功耗降低：平均降低了 4.56%
• 相机启动更快：热启动速度平均提高了 4.48%，冷启动速度平均提高了 6.60%
• 缩短了系统启动时间：平均缩短了 8%（约 950 毫秒）

这些改进基于我们的初始测试，实际设备上的结果可能会有所不同。随着测试的继续进行，我们将进一步分析应用的潜在收益。

Verifica si tu app se verá afectada

如果您的应用使用了任何原生代码，则应重新构建应用以支持 16 KB 设备。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器确定是否存在任何原生代码，然后检查您找到的任何共享库的 ELF 段对齐情况。

如果您的应用仅使用以 Java 或 Kotlin 编程语言编写的代码（包括所有库或 SDK），则该应用已经支持 16 KB 设备。不过，我们建议您在 16 KB 环境中测试应用，以验证应用行为是否没有意外回归。

¿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 cualquier biblioteca o dependencia nativa de terceros (como los SDKs) que las usen.
• Tu app se compiló mediante un compilador de apps de terceros 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 quieres analizar.

4. Busca en la carpeta lib, que aloja archivos de objetos compartidos (.so) si los hay. Si hay archivos de objetos compartidos, tu app usa código nativo. Si no hay archivos de objetos compartidos o no hay una carpeta lib, tu app no usa código nativo.

   

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 la alineación 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 muestra 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 la prueba 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 con herramientas de línea de comandos directamente:

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 Administrador de SDK en Android Studio o la herramienta de línea de comandos sdkmanager.

2. Extrae el archivo APK de la 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 al que extrajiste el archivo APK, verifica el contenido del directorio lib en busca de archivos de objetos compartidos (.so). Estos son los mismos archivos de objetos compartidos que verías cuando identificas 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"
   

   En el que 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 se verá de la siguiente manera 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 menores que 2**14. Si algún segmento de carga es 2**13, 2**12 o valores inferiores, deberás actualizar el empaquetado de esas bibliotecas, luego volver a compilar tu app y volver a realizar la prueba siguiendo los pasos que se indican en 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
   

   Donde 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 dirá "Verification successful" si todas las bibliotecas compartidas están alineadas correctamente.

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

Compila tu app con compatibilidad para 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 sea compatible con 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 del entorno de ejecución
4. Cómo verificar la compatibilidad de los SDKs con 16 KB

Sugerencia: Si actualizas tus herramientas a las versiones más recientes (versión 8.5.1 de AGP o una posterior, y versión r28 del NDK o una posterior) y usas dependencias precompiladas compatibles con 16 KB, tu app es compatible con 16 KB de forma predeterminada y puedes omitir el paso para corregir el código y resolver problemas del entorno de ejecución.

Actualiza el empaquetado de tus bibliotecas compartidas

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

AGP versión 8.5.1 o posterior

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

AGP versión 8.5 o versiones anteriores

Nota: En las versiones 8.3 a 8.5 de AGP, las apps se alinean de forma predeterminada en 16 KB. Sin embargo, bundletool no alinea los APKs de forma predeterminada. Por lo tanto, es posible que la app funcione, pero no se instale cuando se compile a partir de un paquete en Play.

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

Groovy

En tu archivo build.gradle, agrega la siguiente opción:

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

Kotlin

En tu archivo build.gradle.kts, agrega la siguiente opción:

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

Advertencia: Cuando usas bibliotecas compartidas comprimidas, tu app ocupa más espacio cuando se instala, ya que las bibliotecas se extraen del APK y se copian en el disco. Es posible que tu app falle con más frecuencia durante la instalación porque este aumento en el uso del disco significa que hay menos espacio en el dispositivo. Para evitar esto, actualiza a la versión 8.5.1 de AGP o una posterior.

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 ELF de 16 KB para que se ejecute tu app.

Para desarrolladores de juegos, si tu juego se ejecuta en el motor de juegos de Unity, consulta la guía de Unity. Si tu juego se ejecuta en el motor de juego Unreal, consulta la guía de Unreal. Para los motores de juegos nativos, continúa con esta guía.

Nota: Si tu app no extrae bibliotecas nativas al sistema de archivos (extractNativeLibs establecida en false), es probable que notes un ligero aumento en el tamaño binario de tu app después de compilarla con una alineación ELF de 16 KB. Las optimizaciones del administrador de paquetes en Android 15 anulan los costos del tiempo de ejecución de este aumento.

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

Importante: Si tu app usa bibliotecas compartidas precompiladas, también debes volver a compilarlas de la misma manera y volver a importar las bibliotecas alineadas de 16 KB a tu app.

NDK de Android r28 y versiones posteriores

La versión r28 del NDK y versiones posteriores compilan 16 KB alineados de forma predeterminada.

NDK de Android r27

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

ndk-build

En tu Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

En tu archivo build.gradle, establece el argumento -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 "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

Kotlin

En tu archivo build.gradle.kts, establece el argumento -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")
      }
    }
  }
}

Otros sistemas de compilaciones

Especifica las siguientes marcas de vinculador:

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

Android NDK r26 y versiones anteriores

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

ndk-build

Actualiza tu Android.mk para habilitar la alineación ELF de 16 KB:

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

CMake

Actualiza tu CMakeLists.txt para habilitar la alineación ELF de 16 KB:

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 configurar common-page-size=16384 si usas NDK r22 o versiones anteriores. Es obligatorio configurar common-page-size=16384 debido a errores en versiones anteriores de los enlazadores 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 la configuración de ndk-build o cmake de la siguiente manera:

ndk-build

Actualiza tu Android.mk para compilar un ELF compatible con 16 KB:

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

CMake

Actualiza tu CMakeLists.txt para compilar un ELF compatible con 16 KB:

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

Importante: Incluso si tu app se vincula de forma dinámica a la biblioteca estándar de C++ (libc++_shared.so) de NDKs r26 y versiones anteriores, algunas de las cuales no están alineadas con 16 KB, debes actualizar la alineación de todas las demás bibliotecas aquí y debes actualizar tu código para evitar depender de PAGE_SIZE. Para probar esas versiones anteriores del NDK en dispositivos de 16 KB, las versiones canary de las versiones LTS del NDK r23 y r25 están disponibles en Android CI con bibliotecas libc++_shared.so alineadas de 16 KB. Independientemente de esto, se recomienda cambiar a la versión r27 o posterior del NDK de Android para actualizar a la versión alineada ELF de 16 KB de la biblioteca estándar de C++. De lo contrario, tu app no se instalará en dispositivos de 16 KB hoy.

Si no puedes cambiar al NDK de Android más reciente, es posible que puedas actualizar tu app para compilar de forma estática la biblioteca estándar de C++ en tu biblioteca compartida. Consulta la sección Compatibilidad con la biblioteca C++ para obtener detalles sobre la vinculación estática a la biblioteca estándar de C++ y asegúrate de leer la sección Consideraciones importantes.

Corrige el código y resuelve problemas del entorno de ejecución

Incluso si tu app está alineada en 16 KB, es posible que se produzcan errores si en tu código se supone que un dispositivo usa un tamaño de página específico. Para evitar esto, completa los siguientes pasos:

1. Quita las dependencias fijas que hagan referencia a la constante PAGE_SIZE o a instancias en la lógica de tu código que den por sentado 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 hará que la app falle 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 aún usa una página completa, lo que desperdicia memoria. Por estos motivos, PAGE_SIZE no se define cuando se habilita el modo de 16 KB en el 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 la compatibilidad de los SDKs con 16 KB

Muchos SDKs son compatibles con tamaños de página de 16 KB, en especial si los compilas por tu cuenta o obtienes compilaciones previas recientes. Sin embargo, como algunas compilaciones previas o versiones 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 con compatibilidad para 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
   • Habilita el modo de 16 KB en un dispositivo con las opciones para desarrolladores
   • Cómo usar Cuttlefish con 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

3. Inicia 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 mostrar un valor de 16384.

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

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

5. Prueba tu app en detalle 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 de Android 15 basada en 16 KB

Importante: Existe un problema conocido que impide la depuración con LLDB con imágenes del sistema del emulador de 16 KB. Se incluye una solución para este problema en el NDK r27 RC 1 y la actualización de funciones de Android Studio Koala | 2024.1.2 Canary 5.

Para configurar un entorno de 16 KB con Android Emulator, 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 instalar varias versiones juntas.

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 experimental de tamaño de página de 16 KB de las APIs de Google
   • Imagen del sistema experimental de Google APIs con tamaño de página de 16 KB para Intel x86_64 Atom
   Nota: Si planeas emular un dispositivo Google Pixel compatible, solo necesitarás la imagen del sistema ARM 64 v8a.

   

4. Haz clic en Apply > OK 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

En el caso de las versiones 35.1.5 a 35.1.20 de Android Emulator 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 Administrador de SDK, 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 mostrar 16384:

   adb shell getconf PAGE_SIZE
   

Cómo iniciar el emulador

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

使用开发者选项在设备上启用 16 KB 模式

切换以 16KB 页面大小启动设备开发者选项，以便在 16 KB 模式下启动设备。

从 Android 15 QPR1 开始，您可以使用某些设备上提供的开发者选项，以 16 KB 模式启动设备并执行设备端测试。在使用开发者选项之前，请依次前往“设置”->“系统”->“软件更新”，然后应用所有可用的更新。

此开发者选项适用于以下设备：

• Pixel 8 和 Pixel 8 Pro（搭载 Android 15 QPR1 或更高版本）

  警告：由于 Android 15 QPR2 Beta 版 3 存在已知问题，在安装 Android 15 QPR2 Beta 版 3 并以 16 KB 模式启动设备后，Pixel 8 设备上的触摸屏无法正常使用。此问题不会影响 Pixel 8 Pro 设备。

• Pixel 8a（搭载 Android 15 QPR1 或更高版本）

  警告：由于 Android 15 QPR2 Beta 版 3 存在已知问题，在安装 Android 15 QPR2 Beta 版 3 并以 16 KB 模式启动设备后，Pixel 8a 设备上的触摸屏无法正常使用。

• Pixel 9、Pixel 9 Pro 和 Pixel 9 Pro XL（搭载 Android 15 QPR2 Beta 2 或更高版本）

Nota: Android 15 QPR2 está en versión beta. Para obtener más información sobre cómo obtener QPR2 en un dispositivo apto, consulta Cómo obtener compilaciones de la versión beta de QPR para Android 15.

Requisitos de compatibilidad de 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 preparar el lanzamiento de estos próximos dispositivos, Google Play presenta un requisito de compatibilidad para todas las apps nuevas y las actualizaciones de las apps existentes, y se orienta a dispositivos con Android 15 y versiones posteriores para admitir tamaños de página de 16 KB a partir del 1 de noviembre de 2025.

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