कॉन्फ़िगरेशन के बदलावों को हैंडल करना

ऐप्लिकेशन के चालू रहने के दौरान, डिवाइस के कुछ कॉन्फ़िगरेशन में बदलाव हो सकते हैं. इनमें ये शामिल हैं, लेकिन इन तक सीमित नहीं हैं:

  • ऐप्लिकेशन का डिसप्ले साइज़
  • स्क्रीन की दिशा
  • फ़ॉन्ट का साइज़ और मोटाई
  • स्थान-भाषा
  • गहरे रंग वाला मोड बनाम हल्के रंग वाला मोड
  • कीबोर्ड की उपलब्धता

कॉन्फ़िगरेशन में होने वाले ज़्यादातर बदलाव, उपयोगकर्ता के इंटरैक्शन की वजह से होते हैं. उदाहरण के लिए, डिवाइस को घुमाने या फ़ोल्ड करने पर, आपके ऐप्लिकेशन के लिए उपलब्ध स्क्रीन स्पेस बदल जाता है. इसी तरह, फ़ॉन्ट साइज़, भाषा या पसंदीदा थीम जैसी डिवाइस सेटिंग में बदलाव करने पर, Configuration ऑब्जेक्ट में उनकी वैल्यू बदल जाती हैं.

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

ऐक्टिविटी रीक्रिएशन

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

आम तौर पर, Activity, कंपोज़ेबल के लिए होस्ट के तौर पर काम करता है. Activity को फिर से बनाने पर, Compose भी नए कॉन्फ़िगरेशन वैल्यू का इस्तेमाल करके, आपके यूज़र इंटरफ़ेस (यूआई) को फिर से बनाता है.

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

रीक्रिएशन का उदाहरण

मान लें कि एक कंपोज़ेबल, स्ट्रिंग रिसोर्स का इस्तेमाल करके, स्टैटिक टाइटल दिखाता है:

// In the res/values/strings.xml file
// <string name="compose">Jetpack Compose</string>

// In your Compose code
Text(
    text = stringResource(R.string.compose)
)

Activity बनने पर, Text कंपोज़ेबल, मौजूदा कॉन्फ़िगरेशन (जैसे, भाषा) को पढ़ता है और सही स्ट्रिंग रिसोर्स को रिज़ॉल्व करता है.

भाषा बदलने पर, सिस्टम ऐक्टिविटी को फिर से बनाता है. ऐसा होने पर, Compose यूज़र इंटरफ़ेस (यूआई) को फिर से बनाता है. stringResource मौजूदा कॉन्फ़िगरेशन से पढ़ता है. इसलिए, टाइटल अपने-आप सही स्थानीय वैल्यू में अपडेट हो जाता है.

रीक्रिएशन से, Activity में फ़ील्ड के तौर पर सेव की गई कोई भी स्थिति मिट जाती है.

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

Compose में स्थिति सेव करने के बारे में ज़्यादा जानने के लिए, Compose में यूज़र इंटरफ़ेस (यूआई) की स्थिति सेव करना लेख पढ़ें.

उपयोगकर्ताओं की उम्मीदें

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

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

  • डिवाइस को घुमाना
  • मल्टी-विंडो मोड में जाना
  • मल्टी-विंडो मोड या फ़्री-फ़ॉर्म विंडो में होने के दौरान, ऐप्लिकेशन का साइज़ बदलना
  • फ़ोल्ड किए जा सकने वाले डिवाइस को फ़ोल्ड करना, जिसमें एक से ज़्यादा डिसप्ले हों
  • सिस्टम की थीम बदलना. जैसे, गहरे रंग वाला मोड बनाम हल्के रंग वाला मोड
  • फ़ॉन्ट का साइज़ बदलना
  • सिस्टम या ऐप्लिकेशन की भाषा बदलना
  • हार्डवेयर कीबोर्ड को कनेक्ट या डिसकनेक्ट करना
  • डॉक को कनेक्ट या डिसकनेक्ट करना

Activity रीक्रिएशन के दौरान, काम की स्थिति को बनाए रखने के लिए कई तरीके अपनाए जा सकते हैं. आपको किस तरीके का इस्तेमाल करना है, यह इस बात पर निर्भर करता है कि आपको किस तरह की स्थिति बनाए रखनी है:

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

इनमें से हर एपीआई के बारे में ज़्यादा जानने और हर एपीआई का इस्तेमाल कब करना चाहिए, यह जानने के लिए, यूज़र इंटरफ़ेस (यूआई) की स्थिति सेव करना लेख पढ़ें.

ऐक्टिविटी रीक्रिएशन को सीमित करना

कॉन्फ़िगरेशन में होने वाले कुछ बदलावों के लिए, ऐक्टिविटी रीक्रिएशन को रोका जा सकता है. Compose-only ऐप्लिकेशन में, आपका यूज़र इंटरफ़ेस (यूआई) दोनों ही स्थितियों में फिर से कंपोज़ होता है. हालांकि, कॉन्फ़िगरेशन में होने वाले बदलाव को सीधे तौर पर मैनेज करने का सुझाव दिया जाता है.

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

