Cette page a été traduite par l'API Cloud Translation.

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

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

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

Avantages et gains de performances

配置为 16 KB 页面的设备平均使用的内存会略多，但系统和应用性能也会有所提升：

在系统面临内存压力时缩短应用启动时间：平均降低了 3.16%，对于我们测试过的一些应用而言，改进幅度更显著（提升幅度高达 30%）
降低应用启动时的功耗：平均降低 4.56%
相机启动速度更快：平均热启动速度加快 4.48%，冷启动速度平均加快 6.60%
缩短了系统启动时间：平均缩短了 1.5%（约 0.8 秒）

这些改进基于我们的初始测试，实际设备上的结果可能会有所不同。在继续测试的过程中，我们会进一步分析应用的潜在益处。

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 de 16 Ko. Si vous ne savez pas si votre application utilise du code natif, vous pouvez utiliser l'analyseur d'APK pour déterminer la présence de code natif.

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. Néanmoins, nous vous recommandons de tester votre application dans un environnement de 16 Ko pour vérifier qu'il n'y a pas de régressions inattendues dans son comportement.

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 compilé. Pour déterminer si votre application utilise du code natif ou des bibliothèques, procédez comme suit:

Ouvrez Android Studio, cliquez sur File > Open (Fichier > Ouvrir), puis sélectionnez un projet.
Dans la barre de menu, cliquez sur Build > Analyze APK (Compilation > Analyser l'APK).
Sélectionnez l'APK que vous souhaitez analyser.
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.

Créer votre application compatible avec les appareils de 16 Ko

Pour prendre en charge les appareils de 16 Ko, les applications qui utilisent du code natif doivent suivre la procédure décrite dans les sections suivantes.

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

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

AGP version 8.3 ou ultérieure

Les appareils de 16 Ko nécessitent que les applications fournies avec des bibliothèques partagées non compressées les alignent sur une limite de 16 Ko alignée au format ZIP. Pour ce faire, vous devez passer à la version 8.3 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.2 ou version antérieure

Si vous ne pouvez pas mettre à niveau AGP vers la version 8.3 ou ultérieure, l'alternative consiste à utiliser des bibliothèques partagées compressées. Mettez à jour votre configuration Gradle pour que Gradle compresse vos bibliothèques partagées lors du packaging de votre application afin d'éviter les problèmes d'installation liés à 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 en utilisant l'alignement ELF de 16 Ko

Les appareils de 16 Ko nécessitent que les segments ELF des bibliothèques partagées soient correctement alignés à l'aide de l'alignement ELF de 16 Ko pour que votre application puisse s'exécuter.

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

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

Important :Si votre application est associée de manière dynamique à la bibliothèque standard C++ (libc++_shared.so) à partir du NDK Android r26 ou version antérieure, nous vous recommandons de passer à Android NDK r27 ou version ultérieure pour passer à la version ELF de 16 Ko de la bibliothèque standard C++. Sinon, l'installation de votre application échouera sur des appareils de 16 Ko.

Si vous ne pouvez pas passer au NDK Android plus récent, vous pourrez peut-être mettre à jour votre application pour compiler de manière statique la bibliothèque standard C++ dans votre bibliothèque partagée. Pour en savoir plus sur la création de liens statiques vers la bibliothèque standard C++, consultez la section Compatibilité avec les bibliothèques C++. N'oubliez pas de lire la section Remarques importantes.

Android NDK r27 ou version ultérieure

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

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:

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 getpagesize() ou sysconf(_SC_PAGESIZE) à la place.
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 la page sous-jacente, cela n'entraînera pas le plantage de votre application lorsqu'elle est utilisée en mode 16 Ko. Toutefois, si cette valeur est transmise au noyau avec mmap sans MAP_FIXED, celui-ci 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 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 devez tester votre application dans un environnement de 16 Ko pour voir si elle subit des régressions. Pour ce faire, configurez l'un des environnements de test suivants, puis testez minutieusement votre application, en vous concentrant sur les domaines 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:

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, car vous pouvez installer plusieurs versions côte à côte.
Dans Android Studio, cliquez sur Tools > SDK Manager (Outils > Gestionnaire de SDK).
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
Remarque :Si vous prévoyez d'émuler un appareil Google Pixel compatible, vous n'aurez besoin que de l'image système ARM 64 v8a.
Cliquez sur Appliquer > OK pour télécharger les images système que vous avez sélectionnées.
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 pouvez trouver l'image système de 16 Ko dans l'onglet Other Images (Autres images).

Compatibilité 64 bits