Assurer la compatibilité avec les tailles de page de 16 Ko

Auparavant, Android n'acceptait que des pages de 4 Ko de mémoire, ce qui optimisée des performances de la mémoire système pour la quantité moyenne de mémoire totale les appareils Android ont généralement eu. À partir d'Android 15, AOSP prend en charge appareils configurés pour utiliser une taille de page de 16 Ko appareils). Si votre application utilise des bibliothèques du NDK, directement ou indirectement via un SDK, vous devez recompiler votre application pour qu'elle fonctionnent sur ces appareils de 16 Ko.

Alors que les fabricants d’appareils continuent à construire des appareils avec de plus grandes quantités mémoire physique (RAM), un grand nombre de ces appareils adopteront un débit de 16 Ko (et et éventuellement plus) pour optimiser les performances de l'appareil. Ajout... la compatibilité avec les appareils dont la taille de page est de 16 Ko permet à votre application de s'exécuter sur ces appareils et aide votre application à bénéficier des performances associées et d'améliorations. Sans recompilation, les applications risquent de ne pas fonctionner sur les appareils de 16 Ko. lorsqu'ils seront mis en production dans les prochaines versions d'Android.

Pour vous aider à proposer la prise en charge de votre application, nous vous fournissons des conseils sur la façon de vérifier si votre application est concernée, comment recompilez votre application (le cas échéant) et comment la tester dans un environnement de 16 Ko utilisant des émulateurs (y compris Android 15) ; images système pour Android Emulator).

Avantages et gains de performances

Les appareils configurés avec des tailles de page de 16 Ko utilisent un peu plus de mémoire en moyenne, mais bénéficient également de diverses améliorations des performances pour le système et les applications:

  • Diminution du temps de lancement des applications lorsque la mémoire système est forte: 3,16 % de moins en moyenne, avec des améliorations plus importantes (jusqu'à 30%) pour certaines applications que nous avons testées
  • Réduction de la consommation d'énergie lors du lancement de l'application: réduction de 4,56% en moyenne
  • Lancement plus rapide des caméras: démarrage à chaud 4,48% plus rapide en moyenne et démarrage à froid 6,60% plus rapide en moyenne
  • Amélioration du temps de démarrage du système: amélioration de 1,5% (environ 0,8 seconde) en moyenne

Ces améliorations sont basées sur nos tests initiaux et les résultats sur les appareils réels seront probablement différents. Nous fournirons une analyse supplémentaire des gains potentiels pour les applications à mesure que nous poursuivrons nos tests.

Vérifier si votre application est concernée

Si votre application utilise du code natif, vous devez la recompiler pour qu'elle soit compatible avec les appareils 16 ko. Si vous ne savez pas si votre application utilise du code natif, vous pouvez utiliser l'analyseur d'APK pour déterminer si du code natif est présent, puis vérifier l'alignement des segments ELF pour toutes les bibliothèques partagées que vous trouvez.

Si votre application n'utilise que du code écrit en langage de programmation Java ou Kotlin, y compris toutes les bibliothèques ou tous les SDK, elle est déjà compatible avec les appareils de 16 Ko. Toutefois, nous vous recommandons de tester votre application dans un environnement de 16 ko pour vous assurer qu'il n'y a pas de régressions inattendues dans le comportement de l'application.

Votre application utilise-t-elle du code natif ?

Votre application utilise du code natif dans les cas suivants:

  • votre application utilise du code C/C++ (natif) ; Si votre application utilise le NDK Android, elle utilise du code natif.
  • Votre application est associée à toutes les bibliothèques natives tierces ou à toutes les dépendances qui les utilisent.
  • Votre application est créée par un outil de création d'applications tiers qui utilise des bibliothèques natives sur l'appareil.

Identifier les bibliothèques natives à l'aide de l'analyseur d'APK

L'analyseur d'APK est un outil qui vous permet d'évaluer divers aspects d'un APK créé. Pour savoir si votre application utilise du code natif ou des bibliothèques, procédez comme suit :

  1. Ouvrez Android Studio, cliquez sur File > Open (Fichier > Ouvrir), puis sélectionnez un projet.
  2. Dans la barre de menu, cliquez sur Build > Analyze APK (Compilation > Analyser l'APK).

    Option du menu de compilation Studio pour lancer l'analyseur d'APK

  3. Sélectionnez l'APK que vous souhaitez analyser.

  4. Examinez le dossier lib qui héberge les fichiers d'objets partagés (.so) le cas échéant. Si des fichiers d'objets partagés sont présents, votre application utilise du code natif. Si aucun fichier d'objet partagé n'est présent ou s'il n'y a pas de dossier lib, votre application n'utilise pas de code natif.

    Vue de l'analyseur d'APK montrant la présence de fichiers d'objets partagés

Créer votre application avec prise en charge des appareils de 16 ko

Pour prendre en charge les appareils de 16 ko, les applications qui utilisent du code natif doivent suivre les étapes décrites dans les sections suivantes. Si vous passez à la version 8.5.1 ou ultérieure d'AGP et à la version r28 ou ultérieure du NDK, et que vous utilisez des dépendances prédéfinies compatibles avec une taille de 16 Ko, les applications sont compatibles par défaut avec une taille de 16 Ko.

Mettre à jour le packaging de vos bibliothèques partagées

Nous vous recommandons de passer à la version 8.5.1 ou ultérieure d'AGP et d'utiliser des bibliothèques partagées non compressées.

AGP 8.5.1 ou version ultérieure

Les appareils 16 ko nécessitent des applications fournies avec des bibliothèques partagées non compressées pour les aligner sur une limite zippée de 16 ko. Pour ce faire, vous devez passer à la version 8.5.1 ou ultérieure du plug-in Android Gradle (AGP). Consultez la section Assistant de mise à niveau du plug-in Android Gradle pour en savoir plus sur le processus de mise à niveau.

AGP 8.5 ou version antérieure

Si vous ne pouvez pas mettre à niveau AGP vers la version 8.5.1 ou ultérieure, vous pouvez utiliser des bibliothèques partagées compressées. Mettez à jour votre configuration Gradle pour que Gradle compresse vos bibliothèques partagées lors de l'empaquetage de votre application afin d'éviter les problèmes d'installation de l'application avec des bibliothèques partagées non alignées.

Groovy

Dans votre fichier build.gradle, ajoutez l'option suivante :

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

Kotlin

Dans votre fichier build.gradle.kts, ajoutez l'option suivante :

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

Compiler votre application avec un alignement ELF de 16 Ko

Pour que votre application s'exécute, les appareils de 16 ko nécessitent que les segments ELF des bibliothèques partagées soient correctement alignés à l'aide d'un alignement ELF de 16 ko.

Pour compiler votre application à l'aide d'un alignement ELF de 16 ko, suivez la procédure décrite dans l'une des sections suivantes en fonction de la version du NDK Android que vous utilisez.

Android NDK r28 ou version ultérieure

La version r28 du NDK et les versions ultérieures compilent les fichiers 16 Ko alignés par défaut.

Android NDK r27

Pour pouvoir compiler des bibliothèques partagées alignées sur 16 Ko avec le NDK Android r27 ou version ultérieure, vous devez mettre à jour vos indicateurs ndk-build, build.gradle, build.gradle.kts ou Linker comme suit:

ndk-build

Dans votre Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

Dans votre fichier build.gradle, définissez l'argument -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

Dans votre fichier build.gradle.kts, définissez l'argument -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")
      }
    }
  }
}

