तारीख चुनने वाले टूल

तारीख चुनने वाले टूल की मदद से, उपयोगकर्ता कोई तारीख, तारीख की सीमा या दोनों चुन सकते हैं. ये टूल, उपयोगकर्ताओं को तारीखें चुनने के लिए, कैलेंडर डायलॉग या टेक्स्ट इनपुट का इस्तेमाल करते हैं.

टाइप

तारीख चुनने वाले टूल तीन तरह के होते हैं:

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

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

  • DatePicker: तारीख चुनने वाले टूल के लिए सामान्य कंपोज़ेबल. आपके इस्तेमाल किए गए कंटेनर से यह तय होता है कि इसे डॉक किया गया है या यह मॉडल है.
  • DatePickerDialog: यह मोडल और मोडल इनपुट, दोनों तरह के तारीख चुनने वाले टूल के लिए कंटेनर है.
  • DateRangePicker: यह तारीख चुनने वाले किसी भी टूल के लिए इस्तेमाल किया जा सकता है. इसकी मदद से, उपयोगकर्ता शुरू और खत्म होने की तारीख चुनकर, तारीख की सीमा तय कर सकते हैं.

स्टेट

तारीख चुनने वाले अलग-अलग कंपोज़ेबल में, state एक अहम पैरामीटर होता है. यह DatePickerState या DateRangePickerState ऑब्जेक्ट लेता है. इनकी प्रॉपर्टी, तारीख चुनने वाले टूल का इस्तेमाल करके, उपयोगकर्ता के चुने गए विकल्प के बारे में जानकारी कैप्चर करती हैं. जैसे, चुनी गई मौजूदा तारीख.

चुनी गई तारीख का इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, चुनी गई तारीख का इस्तेमाल करना सेक्शन देखें.

डॉक किया गया तारीख चुनने वाला टूल

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

@Composable
fun DatePickerDocked() {
    var showDatePicker by remember { mutableStateOf(false) }
    val datePickerState = rememberDatePickerState()
    val selectedDate = datePickerState.selectedDateMillis?.let {
        convertMillisToDate(it)
    } ?: ""

    Box(
        modifier = Modifier.fillMaxWidth()
    ) {
        OutlinedTextField(
            value = selectedDate,
            onValueChange = { },
            label = { Text("DOB") },
            readOnly = true,
            trailingIcon = {
                IconButton(onClick = { showDatePicker = !showDatePicker }) {
                    Icon(
                        imageVector = Icons.Default.DateRange,
                        contentDescription = "Select date"
                    )
                }
            },
            modifier = Modifier
                .fillMaxWidth()
                .height(64.dp)
        )

        if (showDatePicker) {
            Popup(
                onDismissRequest = { showDatePicker = false },
                alignment = Alignment.TopStart
            ) {
                Box(
                    modifier = Modifier
                        .fillMaxWidth()
                        .offset(y = 64.dp)
                        .shadow(elevation = 4.dp)
                        .background(MaterialTheme.colorScheme.surface)
                        .padding(16.dp)
                ) {
                    DatePicker(
                        state = datePickerState,
                        showModeToggle = false
                    )
                }
            }
        }
    }
}

@Composable
fun DatePickerFieldToModal(modifier: Modifier = Modifier) {
    var selectedDate by remember { mutableStateOf<Long?>(null) }
    var showModal by remember { mutableStateOf(false) }

    OutlinedTextField(
        value = selectedDate?.let { convertMillisToDate(it) } ?: "",
        onValueChange = { },
        label = { Text("DOB") },
        placeholder = { Text("MM/DD/YYYY") },
        trailingIcon = {
            Icon(Icons.Default.DateRange, contentDescription = "Select date")
        },
        modifier = modifier
            .fillMaxWidth()
            .pointerInput(selectedDate) {
                awaitEachGesture {
                    // Modifier.clickable doesn't work for text fields, so we use Modifier.pointerInput
                    // in the Initial pass to observe events before the text field consumes them
                    // in the Main pass.
                    awaitFirstDown(pass = PointerEventPass.Initial)
                    val upEvent = waitForUpOrCancellation(pass = PointerEventPass.Initial)
                    if (upEvent != null) {
                        showModal = true
                    }
                }
            }
    )

    if (showModal) {
        DatePickerModal(
            onDateSelected = { selectedDate = it },
            onDismiss = { showModal = false }
        )
    }
}

