हाल ही की स्क्रीन

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

हाल ही के ऐप्लिकेशन वाली स्क्रीन, दस्तावेज़ पर आधारित मॉडल का इस्तेमाल करती है. इसे Android 5.0 (एपीआई लेवल 21) में पेश किया गया था. इसमें अलग-अलग दस्तावेज़ों वाली एक ही ऐक्टिविटी के कई इंस्टेंस, हाल ही के ऐप्लिकेशन वाली स्क्रीन पर टास्क के तौर पर दिख सकते हैं. उदाहरण के लिए, Google Drive में कई Google दस्तावेज़ों के लिए एक टास्क हो सकता है. हर दस्तावेज़, 'हाल ही के आइटम' स्क्रीन पर एक टास्क के तौर पर दिखता है:

एक और सामान्य उदाहरण तब होता है, जब उपयोगकर्ता अपने ब्राउज़र का इस्तेमाल कर रहा हो और वह शेयर करें > Gmail पर टैप करता है. आपको Gmail ऐप्लिकेशन की लिखें स्क्रीन दिखेगी. उस समय, 'हाल ही के' बटन पर टैप करने से पता चलता है कि Chrome और Gmail अलग-अलग टास्क के तौर पर चल रहे हैं:

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

ActivityManager.AppTask क्लास की मदद से, टास्क मैनेज किए जा सकते हैं. साथ ही, Intent क्लास के ऐक्टिविटी फ़्लैग की मदद से, यह तय किया जा सकता है कि किसी ऐक्टिविटी को हाल ही के ऐप्लिकेशन वाली स्क्रीन में कब जोड़ा जाए या कब हटाया जाए. साथ ही, <activity> एट्रिब्यूट की मदद से, मेनिफ़ेस्ट में व्यवहार सेट किया जा सकता है.

'हाल ही के' स्क्रीन पर टास्क जोड़ना

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

टास्क जोड़ने के लिए, Intent फ़्लैग का इस्तेमाल करना

अपनी गतिविधि के लिए नया दस्तावेज़ बनाते समय, आपको startActivity() तरीके को कॉल करना होता है. साथ ही, गतिविधि लॉन्च करने वाले इंटेंट को पास करना होता है. लॉजिकल ब्रेक डालने के लिए, FLAG_ACTIVITY_NEW_DOCUMENT फ़्लैग को addFlags() तरीके से पास करें. इससे सिस्टम, आपकी गतिविधि को हाल ही के ऐप्लिकेशन वाली स्क्रीन पर एक नए टास्क के तौर पर दिखाएगा. यह फ़्लैग, गतिविधि लॉन्च करने वाले Intent तरीके में मौजूद होता है.

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

private fun newDocumentIntent(context: Context): Intent =
    Intent(context, NewDocumentActivity::class.java).apply {
        addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT or Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS)
        putExtra(KEY_EXTRA_NEW_DOCUMENT_COUNTER, documentCounter++)
    }

@Composable
fun CreateDocumentButton() {
    val context = LocalContext.current
    Button(
        onClick = {
            val intent = newDocumentIntent(context)
            // Add FLAG_ACTIVITY_MULTIPLE_TASK if needed based on state
            context.startActivity(intent)
        }
    ) {
        Text("Create New Document")
    }
}

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

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

class DocumentCentricActivity : ComponentActivity() {
    private var documentState by mutableStateOf(
        DocumentState(
            count = 0,
            textResId = R.string.hello_new_document_counter
        )
    )

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val initialCount = intent.getIntExtra(KEY_EXTRA_NEW_DOCUMENT_COUNTER, 0)

        documentState = documentState.copy(count = initialCount)

        setContent {
            MaterialTheme {
                DocumentScreen(
                    count = documentState.count,
                    textResId = documentState.textResId
                )
            }
        }
    }

    override fun onNewIntent(newIntent: Intent) {
        super.onNewIntent(newIntent)
        // If FLAG_ACTIVITY_MULTIPLE_TASK has not been used, this Activity is reused.
        documentState = documentState.copy(
            textResId = R.string.reusing_document_counter
        )
    }

    data class DocumentState(val count: Int, @StringRes val textResId: Int)

    companion object {
        const val KEY_EXTRA_NEW_DOCUMENT_COUNTER = "KEY_EXTRA_NEW_DOCUMENT_COUNTER"
    }
}

@Composable
fun DocumentScreen(count: Int, @StringRes textResId: Int) {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.Center
    ) {
        // UI reacts to whichever string resource ID was passed down
        Text(text = stringResource(id = textResId))
        Spacer(modifier = Modifier.height(8.dp))
        Text(text = "Counter: $count")
    }
}

ऊपर दिए गए कोड में, Activity, ओएस-लेवल की राउटिंग (onCreate और onNewIntent) को हैंडल करती है. वहीं, @Composable फ़ंक्शन, सिर्फ़ दी गई स्थिति के आधार पर यूज़र इंटरफ़ेस (यूआई) को रेंडर करने के लिए ज़िम्मेदार होता है.

टास्क जोड़ने के लिए, गतिविधि एट्रिब्यूट का इस्तेमाल करना

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

intoExisting

