Diese Seite wurde von der Cloud Translation API übersetzt.

Seitengrößen von 16 KB werden unterstützt

Android 过去仅支持 4 KB 内存页面大小，优化了系统内存性能，以针对 Android 设备通常具备的功能。从 Android 15 开始，AOSP 支持配置为使用 16 KB (16 KB) 页面大小的设备设备）。如果您的应用使用任何 NDK 库，请直接使用或者通过 SDK 间接创建，那么，您需要重新构建自己的应用支持这些 16KB 设备。

随着设备制造商不断打造出物理内存 (RAM)，许多此类设备都会采用 16KB（以及页面大小以优化设备的性能。正在添加支持 16 KB 页面大小的设备，可使您的应用在这些设备上运行并有助于您的应用从相关的广告效果中获益改进。如果不重新编译，应用可能无法在 16KB 设备上运行在未来的 Android 版本中正式推出。

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

Vorteile und Leistungssteigerungen

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

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

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

Prüfen, ob Ihre App betroffen ist

如果您的应用使用了任何原生代码，则应重新构建应用以支持 16 KB 设备。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器确定是否存在任何原生代码，然后检查您找到的任何共享库的 ELF 段对齐情况。

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

Verwendet Ihre App nativen Code?

Ihre App verwendet nativen Code, wenn eine der folgenden Bedingungen zutrifft:

Ihre App verwendet C/C++-Code (nativer Code). Wenn Ihre App das Android-NDK verwendet, verwendet sie nativen Code.
Ihre App ist mit nativen Bibliotheken oder Abhängigkeiten von Drittanbietern (z. B. SDKs) verknüpft, die diese verwenden.
Ihre App wurde von einem Drittanbieter-App-Builder erstellt, der native Bibliotheken auf dem Gerät verwendet.

Native Bibliotheken mit APK Analyzer ermitteln

Mit dem APK Analyzer können Sie verschiedene Aspekte eines erstellten APKs bewerten. So prüfen Sie, ob Ihre App nativen Code oder Bibliotheken verwendet:

Öffnen Sie Android Studio, klicken Sie auf File > Open (Datei > Öffnen) und wählen Sie ein beliebiges Projekt aus.
Klicken Sie in der Menüleiste auf Build > APK analysieren….
Wählen Sie das APK aus, das Sie analysieren möchten.
Suchen Sie im Ordner lib nach Dateien für freigegebene Objekte (.so), falls vorhanden. Wenn Shared Object-Dateien vorhanden sind, verwendet Ihre App nativen Code. Wenn keine Shared Object-Dateien vorhanden sind oder kein lib-Ordner vorhanden ist, verwendet Ihre App keinen nativen Code.

Ausrichtung von ELF-Segmenten für freigegebene Bibliotheken prüfen

Prüfen Sie bei allen freigegebenen Bibliotheken, ob die ELF-Segmente der freigegebenen Bibliotheken mit einer ELF-Ausrichtung von 16 KB richtig ausgerichtet sind. Wenn Sie unter Linux oder macOS entwickeln, können Sie das check_elf_alignment.sh-Script wie im folgenden Abschnitt beschrieben verwenden. Sie können auch die Befehlszeilentools direkt verwenden.

Skript „check_elf_alignment.sh“ verwenden (Linux oder macOS)

So prüfen Sie die Ausrichtung von ELF-Segmenten mit dem check_elf_alignment.sh-Script:

Speichern Sie das check_elf_alignment.sh-Script in einer Datei.
Führen Sie das Script auf der APK-Datei Ihrer App aus:
```
check_elf_alignment.sh APK_NAME.apk
```
Das Script gibt für alle arm64-v8a freigegebenen Bibliotheken entweder ALIGNED oder UNALIGNED aus.
Wenn eine arm64-v8a- oder x86_64-Bibliothek UNALIGNED ist, müssen Sie die Verpackung für diese Bibliotheken aktualisieren, dann Ihre App neu kompilieren und die Schritte in diesem Abschnitt ausführen, um sie noch einmal zu testen.

Befehlszeilentools direkt verwenden

