फायरबेस परफॉर्मेंस मॉनिटरिंग के साथ लोड समय और स्क्रीन रेंडरिंग को मापें

1 परिचय

अंतिम अद्यतन: 2021-03-11

हमें दृश्यों के प्रदर्शन को मापने की आवश्यकता क्यों है?

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

क्या फायरबेस प्रदर्शन मॉनिटरिंग इन प्रदर्शन मेट्रिक्स को आउट-ऑफ़-द-बॉक्स प्रदान नहीं करता है?

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

आप क्या सीखेंगे

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

आपको किस चीज़ की ज़रूरत पड़ेगी

• एंड्रॉइड स्टूडियो 4.0 या उच्चतर
• एक एंड्रॉइड डिवाइस/एमुलेटर
• जावा संस्करण 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 प्रोजेक्ट को एंड्रॉइड स्टूडियो में आयात करें। आपको संभवतः कुछ संकलन त्रुटियाँ दिखाई देंगी या शायद गुम google-services.json फ़ाइल के बारे में एक चेतावनी दिखाई देगी। हम इस चरण के अगले भाग में इसे ठीक कर देंगे।

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

अपने ऐप को फायरबेस से कनेक्ट करें

1. यह सुनिश्चित करने के लिए कि आप एंड्रॉइड स्टूडियो और फायरबेस असिस्टेंट के नवीनतम संस्करणों का उपयोग कर रहे हैं, एंड्रॉइड स्टूडियो / सहायता > अपडेट की जांच करें पर जाएं।
2. असिस्टेंट फलक खोलने के लिए टूल्स > फायरबेस चुनें।

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

7. एंड्रॉइड स्टूडियो में वापस, सहायक फलक में, आपको यह पुष्टि देखनी चाहिए कि आपका ऐप फायरबेस से जुड़ा है।

अपने ऐप में प्रदर्शन मॉनिटरिंग जोड़ें

एंड्रॉइड स्टूडियो में सहायक फलक में, अपने ऐप में प्रदर्शन मॉनिटरिंग जोड़ें पर क्लिक करें।

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

अंत में, आपको एंड्रॉइड स्टूडियो में सहायक फलक में सफलता संदेश देखना चाहिए कि सभी निर्भरताएँ सही ढंग से सेट की गई हैं।

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

फायरबेस परफॉर्मेंस मॉनिटरिंग के साथ मैन्युअल रूप से एकीकृत करने का दूसरा तरीका यहां पाया जा सकता है।

3. ऐप चलाएं

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

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

इस कोडलैब के निम्नलिखित चरणों में, आप सीखेंगे कि अपनी गतिविधि या फ्रैगमेंट के लोड समय और स्क्रीन रेंडरिंग प्रदर्शन को कैसे मापें।

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

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

किसी गतिविधि की लोडिंग को समझना

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

उच्च स्तर पर, जब आपका ऐप startActivity(Intent) कॉल करता है, तो सिस्टम स्वचालित रूप से निम्नलिखित प्रक्रियाएं निष्पादित करता है। प्रत्येक प्रक्रिया को पूरा होने में समय लगता है, जिससे गतिविधि निर्माण और जब उपयोगकर्ता अपनी स्क्रीन पर गतिविधि के लिए यूआई देखता है, के बीच समय की अवधि बढ़ जाती है।

एक टुकड़े की लोडिंग को समझना

गतिविधि के समान एक फ़्रैगमेंट के लिए लोड समय को उस समय के रूप में परिभाषित किया जाता है जब फ़्रैगमेंट अपनी होस्ट गतिविधि से जुड़ जाता है जब तक कि फ़्रैगमेंट दृश्य के लिए पहला फ़्रेम पूरी तरह से स्क्रीन पर नहीं खींचा जाता है।

ध्यान दें: गतिविधि और फ़्रैगमेंट दोनों के लिए उपरोक्त लगभग सभी कार्य मुख्य/यूआई थ्रेड पर होते हैं और यदि आप आरंभीकरण के दौरान बहुत अधिक काम कर रहे हैं और/या आपका दृश्य पदानुक्रम बहुत जटिल है तो आप अपने उपयोगकर्ताओं को रिक्त स्क्रीन पर फंसे रख सकते हैं कुछ समय के लिए जिससे उपयोगकर्ता अनुभव ख़राब हो सकता है।

सामान्य लोडिंग प्रदर्शन समस्याओं को समझने और ठीक करने में सहायता के लिए नीचे कुछ संसाधन दिए गए हैं:

• ऐप का रेंडरिंग प्रदर्शन
• प्रदर्शन का प्रतिपादन
• ऐप लॉन्च का समय
• ऐप लॉन्च समय और गतिविधि निर्माण
• अमान्यताएं, लेआउट और प्रदर्शन

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

    // ...

}

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() कॉलबैक में अपना 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. ऐप को दोबारा चलाएं. फिर, लॉगकैट को " लॉगिंग ट्रेस मेट्रिक " से फ़िल्टर करें। LOAD ACTIVITY बटन पर टैप करें, और नीचे दिए गए लॉग देखें:

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

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

फर्स्टड्रालिस्टनर का उद्देश्य

