यूज़र इंटरफ़ेस (यूआई) इवेंट

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

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

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

  • कारोबारी लॉजिक का मतलब है कि स्टेट में बदलाव होने पर क्या करना है. उदाहरण के लिए, पेमेंट करना या उपयोगकर्ता की प्राथमिकताएं सेव करना. आम तौर पर, डोमेन और डेटा लेयर इस लॉजिक को मैनेज करती हैं. इस गाइड में, Architecture Components ViewModel क्लास का इस्तेमाल, कारोबारी लॉजिक को मैनेज करने वाली क्लास के लिए, राय पर आधारित समाधान के तौर पर किया गया है.
  • यूज़र इंटरफ़ेस (यूआई) के व्यवहार का लॉजिक या यूज़र इंटरफ़ेस (यूआई) लॉजिक का मतलब है कि स्टेट में बदलावों को कैसे दिखाना है. उदाहरण के लिए, नेविगेशन लॉजिक या उपयोगकर्ता को मैसेज कैसे दिखाने हैं. यूज़र इंटरफ़ेस (यूआई) इस लॉजिक को मैनेज करता है.

यूज़र इंटरफ़ेस (यूआई) इवेंट का डिसीजन ट्री

नीचे दिए गए डायग्राम में, किसी खास इवेंट के इस्तेमाल के उदाहरण को मैनेज करने के लिए, सबसे सही तरीका ढूंढने का डिसीजन ट्री दिखाया गया है. इस गाइड के बाकी हिस्से में, इन तरीकों के बारे में विस्तार से बताया गया है.

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

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

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

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

@Composable
fun LatestNewsScreen(viewModel: LatestNewsViewModel = viewModel()) {

    // State of whether more details should be shown
    var expanded by remember { mutableStateOf(false) }

    Column {
        Text("Some text")
        if (expanded) {
            Text("More details")
        }

        Button(
        // The expand details event is processed by the UI that
        // modifies this composable's internal state.
        onClick = { expanded = !expanded }
        ) {
        val expandText = if (expanded) "Collapse" else "Expand"
        Text("$expandText details")
        }

        // The refresh event is processed by the ViewModel that is in charge
        // of the UI's business logic.
        Button(onClick = { viewModel.refreshNews() }) {
            Text("Refresh data")
        }
    }
}

लेज़ी लिस्ट में उपयोगकर्ता इवेंट

अगर कार्रवाई, यूज़र इंटरफ़ेस (यूआई) ट्री में नीचे की ओर होती है, जैसे कि LazyColumn आइटम में, तो उपयोगकर्ता इवेंट को मैनेज करने की ज़िम्मेदारी अब भी ViewModel की होती है.

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

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

data class MyItem(val id: Int)

@Composable
fun MyList(
    items: List<String>,
    onItemClick: (MyItem) -> Unit
) {
    Card {
        LazyColumn {
            itemsIndexed(items) { index, string ->
                ListItem(
                    modifier = Modifier.clickable {
                        onItemClick(MyItem(index))
                    },
                    headlineContent = {
                        Text(text = string)
                    }
                )
            }
        }
    }
}

इस तरीके में, MyList कंपोज़ेबल सिर्फ़ उस डेटा और उन इवेंट के साथ काम करता है जिन्हें वह दिखाता है. इसके पास ViewModel का ऐक्सेस नहीं होता. इवेंट को ऊपर ले जाकर, पिछले कंपोज़ेबल में ViewModel को पास किया जाता है.

इवेंट मैनेज करने के बारे में ज़्यादा जानने के लिए, Compose में इवेंट देखें.

उपयोगकर्ता इवेंट फ़ंक्शन और इवेंट हैंडलर के लिए नाम रखने के नियम

इस गाइड में, उपयोगकर्ता इवेंट को मैनेज करने वाले ViewModel फ़ंक्शन के नाम, उस कार्रवाई के आधार पर रखे जाते हैं जिसे वे मैनेज करते हैं. उदाहरण के लिए: validateInput() या login().

Compose में इवेंट हैंडलर, नाम रखने के स्टैंडर्ड नियम का पालन करते हैं, ताकि डेटा का फ़्लो साफ़ तौर पर दिखे:

  • पैरामीटर का नाम: on + Verb + Target (उदाहरण के लिए, onExpandClicked या onValueChange).
  • लैम्डा एक्सप्रेशन: कंपोज़ेबल को कॉल करते समय, लैम्डा अक्सर उस इवेंट को लागू करने का तरीका होता है.

ViewModel इवेंट मैनेज करना

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

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

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

data class LoginUiState(
    val isLoginInProgress: Boolean = false,
    val errorMessage: String? = null,
    val isUserLoggedIn: Boolean = false
)

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

class LoginViewModel : ViewModel() {

    var uiState by mutableStateOf(LoginUiState())

    fun tryLogin(username: String, password: String) {
        viewModelScope.launch {
            // Emit a new state indicating that login is in progress
            uiState = uiState.copy(isLoginInProgress = true)

            uiState = if (login(username, password)) {
                // Emit a new state indicating that login was successful
                uiState.copy(isLoginInProgress = false, isUserLoggedIn = true)
            } else {
                // Emit a new state with the error message
                LoginUiState(isLoginInProgress = false, errorMessage = "Login failed")
            }
        }
    }

    private suspend fun login(username: String, password: String): Boolean {
        delay(1000)
        return (username == "Hello" && password == "World!")
    }
}

