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

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

प्रकार

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

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

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

  • 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 lambda एक्सप्रेशन तब लागू होता है, जब उपयोगकर्ता किसी तारीख.
    • यह पैरंट कॉम्पोज़ेबल को चुनी गई तारीख दिखाता है.
  • onDismiss lambda एक्सप्रेशन तब लागू होता है, जब उपयोगकर्ता डायलॉग.

नतीजे

लागू होने पर यह ऐसा दिखता है:

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

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

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

@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 }
        )
    }
// ...

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

यह भी देखें: