इस पेज का अनुवाद Cloud Translation API से किया गया है.

गतिविधि एम्बेड करना

ध्यान दें: मॉडर्न Android डेवलपमेंट (एमएडी) में सिंगल-ऐक्टिविटी आर्किटेक्चर का इस्तेमाल, Jetpack API पर आधारित होता है. इसमें Jetpack Compose भी शामिल है. गतिविधि एम्बेड करने की सुविधा को कई गतिविधियों वाले लेगसी ऐप्लिकेशन के लिए बनाया गया है. इन्हें आसानी से एमएडी पर अपडेट नहीं किया जा सकता. एमएडी की मदद से नए ऐप्लिकेशन बनाएं. जब भी मुमकिन हो, अपने लेगसी ऐप्लिकेशन को MAD पर अपडेट करें.

गतिविधि एम्बेड करने की सुविधा, दो गतिविधियों या एक ही तरह के दो इंस्टेंस के बीच की ऐप्लिकेशन की टास्क विंडो गतिविधि.

**पहली इमेज.** सेटिंग ऐप्लिकेशन, जिसमें एक साथ कई गतिविधियां दिखाई गई हैं.

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

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

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

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

गतिविधि एम्बेड करने की सुविधा, Android 12L (एपीआई लेवल 32) और इसके बाद के वर्शन पर काम करने वाले ज़्यादातर बड़ी स्क्रीन वाले डिवाइसों पर काम करती है.

स्प्लिट टास्क विंडो

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

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

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

इसके अलावा, पूरी टास्क विंडो में चल रही कोई भी गतिविधि इसके साथ नई गतिविधि लॉन्च करना:

**तीसरी इमेज.** गतिविधि A, गतिविधि B को एक तरफ़ शुरू करती है.

ऐसी गतिविधियां लॉन्च हो सकती हैं जो पहले से ही बंटी हुई हैं और टास्क विंडो शेयर की जा रही हैं अन्य गतिविधियों को पूरा करते हैं:

किसी दूसरी गतिविधि में 'सबसे ऊपर' पर जाएं:

चौथी इमेज. गतिविधि A, गतिविधि B के बगल में गतिविधि C शुरू करती है.
पिछली मुख्य गतिविधि को छिपाते हुए, किनारे की ओर ले जाएं और स्प्लिट को एक ओर शिफ़्ट करें:

पांचवीं इमेज. गतिविधि B, गतिविधि C को एक तरफ़ शुरू करती है और दो भागों में बंटा होता है.
सबसे ऊपर कोई गतिविधि लॉन्च करें; मतलब एक ही गतिविधि स्टैक में हो:

छठी इमेज. गतिविधि B किसी अतिरिक्त इंटेंट फ़्लैग के बिना गतिविधि C शुरू करती है.
एक ही टास्क में गतिविधि की पूरी विंडों में जानकारी दिखाना:

सातवीं इमेज. A या गतिविधि B की मदद से, अपने हिसाब से गतिविधि C शुरू की जाती है टास्क विंडो पर क्लिक करें.

पीछे जाने का नेविगेशन

अलग-अलग तरह के ऐप्लिकेशन में वापस नेविगेशन के लिए अलग-अलग नियम हो सकते हैं यह, गतिविधियों या उपयोगकर्ता बैक इवेंट को कैसे ट्रिगर करते हैं. उदाहरण के लिए:

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

बटन का इस्तेमाल करने पर, पिछले इवेंट को फ़ोकस की गई पिछली गतिविधि पर भेजा जाता है नेविगेशन. हाथ के जेस्चर पर आधारित नेविगेशन की मदद से, बैक इवेंट को गतिविधि जिसमें जेस्चर हुआ हो.

मल्टी-पैनल लेआउट

Jetpack WindowManager की मदद से, Android 12L (एपीआई लेवल 32) या उसके बाद के वर्शन वाले बड़ी स्क्रीन वाले डिवाइसों और प्लैटफ़ॉर्म के पुराने वर्शन वाले कुछ डिवाइसों में, मल्टी-पैनल लेआउट को एम्बेड करने वाली गतिविधि बनाई जा सकती है. पहले से मौजूद ऐसे ऐप्लिकेशन जो फ़्रैगमेंट या व्यू-आधारित लेआउट के बजाय कई गतिविधियों पर आधारित होते हैं, जैसे कि SlidingPaneLayout सोर्स कोड को रीफ़ैक्टर किए बिना, बड़ी स्क्रीन पर बेहतर उपयोगकर्ता अनुभव दे सकते हैं.

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

**आठवीं इमेज.** एक से ज़्यादा पैनल में एक साथ दो गतिविधियां शुरू की गईं लेआउट.

विशेषताएं विभाजित करें

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

किसी एक्सएमएल कॉन्फ़िगरेशन फ़ाइल में तय किए गए नियमों के लिए, इन एट्रिब्यूट को सेट करें:

splitRatio: कंटेनर के अनुपात को सेट करता है. वैल्यू, ओपन इंटरवल (0.0, 1.0) में फ़्लोटिंग पॉइंट नंबर है.
splitLayoutDirection: इससे पता चलता है कि स्प्लिट कंटेनर को एक-दूसरे के मुकाबले कैसे रखा जाता है. वैल्यू में ये शामिल हैं:
- ltr: बाएं से दाएं
- rtl: दाएं से बाएं
- locale: स्थान सेटिंग से ltr या rtl का पता लगाया जाता है

उदाहरणों के लिए नीचे एक्सएमएल कॉन्फ़िगरेशन देखें.

WindowManager एपीआई का इस्तेमाल करके बनाए गए नियमों के लिए, SplitAttributes.Builder के साथ SplitAttributes ऑब्जेक्ट बनाएं. इसके बाद, बिल्डर के इन तरीकों को कॉल करें:

setSplitType(): स्प्लिट कंटेनर के अनुपात को सेट करता है. SplitAttributes.SplitType.ratio() तरीके के साथ-साथ मान्य आर्ग्युमेंट के लिए, SplitAttributes.SplitType पर जाएं.
setLayoutDirection(): कंटेनर का लेआउट सेट करता है. संभावित वैल्यू के लिए SplitAttributes.LayoutDirection देखें.

ध्यान दें: TOP_TO_BOTTOM और BOTTOM_TO_TOP की खास बातें सिर्फ़ WindowManager API के ज़रिए उपलब्ध हैं. समतुल्य एक्सएमएल एट्रिब्यूट इस्तेमाल नहीं किए जा सकते.

उदाहरणों के लिए नीचे WindowManager API देखें.

**नौवीं इमेज.** इन दो में कसरत के दो स्प्लिट बाईं से दाईं ओर दिए गए हैं, लेकिन उनका अनुपात अलग-अलग है.

प्लेसहोल्डर

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

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

हालांकि, SplitPlaceholder.Builder के SplitPlaceholderRule या setSticky() तरीके का stickyPlaceholder एट्रिब्यूट, डिफ़ॉल्ट ऐक्शन को बदल सकता है. जब एट्रिब्यूट या तरीका true की वैल्यू तय करता है, तो सिस्टम प्लेसहोल्डर को टास्क विंडो में सबसे ऊपर की गई गतिविधि के तौर पर दिखाता है. ऐसा तब होता है, जब डिसप्ले का साइज़ दो पैनल वाले डिसप्ले से एक पैनल वाला डिसप्ले में बदला जाता है. उदाहरण के लिए, स्प्लिट कॉन्फ़िगरेशन देखें.

विंडो के साइज़ में बदलाव

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

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

गतिविधि को स्टैक किया जा सकता है, क्योंकि WindowManager z-ऑर्डर करता है मुख्य पैनल में मौजूद गतिविधियों के ऊपर, दूसरे पैनल में मौजूद गतिविधियां.

दूसरे पैनल में कई गतिविधियां

गतिविधि B बिना किसी अतिरिक्त इंटेंट फ़्लैग के गतिविधि C शुरू करती है:

ऐक्टिविटी के टाइप में A, B, और C गतिविधियां शामिल हैं. साथ ही, C को स्टैक किया गया है
B का शीर्ष

