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

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

पिछली बार अपडेट किए जाने की तारीख: 11-03-2021

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

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

क्या Firebase Performance Monitoring में, ये परफ़ॉर्मेंस मेट्रिक पहले से उपलब्ध नहीं होती हैं?

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

आपको क्या सीखने को मिलेगा

• Android ऐप्लिकेशन में Firebase Performance Monitoring जोड़ने का तरीका
• किसी गतिविधि या फ़्रैगमेंट के लोड होने की प्रोसेस को समझना
• किसी गतिविधि या फ़्रैगमेंट के लोड होने में लगने वाले समय को मेज़र करने के लिए, कस्टम कोड ट्रेस को इंस्ट्रुमेंट करने का तरीका
• स्क्रीन रेंडरिंग के बारे में जानकारी और यह समझना कि धीमा/रुका हुआ फ़्रेम क्या होता है
• स्क्रीन के धीमे चलने/फ़्रीज़ होने की समस्या को रिकॉर्ड करने के लिए, मेट्रिक के साथ कस्टम कोड ट्रेस को इंस्ट्रुमेंट करने का तरीका
• 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 से भी डाउनलोड किया जा सकता है.

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

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

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

1. पक्का करें कि Android Studio और Firebase Assistant के नए वर्शन का इस्तेमाल किया जा रहा हो. इसके लिए, Android Studio/सहायता > अपडेट देखें पर जाएं.
2. Assistant पैनल खोलने के लिए, Tools > Firebase चुनें.
   
3. अपने ऐप्लिकेशन में जोड़ने के लिए, परफ़ॉर्मेंस मॉनिटरिंग चुनें. इसके बाद, परफ़ॉर्मेंस मॉनिटरिंग का इस्तेमाल शुरू करें पर क्लिक करें.
4. नया प्रोजेक्ट बनाने के लिए बटन पर क्लिक करें. इसके बाद, प्रोजेक्ट का नाम डालें. उदाहरण के लिए, Measure Performance Codelab.
5. जारी रखें पर क्लिक करें.
6. अगर आपसे कहा जाए, तो Firebase की शर्तें पढ़ें और स्वीकार करें. इसके बाद, जारी रखें पर क्लिक करें.
7. (ज़रूरी नहीं) Firebase कंसोल में एआई की मदद पाने की सुविधा चालू करें. इसे "Firebase में Gemini" कहा जाता है.
8. इस कोडलैब के लिए, आपको Google Analytics की ज़रूरत नहीं है. इसलिए, Google Analytics के विकल्प को टॉगल करके बंद करें.
9. इसके बाद, आपको एक डायलॉग दिखेगा. इसमें आपको अपने नए Firebase ऐप्लिकेशन को Android Studio प्रोजेक्ट से कनेक्ट करने का विकल्प मिलेगा.
   
10. Android Studio में वापस जाकर, Assistant पैनल में आपको यह पुष्टि दिखेगी कि आपका ऐप्लिकेशन Firebase से कनेक्ट हो गया है.
    

अपने ऐप्लिकेशन में Performance Monitoring SDK जोड़ना

Android Studio में Assistant पैनल में जाकर, Add Performance Monitoring to your app पर क्लिक करें.

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

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

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

Firebase Performance Monitoring के साथ मैन्युअल तरीके से इंटिग्रेट करने का दूसरा तरीका यहां देखा जा सकता है.

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

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

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

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

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

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

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

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

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

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

ऐक्टिविटी की तरह ही, फ़्रैगमेंट के लोड होने में लगने वाले समय को भी इस तरह से तय किया जाता है: जब फ़्रैगमेंट, होस्ट ऐक्टिविटी से अटैच होता है, तब से लेकर जब फ़्रैगमेंट व्यू का पहला फ़्रेम स्क्रीन पर पूरी तरह से दिखता है.

ध्यान दें: ऊपर दिए गए लगभग सभी काम, ऐक्टिविटी और फ़्रैगमेंट, दोनों के लिए Main/UI थ्रेड पर होते हैं. अगर आपने शुरुआत में बहुत ज़्यादा काम किया है और/या आपकी व्यू हैरारकी बहुत जटिल है, तो हो सकता है कि आपके उपयोगकर्ताओं को कुछ समय के लिए खाली स्क्रीन दिखे. इससे उपयोगकर्ता अनुभव खराब हो सकता है.

लोडिंग की परफ़ॉर्मेंस से जुड़ी सामान्य समस्याओं को समझने और उन्हें ठीक करने के लिए, यहां कुछ संसाधन दिए गए हैं:

• ऐप्लिकेशन की रेंडरिंग परफ़ॉर्मेंस
• रेंडरिंग परफ़ॉर्मेंस
• ऐप्लिकेशन लॉन्च होने में लगने वाला समय
• ऐप्लिकेशन लॉन्च होने में लगने वाला समय और गतिविधि बनाने का समय
• लेआउट अमान्य करना, लेआउट, और परफ़ॉर्मेंस

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

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

1. गतिविधि ऑब्जेक्ट के बनते ही, Activity क्लास में कस्टम कोड ट्रेस (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");

    // ...

}

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

    // ...
}

