หน้านี้ได้รับการแปลโดย Cloud Translation API

เริ่มต้นใช้งานการทดสอบ Game Loop

การทดสอบเกมโดยอัตโนมัติอาจเป็นเรื่องยากหากแอปเกมสร้างขึ้นบน เฟรมเวิร์ก UI การทดสอบ Game Loop ช่วยให้คุณสามารถผสานรวมการทดสอบแบบเนทีฟกับ Test Lab และใช้งานได้ง่ายๆ ในอุปกรณ์ที่คุณเลือก การทดสอบ Game Loop จะทดสอบคุณ ทดสอบผ่านแอปเกมไปพร้อมๆ กับจำลองการทำงานของผู้เล่นจริง ช่วงเวลานี้ คำแนะนำจะแสดงวิธีทำการทดสอบ Game Loop จากนั้นดูและจัดการการทดสอบ ในคอนโซล Firebase

คุณสามารถใช้การทดสอบกับเครื่องมือเกมเดียวหรือหลายรายการก็ได้ โดยขึ้นอยู่กับเกมเอนจินของคุณ การวนซ้ำ ลูปคือการทดสอบทั้งหมดหรือบางส่วน ในแอปเกมของคุณ Game Loop มีประโยชน์สำหรับสิ่งต่อไปนี้

ดำเนินการเล่นเกมในระดับเดียวกับที่ผู้ใช้ปลายทางเล่นเกม คุณสามารถ สคริปต์การป้อนข้อมูลของผู้ใช้ ปล่อยให้ผู้ใช้ไม่มีความเคลื่อนไหว หรือแทนที่ ผู้ใช้ กับ AI หากเกมมีความเหมาะสม (เช่น สมมติว่าคุณใช้รถแข่ง เป็นแอปที่ใช้ AI อยู่แล้ว คุณสามารถใส่ AI คนขับ รับผิดชอบข้อมูลของผู้ใช้)
เล่นเกมที่การตั้งค่าคุณภาพสูงสุดเพื่อดูว่าอุปกรณ์รองรับหรือไม่
ทำการทดสอบทางเทคนิค (คอมไพล์ตัวปรับแสงเงาหลายๆ ตัว เรียกใช้โค้ดเหล่านั้น ตรวจสอบว่า เป็นไปตามที่คาดไว้ ฯลฯ)

คุณทำการทดสอบ Game Loop บนอุปกรณ์ทดสอบ 1 เครื่อง อุปกรณ์ทดสอบ 1 ชุด หรือ ใน Test Lab อย่างไรก็ตาม เราไม่แนะนำให้เรียกใช้การทดสอบ Game Loop แบบออนไลน์ อุปกรณ์ที่มีอัตราเฟรมของกราฟิกต่ำกว่าอุปกรณ์จริง

ก่อนเริ่มต้น

หากต้องการใช้การทดสอบ คุณต้องกำหนดค่าแอปสำหรับการทดสอบ Game Loop ก่อน

ในไฟล์ Manifest ของแอป ให้เพิ่มตัวกรอง Intent ใหม่ลงในกิจกรรม ดังนี้
```
<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>
```
วิธีนี้จะช่วยให้ Test Lab เปิดตัวเกมของคุณโดยเรียกใช้ด้วย Intent

