गेम लूप के टेस्ट शुरू करें

जब गेमिंग ऐप्लिकेशन अलग-अलग डिवाइसों पर बने होते हैं, तब गेम की टेस्टिंग को ऑटोमेट करना मुश्किल हो सकता है यूज़र इंटरफ़ेस (यूआई) फ़्रेमवर्क. गेम लूप टेस्ट की मदद से, अपने नेटिव टेस्ट को Test Lab और इन्हें आपके चुने हुए डिवाइसों पर आसानी से इस्तेमाल किया जा सकता है. गेम लूप टेस्ट की मदद से, अपने गेमिंग ऐप्लिकेशन की मदद से, असली खिलाड़ी की तरह व्यवहार करें. यह इस गाइड में, गेम लूप टेस्ट करने का तरीका बताया गया है. इसके बाद, टेस्ट देखने और उसे मैनेज करने का तरीका बताया गया है Firebase कंसोल में नतीजे दिखाता है.

अपने गेम इंजन के आधार पर, टेस्ट लागू किए जा सकते हैं. लूप. लूप, आपके टेस्ट का पूरा या कुछ हिस्सा रन-थ्रू होता है ऐप्लिकेशन पर साइन इन करें. गेम लूप का इस्तेमाल इन कामों के लिए किया जा सकता है:

  • अपने गेम के लेवल को ठीक उसी तरह चलाएं जैसे कोई असली उपयोगकर्ता उसे खेलता है. आप या तो उपयोगकर्ता के इनपुट को स्क्रिप्ट करें, उपयोगकर्ता को कुछ समय से इस्तेमाल में न रहने दें या उपयोगकर्ता एआई की मदद से, अगर यह आपके गेम के हिसाब से सही है (उदाहरण के लिए, मान लें कि आपके पास रेस कार है गेमिंग ऐप्लिकेशन हो और इसमें पहले से ही एआई की सुविधा हो. आपके पास आसानी से एक एआई ड्राइवर उपयोगकर्ता के इनपुट को मैनेज किया जा सकता है).
  • अपने गेम को सबसे अच्छी क्वालिटी वाली सेटिंग पर चलाएं. इससे आपको पता चलेगा कि आपके गेम पर यह सुविधा काम करती है या नहीं.
  • टेक्निकल टेस्ट करें (कई शेडर कंपाइल करें, उन्हें एक्ज़ीक्यूट करें, और देखें कि आउटपुट उम्मीद के मुताबिक है वगैरह).

आप एक टेस्ट डिवाइस, टेस्ट डिवाइसों के सेट या Test Lab को. हालांकि, हमारा सुझाव है कि आप वर्चुअल क्योंकि उनमें फ़िज़िकल डिवाइसों के मुकाबले कम ग्राफ़िक फ़्रेम रेट होते हैं.

शुरू करने से पहले

टेस्ट लागू करने के लिए, आपको पहले अपने ऐप्लिकेशन को गेम लूप टेस्ट के लिए कॉन्फ़िगर करना होगा.

  1. अपने ऐप्लिकेशन मेनिफ़ेस्ट में, अपनी गतिविधि में एक नया इंटेंट फ़िल्टर जोड़ें:

    <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 को आपके गेम को किसी खास यूआरएल से ट्रिगर करने में मदद मिलती है इंटेंट.

  2. हमारा सुझाव है कि आप 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

    इससे आपकी गतिविधि को उस इंटेंट की जांच करने में मदद मिलती है जिससे उसे लॉन्च किया गया है. आप यह भी कर सकते हैं अगर आप चाहें, तो बाद में इस कोड को जोड़ लें. उदाहरण के लिए, गेम लोड करने के बाद इंजन).

  3. सुझाया गया: टेस्ट के आखिर में, इन्हें जोड़ें:

    Kotlin+KTX 

    yourActivity.finish()
    MainActivity.kt

    Java 

    yourActivity.finish();
    MainActivity.java

    गेम लूप टेस्ट पूरा होने पर, आपका ऐप्लिकेशन बंद हो जाएगा. टेस्ट इन बातों पर निर्भर करता है आपके ऐप्लिकेशन का यूज़र इंटरफ़ेस (यूआई) फ़्रेमवर्क, अगला लूप शुरू करने और बंद करने पर पता चलता है कि यह तय करता है कि टेस्ट पूरा हो गया है या नहीं.

गेम लूप टेस्ट बनाना और चलाना

अपने ऐप्लिकेशन को गेम लूप टेस्ट के लिए कॉन्फ़िगर करने के बाद, तुरंत अपने गेमिंग ऐप्लिकेशन पर टेस्ट करके चलाएं. जांच करने के लिए, Firebase कंसोल या gcloud का इस्तेमाल करने वाला Test Lab कमांड लाइन इंटरफ़ेस (सीएलआई) या टेस्ट लूप का इस्तेमाल करके लोकल डिवाइस पर मैनेजर.

