Seitengrößen von 16 KB werden unterstützt

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

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

Vorteile und Leistungssteigerungen

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

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

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

Prüfen, ob Ihre App betroffen ist

Wenn Ihre App nativen Code verwendet, sollten Sie sie neu erstellen, sodass sie 16-KB-Geräte unterstützt. Wenn Sie sich nicht sicher sind, ob Ihre App nativen Code verwendet, können Sie mithilfe des APK Analyzer ermitteln, ob nativer Code vorhanden ist.

Wenn Ihre App nur Code verwendet, der in der Programmiersprache Java oder in Kotlin geschrieben ist (einschließlich aller Bibliotheken oder SDKs), unterstützt sie bereits 16-KB-Geräte. Trotzdem empfehlen wir Ihnen, Ihre Anwendung in einer 16 KB-Umgebung zu testen, um sicherzustellen, dass es keine unerwarteten Regressionen beim Verhalten der Anwendung gibt.

Verwendet Ihre App nativen Code?

Ihre App verwendet nativen Code, wenn einer der folgenden Punkte zutrifft:

• Ihre App verwendet beliebigen (nativen) C/C++ Code. Wenn in deiner App das Android NDK verwendet wird, verwendet sie nativen Code.
• Ihre App ist mit nativen Bibliotheken oder Abhängigkeiten von Drittanbietern verknüpft, in denen sie verwendet werden.
• Ihre App wurde von einem Drittanbieter-App-Builder erstellt, der native Bibliotheken auf dem Gerät verwendet.

Native Bibliotheken mit APK Analyzer identifizieren

APK Analyzer ist ein Tool, mit dem Sie verschiedene Aspekte eines erstellten APKs bewerten können. So finden Sie heraus, ob Ihre App nativen Code oder Bibliotheken verwendet:

1. Öffne Android Studio, klicke auf Datei > Öffnen und wähle ein Projekt aus.

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

   

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

4. Sehen Sie im Ordner lib nach, in dem Dateien mit gemeinsam genutzten Objekten (.so) gehostet werden, falls vorhanden. Wenn gemeinsam genutzte Objektdateien vorhanden sind, verwendet Ihre App nativen Code. Wenn keine gemeinsam genutzten Objektdateien oder kein Ordner lib vorhanden ist, verwendet Ihre Anwendung keinen nativen Code.

   

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

Damit Geräte mit 16 KB unterstützt werden, sollten für Apps, die nativen Code verwenden, die in den folgenden Abschnitten beschriebenen Schritte ausgeführt werden.

Paketerstellung geteilter Bibliotheken aktualisieren

Wir empfehlen ein Upgrade auf AGP 8.3 oder höher und die Verwendung unkomprimierter gemeinsam genutzter Bibliotheken.

AGP-Version 8.3 oder höher

Auf Geräten mit 16 KB sind Apps erforderlich, die mit unkomprimierten gemeinsam genutzten Bibliotheken ausgeliefert werden, damit sie an einer 16 KB großen, an einem Zip- ausgerichteten Grenze ausgerichtet werden können. Dazu müssen Sie ein Upgrade auf Version 8.3 oder höher des Android-Gradle-Plug-ins (AGP) ausführen. Weitere Informationen zum Upgrade finden Sie im Abschnitt „Upgrade Assistant“ für das Android-Gradle-Plug-in.

AGP 8.2 oder niedriger

Wenn ein Upgrade von AGP nicht auf Version 8.3 oder höher möglich ist, können Sie stattdessen auf komprimierte gemeinsam genutzte Bibliotheken umstellen. Aktualisieren Sie Ihre Gradle-Konfiguration, damit Gradle Ihre gemeinsam genutzten Bibliotheken beim Erstellen eines App-Pakets komprimiert. So lassen sich Probleme bei der Installation von Apps mit nicht ausgerichteten gemeinsam genutzten Bibliotheken vermeiden.

Cool

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

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

Kotlin

Fügen Sie 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 gemeinsam genutzten Bibliotheken richtig mit einer 16-KB-ELF-Ausrichtung ausgerichtet werden, damit Ihre App ausgeführt werden kann.

Hinweis: Wenn Ihre Anwendung keine nativen Bibliotheken in das Dateisystem extrahiert (extractNativeLibs ist auf false gesetzt), werden Sie nach der Kompilierung mit einer 16-KB-ELF-Ausrichtung wahrscheinlich eine leichte Erhöhung der Binärgröße Ihrer Anwendung feststellen. Bei Optimierungen des Paketmanagers in Android 15 fallen durch diese Erhöhung keine Laufzeitkosten an.

Wenn du deine App mit einer 16-KB-ELF-Ausrichtung kompilieren möchtest, musst du abhängig von der verwendeten Android-NDK-Version die Schritte in einem der folgenden Abschnitte ausführen.

Wichtig :Wenn in Ihrer App vordefinierte gemeinsam genutzte Bibliotheken verwendet werden, müssen Sie diese auf die gleiche Weise neu kompilieren und die 16 KB ausgerichteten Bibliotheken noch einmal in Ihre App importieren.

Android NDK r26 und niedriger

Damit Sie die Kompilierung von 16 KB ausgerichteten gemeinsam genutzten Bibliotheken mit Android NDK Version r26 oder niedriger unterstützen, müssen Sie Ihre ndk-build- oder cmake-Konfiguration so aktualisieren:

NK-Build

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

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

CMake

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

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

Wichtig :Wenn Ihre App von Android NDK r26 oder niedriger dynamisch mit der C++-Standardbibliothek (libc++_shared.so) verknüpft ist, sollten Sie zu Android NDK r27 oder höher wechseln, um auf die 16 KB ELF-konforme Version der C++-Standardbibliothek zu aktualisieren. Andernfalls kann Ihre App auf Geräten mit 16 KB nicht installiert werden.

Wenn der Wechsel zum neueren Android-NDK nicht möglich ist, können Sie Ihre App möglicherweise aktualisieren, um die C++-Standardbibliothek statisch in Ihre gemeinsam genutzte Bibliothek zu kompilieren. Weitere Informationen zur statischen Verknüpfung mit der C++-Standardbibliothek finden Sie im Abschnitt Unterstützung für C++-Bibliothek. Lesen Sie außerdem den Abschnitt Wichtige Hinweise.

Android NDK r27 und höher

Damit Sie die Kompilierung von 16 KB ausgerichteten gemeinsam genutzten Bibliotheken mit Android NDK Version r27 und höher unterstützen, müssen Sie Ihre ndk-build-, build.gradle-, build.gradle.kts- oder Verknüpfungs-Flags so aktualisieren:

NK-Build

In deinem Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Cool

Legen Sie in der Datei build.gradle 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 Datei build.gradle.kts 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 Verknüpfungs-Flags an:

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

Nach Codeinstanzen suchen, die auf bestimmte Seitengrößen verweisen

Selbst wenn Ihre App auf 16 KB ausgerichtet ist, können Fehler auftreten, wenn Stellen in Ihrem Code davon ausgehen, dass ein Gerät eine bestimmte Seitengröße verwendet. Um dies zu vermeiden, führen Sie die folgenden Schritte aus:

1. Entfernen Sie alle hartcodierten Abhängigkeiten, die auf die PAGE_SIZE-Konstante verweisen, oder entfernen Sie alle 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 der Verwendung von mmap() und anderen APIs, die auf Seiten ausgerichtete 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, führt dies in einigen Fällen nicht dazu, dass Ihre App im 16-KB-Modus funktioniert. Wenn dieser Wert jedoch mit mmap ohne MAP_FIXED an den Kernel übergeben wird, verwendet der Kernel trotzdem eine ganze Seite, was Arbeitsspeicher verschwendet. Aus diesen Gründen ist PAGE_SIZE nicht definiert, wenn der 16-KB-Modus unter NDK r27 und höher aktiviert ist.

Wenn Ihre Anwendung PAGE_SIZE auf diese Weise verwendet und diesen Wert nie direkt an den Kernel weiterleitet, 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 Arbeitsspeicherseite darstellt.

App in einer 16 KB-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 zu sehen, ob es zu Regressionen kommt. Richten Sie dazu eine der folgenden Testumgebungen ein und testen Sie Ihre Anwendung gründlich. Konzentrieren Sie sich dabei auf alle Bereiche, die von der Änderung von Codeinstanzen, die auf bestimmte Seitengrößen verweisen, betroffen sein könnten.

• Android-Emulator mit einem 16 KB-basierten Android 15-System-Image einrichten
• Sepia mit einer Seitengröße von 16 KB auf ARM64 verwenden
• Tintenfisch mit einer Seitengröße von 16 KB auf x86–64 simulieren

Android-Emulator mit einem 16 KB-basierten Android 15-Systemimage einrichten

Wichtig :Aufgrund eines bekannten Problems in Android 15 Beta 2 funktioniert die Fehlerbehebung mit LLDB noch nicht mit 16-KB-Emulator-System-Images.

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

1. 16 KB-basierte Android 15-Emulator-System-Images sind mit Android Studio Jellyfish 2023.3.1 oder höher kompatibel. Damit du Android 15 optimal nutzen kannst, solltest du aber die aktuelle Vorabversion von Android Studio herunterladen.

   Denken Sie daran, dass Sie Ihre vorhandene Version von Android Studio installiert lassen können, 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 Abschnitt Android VanillaIceCream Preview (Vorschau von Android VanillaIceCream) und wählen Sie abhängig von den virtuellen Geräten, die Sie erstellen möchten, eines oder beide der folgenden Emulator-System-Images aus:

   • Google APIs Experimentelle 16k-Seitengröße ARM 64 v8a-Systembild
   • Google APIs Experimentelle 16k Seitengröße Intel x86_64 Atom-System-Image
   Hinweis :Wenn Sie ein unterstütztes Google Pixel-Gerät emulieren möchten, benötigen Sie nur das System-Image ARM 64 v8a.

   

4. Klicken Sie auf Übernehmen > OK, um die System-Images herunterzuladen, die Sie ausgewählt haben.

5. Folgen Sie den Schritten zum Einrichten eines virtuellen Geräts für Android 15. Wenn Sie zur Auswahl eines System-Images aufgefordert werden, wählen Sie das 16 KB-System-Image aus, das Sie heruntergeladen haben. Wenn es nicht automatisch empfohlen wird, finden Sie das 16 KB-Systemimage auf dem Tab Andere Images.