หมายเหตุ: Game Loop ต้องใช้ตัวกรอง Intent เฉพาะแยกต่างหากที่ไม่ได้ใช้ เพื่อวัตถุประสงค์อื่นๆ กิจกรรมอาจมีตัวกรอง Intent อื่นๆ ด้วย เพื่อเรียนรู้ เพิ่มเติมเกี่ยวกับตัวกรอง Intent โปรดดู <ตัวกรองความตั้งใจ> หน้าอ้างอิง
ในโค้ดของคุณ (เราขอแนะนำให้อยู่ในการประกาศเมธอด onCreate) ให้เพิ่มเมธอด ดังต่อไปนี้:
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
```
ซึ่งจะช่วยให้กิจกรรมตรวจสอบ Intent ที่เปิดแอปได้ นอกจากนี้คุณยัง เพิ่มโค้ดนี้ภายหลังหากคุณต้องการ (เช่น หลังจากโหลดเกมครั้งแรก เครื่องมือ)
แนะนำ: เมื่อสิ้นสุดการทดสอบ ให้เพิ่มรายการต่อไปนี้
Kotlin+KTX
```
yourActivity.finish()MainActivity.kt
```
Java
```
yourActivity.finish();MainActivity.java
```
การดำเนินการนี้จะปิดแอปของคุณเมื่อการทดสอบ Game Loop เสร็จสมบูรณ์ การทดสอบอาศัย เฟรมเวิร์ก UI ของแอปเพื่อเริ่มวนซ้ำถัดไป และการปิดแอปจะบอก ว่าการทดสอบเสร็จสิ้นแล้ว

สร้างและเรียกใช้การทดสอบ Game Loop

หลังจากกำหนดค่าแอปสำหรับการทดสอบ Game Loop แล้ว คุณสามารถสร้าง ทดสอบและใช้งานในแอปเกม คุณเลือกทำการทดสอบได้ใน Test Lab โดยใช้คอนโซล Firebase หรือ gcloud อินเทอร์เฟซบรรทัดคำสั่ง (CLI) หรือในอุปกรณ์เฉพาะที่โดยใช้ Test Loop ผู้จัดการ

เรียกใช้ในอุปกรณ์ภายใน

Test Loop Manager ของ Test Lab เป็นแอปโอเพนซอร์สที่ช่วยให้คุณ ผสานรวมการทดสอบ Game Loop และเรียกใช้การทดสอบในอุปกรณ์ภายในของคุณ นอกจากนี้ยังช่วยให้ ทีมรับประกันคุณภาพสามารถเรียกใช้ Game Loop เดียวกันบนอุปกรณ์ของตนได้

วิธีทำการทดสอบในอุปกรณ์ภายในโดยใช้ Test Loop Manager

ดาวน์โหลด Test Loop Manager บนโทรศัพท์หรือแท็บเล็ต แล้วติดตั้งโดยการเรียกใช้
```
adb install testloopmanager.apk
```
เปิดแอปแอป Test Loop ในโทรศัพท์ หรือ แท็บเล็ต แอปจะแสดงรายการแอปบนอุปกรณ์ของคุณ อาจเรียกใช้ด้วย Game Loop ได้ หากไม่เห็นแอปเกมของคุณที่นี่ ให้ตรวจสอบว่า ตัวกรอง Intent ตรงกับรายการที่อธิบายไว้ในขั้นตอนแรก ส่วนก่อนเริ่มต้น
เลือกแอปเกม จากนั้นเลือกจำนวนการวนซ้ำที่ต้องการเรียกใช้ หมายเหตุ: ในขั้นตอนนี้ คุณสามารถเลือกเรียกใช้ชุดย่อยของการวนซ้ำ แทนที่จะเรียกใช้แค่ วนซ้ำ 1 รอบ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ การเรียกใช้การวนซ้ำหลายรายการพร้อมกัน โปรดดูหัวข้อฟีเจอร์ที่ไม่บังคับ
คลิกเรียกใช้การทดสอบ การทดสอบจะเริ่มทํางานทันที

เรียกใช้ใน Test Lab

คุณทำการทดสอบ Game Loop ใน Test Lab ได้โดยใช้ คอนโซล Firebase หรือ gcloud CLI ก่อนคุณ เริ่มต้น หากยังไม่ได้ดำเนินการ คอนโซล Firebase และสร้างโปรเจ็กต์

ใช้คอนโซล Firebase

ในคอนโซล Firebase ให้คลิก Test Lab จากแผงด้านซ้าย
คลิกเรียกใช้การทดสอบครั้งแรก (หรือเรียกใช้การทดสอบ หากโปรเจ็กต์มี ทำการทดสอบก่อนหน้านี้)
เลือก Game Loop เป็นประเภทการทดสอบ แล้วคลิกต่อไป
คลิกเรียกดู แล้วเรียกดูไฟล์ .apk ของแอป หมายเหตุ: ในขั้นตอนนี้ คุณสามารถเลือกเรียกใช้ชุดย่อยของการวนซ้ำ แทนที่จะเรียกใช้แค่ วนซ้ำ 1 รอบ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ ที่เล่นลูปหลายรอบพร้อมกัน โปรดดู ฟีเจอร์เสริม
คลิกต่อไป
เลือกอุปกรณ์จริงที่จะใช้ทดสอบแอป
คลิกเริ่มการทดสอบ

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเริ่มต้นใช้งานคอนโซล Firebase ได้ที่ เริ่มทดสอบด้วยคอนโซล Firebase

ใช้บรรทัดคำสั่ง gcloud (CLI)

ดาวน์โหลดและติดตั้ง Google Cloud SDK หากยังไม่ได้ทำ
ลงชื่อเข้าใช้ gcloud CLI โดยใช้บัญชี Google โดยใช้คำสั่งต่อไปนี้

gcloud auth login
ตั้งค่าโปรเจ็กต์ Firebase ใน gcloud โดยที่ PROJECT_ID คือ รหัสของโปรเจ็กต์ Firebase
```
gcloud config set project PROJECT_ID
```
เรียกใช้การทดสอบแรก:
```
gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23
```
หมายเหตุ: ในขั้นตอนนี้ คุณสามารถเลือกเรียกใช้ชุดย่อยของการวนซ้ำ แทนที่จะเรียกใช้แค่ วนซ้ำ 1 รอบ ดูข้อมูลเพิ่มเติมเกี่ยวกับการเรียกใช้การวนซ้ำหลายรายการพร้อมกันได้ที่ ฟีเจอร์เสริม

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเริ่มต้นใช้งาน gcloud CLI ได้ที่ เริ่มทดสอบจากบรรทัดคำสั่ง gcloud

ฟีเจอร์เสริม

Test Lab มีฟีเจอร์เสริมมากมายที่ช่วยให้คุณปรับแต่ง ซึ่งรวมถึงความสามารถในการเขียนข้อมูลเอาต์พุต การสนับสนุนเกมหลายเกม การวนซ้ำ และป้ายกำกับสำหรับการวนซ้ำที่เกี่ยวข้อง

เขียนข้อมูลเอาต์พุต

การทดสอบ Game Loop สามารถเขียนเอาต์พุตไปยังไฟล์ที่ระบุใน launchIntent.getData() วิธี หลังจากทำการทดสอบแล้ว คุณจะเข้าถึง ข้อมูลเอาต์พุตในส่วน Test Lab ของคอนโซล Firebase (โปรดดู ตัวอย่างไฟล์เอาต์พุตสำหรับการทดสอบ Game Loop)

Test Lab ทำตามแนวทางปฏิบัติแนะนำในการแชร์ไฟล์ระหว่างแอปตามที่อธิบายไว้ใน การแชร์ไฟล์ ในเมธอด onCreate() ของกิจกรรมที่ระบุความตั้งใจของคุณ คุณจะ ตรวจสอบไฟล์เอาต์พุตข้อมูลได้โดยเรียกใช้โค้ดต่อไปนี้

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

หากต้องการเขียนลงในไฟล์จากฝั่ง C++ ของแอปเกม คุณสามารถ ในข้อบ่งชี้ไฟล์แทนเส้นทางของไฟล์:

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

ตัวอย่างไฟล์เอาต์พุต

คุณสามารถใช้ไฟล์ข้อมูลเอาต์พุต (มีรูปแบบเหมือนตัวอย่างด้านล่าง) เพื่อแสดงเกม ผลการทดสอบวนซ้ำในส่วน Test Lab ของคอนโซล Firebase พื้นที่ที่แสดงเป็น /.../ สามารถมีช่องที่กำหนดเองที่คุณต้องการ ตราบใดที่ ไม่ขัดแย้งกับชื่อของฟิลด์อื่นๆ ที่ใช้ในไฟล์นี้

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

Game Loop หลายรายการ

คุณอาจพบว่าการเรียกใช้ Game Loop หลายๆ ครั้งในแอปนั้นมีประโยชน์ ลูปคือ ตรวจสอบแอปเกมของคุณตั้งแต่ต้นจนจบ ตัวอย่างเช่น หากคุณ มีหลายระดับในเกม คุณอาจจะอยากมี Game Loop เดียวเพื่อ เปิดใช้แต่ละระดับ แทนที่จะมีลูปเดียวที่เล่นซ้ำไปเรื่อยๆ ด้วยวิธีนี้ หากแอปเกิดข้อขัดข้องในระดับ 32 คุณก็เปิดเกมนั้นได้โดยตรง วนซ้ำเพื่อทำซ้ำการแก้ไขข้อบกพร่องและทดสอบการแก้ไขข้อบกพร่อง

วิธีอนุญาตให้แอปเรียกใช้การวนซ้ำหลายรายการพร้อมกัน

ในกรณีที่คุณทำการทดสอบด้วย Test Loop Manager ให้ทำดังนี้
1. เพิ่มบรรทัดต่อไปนี้ลงในไฟล์ Manifest ของแอปภายในไฟล์ องค์ประกอบ <application>:
```
<meta-data
  android:name="com.google.test.loops"
  android:value="5" />