नतीजे के तौर पर, एक ही टास्क में ये ज़ेड-ऑर्डर (वे क्रम में) दिखेंगे:

सेकंडरी गतिविधि का स्टैक, जिसमें B के ऊपर गतिविधि C स्टैक की गई है.
सेकंडरी स्टैक को प्राइमरी ऐक्टिविटी स्टैक पर स्टैक किया गया है
गतिविधि A शामिल है.

इसलिए, छोटी टास्क विंडो में, ऐप्लिकेशन सिर्फ़ एक गतिविधि तक सीमित हो जाता है स्टैक पर सबसे ऊपर C दबाएं:

छोटी विंडो में सिर्फ़ गतिविधि C दिख रही है.

छोटी विंडो में वापस जाने पर, स्टैक की गई गतिविधियां देखी जा सकती हैं एक-दूसरे को प्राथमिकता दें.

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

स्टैक किए गए स्प्लिट

गतिविधि B, गतिविधि C को साइड में शुरू करती है और स्प्लिट को साइड में शिफ़्ट करती है:

टास्क की विंडो, जिसमें A और B गतिविधियां हैं. इसके बाद, B और C गतिविधियां दिख रही हैं.

इससे पता चलता है कि एक ही टास्क में ये ज़ेड-क्रम क्या हैं:

ऐक्टिविटी A, B, और C एक ही स्टैक में हैं. गतिविधियां स्टैक की गई हैं
ऊपर से नीचे के क्रम में: C, B, A.

छोटी टास्क विंडो में, ऐप्लिकेशन सी के साथ एक गतिविधि तक सिकुड़ जाता है सबसे ऊपर:

छोटी विंडो में सिर्फ़ गतिविधि C दिख रही है.

फ़िक्स्ड-पोर्ट्रेट ओरिएंटेशन

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

**12वीं इमेज.** लेटरबॉक्स गतिविधियां: लैंडस्केप डिवाइस पर फ़िक्स्ड-पोर्ट्रेट (बाएं), पोर्ट्रेट डिवाइस पर तय-लैंडस्केप (दाएं).

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

**13वीं इमेज.** फ़िक्स्ड-पोर्ट्रेट गतिविधि A, गतिविधि B को एक तरफ़ शुरू करती है.

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

स्प्लिट कॉन्फ़िगरेशन

बांटने के नियम, गतिविधि के बंटवारे को कॉन्फ़िगर करते हैं. एक्सएमएल कॉन्फ़िगरेशन फ़ाइल में या Jetpack WindowManager एपीआई कॉल करके, स्प्लिट रूल तय किए जा सकते हैं.

दोनों ही मामलों में, आपके ऐप्लिकेशन को WindowManager लाइब्रेरी को ऐक्सेस करना होगा. साथ ही, सिस्टम को यह जानकारी देनी होगी कि ऐप्लिकेशन ने गतिविधि एम्बेड करने की सुविधा लागू कर दी है.

ये कार्रवाइयां करें:

अपने ऐप्लिकेशन के मॉड्यूल-लेवल की build.gradle फ़ाइल में, WindowManager लाइब्रेरी की नई डिपेंडेंसी जोड़ें. उदाहरण के लिए:

implementation 'androidx.window:window:1.1.0-beta02'

ध्यान दें: रिलीज़ के वर्शन के लिए, WindowManager के प्रॉडक्ट की जानकारी देखें.

WindowManager लाइब्रेरी में, गतिविधि एम्बेड करने के लिए सभी ज़रूरी कॉम्पोनेंट मिलते हैं.
सिस्टम को सूचित करें कि आपके ऐप्लिकेशन में गतिविधि एम्बेड करने की सुविधा लागू की गई है.

<application> में android.window.PROPERTY_ACTIVITY_EMBEDDING_SPLITS_ENABLED प्रॉपर्टी जोड़ें ऐप्लिकेशन मेनिफ़ेस्ट फ़ाइल के एलिमेंट में जोड़ा जा सकता है और मान को 'सही' पर सेट किया जा सकता है, उदाहरण के लिए:
```
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application>
        <property
            android:name="android.window.PROPERTY_ACTIVITY_EMBEDDING_SPLITS_ENABLED"
            android:value="true" />
    </application>
</manifest>
```
WindowManager रिलीज़ 1.1.0-alpha06 और इसके बाद के वर्शन पर, तब तक गतिविधि के लिए एम्बेड करने वाले स्प्लिट बंद रहते हैं, जब तक प्रॉपर्टी को मेनिफ़ेस्ट में नहीं जोड़ा जाता और 'सही है' पर सेट नहीं किया जाता.

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

एक्सएमएल कॉन्फ़िगरेशन

गतिविधि एम्बेड करने की सुविधा को एक्सएमएल पर आधारित बनाने के लिए, नीचे दिए गए चरणों को पूरा करें:

एक ऐसी एक्सएमएल रिसॉर्स फ़ाइल बनाएं जो ये काम करे:

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

उदाहरण के लिए:

<!-- main_split_config.xml -->

<resources
    xmlns:window="http://schemas.android.com/apk/res-auto">

    <!-- Define a split for the named activities. -->
    <SplitPairRule
        window:splitRatio="0.33"
        window:splitLayoutDirection="locale"
        window:splitMinWidthDp="840"
        window:splitMaxAspectRatioInPortrait="alwaysAllow"
        window:finishPrimaryWithSecondary="never"
        window:finishSecondaryWithPrimary="always"
        window:clearTop="false">
        <SplitPairFilter
            window:primaryActivityName=".ListActivity"
            window:secondaryActivityName=".DetailActivity"/>
    </SplitPairRule>

    <!-- Specify a placeholder for the secondary container when content is
         not available. -->
    <SplitPlaceholderRule
        window:placeholderActivityName=".PlaceholderActivity"
        window:splitRatio="0.33"
        window:splitLayoutDirection="locale"
        window:splitMinWidthDp="840"
        window:splitMaxAspectRatioInPortrait="alwaysAllow"
        window:stickyPlaceholder="false">
        <ActivityFilter
            window:activityName=".ListActivity"/>
    </SplitPlaceholderRule>

    <!-- Define activities that should never be part of a split. Note: Takes
         precedence over other split rules for the activity named in the
         rule. -->
    <ActivityRule
        window:alwaysExpand="true">
        <ActivityFilter
            window:activityName=".ExpandedActivity"/>
    </ActivityRule>

</resources>

कोई शुरू करने वाला टूल बनाएं.

WindowManager RuleController कॉम्पोनेंट, एक्सएमएल कॉन्फ़िगरेशन फ़ाइल को पार्स करता है. साथ ही, सिस्टम में नियमों को उपलब्ध कराता है. ऐप्लिकेशन शुरू होने पर, Jetpack Startup लाइब्रेरी Initializer RuleController के लिए एक्सएमएल फ़ाइल उपलब्ध कराती है, ताकि कोई भी ऐक्टिविटी शुरू होने पर नियम लागू हों.

शुरू करने वाला टूल बनाने के लिए, ये काम करें:
1. अपनी मॉड्यूल-लेवल build.gradle फ़ाइल में Jetpack Startup लाइब्रेरी डिपेंडेंसी जोड़ें. उदाहरण के लिए:
  
  implementation 'androidx.startup:startup-runtime:1.1.1'
  
  ध्यान दें: रिलीज़ के वर्शन के बारे में जानने के लिए, स्टार्टअप की जानकारी देखें.
2. ऐसी क्लास बनाएं जो Initializer इंटरफ़ेस को लागू करती हो.
  
  शुरू करने वाला टूल, एक्सएमएल कॉन्फ़िगरेशन फ़ाइल (main_split_config.xml) के आईडी को RuleController.parseRules() तरीके में पास करके, RuleController के लिए स्प्लिट नियम उपलब्ध कराता है.
  Kotlin
  
  class SplitInitializer : Initializer<RuleController> { override fun create(context: Context): RuleController { return RuleController.getInstance(context).apply { setRules(RuleController.parseRules(context, R.xml.main_split_config)) } } override fun dependencies(): List<Class<out Initializer<*>>> { return emptyList() } }
  Java
  
  public class SplitInitializer implements Initializer<RuleController> { @NonNull @Override public RuleController create(@NonNull Context context) { RuleController ruleController = RuleController.getInstance(context); ruleController.setRules( RuleController.parseRules(context, R.xml.main_split_config) ); return ruleController; } @NonNull @Override public List<Class<? extends Initializer<?>>> dependencies() { return Collections.emptyList(); } }
