Seitengrößen von 16 KB werden unterstützt

Anforderung an die Kompatibilität mit 16 KB bei Google Play

Ab dem 1. November 2025 müssen alle neuen Apps und Updates für bestehende Apps, die bei Google Play eingereicht werden und auf Android 15-Geräte oder höher ausgerichtet sind, Arbeitsspeicherseiten mit 16 KB auf 64‑Bit-Geräten unterstützen.

Weitere Informationen →

Bisher wurden in Android nur Arbeitsspeicherseiten mit 4 KB unterstützt. Dadurch wurde die Leistung des Systemspeichers für die durchschnittliche Menge an Gesamtspeicher optimiert, die Android-Geräte in der Regel hatten. Ab Android 15 unterstützt AOSP Geräte, die für die Verwendung einer Seitengröße von 16 KB konfiguriert sind (16‑KB-Geräte). Wenn Ihre App NDK-Bibliotheken verwendet, entweder direkt oder indirekt über ein SDK, müssen Sie Ihre App neu erstellen, damit sie auf diesen 16‑KB-Geräten funktioniert.

Da Gerätehersteller weiterhin Geräte mit größeren Mengen an physischem Arbeitsspeicher (RAM) entwickeln, werden viele dieser Geräte 16‑KB-Seitengrößen (und schließlich noch größere) verwenden, um die Leistung des Geräts zu optimieren. Wenn Sie Unterstützung für Geräte mit einer Seitengröße von 16 KB hinzufügen, kann Ihre App auf diesen Geräten ausgeführt werden und von den damit verbundenen Leistungsverbesserungen profitieren. Ohne Neukompilierung funktionieren Apps in zukünftigen Android-Versionen nicht auf Geräten mit 16 KB.

Damit Sie Ihre App entsprechend anpassen können, haben wir Anleitungen dazu bereitgestellt, wie Sie prüfen, ob Ihre App betroffen ist, wie Sie Ihre App neu erstellen (falls zutreffend) und wie Sie Ihre App mit Emulatoren (einschließlich Android 15-Systemabbildern für den Android-Emulator) in einer 16‑KB-Umgebung testen.

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 neu erstellen, um Geräte mit 16‑KB-Speicherseiten zu unterstützen. Wenn Sie sich nicht sicher sind, ob Ihre App nativen Code verwendet, können Sie mit dem APK Analyzer prüfen, ob nativer Code vorhanden ist, und dann die Ausrichtung von ELF-Segmenten für alle gefundenen gemeinsam genutzten Bibliotheken prüfen. Android Studio bietet auch Funktionen, mit denen Sie Ausrichtungsprobleme automatisch erkennen können.

Wenn Ihre App nur Code verwendet, der in der Programmiersprache Java oder in Kotlin geschrieben wurde, 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 zu prüfen, ob es unerwartete Regressionen im 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 (nativen Code). Wenn Ihre App das Android NDK verwendet, nutzt sie nativen Code.
• Ihre App ist mit nativen Bibliotheken oder Abhängigkeiten von Drittanbietern (z. B. SDKs) verknüpft, die sie verwenden.
• Ihre App wurde von einem Drittanbieter-App-Builder erstellt, der native Bibliotheken auf dem Gerät verwendet.

Native Bibliotheken mit dem APK Analyzer identifizieren

Mit APK Analyzer können Sie verschiedene Aspekte eines erstellten APKs analysieren. So prüfen Sie, ob Ihre App nativen Code verwendet (unabhängig davon, ob sie mit 16 KB kompatibel ist):

1. Öffnen Sie Android Studio, klicken Sie auf File > Open (Datei > Öffnen) und wählen Sie ein beliebiges Projekt aus.

2. Klicken Sie in der Menüleiste auf Build > Analyze APK...

   

3. Wählen Sie die APK aus, die Sie analysieren möchten.

4. Sehen Sie im Ordner lib nach, in dem sich ggf. Dateien mit freigegebenen Objekten (.so) befinden. Wenn freigegebene Objektdateien vorhanden sind, verwendet Ihre App nativen Code. In der Spalte Ausrichtung werden Warnmeldungen für alle Dateien mit Ausrichtungsproblemen angezeigt. Wenn keine freigegebenen Objektdateien vorhanden sind oder kein lib-Ordner vorhanden ist, verwendet Ihre App keinen nativen Code.

   

