गतिविधि की स्थिति दिखाने वाले इंडिकेटर

प्रोग्रेस इंडिकेटर से किसी कार्रवाई की स्थिति का पता चलता है. वे मोशन का इस्तेमाल करके, उपयोगकर्ता का ध्यान इस बात पर खींचते हैं कि प्रोसेस पूरी होने में कितना समय बचा है. जैसे, डेटा लोड या प्रोसेस होने में कितना समय बचा है. इससे यह भी पता चलता है कि प्रोसेस जारी है. हालांकि, यह नहीं पता चलता कि प्रोसेस पूरी होने में कितना समय लगेगा.

प्रोग्रेस इंडिकेटर का इस्तेमाल करने के लिए, इन तीन उदाहरणों पर गौर करें:

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

मटीरियल डिज़ाइन में, प्रोग्रेस इंडिकेटर दो तरह के होते हैं:

  • तय: इससे पता चलता है कि कितनी प्रोग्रेस हुई है.
  • अनिश्चित: प्रोग्रेस की परवाह किए बिना लगातार ऐनिमेट होता है.

इसी तरह, प्रोग्रेस इंडिकेटर को इन दो में से किसी एक तरीके से दिखाया जा सकता है:

  • लीनियर: यह एक हॉरिज़ॉन्टल बार होता है, जो बाईं से दाईं ओर भरता है.
  • सर्कुलर: एक सर्कल, जिसका स्ट्रोक तब तक बढ़ता है, जब तक कि वह सर्कल की पूरी परिधि को कवर न कर ले.
लीनियर प्रोग्रेस इंडिकेटर के साथ सर्कुलर प्रोग्रेस इंडिकेटर.
पहली इमेज. प्रोग्रेस दिखाने वाले दो तरह के इंडिकेटर.

एपीआई सरफ़ेस

मटीरियल डिज़ाइन के मुताबिक प्रोग्रेस इंडिकेटर बनाने के लिए, कई कंपोज़ेबल का इस्तेमाल किया जा सकता है. हालांकि, उनके पैरामीटर में ज़्यादा अंतर नहीं होता. आपको इन मुख्य पैरामीटर का ध्यान रखना चाहिए:

  • progress: इंडिकेटर से दिखने वाली मौजूदा प्रोग्रेस. Float को 0.0 और 1.0 के बीच पास करें.
  • color: असल इंडिकेटर का रंग. यानी कि कॉम्पोनेंट का वह हिस्सा जो प्रोग्रेस दिखाता है और प्रोग्रेस पूरी होने पर कॉम्पोनेंट को पूरी तरह से कवर कर लेता है.
  • trackColor: उस ट्रैक का रंग जिस पर इंडिकेटर बनाया गया है.

M3 Expressive अपडेट

Material 3 Expressive में, स्टैंडर्ड फ़्लैट LinearProgressIndicator और CircularProgressIndicator के साथ-साथ, LinearWavyProgressIndicator और CircularWavyProgressIndicator को अतिरिक्त विकल्पों के तौर पर शामिल किया गया है. इन इंडिकेटर में राउंडेड स्टाइल के साथ-साथ, ट्रैक की ऊंचाई और वेव शेप के लिए कॉन्फ़िगरेशन की सुविधा होती है. अपने प्रॉडक्ट के हिसाब से सबसे सही विज़ुअल स्टाइल चुनें.

प्रोग्रेस इंडिकेटर के लिए, M3 एक्सप्रेसिव अपडेट के बारे में ज़्यादा जानने के लिए, मटीरियल डिज़ाइन 3 के प्रोग्रेस इंडिकेटर से जुड़े दिशा-निर्देश देखें.

दूसरी इमेज. मटीरियल 3 एक्सप्रेसिव प्रोग्रेस इंडिकेटर में, लहरदार शेप और ट्रैक की अलग-अलग ऊंचाई.

प्रोग्रेस इंडिकेटर, गोल और रंगीन स्टाइल में होते हैं. साथ ही, इनमें चुनने के लिए अतिरिक्त कॉन्फ़िगरेशन होते हैं. इनमें, लहरदार आकार और ट्रैक की अलग-अलग ऊंचाई शामिल है. ऐक्टिव इंडिकेटर के लिए दो शेप उपलब्ध हैं: वेवी और फ़्लैट.

वेवी

वेवी प्रोग्रेस इंडिकेटर, डिटरमिनेट और इंडिटरमिनेट, दोनों वैरिएंट में उपलब्ध हैं. साथ ही, वेव पैरामीटर की मदद से इनके लुक को पसंद के मुताबिक बनाया जा सकता है, ताकि विज़ुअल ज़्यादा बेहतर दिखें.

तीसरी इमेज. लहरदार प्रोग्रेस इंडिकेटर, जिनमें लहर के पैरामीटर को बेहतर तरीके से दिखाया गया है.

