Diese Seite wurde von der Cloud Translation API übersetzt.

Erste Schritte mit Spielschleifentests

Es kann schwierig sein, Spieletests zu automatisieren, wenn Gaming-Apps auf verschiedenen UI-Frameworks basieren. Mit Game Loop-Tests können Sie Ihre nativen Tests in Test Lab einbinden und ganz einfach auf ausgewählten Geräten ausführen. Bei einem Game Loop-Test wird Ihr Test durch Ihre Gaming-App ausgeführt, während die Aktionen eines echten Spielers simuliert werden. Dieses In der Übersicht erfährst du, wie du einen Spielschleifentest durchführst und anschließend den Test aufrufst und verwaltest. Ergebnisse in der Firebase-Konsole.

Je nach Spiel-Engine kannst du Tests mit einem oder mehreren Schleifen. Eine Schleife ist ein vollständiger oder teilweiser Durchlauf Ihres Tests. in Ihrer Gaming-App. Mit Spielschleifen können Sie:

Führe ein Level in deinem Spiel so aus, wie es ein Endnutzer spielen würde. Sie können Sie können die Eingabe des Nutzers per Skript ausführen, den Nutzer inaktiv lassen oder den Nutzer wenn das in Ihrem Spiel sinnvoll ist (z.B. wenn Sie einen Rennwagen haben, und bereits eine KI implementiert haben. Sie können ganz einfach eine KI Fahrer der für die Eingabe der Nutzenden verantwortlich ist).
Führen Sie Ihr Spiel mit der höchsten Qualitätseinstellung aus, um zu prüfen, ob die Geräte dies unterstützen.
Technischen Test durchführen (mehrere Shader kompilieren, ausführen, prüfen, ob der die erwartete Ausgabe usw.)

Sie können einen Spielschleifentest auf einem einzelnen Testgerät, einer Reihe von Testgeräten oder am Test Lab. Wir raten jedoch davon ab, Spielschleifentests auf virtuellen Geräte, da diese eine niedrigere Framerate als physische Geräte haben.

Hinweis

Um einen Test zu implementieren, müssen Sie zuerst Ihre App für Spielschleifentests konfigurieren.

Fügen Sie in Ihrem App-Manifest zu activity einen neuen Intent-Filter hinzu:
```
<activity android:name=".MyActivity">
   <intent-filter>
       <action android:name="com.google.intent.action.TEST_LOOP"/>
       <category android:name="android.intent.category.DEFAULT"/>
       <data android:mimeType="application/javascript"/>
   </intent-filter>
   <intent-filter>
      ... (other intent filters here)
   </intent-filter>
</activity>
```
So kann Test Lab Ihr Spiel starten, indem es mit einer bestimmten Absicht ausgelöst wird.

Hinweis :Für Spielschleifen ist ein separater, dedizierter Intent-Filter erforderlich, der nicht verwendet wird für andere Zwecke. Ihre Aktivitäten können auch andere Intent-Filter enthalten. Weitere Informationen Weitere Informationen zu Intent-Filtern finden Sie in der <intent-filter> Referenzseite.

Fügen Sie in Ihrem Code (wir empfehlen in der Methodendeklaration onCreate) den Parameter Folgendes:

Kotlin+KTX

val launchIntent = intent
if (launchIntent.action == "com.google.intent.action.TEST_LOOP") {
    val scenario = launchIntent.getIntExtra("scenario", 0)
    // Code to handle your game loop here
}MainActivity.kt

Java

Intent launchIntent = getIntent();
if(launchIntent.getAction().equals("com.google.intent.action.TEST_LOOP")) {
    int scenario = launchIntent.getIntExtra("scenario", 0);
    // Code to handle your game loop here
}MainActivity.java

So kann Ihre Aktivität den Intent prüfen, der sie auslöst. Sie können diesen Code auch später hinzufügen, z. B. nach dem ersten Laden der Game Engine.

Empfohlen: Fügen Sie am Ende des Tests Folgendes hinzu:
Kotlin+KTX
```
yourActivity.finish()MainActivity.kt
```
Java
```
yourActivity.finish();MainActivity.java
```
Dadurch wird deine App geschlossen, wenn der Spielschleifentest abgeschlossen ist. Der Test basiert auf das UI-Framework Ihrer App zum Starten der nächsten Schleife. Wenn Sie die App schließen, damit der Test abgeschlossen ist.

Spielschleifentest erstellen und ausführen

Nachdem Sie Ihre App für Spielschleifentests konfiguriert haben, können Sie sofort eine testen und in Ihrer Gaming-App ausführen. Sie können einen Test in Test Lab über die Firebase-Konsole oder das gcloud Befehlszeilenschnittstelle (CLI) oder auf einem lokalen Gerät mithilfe der Testschleife Administrator.

