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

टाइल के साथ इंटरैक्ट करें

टाइल सिर्फ़ जानकारी दिखाने के अलावा, इंटरैक्टिव भी हो सकती हैं. textButton() जैसे किसी एलिमेंट को टैप करने पर रिस्पॉन्स देने के लिए, clickable() का इस्तेमाल करके क्लिक हैंडलर जनरेट करें और उसे लेआउट एलिमेंट से जोड़ें.

किसी ऐक्शन को ट्रिगर करने के लिए, Clickable को दो मुख्य तरीकों से कॉन्फ़िगर किया जा सकता है:

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

ध्यान दें: सिस्टम, सुलभता के मकसद से हर Clickable एलिमेंट के आस-पास, कम से कम 48dp x 48dp का टैप किया जा सकने वाला एरिया अपने-आप बना देता है. अगर आपके पास एक से ज़्यादा इंटरैक्टिव एलिमेंट हैं, तो उनके बीच काफ़ी स्पेस रखें, ताकि उनके टच टारगेट ओवरलैप न हों. टाइल के लिए मेटारियल कॉम्पोनेंट पहले से ही इस दिशा-निर्देश का पालन करते हैं.

एक्सपोर्ट की गई गतिविधि लॉन्च करना

अगर उपयोगकर्ता के टैप करने पर, कोई गतिविधि तुरंत शुरू होनी चाहिए, तो launchAction() का इस्तेमाल करें. गतिविधि की पहचान करने के लिए, कोई ComponentName दें. गतिविधि को एक्सपोर्ट करना ज़रूरी है. इस तरीके से, कार्रवाई के साथ Intent एक्सट्रा पास किए जा सकते हैं. हालांकि, कस्टम Intent फ़्लैग सेट नहीं किए जा सकते.

इस उदाहरण में, name और age जैसे दो एक्सट्रा के साथ TileActivity को लॉन्च करने के लिए Clickable बनाने का तरीका बताया गया है:

textButton(
    labelContent = {
        text("launchAction()".layoutString, typography = BODY_LARGE)
    },
    onClick =
    clickable(
        action =
        launchAction(
            ComponentName(
                "com.example.wear",
                "com.example.wear.snippets.m3.tile.TileActivity",
            ),
            mapOf(
                "name" to ActionBuilders.stringExtra("Bartholomew"),
                "age" to ActionBuilders.intExtra(21),
            ),
        )
    ),
)Interaction.kt

लॉन्च की गई गतिविधि में, इंटेंट एक्सट्रा से वैल्यू पाएं:

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

    // When this activity is launched from the tile InteractionLaunchAction,
    // "name" will be "Bartholomew" and "age" will be 21
    val name = intent.getStringExtra("name")
    val age = intent.getStringExtra("age")

    // ...
}TileActivity.kt

अपनी टाइल सेवा में इंटरैक्शन मैनेज करना

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

टाइल का कॉन्टेंट रीफ़्रेश करना

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

textButton(
    onClick = clickable(loadAction()),
    labelContent = { text("Refresh".layoutString) },
)Interaction.kt

एक से ज़्यादा इंटरैक्टिव एलिमेंट के बीच अंतर करना

अगर आपकी टाइल में एक से ज़्यादा इंटरैक्टिव एलिमेंट हैं, तो Clickable मॉडिफ़ायर के साथ कोई आईडी जोड़ा जा सकता है:

textButton(
    labelContent = {
        text("Deep Link me!".layoutString, typography = BODY_LARGE)
    },
    onClick = clickable(id = "foo", action = loadAction()),
)Interaction.kt

onTileRequest() में जाकर, requestParams.currentState.lastClickableId का इस्तेमाल करके इस आईडी की जांच की जा सकती है. इससे यह तय किया जा सकता है कि कौनसी कार्रवाई की जाए.

उदाहरण: डीप लिंक की मदद से कोई गतिविधि शुरू करना

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