वेवी लीनियर इंडिकेटर, पूरे कंटेनर की ऊंचाई बढ़ाते हैं.

लहरदार प्रोग्रेस इंडिकेटर के दो वैरिएंट हैं: लीनियर और सर्कुलर.

लीनियर वेवी प्रोग्रेस इंडिकेटर

डिफ़ॉल्ट रूप से, वेवी प्रोग्रेस इंडिकेटर का इस्तेमाल करने पर, वेव स्पीड लागू होती है. इससे वेव मोशन लगातार बना रहता है. भले ही, डिटरमिनेट मोड चालू हो. इस वेव मोशन को बंद करने के लिए, 0.dp को waveSpeed पर सेट करें.

यहां दिए गए स्निपेट में, Slider से कंट्रोल किए जाने वाले LinearWavyProgressIndicator को लागू करने का तरीका बताया गया है:

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun LinearWavyProgressIndicatorSample() {
    val sliderState = rememberSliderState(0.1f)
    val animatedProgress by animateFloatAsState(
            targetValue = sliderState.value,
            animationSpec = ProgressIndicatorDefaults.ProgressAnimationSpec,
        )

    Column(horizontalAlignment = Alignment.CenterHorizontally) {
        LinearWavyProgressIndicator(progress = { animatedProgress })
        Spacer(Modifier.requiredHeight(30.dp))
        Text("Set progress:")
        Slider(
            state = sliderState,
            onValueChange = { sliderState.value = it },
            modifier = Modifier.width(300.dp),
        )
    }
}

लीनियर वेवी प्रोग्रेस इंडिकेटर, जिसमें प्रोग्रेस का प्रतिशत नहीं दिखता

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

@Composable
fun IndeterminateLinearWavyProgressIndicatorSample() {
    Column(horizontalAlignment = Alignment.CenterHorizontally) { LinearWavyProgressIndicator() }
}

लहरदार सर्कुलर प्रोग्रेस इंडिकेटर, जो गतिविधि की स्थिति दिखाता है

लहरदार आकार, लंबी प्रोसेस को कम स्टैटिक बना सकता है. इसका इस्तेमाल तब करना चाहिए, जब ज़्यादा एक्सप्रेसिव स्टाइल सही हो. यहां दिए गए स्निपेट में, Slider से कंट्रोल किए जाने वाले CircularWavyProgressIndicator को लागू करने का तरीका बताया गया है:

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CircularWavyProgressIndicatorSample() {
    val sliderState = rememberSliderState(0.1f)
    val animatedProgress by animateFloatAsState(
            targetValue = sliderState.value,
            animationSpec = ProgressIndicatorDefaults.ProgressAnimationSpec,
        )

    Column(horizontalAlignment = Alignment.CenterHorizontally) {
        CircularWavyProgressIndicator(progress = { animatedProgress })
        Spacer(Modifier.requiredHeight(30.dp))
        Text("Set progress:")
        Slider(
            state = sliderState,
            onValueChange = { sliderState.value = it },
            modifier = Modifier.width(300.dp),
        )
    }
}

लहरदार सर्कुलर प्रोग्रेस इंडिकेटर, जिसमें प्रोग्रेस का प्रतिशत नहीं दिखता

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

@Composable
fun IndeterminateCircularWavyProgressIndicatorSample() {
    Column(horizontalAlignment = Alignment.CenterHorizontally) { CircularWavyProgressIndicator() }
}

फ़्लैट

डिटरमिनेट इंडिकेटर

डिटरमिनेट इंडिकेटर से पता चलता है कि कोई कार्रवाई कितनी पूरी हुई है. LinearProgressIndicator या CircularProgressIndicator कंपोज़ेबल का इस्तेमाल करें और progress पैरामीटर के लिए कोई वैल्यू पास करें.

यहां दिए गए स्निपेट में, Slider से कंट्रोल किए जाने वाले LinearProgressIndicator को लागू करने का तरीका बताया गया है:

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun LinearProgressIndicatorSample() {
    val sliderState = rememberSliderState(0.1f)
    val animatedProgress by animateFloatAsState(
            targetValue = sliderState.value,
            animationSpec = ProgressIndicatorDefaults.ProgressAnimationSpec,
        )

    Column(horizontalAlignment = Alignment.CenterHorizontally) {
        LinearProgressIndicator(progress = { animatedProgress })
        Spacer(Modifier.requiredHeight(30.dp))
        Text("Set progress:")
        Slider(
            state = sliderState,
            onValueChange = { sliderState.value = it },
            modifier = Modifier.width(300.dp),
        )
    }
}

