Diese Seite wurde von der Cloud Translation API übersetzt.

Seitengrößen von 16 KB werden unterstützt

Bisher wurden in Android nur Seitengrößen von 4 KB unterstützt, eine optimierte Systemspeicherleistung für die durchschnittliche In der Regel gab es Android-Geräte. Ab Android 15 unterstützt AOSP Geräte, die für die Verwendung einer Seitengröße von 16 KB (16 KB) konfiguriert sind Geräte). Wenn Ihre App NDK-Bibliotheken verwendet, können Sie entweder direkt oder indirekt über ein SDK, müssen Sie Ihre App die auf diesen 16-KB-Geräten funktionieren.

Da Gerätehersteller immer mehr Geräte entwickeln, physischen Arbeitsspeicher (RAM), verwenden viele dieser Geräte 16 KB (und größer werden), um die Leistung des Geräts zu optimieren. Wird hinzugefügt wird die Unterstützung für Geräte mit einer Seitengröße von 16 KB ermöglicht, Geräte und unterstützt Ihre App dabei, von der damit verbundenen Leistung Verbesserungen. Ohne Neukompilierung funktionieren Apps auf Geräten mit 16 KB möglicherweise nicht wenn sie in zukünftigen Android-Versionen produktionsreif sind.

Damit Sie Unterstützung für Ihre App hinzufügen können, haben wir eine Anleitung zur Überprüfung der falls Ihre App betroffen ist, Ihre App neu zu erstellen (falls zutreffend) und wie Sie Ihre App eine 16 KB-Umgebung mit Emulatoren (einschließlich Android 15) System-Images für den Android-Emulator).

Vorteile und Leistungssteigerungen

Geräte, die mit einer Seitengröße von 16 KB konfiguriert sind, benötigen im Durchschnitt etwas mehr Arbeitsspeicher, erzielen aber auch verschiedene Leistungsverbesserungen für das System und die Apps:

Kürzere App-Startzeiten, während das System unter Speicherauslastung steht: im Durchschnitt 3,16 % niedriger, mit deutlicheren Verbesserungen (bis zu 30%) bei einigen von uns getesteten Apps
Verringerter Stromverbrauch beim Starten der App: durchschnittlich 4,56% weniger
Schnellerer Kamerastart: 4,48% schnellere Heißstarts und 6,60% schnellere Kaltstarts im Durchschnitt
Verbesserte Systemstartzeit: durchschnittlich um 8% (ca. 950 Millisekunden)

Diese Verbesserungen basieren auf unseren ersten Tests. Die Ergebnisse auf tatsächlichen Geräten werden sich wahrscheinlich unterscheiden. Im Rahmen unserer Tests werden wir zusätzliche Analysen zu den potenziellen Vorteilen für Apps durchführen.

Prüfen, ob Ihre App betroffen ist

Wenn Ihre App nativen Code verwendet, sollten Sie Ihre App mit Unterstützung für 16 KB-Geräte neu erstellen. Wenn Sie nicht sicher sind, ob Ihre App nativen Code verwendet, können Sie mit dem APK-Analysetool prüfen, ob nativer Code vorhanden ist, und dann die Ausrichtung der ELF-Segmente für alle gefundenen freigegebenen Bibliotheken prüfen.

Wenn in Ihrer App nur Code verwendet wird, der in der Programmiersprache Java oder Kotlin geschrieben ist, einschließlich aller Bibliotheken oder SDKs, unterstützt Ihre App bereits Geräte mit 16 KB. Wir empfehlen Ihnen jedoch, Ihre App in einer 16-KB-Umgebung zu testen, um sicherzustellen, dass es keine unerwarteten Rückschritte beim App-Verhalten gibt.

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 finden Sie heraus, 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-Analyzer 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 freigegebener 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 großen ZIP-ausgerichteten Grenze ausgerichtet werden. 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 mit nicht ausgerichteten freigegebenen 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 korrekt 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 im 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 derzeit nicht auf Geräten mit 16 KB 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 Ihre freigegebene Bibliothek kompiliert wird. Im Abschnitt C++-Bibliothekssupport finden Sie weitere Informationen zur statischen Verknüpfung mit der C++-Standardbibliothek. Lesen Sie sich auch den Abschnitt Wichtige Überlegungen durch.

Nach Codeinstanzen suchen, 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 die folgenden Schritte aus, um dies zu vermeiden:

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 anzugeben, 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 der Android 15-Betaversion sollten Sie jedoch die aktuelle Vorschauversion von Android Studio herunterladen.

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 Preview und wählen Sie je nach den virtuellen Geräten, die Sie erstellen möchten, eines oder beide der folgenden Emulator-Systemimages aus:
- Google APIs Experimental 16k Page Size ARM 64 v8a System Image
- Google APIs – experimentelles System-Image mit 16 KiB Seitengröße für Intel x86_64 Atom
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.

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

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)
Google Pixel 8a (mit Android 15 QPR1 oder höher)

Zurück

64-Bit-Unterstützung