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

Exigence de compatibilité avec Google Play (16 ko)

À partir du 1er novembre 2025, toutes les nouvelles applications et les mises à jour d'applications existantes envoyées sur Google Play et ciblant les appareils Android 15 ou version ultérieure devront être compatibles avec les tailles de page de 16 ko sur les appareils 64 bits.

En savoir plus →

从历史上看，Android 仅支持 4 KB 内存页面大小，这优化了系统内存性能，以适应 Android 设备通常拥有的平均总内存量。从 Android 15 开始，AOSP 支持配置为使用 16 KB 页面大小的设备（16 KB 设备）。如果您的应用直接或通过 SDK 间接使用任何 NDK 库，则需要重新构建应用，才能在这些 16 KB 设备上运行。

随着设备制造商不断制造出具有更大物理内存 (RAM) 的设备，许多此类设备将采用 16 KB（最终甚至更大）的页面大小来优化设备性能。添加对 16 KB 页面大小设备的支持，可让您的应用在这些设备上运行，并帮助您的应用受益于相关的性能改进。如果不重新编译，应用将无法在未来 Android 版本的 16 KB 设备上运行。

为帮助您为应用添加支持，我们提供了相关指南，介绍了如何检查应用是否受到影响、如何重新构建应用（如果适用），以及如何使用模拟器（包括 Android 模拟器的 Android 15 系统映像）在 16 KB 环境中测试应用。

Avantages et gains de performances

配置为使用 16 KB 页面大小的设备平均会使用略多一些的内存，但系统和应用的性能也会得到各种提升：

• 缩短了系统内存压力时的应用启动时间：平均降低了 3.16%；对于我们测试的某些应用而言，改进幅度更大（最高可达 30%）
• 应用启动期间的功耗降低：平均降低了 4.56%
• 相机启动更快：热启动速度平均提高了 4.48%，冷启动速度平均提高了 6.60%
• 缩短了系统启动时间：平均缩短了 8%（约 950 毫秒）

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

Vérifier si votre application est concernée

如果您的应用使用了任何原生代码，则应重新构建应用，使其支持 16 KB 设备。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器来确定是否存在任何原生代码，然后检查您找到的任何共享库的 ELF 段对齐情况。Android Studio 还提供了一些功能，可帮助您自动检测对齐问题。

如果您的应用仅使用以 Java 或 Kotlin 编程语言编写的代码（包括所有库或 SDK），则该应用已支持 16 KB 设备。不过，我们建议您在 16 KB 环境中测试应用，以验证应用行为是否出现意外的回归。

Votre application utilise-t-elle du code natif ?

C'est le cas si l'une des conditions suivantes s'applique :

