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

1 परिचय

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

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

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

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

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

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

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

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

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

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

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

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

e791bed0999db1e0.png

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

42c498d28ead2b77.png

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

dda8bdd9488167a0.png

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

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

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

9b58145acc4be030.png

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

aa0d46fc944e0c0b.png

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

3. ऐप चलाएं

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

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

410d8686b4f45c33.png

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

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

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

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

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

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

c20d14b151549937.png

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

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

5. किसी गतिविधि के लोड समय को मापें

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

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

टेस्टएक्टिविटी.जावा

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 onCreate() कॉलबैक के अंत में FirstDrawListener को पंजीकृत करें। आपको onDrawingFinish() कॉलबैक में अपना viewLoadTrace बंद कर देना चाहिए।

टेस्टएक्टिविटी.जावा

    // 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 नाम देंगे।

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

टेस्टफ्रैगमेंट.जावा

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

टेस्टफ्रैगमेंट.जावा

@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. स्क्रीन रेंडरिंग को समझना और स्लो/फ्रोजन फ्रेम क्या है?

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

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

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

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

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

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

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

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

  1. Fragment को होस्ट करने वाली अपनी गतिविधि में ScreenTrace क्लास को इनिशियलाइज़ करें।

मुख्य गतिविधि.जावा

// 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. जब आप अपना Fragment लोड करते हैं, FragmentLifecycleCallbacks के लिए पंजीकरण करें और onFragmentAttached() और onFragmentDetached() कॉलबैक को ओवरराइड करें। हमने आपके लिए यह किया है। आपको onFragmentAttached() कॉलबैक में स्क्रीन ट्रेस रिकॉर्ड करना शुरू करना होगा और onFragmentAttached() कॉलबैक में रिकॉर्डिंग बंद onFragmentDetached()

मुख्य गतिविधि.जावा

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. लॉगकैट में, ट्रेस के लिए विवरण पृष्ठ पर जाने के लिए फायरबेस कंसोल यूआरएल पर क्लिक करें। ceb9d5ba51bb6e89.jpeg

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

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

a0d8455c5269a590.png

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

5e92a307b7410d8b.png

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

ee7890c7e2c28740.png

10. बधाई

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

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

आगे क्या होगा

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

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

बक्शीश

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

11. बोनस सीखना

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

cd61c1495fad7961.png