Hasta ahora, Android solo admitía tamaños de página de memoria de 4 KB, que tienen rendimiento optimizado de la memoria del sistema para la cantidad promedio de memoria total que Los dispositivos Android solían tener. A partir de Android 15, AOSP admite dispositivos configurados para usar un tamaño de página de 16 KB (16 KB) dispositivos). Si tu app usa bibliotecas del NDK, hazlo directamente o indirectamente a través de un SDK, tendrás que recompilar tu app para que Funciona en estos dispositivos de 16 KB.
A medida que los fabricantes siguen creando dispositivos con mayores cantidades memoria física (RAM), muchos de estos dispositivos adoptarán 16 KB (y eventualmente mayores) para optimizar el rendimiento del dispositivo. Agregando la compatibilidad con dispositivos de tamaño de página de 16 KB permite que tu app se ejecute en estos y ayuda a que tu app se aproveche del rendimiento asociado mejoras continuas. Sin la recompilación, es posible que las apps no funcionen en dispositivos de 16 KB. cuando se producen en versiones futuras de Android.
Para ayudarte a que tu aplicación sea compatible, proporcionamos orientación sobre cómo verificar si tu app se ve afectada, cómo volver a compilar tu app (si corresponde) y saber cómo probarla en un entorno de 16 KB con emuladores (incluido Android 15 imágenes del sistema 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 tanto para el sistema como para las apps:
- Menores tiempos de inicio de la app 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
- Consumo de energía reducido durante el lanzamiento de la app: reducción promedio del 4.56%
- Lanzamiento más rápido de la cámara: inicios en caliente un 4.48% más rápidos en promedio y inicios en frío un 6.60% más rápidos en promedio
- Tiempo de inicio del sistema mejorado: Mejora en un 1.5% (aproximadamente 0.8 segundos) en promedio.
Estas mejoras se basan en nuestras pruebas iniciales, y es probable que los resultados en dispositivos reales difieran. Proporcionaremos un análisis adicional de los posibles beneficios de las apps a medida que continuemos con las pruebas.
Comprueba si tu app se ve afectada
Si tu app usa cualquier código nativo, debes volver a compilarla y admitir 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.
Si tu app solo usa código escrito en el lenguaje de programación Java o en Kotlin, incluidas todas las bibliotecas o SDKs, entonces 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 su comportamiento.
¿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 la función Android NDK, tu app usará código nativo.
- Tu app se vincula con bibliotecas nativas o dependencias de terceros que los usan.
- La app se creó con un compilador de apps externo que usa bibliotecas nativas dispositivo.
Cómo identificar bibliotecas nativas con el Analizador de APK
El Analizador de APK es una herramienta que permite evaluar varios aspectos de un APK Para identificar si tu app usa código nativo o bibliotecas, sigue estos pasos: pasos:
- Abre Android Studio y haz clic en File > Abre y elige cualquier proyecto.
Desde la barra de menú, haz clic en Build > Analizar APK...
Elige el APK que quieras analizar.
Busca en la carpeta
lib
, que aloja archivos de objeto compartido (.so
) si los hay. están presentes. Si hay archivos de objetos compartidos, tu app usa recursos código. Si no hay archivos de objetos compartidos o no hay una carpetalib
, haz lo siguiente: tu app no usa código nativo.
Compila tu app con compatibilidad para dispositivos de 16 KB
Para admitir dispositivos de 16 KB, las apps que usan código nativo deben completar la de pasos que se describen en las siguientes secciones.
Actualizar el empaquetado de las bibliotecas compartidas
Te recomendamos que actualices a la versión 8.3 del AGP o una posterior, y que uses la las bibliotecas compartidas.
AGP versión 8.3 o posterior
Los dispositivos de 16 KB requieren que las apps que incluyen bibliotecas compartidas sin comprimir realicen lo siguiente: Alínealas en un límite alineado de 16 KB. Para hacerlo, debes actualizar al complemento de Android para Gradle (AGP) versión 8.3 o posterior. Consulta el artículo Android Asistente de actualización del complemento de Gradle para obtener detalles sobre el proceso de actualización.
AGP versión 8.2 o anterior
Si no puedes actualizar el AGP a la versión 8.3 o una versión posterior, la alternativa es para usar bibliotecas compartidas comprimidas. Actualiza la configuración de Gradle para Haz que Gradle comprima tus bibliotecas compartidas cuando empaquete tu app para evitar que la app problemas de instalación 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
}
}
}
Compila tu app con la alineación ELF de 16 KB
Los dispositivos de 16 KB requieren las bibliotecas compartidas Segmentos ELF que se deben alinear correctamente con la alineación ELF de 16 KB para que se ejecute tu app.
Para compilar tu app con la alineación ELF de 16 KB, completa los pasos de una de las siguientes opciones: las siguientes secciones, según la versión del NDK de Android que usan.
NDK de Android r26 y versiones anteriores
Compatibilidad con la compilación de bibliotecas compartidas alineadas con 16 KB con el NDK de Android
versión r26 o anterior, debes actualizar tu ndk-build
o cmake
configuración de la siguiente manera:
ndk-build
Actualiza tu Android.mk
para habilitar la alineación del ELF de 16 KB:
LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"
CMake
Actualiza tu CMakeLists.txt
para habilitar la alineación del ELF de 16 KB:
target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
NDK de Android r27 y versiones posteriores
Compatibilidad con la compilación de bibliotecas compartidas alineadas con 16 KB con el NDK de Android
versión r27 o posterior, debes actualizar tu ndk-build
, build.gradle
,
build.gradle.kts
, o marcas 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 del vinculador:
-Wl,-z,max-page-size=16384
Verifica si hay instancias de código que hagan referencia a tamaños de página específicos
Incluso si tu app está alineada con 16 KB, puede encontrar errores si se producen en tu código asumen que un dispositivo usa un tamaño de página específico. Para evitar esto, completa los siguientes pasos:
Quita cualquier dependencia codificada que haga referencia a
PAGE_SIZE
. constante o instancias en la lógica de tu código que suponen que la página de un dispositivo sea de 4 KB (4096
).En su lugar, usa
getpagesize()
osysconf(_SC_PAGESIZE)
.Busca usos de
mmap()
y otras APIs que requieran una alineación de página. y reemplázalos por alternativas si es necesario.
En algunos casos, si tu app usa PAGE_SIZE
como un valor conveniente que no se
en función del tamaño de la página subyacente, esto no provocará que la aplicación falle
cuando se usa en modo de 16 KB. Sin embargo, si este valor se pasa al kernel
con mmap
sin MAP_FIXED
, el kernel usa una página completa, lo que
desperdicia algo de memoria. Por estos motivos, PAGE_SIZE
no está definido cuando 16 KB
está habilitado en NDK r27 y versiones posteriores.
Si tu app usa PAGE_SIZE
de esta manera y nunca pasa directamente este valor a
en el kernel, en lugar de usar PAGE_SIZE
, crea una nueva variable con un nuevo
nombre real para reflejar que se utiliza para otros fines y no refleja una
la página de memoria.
Prueba tu app en un entorno de 16 KB
Después de crear tu app compatible con dispositivos de 16 KB, querrás prueba la app en un entorno de 16 KB para ver si experimenta y no hay regresiones. Para hacerlo, sigue estos pasos:
Configura uno de los siguientes entornos de prueba:
Inicia tu dispositivo de prueba y, luego, ejecuta el siguiente comando para verificar que usa un entorno de 16 KB:
adb shell getconf PAGE_SIZE
El comando debe mostrar un valor de
16384
.En el caso de las bibliotecas compartidas, verifica que estas últimas Los segmentos ELF son esté alineada de forma correcta con la alineación ELF de 16 KB. Puedes usar este script para ayuda con este proceso:
#!/bin/bash # usage: alignment.sh path to search for *.so files dir="$1" RED="\e[31m" GREEN="\e[32m" ENDCOLOR="\e[0m" matches="$(find $dir -name "*.so" -type f)" IFS=$'\n' for match in $matches; do res="$(objdump -p ${match} | grep LOAD | awk '{ print $NF }' | head -1)" if [[ $res =~ "2**14" ]] || [[ $res =~ "2**16" ]]; then echo -e "${match}: ${GREEN}ALIGNED${ENDCOLOR} ($res)" else echo -e "${match}: ${RED}UNALIGNED${ENDCOLOR} ($res)" fi done
Guarda la secuencia de comandos en un archivo, como
alignment.sh
.Extrae el archivo APK de tu app:
unzip APK_NAME.apk -d /tmp/my_apk_out
Ejecuta la secuencia de comandos en los archivos extraídos en
/tmp/my_apk_out
. directorio:alignment.sh /tmp/my_apk_out | grep "arm64-v8a"
La secuencia de comandos genera
ALIGNED
oUNALIGNED
para todos losarm64-v8a
bibliotecas compartidas.Si alguna biblioteca compartida de
arm64-v8a
tiene el estadoUNALIGNED
, deberás actualiza el paquete de esas bibliotecas y, luego, vuelve a compilar tu y vuelve a realizar la prueba siguiendo los pasos que se indican en esta sección.
Ejecuta el siguiente comando
zipalign
para verificar que la app esté 16 KB alineado, donde APK_NAME es el nombre de el archivo APK de tu app:zipalign -c -P 16 -v 4 APK_NAME.apk
Prueba minuciosamente la app y enfócate en las áreas que puedan verse afectadas por cambiar 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
Para configurar un entorno de 16 KB con Android Emulator, sigue estos pasos: pasos:
Las imágenes del sistema del emulador de Android 15 basadas en 16 KB son compatibles con Android Studio Jellyfish | 2023.3.1 o una versión posterior Sin embargo, para tener cuando trabajes con la versión beta de Android 15, descarga la versión versión preliminar de Android Studio.
Recuerda que puedes conservar tu versión actual de Android Studio ya que puedes instalar varias versiones en paralelo.
En Android Studio, haz clic en Tools > SDK Manager.
En la pestaña SDK Platforms, marca Show Package Details y, luego, expande la sección Android VanillaIceCream Preview y selecciona una o ambas las siguientes imágenes del sistema del emulador, según los dispositivos virtuales que deseas crear:
- Imagen del sistema experimental ARM 64 v8a de las APIs de Google experimental de 16 k
- Imagen del sistema Atom de Intel x86_64 experimental de 16 KB de tamaño de página experimental de las APIs de Google
Haz clic en Aplicar > OK para descargar las imágenes del sistema que seleccionaste.
Sigue los pasos para configurar un dispositivo virtual para Android 15 y cuándo hacerlo que selecciones una imagen del sistema, selecciona la imagen de sistema de 16 KB que que descargaste. Si no se recomienda automáticamente, puedes encontrar la Imagen del sistema de 16 KB en la pestaña Otras imágenes
- En el Administrador de dispositivos, haz clic en los 3 puntos que aparecen junto a la imagen de 16 KB y, luego, haz clic en Show on Disk.
- En esta carpeta, busca el archivo
config.ini
. Agrega la siguiente línea al archivo
config.ini
y guarda los cambios:kernel.parameters = androidboot.page_shift=14
Para verificar los cambios, ejecuta el siguiente comando, que debería mostrar
16384
:adb shell getconf PAGE_SIZE