नियम की परिभाषाओं के लिए कॉन्टेंट देने वाला बनाएं.

androidx.startup.InitializationProvider को अपनी ऐप्लिकेशन मेनिफ़ेस्ट फ़ाइल में <provider> के तौर पर जोड़ें. अपने RuleController शुरू करने वाले टूल, SplitInitializer को लागू करने का रेफ़रंस शामिल करें:
```


<provider android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    
    <meta-data android:name="${applicationId}.SplitInitializer"
        android:value="androidx.startup" />
</provider>
```
ऐप्लिकेशन के onCreate() तरीके को कॉल करने से पहले, InitializationProvider SplitInitializer का पता लगाता है और उसे शुरू करता है. इसकी वजह से, ऐप्लिकेशन की मुख्य गतिविधि शुरू होने पर स्प्लिट करने के नियम लागू होते हैं.

WindowManager एपीआई

कुछ एपीआई कॉल की मदद से, प्रोग्राम के हिसाब से गतिविधि एम्बेड करने की प्रोसेस लागू की जा सकती है. किसी भी ऐक्टिविटी लॉन्च से पहले, नियम लागू करने के लिए Application के सब-क्लास के onCreate() तरीके का इस्तेमाल करके कॉल करें.

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

प्रोग्राम के हिसाब से अपने-आप होने वाली गतिविधियों का बंटवारा बनाने के लिए, ये काम करें:

बांटने का नियम बनाएं:
1. स्प्लिट शेयर करने वाली गतिविधियों की पहचान करने वाला SplitPairFilter बनाएं:
  Kotlin
  
  val splitPairFilter = SplitPairFilter( ComponentName(this, ListActivity::class.java), ComponentName(this, DetailActivity::class.java), null )
  Java
  
  SplitPairFilter splitPairFilter = new SplitPairFilter( new ComponentName(this, ListActivity.class), new ComponentName(this, DetailActivity.class), null );
2. किसी फ़िल्टर सेट में फ़िल्टर जोड़ना:
  Kotlin
  
  val filterSet = setOf(splitPairFilter)
  Java
  
  Set<SplitPairFilter> filterSet = new HashSet<>(); filterSet.add(splitPairFilter);
3. बांटने के लिए लेआउट एट्रिब्यूट बनाएं:
  Kotlin
  
  val splitAttributes: SplitAttributes = SplitAttributes.Builder() .setSplitType(SplitAttributes.SplitType.ratio(0.33f)) .setLayoutDirection(SplitAttributes.LayoutDirection.LEFT_TO_RIGHT) .build()
  Java
  
  final SplitAttributes splitAttributes = new SplitAttributes.Builder() .setSplitType(SplitAttributes.SplitType.ratio(0.33f)) .setLayoutDirection(SplitAttributes.LayoutDirection.LEFT_TO_RIGHT) .build();
  SplitAttributes.Builder एक ऑब्जेक्ट बनाता है, जिसमें लेआउट एट्रिब्यूट होते हैं:
  - setSplitType: इससे पता चलता है कि हर गतिविधि कंटेनर के लिए, डिसप्ले एरिया को किस तरह बांटा गया है. अनुपात के बंटवारे का टाइप, मुख्य कंटेनर को दिए गए डिसप्ले एरिया के उपलब्ध अनुपात के बारे में बताता है; सेकंडरी कंटेनर, डिसप्ले एरिया का बचा हुआ हिस्सा इस्तेमाल करता है.
  - setLayoutDirection: इससे पता चलता है कि गतिविधि कंटेनर को एक-दूसरे के मुकाबले किस तरह रखा जाता है, यानी प्राइमरी कंटेनर पहले से मौजूद होता है.
4. SplitPairRule बनाएं:
  Kotlin
  
  val splitPairRule = SplitPairRule.Builder(filterSet) .setDefaultSplitAttributes(splitAttributes) .setMinWidthDp(840) .setMinSmallestWidthDp(600) .setMaxAspectRatioInPortrait(EmbeddingAspectRatio.ratio(1.5f)) .setFinishPrimaryWithSecondary(SplitRule.FinishBehavior.NEVER) .setFinishSecondaryWithPrimary(SplitRule.FinishBehavior.ALWAYS) .setClearTop(false) .build()
  Java
  
  SplitPairRule splitPairRule = new SplitPairRule.Builder(filterSet) .setDefaultSplitAttributes(splitAttributes) .setMinWidthDp(840) .setMinSmallestWidthDp(600) .setMaxAspectRatioInPortrait(EmbeddingAspectRatio.ratio(1.5f)) .setFinishPrimaryWithSecondary(SplitRule.FinishBehavior.NEVER) .setFinishSecondaryWithPrimary(SplitRule.FinishBehavior.ALWAYS) .setClearTop(false) .build();
  SplitPairRule.Builder नियम बनाता और कॉन्फ़िगर करता है:
  - filterSet: इसमें स्प्लिट पेयर वाले फ़िल्टर होते हैं. इन फ़िल्टर से यह तय किया जाता है कि नियम को कब लागू करना है. इसके लिए, उन गतिविधियों की पहचान की जाती है जो स्प्लिट शेयर करती हैं.
  - setDefaultSplitAttributes: नियम पर लेआउट एट्रिब्यूट लागू करता है.
  - setMinWidthDp: डिसप्ले की सबसे कम चौड़ाई (डेंसिटी-इंडिपेंडेंट पिक्सल, dp में) सेट करता है, जिससे स्क्रीन को स्प्लिट किया जा सकता है.
  - setMinSmallestWidthDp: यह कम से कम वैल्यू (डीपी) सेट करता है, जो दो डिसप्ले डाइमेंशन में से छोटे डाइमेंशन को स्प्लिट करने के लिए ज़रूरी होती है. भले ही, डिवाइस ओरिएंटेशन कुछ भी हो.
  - setMaxAspectRatioInPortrait: इससे पोर्ट्रेट ओरिएंटेशन में, डिसप्ले का ज़्यादा से ज़्यादा आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) सेट किया जाता है. इसके लिए, गतिविधि के अनुपात दिखाए जाते हैं. अगर पोर्ट्रेट डिसप्ले का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात), ज़्यादा से ज़्यादा आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) से ज़्यादा होता है, तो डिसप्ले की चौड़ाई पर ध्यान दिए बिना स्प्लिट करने की सुविधा बंद हो जाती है. ध्यान दें: डिफ़ॉल्ट मान 1.4 है, जिसकी वजह से ज़्यादातर टैबलेट पर पोर्ट्रेट ओरिएंटेशन में गतिविधियां पूरी टास्क विंडो में रुक जाती हैं. SPLIT_MAX_ASPECT_RATIO_PORTRAIT_DEFAULT और setMaxAspectRatioInLandscape भी देखें. लैंडस्केप की डिफ़ॉल्ट वैल्यू ALWAYS_ALLOW है.
  - setFinishPrimaryWithSecondary: यह सेट करता है कि सेकंडरी कंटेनर में सभी गतिविधियों को पूरा करने से, प्राइमरी कंटेनर की गतिविधियों पर क्या असर पड़ता है. NEVER से पता चलता है कि सेकंडरी कंटेनर में मौजूद सभी गतिविधियां खत्म होने के बाद, सिस्टम को मुख्य गतिविधियां पूरी नहीं करनी चाहिए (गतिविधियां खत्म करना देखें).
  - setFinishSecondaryWithPrimary: यह सेट करता है कि प्राइमरी कंटेनर में सभी गतिविधियों को पूरा करने से, सेकंडरी कंटेनर की गतिविधियों पर क्या असर पड़ता है. ALWAYS से पता चलता है कि प्राइमरी कंटेनर की सभी गतिविधियां खत्म होने के बाद, सिस्टम को हमेशा सेकंडरी कंटेनर में की गई गतिविधियों को पूरा करना चाहिए (गतिविधियां खत्म करना देखें).
  - setClearTop: इससे पता चलता है कि कंटेनर में कोई नई गतिविधि लॉन्च होने पर, सेकंडरी कंटेनर की सभी गतिविधियां पूरी हो गई हैं या नहीं. 'गलत' से पता चलता है कि नई गतिविधियों को, सेकंडरी कंटेनर में पहले से मौजूद गतिविधियों के ऊपर स्टैक किया जाता है.
