इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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

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

अपने ऐप्लिकेशन मेनिफ़ेस्ट में, अपनी गतिविधि में नया इंटेंट फ़िल्टर जोड़ें:
```
<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-filter> रेफ़रंस पेज देखें.
हमारा सुझाव है कि 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
```
इससे आपकी गतिविधि को, उसे लॉन्च करने वाले इंटेंट की जांच करने में मदद मिलती है. अगर आप चाहें, तो इस कोड को बाद में भी जोड़ा जा सकता है. उदाहरण के लिए, गेम इंजन को शुरू में लोड करने के बाद.
सुझाव: टेस्ट के आखिर में, ये जोड़ें:
Kotlin+KTX
```
yourActivity.finish()MainActivity.kt
```
Java
```
yourActivity.finish();MainActivity.java
```
इससे गेम लूप टेस्ट पूरा होने पर, आपका ऐप्लिकेशन बंद हो जाता है. अगला लूप शुरू करने के लिए, टेस्ट आपके ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) फ़्रेमवर्क पर निर्भर करता है. साथ ही, ऐप्लिकेशन को बंद करने से यह पता चलता है कि टेस्ट पूरा हो गया है.

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

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

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

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

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

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

Test Lab में चलाएं

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

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

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

Firebase कंसोल का इस्तेमाल शुरू करने के बारे में ज़्यादा जानने के लिए, Firebase कंसोल से टेस्टिंग शुरू करना लेख पढ़ें.

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

अगर आपने पहले से Google Cloud SDK टूल डाउनलोड और इंस्टॉल नहीं किया है, तो ऐसा करें
अपने Google खाते का इस्तेमाल करके gcloud सीएलआई में साइन इन करें:

gcloud auth login
gcloud में अपना Firebase प्रोजेक्ट सेट करें. यहां 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
```
ध्यान दें: इस चरण में, सिर्फ़ एक लूप के बजाय, लूप का सबसेट चलाया जा सकता है. एक साथ कई लूप चलाने के बारे में ज़्यादा जानने के लिए, ज़रूरी नहीं सुविधाएं देखें.

gcloud CLI का इस्तेमाल शुरू करने के बारे में ज़्यादा जानने के लिए, 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 सेक्शन में गेम loop टेस्ट के नतीजे दिखाने के लिए, आउटपुट डेटा फ़ाइलों (नीचे दिए गए उदाहरण की तरह फ़ॉर्मैट की गई) का इस्तेमाल किया जा सकता है. /.../ के तौर पर दिखाए गए एरिया में, आपके ज़रूरत के मुताबिक कस्टम फ़ील्ड हो सकते हैं. हालांकि, यह ज़रूरी है कि वे इस फ़ाइल में इस्तेमाल किए गए अन्य फ़ील्ड के नाम से मेल न खाते हों:

{
  "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 पर क्रैश होता है, तो क्रैश को फिर से चलाने और गड़बड़ी ठीक करने की जांच करने के लिए, सीधे उस गेम loop को लॉन्च किया जा सकता है.

अपने ऐप्लिकेशन को एक साथ कई लूप चलाने की सुविधा देने के लिए:

अगर टेस्ट लूप मैनेजर की मदद से कोई टेस्ट चलाया जा रहा है, तो:
1. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, <application> एलिमेंट के अंदर यह लाइन जोड़ें:
```
<meta-data
  android:name="com.google.test.loops"
  android:value="5" />
```
  इस लॉन्च इंटेंट में, टारगेट लूप को इंटीजर पैरामीटर के तौर पर शामिल किया गया है. android:value फ़ील्ड में, 1 से 1024 के बीच कोई इंटीजर दिया जा सकता है. यह एक टेस्ट के लिए, लूप की ज़्यादा से ज़्यादा संख्या होती है. ध्यान दें कि लूप का इंडेक्स 0 से नहीं, बल्कि 1 से शुरू होता है.
2. Test Loop Manager ऐप्लिकेशन में, एक चुनने वाली स्क्रीन दिखती है. इससे आपको यह चुनने की सुविधा मिलती है कि आपको कौनसे लूप चलाने हैं. एक से ज़्यादा लूप चुनने पर, पिछला लूप पूरा होने के बाद, हर लूप क्रम से लॉन्च होता है.
अगर Firebase कंसोल की मदद से कोई टेस्ट चलाया जा रहा है, तो स्थिति फ़ील्ड में लूप नंबर की सूची या रेंज डालें.
अगर gcloud सीएलआई की मदद से टेस्ट किया जा रहा है, तो --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 वैल्यू के आधार पर, अपने लूप के व्यवहार को बदला जा सकता है.

गेम लूप लेबल करना

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

com.google.test.loops.player_experience: For लूप का इस्तेमाल, गेम खेलते समय उपयोगकर्ता के अनुभव को फिर से बनाने के लिए किया जाता है. इन लूप की मदद से जांच करने का मकसद ऐसी समस्याओं का पता लगाना है जिनका सामना असली उपयोगकर्ता को गेम खेलते समय करना चाहिए.
com.google.test.loops.gpu_compatibility: उन लूप के लिए जिनका इस्तेमाल जीपीयू से जुड़ी समस्याओं की जांच करने के लिए किया जाता है. इन लूप की मदद से टेस्टिंग करने का मकसद, ऐसा GPU कोड चलाना है जो शायद प्रोडक्शन में ठीक से न चल पाए. इससे, हार्डवेयर और ड्राइवर से जुड़ी समस्याओं का पता चलता है.
com.google.test.loops.compatibility: For लूप का इस्तेमाल, कई तरह की संगतता से जुड़ी समस्याओं की जांच करने के लिए किया जाता है. इनमें 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 से 1,024 (किसी एक टेस्ट के लिए ज़्यादा से ज़्यादा लूप की संख्या) के बीच की कोई रेंज या इंटिजर का एक सेट दिया जा सकता है. यह रेंज या सेट, उन लूप को दिखाता है जिन्हें आपको लेबल करना है. ध्यान दें कि लूप का इंडेक्स 0 से नहीं, बल्कि 1 से शुरू होता है. उदाहरण के लिए, android:value="1,3-5", 1, 3, 4, और 5वें लूप पर LABEL_NAME लागू करता है.
2. Test Loop Manager ऐप्लिकेशन में, लेबल फ़ील्ड में एक या उससे ज़्यादा लेबल डालें.
अगर Firebase कंसोल की मदद से कोई टेस्ट चलाया जा रहा है, तो लेबल फ़ील्ड में एक या एक से ज़्यादा लेबल डालें.
अगर gcloud CLI की मदद से कोई टेस्ट चलाया जा रहा है, तो --scenario-labels फ़्लैग का इस्तेमाल करके, एक या उससे ज़्यादा परिस्थिति के लेबल तय करें (उदाहरण के लिए, --scenario-labels=performance,gpu).

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

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

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

Test Lab में गेम लूप टेस्ट से जुड़ी ये समस्याएं पहले से जानी-पहचानी हैं:

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