ऐप्लिकेशन के शुरू होने का विश्लेषण और ऑप्टिमाइज़ेशन

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

हमारा सुझाव है कि आप मैक्रोबेंचमार्क लाइब्रेरी का इस्तेमाल करके, स्टार्टअप. इस लाइब्रेरी में खास जानकारी और सिस्टम की पूरी जानकारी शामिल होती है, ताकि आप स्टार्टअप के दौरान क्या होता है.

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

अपने ऐप्लिकेशन के स्टार्टअप का विश्लेषण करने के लिए, यह तरीका अपनाएं:

स्टार्टअप का विश्लेषण करने और उसे ऑप्टिमाइज़ करने का तरीका

ऐप्लिकेशन खुलने के दौरान अक्सर ऐसे खास संसाधन लोड करने पड़ते हैं जो हर किसी के लिए, असली उपयोगकर्ता. गै़र-ज़रूरी संसाधन, स्टार्टअप के बाद लोड होने का इंतज़ार कर सकते हैं पूरा करता है.

परफ़ॉर्मेंस खराब करने के लिए, इन बातों का ध्यान रखें:

  • हर ऑपरेशन में लगने वाले समय को मापने के लिए, मैक्रोबेंचमार्क लाइब्रेरी का इस्तेमाल करें. और उन ब्लॉक की पहचान करें जिन्हें पूरा होने में ज़्यादा समय लगता है.

  • पुष्टि करें कि ऐप्लिकेशन को चालू करने के लिए, ज़्यादा संसाधन इस्तेमाल करना ज़रूरी है. अगर आपने ऐप के पूरी तरह से तैयार होने तक कार्रवाई की जा सकती है, लेकिन इससे ऐप स्टार्टअप पर संसाधन सीमाएं.

  • पक्का करें कि ऐप्लिकेशन शुरू होने पर यह कार्रवाई की जाए. अक्सर, लेगसी कोड या तीसरे पक्ष की ऐसी कार्रवाइयों को कॉल किया जा सकता है जिनकी ज़रूरत नहीं है लाइब्रेरी.

  • अगर हो सके, तो लंबे समय से चल रही कार्रवाइयों को बैकग्राउंड में ले जाएं. बैकग्राउंड प्रोसेस के चालू होने पर भी, सीपीयू के इस्तेमाल पर असर पड़ सकता है.

ऑपरेशन की पूरी जांच करने के बाद, आप समझौते में बदलाव करने का फ़ैसला ले सकते हैं कॉन्टेंट लोड होने में लगने वाले समय और ऐप्लिकेशन में इसे शामिल करने की ज़रूरत के बीच का समय शुरू करें. रिग्रेशन या नुकसान पहुंचा सकने वाले बदलावों को शामिल करना न भूलें आपके ऐप्लिकेशन के वर्कफ़्लो में बदलाव करते समय.

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

प्रमुख कार्रवाइयों में लगने वाले समय का आकलन करना और उसका विश्लेषण करना

ऐप्लिकेशन के स्टार्ट होने का समय पूरा होने के बाद, ट्रेस देखें और समय मापें bindApplication या activityStart जैसी बड़ी कार्रवाइयों के लिए लिया गया है. बुध Perfetto या Android का इस्तेमाल करने का सुझाव दें Studio प्रोफ़ाइलर का इस्तेमाल कर सकते हैं.

किसी भी कार्रवाई की पहचान करने के लिए, ऐप्लिकेशन शुरू होने में लगने वाला कुल समय देखें जो ये काम करते हैं:

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

परफ़ॉर्मेंस में अंतर का पता लगाने के लिए, इनमें से हर ट्रेस की और जांच करें.

मुख्य थ्रेड पर महंगे ऑपरेशन का पता लगाएं

सबसे सही तरीका यह है कि फ़ाइल I/O और नेटवर्क जैसे महंगे ऑपरेशन बनाए रखें मुख्य थ्रेड से बाहर निकाल सकता है. यह ऐप्लिकेशन स्टार्टअप के दौरान भी उतना ही ज़रूरी है, क्योंकि मुख्य थ्रेड पर महंगी कार्रवाइयां करने से, ऐप्लिकेशन काम करना बंद कर सकता है और अन्य ज़रूरी कामों में देरी हो सकती है. StrictMode.ThreadPolicy यह कर सकते हैं ऐसे मामलों की पहचान करने में मदद करें जहां मुख्य थ्रेड में महंगी कार्रवाइयां हो रही हैं. StrictMode को चालू रखना एक अच्छा तरीका है डीबग करता है, ताकि समस्याओं की जल्द से जल्द पहचान की जा सके, जैसा कि नीचे दिया गया उदाहरण:

Kotlin

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        ...
        if (BuildConfig.DEBUG)
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectAll()
                    .penaltyDeath()
                    .build()
            )
        ...
    }
}

Java

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        ...
        if(BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(
                    new StrictMode.ThreadPolicy.Builder()
                            .detectAll()
                            .penaltyDeath()
                            .build()
            );
        }
        ...
    }
}

StrictMode.ThreadPolicy का इस्तेमाल करने से, सभी डीबग बिल्ड पर थ्रेड नीति चालू हो जाती है और थ्रेड नीति के उल्लंघन का पता चलने पर ऐप्लिकेशन को क्रैश कर देता है, से थ्रेड की नीति के उल्लंघन का पता लगाना मुश्किल हो जाता है.

टीटीआईडी और टीटीएफ़डी

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

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

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

थ्रेड की पूरी स्थिति का विश्लेषण करना