fun convertMillisToDate(millis: Long): String {
    val formatter = SimpleDateFormat("MM/dd/yyyy", Locale.getDefault())
    return formatter.format(Date(millis))
}

कोड के बारे में अहम बातें

  • जब उपयोगकर्ता IconButton पर क्लिक करता है, तब तारीख चुनने वाला टूल दिखता है.
    • आइकॉन बटन, OutlinedTextField के trailingIcon पैरामीटर के लिए आर्ग्युमेंट के तौर पर काम करता है.
    • showDatePicker स्टेट वैरिएबल, डॉक किए गए तारीख चुनने वाले टूल की विज़िबिलिटी को कंट्रोल करता है.
  • तारीख चुनने वाले टूल का कंटेनर, Popup कंपोज़ेबल है. यह अन्य एलिमेंट के लेआउट पर असर डाले बिना, कॉन्टेंट पर ओवरले करता है.
  • selectedDate , DatePickerState ऑब्जेक्ट से चुनी गई तारीख की वैल्यू कैप्चर करता है और convertMillisToDate फ़ंक्शन का इस्तेमाल करके, उसे फ़ॉर्मैट करता है.
  • चुनी गई तारीख, टेक्स्ट फ़ील्ड में दिखती है.
  • offset मॉडिफ़ायर का इस्तेमाल करके, डॉक किए गए तारीख चुनने वाले टूल को टेक्स्ट फ़ील्ड के नीचे रखा जाता है.
  • टेक्स्ट फ़ील्ड और तारीख चुनने वाले टूल को सही तरीके से लेयर करने के लिए, Box को रूट कंटेनर के तौर पर इस्तेमाल किया जाता है.

नतीजे

कैलेंडर आइकॉन पर क्लिक करने के बाद, यह इस तरह दिखता है:

डॉक किए गए तारीख चुनने वाले टूल का उदाहरण.
पहली इमेज. डॉक किया गया तारीख चुनने वाला टूल.

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

@Composable
fun DatePickerModal(
    onDateSelected: (Long?) -> Unit,
    onDismiss: () -> Unit
) {
    val datePickerState = rememberDatePickerState()

    DatePickerDialog(
        onDismissRequest = onDismiss,
        confirmButton = {
            TextButton(onClick = {
                onDateSelected(datePickerState.selectedDateMillis)
                onDismiss()
            }) {
                Text("OK")
            }
        },
        dismissButton = {
            TextButton(onClick = onDismiss) {
                Text("Cancel")
            }
        }
    ) {
        DatePicker(state = datePickerState)
    }
}

  • DatePickerModal कंपोज़ेबल फ़ंक्शन, मोडल तारीख चुनने वाला टूल दिखाता है.
  • जब उपयोगकर्ता कोई तारीख चुनता है, तब onDateSelected लैम्डा एक्सप्रेशन लागू होता है.
    • यह चुनी गई तारीख को पैरंट कंपोज़ेबल में दिखाता है.
  • जब उपयोगकर्ता डायलॉग को खारिज करता है, तब onDismiss लैम्डा एक्सप्रेशन लागू होता है.

नतीजे

यह इस तरह दिखता है:

मोडल तारीख चुनने वाले टूल का उदाहरण.
दूसरी इमेज. मोडल तारीख चुनने वाला टूल.

इनपुट मोडल तारीख चुनने वाला टूल

इनपुट मोडल तारीख चुनने वाला टूल, स्क्रीन पर फ़्लोट करने वाला डायलॉग दिखाता है. इसकी मदद से, उपयोगकर्ता तारीख डाल सकता है.

@Composable
fun DatePickerModalInput(
    onDateSelected: (Long?) -> Unit,
    onDismiss: () -> Unit
) {
    val datePickerState = rememberDatePickerState(initialDisplayMode = DisplayMode.Input)

    DatePickerDialog(
        onDismissRequest = onDismiss,
        confirmButton = {
            TextButton(onClick = {
                onDateSelected(datePickerState.selectedDateMillis)
                onDismiss()
            }) {
                Text("OK")
            }
        },
        dismissButton = {
            TextButton(onClick = onDismiss) {
                Text("Cancel")
            }
        }
    ) {
        DatePicker(state = datePickerState)
    }
}

