उपयोगकर्ता के इंटरैक्शन मैनेज करना

Glance, Action क्लास का इस्तेमाल करके, उपयोगकर्ता के इंटरैक्शन को आसानी से मैनेज करता है. Glance की Action क्लास, उपयोगकर्ता की कार्रवाइयों को तय करती हैं. साथ ही, कार्रवाई के जवाब में की गई कार्रवाई को तय किया जा सकता है. GlanceModifier.clickable तरीके का इस्तेमाल करके, किसी भी कॉम्पोनेंट पर Action लागू किया जा सकता है.

ऐप्लिकेशन विजेट, रिमोट प्रोसेस पर काम करते हैं. इसलिए, कार्रवाइयों को बनाने के समय ही तय कर दिया जाता है. साथ ही, उन्हें रिमोट प्रोसेस में ही पूरा किया जाता है. नेटिव RemoteViews में, यह काम PendingIntents का इस्तेमाल करके किया जाता है.

इस पेज पर इन कार्रवाइयों के बारे में बताया गया है:

• कोई गतिविधि शुरू करना
• कोई सेवा लॉन्च करना
• ब्रॉडकास्ट इवेंट भेजना
• कॉलबैक चलाएं

ध्यान दें: कार्रवाइयों को मैनेज करने के तरीके का उदाहरण देखने के लिए, ActionAppWidget.kt देखें.

कोई गतिविधि लॉन्च करना

उपयोगकर्ता के इंटरैक्शन पर कोई गतिविधि शुरू करने के लिए, GlanceModifier.clickable मॉडिफ़ायर का इस्तेमाल करके, Button या अन्य कंपोज़ेबल को actionStartActivity फ़ंक्शन दें.

actionStartActivity में इनमें से कोई एक जानकारी दें:

• टारगेट गतिविधि क्लास
• ComponentName
• इंटेंट

Glance, कार्रवाई को दिए गए टारगेट और पैरामीटर के साथ PendingIntent में बदलता है. यहां दिए गए उदाहरण में, जब कोई उपयोगकर्ता बटन पर क्लिक करता है, तब NavigationActivity लॉन्च होता है:

@Composable
fun MyContent() {
    // ..
    Button(
        text = "Go Home",
        onClick = actionStartActivity<MyActivity>()
    )
}
GlanceSnippets.kt

कोई सेवा लॉन्च करना

किसी गतिविधि को लॉन्च करने की तरह ही, उपयोगकर्ता के इंटरैक्शन पर किसी सेवा को लॉन्च करें. इसके लिए, actionStartService में से किसी एक तरीके का इस्तेमाल करें.

actionStartService में इनमें से कोई एक जानकारी दें:

• टारगेट गतिविधि क्लास
• ComponentName
• इंटेंट

@Composable
fun MyButton() {
    // ..
    Button(
        text = "Sync",
        onClick = actionStartService<SyncService>(
            isForegroundService = true // define how the service is launched
        )
    )
}
GlanceSnippets.kt

ब्रॉडकास्ट इवेंट भेजना

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

actionSendBroadcast में इनमें से कोई एक जानकारी दें:

• स्ट्रिंग ऐक्शन
• ComponentName
• कोई इंटेंट
• BroadcastReceiver क्लास

@Composable
fun MyButton() {
    // ..
    Button(
        text = "Send",
        onClick = actionSendBroadcast<MyReceiver>()
    )
}
GlanceSnippets.kt

कस्टम कार्रवाइयां करना

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

lambda ऐक्शन चलाना

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

ध्यान दें: लैंबडा कॉलबैक, WorkManager वर्कर के कॉन्टेक्स्ट में चलते हैं. यह वर्कर, Service में चलता है. Android 12 या इसके बाद के वर्शन को टारगेट करने वाले ऐप्लिकेशन, ऐसी सेवाओं या ब्रॉडकास्ट रिसीवर से गतिविधियां शुरू नहीं कर सकते जो ट्रैम्पोलिन के तौर पर काम करते हैं. लैंबडा से गतिविधियां शुरू करने के बजाय, actionStartActivity कॉलबैक का इस्तेमाल करके, GlanceAppWidget से गतिविधि शुरू करें.

उदाहरण के लिए, lambda फ़ंक्शन को GlanceModifier.clickable modifier पर भेजें:

Text(
    text = "Submit",
    modifier = GlanceModifier.clickable {
        submitData()
    }
)
GlanceSnippets.kt