5. WindowManager RuleController का सिंगलटन इंस्टेंस पाएं और नियम जोड़ें:
  Kotlin
  
  val ruleController = RuleController.getInstance(this) ruleController.addRule(splitPairRule)
  Java
  
  RuleController ruleController = RuleController.getInstance(this); ruleController.addRule(splitPairRule);
जब कॉन्टेंट उपलब्ध न हो, तो सेकंडरी कंटेनर के लिए एक प्लेसहोल्डर बनाएं:
1. एक ActivityFilter बनाएं, जो उस गतिविधि की पहचान करे जिसके साथ प्लेसहोल्डर किसी टास्क विंडो को स्प्लिट करता है:
  Kotlin
  
  val placeholderActivityFilter = ActivityFilter( ComponentName(this, ListActivity::class.java), null )
  Java
  
  ActivityFilter placeholderActivityFilter = new ActivityFilter( new ComponentName(this, ListActivity.class), null );
2. किसी फ़िल्टर सेट में फ़िल्टर जोड़ना:
  Kotlin
  
  val placeholderActivityFilterSet = setOf(placeholderActivityFilter)
  Java
  
  Set<ActivityFilter> placeholderActivityFilterSet = new HashSet<>(); placeholderActivityFilterSet.add(placeholderActivityFilter);
3. कोई SplitPlaceholderRule बनाएं:
  Kotlin
  
  val splitPlaceholderRule = SplitPlaceholderRule.Builder( placeholderActivityFilterSet, Intent(context, PlaceholderActivity::class.java) ).setDefaultSplitAttributes(splitAttributes) .setMinWidthDp(840) .setMinSmallestWidthDp(600) .setMaxAspectRatioInPortrait(EmbeddingAspectRatio.ratio(1.5f)) .setFinishPrimaryWithPlaceholder(SplitRule.FinishBehavior.ALWAYS) .setSticky(false) .build()
  Java
  
  SplitPlaceholderRule splitPlaceholderRule = new SplitPlaceholderRule.Builder( placeholderActivityFilterSet, new Intent(context, PlaceholderActivity.class) ).setDefaultSplitAttributes(splitAttributes) .setMinWidthDp(840) .setMinSmallestWidthDp(600) .setMaxAspectRatioInPortrait(EmbeddingAspectRatio.ratio(1.5f)) .setFinishPrimaryWithPlaceholder(SplitRule.FinishBehavior.ALWAYS) .setSticky(false) .build();
  SplitPlaceholderRule.Builder नियम बनाता और कॉन्फ़िगर करता है:
  - placeholderActivityFilterSet: इसमें गतिविधि के ऐसे फ़िल्टर होते हैं जो यह तय करते हैं कि प्लेसहोल्डर गतिविधि से जुड़ी गतिविधियों की पहचान करके, नियम को कब लागू करना है.
  - Intent: इससे प्लेसहोल्डर गतिविधि के लॉन्च की जानकारी मिलती है.
  - setDefaultSplitAttributes: नियम पर लेआउट एट्रिब्यूट लागू करता है.
  - setMinWidthDp: स्प्लिट की सबसे कम चौड़ाई (डेंसिटी-इंडिपेंडेंट पिक्सल, डीपी) सेट करता है, जिससे स्क्रीन को स्प्लिट किया जा सकता है.
  - setMinSmallestWidthDp: यह विकल्प, सबसे कम वैल्यू (डीपी) को सेट करता है, जो दो डिसप्ले डाइमेंशन में से सबसे छोटी वैल्यू को बांटने के लिए ज़रूरी होती है. इस बात से कोई फ़र्क़ नहीं पड़ता कि डिवाइस ओरिएंटेशन कैसा है.
  - setMaxAspectRatioInPortrait: इससे पोर्ट्रेट ओरिएंटेशन में, डिसप्ले का ज़्यादा से ज़्यादा आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) सेट किया जाता है. इसके लिए, गतिविधि के अनुपात दिखाए जाते हैं. ध्यान दें: डिफ़ॉल्ट मान 1.4 है, जिसकी वजह से ज़्यादातर टैबलेट पर गतिविधियों की वजह से, टास्क विंडो पोर्ट्रेट ओरिएंटेशन में खुलती है. SPLIT_MAX_ASPECT_RATIO_PORTRAIT_DEFAULT औरsetMaxAspectRatioInLandscape भी देखें. लैंडस्केप की डिफ़ॉल्ट वैल्यू ALWAYS_ALLOW है.
  - setFinishPrimaryWithPlaceholder: सेट करता है कि प्लेसहोल्डर गतिविधि को पूरा करने से, प्राइमरी कंटेनर की गतिविधियों पर क्या असर पड़ता है. 'हमेशा' यह बताता है कि प्लेसहोल्डर के खत्म होने पर, सिस्टम को हमेशा प्राइमरी कंटेनर में गतिविधियों को पूरा करना चाहिए (गतिविधियां खत्म करना देखें).
  - setSticky: यह तय करता है कि छोटे डिसप्ले पर, गतिविधि स्टैक के सबसे ऊपर प्लेसहोल्डर गतिविधि दिखेगी या नहीं. ऐसा तब होगा, जब प्लेसहोल्डर कम से कम चौड़ाई के हिसाब से बांटा गया हो.
4. WindowManager RuleController में नियम जोड़ें:
  Kotlin
  
  ruleController.addRule(splitPlaceholderRule)
  Java
  
  ruleController.addRule(splitPlaceholderRule);
  ध्यान दें: RuleController को पिछले नियम के लिए इंस्टैंशिएट किया गया था.
उन गतिविधियों के बारे में बताएं जिन्हें कभी भी बंटवारे का हिस्सा नहीं होना चाहिए:
1. ऐसा ActivityFilter बनाएं जो ऐसी गतिविधि की पहचान करे जो हमेशा टास्क के पूरे डिसप्ले एरिया में जगह ले रही हो:
  Kotlin
  
  val expandedActivityFilter = ActivityFilter( ComponentName(this, ExpandedActivity::class.java), null )
  Java
  
  ActivityFilter expandedActivityFilter = new ActivityFilter( new ComponentName(this, ExpandedActivity.class), null );
2. किसी फ़िल्टर सेट में फ़िल्टर जोड़ना:
  Kotlin
  
  val expandedActivityFilterSet = setOf(expandedActivityFilter)
  Java
  
  Set<ActivityFilter> expandedActivityFilterSet = new HashSet<>(); expandedActivityFilterSet.add(expandedActivityFilter);
3. कोई ActivityRule बनाएं:
  Kotlin
  
  val activityRule = ActivityRule.Builder(expandedActivityFilterSet) .setAlwaysExpand(true) .build()
  Java
  
  ActivityRule activityRule = new ActivityRule.Builder( expandedActivityFilterSet ).setAlwaysExpand(true) .build();
  ActivityRule.Builder नियम बनाता और कॉन्फ़िगर करता है:
  - expandedActivityFilterSet: इसमें गतिविधि वाले फ़िल्टर होते हैं. इनसे यह तय किया जाता है कि नियम को कब लागू करना है. इसके लिए, उन गतिविधियों की पहचान की जाती है जिन्हें आपको स्प्लिट से बाहर रखना है.
  - setAlwaysExpand: इससे पता चलता है कि गतिविधि को पूरी टास्क विंडो में पूरा करना है या नहीं.