Ausrichtungsprobleme mit automatisierten Prüfungen erkennen

Android Studio warnt Sie proaktiv, wenn Ihre vorgefertigten Bibliotheken oder APKs nicht der 16‑KB-Regel entsprechen. Verwenden Sie das APK-Analysetool, um zu prüfen, welche Bibliotheken aktualisiert werden müssen oder ob Codeänderungen erforderlich sind.

Lint in Android Studio hebt auch native Bibliotheken hervor, die nicht für 16 KB optimiert sind.

Ausrichtung von ELF-Segmenten für gemeinsam genutzte Bibliotheken prüfen

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

Das 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:

1. Speichern Sie das check_elf_alignment.sh-Skript in einer Datei.

2. Führen Sie das Skript für die APK-Datei Ihrer App aus:

   check_elf_alignment.sh APK_NAME.apk
   

   Das Skript gibt entweder ALIGNED oder UNALIGNED für alle arm64-v8a-Bibliotheken aus.

3. Wenn arm64-v8a- oder x86_64-Bibliotheken UNALIGNED sind, müssen Sie die Verpackung für diese Bibliotheken aktualisieren, Ihre App neu kompilieren und sie noch einmal testen. Folgen Sie dazu der Anleitung in diesem Abschnitt.

Befehlszeilentools direkt verwenden

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

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

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

3. Prüfen Sie im temporären Verzeichnis, in das Sie Ihre APK-Datei extrahiert haben, den Inhalt des Verzeichnisses lib auf Dateien mit gemeinsam genutzten Objekten (.so). Das 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 freigegebene Objektdatei 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 freigegebenen Objektdatei, die Sie prüfen, und NDK_VERSION die Version des Android NDK, die Sie installiert haben (z. B. 28.0.12433566). Die Ausgabe sieht für jede Datei, die Sie prüfen, 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
   

4. Prüfen Sie die Ausgabelinien, um sicherzustellen, dass die Lastsegmente keine Werte unter 2**14 haben. Wenn für Ladegruppen 2**13-, 2**12- oder niedrigere Werte angezeigt werden, müssen Sie die Verpackung für diese Bibliotheken aktualisieren, Ihre App neu kompilieren und die Tests anhand der Schritte in diesem Abschnitt wiederholen.

5. Führen Sie als Nächstes das zipalign-Befehlszeilentool für die 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 „Verification successful“ (Bestätigung erfolgreich) angezeigt, wenn alle freigegebenen Bibliotheken richtig ausgerichtet sind.

   Wenn die Überprüfung fehlgeschlagen ist, müssen einige gemeinsam genutzte Bibliotheken neu ausgerichtet werden. Aktualisieren Sie die Verpackung für diese Bibliotheken, kompilieren Sie Ihre App neu und führen Sie den Test noch einmal durch. Folgen Sie dazu der Anleitung in diesem Abschnitt.

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

Wenn Ihre App nativen Code verwendet, führen Sie die Schritte in den folgenden Abschnitten aus, um sicherzustellen, dass Ihre App Geräte mit 16‑KB-Speicherseiten unterstützt:

1. Verpackung Ihrer gemeinsam genutzten Bibliotheken aktualisieren
2. App mit 16‑KB-ELF-Ausrichtung kompilieren
3. Code korrigieren und Laufzeitprobleme beheben
4. SDKs auf Unterstützung von 16 KB prüfen

Verpackung Ihrer gemeinsam genutzten Bibliotheken aktualisieren

Wir empfehlen, ein Upgrade auf AGP-Version 8.5.1 oder höher durchzuführen und unkomprimierte gemeinsam genutzte Bibliotheken zu verwenden.

AGP-Version 8.5.1 oder höher

Bei Geräten mit 16 KB müssen Apps, die mit unkomprimierten gemeinsam genutzten Bibliotheken ausgeliefert werden, an einer 16‑KB-ZIP-Ausrichtungsgrenze ausgerichtet werden. Dazu müssen Sie das Android-Gradle-Plug-in (AGP) auf Version 8.5.1 oder höher aktualisieren. Weitere Informationen zum Upgrade finden Sie im Abschnitt Upgrade-Assistent für das Android-Gradle-Plugin.

AGP-Version 8.5 oder niedriger

