ऐप्लिकेशन स्टार्टअप Android Jetpack का हिस्सा है.

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

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

सेटअप

अपनी लाइब्रेरी या ऐप्लिकेशन में Jetpack Startup इस्तेमाल करने के लिए, Gradle में यह जानकारी जोड़ें फ़ाइल:

ग्रूवी

dependencies {
    implementation "androidx.startup:startup-runtime:1.1.1"
}

Kotlin

dependencies {
    implementation("androidx.startup:startup-runtime:1.1.1")
}

ऐप्लिकेशन शुरू होने पर कॉम्पोनेंट शुरू करना

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

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

कॉम्पोनेंट शुरू करने वाले टूल को लागू करना

आप एक ऐसी क्लास बनाकर हर कॉम्पोनेंट शुरू करने वाले को तय करते हैं जो Initializer<T> इंटरफ़ेस. यह इंटरफ़ेस दो ज़रूरी तरीकों के बारे में बताता है:

• create() तरीका, जिसमें सभी ज़रूरी कार्रवाइयां शामिल होती हैं कॉम्पोनेंट को शुरू करता है और T का इंस्टेंस दिखाता है.
• dependencies() तरीका, जो अन्य क्वेरी की सूची दिखाता है Initializer<T> ऑब्जेक्ट, जिन पर शुरू करने वाला टूल निर्भर करता है. आप इसका इस्तेमाल कर सकते हैं का इस्तेमाल करें.

उदाहरण के लिए, मान लें कि आपका ऐप्लिकेशन, WorkManager और इसके लिए यह ज़रूरी है तो स्टार्टअप पर शुरू करते हैं. ऐसी WorkManagerInitializer क्लास तय करें जो Initializer<WorkManager> को लागू करता है:

Kotlin

// Initializes WorkManager.
class WorkManagerInitializer : Initializer<WorkManager> {
    override fun create(context: Context): WorkManager {
        val configuration = Configuration.Builder().build()
        WorkManager.initialize(context, configuration)
        return WorkManager.getInstance(context)
    }
    override fun dependencies(): List<Class<out Initializer<*>>> {
        // No dependencies on other libraries.
        return emptyList()
    }
}

Java

// Initializes WorkManager.
class WorkManagerInitializer implements Initializer<WorkManager> {

    @Override
    public WorkManager create(Context context) {
        Configuration configuration = Configuration.Builder().build();
        WorkManager.initialize(context, configuration);
        return WorkManager.getInstance(context);
    }

    @Override
    public List<Class<Initializer<?>>> dependencies() {
        // No dependencies on other libraries.
        return emptyList();
    }

}

dependencies() तरीका, खाली सूची दिखाता है, क्योंकि WorkManager ये काम नहीं करता किसी दूसरी लाइब्रेरी पर निर्भर हो सकता है.

मान लीजिए कि आपका ऐप्लिकेशन ExampleLogger नाम की लाइब्रेरी पर भी निर्भर करता है, जिसमें टर्न, WorkManager पर निर्भर करता है. इस डिपेंडेंसी का मतलब है कि आपको यह पक्का करना होगा कि ऐप्लिकेशन स्टार्टअप WorkManager पहले शुरू करता है. एक Initializer<ExampleLogger> को लागू करने वाली ExampleLoggerInitializer क्लास:

Kotlin

// Initializes ExampleLogger.
class ExampleLoggerInitializer : Initializer<ExampleLogger> {
    override fun create(context: Context): ExampleLogger {
        // WorkManager.getInstance() is non-null only after
        // WorkManager is initialized.
        return ExampleLogger(WorkManager.getInstance(context))
    }

    override fun dependencies(): List<Class<out Initializer<*>>> {
        // Defines a dependency on WorkManagerInitializer so it can be
        // initialized after WorkManager is initialized.
        return listOf(WorkManagerInitializer::class.java)
    }
}

Java

// Initializes ExampleLogger.
class ExampleLoggerInitializer implements Initializer<ExampleLogger> {

    @Override
    public ExampleLogger create(Context context) {
        // WorkManager.getInstance() is non-null only after
        // WorkManager is initialized.
        return ExampleLogger(WorkManager.getInstance(context));
    }

    @Override
    public List<Class<Initializer<?>>> dependencies() {
        // Defines a dependency on WorkManagerInitializer so it can be
        // initialized after WorkManager is initialized.
        return Arrays.asList(WorkManagerInitializer.class);
    }
}

आपने dependencies() तरीके में WorkManagerInitializer को शामिल किया है. इसलिए, ऐप्लिकेशन स्टार्टअप ExampleLogger से पहले WorkManager पर शुरू हो जाता है.

ध्यान दें: अगर आपने पहले कभी अपने कॉम्पोनेंट में कॉम्पोनेंट शुरू करने के लिए, कॉन्टेंट देने वालों का इस्तेमाल किया है ऐप्लिकेशन शुरू करते समय, यह पक्का करें कि आपने कॉन्टेंट देने वाले उन लोगों या संगठनों को हटा दिया हो.

मेनिफ़ेस्ट एंट्री सेट अप करें