स्थानीय डिवाइस पर चलाएं

Test Lab का टेस्ट लूप मैनेजर एक ओपन सोर्स ऐप्लिकेशन है, जो गेम लूप के टेस्ट इंटिग्रेट करके उन्हें अपने लोकल डिवाइसों पर चलाएं. इससे आपका क्वालिटी अश्योरेंस टीम को अपने डिवाइसों पर एक जैसे गेम लूप चलाने होंगे.

टेस्ट लूप मैनेजर का इस्तेमाल करके, किसी स्थानीय डिवाइस पर टेस्ट करने के लिए:

  1. टेस्ट लूप मैनेजर को डाउनलोड करें पर जाएं और यह चलाकर उसे इंस्टॉल करें: 
    adb install testloopmanager.apk
  2. अपने डिवाइस पर, अपने फ़ोन पर Test Loop ऐप्लिकेशन खोलें या टैबलेट. ऐप्लिकेशन, आपके डिवाइस पर उन ऐप्लिकेशन की सूची दिखाता है जो को गेम लूप की मदद से चलाया जा सकता है. अगर आपको यहां अपना गेमिंग ऐप्लिकेशन नहीं दिख रहा, तो पक्का करें कि आपका इंटेंट फ़िल्टर, पहले चरण में बताए गए फ़िल्टर से मैच करता हो सेक्शन शुरू करने से पहले.
  3. अपना गेमिंग ऐप्लिकेशन चुनें. इसके बाद, चुनें कि आपको कितने लूप चलाने हैं. ध्यान दें: इस चरण में, लूप के बजाय सिर्फ़ लूप का सबसेट चलाया जा सकता है. एक लूप. अगर आपको ज़्यादा जानकारी चाहिए, तो एक साथ कई लूप चलाने के लिए, वैकल्पिक सुविधाएं देखें.
  4. टेस्ट चलाएं पर क्लिक करें. जांच तुरंत शुरू हो जाएगी.

Test Lab में चलाएं

Test Lab में गेम लूप टेस्ट करने के लिए, इनमें से कोई एक तरीका अपनाएं: Firebase console या gcloud सीएलआई. इससे पहले शुरू करें, अगर आपने अभी तक नहीं किया है, तो Firebase कंसोल खोलें और कोई प्रोजेक्ट बनाएं.

Firebase कंसोल का इस्तेमाल करना

  1. Firebase कंसोल में, बाएं पैनल में Test Lab पर क्लिक करें.
  2. अपना पहला टेस्ट करें पर क्लिक करें (या अगर आपके प्रोजेक्ट में है, तो एक टेस्ट चलाएं पर क्लिक करें टेस्ट किया जाए).
  3. टेस्ट टाइप के तौर पर गेम लूप चुनें. इसके बाद, जारी रखें पर क्लिक करें.
  4. ब्राउज़ करें पर क्लिक करें. इसके बाद, अपने ऐप्लिकेशन की .apk फ़ाइल ब्राउज़ करें. ध्यान दें: इस चरण में, लूप के बजाय सिर्फ़ लूप का सबसेट चलाया जा सकता है. एक लूप. अगर आपको ज़्यादा जानकारी चाहिए, तो एक साथ कई लूप चलाना, वैकल्पिक सुविधाएं.
  5. जारी रखें पर क्लिक करें.
  6. अपने ऐप्लिकेशन की जांच करने के लिए, डिवाइसों को चुनें.
  7. टेस्ट शुरू करें पर क्लिक करें.

Firebase कंसोल का इस्तेमाल शुरू करने के बारे में ज़्यादा जानकारी के लिए, यहां देखें Firebase कंसोल के साथ जांच करना शुरू करें.

gcloud कमांड-लाइन (सीएलआई) का इस्तेमाल करना

  1. अगर आपने अभी तक इसका इस्तेमाल नहीं किया है, तो Google Cloud SDK को डाउनलोड और इंस्टॉल करें

  2. अपने Google खाते का इस्तेमाल करके gcloud सीएलआई में साइन इन करें:

    gcloud auth login

  3. अपना Firebase प्रोजेक्ट gcloud में सेट करें, जहां PROJECT_ID है आपके Firebase प्रोजेक्ट का आईडी:

    gcloud config set project PROJECT_ID

  4. अपना पहला टेस्ट करें:

    gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23

gcloud सीएलआई का इस्तेमाल शुरू करने के बारे में ज़्यादा जानकारी के लिए यह देखें gcloud कमांड लाइन से टेस्टिंग शुरू करें.

वैकल्पिक सुविधाएं