So prüfen Sie die Ausrichtung von ELF-Segmenten direkt mit Befehlszeilentools:

Achten Sie darauf, dass sowohl die Android SDK Build Tools Version 35.0.0 oder höher als auch das Android NDK über den SDK-Manager in Android Studio oder das Befehlszeilentool sdkmanager installiert sind.

Extrahieren Sie die APK-Datei Ihrer App:

Linux oder macOS

unzip APK_NAME.apk -d /tmp/my_apk_out

Windows (PowerShell)

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

Prüfen Sie im temporären Verzeichnis, in das Sie Ihre APK-Datei extrahiert haben, den Inhalt des Verzeichnisses lib auf Dateien des Typs „Shared Object“ (.so). Dies sind dieselben gemeinsam genutzten Objektdateien, die Sie beim Identifizieren nativer Bibliotheken mit dem APK-Analysetool gesehen haben. Führen Sie den folgenden Befehl für jede Shared Object-Datei aus:
Linux oder 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"
```
Dabei ist SDK_ROOT_LOCATION der Pfad zum Verzeichnis, in dem Sie das Android SDK installiert haben, SHARED_OBJECT_FILE der Name der zu prüfenden Shared Object-Datei und NDK_VERSION die Version des installierten Android NDK (z. B. 28.0.12433566). Die Ausgabe sieht für jede geprüfte Datei in etwa so aus:
```
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
```
Prüfen Sie die Ausgabezeilen, um sicherzustellen, dass die Werte der Lastsegmente nicht unter 2**14 liegen. Wenn für Ladesegmente 2**13, 2**12 oder niedrigere Werte angegeben sind, müssen Sie das Paket für diese Bibliotheken aktualisieren, dann Ihre App neu kompilieren und die Schritte in diesem Abschnitt ausführen, um sie noch einmal zu testen.
Führen Sie als Nächstes das zipalign-Befehlszeilentool auf der APK-Datei Ihrer App aus:
Linux oder 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
```
Dabei ist SDK_ROOT_LOCATION der Pfad zum Verzeichnis, in dem Sie das Android SDK installiert haben, und APK_NAME der Name der APK-Datei Ihrer App. In der letzten Zeile der Ausgabe wird „Verifizierung erfolgreich“ angezeigt, wenn alle freigegebenen Bibliotheken richtig ausgerichtet sind.

Wenn die Überprüfung fehlgeschlagen ist, müssen einige freigegebene Bibliotheken neu ausgerichtet werden. Aktualisieren Sie dazu das Paket für diese Bibliotheken, kompilieren Sie die App neu und wiederholen Sie die Schritte in diesem Abschnitt.

App mit Unterstützung für Geräte mit 16 KB erstellen

Wenn Sie Apps mit nativem Code für Geräte mit 16 KB unterstützen möchten, müssen Sie die in den folgenden Abschnitten beschriebenen Schritte ausführen. Wenn Sie auf die AGP-Version 8.5.1 oder höher und die NDK-Version r28 oder höher aktualisieren und vorgefertigte Abhängigkeiten verwenden, die mit 16 KB kompatibel sind, sind Apps standardmäßig mit 16 KB kompatibel.

Verpackung Ihrer freigegebenen Bibliotheken aktualisieren

Wir empfehlen ein Upgrade auf AGP-Version 8.5.1 oder höher und die Verwendung nicht komprimierter freier Bibliotheken.

AGP-Version 8.5.1 oder höher

Für Geräte mit 16 KB müssen Apps, die mit nicht komprimierten freigegebenen Bibliotheken ausgeliefert werden, an einer 16-KB-Zip-Grenze ausgerichtet sein. Dazu müssen Sie auf das Android Gradle Plugin (AGP) Version 8.5.1 oder höher aktualisieren. Weitere Informationen zum Upgrade finden Sie im Abschnitt Android Gradle Plugin Upgrade Assistant.

AGP-Version 8.5 oder niedriger