उपरोक्त अनुभाग में, हमने एक FirstDrawListener पंजीकृत किया है। FirstDrawListener का उद्देश्य यह मापना है कि पहला फ्रेम कब शुरू हुआ और ड्राइंग कब समाप्त हुई।

यह ViewTreeObserver.OnDrawListener को कार्यान्वित करता है और onDraw() कॉलबैक को ओवरराइड करता है जो तब लागू होता है जब व्यू ट्री खींचा जाने वाला होता है। इसके बाद यह दो उपयोगिता कॉलबैक onDrawingStart() और onDrawingFinish() प्रदान करने के लिए परिणाम को रैप करता है।

FirstDrawListener का पूरा कोड इस कोडलैब के सोर्स कोड में पाया जा सकता है।

श्रेय: हमने कोडलैब के इस अनुभाग को लिखने के लिए निम्नलिखित दो ब्लॉग पोस्ट ( पियरे-यवेस रिकाऊ द्वारा लिखित) का उपयोग किया:

• एंड्रॉइड वाइटल्स - पहला ड्रा समय 👩‍🎨
• एंड्रॉइड वाइटल्स - पहली खींची गई सतह पर बढ़ना 🤽‍♂️

6. एक टुकड़े के लोड समय को मापें

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

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

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

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. FirstDrawListener onViewCreated() कॉलबैक में पंजीकृत करें। फिर, गतिविधि उदाहरण के समान, 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. ऐप को दोबारा चलाएं. फिर, लॉगकैट को " लॉगिंग ट्रेस मेट्रिक " से फ़िल्टर करें। LOAD FRAGMENT बटन पर टैप करें, और नीचे दिए गए लॉग देखें:

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

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

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

हालाँकि, सामान्य तौर पर, चूंकि संलग्न ड्रॉ श्रोता पूरे व्यू ट्री के लिए वैश्विक है, इसलिए किसी भी संलग्न दृश्य को काम करना चाहिए।

7. स्क्रीन रेंडरिंग को समझना और स्लो/फ्रोजन फ्रेम क्या है

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

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

युक्तियाँ: कुछ सामान्य रेंडरिंग प्रदर्शन समस्याओं को समझने और ठीक करने के लिए रेंडरिंग प्रदर्शन और फिक्सिंग जंक्स पर एक नज़र डालें।

इसके अलावा, अधिक आधुनिक उपकरणों में आमतौर पर > 60Hz की ताज़ा दर होती है, इसलिए हमें फ़्रेम रेंडर करने के लिए हमेशा 16ms का अनुमान नहीं लगाना चाहिए। अधिक विवरण के लिए एंड्रॉइड पर उच्च ताज़ा दर रेंडरिंग पर एक नज़र डालें।

8. एक टुकड़े के धीमे/जमे हुए फ्रेम को मापें

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

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

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

इन कस्टम मेट्रिक्स को संलग्न करके, फ्रैगमेंट के लिए स्क्रीन ट्रेस को उसी तरह से संभाला जा सकता है जैसे किसी गतिविधि के लिए स्क्रीन ट्रेस को और फायरबेस कंसोल के प्रदर्शन डैशबोर्ड में अन्य स्क्रीन रेंडरिंग ट्रेस के साथ प्रदर्शित किया जा सकता है।

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

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. जब आप अपना Fragment लोड करते हैं, तो 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 क्लिक करें।

लॉगकैट को " लॉगिंग ट्रेस मेट्रिक " से फ़िल्टर करें, फिर नीचे दिए गए जैसे लॉग देखें:

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

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

9. फायरबेस कंसोल में मेट्रिक्स की जाँच करें

1. लॉगकैट में, ट्रेस के लिए विवरण पृष्ठ पर जाने के लिए फायरबेस कंसोल यूआरएल पर क्लिक करें।

वैकल्पिक रूप से, फायरबेस कंसोल में, उस प्रोजेक्ट का चयन करें जिसमें आपका ऐप है। बाएं पैनल में, रिलीज़ और मॉनिटर अनुभाग ढूंढें, फिर प्रदर्शन पर क्लिक करें।

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

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

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

3. आप अपने कस्टम स्क्रीन ट्रेस के लिए प्रदर्शन डेटा भी देख सकते हैं।

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

10. बधाई हो

बधाई हो! आपने फायरबेस परफॉर्मेंस मॉनिटरिंग का उपयोग करके एक गतिविधि और एक फ्रैगमेंट के लोड समय और स्क्रीन रेंडरिंग प्रदर्शन को सफलतापूर्वक मापा है!

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

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

आगे क्या होगा

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

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

बक्शीश

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

11. बोनस सीखना

किसी गतिविधि की लोडिंग के दौरान क्या हो रहा है, इसे समझने से आपको अपने ऐप की प्रदर्शन विशेषताओं को बेहतर ढंग से समझने में मदद मिलेगी। पिछले चरण में, हमने उच्च स्तर पर वर्णन किया था कि किसी गतिविधि की लोडिंग के दौरान क्या होता है, लेकिन निम्नलिखित आरेख प्रत्येक चरण का बहुत अधिक विस्तार से वर्णन करता है।