```
  Intent การเปิดตัวนี้มีลูปเป้าหมายเป็นพารามิเตอร์จำนวนเต็ม ใน ในช่อง android:value คุณสามารถระบุจำนวนเต็มได้ตั้งแต่ 1 ถึง 1024 (ฟิลด์ จำนวนการวนซ้ำสูงสุดที่อนุญาตสำหรับการทดสอบ 1 ครั้ง) หมายเหตุ ที่ลูปจะได้รับการจัดทำดัชนีโดยเริ่มจาก 1 ไม่ใช่ 0
2. ในแอป Test Loop Manager หน้าจอการเลือกจะปรากฏขึ้น ให้คุณเลือกการวนซ้ำที่คุณต้องการเรียกใช้ หากคุณเลือกหลายรายการ การวนซ้ำ แต่ละลูปจะเปิดขึ้นตามลำดับหลังจากการวนซ้ำก่อนหน้า เสร็จสมบูรณ์
หากคุณกำลังทดสอบด้วยคอนโซล Firebase ให้ป้อนรายการหรือ ช่วงของหมายเลขวนซ้ำในช่องสถานการณ์
หากกำลังทำการทดสอบด้วย gcloud CLI ให้ระบุรายการหมายเลขวนซ้ำ โดยใช้แฟล็ก --scenario-numbers ตัวอย่างเช่น --scenario-numbers=1,3,5 เรียกใช้ลูป 1, 3 และ 5
ถ้าคุณกำลังเขียน C++ และต้องการเปลี่ยนลักษณะการทำงานของลูป ให้ส่งค่า เพิ่มเติมไปยังโค้ด C++ ดั้งเดิมของคุณ:
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
```
ตอนนี้คุณเปลี่ยนลักษณะการทำงานของการวนซ้ำโดยอิงตามผลลัพธ์ int ได้แล้ว