override fun onTileRequest(
    requestParams: RequestBuilders.TileRequest
): ListenableFuture<Tile?> {
    val lastClickableId = requestParams.currentState.lastClickableId
    if (lastClickableId == "foo") {
        TaskStackBuilder.create(this)
            .addNextIntentWithParentStack(
                Intent(
                    Intent.ACTION_VIEW,
                    "googleandroidsnippets://app/message_detail/1".toUri(),
                    this,
                    TileActivity::class.java,
                )
            )
            .startActivities()
    }
    // ... User didn't tap a button (either first load or tapped somewhere else)
    // ...
}
Interaction.kt

इसके बाद, TileActivity में, googleandroidsnippets://app/message_detail/{id} पैटर्न से मैच करने के लिए अपना नेविगेशन कॉन्फ़िगर करें.

AppScaffold {
    val navController = rememberSwipeDismissableNavController()
    SwipeDismissableNavHost(
        navController = navController,
        startDestination = "message_list",
    ) {
        // ...
        composable(
            route = "message_detail/{id}",
            deepLinks =
            listOf(
                navDeepLink {
                    uriPattern = "googleandroidsnippets://app/message_detail/{id}"
                }
            ),
        ) {
            val id = it.arguments?.getString("id") ?: "0"
            MessageDetails(details = "message $id")
        }
    }
}TileActivity.kt

उपयोगकर्ता को नेविगेशन का बेहतर अनुभव देने के लिए, TaskStackBuilder का इस्तेमाल करें. जब उपयोगकर्ता एलिमेंट पर टैप करता है, तो उसे सीधे डीप लिंक की गई स्क्रीन पर ले जाया जाता है. इस उदाहरण में, वह message_detail/1 स्क्रीन है. .addNextIntentWithParentStack() का इस्तेमाल करने की वजह से, पैरंट गतिविधि को भी बैक स्टैक में जोड़ दिया गया है. इसका मतलब है कि अगर उपयोगकर्ता पीछे की ओर स्वाइप करता है, तो वह टाइल से तुरंत बाहर निकलने के बजाय, ऐप्लिकेशन की मुख्य स्क्रीन पर जाएगा. उदाहरण के लिए, MessageList. दूसरी बार स्वाइप करने पर, उन्हें टाइल पर वापस ले जाया जाता है.

टाइल में स्टेटस अपडेट करना

आपकी टाइल में एक StateBuilders.State ऑब्जेक्ट होता है, जो की-वैल्यू पेयर को सेव करता है और रीलोड होने पर भी बना रहता है. जब कोई उपयोगकर्ता टाइल के साथ इंटरैक्ट करता है, तो इस स्थिति को अपडेट करने के लिए loadAction() का इस्तेमाल किया जा सकता है.

ऐसा करने के लिए, loadAction() में DynamicDataMap को पास करें. इसमें नई स्थिति की वैल्यू होनी चाहिए.

textButton(
    labelContent = {
        text("loadAction()".layoutString, typography = BODY_LARGE)
    },
    onClick =
    clickable(
        action =
        loadAction(
            dynamicDataMapOf(
                stringAppDataKey("name") mapTo "Javier",
                intAppDataKey("age") mapTo 37,
            )
        )
    ),
)Interaction.kt

जब इस कार्रवाई से onTileRequest() ट्रिगर होता है, तो requestParams.currentState.stateMap से अपडेट किया गया डेटा पढ़ा जा सकता है. यह उन इंटरैक्शन के लिए फ़ायदेमंद है जो टाइल पर मौजूद डेटा में सीधे तौर पर बदलाव करते हैं. जैसे, किसी काउंटर को बढ़ाना या किसी सेटिंग को टॉगल करना.

override fun onTileRequest(
    requestParams: RequestBuilders.TileRequest
): ListenableFuture<Tile> {

    // When triggered by loadAction(), "name" will be "Javier", and "age" will
    // be 37.
    with(requestParams.currentState.stateMap) {
        val name = this[stringAppDataKey("name")]
        val age = this[intAppDataKey("age")]
    }

    // ...
}Interaction.kt