Wenn Sie AGP nicht auf Version 8.5.1 oder höher aktualisieren können, können Sie stattdessen komprimierte freigegebene Bibliotheken verwenden. Aktualisieren Sie Ihre Gradle-Konfiguration, damit Gradle Ihre freigegebenen Bibliotheken beim Verpacken Ihrer App komprimiert, um Probleme bei der App-Installation durch nicht ausgerichtete freigegebene Bibliotheken zu vermeiden.

Groovy

Fügen Sie in der Datei build.gradle die folgende Option hinzu:

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

Kotlin

Fügen Sie in der Datei build.gradle.kts die folgende Option hinzu:

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

App mit 16 KB ELF-Ausrichtung kompilieren

Bei Geräten mit 16 KB müssen die ELF-Segmente der freigegebenen Bibliotheken richtig mit einer ELF-Ausrichtung von 16 KB ausgerichtet sein, damit Ihre App ausgeführt werden kann.

Führen Sie je nach verwendeter Version des Android NDK die Schritte in einem der folgenden Abschnitte aus, um Ihre App mit einer ELF-Ausrichtung von 16 KB zu kompilieren.

Android NDK r28 und höher

Mit der NDK-Version r28 und höher werden standardmäßig 16 KB-ausgerichtete Module kompiliert.

Android NDK r27

Wenn Sie freigegebene Bibliotheken mit einer Ausrichtung von 16 KB mit der Android NDK-Version r27 und höher kompilieren möchten, müssen Sie die ndk-build-, build.gradle-, build.gradle.kts- oder Linker-Flags so aktualisieren:

ndk-build

Auf deinem Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

Legen Sie in der build.gradle-Datei das Argument -DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON fest:

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

Legen Sie in der build.gradle.kts-Datei das Argument -DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON fest:

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

Andere Build-Systeme

Geben Sie die folgenden Linker-Flags an:

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

Android NDK r26 und niedriger

Wenn Sie freigegebene Bibliotheken mit einer Ausrichtung von 16 KB mit der Android NDK-Version r26 oder niedriger kompilieren möchten, müssen Sie Ihre ndk-build- oder cmake-Konfiguration so aktualisieren:

ndk-build

Aktualisieren Sie Android.mk, um die 16 KB-ELF-Ausrichtung zu aktivieren:

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

CMake

Aktualisieren Sie CMakeLists.txt, um die 16 KB-ELF-Ausrichtung zu aktivieren:

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

Wichtig :Auch wenn Ihre App dynamisch mit der C++-Standardbibliothek (libc++_shared.so) aus NDKs r26 und niedriger verknüpft ist, von denen einige nicht auf 16 KB ausgerichtet sind, sollten Sie hier die Ausrichtung aller anderen Bibliotheken aktualisieren und Ihren Code aktualisieren, um Abhängigkeiten von PAGE_SIZE zu vermeiden. Für Tests mit diesen niedrigeren NDK-Versionen auf Geräten mit 16 KB sind Canary-Releases der LTS-NDK-Versionen r23 und r25 mit 16 KB ausgerichteten libc++_shared.so-Bibliotheken in Android CI verfügbar. Wir empfehlen Ihnen jedoch, auf Android NDK r27 oder höher umzustellen, um die 16 KB große ELF-ausgerichtete Version der C++-Standardbibliothek zu verwenden. Andernfalls kann Ihre App auf Geräten mit 16 KB nicht installiert werden.

Wenn Sie nicht auf das neuere Android NDK umsteigen können, können Sie Ihre App möglicherweise so aktualisieren, dass die C++-Standardbibliothek statisch in die freigegebene Bibliothek kompiliert wird. Im Abschnitt C++-Bibliotheksunterstützung finden Sie Details zur statischen Verknüpfung mit der C++-Standardbibliothek. Lesen Sie sich auch den Abschnitt Wichtige Überlegungen durch.

Codeinstanzen prüfen, die auf bestimmte Seitengrößen verweisen

Auch wenn Ihre App auf 16 KB ausgerichtet ist, kann es zu Fehlern kommen, wenn an Stellen in Ihrem Code davon ausgegangen wird, dass ein Gerät eine bestimmte Seitengröße verwendet. Führen Sie dazu die folgenden Schritte aus:

Entfernen Sie alle hartcodierten Abhängigkeiten, die auf die Konstante PAGE_SIZE oder Instanzen in Ihrer Codelogik verweisen, die davon ausgehen, dass die Seitengröße eines Geräts 4 KB (4096) beträgt.

Verwenden Sie stattdessen getpagesize() oder sysconf(_SC_PAGESIZE).
Suchen Sie nach Verwendungen von mmap() und anderen APIs, die seitenausgerichtete Argumente erfordern, und ersetzen Sie sie bei Bedarf durch Alternativen.

Wenn Ihre App PAGE_SIZE als praktischen Wert verwendet, der nicht an die zugrunde liegende Seitengröße gebunden ist, funktioniert sie in einigen Fällen auch im 16-KB-Modus. Wenn dieser Wert jedoch mit mmap ohne MAP_FIXED an den Kernel übergeben wird, verwendet der Kernel weiterhin eine ganze Seite, was etwas Speicher verschwendet. Aus diesen Gründen ist PAGE_SIZE nicht definiert, wenn der 16-KB-Modus in NDK r27 und höher aktiviert ist.

Wenn Ihre App PAGE_SIZE auf diese Weise verwendet und diesen Wert nie direkt an den Kernel weitergibt, erstellen Sie anstelle von PAGE_SIZE eine neue Variable mit einem neuen Namen, um anzuzeigen, dass sie für andere Zwecke verwendet wird und keine echte Speicherseite darstellt.

SDKs auf Unterstützung von 16 KB prüfen

Viele SDKs sind mit Seitengrößen von 16 KB kompatibel, insbesondere wenn Sie sie selbst erstellen oder aktuelle vorkonfigurierte SDKs verwenden. Da einige vorkonfigurierte SDKs oder SDK-Versionen jedoch nicht mit 16 KB kompatibel sind, sollten Sie auf der Website des jeweiligen SDK-Anbieters nachsehen, welche Version mit 16 KB verwendet werden kann.

App in einer 16 KB großen Umgebung testen

Nachdem Sie Ihre App mit Unterstützung für 16 KB-Geräte erstellt haben, sollten Sie sie in einer 16 KB-Umgebung testen, um festzustellen, ob es zu Rückschritten gekommen ist. Gehen Sie hierzu folgendermaßen vor:

Android 15 SDK einrichten
Richten Sie eine der folgenden Testumgebungen ein:
Starten Sie Ihr Testgerät und führen Sie den folgenden Befehl aus, um zu prüfen, ob eine 16-KB-Umgebung verwendet wird:
```
adb shell getconf PAGE_SIZE
```
Der Befehl sollte den Wert 16384 zurückgeben.
Führen Sie den folgenden Befehl zipalign aus, um zu prüfen, ob Ihre App auf 16 KB ausgerichtet ist. Dabei ist APK_NAME der Name der APK-Datei Ihrer App:
```
zipalign -c -P 16 -v 4 APK_NAME.apk
```
Testen Sie Ihre App gründlich und konzentrieren Sie sich dabei auf Bereiche, die sich durch Änderungen an Codeinstanzen, die auf bestimmte Seitengrößen verweisen, auswirken könnten.

Android-Emulator mit einem 16-KB-basierten Android 15-System-Image einrichten

So richten Sie eine 16-KB-Umgebung mit dem Android-Emulator ein:

16 KB große Android 15-Emulator-Systembilder sind mit Android Studio Jellyfish | 2023.3.1 oder höher kompatibel. Für die beste Leistung bei der Arbeit mit 16 KB-Geräten sollten Sie jedoch Android Studio Ladybug | 2024.2.1 oder höher verwenden.

Wir arbeiten ständig an neuen Funktionen. Laden Sie daher neuere Versionen oder die aktuelle Vorabversion von Android Studio herunter, sobald sie verfügbar sind.