Test Lab में कई वैकल्पिक सुविधाएं मिलती हैं. इनकी मदद से, अपने हिसाब से बदलाव किए जा सकते हैं टेस्ट, जिनमें आउटपुट डेटा लिखने की क्षमता, कई गेम के लिए सहायता शामिल है लूप और मिलते-जुलते लूप के लिए लेबल की मदद ली जाती है.

आउटपुट डेटा सेव करने की अनुमति दें

आपका गेम लूप टेस्ट, launchIntent.getData() तरीका. टेस्ट करने के बाद, इसे ऐक्सेस किया जा सकता है Firebase कंसोल के Test Lab सेक्शन में आउटपुट डेटा (देखें गेम लूप के टेस्ट आउटपुट फ़ाइल का उदाहरण).

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

आउटपुट फ़ाइल का उदाहरण

गेम दिखाने के लिए, आउटपुट डेटा फ़ाइलों का इस्तेमाल किया जा सकता है. इन फ़ाइलों को नीचे दिए गए उदाहरण की तरह फ़ॉर्मैट किया गया है Firebase कंसोल के Test Lab सेक्शन में, लूप टेस्ट के नतीजे देखें. /.../ के तौर पर दिखाए गए इलाकों में, आपकी ज़रूरत के हिसाब से कोई भी कस्टम फ़ील्ड शामिल हो सकता है. हालांकि, ऐसा सिर्फ़ तब होगा, जब उनका इस फ़ाइल में इस्तेमाल किए गए अन्य फ़ील्ड के नाम से कोई टकराव नहीं होता:

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

एक से ज़्यादा गेम लूप

आपको अपने ऐप्लिकेशन में एक से ज़्यादा गेम लूप चलाना मददगार लग सकता है. लूप एक आपके गेम ऐप्लिकेशन को शुरू से आखिर तक पूरा रन-थ्रू बनाएं. उदाहरण के लिए, अगर आपके गेम में कई लेवल हैं, तो हो सकता है कि आप सभी लेवल में बार-बार आने वाले लूप की जगह, हर लेवल को लॉन्च करना. इस तरह, अगर आपका ऐप्लिकेशन लेवल 32 पर क्रैश हो जाता है, तो सीधे वह गेम लॉन्च किया जा सकता है लूप की मदद से, क्रैश और गड़बड़ी ठीक करने की जाँच करें.

