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

一直以来，Android 仅支持 4 KB 的内存页面大小，针对 Android 设备通常拥有的平均总内存量，系统内存性能进行了优化。从 Android 15 开始，Android 支持配置为使用 16 KB 页面大小的设备（即 16 KB 设备）。

随着设备制造商不断打造具有更大物理内存 (RAM) 的设备，这些设备中的许多可能会配置 16 KB（最终更大）的页面大小，以优化设备的性能。添加对 16 KB 设备的支持可让您的应用在这些设备上运行，并帮助您的应用从相关性能改进中受益。为了帮助您解决此问题，我们提供了一些指南，帮助您了解如何检查您的应用是否受到影响、如何重新构建应用（如果适用），以及如何同时使用模拟器和实体设备在 16 KB 的环境中测试应用。

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

如果您的应用使用任何原生代码，则您应重新构建支持 16 KB 设备的应用。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器来确定是否存在任何原生代码。

如果您的应用仅使用以 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 bibliotecas nativas o dependencias de terceros que las usen.
• Tu app se compiló con un compilador de apps de terceros que usa bibliotecas nativas integradas en el dispositivo.

Cómo identificar 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 identificar si tu app usa código nativo o bibliotecas, sigue estos pasos:

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 dentro de 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, significa que 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 los 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 o una posterior del AGP y que uses bibliotecas compartidas sin comprimir.

AGP versión 8.3 o posterior

Los dispositivos de 16 KB requieren que las apps que se envían con bibliotecas compartidas sin comprimir los alineen en un límite alineado con un archivo ZIP de 16 KB. Para ello, debes actualizar a la versión 8.3 o posterior del complemento de Android para Gradle (AGP). Consulta la sección Asistente de actualización del complemento de Android para Gradle si quieres obtener información detallada 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 cambiar para usar bibliotecas compartidas comprimidas. Actualiza la configuración de Gradle para que Gradle comprima las bibliotecas compartidas cuando empaquetes tu app, a fin de 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
      }
  }
}

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

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

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

Para compilar tu app con la 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 compiladas previamente, también debes volver a compilarlas de la misma manera y volver a importar las bibliotecas alineadas con 16 KB a la app.

NDK de Android 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 ndk-build o cmake 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")

Importante: Si tu app se vincula de forma dinámica a la biblioteca estándar de C++ (libc++_shared.so) desde el NDK de Android r26 o versiones anteriores, se recomienda cambiar al NDK de Android r27 o versiones posteriores para actualizar a la versión de 16 KB alineada con ELF de la biblioteca estándar de C++. De lo contrario, tu app no se instalará en dispositivos de 16 KB.

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

NDK de Android r27 y versiones posteriores

Para admitir la compilación de bibliotecas compartidas alineadas con 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 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 generar errores si algunas partes del código suponen que un dispositivo usa un tamaño de página específico. Para evitar esto, completa los siguientes pasos:

1. Quita las dependencias codificadas que hagan referencia a la constante PAGE_SIZE o las instancias en tu lógica de código que suponen que el tamaño de la 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 la página subyacente, esto no provocará que la app falle cuando se use en el modo de 16 KB. Sin embargo, si se pasa este valor al kernel con mmap sin MAP_FIXED, el kernel usará una página completa, lo que desperdiciará algo de memoria. Por estos motivos, PAGE_SIZE no está definido 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 directamente este valor 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.

Prueba tu app en un entorno de 16 KB

Después de crear tu app compatible con dispositivos de 16 KB, te recomendamos probarla en un entorno de ese tamaño para comprobar si experimenta regresiones. Para ello, configura uno de los siguientes entornos de prueba y, luego, prueba por completo tu app con un enfoque en las áreas que puedan verse afectadas por el cambio de instancias de código que hagan referencia a tamaños de página específicos.

• Configura Android Emulator con una imagen del sistema de Android 15 basada de 16 KB
• 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.

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

Importante: Debido a un problema conocido en la versión beta 2 de Android 15, la depuración con LLDB aún no funciona con imágenes del sistema del emulador de 16 KB.

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 disfrutar de la mejor experiencia cuando trabajes con la versión beta de Android 15, descarga la versión preliminar más reciente de Android Studio.

   Recuerda que no es necesario desinstalar la versión actual de Android Studio que tienes, 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, expande la sección Android VanillaIceCream Preview y selecciona una de las siguientes imágenes del sistema del emulador, o ambas, según los dispositivos virtuales que quieras 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
   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.