Wenn Sie kein Upgrade von AGP auf Version 8.5.1 oder höher ausführen können, müssen Sie stattdessen komprimierte gemeinsam genutzte Bibliotheken verwenden. Aktualisieren Sie Ihre Gradle-Konfiguration, damit Gradle Ihre gemeinsam genutzten Bibliotheken beim Verpacken Ihrer App komprimiert, um Probleme bei der App-Installation mit nicht ausgerichteten gemeinsam genutzten Bibliotheken zu vermeiden.

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

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

App mit 16‑KB-ELF-Ausrichtung kompilieren

Damit Ihre App auf 16‑KB-Geräten ausgeführt werden kann, müssen die ELF-Segmente der gemeinsam genutzten Bibliotheken mit 16‑KB-ELF-Ausrichtung richtig ausgerichtet sein.

Wenn Ihr Spiel auf der Unity-Spiel-Engine basiert, lesen Sie den Unity-Leitfaden. Wenn Ihr Spiel auf der Unreal-Game-Engine ausgeführt wird, lesen Sie den Unreal-Leitfaden. Wenn Sie eine native Spiele-Engine verwenden, fahren Sie mit dieser Anleitung fort.

Führen Sie die Schritte in einem der folgenden Abschnitte aus, um Ihre App mit 16 KB ELF-Ausrichtung zu kompilieren. Das hängt von der Version des Android NDK ab, die Sie verwenden.

Android NDK r28 und höher

In NDK-Version r28 und höher wird standardmäßig 16‑KB-kompatibel kompiliert.

Android NDK r27

Damit das Kompilieren von 16‑KB-ausgerichteten gemeinsam genutzten Bibliotheken mit Android NDK Version r27 und höher unterstützt wird, müssen Sie Ihre ndk-build-, build.gradle-, build.gradle.kts- oder Linker-Flags so aktualisieren:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

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

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

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

Android NDK r26 und niedriger

Wenn Sie mit Android NDK-Version r26 oder niedriger 16-KB-ausgerichtete gemeinsam genutzte Bibliotheken kompilieren möchten, müssen Sie Ihre ndk-build- oder cmake-Konfiguration so aktualisieren:

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

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

Android NDK r22 und niedriger

Zusätzlich zu dem für NDK r26 und niedriger beschriebenen Schritt müssen Sie common-page-size=16384 festlegen, wenn Sie NDK r22 oder niedriger verwenden. Die Einstellung common-page-size=16384 ist aufgrund von Fehlern in früheren Versionen der Linker GNU ld und LLVM lld erforderlich. Wir empfehlen jedoch dringend, Ihre Tools auf eine neuere Version zu aktualisieren, um diese Fehler vollständig zu vermeiden.

Wenn Sie 16-KB-kompatible gemeinsam genutzte Bibliotheken mit Android NDK-Version r22 oder niedriger kompilieren möchten, aktualisieren Sie Ihre ndk-build- oder cmake-Konfiguration wie folgt:

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

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

Code korrigieren und Laufzeitprobleme beheben

Auch wenn Ihre App auf 16 KB ausgerichtet ist, können Fehler auftreten, wenn in Ihrem Code davon ausgegangen wird, dass ein Gerät eine bestimmte Seitengröße verwendet. Führen Sie die folgenden Schritte aus, um das zu vermeiden:

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

   Verwenden Sie stattdessen getpagesize() oder sysconf(_SC_PAGESIZE).

2. Suchen Sie nach Verwendungen von mmap() und anderen APIs, für die seitenbezogene Argumente erforderlich sind, 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, führt dies im 16‑KB-Modus nicht zu Problemen. Wenn dieser Wert jedoch mit mmap ohne MAP_FIXED an den Kernel übergeben wird, verwendet der Kernel trotzdem eine ganze Seite, was zu Speicherverschwendung führt. 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 übergibt, erstellen Sie anstelle von PAGE_SIZE eine neue Variable mit einem neuen Namen, um widerzuspiegeln, dass sie für andere Zwecke verwendet wird und keine tatsächliche Speicherseite darstellt.

SDKs auf 16 KB-Unterstützung prüfen

Viele SDKs sind mit 16‑KB-Seitengrößen kompatibel, insbesondere wenn Sie sie selbst erstellen oder aktuelle vorkompilierte Versionen verwenden. Da einige SDK-Prebuilts 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-Umgebung testen

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

