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 en el rendimiento
配置为 16 KB 页面的设备平均使用的内存会略多,但系统和应用性能也会有所提升:
- 在系统面临内存压力时缩短应用启动时间:平均降低了 3.16%,对于我们测试过的一些应用而言,改进幅度更显著(提升幅度高达 30%)
- 降低应用启动时的功耗:平均降低 4.56%
- 相机启动速度更快:平均热启动速度加快 4.48%,冷启动速度平均加快 6.60%
- 缩短了系统启动时间:平均缩短了 1.5%(约 0.8 秒)
这些改进基于我们的初始测试,实际设备上的结果可能会有所不同。在继续测试的过程中,我们会进一步分析应用的潜在益处。
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