4. WindowManager RuleController में नियम जोड़ें:
  Kotlin
  
  ruleController.addRule(activityRule)
  Java
  
  ruleController.addRule(activityRule);
  ध्यान दें: RuleController को पहले इंस्टैंशिएट किया गया था.

अलग-अलग ऐप्लिकेशन पर एम्बेड करना

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

उदाहरण के लिए, सेटिंग ऐप्लिकेशन, वॉलपेपर पिकर ऐप्लिकेशन से वॉलपेपर चुनने की गतिविधि को एम्बेड कर सकता है:

**14वीं इमेज.** सेटिंग ऐप्लिकेशन (बाईं ओर मौजूद मेन्यू). इसमें, एम्बेड की गई गतिविधि (दाएं) के तौर पर वॉलपेपर चुनने का विकल्प मौजूद है.

ट्रस्ट मॉडल

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

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

भरोसेमंद होस्ट

अन्य ऐप्लिकेशन को अपने ऐप्लिकेशन की गतिविधियों को एम्बेड करने और पूरी तरह से कंट्रोल करने की अनुमति देने के लिए, अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल के <activity> या <application> एलिमेंट के android:knownActivityEmbeddingCerts एट्रिब्यूट में होस्ट ऐप्लिकेशन का SHA-256 सर्टिफ़िकेट तय करें.

android:knownActivityEmbeddingCerts की वैल्यू को किसी स्ट्रिंग के तौर पर सेट करें:

<activity
    android:name=".MyEmbeddableActivity"
    android:knownActivityEmbeddingCerts="@string/known_host_certificate_digest"
    ... />

या, एक से ज़्यादा सर्टिफ़िकेट तय करने के लिए, स्ट्रिंग का कलेक्शन:

<activity
    android:name=".MyEmbeddableActivity"
    android:knownActivityEmbeddingCerts="@array/known_host_certificate_digests"
    ... />

जो नीचे दिए गए संसाधन का संदर्भ देता है:

<resources>
    <string-array name="known_host_certificate_digests">
      <item>cert1</item>
      <item>cert2</item>
      ...
    </string-array>
</resources>

ऐप्लिकेशन के मालिक Gradle signingReport टास्क चलाकर, SHA सर्टिफ़िकेट का ब्यौरा पा सकते हैं. सर्टिफ़िकेट डाइजेस्ट, SHA-256 फ़िंगरप्रिंट है, जिसमें कोलन को अलग नहीं किया जाता है. ज़्यादा जानकारी के लिए, हस्ताक्षर रिपोर्ट चलाना और अपने क्लाइंट की पुष्टि करना लेख पढ़ें.

गैर-भरोसेमंद होस्ट

किसी भी ऐप्लिकेशन को अपने ऐप्लिकेशन की गतिविधियों को एम्बेड करने और उनके प्रज़ेंटेशन को कंट्रोल करने की अनुमति देने के लिए, ऐप्लिकेशन मेनिफ़ेस्ट में <activity> या <application> एलिमेंट में android:allowUntrustedActivityEmbedding एट्रिब्यूट के बारे में बताएं, उदाहरण के लिए:

<activity
    android:name=".MyEmbeddableActivity"
    android:allowUntrustedActivityEmbedding="true"
    ... />

एट्रिब्यूट की डिफ़ॉल्ट वैल्यू 'गलत' है. यह क्रॉस-ऐप्लिकेशन गतिविधि को एम्बेड करने से रोकता है.

पसंद के मुताबिक पुष्टि

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

यह देखने के लिए कि कोई होस्ट आपकी गतिविधि को एम्बेड कर रहा है या नहीं, Jetpack WindowManager लाइब्रेरी के ActivityEmbeddingController#isActivityEmbedded() तरीके का इस्तेमाल करें. उदाहरण के लिए:

Kotlin

fun isActivityEmbedded(activity: Activity): Boolean {
    return ActivityEmbeddingController.getInstance(this).isActivityEmbedded(activity)
}

Java

boolean isActivityEmbedded(Activity activity) {
    return ActivityEmbeddingController.getInstance(this).isActivityEmbedded(activity);
}

कम से कम साइज़ की पाबंदी

Android सिस्टम, एम्बेड की गई गतिविधियों के लिए ऐप्लिकेशन मेनिफ़ेस्ट <layout> एलिमेंट में बताई गई कम से कम ऊंचाई और चौड़ाई लागू करता है. अगर कोई ऐप्लिकेशन कम से कम ऊंचाई और चौड़ाई की जानकारी नहीं देता है, तो सिस्टम के डिफ़ॉल्ट मान (sw220dp) लागू होते हैं.

अगर होस्ट, एम्बेड किए गए कंटेनर का साइज़ बदलकर, सबसे कम साइज़ में करने की कोशिश करता है, तो एम्बेड किया गया कंटेनर, सभी टास्क की सीमाओं में शामिल हो जाता है.

<गतिविधि-उपनाम>

<activity-alias> एलिमेंट के साथ काम करने के लिए, भरोसेमंद या गैर-भरोसेमंद गतिविधि को एम्बेड करने के लिए, android:knownActivityEmbeddingCerts या android:allowUntrustedActivityEmbedding को उपनाम के बजाय टारगेट गतिविधि पर लागू करना चाहिए. सिस्टम सर्वर पर सुरक्षा की पुष्टि करने वाली नीति, टारगेट पर सेट किए गए फ़्लैग पर आधारित होती है, दूसरे नाम पर नहीं.

होस्ट ऐप्लिकेशन

होस्ट ऐप्लिकेशन, क्रॉस-ऐप्लिकेशन गतिविधि को एम्बेड करने की प्रोसेस को वैसे ही लागू करते हैं जैसे वे सिंगल-ऐप्लिकेशन गतिविधि एम्बेड करने की सुविधा लागू करते हैं. SplitPairRule और SplitPairFilter या ActivityRule और ActivityFilter ऑब्जेक्ट, एम्बेड की गई गतिविधियों और टास्क विंडो के बंटवारे के बारे में बताते हैं. बांटने के नियम एक्सएमएल में स्टैटिक तरीके से या Jetpack WindowManager एपीआई कॉल का इस्तेमाल करके, रनटाइम के दौरान तय किए जाते हैं.

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

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

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

बांटने के उदाहरण

फ़ुल विंडो से स्प्लिट करें

**15वीं इमेज.** गतिविधि A, गतिविधि B को एक तरफ़ शुरू करती है.

किसी भी रीफ़ैक्टरिंग की ज़रूरत नहीं है. स्प्लिट के लिए कॉन्फ़िगरेशन तय किया जा सकता है स्टैटिक तरीके से या रनटाइम पर कॉल करें और फिर कॉल करें Context#startActivity() बिना किसी अतिरिक्त पैरामीटर के.

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

डिफ़ॉल्ट रूप से बांटें

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

प्लेसहोल्डर के साथ स्प्लिट करने के लिए, प्लेसहोल्डर बनाएं और उसे जोड़ें इसमें इन्हें शामिल किया जा सकता है:

<SplitPlaceholderRule
    window:placeholderActivityName=".PlaceholderActivity">
    <ActivityFilter
        window:activityName=".MainActivity"/>
</SplitPlaceholderRule>

डीप लिंक स्प्लिट

जब किसी ऐप्लिकेशन को कोई इंटेंट मिलता है, तो टारगेट की गई गतिविधि को इस तरह दिखाया जा सकता है: गतिविधि के बंटवारे का दूसरा हिस्सा; उदाहरण के लिए, किसी सूची में मौजूद किसी आइटम के बारे में जानकारी दिखाने वाली स्क्रीन. छोटे डिसप्ले पर, टास्क की पूरी विंडो में जानकारी दिखाई गई है; बड़ा डिवाइसों पर लागू होगा.

**17वीं इमेज.** डीप लिंक की ज़्यादा जानकारी वाली गतिविधि को छोटी स्क्रीन पर अकेले दिखाया गया हो, साथ ही, बड़ी स्क्रीन पर सूची गतिविधि भी देखी जा सकती है.

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

Kotlin