Sie können die vorhandene Version von Android Studio installiert lassen, da Sie mehrere Versionen parallel installieren können.
Klicken Sie in Android Studio auf Tools > SDK-Manager.
Klicken Sie auf dem Tab SDK-Plattformen auf Paketdetails anzeigen, maximieren Sie den Bereich Android VanillaIceCream oder höher und wählen Sie je nach den virtuellen Geräten, die Sie erstellen möchten, eines oder beide der folgenden Emulatorsystembilder aus:
- Google APIs Experimental 16 KB Page Size ARM 64 v8a System Image
- Google APIs Experimental – 16 KB Seitengröße – Intel x86_64 Atom-Systembild
Hinweis :Wenn Sie ein unterstütztes Google Pixel-Gerät emulieren möchten, benötigen Sie nur das ARM 64 v8a-System-Image.
Klicken Sie auf Übernehmen > OK, um die ausgewählten Systembilder herunterzuladen.
Folgen Sie der Anleitung zum Einrichten eines virtuellen Geräts für Android 15. Wenn Sie aufgefordert werden, ein System-Image auszuwählen, wählen Sie das heruntergeladene 16-KB-System-Image aus. Wenn es nicht automatisch empfohlen wird, finden Sie das 16 KB große System-Image auf dem Tab Weitere Bilder.

Zusätzliche Schritte für einige Emulatorversionen und System-Images

Für die Android-Emulatorversionen 35.1.5 bis 35.1.20 und vor der Revision 4 der im SDK Manager angebotenen Systemimages von Android 15.0 mit einer Seitengröße von 16 KB müssen Sie außerdem die folgenden Schritte ausführen, um eine 16-KB-Umgebung auf x86_64-Systemen zu simulieren. Diese Schritte sind nach Version 35.1.21 und mit Revision 4 der System-Images für Android 15.0 mit einer Seitengröße von 16 KB oder höher nicht mehr erforderlich.

Klicken Sie im Gerätemanager auf das Dreipunkt-Menü neben dem 16-KB-Image und dann auf Auf dem Laufwerk anzeigen.
Suchen Sie in diesem Ordner nach der Datei config.ini.
Fügen Sie der Datei config.ini die folgende Zeile hinzu und speichern Sie die Änderungen:
```
kernel.parameters = androidboot.page_shift=14
```
Führen Sie den folgenden Befehl aus, um Ihre Änderungen zu überprüfen. Er sollte 16384 zurückgeben:
```
adb shell getconf PAGE_SIZE
```

Emulator starten

Nachdem Sie den Android-Emulator und die virtuellen Geräte eingerichtet haben, starten Sie den Emulator über das Menü des Zielgeräts oder über die Befehlszeile.

16‑KB-Modus auf einem Gerät über die Entwickleroptionen aktivieren

Aktivieren oder deaktivieren Sie die Entwickleroption Mit Seitengröße von 16 KB starten, um ein Gerät im 16‑KB-Modus zu starten.

Ab Android 15 QPR1 können Sie die Entwickleroption auf bestimmten Geräten verwenden, um das Gerät im 16-KB-Modus zu starten und On-Device-Tests durchzuführen.

Diese Entwickleroption ist auf den folgenden Geräten verfügbar:

Google Pixel 8 und Google Pixel 8 Pro (mit Android 15 QPR1 oder höher)

Warnung: Aufgrund eines bekannten Problems mit Android 15 QPR2 Beta 3 funktioniert der Touchscreen auf Google Pixel 8 nicht, nachdem Android 15 QPR2 Beta 3 installiert und das Gerät im 16-KB-Modus gestartet wurde. Dieses Problem betrifft nicht Google Pixel 8 Pro.
Google Pixel 8a (mit Android 15 QPR1 oder höher)

Warnung: Aufgrund eines bekannten Problems mit Android 15 QPR2 Beta 3 funktioniert der Touchscreen auf Pixel 8a nicht, nachdem Android 15 QPR2 Beta 3 installiert und das Gerät im 16-KB-Modus gestartet wurde.
Google Pixel 9, Google Pixel 9 Pro und Google Pixel 9 Pro XL (mit Android 15 QPR2 Beta 2 oder höher)