1. Android 15 SDK einrichten

2. Richten Sie eine der folgenden Testumgebungen ein:

   • Android Emulator mit einem Android 15-Systemimage auf 16‑KB-Basis einrichten
     • Cuttlefish mit einer Seitengröße von 16 KB auf ARM64 verwenden
     • Cuttlefish mit einer Seitengröße von 16 KB auf x86-64 simulieren
   • 16‑KB-Modus auf einem Gerät über die Entwickleroptionen aktivieren

3. Starten Sie Ihr Testgerät und führen Sie dann den folgenden Befehl aus, um zu prüfen, ob es eine 16‑KB-Umgebung verwendet:

   adb shell getconf PAGE_SIZE
   

   Der Befehl sollte den Wert 16384 zurückgeben.

4. Führen Sie den folgenden zipalign-Befehl aus, um zu prüfen, ob Ihre App 16 KB-kompatibel ist. Dabei ist APK_NAME der Name der APK-Datei Ihrer App:

   zipalign -c -P 16 -v 4 APK_NAME.apk
   

5. Testen Sie Ihre App gründlich und konzentrieren Sie sich dabei auf Bereiche, die von geänderten Code-Instanzen, die auf bestimmte Seitengrößen verweisen, betroffen sein könnten.

Android-Emulator mit einem auf 16 KB basierenden Android 15-Systemimage einrichten

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

1. Auf 16 KB basierende Android 15-Emulator-Systemabbilder 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 Ihre vorhandene Version von Android Studio installiert lassen, da Sie mehrere Versionen nebeneinander installieren können.

2. Klicken Sie in Android Studio auf Tools > SDK Manager.

3. Klicken Sie auf dem Tab SDK Platforms (SDK-Plattformen) das Kästchen Show Package Details (Paketdetails anzeigen) an, maximieren Sie den Bereich Android VanillaIceCream (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 Emulator-System-Images aus:

   • Google APIs Experimental – 16 KB-Seitengröße – ARM 64 v8a-Systemabbild
   • Google APIs Experimental – 16 KB-Seitengröße – Intel x86_64 Atom-System Image

   

4. Klicken Sie auf Übernehmen > OK, um die ausgewählten Systemabbilder herunterzuladen.

5. 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 Systembild auf dem Tab Andere Bilder.

   

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

Bei Android Emulator-Versionen 35.1.5 bis 35.1.20 und vor der Revision 4 der im SDK Manager angebotenen Android 15.0-Systemimages mit 16 KB-Seitengröße 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 Android 15.0-System-Images mit 16 KB-Seitengröße oder höher nicht mehr erforderlich.

1. Klicken Sie im Geräte-Manager neben dem 16 KB großen Bild auf das Dreipunkt-Menü und dann auf Auf Festplatte anzeigen.
2. Suchen Sie in diesem Ordner nach der Datei config.ini.

3. Fügen Sie der Datei config.ini die folgende Zeile hinzu und speichern Sie die Änderungen:

   kernel.parameters = androidboot.page_shift=14
   

4. 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 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 verwenden, die auf bestimmten Geräten verfügbar ist, um das Gerät im 16‑KB-Modus zu starten und Tests auf dem Gerät durchzuführen. Bevor Sie die Entwickleroption verwenden, rufen Sie Einstellungen > System > Softwareupdates auf und installieren Sie alle verfügbaren Updates.

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 Pixel 8-Geräten nicht, nachdem Android 15 QPR2 Beta 3 installiert und das Gerät im 16‑KB-Modus gestartet wurde. Das Pixel 8 Pro ist von diesem Problem nicht betroffen.

• 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-Geräten 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)

Anforderungen an die Kompatibilität mit Google Play

Da Gerätehersteller Geräte mit mehr RAM ausstatten, um die Leistung zu optimieren, werden viele größere Seitengrößen wie 16 KB einführen. Zur Vorbereitung auf die Einführung dieser Geräte führt Google Play eine neue Kompatibilitätsanforderung ein: Ab dem 1. November 2025 müssen alle neuen Apps und Updates für bestehende Apps, die bei Google Play eingereicht werden und auf Geräte mit Android 15 (API-Level 35) und höher ausgerichtet sind, 16‑KB-Seitengrößen unterstützen.

Weitere Informationen zu dieser Kompatibilitätsanforderung finden Sie in diesem Blogpost.