Firebase प्रदर्शन मॉनिटर करने की सुविधा की मदद से, लोड होने में लगने वाले समय और स्क्रीन रेंडरिंग का आकलन करें

1. शुरुआती जानकारी

पिछली बार अपडेट किया गया: 2021-03-11

व्यू की परफ़ॉर्मेंस का आकलन करना क्यों ज़रूरी है?

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

क्या Firebase की परफ़ॉर्मेंस मॉनिटर करने से, अलग-अलग तरह की परफ़ॉर्मेंस मेट्रिक उपलब्ध नहीं कराई जाती?

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

आपको इनके बारे में जानकारी मिलेगी

  • किसी Android ऐप्लिकेशन में, Firebase की परफ़ॉर्मेंस मॉनिटर करने की सुविधा को जोड़ने का तरीका
  • किसी गतिविधि या फ़्रैगमेंट के लोड होने को समझना
  • किसी ऐक्टिविटी या फ़्रैगमेंट के लोड होने में लगने वाले समय को मापने के लिए, कस्टम कोड ट्रेस बनाने का तरीका
  • स्क्रीन रेंडरिंग के बारे में जानकारी और धीमे/फ़्रोज़न फ़्रेम के बारे में जानकारी
  • धीमी या फ़्रीज़ की गई स्क्रीन को रिकॉर्ड करने के लिए, मेट्रिक की मदद से कस्टम कोड ट्रेस बनाने का तरीका
  • Firebase कंसोल में, इकट्ठा की गई मेट्रिक को देखने का तरीका

आपको इन चीज़ों की ज़रूरत होगी

  • Android Studio 4.0 या इसके बाद वाला वर्शन
  • Android डिवाइस/एम्युलेटर
  • Java वर्शन 8 या इससे नया वर्शन

2. सेट अप किया जा रहा है

कोड पाएं

इस कोडलैब के सैंपल कोड का क्लोन बनाने के लिए, नीचे दिए गए निर्देशों का पालन करें. इससे आपकी मशीन पर codelab-measure-android-view-performance नाम का फ़ोल्डर बन जाएगा:

$ git clone https://github.com/FirebaseExtended/codelab-measure-android-view-performance.git
$ cd codelab-measure-android-view-performance

अगर आपकी मशीन पर git नहीं है, तो सीधे GitHub से भी कोड डाउनलोड किया जा सकता है.

Android Studio में measure-view-performance-start प्रोजेक्ट इंपोर्ट करें. आपको कंपाइलेशन से जुड़ी कुछ गड़बड़ियां दिख सकती हैं. इसके अलावा, छूटी हुई google-services.json फ़ाइल के बारे में चेतावनी भी दिख सकती है. इस चरण के अगले सेक्शन में, हम इसे ठीक कर देंगे.

इस कोडलैब में, हम अपने Android ऐप्लिकेशन को Firebase प्रोजेक्ट के साथ रजिस्टर करने के लिए, Firebase Assistant प्लगिन का इस्तेमाल करेंगे. साथ ही, अपने Android प्रोजेक्ट में ज़रूरी Firebase कॉन्फ़िगरेशन फ़ाइलें, प्लगिन, और डिपेंडेंसी जोड़ेंगे — ये सभी काम Android Studio में किए जा सकेंगे!

अपने ऐप्लिकेशन को Firebase से कनेक्ट करें

  1. Android Studio/सहायता > अपडेट देखें और पक्का करें कि आप Android Studio और Firebase Assistant के नए वर्शन का इस्तेमाल कर रहे हैं.
  2. टूल चुनें > Assistant पैनल खोलने के लिए, Firebase.