Auf einem lokalen Gerät ausführen

Der Test Loop Manager von Test Lab ist eine Open-Source-App, mit der Sie Integrieren Sie Spielschleifentests und führen Sie sie auf Ihren lokalen Geräten aus. Außerdem können Ihre Qualitätssicherungsteam, um dieselben Spielschleifen auf ihren Geräten auszuführen.

So führen Sie einen Test auf einem lokalen Gerät mit dem Test Loop Manager aus:

Laden Sie den Test Loop Manager herunter. auf einem Smartphone oder Tablet und installiere es mit folgendem Befehl:
```
adb install testloopmanager.apk
```
Öffne auf deinem Gerät die App Test Loop Apps auf deinem Smartphone oder Tablet. Die App zeigt eine Liste der Apps auf Ihrem Gerät an, die mit Game Loops ausgeführt werden können. Wenn du deine Gaming-App hier nicht siehst, stimmt Ihr Intent-Filter mit dem Filter überein, der im ersten Schritt der Abschnitt „Vorbereitung“:
Wähle deine Gaming-App und dann die Anzahl der Loops aus, die du ausführen möchtest. Hinweis: In diesem Schritt können Sie eine Teilmenge von Schleifen ausführen, eine Schleife. Weitere Informationen zu Ausführen mehrerer Schleifen gleichzeitig, siehe Optionale Funktionen.
Klicken Sie auf Testen. Ihr Test beginnt sofort.

Ausführung in Test Lab

Du kannst einen Spielschleifentest in Test Lab mit dem Firebase-Konsole oder die gcloud CLI Öffnen Sie vor Beginn die Firebase-Konsole und erstellen Sie ein Projekt.

Firebase-Konsole verwenden

Klicken Sie in der Firebase-Konsole im linken Bereich auf Test Lab.
Klicken Sie auf Ersten Test ausführen oder auf Test ausführen, wenn für Ihr Projekt bereits ein Test ausgeführt wurde.
Wählen Sie als Testtyp Spielschleife aus und klicken Sie dann auf Weiter.
Klicken Sie auf Durchsuchen und suchen Sie die Datei .apk Ihrer Anwendung. Hinweis: In diesem Schritt können Sie eine Teilmenge von Schleifen ausführen, eine Schleife. Weitere Informationen zu mehrere Schleifen gleichzeitig ausführen, Optionale Funktionen:
Klicken Sie auf Weiter.
Wählen Sie die physischen Geräte aus, die zum Testen Ihrer App verwendet werden sollen.
Klicken Sie auf Tests starten.

Weitere Informationen zu den ersten Schritten mit der Firebase-Konsole finden Sie unter Führen Sie den Test mit der Firebase-Konsole durch.

gcloud-Befehlszeile verwenden

Falls noch nicht geschehen, laden Sie das Google Cloud SDK herunter und installieren Sie es.
Melden Sie sich mit Ihrem Google-Konto in der gcloud CLI an:

gcloud auth login
Legen Sie Ihr Firebase-Projekt in gcloud fest, wobei PROJECT_ID ist ID Ihres Firebase-Projekts:
```
gcloud config set project PROJECT_ID
```
Führen Sie Ihren ersten Test aus:
```
gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23
```
Hinweis: In diesem Schritt können Sie eine Teilmenge von Schleifen ausführen, anstatt nur eine Schleife. Weitere Informationen zum Ausführen mehrerer Schleifen gleichzeitig finden Sie unter Optionale Funktionen.

Weitere Informationen zu den ersten Schritten mit der gcloud CLI finden Sie unter Starten Sie den Test über die gcloud-Befehlszeile.

Optionale Funktionen

Test Lab bietet mehrere optionale Funktionen, mit denen Sie Ihr Tests, einschließlich der Möglichkeit zum Schreiben von Ausgabedaten, Unterstützung mehrerer Spiele Schleifen und Beschriftungen für verwandte Schleifen.

Ausgabedaten schreiben

Ihr Spielschleifentest kann die Ausgabe in eine Datei schreiben, die im launchIntent.getData()-Methode. Nach dem Test können Sie auf diese im Abschnitt Test Lab der Firebase-Konsole (siehe Beispiel für eine Spielschleifentestausgabedatei).

Test Lab befolgt die Best Practices für die Freigabe einer Datei zwischen Apps, die unter folgendem Link beschrieben werden: Datei freigeben. In der onCreate()-Methode Ihrer Aktivität, also dort, wo sich Ihr Intent befindet, können Sie Ihre Datenausgabedatei überprüfen, indem Sie folgenden Code ausführen:

Kotlin+KTX