3. हमने FistDrawListener को लागू किया है. इसमें दो कॉलबैक हैं: onDrawingStart() और onDrawingFinish() (FirstDrawListener के बारे में ज़्यादा जानकारी और इसकी परफ़ॉर्मेंस पर असर डालने वाली चीज़ों के बारे में जानने के लिए, नीचे दिया गया अगला सेक्शन देखें). गतिविधि के onCreate()कॉलबैक के आखिर में FirstDrawListener रजिस्टर करें. आपको onDrawingFinish()callback में 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();             
        }         
    });

4. ऐप्लिकेशन को फिर से चलाएं. इसके बाद, logcat को "Logging trace metric" से फ़िल्टर करें. LOAD ACTIVITY बटन पर टैप करें और नीचे दिए गए लॉग देखें:

I/FirebasePerformance: Logging trace metric: TestActivity-LoadTime (duration: XXXms)

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

FirstDrawListener का मकसद

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

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

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

क्रेडिट: हमने इस कोडलैब के इस सेक्शन को लिखने के लिए, इन दो ब्लॉग पोस्ट का इस्तेमाल किया है. इन्हें पियरे-यवेस रिको ने लिखा है:

• Android की ज़रूरी जानकारी - पहली बार दिखने में लगने वाला समय 👩‍🎨
• Android की ज़रूरी जानकारी - पहली बार स्क्रीन पर कॉन्टेंट दिखने में लगने वाला समय 🤽‍♂️

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

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

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

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

TestFragment.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");
   }

2. onViewCreated() कॉलबैक फ़ंक्शन में FirstDrawListener को रजिस्टर करें. इसके बाद, गतिविधि के उदाहरण की तरह ही, onDrawingFinish() में ट्रेस को रोकें.

TestFragment.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();
       }
   });

3. ऐप्लिकेशन को फिर से चलाएं. इसके बाद, logcat को "Logging trace metric" से फ़िल्टर करें. LOAD FRAGMENT बटन पर टैप करें और नीचे दिए गए लॉग देखें:

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

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

ध्यान दें: गतिविधि के उदाहरण के लिए, FirstDrawListener को पास किया गया व्यू, setContentView() तरीके में रेफ़र किया गया व्यू है. हालांकि, फ़्रैगमेंट के उदाहरण के लिए, व्यू वह होता है जिसे onViewCreated() कॉलबैक में रेफ़र किया गया है.

हालांकि, आम तौर पर अटैच किया गया ड्रॉ लिसनर, पूरे व्यू ट्री के लिए ग्लोबल होता है. इसलिए, अटैच किया गया कोई भी व्यू काम करना चाहिए.

7. स्क्रीन रेंडरिंग के बारे में जानकारी और यह समझना कि धीमा/रुका हुआ फ़्रेम क्या होता है

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

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

सलाह: रेंडरिंग की परफ़ॉर्मेंस से जुड़ी कुछ सामान्य समस्याओं को समझने और उन्हें ठीक करने के लिए, रेंडरिंग की परफ़ॉर्मेंस और जंक ठीक करना लेख पढ़ें.

साथ ही, ज़्यादातर नए डिवाइसों में रीफ़्रेश रेट >60 हर्ट्ज़ होता है. इसलिए, हमें हमेशा यह नहीं मान लेना चाहिए कि किसी फ़्रेम को रेंडर करने में 16 मि॰से॰ लगते हैं. ज़्यादा जानकारी के लिए, Android पर ज़्यादा रीफ़्रेश रेट वाली रेंडरिंग देखें.

8. किसी फ़्रैगमेंट के धीमे/रुके हुए फ़्रेम मेज़र करना

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

हमने AppStateMonitor क्लास (यह परफ़ॉर्मेंस मॉनिटरिंग एसडीके का हिस्सा है और ऐक्टिविटी के लिए स्क्रीन ट्रेस रिकॉर्ड करने के लिए ज़िम्मेदार है) से प्रेरणा लेकर, 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);

    // ...
}

2. फ़्रैगमेंट लोड करते समय, 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);
           }
       };

4. ऐप्लिकेशन को फिर से चलाएं. इसके बाद, LOAD FRAGMENT बटन पर टैप करें. कुछ सेकंड इंतज़ार करें. इसके बाद, सबसे नीचे मौजूद नेविगेशन बार में back button पर क्लिक करें.

"Logging trace metric" का इस्तेमाल करके, logcat को फ़िल्टर करें. इसके बाद, नीचे दिए गए लॉग देखें:

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 Performance Monitoring को भेज दिया है. हम इस कोडलैब में बाद में, Firebase कंसोल में रिकॉर्ड की गई मेट्रिक देखेंगे.

9. Firebase कंसोल में मेट्रिक देखना

1. logcat में, Firebase कंसोल के यूआरएल पर क्लिक करके, ट्रेस की जानकारी वाले पेज पर जाएं.

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

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

ध्यान दें: अगर आपको डेटा नहीं दिखता है, तो ऐप्लिकेशन को फिर से लॉन्च करें और इसे कम से कम 30 सेकंड तक चलने दें.

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

3. आपके पास कस्टम स्क्रीन ट्रेस के लिए, परफ़ॉर्मेंस का डेटा देखने का विकल्प भी होता है.

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

10. बधाई

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

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

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

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

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

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

बोनस

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

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

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