Autres systèmes de compilation

Spécifiez les indicateurs d'association suivants:

-Wl,-z,max-page-size=16384

Android NDK r26 ou version antérieure

Pour pouvoir compiler des bibliothèques partagées alignées sur 16 Ko avec la version r26 ou antérieure du NDK Android, vous devez mettre à jour votre configuration ndk-build ou cmake comme suit:

ndk-build

Mettez à jour votre Android.mk pour activer l'alignement ELF de 16 Ko :

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

CMake

Mettez à jour votre CMakeLists.txt pour activer l'alignement ELF de 16 Ko :

target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384")

Rechercher des instances de code qui font référence à des tailles de page spécifiques

Même si votre application est alignée en 16 Ko, elle peut rencontrer des erreurs si des emplacements de votre code supposent qu'un appareil utilise une taille de page spécifique. Pour éviter cela, procédez comme suit:

  1. Supprimez toutes les dépendances codées en dur qui font référence à la constante PAGE_SIZE ou aux instances de votre logique de code qui supposent que la taille de la page d'un appareil est de 4 Ko (4096).

    Utilisez plutôt getpagesize() ou sysconf(_SC_PAGESIZE).

  2. Recherchez les utilisations de mmap() et d'autres API nécessitant des arguments alignés sur la page, et remplacez-les par d'autres si nécessaire.

Dans certains cas, si votre application utilise PAGE_SIZE comme valeur pratique qui n'est pas liée à la taille de page sous-jacente, votre application ne sera pas interrompue lorsqu'elle sera utilisée en mode 16 ko. Toutefois, si cette valeur est transmise au noyau avec mmap sans MAP_FIXED, le noyau utilise tout de même une page entière, ce qui gaspille de la mémoire. Pour ces raisons, PAGE_SIZE n'est pas défini lorsque le mode 16 Ko est activé sur NDK r27 ou version ultérieure.

Si votre application utilise PAGE_SIZE de cette manière et ne transmet jamais directement cette valeur au noyau, au lieu d'utiliser PAGE_SIZE, créez une variable avec un nouveau nom pour indiquer qu'elle est utilisée à d'autres fins et qu'elle ne reflète pas une page de mémoire réelle.

Tester votre application dans un environnement de 16 Ko

