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

Históricamente, Android solo admitía tamaños de página de memoria de 4 KB, lo que optimizó el rendimiento de la memoria del sistema para la cantidad promedio de memoria total que los dispositivos Android solían tener. A partir de Android 15, Android admite dispositivos configurados para usar un tamaño de página de 16 KB (dispositivos de 16 KB).

A medida que los fabricantes de dispositivos continúan creando dispositivos con mayores cantidades de memoria física (RAM), es probable que muchos de estos dispositivos estén configurados con tamaños de página de 16 KB (y, eventualmente, más grandes) para optimizar el rendimiento del dispositivo. Agregar compatibilidad con dispositivos de 16 KB permite que tu app se ejecute en esos dispositivos y ayuda a que se beneficie de las mejoras de rendimiento asociadas. Para ayudarte con esto, proporcionamos orientación sobre cómo verificar si tu app se ve afectada, cómo volver a compilarla (si corresponde) y probarla en un entorno de 16 KB con emuladores y dispositivos físicos.

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

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

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.

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:

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

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:

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

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

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

   

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.