कॉन्टेंट लोड होने में लगने वाले समय को रिकॉर्ड करने वाले फ़ंक्शन जोड़ें

जब आपका गेम, कॉन्टेंट लोड होने के इवेंट की परफ़ॉर्मेंस दिखा रहा होता है, तब दो वजहों से इसे रिकॉर्ड करना ज़रूरी होता है:

1. लोड करते समय फ़्रेम टाइम के डेटा को प्रदूषण से बचाने के लिए.
2. लोड होने में लगने वाले समय का विश्लेषण करने के लिए, ताकि यह देखा जा सके कि लोड होने में लगने वाला समय कब और कहां से ज़्यादा है स्वीकार किए जाते हैं.

लोड होने वाले किसी इवेंट में, इन चीज़ों से जुड़ा मेटाडेटा हो सकता है:

typedef struct TuningFork_LoadingTimeMetadata {
    enum LoadingState {
        UNKNOWN_STATE = 0,
        // The first time the game is run
        FIRST_RUN = 1,
        // App is not backgrounded
        COLD_START = 2,
        // App is backgrounded
        WARM_START = 3,
        // App is backgrounded, least work needed
        HOT_START = 4,
        // Asset loading between levels
        INTER_LEVEL = 5
    } state;
    enum LoadingSource {
        UNKNOWN_SOURCE = 0,
        // Uncompressing data.
        MEMORY = 1,
        // Reading assets from APK bundle.
        APK = 2,
        // Reading assets from device storage.
        DEVICE_STORAGE = 3,
        // Reading assets from external storage, e.g. SD card.
        EXTERNAL_STORAGE = 4,
        // Loading assets from the network.
        NETWORK = 5,
        // Shader compilation.
        SHADER_COMPILATION = 6,
        // Time spent between process starting and onCreate.
        PRE_ACTIVITY = 7,
        // Total time spent between process starting and first render frame.
        FIRST_TOUCH_TO_FIRST_FRAME = 8
    } source;
    int32_t compression_level;  // 0 = no compression, 100 = max compression
    enum NetworkConnectivity {
        UNKNOWN = 0,
        WIFI = 1,
        CELLULAR_NETWORK = 2
    } network_connectivity;
    uint64_t network_transfer_speed_bps;  // bandwidth in bits per second
    uint64_t network_latency_ns;          // latency in nanoseconds
} TuningFork_LoadingTimeMetadata;

ऐसे फ़ील्ड शून्य हो सकते हैं जो आपकी ज़रूरतों के हिसाब से काम के नहीं हैं.

लोड होने वाले इवेंट में, उससे जुड़ा एनोटेशन भी हो सकता है. इसे इसमें परिभाषित किया गया है फ़्रेम टाइम एनोटेशन की तरह ही, Annotation में एक या उससे ज़्यादा फ़ील्ड का इस्तेमाल करके dev_tuningfork.proto फ़ाइल में मौजूद मैसेज.

TuningFork_ErrorCode TuningFork_startRecordingLoadingTime( const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation, TuningFork_LoadingEventHandle* handle);

यह फ़ंक्शन, दिया गया मेटाडेटा और व्याख्या शामिल करता है और handle को भरता है. TuningFork_stopRecordingLoadingTime() फ़ंक्शन.

TuningFork_ErrorCode TuningFork_stopRecordingLoadingTime( TuningFork_LoadingEventHandle handle);

यह फ़ंक्शन, पहले से शुरू किए गए इवेंट को रिकॉर्ड करना बंद कर देता है TuningFork_startRecordingLoadingTime(). इवेंट अगले दिन अपलोड किया जाता है सेशन फ़्लश.

TuningFork_ErrorCode TuningFork_recordLoadingTime( uint64_t time_ns, const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation);

हमारा सुझाव है कि आप सीधे तौर पर 'शुरू करें' और 'रोकें' फ़ंक्शन का इस्तेमाल करें ऊपर दी गई जानकारी. अगर ऐसा नहीं हो पा रहा है, तो इस फ़ंक्शन को कॉल करें का इस्तेमाल, किसी अवधि और उससे जुड़े मेटाडेटा और जानकारी को रिकॉर्ड करने के लिए किया जाता है.

ग्रुप फ़ंक्शन लोड हो रहे हैं

चेतावनी: कॉन्टेंट लोड होने के सभी इवेंट, लोडिंग ग्रुप का हिस्सा होने चाहिए.

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

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

ध्यान दें: एक समय में सिर्फ़ एक लोडिंग ग्रुप चालू हो सकता है.

TuningFork_ErrorCode TuningFork_startLoadingGroup( const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation, TuningFork_LoadingEventHandle* handle);

यह फ़ंक्शन, दिया गया मेटाडेटा और व्याख्या शामिल करता है और handle को भरता है. TuningFork_stopLoadingGroup() फ़ंक्शन. ये मेटाडेटा और एनोटेशन होते हैं फ़िलहाल, इसका इस्तेमाल Play बैकएंड में नहीं किया जाता. इसलिए, इसे nullptr पर सेट किया जा सकता है. बाद के सभी कॉन्टेंट लोड होने के इवेंट को एक यूनीक ग्रुप आईडी से टैग किया जाएगा.

TuningFork_ErrorCode TuningFork_stopLoadingGroup( TuningFork_LoadingEventHandle handle);

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

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है पहली इमेज. लोड होने वाले ग्रुप का उदाहरण.