override fun onCreate(savedInstanceState Bundle?) {
    . . .
    RuleController.getInstance(this)
        .addRule(SplitPairRule.Builder(filterSet).build())
    startActivity(Intent(this, DetailActivity::class.java))
}

Java

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    . . .
    RuleController.getInstance(this)
        .addRule(new SplitPairRule.Builder(filterSet).build());
    startActivity(new Intent(this, DetailActivity.class));
}

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

बड़ा डिसप्ले, जिसमें सूची में की गई गतिविधि और ज़्यादा जानकारी वाली गतिविधि साथ-साथ मौजूद है.
वापस जाने वाला नेविगेशन, ज़्यादा जानकारी वाली गतिविधि को खारिज नहीं कर सका और सूची नहीं छोड़ सका
गतिविधि दिखाई जाती है.

सिर्फ़ ज़्यादा जानकारी वाली गतिविधि वाला छोटा डिसप्ले. वापस जाने वाला नेविगेशन चालू नहीं किया जा सका
ज़्यादा जानकारी वाली गतिविधि को खारिज करें और सूची की गतिविधि दिखाएं.

इसके बजाय, आप finishPrimaryWithSecondary एट्रिब्यूट:

<SplitPairRule
    window:finishPrimaryWithSecondary="always">
    <SplitPairFilter
        window:primaryActivityName=".ListActivity"
        window:secondaryActivityName=".DetailActivity"/>
</SplitPairRule>

नीचे कॉन्फ़िगरेशन एट्रिब्यूट देखें.

स्प्लिट कंटेनर में कई गतिविधियां

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

**18वीं इमेज.** गतिविधि को, इसके दूसरे पैनल में खोला गया टास्क विंडो पर क्लिक करें.

Kotlin

class DetailActivity {
    . . .
    fun onOpenSubDetail() {
      startActivity(Intent(this, SubDetailActivity::class.java))
    }
}

Java

public class DetailActivity {
    . . .
    void onOpenSubDetail() {
        startActivity(new Intent(this, SubDetailActivity.class));
    }
}

उप-जानकारी गतिविधि को ब्यौरे वाली गतिविधि के ऊपर रखा जाता है, जिसमें यह छिपी हुई होती है:

इसके बाद, उपयोगकर्ता वापस नेविगेट करके जानकारी के पिछले लेवल पर जा सकता है की मदद से:

**19 इमेज.** गतिविधि को स्टैक के सबसे ऊपरी हिस्से से हटाया गया.

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

नए टास्क में की जाने वाली गतिविधियां

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

**इमेज 20.** गतिविधि B से नए टास्क में गतिविधि C शुरू करें.

ऐक्टिविटी बदलना

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

**इमेज 21.** मुख्य पैनल में टॉप लेवल नेविगेशन गतिविधि दूसरे पैनल में डेस्टिनेशन गतिविधियों को बदलता है.

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

ऐसे मामलों में, स्क्रीन A को पिछली गतिविधियों से हटाना ज़रूरी है.

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

<SplitPairRule
    window:clearTop="true">
    <SplitPairFilter
        window:primaryActivityName=".Menu"
        window:secondaryActivityName=".ScreenA"/>
    <SplitPairFilter
        window:primaryActivityName=".Menu"
        window:secondaryActivityName=".ScreenB"/>
</SplitPairRule>

Kotlin

class MenuActivity {
    . . .
    fun onMenuItemSelected(selectedMenuItem: Int) {
        startActivity(Intent(this, classForItem(selectedMenuItem)))
    }
}

Java

public class MenuActivity {
    . . .
    void onMenuItemSelected(int selectedMenuItem) {
        startActivity(new Intent(this, classForItem(selectedMenuItem)));
    }
}

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

एक से ज़्यादा स्प्लिट

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

जब किसी सेकंडरी कंटेनर में कोई गतिविधि, किसी नई गतिविधि को साइड में लॉन्च करती है, मौजूदा स्प्लिट के ऊपर एक नया स्प्लिट बनाया जाता है.

**इमेज 22.** गतिविधि B, गतिविधि C को एक तरफ़ शुरू करती है.

पिछली गतिविधियों में, पहले खोली गई सभी गतिविधियां शामिल होती हैं. इसलिए, उपयोगकर्ता C होने के बाद, A/B स्प्लिट पर जा सकते हैं.

स्टैक में A, B, और C गतिविधियां हैं. ये गतिविधियां
ऊपर से नीचे के क्रम में: C, B, A.

नया स्प्लिट बनाने के लिए, नई गतिविधि को मौजूदा हिस्से की साइड में लॉन्च करें दूसरा कंटेनर. A/B और B/C, दोनों के लिए कॉन्फ़िगरेशन बताएं विभाजित करता है और B से गतिविधि C को सामान्य रूप से लॉन्च करता है:

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
    <SplitPairFilter
        window:primaryActivityName=".B"
        window:secondaryActivityName=".C"/>
</SplitPairRule>

Kotlin

class B {
    . . .
    fun onOpenC() {
        startActivity(Intent(this, C::class.java))
    }
}

Java

public class B {
    . . .
    void onOpenC() {
        startActivity(new Intent(this, C.class));
    }
}

अलग-अलग स्थितियों में बदलाव पर प्रतिक्रिया दें

किसी ऐप्लिकेशन की अलग-अलग गतिविधियों में ऐसे यूज़र इंटरफ़ेस (यूआई) एलिमेंट हो सकते हैं जो एक जैसा परफ़ॉर्म करते हों फ़ंक्शन; उदाहरण के लिए, ऐसा कंट्रोल जो खाते वाली विंडो को खोलता है सेटिंग.

**23 इमेज.** एक जैसे फ़ंक्शन वाले यूज़र इंटरफ़ेस (यूआई) एलिमेंट वाली अलग-अलग गतिविधियां.

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

**24 इमेज.** गतिविधि स्प्लिट में डुप्लीकेट यूज़र इंटरफ़ेस (यूआई) एलिमेंट.

यह जानने के लिए कि गतिविधियों को कब बांटा गया है, SplitController.splitInfoList फ़्लो देखें या स्प्लिट स्टेटस में हुए बदलावों के बारे में जानने के लिए, लिसनर को SplitControllerCallbackAdapter के साथ रजिस्टर करें. फिर, अपने हिसाब से यूज़र इंटरफ़ेस (यूआई) में बदलाव करें:

Kotlin

val layout = layoutInflater.inflate(R.layout.activity_main, null)
val view = layout.findViewById<View>(R.id.infoButton)
lifecycleScope.launch {
    lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        splitController.splitInfoList(this@SplitDeviceActivity) // The activity instance.
            .collect { list ->
                view.visibility = if (list.isEmpty()) View.VISIBLE else View.GONE
            }
    }
}

Java

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    . . .
    new SplitControllerCallbackAdapter(SplitController.getInstance(this))
        .addSplitListener(
            this,
            Runnable::run,
            splitInfoList -> {
                View layout = getLayoutInflater().inflate(R.layout.activity_main, null);
                layout.findViewById(R.id.infoButton).setVisibility(
                    splitInfoList.isEmpty() ? View.VISIBLE : View.GONE);
            });
}

कोरूटीन को किसी भी लाइफ़साइकल स्थिति में लॉन्च किया जा सकता है. हालांकि, आम तौर पर संसाधनों को बचाने के लिए, उन्हें STARTED की स्थिति में लॉन्च किया जाता है. ज़्यादा जानकारी के लिए, लाइफ़साइकल अवेयर कॉम्पोनेंट के साथ Kotlin कोरूटीन इस्तेमाल करना लेख पढ़ें.

कॉलबैक किसी भी लाइफ़साइकल की स्थिति में किए जा सकते हैं. यह तब भी हो सकता है, जब कोई गतिविधि रोक दिया गया है. लिसनर आम तौर पर onStart() में और रजिस्टर होने चाहिए onStop() में अपंजीकृत किया गया.

फ़ुल-विंडो मोडल

