फ़्रेम टाइमिंग से जुड़े फ़ंक्शन जोड़ें

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

include/tuningfork/tuningfork.h पर मौजूद हेडर फ़ाइल में मुख्य इंटरफ़ेस होता है ट्यूनिंग फ़ोर्क लाइब्रेरी के लिए उपलब्ध है. पर मौजूद फ़ाइल include/tuningfork/tuningfork_extra.h में यूटिलिटी फ़ंक्शन शामिल हैं.

कई फ़ंक्शन, प्रोटोकॉल बफ़र को क्रम में लगाते हैं. उपयोग करने के बारे में आपके गेम के अंदर प्रोटोकॉल बफ़र, प्रोटोकॉल बफ़र के बारे में जानकारी.

फ़ंक्शन पैरामीटर और रिटर्न वैल्यू के बारे में हेडर में बताया गया है और reference API दस्तावेज़.

Android Performance Tuner के लाइफ़साइकल फ़ंक्शन

ट्यूनिंग फ़ोर्क की लाइफ़साइकल को कंट्रोल करने के लिए, नीचे दिए गए फ़ंक्शन का इस्तेमाल करें इंस्टेंस.

शुरू करें

TFErrorCode TuningFork_init(const TFSettings* settings, JNIEnv* env, jobject context);

स्टार्ट-अप के समय आपको इस फ़ंक्शन को एक बार कॉल करना होगा, आम तौर पर नेटिव कोड से को ऐप्लिकेशन के onCreate() तरीके से लागू किया जाता है. यह एक विज्ञापन समूह के लिए आवश्यक डेटा Fork लाइब्रेरी को ट्यून किया जा रहा है.

आपके पास assets/tuningfork में tuningfork_settings.bin फ़ाइल मौजूद होनी चाहिए इसमें हिस्टोग्राम और एनोटेशन सेटिंग होती हैं. यहां की यात्रा पर हूं टेक्स्ट फ़ाइल को बाइनरी में बदलें, देखें टेक्स्ट बनाम बाइनरी प्रज़ेंटेशन.

settings को भरे जाने वाले फ़ील्ड यह तय करते हैं कि लाइब्रेरी अपने-आप शुरू कैसे होगी.

/**
 * @brief Initialization settings
 *   Zero any values that are not being used.
 */
struct TFSettings {
  /**
   * Cache object to be used for upload data persistence.
   * If unset, data is persisted to /data/local/tmp/tuningfork
   */
  const TFCache* persistent_cache;
  /**
   * The address of the Swappy_injectTracers function.
   * If this is unset, you need to call TuningFork_tick explicitly.
   * If it is set, telemetry for 4 instrument keys is automatically recorded.
   */
  SwappyTracerFn swappy_tracer_fn;
  /**
   * Callback
   * If set, this is called with the fidelity parameters that are downloaded.
   * If unset, you need to call TuningFork_getFidelityParameters explicitly.
   */
  ProtoCallback fidelity_params_callback;
  /**
   * A serialized protobuf containing the fidelity parameters to be uploaded
   *  for training.
   * Set this to nullptr if you are not using training mode. Note that these
   *  are used instead of the default parameters loaded from the APK, if they
   *  are present and there are neither a successful download nor saved parameters.
   */
  const CProtobufSerialization* training_fidelity_params;
  /**
   * A null-terminated UTF-8 string containing the endpoint that Tuning Fork
   * will connect to for parameter, upload, and debug requests. This overrides
   * the value in base_uri in the settings proto and is intended for debugging
   * purposes only.
   */
  const char* endpoint_uri_override;
  /**
   * The version of Swappy that swappy_tracer_fn comes from.
   */
  uint32_t swappy_version;
  /**
   * The number of each metric that is allowed to be allocated at any given
   * time. If any element is zero, the default for that metric type is used.
   * Memory for all metrics is allocated up-front at initialization. When all
   * metrics of a given type are allocated, further requested metrics are not
   * added and data is lost.
   */
  TuningFork_MetricLimits max_num_metrics;
};

अगर आपने Swappy_injectTracer() फ़ंक्शन में पास किया (OpenGL, वल्कन) को इनिशलाइज़ेशन के समय फ़्रेम पेसिंग एपीआई से लिया गया है, ट्यूनिंग फ़ोर्क लाइब्रेरी टिक को साफ़ तौर पर निर्देश दिए बिना, अपने-आप फ़्रेम टाइम रिकॉर्ड कर लेता है उसी तरीके से काम करता है. डेमो ऐप्लिकेशन में ऐसा किया जाता है:

void InitTf(JNIEnv* env, jobject activity) {
   SwappyGL_init(env, activity);
   swappy_enabled = SwappyGL_isEnabled();
   TFSettings settings {};
   if (swappy_enabled) {
       settings.swappy_tracer_fn = &SwappyGL_injectTracer;
       settings.swappy_version = Swappy_version();
   }
...
}

ध्यान दें: आप स्वैपपी के जिस वर्शन का इस्तेमाल कर रहे हैं उसे सेट करना ज़रूरी है TFSettings के swappy_version फ़ील्ड में. इससे पक्का होता है कि TuningFork स्वैपी कॉलबैक से मिलने वाले डेटा को समझने में मदद मिलती है.