अपने ऐप्लिकेशन को एक साथ कई लूप चलाने के लिए:

  • अगर टेस्ट लूप मैनेजर की मदद से टेस्ट किया जा रहा है, तो:

    1. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, इस लाइन के अंदर यह लाइन जोड़ें <application> एलिमेंट: 

      <meta-data
  android:name="com.google.test.loops"
  android:value="5" />

      इस लॉन्च इंटेंट में टारगेट लूप को पूर्णांक पैरामीटर के तौर पर शामिल किया गया है. तय सीमा में android:value फ़ील्ड में, 1 से 1024 तक का कोई पूर्णांक तय किया जा सकता है ( (एक टेस्ट के लिए ज़्यादा से ज़्यादा लूप की संख्या) तय करें. नोट जोड़ें वाले लूप 1 से शुरू होते हैं, 0 से नहीं.

    2. टेस्ट लूप मैनेजर ऐप्लिकेशन में, चुनने के लिए एक स्क्रीन दिखती है आपको यह चुनने की अनुमति देता है कि आप कौन-से लूप चलाना चाहते हैं. अगर आपने एक से ज़्यादा लूप होता है, तो हर लूप पिछले लूप के बाद, क्रम में लॉन्च होता है पूरा करता है.

  • अगर Firebase कंसोल की मदद से टेस्ट किया जा रहा है, तो कोई सूची या स्थिति फ़ील्ड में लूप नंबर की सीमा.

  • अगर gcloud सीएलआई की मदद से टेस्ट किया जा रहा है, तो लूप नंबर की सूची बनाएं --scenario-numbers फ़्लैग का इस्तेमाल करके. उदाहरण के लिए, --scenario-numbers=1,3,5 लूप 1, 3, और 5 पर चलता है.

  • अगर आप 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 के आधार पर अपने लूप के व्यवहार को बदल सकते हैं वैल्यू.

गेम लूप को लेबल करें

जब अपने गेम लूप को एक या उससे ज़्यादा स्थिति के लेबल के साथ लेबल किया जाता है, तो आपको और आपके QA को टीम, मिलते-जुलते गेम लूप के सेट को आसानी से लॉन्च कर सकती है (उदाहरण के लिए, "सभी डिवाइसों पर काम करने की सुविधा गेम लूप") और उनका एक ही मैट्रिक्स में परीक्षण करें. आप अपने खुद के लेबल बना सकते हैं या Test Lab के पहले से तय लेबल इस्तेमाल करें:

  • com.google.test.loops.player_experience: इन कामों के लिए इस्तेमाल किए जाने वाले लूप के लिए गेम खेलते समय असली उपयोगकर्ता के अनुभव को फिर से दिखा सकते हैं. इसका लक्ष्य इन लूप की जांच करके उन समस्याओं का पता लगाया जा सकता है जिनका सामना उपयोगकर्ता को गेम खेलना.
  • com.google.test.loops.gpu_compatibility: परीक्षण करने के लिए उपयोग किए जाने वाले लूप के लिए जीपीयू से जुड़ी समस्याएं. इन लूप के साथ टेस्ट करने का मकसद जीपीयू को एक्ज़ीक्यूट करना है ऐसा कोड जो प्रोडक्शन में ठीक से न चल सके, ताकि हार्डवेयर और ड्राइवर.
  • com.google.test.loops.compatibility: ‘यह’ टेस्ट करने के लिए इस्तेमाल किए जाने वाले लूप के लिए साथ काम करने से जुड़ी अलग-अलग तरह की समस्याएं हो सकती हैं. इनमें I/O से जुड़ी समस्याएं और OpenSSL शामिल हैं समस्याएं.
  • com.google.test.loops.performance: उन लूप के लिए जिनका इस्तेमाल करके डिवाइस की परफ़ॉर्मेंस. उदाहरण के लिए, हो सकता है कि कोई गेम बेहद मुश्किल जगह पर खेला जाए ग्राफ़िक सेटिंग का इस्तेमाल करके देखा जा सकता है कि नया डिवाइस कैसे काम करता है.

अपने ऐप्लिकेशन को एक ही लेबल वाले लूप चलाने की सुविधा चालू करने के लिए:

  • अगर टेस्ट लूप मैनेजर का इस्तेमाल करके टेस्ट किया जा रहा है, तो:

    1. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, यह मेटा-डेटा लाइन जोड़ें और उसे बदलें LABEL_NAME अपनी पसंद के लेबल के साथ:

      <meta-data
 android:name="com.google.test.loops.LABEL_NAME"
 android:value="1,3-5" />

      android:value फ़ील्ड में, कोई रेंज या पूर्णांकों का सेट तय किया जा सकता है 1 से 1024 तक (किसी एक टेस्ट के लिए, ज़्यादा से ज़्यादा लूप की अनुमति है) उन लूप को प्रस्तुत करें जिन्हें आप लेबल करना चाहते हैं. ध्यान दें कि लूप को इंडेक्स किया जाता है 1 से शुरू होती है, न कि 0 से. उदाहरण के लिए, android:value="1,3-5" लागू होता है 1, 3, 4, और 5 को लूप करने के लिए LABEL_NAME.

    2. टेस्ट लूप मैनेजर ऐप्लिकेशन में, लेबल में एक या उससे ज़्यादा लेबल डालें फ़ील्ड.

  • अगर Firebase कंसोल की मदद से टेस्ट किया जा रहा है, तो एक या एक से ज़्यादा कंसोल डालें लेबल फ़ील्ड में लेबल.

  • अगर gcloud सीएलआई की मदद से टेस्ट किया जा रहा है, तो किसी एक के बारे में बताएं या कुछ अन्य स्थिति के लिए, --scenario-labels फ़्लैग (उदाहरण के लिए, --scenario-labels=performance,gpu).

ऐप्लिकेशन लाइसेंसिंग से जुड़ी सहायता

Test Lab ऐसे ऐप्लिकेशन का इस्तेमाल करता है जो ऐप्लिकेशन लाइसेंसिंग Google Play की ओर से उपलब्ध कराई जाने वाली सेवा. जांच के दौरान लाइसेंस की जांच करना Test Lab के साथ आपका ऐप्लिकेशन पब्लिश किया जाता है, तो आपको अपने ऐप्लिकेशन को प्रोडक्शन चैनल पर पब्लिश करना होगा Play Store में. इसका उपयोग करके अल्फ़ा या बीटा चैनल में अपने ऐप्लिकेशन का परीक्षण करने के लिए Test Lab, इस पर अपना ऐप्लिकेशन अपलोड करने से पहले, लाइसेंस से जुड़ी जांच हटाएं Test Lab.

ज्ञात समस्याएं

Test Lab में गेम लूप टेस्ट में ये समस्याएं आती हैं:

  • कुछ क्रैश में बैकट्रेस की सुविधा काम नहीं करती. उदाहरण के लिए, कुछ रिलीज़ बिल्ड शायद इसका इस्तेमाल करके debuggerd प्रोसेस के आउटपुट को रोकें prctl(PR_SET_DUMPABLE, 0). इस बारे में ज़्यादा जानने के लिए, यह देखें debuggerd.
  • फ़ाइल को ऐक्सेस करने की अनुमति से जुड़ी गड़बड़ियों की वजह से, फ़िलहाल एपीआई लेवल 19 का इस्तेमाल नहीं किया जा सकता.