Erste Schritte mit der Memory Advice API

In diesem Leitfaden wird beschrieben, wie Sie die Jetpack-Release der Memory Advice API in Ihrem mit Android Studio.

Spiele sollten die Memory Advice API-Version verwenden, die für ihre Build-Umgebung empfohlen werden. Für Android Studio empfehlen wir die Jetpack-Release Informationen zu Releases für andere Build-Umgebungen z. B. die Erweiterung „Android Game Development“ (AGDE) erhalten Sie unter Distributionen.

Bibliothek hinzufügen

In diesem Abschnitt wird beschrieben, wie Sie die Bibliothek zu Android Studio (Android Gradle-Plug-in).

Abhängigkeiten hinzufügen

Führen Sie die folgenden Schritte aus, um die Bibliothek Ihrem Android Studio-Projekt hinzuzufügen:

Aktivieren Sie die Android Jetpack-Bibliothek auf Projektebene gradle.properties), die Datei befindet sich normalerweise im Stammverzeichnis Ihres Projekts:
```
  android.useAndroidX=true
```
Öffnen Sie die Datei build.gradle auf Modulebene und fügen Sie Folgendes hinzu: implementation zum Abhängigkeitenblock. Dies deklariert die Memory Consult API Abhängigkeiten in Ihrer Anwendung.
```
 dependencies {
     implementation 'androidx.games:games-memory-advice:1.0.0-beta01'
 }
```
Geben Sie die NDK-Version im Block android an:
```
 ndkVersion "23.1.7779620"
```
Wählen Sie eine Version des NDK aus, die mit der Memory Advice API kompatibel ist. Eine Liste der unterstützten NDK-Versionen finden Sie auf der Seite zur Veröffentlichung von Android Games Jetpack.

Deklarieren Sie zusätzliche Build-Flags für CMake. Fügen Sie dazu den folgenden Code defaultConfig-Block innerhalb des android-Blocks:

 externalNativeBuild {
     cmake {
         cppFlags '-std=c++14'
         // c++_shared flavor is the only supported STL type.
         arguments "-DANDROID_STL=c++_shared"
     }
 }

Aktivieren Sie die Funktion Prefab. Fügen Sie ab Version 4.1 des Android-Gradle-Plug-ins(AGP) den folgenden Code im android-Block:
```
 buildFeatures {
    prefab true
 }
```
Wenn Sie AGP 4.0 oder eine ältere Version verwenden, lesen Sie die Seite mit Präferenzen finden Sie eine entsprechende Konfigurationsanleitung.
Speichere die Datei. Wenn die folgende Meldung angezeigt wird, klicken Sie auf Jetzt synchronisieren. Schaltfläche zum Aktualisieren Ihres Projekts:
```
  Gradle files have changed since last project sync. A project sync may be
  necessary for the IDE to work properly.
```

CMake für C/C++ Build konfigurieren

So fügen Sie die Headerdateien und die Laufzeitbibliothek für die Memory Advice API hinzu: in Ihr Projekt einfügen, öffnen Sie die CMakeLists.txt-Hauptdatei Ihres Projekts. Im Projekt, die Datei befindet sich unter App > src > Haupt > cpp Nach dem Öffnen der Datei enthält, führen Sie die folgenden Schritte aus:

Fügen Sie oben in der Datei nach jeder cmake_minimum_required- und project-Linien:
```
 find_package(games-memory-advice REQUIRED CONFIG)
```
Fügen Sie im Befehl target_link_libraries games-memory-advice::memory_advice. Dadurch wird die Memory Advice API eine Abhängigkeit von der nativen Bibliothek Ihres Projekts und fügt diese in Ihr endgültiges Anwendungspaket auf. Das Update sollte in etwa so aussehen:
```
 target_link_libraries(
     your-native-lib

     #link memory advice to the project
     games-memory-advice::memory_advice

     #rest of the dependencies
     #...
 )
```

Java-Dateien konfigurieren

Die in der Memory Advice API enthaltene native Bibliothek ist libmemory_advice.so Es handelt sich um eine Kompilierungsabhängigkeit für die eigene App. gemeinsam genutzte Bibliothek in C/C++. Sie wird automatisch geladen, wenn Ihre App ihre eigene gemeinsam genutzte Bibliothek mit der Funktion System.loadlibrary().

Dieser Schritt ist optional.

Suchen Sie in Ihrem Projekt nach dem Java-Code, mit dem die nativen Bibliotheken geladen werden. Wenn es nicht vorhanden ist, fügen Sie ihn hinzu. Der Code sollte System.loadLibrary("your-native-lib") ähnlich sein und ist die sich in einem static-Block befindet.

System.loadLibrary("memory_advice") hinzufügen unter System.loadLibrary("your-native-lib"). Das Update sollte in etwa so aussehen: Folgendes:

 static {
     System.loadLibrary("your-native-lib");
     // Note: loading libmemory_advice.so is optional.
     System.loadLibrary("memory_advice");
 }

Bibliothek verwenden

In diesem Abschnitt wird die Verwendung der Bibliothek beschrieben.

Headerdateien hinzufügen

Fügen Sie Ihrem Projekt die folgende Bibliotheks-Headerdatei hinzu:

    #include <memory_advice/memory_advice.h>

Bibliothek initialisieren

Sie müssen die Bibliothek einmal initialisieren, wenn die App gestartet wird. Fügen Sie dazu Code in Ihr Projekt ein:

    MemoryAdvice_init(env, activity);

Die Parameter env und activity sind die Variablen JNIEnv* und jobject die für Ihre native Bibliothek verfügbar sein sollten. Jeder JNI-Aufruf an Ihre native diese Variablen enthalten. Wenn Sie den GameActivity-Bibliothek achten Sie darauf, Aufrufen des Threads an die JavaVM anhängen bevor die MemoryAdvice_init-Funktion aufgerufen wird.

Speicherstatus abfragen

Sie können den Speicherstatus Ihrer App abrufen, indem Sie die Bibliothek am Intervall Ihrer Wahl. Verwenden Sie die Methode MemoryAdvice_getMemoryState verwenden, wenn Sie die Bibliothek abfragen müssen:

    MemoryAdvice_MemoryState state = MemoryAdvice_getMemoryState();
    switch (state) {
      case MEMORYADVICE_STATE_OK:
        // The application can safely allocate significant memory.
        break;
      case MEMORYADVICE_STATE_APPROACHING_LIMIT:
        //The application should minimize memory allocation.
        break;
      case MEMORYADVICE_STATE_CRITICAL:
        // The application should free memory as soon as possible,
        // until the memory state changes.
        break;
    }

Watcher einrichten

Sie können auch Watcher und registrieren Sie die Memory Advice API. wenn sich der Status entweder dem Grenzwert nähert oder die kritische Arbeitsspeicherstatus (aber nicht für den Ok-Zustand). Mit dem folgenden Code wird beispielsweise ein Watcher erstellt, und fordert alle zwei Sekunden eine Memory Advice API-Benachrichtigung an:

    static int USER_DATA;
    constexpr int callback_waittime_ms = 2000;

    void callback(MemoryAdvice_MemoryState state, void* context) {
        switch (state) {
          case MEMORYADVICE_STATE_APPROACHING_LIMIT:
            //The application should minimize memory allocation.
            break;
          case MEMORYADVICE_STATE_CRITICAL:
            // The application should free memory as soon as possible,
            // until the memory state changes.
            break;
        }
    }

    MemoryAdvice_registerWatcher(callback_waittime_ms, callback, &USER_DATA);

Nächste Schritte

In der Übersicht finden Sie weitere Ressourcen und Melden von Problemen.