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

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 या इसके बाद के वर्शन को टारगेट करने वाले ऐप्लिकेशन, ट्रैंपोलीन के तौर पर काम करने वाली सेवाओं या ब्रॉडकास्ट रिसीवर से गतिविधियां शुरू नहीं कर सकते. लैम्ब्डा से गतिविधियां शुरू करने के बजाय, GlanceAppWidget से गतिविधि शुरू करने के लिए, actionStartActivity कॉलबैक का इस्तेमाल करें.

उदाहरण के लिए, लैम्ब्डा फ़ंक्शन को GlanceModifier.clickable मॉडिफ़ायर में पास करें:

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

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

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

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

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

कार्रवाई पूरी होने के बाद विजेट को अपडेट करने के लिए, एक नया इंस्टेंस बनाएं और 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, उपयोगकर्ता के क्लिक को मैनेज करने और दिए गए ActionCallback के onRun तरीके को कॉल करने के लिए, कस्टम एसिंक BroadcastReceiver का इस्तेमाल करता है. इससे स्क्रिप्ट को एक्ज़ीक्यूट करने के लिए ज़्यादा समय मिलता है. हालांकि, इस पर कुछ पाबंदियां लागू होती हैं. ज़्यादा समय लेने वाले या मुश्किल टास्क को, उदाहरण के लिए, 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