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

जब गेमिंग ऐप्लिकेशन अलग-अलग डिवाइसों पर बने होते हैं, तब गेम की टेस्टिंग को ऑटोमेट करना मुश्किल हो सकता है यूज़र इंटरफ़ेस (यूआई) फ़्रेमवर्क. गेम लूप टेस्ट की मदद से, अपने नेटिव टेस्ट को 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
    }

    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
    }

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

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

    Kotlin+KTX

    yourActivity.finish()

    Java

    yourActivity.finish();

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

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

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

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

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

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

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

Test Lab में चलाएं

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

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

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

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

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

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

  2. अपने Google खाते का इस्तेमाल करके, gcloud CLI में साइन इन करें:

    gcloud auth login

  3. gcloud में अपना Firebase प्रोजेक्ट सेट करें. यहां 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}")
    // ...
}

Java

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

अगर आपको अपने गेम ऐप्लिकेशन के 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);

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

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 पर क्रैश हो जाता है, तो सीधे वह गेम लॉन्च किया जा सकता है लूप की मदद से, क्रैश और गड़बड़ी ठीक करने की जाँच करें.

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

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

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

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

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

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

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

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

  • अगर आप C++ लिख रहे हैं और अपने लूप का व्यवहार बदलना चाहते हैं, तो अतिरिक्त अनुसरण करना होगा:

    Kotlin+KTX

    val launchIntent = intent
    val scenario = launchIntent.getIntExtra("scenario", 0)

    Java

    Intent launchIntent = getIntent();
    int scenario = launchIntent.getIntExtra("scenario", 0);

    अब int वैल्यू के आधार पर, अपने लूप के व्यवहार को बदला जा सकता है.

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

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

  • com.google.test.loops.player_experience: For लूप का इस्तेमाल, गेम खेलते समय उपयोगकर्ता के अनुभव को फिर से बनाने के लिए किया जाता है. इसका लक्ष्य इन लूप की जांच करके उन समस्याओं का पता लगाया जा सकता है जिनका सामना उपयोगकर्ता को गेम खेलना.
  • com.google.test.loops.gpu_compatibility: For लूप, जीपीयू से जुड़ी समस्याओं की जांच करने के लिए इस्तेमाल किए जाते हैं. इन लूप के साथ टेस्ट करने का मकसद जीपीयू को एक्ज़ीक्यूट करना है ऐसा कोड जो प्रोडक्शन में ठीक से न चल सके, ताकि हार्डवेयर और ड्राइवर होते हैं.
  • 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 से 1024 तक (किसी एक टेस्ट के लिए, ज़्यादा से ज़्यादा लूप की अनुमति है) उन लूप को प्रस्तुत करें जिन्हें आप लेबल करना चाहते हैं. ध्यान दें कि लूप का इंडेक्स 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 का इस्तेमाल नहीं किया जा सकता.