ऐप्लिकेशन शुरू होने में लगने वाला समय चुनें और थ्रेड के पूरे हिस्से को देखें. मुख्य थ्रेड हर समय जवाबदेह होना चाहिए.

Android Studio प्रोफ़ाइलर और अन्य टूल जैसे परफ़ेटो मुख्य थ्रेड के बारे में खास जानकारी दें और बताएं कि इसमें कितना समय बीतता है करते हैं. परफ़ेटो ट्रेस को विज़ुअलाइज़ करने के बारे में ज़्यादा जानकारी के लिए, यह देखें Perfetto यूज़र इंटरफ़ेस (यूआई) दस्तावेज़.

मुख्य थ्रेड के स्लीप मोड (कम बैटरी मोड) के मुख्य हिस्सों की पहचान करना

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

मुख्य थ्रेड को ब्लॉक करने की सुविधा और बिना किसी रुकावट के नींद लेने की सुविधा को कम करें

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

आईओ से जुड़ी नींद खराब होने से स्वास्थ्य में सुधार हो सकता है. IO करने वाली अन्य प्रोसेस, IO का पता है कि सबसे लोकप्रिय ऐप्लिकेशन क्या कर रहा है.

स्टार्टअप समय में सुधार करें

ऑप्टिमाइज़ेशन के लिए किसी अवसर की पहचान करने के बाद, संभावित समाधानों के बारे में जानें ऐप्लिकेशन के खुलने में लगने वाले समय को कम करने के लिए:

  • तेज़ी से काम करने के लिए, कॉन्टेंट को लेज़ी और एसिंक्रोनस तरीके से लोड करें TTID.
  • बाइंडर कॉल करने वाले कॉलिंग फ़ंक्शन कम करें. अगर उन्हें हटाया नहीं जा सकता, पक्का करें कि इन कॉल को इसके बजाय वैल्यू को कैश मेमोरी में रखकर ऑप्टिमाइज़ किया जा रहा हो बार-बार किए जाने वाले कॉल या ब्लॉक न करने वाले काम को बैकग्राउंड थ्रेड पर ले जाना.
  • अपने ऐप्लिकेशन का स्टार्टअप तेज़ी से दिखाने के लिए, आप कुछ ऐसा दिखा सकते हैं उपयोगकर्ता को जल्द से जल्द कम से कम रेंडरिंग की ज़रूरत होती है. ऐसा तब तक होता है, जब तक लोड हो गया है.
  • स्टार्टअप प्रोफ़ाइल बनाएं और जोड़ें आपके ऐप्लिकेशन को मिलता है.
  • इन कामों के लिए, Jetpack App Startup लाइब्रेरी का इस्तेमाल करें ऐप्लिकेशन के शुरू होने के दौरान कॉम्पोनेंट को शुरू करने की प्रोसेस को आसान बनाया जा सकता है.

यूज़र इंटरफ़ेस (यूआई) की परफ़ॉर्मेंस का विश्लेषण करना

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

शुरू करने पर होने वाले काम को सीमित करें

कुछ फ़्रेम को लोड होने में दूसरों के मुकाबले ज़्यादा समय लग सकता है. इन्हें माना जाता है महंगे ड्रॉर चुनें.

शुरू करने की प्रोसेस को ऑप्टिमाइज़ करने के लिए, ये काम करें:

  • धीमे लेआउट वाले पास को प्राथमिकता दें और सुधारों के लिए इन्हें चुनें.
  • Perfetto से मिली हर चेतावनी की जांच करें. साथ ही, कस्टम ट्रेस इवेंट ज़्यादा पेमेंट या देरी हो सकती है.

फ़्रेम डेटा मेज़र करना

फ़्रेम डेटा को मेज़र करने के कई तरीके हैं. डेटा इकट्ठा करने के पांच मुख्य तरीके हैं:

मुख्य गतिविधि लोड होने में लगने वाला समय देखें

आपके ऐप्लिकेशन की मुख्य गतिविधि में ऐसी बहुत ज़्यादा जानकारी हो सकती है कई सोर्स से लोड किया जाता है. खास तौर पर, होम Activity का लेआउट जांचें Choreographer.onDraw को देखें होम में की गई गतिविधि का डेटा शामिल करता है.

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

मुख्य गतिविधि लोड होने के समय को ऑप्टिमाइज़ करने के लिए, इन संभावित समाधानों पर विचार करें:

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

  • जहां लेआउट नहीं हैं वहां ViewStub का इस्तेमाल करें तुरंत VISIBLE. ViewStub एक ऐसा व्यू होता है जिसे न देखा जा सकता हो और जिसका साइज़ शून्य हो का इस्तेमाल, रनटाइम के दौरान लेआउट संसाधनों को लेज़ी तरीके से बढ़ाने के लिए किया जा सकता है. ज़्यादा के लिए जानकारी, ViewStub देखें.

    अगर Jetpack Compose का इस्तेमाल किया जा रहा है, तो आपको इससे मिलती-जुलती जानकारी मिल सकती है कुछ कॉम्पोनेंट लोड होने में देरी करने के लिए, स्थिति का इस्तेमाल करके ViewStub के साथ व्यवहार:

    var shouldLoad by remember {mutableStateOf(false)}

if (shouldLoad) {
 MyComposable()
}

    बदलाव करके कंडिशनल ब्लॉक में कंपोज़ेबल को लोड करें shouldLoad:

    LaunchedEffect(Unit) {
 shouldLoad = true
}

    यह कंपोज़िशन को ट्रिगर करता है, जिसमें कंडिशनल के अंदर कोड शामिल होता है रोकने की पूरी कोशिश करता है.