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.

Aumento de los beneficios y del 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.

Verifica si el cambio afecta a tu app

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 da alguna de las siguientes condiciones:

• Tu app usa cualquier código (nativo) C/C++. Si tu app usa el NDK de Android, usa código nativo.
• Tu app se vincula con bibliotecas nativas de terceros.
• Tu app se compiló mediante un creador de apps de terceros que usa bibliotecas nativas 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 en la carpeta lib, que aloja archivos de objeto compartido (.so) si los hay. Si hay archivos de objetos compartidos, tu app usa código nativo. Si no hay archivos de objetos compartidos o una carpeta lib, la app no usa código nativo.

   

Cómo compilar tu app compatible con 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.

Actualiza a AGP 8.3 o versiones posteriores.

Los dispositivos de 16 KB requieren apps que incluyen bibliotecas compartidas sin comprimir para alinearlas en un límite de 16 KB alineado con ZIP. Para ello, debes actualizar a la versión 8.3 o una posterior del complemento de Android para Gradle (AGP). Consulta la sección Asistente de actualización del complemento de Android para Gradle a fin de obtener información sobre el proceso de actualización.

Te recomendamos que uses bibliotecas compartidas sin comprimir, pero si no puedes actualizar AGP a la versión 8.3 o una posterior, la alternativa es comenzar a usar bibliotecas compartidas comprimidas. Actualiza la configuración de Gradle para que Gradle comprima las bibliotecas compartidas cuando empaquetes la app, y así evitar problemas de instalación con bibliotecas compartidas no alineadas.

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

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

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

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

Para compilar tu app con una 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 de 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 haber errores si partes de tu código suponen que un dispositivo usa un tamaño de página específico. Para evitar esto, completa los siguientes pasos:

1. Quita todas las dependencias hard-coded que hagan referencia a la constante PAGE_SIZE o las instancias en la lógica del código que den por sentado 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 los usos de mmap() y otras APIs que requieran argumentos alineados con la página y reemplázalos con alternativas cuando sea necesario.

Prueba la app en un entorno de 16 KB

Después de compilar la app compatible con dispositivos de 16 KB, te recomendamos probarla en un entorno de 16 KB para ver si experimenta regresiones. Para ello, usa uno de los siguientes entornos de pruebas:

• Cómo usar Cuttlefish con un tamaño de página de 16 KB en ARM64
• Simula Cuttlefish con un tamaño de página de 16 KB en x86-64.
• Flash Pixel 6 y Pixel 6 Pro compatibles con un tamaño de página de 16 KB