e791bed0999db1e0.png

  1. अपने ऐप्लिकेशन में जोड़ने के लिए, परफ़ॉर्मेंस मॉनिटरिंग चुनें. इसके बाद, परफ़ॉर्मेंस मॉनिटरिंग से शुरू करें पर क्लिक करें.
  2. अपने Android प्रोजेक्ट को Firebase से कनेक्ट करने के लिए, Firebase से कनेक्ट करें पर क्लिक करें (इससे आपके ब्राउज़र में Firebase कंसोल खुल जाएगा).
  3. Firebase कंसोल में, प्रोजेक्ट जोड़ें पर क्लिक करें. इसके बाद, Firebase प्रोजेक्ट का नाम डालें (अगर आपके पास पहले से कोई Firebase प्रोजेक्ट है, तो आपके पास उस मौजूदा प्रोजेक्ट को चुनने का विकल्प है). Firebase प्रोजेक्ट और नया Firebase ऐप्लिकेशन बनाने के लिए, जारी रखें पर क्लिक करें और शर्तों को स्वीकार करें.
  4. इसके बाद, आपको अपने नए Firebase ऐप्लिकेशन को Android Studio प्रोजेक्ट से कनेक्ट करने के लिए एक डायलॉग बॉक्स दिखेगा.

42c498d28ead2b77.png

  1. Android Studio के Assistant पैनल में, आपको यह पुष्टि करने वाली सूचना दिखेगी कि आपका ऐप्लिकेशन Firebase से कनेक्ट हो गया है.

dda8bdd9488167a0.png

अपने ऐप्लिकेशन में परफ़ॉर्मेंस मॉनिटर करने की सुविधा जोड़ें

Android Studio में Assistant पैनल में जाकर, अपने ऐप्लिकेशन में परफ़ॉर्मेंस मॉनिटर करने की सुविधा जोड़ें पर क्लिक करें.

आपको बदलावों को स्वीकार करें के लिए एक डायलॉग दिखेगा. इसके बाद, Android Studio आपके ऐप्लिकेशन को सिंक कर देगा, ताकि यह पक्का किया जा सके कि सभी ज़रूरी डिपेंडेंसी जोड़ दी गई हैं.

9b58145acc4be030.png

आखिर में, आपको Android Studio के Assistant पैनल में सफलता का मैसेज दिखेगा कि सभी डिपेंडेंसी सही तरीके से सेट अप की गई हैं.

aa0d46fc944e0c0b.png

"(ज़रूरी नहीं) डीबग लॉगिंग चालू करें" चरण में दिए गए निर्देशों का पालन करके डीबग लॉगिंग चालू करें. ये निर्देश सार्वजनिक दस्तावेज़ में भी उपलब्ध हैं.

3. ऐप्लिकेशन चलाएं

अगर आपने अपने ऐप्लिकेशन को परफ़ॉर्मेंस मॉनिटर करने वाले SDK टूल के साथ इंटिग्रेट कर लिया है, तो प्रोजेक्ट अब कंपाइल हो जाना चाहिए. Android Studio में, Run पर क्लिक करें > अपने कनेक्ट किए गए Android डिवाइस/एम्युलेटर पर ऐप्लिकेशन बनाने और चलाने के लिए ‘ऐप्लिकेशन' चलाएं.

ऐप्लिकेशन में दो बटन होते हैं, जो आपको संबंधित ऐक्टिविटी और फ़्रैगमेंट पर ले जाते हैं, जैसे कि:

410d8686b4f45c33.png

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

4. किसी ऐक्टिविटी या फ़्रैगमेंट के लोड होने की जानकारी

इस चरण में हम जानेंगे कि किसी ऐक्टिविटी या फ़्रैगमेंट को लोड करने के दौरान, सिस्टम क्या कर रहा है.

किसी गतिविधि के लोड होने की वजह समझना

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

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

c20d14b151549937.png

फ़्रैगमेंट के लोड होने की जानकारी

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

5. किसी गतिविधि के लोड होने में लगने वाले समय का आकलन करें

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

  1. ऐक्टिविटी ऑब्जेक्ट बनाते ही, गतिविधि क्लास में कस्टम कोड ट्रेस (TestActivity-LoadTime नाम से) शुरू करें.