यहां दिए गए स्निपेट में, Slider से कंट्रोल किए जाने वाले CircularProgressIndicator को लागू करने का तरीका बताया गया है:

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CircularProgressIndicatorSample() {
    val sliderState = rememberSliderState(0.1f)
    val animatedProgress by animateFloatAsState(
            targetValue = sliderState.value,
            animationSpec = ProgressIndicatorDefaults.ProgressAnimationSpec,
        )

    Column(horizontalAlignment = Alignment.CenterHorizontally) {
        CircularProgressIndicator(progress = { animatedProgress })
        Spacer(Modifier.requiredHeight(30.dp))
        Text("Set progress:")
        Slider(
            state = sliderState,
            onValueChange = { sliderState.value = it },
            modifier = Modifier.width(300.dp),
        )
    }
}

यहां दिए गए स्निपेट में, ज़्यादा जानकारी वाला उदाहरण दिया गया है. जब उपयोगकर्ता बटन दबाता है, तो ऐप्लिकेशन उसे प्रोग्रेस इंडिकेटर से बदल देता है और एक कोरूटीन लॉन्च करता है. यह कोरूटीन, progress की वैल्यू को धीरे-धीरे बढ़ाता है. इससे प्रोग्रेस इंडिकेटर, एक-एक करके आगे बढ़ता है.

@Composable
fun LinearDeterminateIndicator() {
    var currentProgress by remember { mutableFloatStateOf(0f) }
    var loading by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope() // Create a coroutine scope
    // Animate between progress updates so the indicator fills smoothly.
    val animatedProgress by animateFloatAsState(
        targetValue = currentProgress,
        animationSpec = ProgressIndicatorDefaults.ProgressAnimationSpec,
    )

    if (loading) {
        LinearProgressIndicator(
            progress = { animatedProgress },
            modifier = Modifier.fillMaxWidth(),
        )
    } else {
        Button(onClick = {
            loading = true
            scope.launch {
                loadProgress { progress ->
                    currentProgress = progress
                }
                loading = false // Reset loading when the coroutine finishes
            }
        }) {
            Text("Start loading")
        }
    }
}

/** Iterate the progress value */
suspend fun loadProgress(updateProgress: (Float) -> Unit) {
    for (i in 1..100) {
        updateProgress(i.toFloat() / 100)
        delay(100)
    }
}

जब लोडिंग कुछ हद तक पूरी हो जाती है, तो पिछले उदाहरण में दिया गया लीनियर इंडिकेटर इस तरह दिखता है:

चौथी इमेज. लीनियर डिटरमिनेट प्रोग्रेस इंडिकेटर.

इसी तरह, सर्कुलर इंडिकेटर इस तरह दिखता है:

पांचवीं इमेज. सर्कुलर प्रोग्रेस इंडिकेटर.

अनिश्चित इंडिकेटर

अनिश्चित इंडिकेटर से यह पता नहीं चलता कि कोई कार्रवाई पूरी होने के कितने करीब है. इसके बजाय, यह मोशन का इस्तेमाल करके उपयोगकर्ता को बताता है कि प्रोसेस जारी है. हालांकि, यह नहीं बताता कि प्रोसेस कितनी पूरी हो चुकी है.

अनिश्चित प्रोग्रेस इंडिकेटर बनाने के लिए, LinearProgressIndicator या CircularProgressIndicator कंपोज़ेबल का इस्तेमाल करें. हालांकि, progress के लिए कोई वैल्यू पास न करें. यहां दिए गए स्निपेट में, अनिश्चित LinearProgressIndicator को लागू करने का तरीका बताया गया है:

@Composable
fun IndeterminateLinearProgressIndicatorSample() {
    Column(horizontalAlignment = Alignment.CenterHorizontally) { LinearProgressIndicator() }
}

यहां दिए गए स्निपेट में, अनिश्चित CircularProgressIndicator को लागू करने का तरीका बताया गया है:

@Composable
fun IndeterminateCircularProgressIndicatorSample() {
    Column(horizontalAlignment = Alignment.CenterHorizontally) { CircularProgressIndicator() }
}

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

@Composable
fun IndeterminateCircularIndicator() {
    var loading by remember { mutableStateOf(false) }

    if (loading) {
        CircularProgressIndicator(
            modifier = Modifier.size(64.dp),
            color = MaterialTheme.colorScheme.secondary,
            trackColor = MaterialTheme.colorScheme.surfaceVariant,
        )
    } else {
        Button(onClick = { loading = true }) {
            Text("Start loading")
        }
    }
}

इंडिकेटर चालू होने पर, इसे लागू करने का उदाहरण यहां दिया गया है:

छठी इमेज. गोल आकार का प्रोग्रेस इंडिकेटर, जिसमें प्रोग्रेस का प्रतिशत नहीं दिखता.

यहां उसी तरीके का एक उदाहरण दिया गया है, लेकिन इसमें CircularProgressIndicator के बजाय LinearProgressIndicator का इस्तेमाल किया गया है:

सातवीं इमेज. लीनियर प्रोग्रेस इंडिकेटर, जिसमें प्रोग्रेस का प्रतिशत नहीं दिखता.

अन्य संसाधन