val launchIntent = intent
val logFile = launchIntent.data
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    // ...
}MainActivity.kt

Java

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    // ...
}MainActivity.java

Wenn du mit der C++-Seite deiner Spiele-App in die Datei schreiben möchtest, kannst du übergeben Sie den Dateideskriptor anstelle des Dateipfads:

Kotlin+KTX

val launchIntent = intent
val logFile = launchIntent.data
var fd = -1
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    fd = try {
        contentResolver
            .openAssetFileDescriptor(logFile, "w")!!
            .parcelFileDescriptor
            .fd
    } catch (e: FileNotFoundException) {
        e.printStackTrace()
        -1
    } catch (e: NullPointerException) {
        e.printStackTrace()
        -1
    }
}

// C++ code invoked here.
// native_function(fd);MainActivity.kt

Java

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
int fd = -1;
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    try {
        fd = getContentResolver()
                .openAssetFileDescriptor(logFile, "w")
                .getParcelFileDescriptor()
                .getFd();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        fd = -1;
    } catch (NullPointerException e) {
        e.printStackTrace();
        fd = -1;
    }
}

// C++ code invoked here.
// native_function(fd);MainActivity.java

C++

#include <unistd.h>
JNIEXPORT void JNICALL
Java_my_package_name_MyActivity_native_function(JNIEnv *env, jclass type, jint log_file_descriptor) {
// The file descriptor needs to be duplicated.
int my_file_descriptor = dup(log_file_descriptor);
}

Beispiel für eine Ausgabedatei

Sie können Ausgabedatendateien, die wie im Beispiel unten formatiert sind, zur Darstellung des Spiels verwenden. Ergebnisse von Schleifentests im Abschnitt Test Lab der Firebase-Konsole. Bereiche, die als /.../ angezeigt werden, können beliebige benutzerdefinierte Felder enthalten, solange Sie stehen nicht in Konflikt mit den Namen anderer in dieser Datei verwendeter Felder:

{
  "name": "test name",
  "start_timestamp": 0, // Timestamp of the test start (in us).
                           Can be absolute or relative
  "driver_info": "...",
  "frame_stats": [
    {
      "timestamp": 1200000, // Timestamp at which this section was written
                               It contains value regarding the period
                               start_timestamp(0) -> this timestamp (1200000 us)
      "avg_frame_time": 15320, // Average time to render a frame in ns
      "nb_swap": 52, // Number of frame rendered
      "threads": [
        {
          "name": "physics",
          "Avg_time": 8030 // Average time spent in this thread per frame in us
        },
        {
          "name": "AI",
          "Avg_time": 2030 // Average time spent in this thread per frame in us
        }
      ],
      /.../ // Any custom field you want (vertices display on the screen, nb units …)
    },
    {
      // Next frame data here, same format as above
    }
  ],
  "loading_stats": [
    {
      "name": "assets_level_1",
      "total_time": 7850, // in us
      /.../
    },
    {
      "name": "victory_screen",
      "total_time": 554, // in us
      /.../
    }

  ],
  /.../, // You can add custom fields here
}

Mehrere Spielschleifen

Es kann nützlich sein, mehrere Spielschleifen in Ihrer App auszuführen. Eine Schleife ist eine von Anfang bis Ende durchläuft. Wenn Sie beispielsweise mehrere Level haben, ist eine Spielschleife sinnvoll, statt eine Schleife zu haben, die alle Ebenen durchläuft. Wenn deine App dann auf Level 32 abstürzt, kannst du das Spiel direkt starten. Schleife, um den Absturz zu reproduzieren und die Fehlerkorrekturen zu testen.

So aktivieren Sie für Ihre App die gleichzeitige Ausführung mehrerer Schleifen:

Wenn Sie einen Test mit dem Test Loop Manager ausführen:
1. Fügen Sie dem Manifest Ihrer App die folgende Zeile im <application>-Element hinzu:
```
<meta-data
  android:name="com.google.test.loops"
  android:value="5" />
```
  Dieser Start-Intent enthält die Zielschleife als Ganzzahlparameter. Geben Sie im Feld android:value eine Ganzzahl zwischen 1 und 1.024 ein (die maximale Anzahl von Schleifen, die für einen einzelnen Test zulässig sind). Hinweis dass Schleifen beginnend bei 1 und nicht bei 0 indexiert werden.