• 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 à des bibliothèques ou dépendances natives tierces (telles que des SDK) qui les utilisent.
• Votre application est conçue 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 vérifier si votre application utilise du code natif (qu'elle soit ou non compatible avec les pages de 16 ko) :

1. Ouvrez Android Studio, puis cliquez sur File > Open (Fichier > Ouvrir) et choisissez un projet.

2. Dans la barre de menu, cliquez sur Build > Analyze APK… (Compiler > Analyser l'APK…).

   

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

4. Regardez si le dossier lib contient des fichiers d'objet partagé (.so). Si des fichiers d'objets partagés sont présents, votre application utilise du code natif. La colonne Alignement affiche des messages d'avertissement pour les fichiers qui présentent des problèmes d'alignement. Si aucun fichier d'objet partagé n'est présent ou si le dossier lib n'existe pas, votre application n'utilise pas de code natif.

   

Détecter les problèmes d'alignement grâce aux vérifications automatisées

Android Studio vous avertit de manière proactive si vos bibliothèques ou APK prédéfinis ne respectent pas la limite de 16 Ko. Utilisez l'analyseur APK pour vérifier les bibliothèques qui doivent être mises à jour ou si des modifications de code sont nécessaires.

Lint dans Android Studio met également en évidence les bibliothèques natives qui ne sont pas alignées sur 16 Ko.

Vérifier l'alignement des segments ELF pour les bibliothèques partagées

Pour toutes les bibliothèques partagées, vérifiez que leurs segments ELF sont correctement alignés à l'aide de l'alignement ELF de 16 Ko. Si vous développez sur Linux ou macOS, vous pouvez utiliser le script check_elf_alignment.sh comme décrit dans la section suivante. Vous pouvez également utiliser directement les outils de ligne de commande.

Utiliser le script check_elf_alignment.sh (Linux ou macOS)

Pour vérifier l'alignement des segments ELF à l'aide du script check_elf_alignment.sh, procédez comme suit :

1. Enregistrez le script check_elf_alignment.sh dans un fichier.

2. Exécutez le script sur le fichier APK de votre application :

   check_elf_alignment.sh APK_NAME.apk
   

   Le script génère ALIGNED ou UNALIGNED pour toutes les bibliothèques partagées arm64-v8a.

3. Si des bibliothèques partagées arm64-v8a ou x86_64 sont UNALIGNED, vous devrez mettre à jour l'empaquetage de ces bibliothèques, puis recompiler votre application et la tester à nouveau en suivant les étapes de cette section.

Utiliser directement les outils de ligne de commande

Pour vérifier l'alignement des segments ELF à l'aide des outils en ligne de commande, procédez comme suit :

1. Assurez-vous que les outils de compilation du SDK Android version 35.0.0 ou ultérieure et le NDK Android sont installés à l'aide du SDK Manager dans Android Studio ou de l'outil de ligne de commande sdkmanager.

2. Extrayez le fichier APK de votre application :

   Linux ou macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

   Expand-Archive -Path .\APK_NAME.apk -DestinationPath ~\tmp\my_apk_out
   

3. Dans le répertoire temporaire dans lequel vous avez extrait votre fichier APK, vérifiez le contenu du répertoire lib pour les fichiers d'objet partagé (.so). Il s'agit des mêmes fichiers d'objets partagés que ceux que vous avez vus lors de l'identification des bibliothèques natives à l'aide de l'analyseur d'APK. Exécutez la commande suivante sur chaque fichier d'objet partagé :

   Linux ou macOS

   SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-objdump -p SHARED_OBJECT_FILE.so | grep LOAD
   

   Windows (PowerShell)

   SDK_ROOT_LOCATION\Android\sdk\ndk\NDK_VERSION\toolchains\llvm\prebuilt\windows-x86_64\bin\llvm-objdump.exe -p SHARED_OBJECT_FILE.so | Select-String -Pattern "LOAD"
   

   Où SDK_ROOT_LOCATION correspond au chemin d'accès au répertoire dans lequel vous avez installé le SDK Android, SHARED_OBJECT_FILE correspond au nom du fichier d'objet partagé que vous vérifiez et NDK_VERSION correspond à la version du NDK Android que vous avez installée (par exemple, 28.0.12433566). La sortie ressemblera à ce qui suit pour chaque fichier que vous vérifiez :

   LOAD off    0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**14
   LOAD off    0x0000000000042a90 vaddr 0x0000000000043a90 paddr 0x0000000000043a90 align 2**14
   LOAD off    0x0000000000046230 vaddr 0x0000000000048230 paddr 0x0000000000048230 align 2**14
   

4. Vérifiez les lignes de sortie pour vous assurer que les segments de chargement n'ont pas de valeurs inférieures à 2**14. Si des segments de chargement ont des valeurs 2**13, 2**12 ou inférieures, vous devrez mettre à jour le packaging de ces bibliothèques, puis recompiler votre application et la tester à nouveau en suivant les étapes de cette section.

5. Exécutez ensuite l'outil de ligne de commande zipalign sur le fichier APK de votre application :

   Linux ou macOS

   SDK_ROOT_LOCATION/Android/sdk/build-tools/35.0.0/zipalign -v -c -P 16 4 APK_NAME.apk
   

   Windows (PowerShell)

   SDK_ROOT_LOCATION\Android\sdk\build-tools\35.0.0\zipalign.exe -v -c -P 16 4 APK_NAME.apk
   

   Où SDK_ROOT_LOCATION est le chemin d'accès au répertoire dans lequel vous avez installé le SDK Android, et APK_NAME est le nom du fichier APK de votre application. La dernière ligne du résultat indiquera "Validation réussie" si toutes les bibliothèques partagées sont correctement alignées.

   Si la validation a échoué, certaines bibliothèques partagées doivent être réalignées. Vous devrez donc mettre à jour le packaging de ces bibliothèques, puis recompiler votre application et la tester à nouveau en suivant les étapes de cette section.

Compiler votre application avec la prise en charge des appareils 16 ko

Si votre application utilise du code natif, suivez les étapes décrites dans les sections suivantes pour vous assurer qu'elle est compatible avec les appareils de 16 Ko :

1. Mettre à jour le packaging de vos bibliothèques partagées
2. Compilez votre application en utilisant l'alignement ELF de 16 Ko
3. Corriger le code et résoudre les problèmes d'exécution
4. Vérifier la compatibilité des SDK avec les pages de 16 Ko

Conseil : Si vous mettez à jour vos outils vers les dernières versions (AGP version 8.5.1 ou ultérieure et NDK version r28 ou ultérieure) et que vous utilisez des dépendances précompilées compatibles avec 16 Ko, votre application est compatible avec 16 Ko par défaut. Vous pouvez alors passer directement à l'étape Corriger le code et résoudre les problèmes d'exécution.

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 version 8.5.1 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 sur le format zip. Pour ce faire, vous devez passer au plug-in Android Gradle (AGP) version 8.5.1 ou ultérieure. Pour en savoir plus sur la procédure de mise à niveau, consultez la section Assistant de mise à niveau du plug-in Android Gradle.

AGP version 8.5 ou antérieure

Remarque : Dans les versions 8.3 à 8.5 d'AGP, les applications sont alignées sur 16 Ko par défaut. Toutefois, bundletool n'aligne pas les APK par défaut. L'application peut donc sembler fonctionner, mais elle ne s'installera pas si elle est créée à partir d'un bundle dans Play.

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. Vous éviterez ainsi les problèmes d'installation d'application liés aux 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
      }
  }
}