Compose में कॉन्फ़िगरेशन में होने वाले बदलावों को सीधे तौर पर मैनेज करने के कई फ़ायदे हैं:

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

कॉन्फ़िगरेशन में होने वाले खास बदलावों के लिए, ऐक्टिविटी रीक्रिएशन को बंद करने के लिए, AndroidManifest.xml फ़ाइल में <activity> एंट्री में android:configChanges में कॉन्फ़िगरेशन टाइप जोड़ें. `android:configChanges` एट्रिब्यूट के दस्तावेज़ में, संभावित वैल्यू दिखती हैं.

मेनिफ़ेस्ट का यह कोड, स्क्रीन ओरिएंटेशन और कीबोर्ड की उपलब्धता में बदलाव होने पर, Activity रीक्रिएशन को MyActivity के लिए बंद कर देता है:

<activity
    android:name=".MyActivity"
    android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
    android:label="@string/app_name">

कॉन्फ़िगरेशन में होने वाले बदलावों पर प्रतिक्रिया देना

Jetpack Compose की मदद से, आपका ऐप्लिकेशन कॉन्फ़िगरेशन में होने वाले बदलावों पर आसानी से प्रतिक्रिया दे सकता है. हालांकि, अगर आपने कॉन्फ़िगरेशन में होने वाले उन सभी बदलावों के लिए Activity रीक्रिएशन को बंद कर दिया है जिनके लिए ऐसा किया जा सकता है, तो भी आपके ऐप्लिकेशन को कॉन्फ़िगरेशन में होने वाले बदलावों को सही तरीके से मैनेज करना होगा.

The Configuration ऑब्जेक्ट, Compose यूज़र इंटरफ़ेस (यूआई) के क्रम में, with the LocalConfiguration कंपोज़िशन लोकल के साथ उपलब्ध है. जब भी इसमें बदलाव होता है, तो LocalConfiguration.current से पढ़ने वाले कंपोज़ेबल फ़ंक्शन फिर से कंपोज़ होते हैं. कंपोज़िशन लोकल के काम करने के तरीके के बारे101} में जानने के लिए, CompositionLocal की मदद से स्थानीय दायरे वाला डेटा लेख पढ़ें.

उदाहरण

यहां दिए गए उदाहरण में, एक कंपोज़ेबल, खास फ़ॉर्मैट में तारीख दिखाता है. कंपोज़ेबल, ConfigurationCompat.getLocales के साथ LocalConfiguration.current को कॉल करके, सिस्टम की स्थानीय सेटिंग में होने वाले कॉन्फ़िगरेशन में बदलावों पर प्रतिक्रिया देता है.

@Composable
fun DateText(year: Int, dayOfYear: Int) {
    val dateTimeFormatter = DateTimeFormatter.ofPattern(
        "MMM dd",
        ConfigurationCompat.getLocales(LocalConfiguration.current)[0]
    )
    Text(
        dateTimeFormatter.format(LocalDate.ofYearDay(year, dayOfYear))
    )
}

स्थानीय सेटिंग में बदलाव होने पर, Activity रीक्रिएशन से बचने के लिए, Compose कोड को होस्ट करने वाली Activity को स्थानीय सेटिंग में होने वाले कॉन्फ़िगरेशन में बदलावों से ऑप्ट आउट करना होगा. ऐसा करने के लिए, android:configChanges को locale|layoutDirection पर सेट करें.

कॉन्फ़िगरेशन में होने वाले बदलाव: ज़रूरी कॉन्सेप्ट और सबसे सही तरीके

कॉन्फ़िगरेशन में होने वाले बदलावों पर काम करते समय, आपको इन ज़रूरी कॉन्सेप्ट के बारे में पता होना चाहिए:

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

उपयोगकर्ता को बेहतर अनुभव देने के लिए, इन सबसे सही तरीकों को अपनाएं:

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

साइज़ के हिसाब से कॉन्फ़िगरेशन में होने वाले बदलावों को मैनेज करना

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

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

साइज़ के हिसाब से कॉन्फ़िगरेशन में होने वाले बदलावों के लिए, ऐक्टिविटी रीक्रिएशन को सीमित करना

साइज़ के हिसाब से कॉन्फ़िगरेशन में होने वाले बदलावों के लिए, Activity रीक्रिएशन को बंद करने पर, सिस्टम Activity को फिर से नहीं बनाता. इसके बजाय, इसे Activity.onConfigurationChanged पर कॉल मिलता है. LocalConfiguration.current को पढ़ने वाले सभी कंपोज़ेबल, नए साइज़ को दिखाने के लिए अपने-आप फिर से कंपोज़ होते हैं.

मेनिफ़ेस्ट फ़ाइल में android:configChanges="screenSize|smallestScreenSize|orientation|screenLayout" होने पर, साइज़ के हिसाब से कॉन्फ़िगरेशन में होने वाले बदलावों के लिए, Activity रीक्रिएशन बंद हो जाता है.

अन्य संसाधन

कॉन्फ़िगरेशन में होने वाले बदलावों को मैनेज करने के बारे में ज़्यादा जानने के लिए, ये अन्य संसाधन देखें:

दस्तावेज़

Views का कॉन्टेंट