ติดป้ายกำกับ Game Loop

เมื่อคุณติดป้ายกำกับ Game Loop ด้วยป้ายกำกับสถานการณ์อย่างน้อย 1 รายการ จะถือว่าคุณและ QA ของคุณ ทีมสามารถเปิดตัวชุด Game Loop ที่เกี่ยวข้องได้โดยง่าย (เช่น "ความเข้ากันได้ทั้งหมด Game Loop") และทดสอบในเมทริกซ์เดียว คุณสามารถสร้างป้ายกำกับของตัวเอง หรือ ใช้ป้ายกำกับที่กำหนดไว้ล่วงหน้าจาก Test Lab ดังนี้

com.google.test.loops.player_experience: สำหรับการวนซ้ำที่ใช้เพื่อ สร้างประสบการณ์จริงให้กับผู้ใช้ในขณะเล่นเกม เป้าหมายของ การทดสอบแบบวนซ้ำเหล่านี้คือ การค้นหาปัญหาที่ผู้ใช้จริงพบขณะ และเล่นเกม
com.google.test.loops.gpu_compatibility: สำหรับการวนซ้ำที่ใช้ทดสอบ ปัญหาเกี่ยวกับ GPU เป้าหมายในการทดสอบด้วยการวนซ้ำเหล่านี้คือการใช้ GPU ที่อาจทำงานอย่างไม่ถูกต้องในเวอร์ชันที่ใช้งานจริง เพื่อแสดงปัญหาเกี่ยวกับ ฮาร์ดแวร์และไดรเวอร์
com.google.test.loops.compatibility: สำหรับการวนซ้ำที่ใช้เพื่อทดสอบ ปัญหาความเข้ากันได้ที่หลากหลาย ซึ่งรวมถึงปัญหา I/O และ OpenSSL ปัญหา
com.google.test.loops.performance: สำหรับการวนซ้ำที่ใช้ทดสอบพารามิเตอร์ ประสิทธิภาพการทำงานของอุปกรณ์ เช่น เกมอาจทํางานที่ซับซ้อนที่สุด การตั้งค่ากราฟิกเพื่อดูว่าอุปกรณ์ใหม่ทำงานอย่างไร