कुछ गतिविधियां उपयोगकर्ताओं को ऐप्लिकेशन से इंटरैक्ट करने से तब तक रोकती हैं, जब तक तय की गई कार्रवाई की गई हो; उदाहरण के लिए, लॉगिन स्क्रीन पर होने वाली गतिविधि, नीति स्वीकार करने वाली स्क्रीन या गड़बड़ी का मैसेज दिखेगा. मोडल गतिविधियों पर रोक लगानी चाहिए स्प्लिट में दिखने से रोका जा सकता है.

विस्तार करें का उपयोग करके किसी गतिविधि को हमेशा टास्क विंडो भरने के लिए बाध्य किया जा सकता है कॉन्फ़िगरेशन:

<ActivityRule
    window:alwaysExpand="true">
    <ActivityFilter
        window:activityName=".FullWidthActivity"/>
</ActivityRule>

गतिविधियां पूरी करें

उपयोगकर्ता, स्प्लिट के दोनों ओर गतिविधियों को पूरा करने के लिए, स्क्रीन के किनारे:

**इमेज 25.** स्वाइप करने के जेस्चर से जुड़ी गतिविधि B.

**इमेज 26.** स्वाइप करने के जेस्चर का इस्तेमाल करने से जुड़ी गतिविधि A.

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

किसी कंटेनर में सभी गतिविधियों को पूरा करने का असर, विरोधी कंटेनर पर होने वाला असर, स्प्लिट कॉन्फ़िगरेशन पर निर्भर करता है.

कॉन्फ़िगरेशन एट्रिब्यूट

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

window:finishPrimaryWithSecondary — सेकंडरी कंटेनर में सभी गतिविधियों को पूरा करने से, प्राइमरी कंटेनर की गतिविधियों पर क्या असर पड़ता है
window:finishSecondaryWithPrimary — प्राइमरी कंटेनर में सभी गतिविधियों को पूरा करने से, सेकंडरी कंटेनर की गतिविधियों पर क्या असर पड़ता है

एट्रिब्यूट की ये वैल्यू हो सकती हैं:

always — जुड़े हुए कंटेनर की गतिविधियों को हमेशा पूरा करें
never — जुड़े हुए कंटेनर में गतिविधियों को कभी भी पूरा न करें
adjacent — जब दो कंटेनर एक-दूसरे के बगल में दिखाए जाते हैं, तब संबंधित कंटेनर में गतिविधियों को पूरा करें, न कि जब दो कंटेनर को स्टैक किया गया हो

उदाहरण के लिए:

<SplitPairRule
    <!-- Do not finish primary container activities when all secondary container activities finish. -->
    window:finishPrimaryWithSecondary="never"
    <!-- Finish secondary container activities when all primary container activities finish. -->
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

डिफ़ॉल्ट कॉन्फ़िगरेशन

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

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

गतिविधियों A और B को शामिल करें. A की प्रोसेस पूरी हुई और B को छोड़ दिया गया
पूरी विंडो को घेर लेते हैं.

गतिविधियों A और B को शामिल करें. B ख़त्म हो गया, A को छोड़ दिया
पूरी विंडो को घेर लेते हैं.

साथ मिलकर गतिविधियां पूरी करें

सेकंडरी कंटेनर में सभी गतिविधियां खत्म होने के बाद, मुख्य कंटेनर में होने वाली गतिविधियों को अपने-आप पूरा होने दें:

<SplitPairRule
    window:finishPrimaryWithSecondary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

गतिविधियों A और B को शामिल करें. B खत्म हो गया है, जो
टास्क विंडो को खाली छोड़कर, A पूरा करता है.

गतिविधियों A और B को शामिल करें. A खत्म हो गया है, B को अकेले छोड़ दिया है
पर क्लिक करें.

मुख्य कंटेनर की सभी गतिविधियां खत्म होने के बाद, दूसरे कंटेनर में होने वाली गतिविधियों को अपने-आप पूरा होने दें:

<SplitPairRule
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

गतिविधियों A और B को शामिल करें. A खत्म हो गया है, जो यह भी
टास्क विंडो को खाली छोड़कर, B पूरा हो जाता है.

गतिविधियों A और B को शामिल करें. B खत्म हो गया है, A को अकेला छोड़ रहे हैं
पर क्लिक करें.

मुख्य या दूसरे कंटेनर में से किसी एक की सभी गतिविधियां पूरी होने के बाद, गतिविधियों को एक साथ पूरा करें:

<SplitPairRule
    window:finishPrimaryWithSecondary="always"
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

कंटेनर में कई गतिविधियां खत्म करना

अगर स्प्लिट कंटेनर में कई गतिविधियां स्टैक की गई हैं, तो कोई गतिविधि पूरी होना जो स्टैक में नीचे मौजूद हैं, ऊपर की गतिविधियों को अपने-आप पूरा नहीं करते.

उदाहरण के लिए, अगर दो गतिविधियां सेकंडरी कंटेनर में हैं, तो B के ऊपर C:

सेकंडरी गतिविधि का स्टैक जिसमें B के ऊपर गतिविधि C स्टैक की गई है
डेटा को गतिविधि वाले प्राइमरी ऐक्टिविटी स्टैक के ऊपर स्टैक किया गया है
ए॰

और स्प्लिट का कॉन्फ़िगरेशन गतिविधि A और B:

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

टॉप गतिविधि को खत्म करने से स्प्लिट बरकरार रहता है.

प्राइमरी कंटेनर में गतिविधि A और गतिविधि B और C के साथ बांटें
सेकंडरी, B के ऊपर C रखा गया. C खत्म होता है, A और B को छोड़ दिया जाता है
गतिविधि का बंटवारा.

द्वितीयक कंटेनर की सबसे नीचे (रूट) गतिविधि खत्म करने से ऐसा नहीं होता उससे जुड़ी गतिविधियाँ हटा दें; और इसलिए, स्प्लिट भी बनाए रखता है.

प्राइमरी कंटेनर में गतिविधि A और गतिविधि B और C के साथ बांटें
सेकंडरी, B के ऊपर C रखा गया. B ख़त्म हो गया और A और C को छोड़ दिया
गतिविधि का बंटवारा.

गतिविधियों को एक साथ पूरा करने के लिए कोई अतिरिक्त नियम, जैसे कि फ़िनिश प्राथमिक के साथ द्वितीयक गतिविधि भी निष्पादित की जाती है:

<SplitPairRule
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

प्राइमरी कंटेनर में गतिविधि A और गतिविधि B और C के साथ बांटें
दूसरा कंटेनर, B के ऊपर C रखा गया. एक फ़िनिश, यह भी
B और C के आखिरी चरण पूरे कर लिए.

साथ ही, जब प्राइमरी और सेकंडरी स्कूल को एक साथ खत्म करने के लिए स्प्लिट किया गया हो:

<SplitPairRule
    window:finishPrimaryWithSecondary="always"
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

प्राइमरी कंटेनर में गतिविधि A और गतिविधि B और C के साथ बांटें
सेकंडरी, B के ऊपर C रखा गया. A फ़िनिश, B भी फ़िनिशिंग और
सी॰

रनटाइम के दौरान स्प्लिट प्रॉपर्टी बदलना

मौजूदा समय में चालू और दिख रहे स्प्लिट की प्रॉपर्टी बदली नहीं जा सकतीं. स्प्लिट करने के नियमों में बदलाव करने पर, अतिरिक्त गतिविधियों के लॉन्च और नई गतिविधियों पर असर पड़ता है कंटेनर हैं, लेकिन मौजूदा और ऐक्टिव स्प्लिट नहीं.

ऐक्टिव स्प्लिट की प्रॉपर्टी बदलने के लिए, साइड गतिविधि पूरी करें या अलग-अलग गतिविधियों को स्प्लिट करें और नए कॉन्फ़िगरेशन के साथ फिर से साइड में लॉन्च करें.

स्प्लिट से पूरी विंडो में किसी गतिविधि का डेटा निकालना

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

रनटाइम के दौरान, स्प्लिट सहायता की जांच करना