Avertissement : Lorsque vous utilisez des bibliothèques partagées compressées, votre application prend plus de place une fois installée, car les bibliothèques sont extraites de l'APK et copiées sur le disque. Il est possible que votre application ne s'installe pas plus souvent, car cette augmentation de l'utilisation du disque signifie qu'il y a moins d'espace sur l'appareil. Pour éviter ce problème, passez à AGP 8.5.1 ou version ultérieure.

Compilez votre application en utilisant l'alignement ELF de 16 ko

Pour que votre application s'exécute sur les appareils de 16 ko, les segments ELF des bibliothèques partagées doivent être correctement alignés à l'aide de l'alignement ELF de 16 ko.

Si vous êtes développeur de jeux et que votre jeu s'exécute sur le moteur de jeu Unity, consultez le guide Unity. Si votre jeu s'exécute sur le moteur de jeu Unreal, consultez le guide Unreal. Pour les moteurs de jeu natifs, poursuivez avec ce guide.

Remarque : Si votre application n'extrait pas les bibliothèques natives dans le système de fichiers (extractNativeLibs défini sur false), vous remarquerez probablement une légère augmentation de la taille du binaire de votre application après la compilation à l'aide d'un alignement ELF de 16 ko. Les optimisations apportées au gestionnaire de packages dans Android 15 compensent les coûts d'exécution liés à cette augmentation.

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

Important : Si votre application utilise des bibliothèques partagées prédéfinies, vous devez également les recompiler de la même manière et réimporter les bibliothèques alignées sur 16 ko dans votre application.

Android NDK r28 ou version ultérieure

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

Android NDK r27

Pour prendre en charge la compilation de bibliothèques partagées alignées sur 16 Ko avec Android NDK version r27 et ultérieure, vous devez mettre à jour vos indicateurs ndk-build, build.gradle, build.gradle.kts ou de l'éditeur de liens 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 de l'éditeur de liens suivants :

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

Android NDK r26 et versions antérieures

Mettez toujours à jour votre NDK. Cette méthode ne doit être utilisée qu'en dernier recours, et aucune assistance n'est garantie.

Pour prendre en charge la compilation de bibliothèques partagées alignées sur 16 ko avec le NDK Android version r26 ou antérieure, 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")

Android NDK r22 et versions antérieures

Mettez toujours à jour votre NDK. Cette méthode ne doit être utilisée qu'en dernier recours, et aucune assistance n'est garantie.

En plus de l'étape décrite pour NDK r26 et les versions antérieures, vous devez définir common-page-size=16384 si vous utilisez NDK r22 ou une version antérieure. Le paramètre common-page-size=16384 est requis en raison de bugs dans les versions antérieures des éditeurs de liens GNU ld et LLVM lld. Cette solution de contournement pour la taille de page courante ne fonctionne que si l'ELF comporte également une section .relro_padding (LLD 18 et versions ultérieures).

Pour compiler des bibliothèques partagées compatibles avec 16 ko avec Android NDK version r22 ou antérieure, mettez à jour votre configuration ndk-build ou cmake comme suit :

ndk-build

Mettez à jour votre Android.mk pour créer un fichier ELF compatible avec les pages de 16 ko :

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

CMake

