สัญญาณบอกสถานะความคืบหน้า

สัญญาณบอกสถานะความคืบหน้าจะแสดงสถานะของการดำเนินการให้เห็นเป็นภาพ โดยใช้การเคลื่อนไหวเพื่อดึงดูดความสนใจของผู้ใช้ว่ากระบวนการใกล้จะเสร็จสมบูรณ์แล้ว เช่น การโหลดหรือการประมวลผลข้อมูล นอกจากนี้ยังสามารถใช้เพื่อแสดงว่ากำลังมีการประมวลผลอยู่ โดยไม่ระบุว่าใกล้จะเสร็จสมบูรณ์เพียงใด

พิจารณากรณีการใช้งาน 3 กรณีต่อไปนี้ที่คุณอาจใช้สัญญาณบอกสถานะความคืบหน้า

  • การโหลดเนื้อหา: ขณะดึงเนื้อหาจากเครือข่าย เช่น การโหลดรูปภาพหรือข้อมูลสำหรับโปรไฟล์ผู้ใช้
  • การอัปโหลดไฟล์: แจ้งให้ผู้ใช้ทราบว่าการอัปโหลดอาจใช้เวลานานเท่าใด
  • การประมวลผลที่ใช้เวลานาน: ขณะที่แอปประมวลผลข้อมูลจำนวนมาก ให้แจ้งให้ผู้ใช้ทราบว่าประมวลผลข้อมูลไปแล้วเท่าใดจากทั้งหมด

ใน Material Design มีสัญญาณบอกสถานะความคืบหน้า 2 ประเภท ได้แก่

  • แบบระบุได้: แสดงความคืบหน้าอย่างชัดเจน
  • ไม่แน่นอน: แสดงภาพเคลื่อนไหวอย่างต่อเนื่องโดยไม่คำนึงถึงความคืบหน้า

ในทำนองเดียวกัน ตัวบอกสถานะความคืบหน้าสามารถใช้รูปแบบใดรูปแบบหนึ่งต่อไปนี้

  • เชิงเส้น: แถบแนวนอนที่เติมจากซ้ายไปขวา
  • วงกลม: วงกลมที่มีเส้นขอบยาวขึ้นจนครอบคลุมเส้นรอบวงทั้งหมดของวงกลม
สัญญาณบอกสถานะความคืบหน้าแบบเส้นตรงพร้อมสัญญาณบอกสถานะความคืบหน้าแบบวงกลม
รูปที่ 1 สัญญาณบอกสถานะความคืบหน้า 2 ประเภท

แพลตฟอร์ม API

แม้ว่าจะมี Composable หลายรายการที่คุณใช้สร้างสัญญาณบอกสถานะความคืบหน้าที่สอดคล้องกับ Material Design ได้ แต่พารามิเตอร์ของ Composable เหล่านั้นก็ไม่ได้แตกต่างกันมากนัก พารามิเตอร์หลักที่คุณควรคำนึงถึงมีดังนี้

  • progress: ความคืบหน้าปัจจุบันที่ตัวบอกสถานะแสดง ส่ง Float ระหว่าง 0.0 ถึง 1.0
  • color: สีของสัญญาณบอกสถานะจริง ซึ่งก็คือส่วนของคอมโพเนนต์ที่แสดงความคืบหน้าและครอบคลุมคอมโพเนนต์ทั้งหมดเมื่อความคืบหน้าเสร็จสมบูรณ์
  • trackColor: สีของแทร็กที่วาดตัวบ่งชี้ไว้ด้านบน

การอัปเดต M3 Expressive

Material 3 Expressive เปิดตัว LinearWavyProgressIndicator และ CircularWavyProgressIndicator เป็นตัวเลือกเพิ่มเติมควบคู่ไปกับ LinearProgressIndicator และ CircularProgressIndicator แบบแบนราบมาตรฐาน ตัวบ่งชี้เหล่านี้มีสไตล์โค้งมนและการกำหนดค่าสำหรับความสูงของแทร็กและรูปร่างคลื่น เลือกสไตล์ภาพที่เหมาะกับผลิตภัณฑ์ของคุณมากที่สุด

ดูข้อมูลเพิ่มเติมเกี่ยวกับการอัปเดต M3 Expressive สำหรับสัญญาณบอกสถานะความคืบหน้าได้ที่หลักเกณฑ์เกี่ยวกับสัญญาณบอกสถานะความคืบหน้าของ Material Design 3

รูปที่ 2 รูปร่างคลื่นของสัญญาณบอกความคืบหน้าแบบ Material 3 Expressive และความสูงของแทร็กที่ปรับเปลี่ยนได้

ตัวบ่งชี้ความคืบหน้ามีรูปแบบโค้งมนและมีสีสัน รวมถึงมีการกำหนดค่าเพิ่มเติมให้เลือก เช่น รูปทรงคลื่นและความสูงของแทร็กที่ปรับเปลี่ยนได้ ตัวบ่งชี้ที่ทำงานอยู่มีตัวเลือกรูปร่าง 2 แบบ ได้แก่ คลื่นและแบน

ภาพขยับเป็นคลื่น