2. In der Test Loop Manager-App erscheint ein Auswahlbildschirm, der können Sie auswählen, welche Schleifen ausgeführt werden sollen. Wenn Sie mehrere Schleifen auswählen, wird jede Schleife nach Abschluss der vorherigen Schleife gestartet.
Wenn Sie einen Test mit der Firebase-Konsole ausführen, geben Sie im Feld Szenarien eine Liste oder einen Bereich von Schleifennummern ein.
Wenn Sie einen Test mit der gcloud CLI ausführen, geben Sie eine Liste mit Schleifennummern an. indem Sie das Flag --scenario-numbers verwenden. Beispiel: --scenario-numbers=1,3,5 führt die Schleifen 1, 3 und 5 aus.
Wenn Sie C++ schreiben und das Verhalten der Schleife ändern möchten, übergeben Sie den folgenden Zusatz in Ihren nativen C++-Code einfügen:
Kotlin+KTX
```
val launchIntent = intent
val scenario = launchIntent.getIntExtra("scenario", 0)MainActivity.kt
```
Java
```
Intent launchIntent = getIntent();
int scenario = launchIntent.getIntExtra("scenario", 0);MainActivity.java
```
Sie können das Verhalten der Schleife jetzt basierend auf dem resultierenden int-Wert ändern.

Spielschleifen beschriften

Wenn Sie Spielschleifen mit einem oder mehreren Szenariolabels versehen, kann das Team problemlos eine Reihe zusammengehöriger Spielschleifen starten (z.B. "alle Kompatibilität Spielschleifen“), und testen sie in einer einzigen Matrix. Sie können eigene Labels erstellen oder Vordefinierte Labels von Test Lab verwenden:

com.google.test.loops.player_experience: für Schleifen, die verwendet werden, um das Spielerlebnis zu reproduzieren. Das Ziel der mit diesen Schleifen zu testen, besteht darin, Probleme zu finden, das Spiel spielen.
com.google.test.loops.gpu_compatibility: für Schleifen, die zum Testen verwendet werden Probleme mit der GPU. Das Ziel der Tests mit diesen Schleifen besteht darin, der in der Produktion möglicherweise nicht ordnungsgemäß ausgeführt wird, um Probleme mit Hardware und Treiber.
com.google.test.loops.compatibility: für Schleifen zum Testen eines Zahlreiche Kompatibilitätsprobleme, darunter E/A-Probleme und OpenSSL Probleme.
com.google.test.loops.performance: für Schleifen, die zum Testen des Leistung des Geräts zu ermitteln. Ein Spiel kann zum Beispiel in den komplexesten Grafikeinstellungen, um das Verhalten eines neuen Geräts zu sehen.

So aktivieren Sie für Ihre App das Ausführen von Schleifen mit demselben Label:

Wenn Sie einen Test mit dem Test Loop Manager ausführen:
1. Fügen Sie im Manifest Ihrer App die folgende Metadatenzeile hinzu und ersetzen Sie LABEL_NAME durch ein Label Ihrer Wahl:
```
<meta-data
 android:name="com.google.test.loops.LABEL_NAME"
 android:value="1,3-5" />
```
  Im Feld android:value können Sie einen Bereich oder eine Reihe von Ganzzahlen von 1 bis 1.024 (die maximal zulässige Anzahl von Schleifen für einen einzelnen Test) angeben, die die Schleifen repräsentieren, die Sie beschriften möchten. Schleifen werden ab dem von 1 und nicht von 0. Beispielsweise gilt android:value="1,3-5" LABEL_NAME zu den Schleifen 1, 3, 4 und 5.
2. Geben Sie in der Test Loop Manager App in das Feld Labels ein oder mehrere Labels ein. ein.
Wenn Sie einen Test mit der Firebase-Konsole ausführen, geben Sie mindestens einen Labels im Feld Labels.
Wenn Sie einen Test mit der gcloud CLI ausführen, geben Sie eine an Szenario-Labels erstellen, indem Sie die --scenario-labels-Flag (z.B. --scenario-labels=performance,gpu).

Support für die App-Lizenzierung

Test Lab unterstützt Apps, die den App-Lizenzierung von Google Play angeboten wird. Damit die Lizenzierung beim Testen Ihrer App mit Test Lab überprüft werden kann, müssen Sie Ihre App im Play Store im Produktionskanal veröffentlichen. So testen Sie Ihre App in der Alpha- oder Betaversion mit Test Lab, entferne die Lizenzprüfung, bevor du deine App auf hochlädst Test Lab

Bekannte Probleme

Bei Spielschleifentests in Test Lab sind die folgenden bekannten Probleme aufgetreten:

Bei einigen Abstürzen werden Backtraces nicht unterstützt. Beispielsweise können einige Release-Builds Ausgabe des Prozesses debuggerd unterdrücken mit prctl(PR_SET_DUMPABLE, 0). Weitere Informationen finden Sie unter debuggerd
API-Level 19 wird aufgrund von Dateiberechtigungsfehlern derzeit nicht unterstützt.