App Startup में, InitializationProvider नाम का कॉन्टेंट देने वाला एक खास प्लैटफ़ॉर्म शामिल है जिसकी मदद से यह आपके कॉम्पोनेंट शुरू करने वालों को खोजता है और कॉल करता है. ऐप्लिकेशन स्टार्टअप <meta-data> एंट्री की जांच करके, कॉम्पोनेंट शुरू करने वाले टूल का पता लगाता है InitializationProvider मेनिफ़ेस्ट प्रविष्टि के अंतर्गत. फिर, ऐप्लिकेशन स्टार्टअप dependencies() तरीकों का इस्तेमाल करें, जो इसकी मदद से पहले ही खोजे जा चुके हैं.

इसका मतलब है कि कॉम्पोनेंट शुरू करने के लिए, उसे ऐप्लिकेशन से खोजा जा सकेगा स्टार्टअप हो, तो इनमें से कोई एक शर्त पूरी होनी चाहिए:

• घटक शुरू करने के टूल में संबंधित <meta-data> प्रविष्टि InitializationProvider मेनिफ़ेस्ट एंट्री.
• घटक प्रारंभकर्ता को dependencies() पद्धति में शुरू करें जो पहले से खोजा जा सकता है.

WorkManagerInitializer और ExampleLoggerInitializer. ऐप्लिकेशन स्टार्टअप इन्हें खोज सकें, इसके लिए शुरू करने के लिए, मेनिफ़ेस्ट फ़ाइल में इन्हें जोड़ें:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <!-- This entry makes ExampleLoggerInitializer discoverable. -->
    <meta-data  android:name="com.example.ExampleLoggerInitializer"
          android:value="androidx.startup" />
</provider>

आपको WorkManagerInitializer के लिए <meta-data> एंट्री जोड़ने की ज़रूरत नहीं है, क्योंकि WorkManagerInitializer, ExampleLoggerInitializer पर डिपेंडेंसी है. इसका मतलब है कि अगर ExampleLoggerInitializer खोजे जाने लायक है, तो WorkManagerInitializer.

tools:node="merge" एट्रिब्यूट यह पक्का करता है कि मेनिफ़ेस्ट मर्जर हो टूल किसी भी कॉन्फ़्लिक्टिंग एंट्री को ठीक से हल करता है.

लिंट की जांच करें

App Startup लाइब्रेरी में लिंट के नियमों का एक सेट होता है, जिसका इस्तेमाल करके आपने कॉम्पोनेंट शुरू करने वाले टूल को सही तरीके से तय किया है या नहीं. ये काम किए जा सकते हैं कमांड लाइन से ./gradlew :app:lintDebug चलाकर ये लिंट जांच करते हैं.

कॉम्पोनेंट को मैन्युअल तरीके से शुरू करना

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

आपको जो कॉम्पोनेंट चाहिए उसके लिए, अपने-आप शुरू होने की सुविधा को सबसे पहले बंद करना होगा मैन्युअल तरीके से शुरू करना होगा.

किसी एक कॉम्पोनेंट के लिए, अपने-आप शुरू होने की सुविधा बंद करें

किसी एक कॉम्पोनेंट के लिए, अपने-आप शुरू होने की सुविधा को बंद करने के लिए, मेनिफ़ेस्ट से उस कॉम्पोनेंट के शुरू करने वाले के लिए <meta-data> एंट्री.

उदाहरण के लिए, मेनिफ़ेस्ट फ़ाइल में इन्हें जोड़ने से, अपने-आप काम करने की सुविधा बंद हो जाती है ExampleLogger के लिए शुरू करना:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data android:name="com.example.ExampleLoggerInitializer"
              tools:node="remove" />
</provider>

सिर्फ़ एंट्री हटाने के बजाय, एंट्री में tools:node="remove" का इस्तेमाल किया जा सकता है यह सुनिश्चित करने के लिए कि मर्जर टूल अन्य सभी मर्ज की गई मेनिफ़ेस्ट फ़ाइलें.

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

सभी कॉम्पोनेंट के लिए, अपने-आप शुरू होने की सुविधा बंद करें

सभी स्वचालित प्रारंभीकरण को अक्षम करने के लिए, के लिए पूरी प्रविष्टि निकालें मेनिफ़ेस्ट से InitializationProvider:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    tools:node="remove" />

कॉम्पोनेंट की शुरुआत करने के लिए, मैन्युअल तरीके से कॉल करें

अगर किसी कॉम्पोनेंट के लिए अपने-आप शुरू होने की सुविधा बंद है, तो AppInitializer का इस्तेमाल करके, मैन्युअल तरीके से उस कॉम्पोनेंट और उसकी डिपेंडेंसी शुरू करें.

उदाहरण के लिए, यह कोड AppInitializer को कॉल करता है और मैन्युअल तरीके से शुरू करता है ExampleLogger:

Kotlin

AppInitializer.getInstance(context)
    .initializeComponent(ExampleLoggerInitializer::class.java)

Java

AppInitializer.getInstance(context)
    .initializeComponent(ExampleLoggerInitializer.class);

इस वजह से, ऐप्लिकेशन स्टार्टअप WorkManager भी शुरू कर देता है, क्योंकि WorkManager यह ExampleLogger पर निर्भर करता है.

सुझाव या राय दें

इन संसाधनों की मदद से, हमारे साथ अपने सुझाव, शिकायत या राय शेयर करें:

समस्या को ट्रैक करने वाला टूल

समस्याओं की शिकायत करें, ताकि हम गड़बड़ियां ठीक कर सकें.