यह मोडल तारीख चुनने वाले टूल के उदाहरण जैसा ही है. इसमें मुख्य अंतर यह है:

  • initialDisplayMode पैरामीटर, शुरुआती डिसप्ले मोड को DisplayMode.Input पर सेट करता है.
इनपुट के साथ तारीख चुनने वाला मॉडल.
तीसरी इमेज. इनपुट मोडल तारीख चुनने वाला टूल.

तारीख की सीमा चुनने वाला टूल

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

DateRangePicker का इस्तेमाल, DatePicker के जैसा ही होता है. इसका इस्तेमाल, डॉक किए गए पिकर के लिए PopUp के चाइल्ड के तौर पर किया जा सकता है. इसके अलावा, इसे मोडल पिकर के तौर पर इस्तेमाल किया जा सकता है और DatePickerDialog को पास किया जा सकता है. इसमें मुख्य अंतर यह है कि आप DatePickerState के बजाय DateRangePickerState का इस्तेमाल करते हैं.

यहां दिए गए स्निपेट में, तारीख की सीमा चुनने वाला मोडल टूल बनाने का तरीका बताया गया है:

@Composable
fun DateRangePickerModal(
    onDateRangeSelected: (Pair<Long?, Long?>) -> Unit,
    onDismiss: () -> Unit
) {
    val dateRangePickerState = rememberDateRangePickerState()

    DatePickerDialog(
        onDismissRequest = onDismiss,
        confirmButton = {
            TextButton(
                onClick = {
                    onDateRangeSelected(
                        Pair(
                            dateRangePickerState.selectedStartDateMillis,
                            dateRangePickerState.selectedEndDateMillis
                        )
                    )
                    onDismiss()
                }
            ) {
                Text("OK")
            }
        },
        dismissButton = {
            TextButton(onClick = onDismiss) {
                Text("Cancel")
            }
        }
    ) {
        DateRangePicker(
            state = dateRangePickerState,
            title = {
                Text(
                    text = "Select date range"
                )
            },
            showModeToggle = false,
            modifier = Modifier
                .fillMaxWidth()
                .height(500.dp)
                .padding(16.dp)
        )
    }
}

कोड के बारे में अहम बातें

  • onDateRangeSelected पैरामीटर, एक कॉलबैक है. इसे Pair<Long?, Long?> मिलता है. यह चुनी गई शुरू और खत्म होने की तारीखों को दिखाता है. इससे पैरंट कंपोज़ेबल को चुनी गई सीमा का ऐक्सेस मिलता है.
  • rememberDateRangePickerState() तारीख की सीमा चुनने वाले टूल के लिए स्टेट बनाता है.
  • DatePickerDialog, मोडल डायलॉग कंटेनर बनाता है.
  • पुष्टि करने वाले बटन के onClick हैंडलर में, onDateRangeSelected, चुनी गई सीमा को पैरंट कंपोज़ेबल में पास करता है.
  • DateRangePicker कंपोज़ेबल, डायलॉग के कॉन्टेंट के तौर पर काम करता है.

नतीजे

यह इस तरह दिखता है:

मोडल रेंज के लिए तारीख चुनने वाले टूल का उदाहरण.
चौथी इमेज. चुनी गई सीमा के साथ, मोडल तारीख चुनने वाला टूल.

चुनी गई तारीख का इस्तेमाल करना

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

// ...
    var selectedDate by remember { mutableStateOf<Long?>(null) }
// ...
        if (selectedDate != null) {
            val date = Date(selectedDate!!)
            val formattedDate = SimpleDateFormat("MMM dd, yyyy", Locale.getDefault()).format(date)
            Text("Selected date: $formattedDate")
        } else {
            Text("No date selected")
        }
// ...
        DatePickerModal(
            onDateSelected = {
                selectedDate = it
                showModal = false
            },
            onDismiss = { showModal = false }
        )
    }
// ...

तारीख की सीमा चुनने वाले टूल के लिए भी यही तरीका लागू होता है. हालांकि, शुरू और खत्म होने की वैल्यू कैप्चर करने के लिए, range date pickers आपको use a Pair<Long?, Long?> या डेटा क्लास का इस्तेमाल करना होगा.

इन्हें भी देखें