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

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:

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

2. Desde la barra de menú, haz clic en Build > Analizar APK...

   

3. Elige el APK que quieras analizar.

4. 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 carpeta lib, 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.

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

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:

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

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:

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

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:

1. 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() o sysconf(_SC_PAGESIZE).

2. 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:

1. Configura el SDK de Android 15.

2. Configura uno de los siguientes entornos de prueba:

   • Configura Android Emulator con un sistema Android 15 basado en 16 KB. imagen
   • Cómo usar Cuttlefish con tamaño de página de 16 KB en ARM64
   • Simula Cuttlefish con tamaño de página de 16 KB en x86-64.

3. 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.

4. 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
   

   1. Guarda la secuencia de comandos en un archivo, como alignment.sh.

   2. Extrae el archivo APK de tu app:

      unzip APK_NAME.apk -d /tmp/my_apk_out
      

   3. 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 o UNALIGNED para todos los arm64-v8a bibliotecas compartidas.

   4. Si alguna biblioteca compartida de arm64-v8a tiene el estado UNALIGNED, 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.

5. 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
   

6. 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:

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 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.

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

   

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

5. 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

   

1. 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.
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