गतिविधि एम्बेड करने की सुविधा, Android 12L (एपीआई लेवल 32) और इसके बाद वाले वर्शन पर काम करती है. हालांकि, यह प्लैटफ़ॉर्म के पुराने वर्शन वाले कुछ डिवाइसों पर भी उपलब्ध है. रनटाइम पर सुविधा की उपलब्धता के बारे में जानने के लिए, SplitController.splitSupportStatus प्रॉपर्टी या SplitController.getSplitSupportStatus() तरीके का इस्तेमाल करें:

Kotlin

if (SplitController.getInstance(this).splitSupportStatus ==
     SplitController.SplitSupportStatus.SPLIT_AVAILABLE) {
     // Device supports split activity features.
}

Java

if (SplitController.getInstance(this).getSplitSupportStatus() ==
     SplitController.SplitSupportStatus.SPLIT_AVAILABLE) {
     // Device supports split activity features.
}

अगर स्प्लिट की सुविधा काम नहीं करती है, तो गतिविधि स्टैक के सबसे ऊपर गतिविधियों को लॉन्च किया जाता है. इसके लिए, बिना गतिविधि वाले एम्बेड करने वाले मॉडल का इस्तेमाल किया जाता है.

सिस्टम को ओवरराइड होने से रोकें

Android डिवाइसों के मैन्युफ़ैक्चरर (ओरिजनल इक्विपमेंट मैन्युफ़ैक्चरर या OEM), डिवाइस सिस्टम के फ़ंक्शन के रूप में गतिविधि एम्बेड करने की सुविधा लागू कर सकता है. कॉन्टेंट बनाने सिस्टम, मल्टी-ऐक्टिविटी ऐप्लिकेशन के लिए स्प्लिट नियम तय करता है. का व्यवहार भी शामिल है. सिस्टम, मल्टी-ऐक्टिविटी ऐप्लिकेशन को ज़बरदस्ती ओवरराइड करता है सिस्टम से तय की गई गतिविधि एम्बेड करने वाला मोड.

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

प्रॉपर्टी, ऐप्लिकेशन मेनिफ़ेस्ट फ़ाइल में, उदाहरण के लिए:

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application>
        <property
            android:name="android.window.PROPERTY_ACTIVITY_EMBEDDING_ALLOW_SYSTEM_OVERRIDE"
            android:value="true|false" />
    </application>
</manifest>

प्रॉपर्टी का नाम Jetpack WindowManager में बताया गया है WindowProperties ऑब्जेक्ट देते हैं. अगर आपका ऐप्लिकेशन गतिविधि एम्बेड करने की सुविधा लागू करता है या अगर आपfalse सिस्टम को, गतिविधि एम्बेड करने के नियम लागू करने से रोकना हो आपके ऐप्लिकेशन को मिलता है. वैल्यू को true पर सेट करें, ताकि सिस्टम लागू कर सके आपके ऐप्लिकेशन में सिस्टम से तय की गई गतिविधि एम्बेड करना.

सीमाएं, पाबंदियां, और सावधानियां

टास्क का सिर्फ़ होस्ट ऐप्लिकेशन, जिसकी पहचान रूट के मालिक के तौर पर की गई हो टास्क में की गई गतिविधि के आधार पर, टास्क में अन्य गतिविधियों को व्यवस्थित कर सकते हैं और उन्हें एम्बेड कर सकते हैं. अगर एम्बेड करने और स्प्लिट करने की सुविधा वाली गतिविधियां किसी ऐसे टास्क में चलती हैं जो से लिंक है, तो वीडियो एम्बेड करने और स्प्लिट करने की सुविधा ट्रैक करने में मदद मिलती है.
गतिविधियों को सिर्फ़ एक टास्क में व्यवस्थित किया जा सकता है. कोई गतिविधि लॉन्च करना में वह हमेशा एक नई विस्तृत विंडो में होता है. मौजूदा स्प्लिट.
एक ही प्रोसेस में होने वाली गतिविधियों को ही व्यवस्थित किया जा सकता है और उन्हें अलग-अलग हिस्सों में बांटा जा सकता है. कॉन्टेंट बनाने SplitInfo कॉलबैक सिर्फ़ एक जैसी प्रोसेस से जुड़ी गतिविधियों की रिपोर्ट देता है, अलग-अलग प्रोसेस में होने वाली गतिविधियों के बारे में जानने का कोई तरीका नहीं है.
गतिविधि के हर जोड़े या एक बार में होने वाली गतिविधि का नियम, सिर्फ़ उन गतिविधियों पर लागू होता है जिनमें ऐसा नियम के रजिस्टर होने के बाद होता है. फ़िलहाल, ऐसा कोई तरीका नहीं है मौजूदा स्प्लिट या उनकी विज़ुअल प्रॉपर्टी को अपडेट करें.
स्प्लिट पेयर के हिसाब से फ़िल्टर कॉन्फ़िगरेशन तब इस्तेमाल किए जाने वाले इंटेंट से मेल खाना चाहिए, जब गतिविधियों को पूरी तरह लॉन्च करना. मिलान उस समय होता है जब कोई नया ऐक्टिविटी, आवेदन की प्रक्रिया से शुरू होती है. इसलिए, हो सकता है कि उसे इसके बारे में पता न हो कॉम्पोनेंट के नाम जिन्हें सिस्टम प्रोसेस में, बाद में इस्तेमाल करते समय रिज़ॉल्व किया जाता है इंप्लिसिट इंटेंट. अगर लॉन्च के समय किसी कॉम्पोनेंट का नाम पता नहीं चल पाता है, तो इसके बजाय वाइल्डकार्ड (“*/*”) का इस्तेमाल किया जा सकता है. साथ ही, इंटेंट कार्रवाई के आधार पर.
वर्तमान में गतिविधियों को कंटेनर के बीच या अंदर और बाहर ले जाने का कोई तरीका नहीं है स्प्लिट बनाए गए. स्प्लिट सिर्फ़ इन्हें बना रहे हैं: मैच करने के नियमों वाली नई गतिविधियां लॉन्च होने पर, WindowManager लाइब्रेरी, और स्प्लिट तब खत्म हो जाते हैं, जब स्प्लिट कंटेनर में आखिरी गतिविधि होती है खत्म हुआ.
कॉन्फ़िगरेशन में बदलाव होने पर गतिविधियों को फिर से लॉन्च किया जा सकता है, इसलिए स्प्लिट होने पर बनाया या हटाया जाता है और गतिविधि की सीमाएं बदल जाती हैं, तो गतिविधि पहले वाले मामले को पूरी तरह खत्म करके और नया सवाल. इसलिए, ऐप्लिकेशन डेवलपर को इन चीज़ों को लेकर सावधान रहना चाहिए लाइफ़साइकल कॉलबैक से नई गतिविधियां लॉन्च करना.
गतिविधि एम्बेड करने की सुविधा के लिए, डिवाइसों में विंडो एक्सटेंशन इंटरफ़ेस होना ज़रूरी है. Android 12L (एपीआई लेवल 32) या उसके बाद के वर्शन पर काम करने वाले करीब सभी बड़ी स्क्रीन वाले डिवाइसों में इंटरफ़ेस शामिल होता है. हालांकि, बड़ी स्क्रीन वाले कुछ डिवाइस जिनमें कई गतिविधियां करने की सुविधा नहीं है उनमें विंडो एक्सटेंशन का इंटरफ़ेस शामिल नहीं होता है. अगर बड़ी स्क्रीन वाले डिवाइस पर मल्टी-विंडो मोड काम नहीं करता, तो हो सकता है कि उस पर गतिविधि एम्बेड करने की सुविधा काम न करती हो.

अन्य संसाधन

कोडलैब — गतिविधि एम्बेड करने और मटीरियल डिज़ाइन के साथ, सूची की जानकारी देने वाला लेआउट बनाएं
लर्निंग पाथवे — गतिविधि एम्बेड करना

{% endverba नया %}

आपके लिए सुझाव

ध्यान दें: JavaScript बंद होने पर लिंक टेक्स्ट दिखता है
गतिविधि एम्बेड करने और मटीरियल डिज़ाइन की मदद से, सूची की ज़्यादा जानकारी देने वाला लेआउट बनाना
डिवाइस के साथ काम करने वाला मोड
मल्टी-विंडो मोड काम करता है

{% verbatim %}