TestActivity.java

public class TestActivity extends AppCompatActivity {   
    // TODO (1): Start trace recording as soon as the Activity object is created.
    private final Trace viewLoadTrace = FirebasePerformance.startTrace("TestActivity-LoadTime");

    // ...

}
  1. onCreate()कॉलबैक को बदलें और setContentView()तरीका की मदद से व्यू जोड़ें.
@Override     
public void onCreate(Bundle savedInstanceState) {    
    super.onCreate(savedInstanceState);          

    // Current Activity's main View (as defined in the layout xml file) is inflated after this            
    setContentView(R.layout.activity_test);          

    // ...

    // TODO (2): Get the View added by Activity's setContentView() method.         
    View mainView = findViewById(android.R.id.content);     

    // ...
}
  1. हमने FistDrawListener को लागू करने की प्रोसेस शामिल की है, जिसमें दो कॉलबैक हैं: onDrawingStart() और onDrawingFinish() (FirstDrawListener और इसकी परफ़ॉर्मेंस पर किन चीज़ों का असर पड़ सकता है, इस बारे में ज़्यादा जानकारी के लिए नीचे दिया गया अगला सेक्शन देखें). ऐक्टिविटी के onCreate()कॉलबैक के खत्म होने पर, FirstDrawListener को रजिस्टर करें. onDrawingFinish()कॉलबैक के दौरान, आपका viewLoadTrace बंद हो जाना चाहिए.

TestActivity.java

    // TODO (3): Register the callback to listen for first frame rendering (see
    //  "OnFirstDrawCallback" in FirstDrawListener) and stop the trace when View drawing is
    //  finished.
    FirstDrawListener.registerFirstDrawListener(mainView, new FirstDrawListener.OnFirstDrawCallback() {              
        @Override             
        public void onDrawingStart() {       
          // In practice you can also record this event separately
        }

        @Override             
        public void onDrawingFinish() {
            // This is when the Activity UI is completely drawn on the screen
            viewLoadTrace.stop();             
        }         
    });
  1. ऐप्लिकेशन को फिर से चलाएं. इसके बाद, लॉगकैट को "लॉगिंग ट्रेस मेट्रिक" से फ़िल्टर करें. LOAD ACTIVITY बटन पर टैप करें और इस तरह के लॉग देखें:
I/FirebasePerformance: Logging trace metric: TestActivity-LoadTime (duration: XXXms)

🎉 बधाई हो! आपने किसी गतिविधि के लोड होने में लगने वाले समय को मेज़र कर लिया है और Firebase की परफ़ॉर्मेंस मॉनिटर करने की सुविधा को उस डेटा की शिकायत की है. हम रिकॉर्ड की गई मेट्रिक को बाद में इस कोडलैब में Firebase कंसोल में देखेंगे.

FirstDrawListener का मकसद

ठीक ऊपर दिए गए सेक्शन में, हमने एक FirstDrawListener रजिस्टर किया है. FirstDrawListener का मकसद यह मेज़र करना है कि पहला फ़्रेम कब शुरू हुआ और कब खत्म हुआ.

यह ViewTreeObserver.OnDrawListener को लागू करता है. साथ ही, व्यू ट्री को ड्रॉ करने के समय शुरू होने वाले onDraw() कॉलबैक को बदल देता है. इसके बाद, यह नतीजे को रैप करके दो यूटिलिटी कॉलबैक onDrawingStart()और onDrawingFinish() देता है.

FirstDrawListener का पूरा कोड, इस कोडलैब के सोर्स कोड में देखा जा सकता है.

6. किसी फ़्रैगमेंट के लोड होने में लगने वाले समय को मेज़र करना