@Composable
fun LoginScreen(viewModel: LoginViewModel, onSuccessfulLogin: () -> Unit) {

    val uiState = viewModel.uiState

    LaunchedEffect(uiState) {
        if (uiState.isUserLoggedIn) {
            onSuccessfulLogin()
        }
    }

    if (uiState.isLoginInProgress) {
        CircularProgressIndicator()
    } else {
        LoginForm(
            onLoginAttempt = { username, password ->
                viewModel.tryLogin(username, password)
            },
            errorMessage = uiState.errorMessage
        )
    }
}

इवेंट प्रोसेस करने से स्टेट अपडेट हो सकती हैं

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

// Models the UI state for the Latest news screen.
data class LatestNewsUiState(
    val news: List<News> = emptyList(),
    val isLoading: Boolean = false,
    val userMessage: String? = null
)

जब कारोबारी लॉजिक के लिए, उपयोगकर्ता को कुछ समय के लिए दिखने वाला नया मैसेज दिखाना ज़रूरी होता है, तो ViewModel, यूज़र इंटरफ़ेस (यूआई) स्टेट को इस तरह से अपडेट करेगा:

class LatestNewsViewModel(/* ... */) : ViewModel() {

    var uiState by mutableStateOf(LatestNewsUiState())
        private set

    fun refreshNews() {
        viewModelScope.launch {
            // If there isn't internet connection, show a new message on the screen.
            if (!internetConnection()) {
                uiState = uiState.copy(userMessage = "No Internet connection")
                return@launch
            }

            // Do something else.
        }
    }

    fun userMessageShown() {
        uiState = uiState.copy(userMessage = null)
    }
}

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

@Composable
fun LatestNewsScreen(
    snackbarHostState: SnackbarHostState,
    viewModel: LatestNewsViewModel = viewModel(),
) {
    // Rest of the UI content.

    // If there are user messages to show on the screen,
    // show it and notify the ViewModel.
    viewModel.uiState.userMessage?.let { userMessage ->
        LaunchedEffect(userMessage) {
            snackbarHostState.showSnackbar(userMessage)
            // Once the message is displayed and dismissed, notify the ViewModel.
            viewModel.userMessageShown()
        }
    }
}

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

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

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

@Composable
fun LoginScreen(
    onHelp: () -> Unit, // Caller navigates to the help screen
    viewModel: LoginViewModel = viewModel()
) {
    // Rest of the UI
    Button(
        onClick = dropUnlessResumed { onHelp() }
    ) {
        Text("Get help")
    }
}

dropUnlessResumed , Lifecycle लाइब्रेरी का हिस्सा है. इससे onHelp फ़ंक्शन सिर्फ़ तब चलाया जा सकता है, जब लाइफ़साइकल कम से कम RESUMED पर हो.

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

@Composable
fun LoginScreen(
    onUserLogIn: () -> Unit, // Caller navigates to the right screen
    viewModel: LoginViewModel = viewModel()
) {
    Button(
        onClick = {
            // ViewModel validation is triggered
            viewModel.tryLogin()
        }
    ) {
        Text("Log in")
    }
    // Rest of the UI

    val lifecycle = LocalLifecycleOwner.current.lifecycle
    val currentOnUserLogIn by rememberUpdatedState(onUserLogIn)
    LaunchedEffect(viewModel, lifecycle)  {
        // Whenever the uiState changes, check if the user is logged in and
        // call the `onUserLogin` event when `lifecycle` is at least STARTED
        snapshotFlow { viewModel.uiState }
            .filter { it.isUserLoggedIn }
            .flowWithLifecycle(lifecycle)
            .collect {
                currentOnUserLogIn()
            }
    }
}

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

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

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

class DobValidationViewModel(/* ... */) : ViewModel() {
    var uiState by mutableStateOf(DobValidationUiState())
        private set
}

@Composable
fun DobValidationScreen(
    onNavigateToNextScreen: () -> Unit, // Caller navigates to the right screen
    viewModel: DobValidationViewModel = viewModel()
) {
    // TextField that updates the ViewModel when a date of birth is selected

    var validationInProgress by rememberSaveable { mutableStateOf(false) }

    Button(
        onClick = {
            viewModel.validateInput()
            validationInProgress = true
        }
    ) {
        Text("Continue")
    }
    // Rest of the UI

    /*
        * The following code implements the requirement of advancing automatically
        * to the next screen when a valid date of birth has been introduced
        * and the user wanted to continue with the registration process.
        */

    if (validationInProgress) {
        val lifecycle = LocalLifecycleOwner.current.lifecycle
        val currentNavigateToNextScreen by rememberUpdatedState(onNavigateToNextScreen)
        LaunchedEffect(viewModel, lifecycle) {
            // If the date of birth is valid and the validation is in progress,
            // navigate to the next screen when `lifecycle` is at least STARTED,
            // which is the default Lifecycle.State for the `flowWithLifecycle` operator.
            snapshotFlow { viewModel.uiState }
                .filter { it.isDobValid }
                .flowWithLifecycle(lifecycle)
                .collect {
                    validationInProgress = false
                    currentNavigateToNextScreen()
                }
        }
    }
}

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

इस्तेमाल के अन्य उदाहरण

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

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

सैंपल

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

अन्य संसाधन

यूज़र इंटरफ़ेस (यूआई) इवेंट के बारे में ज़्यादा जानने के लिए, ये अन्य संसाधन देखें:

कोडलैब

दस्तावेज़

Views कॉन्टेंट