नष्ट करें

TFErrorCode TuningFork_destroy();

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

फ़्लश

TFErrorCode TuningFork_flush();

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

फ़िडेलिटी पैरामीटर सेट करें

TFErrorCode TuningFork_setFidelityParameters(const CProtobufSerialization* params);

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

एनोटेशन

TFErrorCode TuningFork_setCurrentAnnotation(const CProtobufSerialization* annotation);

यह फ़ंक्शन, एनोटेशन को बाद वाले टिक के साथ जोड़ने के लिए सेट करता है. यह वापस आ जाता है अगर एनोटेशन को डिकोड करने में कोई गड़बड़ी हुई हो और TFERROR_INVALID_ANNOTATION अगर कोई गड़बड़ी न हो, तो TFERROR_OK.

हर फ़्रेम के फ़ंक्शन

TFErrorCode TuningFork_frameTick(TFInstrumentKey key);

यह फ़ंक्शन दिए गए key के साथ पिछली टिक के बीच के समय को रिकॉर्ड करता है और key और मौजूदा समय से जुड़ा हिस्टोग्राम एनोटेशन.

TFErrorCode TuningFork_frameDeltaTimeNanos(TFInstrumentKey key, TFDuration dt);

यह फ़ंक्शन, key और मौजूदा एनोटेशन.

TFErrorCode TuningFork_startTrace(TFInstrumentKey key, TraceHandle* handle);

यह फ़ंक्शन दिए गए key से जुड़े ट्रेस हैंडल पर एक हैंडल सेट करता है.

TFErrorCode TuningFork_endTrace(TraceHandle handle);

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

ऐप्लिकेशन के लाइफ़साइकल फ़ंक्शन

typedef enum TuningFork_LifecycleState {
    TUNINGFORK_STATE_UNINITIALIZED = 0,
    TUNINGFORK_STATE_ONCREATE = 1,
    TUNINGFORK_STATE_ONSTART = 2,
    TUNINGFORK_STATE_ONSTOP = 3,
    TUNINGFORK_STATE_ONDESTROY = 4,
} TuningFork_LifecycleState;

TFErrorCode TuningFork_reportLifecycleEvent(TuningForkLifecycleState state);

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

उन्‍नत फ़ंक्‍शन

tuningfork_extra.h में ये फ़ंक्शन उपलब्ध हैं.

APK में फ़ाइलें ढूंढना और लोड करना

TFErrorCode TuningFork_findFidelityParamsInApk(JNIEnv* env, jobject context, const char* filename, CProtobufSerialization* fidelityParams);

यह फ़ंक्शन, यहां मौजूद assets/tuningfork डायरेक्ट्री से fidelityParams को लोड करता है दिए गए फ़ाइल नाम वाला APK. fidelityParams का सीरियल नंबर होना चाहिए FidelityParams मैसेज. ज़्यादा जानकारी के लिए, यह देखें क्वालिटी के लेवल तय करें.

क्रम से लगाने की सुविधा का मालिकाना हक, कॉलर को दिया जाता है, जिसे कॉल करना होगा होल्ड पर रखी गई किसी भी मेमोरी को हटाने के लिए CProtobufSerialization_Free.

फ़िडेलिटी के पैरामीटर को किसी अलग थ्रेड में डाउनलोड करें

void TuningFork_startFidelityParamDownloadThread(const CProtobufSerialization* defaultParams, ProtoCallback fidelity_params_callback);

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

डिवाइस पर सेव किए गए फ़िडेलिटी पैरामीटर को सेव करें और मिटाएं

TFErrorCode TuningFork_saveOrDeleteFidelityParamsFile(JNIEnv* env, jobject context, const CProtobufSerialization* fidelity_params);

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

वेब अनुरोध

लाइब्रेरी, सर्वर एंडपॉइंट को इस तरह के अनुरोध करती है:

• generateTuningParameters का अनुरोध शुरू करते समय किया जाता है.
• गेमप्ले के दौरान, भेजने के लिए समय-समय पर uploadTelemetry का अनुरोध किया जाता है सर्वर को डेटा भेजना है.
• डीबग APK, debugInfo अनुरोध भी भेज सकते हैं, जिससे डीबग सर्वर को जानकारी मिलती है सेटिंग, डिफ़ॉल्ट फ़िडेलिटी पैरामीटर, और dev_tuningfork.proto स्ट्रक्चर.

ऑफ़लाइन खिलाड़ी

अगर शुरू करते समय कोई कनेक्शन उपलब्ध नहीं है, तो अनुरोध फिर से करने की कोशिश की जाती है ऐसा कई बार किया जाता है.

अगर अपलोड करते समय कोई कनेक्शन नहीं है, तो अपलोड को कैश मेमोरी में सेव किया जाता है. आप अपने अपने कैश मेमोरी में सेव करने की प्रोसेस, TFCache ऑब्जेक्ट को ज़रूरत के हिसाब से इस्तेमाल करते हैं. अगर आपने कैश मेमोरी की जानकारी नहीं दी है, तो कुछ समय के लिए सेव किए गए स्टोरेज में फ़ाइलों के तौर पर सेव होती है.