Mettez à jour votre CMakeLists.txt pour créer un fichier ELF compatible avec les pages de 16 ko :

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

Important : Même si votre application établit un lien dynamique vers la bibliothèque standard C++ (libc++_shared.so) à partir des NDK r26 et versions antérieures, dont certaines ne sont pas alignées sur 16 Ko, vous devez quand même mettre à jour l'alignement de toutes les autres bibliothèques ici et mettre à jour votre code pour éviter de dépendre de PAGE_SIZE. Pour effectuer des tests sur ces versions antérieures du NDK sur des appareils de 16 Ko, les versions Canary des versions LTS du NDK r23 et r25 sont disponibles sur Android CI avec des bibliothèques libc++_shared.so alignées sur 16 Ko. Dans tous les cas, il est recommandé de passer à Android NDK r27 ou version ultérieure pour passer à la version de la bibliothèque standard C++ alignée sur ELF de 16 Ko. Sinon, votre application ne pourra pas être installée sur les appareils 16 ko aujourd'hui.

Si vous ne pouvez pas passer au nouveau NDK Android, vous pourrez peut-être mettre à jour votre application pour compiler statiquement la bibliothèque standard C++ dans votre bibliothèque partagée. Consultez la section Compatibilité avec les bibliothèques C++ pour en savoir plus sur l'association statique à la bibliothèque standard C++, et assurez-vous de lire la section Points importants à prendre en compte.

Corriger le code et résoudre les problèmes d'exécution

Même si votre application est alignée sur 16 ko, elle peut rencontrer des erreurs si des emplacements de votre code partent du principe 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 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 qui nécessitent des arguments alignés sur la page, et remplacez-les par des alternatives 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, cela n'entraînera pas de dysfonctionnement 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, le noyau utilise toujours 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 et versions ultérieures.

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

Vérifier la compatibilité des SDK avec les pages de 16 Ko

De nombreux SDK sont compatibles avec les tailles de page de 16 Ko, en particulier si vous les créez vous-même ou si vous obtenez des précompilés récents. Toutefois, comme certains SDK précompilés ou certaines versions de SDK ne sont pas compatibles avec 16 Ko, vous devez consulter le site Web de chaque fournisseur de SDK pour déterminer la version à utiliser avec 16 Ko.

Tester votre application dans un environnement de 16 ko

Une fois que vous avez créé votre application compatible avec les appareils 16 ko, vous devez la tester dans un environnement 16 ko pour voir si elle présente 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 :

   • Configurer Android Emulator avec une image système Android 15 basée sur 16 ko
     • Utiliser Cuttlefish avec une taille de page de 16 ko sur ARM64
     • Simuler Cuttlefish avec une taille de page de 16 ko sur x86-64
   • Activer le mode 16 ko sur un appareil à l'aide des options pour les développeurs
   • Utiliser Samsung Remote Test Lab sur les appareils compatibles de 16 Ko

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

5. Testez minutieusement votre application, en vous concentrant sur les zones qui pourraient être affectées par la modification des instances de code faisant référence à des tailles de page spécifiques.

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

Important : Un problème connu empêche le débogage avec LLDB avec les images système de l'émulateur de 16 Ko. Un correctif pour ce problème est inclus dans NDK r27 RC 1 et Android Studio Koala Feature Drop | 2024.1.2 Canary 5.

Pour configurer un environnement de 16 Ko à l'aide de l'émulateur Android, 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 lorsque vous travaillez avec des appareils de 16 Ko, utilisez Android Studio Ladybug | 2024.2.1 ou version ultérieure.

   Nous travaillons constamment sur de nouvelles fonctionnalités. Pensez donc à télécharger les nouvelles versions ou la dernière version preview d'Android Studio dès qu'elles sont disponibles.

   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 Show Package Details (Afficher les détails du package), puis développez la section Android VanillaIceCream (Android VanillaIceCream) ou version ultérieure et sélectionnez une ou les deux images système de l'émulateur suivantes, en fonction des appareils virtuels que vous souhaitez créer :

   • Image système Google APIs Experimental 16 KB Page Size ARM 64 v8a
   • Image système Google APIs Experimental 16 KB Page Size 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.

   

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

5. Suivez les étapes 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.

   

Étapes supplémentaires pour certaines versions de l'émulateur et images système