Après avoir créé votre application compatible avec les appareils de 16 Ko, vous pouvez tester votre application dans un environnement de 16 Ko pour voir si elle subit des régressions. Pour ce faire, procédez comme suit :

  1. Configurez le SDK Android 15.

  2. Configurez l'un des environnements de test suivants:

  3. Démarrez votre appareil de test, puis exécutez la commande suivante pour vérifier qu'il utilise un environnement de 16 ko :

    adb shell getconf PAGE_SIZE
    

    La commande doit renvoyer la valeur 16384.

  4. Pour toutes les bibliothèques partagées, vérifiez que les segments ELF des bibliothèques partagées sont correctement alignés à l'aide de l'alignement ELF de 16 Ko. Vous pouvez utiliser ce script pour faciliter ce processus:

    #!/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. Enregistrez le script dans un fichier tel que alignment.sh.

    2. Extrayez le fichier APK de votre application:

        unzip APK_NAME.apk -d /tmp/my_apk_out
        ```
    
    1.  Run the script on the extracted files in the `/tmp/my_apk_out`
        directory:
    
    ```none {: .devsite-terminal .devsite-click-to-copy }
        alignment.sh /tmp/my_apk_out | grep "arm64-v8a"
        ```
    
    The script outputs either `ALIGNED` or `UNALIGNED` for all the `arm64-v8a`
        shared libraries.
    
    1.  If any `arm64-v8a` shared libraries are `UNALIGNED`, you'll need to
        [update the packaging for those libraries][20], then [recompile your
        app][21] and retest by following the steps in this section.
    
  5. Exécutez la commande zipalign suivante pour vérifier que votre application est alignée sur 16 ko, où APK_NAME est le nom du fichier APK de votre application :

    zipalign -c -P 16 -v 4 APK_NAME.apk
    
  6. Testez minutieusement votre application, en vous concentrant sur les éléments susceptibles d'être affectés par la modification des instances de code qui font référence à des tailles de page spécifiques.

Configurer Android Emulator avec une image système Android 15 basée sur 16 ko

Pour configurer un environnement de 16 Ko à l'aide d'Android Emulator, procédez comme suit:

  1. Les images système de l'émulateur Android 15 basées sur 16 Ko sont compatibles avec Android Studio Jellyfish | 2023.3.1 ou version ultérieure. Toutefois, pour une expérience optimale avec la version bêta d'Android 15, téléchargez la dernière version preview d'Android Studio.

    N'oubliez pas que vous pouvez conserver la version existante d'Android Studio, puisque vous pouvez installer plusieurs versions simultanément.

  2. Dans Android Studio, cliquez sur Tools > SDK Manager (Outils > Gestionnaire de SDK).

  3. Dans l'onglet SDK Platforms (Plates-formes SDK), cochez la case Show Package Details (Afficher les détails du package), puis développez la section Android VanillaIceCream Preview (Aperçu d'Android VanillaIceCream) et sélectionnez l'une des images système d'émulateur suivantes ou les deux, en fonction des appareils virtuels que vous souhaitez créer:

    • Image système expérimentale des API Google 16 Ko ARM 64 v8a
    • Image système expérimentale des API Google au format 16 ko Intel x86_64 Atom

    Télécharger des images système de l'émulateur de 16 ko à l'aide de SDK Manager dans Android Studio

  4. Cliquez sur Appliquer > OK pour télécharger les images système que vous avez sélectionnées.

  5. Suivez la procédure pour configurer un appareil virtuel pour Android 15. Lorsque vous êtes invité à sélectionner une image système, sélectionnez l'image système de 16 ko que vous avez téléchargée. Si elle n'est pas recommandée automatiquement, vous trouverez l'image système de 16 ko dans l'onglet Autres images.

    Recherchez l'image de l'émulateur de 16 Ko dans l'onglet "Autres images".

  1. Dans le Gestionnaire d'appareils, cliquez sur les trois points à côté de l'image de 16 ko, puis sur Afficher sur le disque.
  2. Dans ce dossier, recherchez le fichier config.ini.
  3. Ajoutez la ligne suivante dans le fichier config.ini et enregistrez les modifications :

    kernel.parameters = androidboot.page_shift=14
    
  4. Pour vérifier vos modifications, exécutez la commande suivante, qui doit renvoyer 16384:

    adb shell getconf PAGE_SIZE
    

Activer le mode 16 Ko sur un appareil à l'aide des options pour les développeurs

Activer/Désactiver le développeur Démarrer avec une page de 16 Ko permettant de démarrer un appareil en mode 16 Ko.

À partir d'Android 15 QPR1, vous pouvez utilisez l'option pour les développeurs disponible sur certaines appareils pour les démarrer en mode 16 Ko et effectuer des tests sur l'appareil.

Cette option pour les développeurs est disponible sur les appareils suivants:

  • Pixel 8 et 8 Pro (avec Android 15 QPR1 bêta 1 ou version ultérieure)