इस गतिविधि में, दस्तावेज़ के लिए किसी मौजूदा टास्क का फिर से इस्तेमाल किया जाता है. यह FLAG_ACTIVITY_MULTIPLE_TASK फ़्लैग सेट किए बिना FLAG_ACTIVITY_NEW_DOCUMENT फ़्लैग सेट करने जैसा ही है. इसके बारे में टास्क जोड़ने के लिए इंटेंट फ़्लैग का इस्तेमाल करना सेक्शन में बताया गया है.

always

इस गतिविधि से दस्तावेज़ के लिए एक नया टास्क बनता है. भले ही, दस्तावेज़ पहले से खुला हो. इस वैल्यू का इस्तेमाल करने का मतलब है कि आपने FLAG_ACTIVITY_NEW_DOCUMENT और FLAG_ACTIVITY_MULTIPLE_TASK, दोनों फ़्लैग सेट किए हैं.

none

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

never

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

कार्य निकालें

डिफ़ॉल्ट रूप से, किसी दस्तावेज़ पर की जा रही गतिविधि खत्म होने पर, वह 'हाल ही के' स्क्रीन से अपने-आप हट जाता है. ActivityManager.AppTask क्लास, Intent फ़्लैग या <activity> एट्रिब्यूट का इस्तेमाल करके, इस व्यवहार को बदला जा सकता है.

<activity> एट्रिब्यूट को true पर सेट करके, किसी टास्क को 'हाल ही के' स्क्रीन से हमेशा के लिए हटाया जा सकता है.android:excludeFromRecents

<activity> एट्रिब्यूट android:maxRecents को पूर्णांक वैल्यू पर सेट करके, यह तय किया जा सकता है कि आपका ऐप्लिकेशन, हाल ही के ऐप्लिकेशन वाली स्क्रीन पर ज़्यादा से ज़्यादा कितने टास्क दिखा सकता है. ज़्यादा से ज़्यादा टास्क जोड़ने पर, हाल ही में इस्तेमाल किए गए टास्क की सूची से सबसे पुराना टास्क हट जाता है. डिफ़ॉल्ट वैल्यू 16 होती है. ज़्यादा से ज़्यादा वैल्यू 50 होती है. हालांकि, कम मेमोरी वाले डिवाइसों पर यह वैल्यू 25 होती है. एक से कम वैल्यू मान्य नहीं हैं.

टास्क हटाने के लिए, AppTask क्लास का इस्तेमाल करना

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

@Composable
fun RemoveTaskButton() {
    val context = LocalContext.current
    Button(
        onClick = {
            // It is good practice to remove a document from the overview stack if not needed anymore.
            (context as? Activity)?.finishAndRemoveTask()
        }
    ) {
        Text("Remove from Recents")
    }
}

पूरे हो चुके टास्क सेव रखना

अगर आपको हाल ही में इस्तेमाल किए गए ऐप्लिकेशन की स्क्रीन पर किसी टास्क को बनाए रखना है, भले ही उसकी गतिविधि पूरी हो गई हो, तो गतिविधि लॉन्च करने वाले इंटेंट के addFlags() तरीके में FLAG_ACTIVITY_RETAIN_IN_RECENTS फ़्लैग पास करें.

private fun newDocumentIntent() =
        Intent(this, NewDocumentActivity::class.java).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT or
                    android.content.Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS)
            putExtra(KEY_EXTRA_NEW_DOCUMENT_COUNTER, getAndIncrement())
        }

इसी तरह का इफ़ेक्ट पाने के लिए, <activity> एट्रिब्यूट android:autoRemoveFromRecents को false पर सेट करें. दस्तावेज़ से जुड़ी गतिविधियों के लिए डिफ़ॉल्ट वैल्यू true होती है. वहीं, सामान्य गतिविधियों के लिए यह false होती है. इस एट्रिब्यूट का इस्तेमाल करने पर, FLAG_ACTIVITY_RETAIN_IN_RECENTS फ़्लैग की वैल्यू बदल जाती है.

हाल ही के यूआरएल शेयर करने की सुविधा चालू करें (सिर्फ़ Pixel के लिए)

Android 12 या इसके बाद के वर्शन वाले Pixel डिवाइसों पर, उपयोगकर्ता हाल ही में देखे गए वेब कॉन्टेंट के लिंक शेयर कर सकते हैं. इसके लिए, उन्हें सीधे तौर पर 'हाल ही के आइटम' स्क्रीन पर जाना होगा. किसी ऐप्लिकेशन में कॉन्टेंट देखने के बाद, उपयोगकर्ता हाल ही में इस्तेमाल किए गए ऐप्लिकेशन वाली स्क्रीन पर जाकर, उस ऐप्लिकेशन को ढूंढ सकता है जिसमें उसने कॉन्टेंट देखा था. इसके बाद, यूआरएल को कॉपी या शेयर करने के लिए, लिंक बटन पर टैप कर सकता है.

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

class MainActivity : ComponentActivity() {

    // Track the current URL as state so the UI can update it during navigation
    private var currentWebUri by mutableStateOf("https://example.com/home")

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            AppTheme {
                // Pass a lambda to your Compose UI so it can update the URL state
                // as the user navigates through your app.
                MainScreen(
                    onPageChanged = { newUrl -> currentWebUri = newUrl }
                )
            }
        }
    }

    override fun onProvideAssistContent(outContent: AssistContent) {
        super.onProvideAssistContent(outContent)

        // The system calls this when the user enters the Recents screen.
        // Provide the active URI tracked by the Compose state.
        outContent.webUri = Uri.parse(currentWebUri)
    }
}