Pour les versions 35.1.5 à 35.1.20 de l'émulateur Android, et avant la révision 4 des images système Android 15.0 16 Ko proposées dans le SDK Manager, vous devez également effectuer les étapes suivantes pour simuler un environnement 16 Ko sur les systèmes x86_64. Ces étapes ne sont pas nécessaires après la version 35.1.21, ni avec la révision 4 des images système Android 15.0 16 ko ou ultérieures.

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 au fichier config.ini et enregistrez vos modifications :

   kernel.parameters = androidboot.page_shift=14
   

4. Pour vérifier vos modifications, exécutez la commande suivante, qui devrait renvoyer 16384 :

   adb shell getconf PAGE_SIZE
   

Lancer l'émulateur

Une fois que vous avez terminé de configurer l'émulateur Android et les appareils virtuels, lancez l'émulateur à partir du menu de l'appareil cible ou à partir de la ligne de commande.

使用开发者选项在设备上启用 16 KB 模式

切换以 16KB 页面大小启动设备开发者选项，以在 16 KB 模式下启动设备。

从 Android 15 QPR1 开始，您可以使用某些设备上提供的开发者选项，以 16 KB 模式启动设备并执行设备端测试。在使用开发者选项之前，请依次前往设置 > 系统 > 软件更新，并应用所有可用的更新。

此开发者选项适用于以下设备：

• Pixel 8 和 8 Pro（搭载 Android 15 QPR1 或更高版本）

• Pixel 8a（搭载 Android 15 QPR1 或更高版本）

• Pixel 9、9 Pro 和 9 Pro XL（搭载 Android 15 QPR2 Beta 2 或更高版本）

Remarque : Android 15 QPR2 est en version bêta. Pour savoir comment obtenir QPR2 sur un appareil éligible, consultez Obtenir les versions bêta QPR d'Android 15.

Mode rétrocompatible 16 ko

Avertissement en mode de compatibilité de taille de page

L'option de rétrocompatibilité 16 ko est disponible lorsqu'un appareil fonctionne avec un kernel 16 ko. Le gestionnaire de package exécute une application en mode rétrocompatible 16 ko lorsque les conditions suivantes sont remplies :

• Si l'application comporte des fichiers ELF (avec une extension .so) dont l'alignement du segment LOAD est de 4 Ko.
• Si l'APK compressé contient des fichiers ELF non compressés alignés sur 4 Ko.

Si le gestionnaire de packages a activé le mode de rétrocompatibilité 16 ko pour une application, celle-ci affiche un avertissement lors de son premier lancement indiquant qu'elle s'exécute en mode de rétrocompatibilité 16 ko.

Le mode de rétrocompatibilité de 16 Ko permet à certaines applications de fonctionner, mais pour une fiabilité et une stabilité optimales, les applications doivent toujours être alignées sur 16 Ko.

Sur la page d'informations de l'application, sous Avancé, activez ou désactivez le paramètre Exécuter l'appli en mode de compatibilité de taille de page pour activer ou désactiver le mode de rétrocompatibilité 16 ko pour une application spécifique. Ce paramètre n'est visible que lorsque l'appareil fonctionne avec une taille de page de 16 ko.

Paramètre du mode de compatibilité de taille de page

Pour forcer la rétrocompatibilité de 16 Ko pour chaque application sur l'appareil :

adb shell setprop bionic.linker.16kb.app_compat.enabled true
adb shell setprop pm.16kb.app_compat.disabled false

Pour désactiver la rétrocompatibilité de 16 Ko pour toutes les applications de l'appareil :

adb shell setprop bionic.linker.16kb.app_compat.enabled false
adb shell setprop pm.16kb.app_compat.disabled true

Définissez la propriété android:pageSizeCompat sur "enabled" (activé) ou "disabled" (désactivé) pour activer ou désactiver le mode Backcompat pour une application spécifique dans son AndroidManifest.xml. Lorsque cette propriété est définie, l'application n'affiche pas d'avertissements concernant le mode de rétrocompatibilité lors de son lancement.

Exigence de compatibilité avec Google Play

Les fabricants d'appareils équipent leurs appareils de plus de RAM pour optimiser les performances. Par conséquent, beaucoup adopteront des tailles de page plus importantes, comme 16 ko. Pour préparer le lancement de ces futurs appareils, Google Play introduit une nouvelle exigence de compatibilité : à partir du 1er novembre 2025, toutes les nouvelles applications et les mises à jour des applications existantes envoyées sur Google Play et ciblant les appareils exécutant Android 15 (niveau d'API 35) ou une version ultérieure devront être compatibles avec les tailles de page de 16 ko.

Pour en savoir plus sur cette exigence de compatibilité, consultez cet article de blog.