इसके अलावा, इसे उन कंपोज़ेबल पर onClick पैरामीटर को पास करें जिन पर यह काम करता है:

Button(
    text = "Submit",
    onClick = {
        submitData()
    }
)
GlanceSnippets.kt

Run ActionCallback

इसके अलावा, उपयोगकर्ता के इंटरैक्शन पर कार्रवाई करने के लिए, actionRunCallback तरीकों का इस्तेमाल करें. इसके लिए, ActionCallback को पसंद के मुताबिक लागू करें:

@Composable
private fun MyContent() {
    // ..
    Image(
        provider = ImageProvider(R.drawable.ic_hourglass_animated),
        modifier = GlanceModifier.clickable(
            onClick = actionRunCallback<RefreshAction>()
        ),
        contentDescription = "Refresh"
    )
}

class RefreshAction : ActionCallback {
    override suspend fun onAction(
        context: Context,
        glanceId: GlanceId,
        parameters: ActionParameters
    ) {
        // TODO implement
    }
}
GlanceSnippets.kt

उपयोगकर्ता के क्लिक करने पर, उपलब्ध कराए गए suspend onAction का ActionCallback तरीका कॉल किया जाता है. इससे तय किया गया लॉजिक (यानी, रीफ़्रेश डेटा का अनुरोध करना) लागू होता है.

कार्रवाई पूरी होने के बाद विजेट को अपडेट करने के लिए, एक नया इंस्टेंस बनाएं और update(..) को कॉल करें. ज़्यादा जानकारी के लिए, GlanceAppWidget की स्थिति मैनेज करना सेक्शन देखें.

class RefreshAction : ActionCallback {
    override suspend fun onAction(
        context: Context,
        glanceId: GlanceId,
        parameters: ActionParameters
    ) {
        // do some work but offset long-term tasks (e.g a Worker)
        MyAppWidget().update(context, glanceId)
    }
}
GlanceSnippets.kt

ध्यान दें: Glance, उपयोगकर्ता के क्लिक को मैनेज करने के लिए, कस्टम एसिंक BroadcastReceiver का इस्तेमाल करता है. साथ ही, दिए गए ActionCallback के onRun तरीके को कॉल करता है. इससे ज़्यादा समय तक कोड को चलाने की अनुमति मिलती है. हालांकि, कुछ पाबंदियां लागू होती हैं. लंबे समय तक चलने वाले या ज़्यादा समय लेने वाले किसी भी टास्क को, उदाहरण के लिए, Worker में ऑफ़सेट किया जाना चाहिए.

कार्रवाइयों के लिए पैरामीटर उपलब्ध कराना

किसी कार्रवाई के बारे में अतिरिक्त जानकारी देने के लिए, ActionParameters एपीआई का इस्तेमाल करके, टाइप किया गया की-वैल्यू पेयर बनाएं. उदाहरण के लिए, क्लिक किए गए डेस्टिनेशन को तय करने के लिए:

private val destinationKey = ActionParameters.Key<String>(
    NavigationActivity.KEY_DESTINATION
)

class MyAppWidget : GlanceAppWidget() {

    // ..

    @Composable
    private fun MyContent() {
        // ..
        Button(
            text = "Home",
            onClick = actionStartActivity<NavigationActivity>(
                actionParametersOf(destinationKey to "home")
            )
        )
        Button(
            text = "Work",
            onClick = actionStartActivity<NavigationActivity>(
                actionParametersOf(destinationKey to "work")
            )
        )
    }

    override suspend fun provideGlance(context: Context, id: GlanceId) {
        provideContent { MyContent() }
    }
}
GlanceSnippets.kt

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

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val destination = intent.extras?.getString(KEY_DESTINATION) ?: return
        // ...
    }
}
GlanceSnippets.kt

ये पैरामीटर, ActionCallback को भी दिए जाते हैं. वैल्यू पाने के लिए, तय की गई Parameters.Key का इस्तेमाल करें:

class RefreshAction : ActionCallback {

    private val destinationKey = ActionParameters.Key<String>(
        NavigationActivity.KEY_DESTINATION
    )

    override suspend fun onAction(
        context: Context,
        glanceId: GlanceId,
        parameters: ActionParameters
    ) {
        val destination: String = parameters[destinationKey] ?: return
        // ...
    }
}
GlanceSnippets.kt