ตัวบอกสถานะความคืบหน้าแบบคลื่นมีทั้งรูปแบบที่ระบุได้และระบุไม่ได้ และช่วยให้คุณปรับแต่งลักษณะที่ปรากฏด้วยพารามิเตอร์คลื่นเพื่อให้ภาพที่สื่อความหมายได้มากขึ้น

รูปที่ 3 สัญญาณบอกสถานะความคืบหน้าแบบคลื่นพร้อมพารามิเตอร์คลื่นที่สื่อความหมาย

ตัวบอกสถานะเชิงเส้นแบบหยักจะเพิ่มความสูงของคอนเทนเนอร์โดยรวม

สัญญาณบอกความคืบหน้าแบบคลื่นมี 2 รูปแบบ ได้แก่ แบบเส้นตรงและแบบวงกลม

สัญญาณบอกสถานะความคืบหน้าแบบคลื่นเชิงเส้นที่กำหนดได้

โดยค่าเริ่มต้น เมื่อใช้ตัวบอกสถานะความคืบหน้าแบบคลื่น ระบบจะใช้ความเร็วคลื่นเพื่อสร้างการเคลื่อนไหวของคลื่นที่สม่ำเสมอ แม้จะอยู่ในโหมดที่กำหนดก็ตาม คุณปิดการเคลื่อนไหวแบบคลื่นนี้ได้โดยส่ง 0.dp ไปยัง waveSpeed

ข้อมูลโค้ดต่อไปนี้แสดงวิธีใช้ LinearWavyProgressIndicator แบบกำหนดได้ซึ่งควบคุมโดย Slider

@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() }
}

สัญญาณบอกสถานะความคืบหน้าแบบวงกลมที่มีคลื่นแบบกำหนดได้

รูปร่างคลื่นช่วยให้กระบวนการที่ใช้เวลานานดูไม่นิ่งจนเกินไป และเหมาะที่สุดเมื่อต้องการใช้สไตล์ที่สื่ออารมณ์ได้มากขึ้น ข้อมูลโค้ดต่อไปนี้แสดงวิธีใช้ CircularWavyProgressIndicator แบบกำหนดได้ซึ่งควบคุมโดย Slider

@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() }
}

คงที่

สัญญาณบอกสถานะที่แน่นอน

ตัวบ่งชี้แบบจำกัดจะแสดงความคืบหน้าของการดำเนินการอย่างแม่นยำ โดยใช้ Composable LinearProgressIndicator หรือ CircularProgressIndicator และส่งค่าสำหรับพารามิเตอร์ progress

ข้อมูลโค้ดต่อไปนี้แสดงวิธีใช้ LinearProgressIndicator แบบกำหนดได้ซึ่งควบคุมโดย Slider

@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),
        )
    }
}

ข้อมูลโค้ดต่อไปนี้แสดงวิธีใช้ CircularProgressIndicator แบบกำหนดได้ซึ่งควบคุมโดย Slider

@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),
        )
    }
}

ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างที่ค่อนข้างละเอียด เมื่อผู้ใช้กดปุ่ม แอปจะแทนที่ปุ่มด้วยสัญญาณบอกสถานะความคืบหน้าและเปิดใช้งาน Coroutine ที่จะค่อยๆ เพิ่มค่าของ 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)
    }
}

เมื่อการโหลดเสร็จสมบูรณ์บางส่วน ตัวบ่งชี้เชิงเส้นในตัวอย่างก่อนหน้าจะปรากฏดังนี้

รูปที่ 4 สัญญาณบอกสถานะความคืบหน้าแบบเส้นตรงที่กำหนดได้

ในทำนองเดียวกัน สัญญาณบอกสถานะแบบวงกลมจะปรากฏดังนี้

รูปที่ 5 สัญญาณบอกสถานะความคืบหน้าแบบวงกลมที่กำหนดได้

สัญญาณบอกสถานะแบบไม่แน่นอน

ตัวบอกสถานะแบบไม่แน่นอนไม่ได้แสดงให้เห็นว่าการดำเนินการใกล้เสร็จสมบูรณ์เพียงใด แต่จะใช้การเคลื่อนไหวเพื่อระบุให้ผู้ใช้ทราบว่ากำลังประมวลผลอยู่ โดยไม่ได้ระบุระดับความสมบูรณ์

หากต้องการสร้างตัวบ่งชี้ความคืบหน้าที่ไม่แน่นอน ให้ใช้คอมโพสิเบิล 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")
        }
    }
}

ต่อไปนี้เป็นตัวอย่างการใช้งานเมื่อสัญญาณบอกสถานะทำงานอยู่

รูปที่ 6 สัญญาณบอกสถานะความคืบหน้าแบบวงกลมที่ไม่ระบุเวลา

ตัวอย่างต่อไปนี้เป็นการใช้งานแบบเดียวกัน แต่ใช้ LinearProgressIndicator แทน CircularProgressIndicator

รูปที่ 7 ตัวบอกสถานะความคืบหน้าแบบเส้นตรงที่ไม่ระบุเวลา

แหล่งข้อมูลเพิ่มเติม