फ़्रैगमेंट के लोड होने में लगने वाले समय को मेज़र करना उसी तरह से होता है जैसे हम किसी गतिविधि के लिए, इसे मेज़र करते हैं. हालांकि, इसमें कुछ मामूली अंतर होते हैं. हम एक कस्टम कोड ट्रेस भी बनाएंगे:

  1. onAttach() कॉलबैक को बदलें और fragmentLoadTrace रिकॉर्ड करना शुरू करें. हम इस ट्रेस को Test-Fragment-LoadTime नाम देंगे.

जैसा कि पहले चरण में बताया गया था, फ़्रैगमेंट ऑब्जेक्ट किसी भी समय बनाया जा सकता है, लेकिन यह सिर्फ़ तब चालू होता है, जब यह अपनी होस्ट गतिविधि से अटैच होता है.

Testफ़्रैगमेंट.java

public class TestFragment extends Fragment {

   // TODO (1): Declare the Trace variable.
   private Trace fragmentLoadTrace;

   @Override
   public void onAttach(@NonNull Context context) {
       super.onAttach(context);

       // TODO (2): Start trace recording as soon as the Fragment is attached to its host Activity.
       fragmentLoadTrace = FirebasePerformance.startTrace("TestFragment-LoadTime");
   }
  1. onViewCreated()कॉलबैक में FirstDrawListener को रजिस्टर करें. इसके बाद, गतिविधि के उदाहरण की तरह ही, onDrawingFinish() में ट्रेस को रोकें.

Testफ़्रैगमेंट.java

@Override
public void onViewCreated(@NonNull View mainView, Bundle savedInstanceState) {
   super.onViewCreated(mainView, savedInstanceState);

   // ...

   // TODO (3): Register the callback to listen for first frame rendering (see
   //  "OnFirstDrawCallback" in FirstDrawListener) and stop the trace when view drawing is
   //  finished.
   FirstDrawListener.registerFirstDrawListener(mainView, new FirstDrawListener.OnFirstDrawCallback() {

       @Override
       public void onDrawingStart() {
           // In practice you can also record this event separately
       }

       @Override
       public void onDrawingFinish() {
           // This is when the Fragment UI is completely drawn on the screen
           fragmentLoadTrace.stop();
       }
   });
  1. ऐप्लिकेशन को फिर से चलाएं. इसके बाद, लॉगकैट को "लॉगिंग ट्रेस मेट्रिक" से फ़िल्टर करें. LOAD FRAGMENT बटन पर टैप करें और इस तरह के लॉग देखें:
I/FirebasePerformance: Logging trace metric: TestFragment-LoadTime (duration: XXXms)

🎉 बधाई हो! आपने किसी फ़्रैगमेंट के लोड होने में लगने वाले समय को मेज़र कर लिया है और Firebase की परफ़ॉर्मेंस मॉनिटर करने की सुविधा को डेटा की रिपोर्ट की है. हम रिकॉर्ड की गई मेट्रिक को बाद में इस कोडलैब में Firebase कंसोल में देखेंगे.

7. स्क्रीन रेंडरिंग के बारे में जानकारी और धीमे/फ़्रोज़न फ़्रेम के बारे में जानकारी

यूज़र इंटरफ़ेस (यूआई) रेंडरिंग की मदद से, ऐप्लिकेशन से फ़्रेम जनरेट किया जाता है और उसे स्क्रीन पर दिखाया जाता है. यह पक्का करने के लिए कि आपके ऐप्लिकेशन के साथ उपयोगकर्ता का इंटरैक्शन आसान है, आपके ऐप्लिकेशन को 16 मि॰से॰ से कम समय में फ़्रेम रेंडर होने चाहिए, ताकि हर सेकंड 60 फ़्रेम प्रति सेकंड हासिल किए जा सकें ( 60fps ही क्यों?. अगर आपके ऐप्लिकेशन को धीमे यूज़र इंटरफ़ेस (यूआई) रेंडरिंग की समस्या है, तो सिस्टम को फ़्रेम स्किप करने के लिए मजबूर होना पड़ता है. इसके बाद, उपयोगकर्ता को आपके ऐप्लिकेशन में हकलाहट महसूस होगी. हम इसे जैंक कहते हैं.

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

8. किसी फ़्रैगमेंट के रेंडर होने में ज़्यादा समय लेने वाले/फ़्रोज़न फ़्रेम मेज़र करना

Firebase परफ़ॉर्मेंस मॉनिटर करने की सुविधा, किसी गतिविधि के लिए रेंडर होने में ज़्यादा समय लेने वाले/फ़्रोज़न फ़्रेम को अपने-आप कैप्चर करती है. हालांकि, ऐसा सिर्फ़ तब होता है, जब यह हार्डवेयर की मदद से तेज़ी से काम करता हो. हालांकि, फ़िलहाल यह सुविधा फ़्रैगमेंट के लिए उपलब्ध नहीं है. फ़्रैगमेंट के लाइफ़साइकल में, धीमे या फ़्रीज़ किए गए फ़्रेम को onFragmentAttached() और onFragmentDetached() कॉलबैक के बीच पूरी गतिविधि के लिए, धीमे/फ़्रीज़ किए गए फ़्रेम के तौर पर परिभाषित किया जाता है.

हमने AppStateMonitor क्लास (जो गतिविधि के लिए स्क्रीन ट्रेस रिकॉर्ड करने के लिए ज़िम्मेदार परफ़ॉर्मेंस मॉनिटरिंग SDK टूल का हिस्सा है) की मदद से, ScreenTrace क्लास (जो कोडलैब सोर्स कोड रेपो का हिस्सा है) लागू की. धीमे/फ़्रोज़न फ़्रेम को कैप्चर करने के लिए, ScreenTrace क्लास को ऐक्टिविटी के FragmentManager के लाइफ़साइकल कॉलबैक से जोड़ा जा सकता है. यह क्लास दो सार्वजनिक एपीआई उपलब्ध कराती है:

  • recordScreenTrace(): स्क्रीन ट्रेस रिकॉर्ड करना शुरू करता है
  • sendScreenTrace(): इससे स्क्रीन ट्रेस की रिकॉर्डिंग बंद हो जाती है और कुल, धीमे, और फ़्रोज़न फ़्रेम की संख्या को लॉग करने के लिए कस्टम मेट्रिक जुड़ जाती है

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

आपके फ़्रैगमेंट के लिए, स्क्रीन ट्रेस लॉग करने का तरीका यहां बताया गया है:

  1. अपनी ऐक्टिविटी में फ़्रैगमेंट को होस्ट करने वाली ScreenTrace क्लास शुरू करें.

MainActivity.java

// Declare the Fragment tag
private static final String FRAGMENT_TAG = TestFragment.class.getSimpleName();

// TODO (1): Declare the ScreenTrace variable.
private ScreenTrace screenTrace;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // TODO (2): Initialize the ScreenTrace variable.
    screenTrace = new ScreenTrace(this, FRAGMENT_TAG);

    // ...
}
  1. अपना फ़्रैगमेंट लोड करने पर, FragmentLifecycleCallbacks के लिए रजिस्टर करें और onFragmentAttached() और onFragmentDetached()कॉलबैक बदलें. हमने आपके लिए यह किया है. आपको onFragmentAttached() कॉलबैक में, स्क्रीन ट्रेस रिकॉर्ड करना शुरू करना होगा और onFragmentDetached() कॉलबैक में रिकॉर्डिंग बंद करनी होगी.

MainActivity.java

private final FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks =
       new FragmentManager.FragmentLifecycleCallbacks() {

           @Override
           public void onFragmentAttached(@NonNull FragmentManager fm, @NonNull Fragment f, @NonNull Context context) {
               super.onFragmentAttached(fm, f, context);

               // TODO (3): Start recording the screen traces as soon as the Fragment is
               //  attached to its host Activity.
               if (FRAGMENT_TAG.equals(f.getTag()) && screenTrace.isScreenTraceSupported()) {
                   screenTrace.recordScreenTrace();
               }
           }

           @Override
           public void onFragmentDetached(@NonNull FragmentManager fm, @NonNull Fragment f) {
               super.onFragmentDetached(fm, f);

               // TODO (4): Stop recording the screen traces as soon as the Fragment is
               //  detached from its host Activity.
               if (FRAGMENT_TAG.equals(f.getTag()) && screenTrace.isScreenTraceSupported()) {
                   screenTrace.sendScreenTrace();
               }

               // Unregister Fragment lifecycle callbacks after the Fragment is detached
               fm.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks);
           }
       };
  1. ऐप्लिकेशन को फिर से चलाएं. इसके बाद, LOAD FRAGMENT बटन पर टैप करें. कुछ सेकंड इंतज़ार करें. इसके बाद, नीचे मौजूद नेविगेशन बार में मौजूद back button पर क्लिक करें.

लॉगकैट को "लॉगिंग ट्रेस मेट्रिक" से फ़िल्टर करें. इसके बाद, इस तरह के लॉग देखें:

I/FirebasePerformance: Logging trace metric: _st_MainActivity-TestFragment (duration: XXXms)

लॉगकैट को "FireperfViews" से फ़िल्टर करें. इसके बाद, इस तरह के लॉग देखें:

D/FireperfViews: sendScreenTrace MainActivity-TestFragment, name: _st_MainActivity-TestFragment, total_frames: XX, slow_frames: XX, frozen_frames: XX

🎉 बधाई हो! आपने किसी फ़्रैगमेंट के लिए, धीमे/फ़्रोज़न फ़्रेम को मेज़र कर लिया है और उस डेटा को Firebase की परफ़ॉर्मेंस मॉनिटर करने की सुविधा को रिपोर्ट कर दिया है. हम रिकॉर्ड की गई मेट्रिक को बाद में इस कोडलैब में, Firebase कंसोल में देखेंगे.

9. Firebase कंसोल में मेट्रिक की जांच करना