วิธีอนุญาตให้แอปเรียกใช้การวนซ้ำที่มีป้ายกำกับเดียวกัน

ในกรณีที่คุณทำการทดสอบด้วย Test Loop Manager ให้ทำดังนี้
1. ในไฟล์ Manifest ของแอป ให้เพิ่มบรรทัดข้อมูลเมตาต่อไปนี้แล้วแทนที่ LABEL_NAME โดยใช้ป้ายกำกับที่ต้องการ:
```
<meta-data
 android:name="com.google.test.loops.LABEL_NAME"
 android:value="1,3-5" />
```
  ในช่อง android:value คุณจะระบุช่วงหรือชุดจำนวนเต็มได้ ตั้งแต่ 1 ถึง 1024 (จำนวนการวนซ้ำสูงสุดที่อนุญาตสำหรับการทดสอบ 1 ครั้ง) แสดงการวนซ้ำที่คุณต้องการติดป้ายกำกับ โปรดทราบว่าจะมีการจัดทำดัชนีการวนซ้ำตั้งแต่เริ่มต้น จาก 1 ไม่ใช่ 0 เช่น android:value="1,3-5" จะมีผล LABEL_NAME เพื่อวนซ้ำ 1, 3, 4 และ 5
2. ในแอป Test Loop Manager ให้ป้อนป้ายกำกับอย่างน้อย 1 รายการในป้ายกำกับ ด้วย
หากกำลังทดสอบด้วยคอนโซล Firebase ให้ป้อนอย่างน้อย 1 รายการ ป้ายกำกับในช่องป้ายกำกับ
หากกำลังทดสอบด้วย gcloud CLI โปรดระบุ ป้ายกำกับสถานการณ์อย่างน้อย 1 รายการด้วยการใช้ Flag --scenario-labels (เช่น --scenario-labels=performance,gpu).

การสนับสนุนการมอบใบอนุญาตแอป

Test Lab รองรับแอปที่ใช้ การอนุญาตให้ใช้สิทธิแอป ที่ให้บริการโดย Google Play เพื่อตรวจสอบการอนุญาตให้ใช้สิทธิให้สำเร็จเมื่อทำการทดสอบ แอปของคุณด้วย Test Lab คุณต้องเผยแพร่แอปไปยังช่องทางของเวอร์ชันที่ใช้งานจริง ใน Play Store หากต้องการทดสอบแอปในเวอร์ชันอัลฟ่าหรือเบต้าโดยใช้ Test Lab โปรดนำการตรวจสอบการให้สัญญาอนุญาตออกก่อนอัปโหลดแอปไปยัง Test Lab

ปัญหาที่ทราบ

การทดสอบ Game Loop ใน Test Lab มีปัญหาที่ทราบดังต่อไปนี้

ข้อขัดข้องบางรายการไม่รองรับ Backtrace ตัวอย่างเช่น บิลด์รุ่นบางเวอร์ชันอาจ ระงับเอาต์พุตของกระบวนการ debuggerd โดยใช้ prctl(PR_SET_DUMPABLE, 0). ดูข้อมูลเพิ่มเติมได้ที่ debuggerd.
ขณะนี้ยังไม่รองรับ API ระดับ 19 เนื่องจากเกิดข้อผิดพลาดเกี่ยวกับสิทธิ์ของไฟล์