  1. लॉगकैट में, ट्रेस के बारे में ज़्यादा जानकारी वाले पेज पर जाने के लिए 'Firebase कंसोल' के यूआरएल पर क्लिक करें. ceb9d5ba51bb6e89.jpeg अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

इसके अलावा, Firebase कंसोल में जाकर, वह प्रोजेक्ट चुनें जिसमें आपका ऐप्लिकेशन मौजूद है. बाएं पैनल में, रिलीज़ और मॉनिटर करें सेक्शन में जाकर, परफ़ॉर्मेंस पर क्लिक करें.

  • मुख्य डैशबोर्ड टैब में, नीचे ट्रेस टेबल तक स्क्रोल करें. इसके बाद, कस्टम ट्रेस टैब पर क्लिक करें. इस टेबल में, आपको वे कस्टम कोड ट्रेस दिखेंगे जिन्हें हमने पहले जोड़ा था. साथ ही, आपको कुछ आउट-ऑफ़-द-बॉक्स ट्रेस जैसे _app_start ट्रेस भी दिखेंगे.
  • अपने दो कस्टम कोड ट्रेस ढूंढें, TestActivity-LoadTime और TestFragment-LoadTime. इकट्ठा किए गए डेटा के बारे में ज़्यादा जानकारी देखने के लिए, किसी एक कैंपेन की अवधि पर क्लिक करें.

a0d8455c5269a590.png

  1. कस्टम कोड ट्रेस का ज़्यादा जानकारी वाला पेज आपको ट्रेस की अवधि (यानी, मेज़र किया गया लोड समय) के बारे में जानकारी दिखाता है.

5e92a307b7410d8b.png

  1. अपने कस्टम स्क्रीन ट्रेस का परफ़ॉर्मेंस डेटा भी देखा जा सकता है.
  • मुख्य डैशबोर्ड टैब पर वापस जाएं, नीचे की ओर स्क्रोल करके ट्रेस टेबल पर जाएं. इसके बाद, स्क्रीन रेंडरिंग टैब पर क्लिक करें. इस टेबल में, आपको वे कस्टम स्क्रीन ट्रेस दिखेंगे जिन्हें हमने पहले जोड़ा था. साथ ही, स्क्रीन के अलग-अलग तरह के ट्रेस, जैसे कि MainActivity ट्रेस भी दिखेंगे.
  • अपना कस्टम स्क्रीन ट्रेस ढूंढें, MainActivity-TestFragment. धीमे रेंडर होने वाले और रुके हुए फ़्रेम का इकट्ठा किया गया डेटा देखने के लिए, ट्रेस के नाम पर क्लिक करें.

ee7890c7e2c28740.png

10. बधाई

बधाई हो! आपने Firebase परफ़ॉर्मेंस मॉनिटर करने की सुविधा का इस्तेमाल करके, किसी ऐक्टिविटी और फ़्रैगमेंट के लोड होने में लगने वाले समय और स्क्रीन रेंडरिंग की परफ़ॉर्मेंस को मेज़र कर लिया है!

आपने क्या हासिल किया

  • आपने सैंपल ऐप्लिकेशन में Firebase परफ़ॉर्मेंस मॉनिटरिंग को इंटिग्रेट किया है
  • अब आपको व्यू लोड होने की अवधि के बारे में जानकारी मिल गई है
  • आपने कस्टम कोड ट्रेस जोड़कर किसी ऐक्टिविटी और फ़्रैगमेंट, दोनों के लोड होने में लगने वाले समय को मेज़र किया है
  • आपने कस्टम मेट्रिक की मदद से कस्टम स्क्रीन ट्रेस जोड़कर, रेंडर होने में ज़्यादा समय लेने वाले/फ़्रोज़न फ़्रेम रिकॉर्ड किए

आगे क्या करना है

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

इसके अलावा, Firebase परफ़ॉर्मेंस में एचटीटीपी/एस नेटवर्क अनुरोध को अपने-आप मॉनिटर करने की सुविधा भी मौजूद है. इससे, एक लाइन में कोड लिखे बिना ही नेटवर्क अनुरोधों को आसानी से पूरा किया जा सकता है. क्या आप अपने ऐप्लिकेशन से कुछ नेटवर्क अनुरोध भेजने और Firebase कंसोल में मेट्रिक ढूंढने की कोशिश कर सकते हैं?

बोनस

अब आपको पता है कि कस्टम कोड ट्रेस का इस्तेमाल करके अपनी ऐक्टिविटी/फ़्रैगमेंट के लोड होने में लगने वाले समय और स्क्रीन रेंडरिंग की परफ़ॉर्मेंस को कैसे मापा जाता है, तो क्या आपके पास हमारे ओपन सोर्स कोड बेस के बारे में जानने का विकल्प है. इससे यह पता चल सकेगा कि उन मेट्रिक को किसी ऐसी गतिविधि/फ़्रैगमेंट के लिए रिकॉर्ड किया जा सकता है या नहीं जो ऐप्लिकेशन का हिस्सा है? अगर आप चाहें, तो पीआर को बेझिझक भेजें :-)

11. बोनस लर्निंग

किसी गतिविधि के लोड होने के दौरान क्या हो रहा है, यह समझने से आपको अपने ऐप्लिकेशन की परफ़ॉर्मेंस की विशेषताओं को समझने में मदद मिलेगी. पहले के चरण में, हमने हाई लेवल पर बताया था कि गतिविधि लोड होने के दौरान क्या होता है. हालांकि, नीचे दिए गए डायग्राम में हर चरण के बारे में ज़्यादा जानकारी दी गई है.

cd61c1495fad7961.png