จะยกสถานะที่ไหน

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

แนวทางปฏิบัติแนะนำ

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

บรรพบุรุษร่วมที่ต่ำที่สุดอาจอยู่นอก Composition ได้ด้วย เช่น เมื่อยกสถานะใน ViewModel เนื่องจากมีตรรกะทางธุรกิจเข้ามาเกี่ยวข้อง

หน้านี้จะอธิบายแนวทางปฏิบัติแนะนำนี้โดยละเอียดและข้อควรระวังที่ควรคำนึงถึง

ประเภทของสถานะ UI และตรรกะ UI

ด้านล่างนี้คือคำจำกัดความของประเภทสถานะและตรรกะของ UI ที่ใช้ในเอกสารนี้

สถานะ UI

สถานะ UI คือพร็อพเพอร์ตี้ที่อธิบาย UI สถานะ UI มี 2 ประเภท ได้แก่

  • สถานะ UI ของหน้าจอคือสิ่งที่คุณต้องแสดงบนหน้าจอ ตัวอย่างเช่น คลาส NewsUiState อาจมีบทความข่าวและข้อมูลอื่นๆ ที่จำเป็นต่อการแสดงผล UI โดยปกติแล้ว สถานะนี้จะเชื่อมต่อกับลำดับชั้นอื่นๆ เนื่องจากมีข้อมูลแอป
  • สถานะองค์ประกอบ UI หมายถึงพร็อพเพอร์ตี้ที่อยู่ภายในองค์ประกอบ UI ซึ่งส่งผลต่อวิธีแสดงผล องค์ประกอบ UI อาจแสดงหรือซ่อนอยู่ และอาจมีแบบอักษร ขนาดแบบอักษร หรือสีแบบอักษรที่เฉพาะเจาะจง ใน Jetpack Compose สถานะจะอยู่ภายนอก Composable และคุณยังสามารถยกสถานะออกจากบริเวณใกล้เคียงของ Composable ไปยังฟังก์ชัน Composable ที่เรียกใช้หรือตัวเก็บสถานะได้ด้วย ตัวอย่างเช่น ScaffoldState สำหรับ Composable ของ Scaffold

เชิงตรรกะ

ตรรกะในแอปพลิเคชันอาจเป็นตรรกะทางธุรกิจหรือตรรกะ UI ก็ได้ ดังนี้

  • ตรรกะทางธุรกิจคือการใช้ข้อกำหนดของผลิตภัณฑ์สำหรับข้อมูลแอป เช่น การบุ๊กมาร์กบทความในแอปโปรแกรมอ่านข่าวเมื่อผู้ใช้แตะปุ่ม ตรรกะนี้ในการบันทึกบุ๊กมาร์กลงในไฟล์หรือฐานข้อมูลมักจะอยู่ในโดเมนหรือชั้นข้อมูล โดยปกติแล้ว ตัวเก็บสถานะจะมอบสิทธิ์ตรรกะนี้ให้กับเลเยอร์เหล่านั้นโดยการเรียกใช้เมธอดที่แสดง
  • ตรรกะ UI เกี่ยวข้องกับวิธีแสดงสถานะ UI บนหน้าจอ เช่น การรับคำแนะนำแถบค้นหาที่ถูกต้องเมื่อผู้ใช้เลือกหมวดหมู่ การเลื่อนไปยังรายการที่เฉพาะเจาะจงในรายการ หรือตรรกะการนำทางไปยังหน้าจอที่เฉพาะเจาะจงเมื่อผู้ใช้คลิกปุ่ม

ตรรกะ UI

เมื่อตรรกะ UI ต้องอ่านหรือเขียนสถานะ คุณควรกำหนดขอบเขตสถานะให้กับ UI ตามวงจรของ UI เพื่อให้บรรลุเป้าหมายนี้ คุณควรยกสถานะในระดับที่ถูกต้องในฟังก์ชันที่ประกอบกันได้ หรือจะทำในคลาสตัวเก็บสถานะธรรมดาซึ่งกำหนดขอบเขตตามวงจรของ UI ด้วยก็ได้

ด้านล่างนี้คือคำอธิบายของทั้ง 2 โซลูชันและคำอธิบายว่าควรใช้โซลูชันใดเมื่อใด

Composable เป็นเจ้าของสถานะ

การมีตรรกะ UI และสถานะองค์ประกอบ UI ใน Composable เป็นแนวทางที่ดีหากสถานะและตรรกะไม่ซับซ้อน คุณสามารถปล่อยให้สถานะอยู่ภายใน Composable หรือยกขึ้นตามที่จำเป็นได้

ไม่จำเป็นต้องย้ายสถานะ

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

@Composable
fun ChatBubble(
    message: Message
) {
    var showDetails by rememberSaveable { mutableStateOf(false) } // Define the UI element expanded state

    Text(
        text = AnnotatedString(message.content),
        modifier = Modifier.clickable {
            showDetails = !showDetails // Apply UI logic
        }
    )

    if (showDetails) {
        Text(message.timestamp)
    }
}

ตัวแปร showDetails คือสถานะภายในสำหรับองค์ประกอบ UI นี้ โดยจะอ่านและแก้ไขใน Composable นี้เท่านั้น และตรรกะที่ใช้กับตัวแปรนี้ก็เรียบง่ายมาก ดังนั้น การยกสถานะในกรณีนี้จึงไม่เป็นประโยชน์มากนัก คุณจึงปล่อยให้เป็นสถานะภายในได้ การทำเช่นนี้จะทำให้ Composable นี้เป็นเจ้าของและเป็นแหล่งข้อมูลที่เชื่อถือได้เพียงแหล่งเดียว (SSOT) ของสถานะที่ขยาย

การโฮสต์ภายในฟังก์ชันที่ประกอบกันได้

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

ตัวอย่างต่อไปนี้คือแอปแชทที่ใช้ฟังก์ชันการทำงาน 2 อย่าง

  • ปุ่ม JumpToBottom จะเลื่อนรายการข้อความลงไปด้านล่าง ปุ่มจะใช้ตรรกะ UI กับสถานะรายการ
  • รายการ MessagesList จะเลื่อนไปที่ด้านล่างหลังจากที่ผู้ใช้ส่งข้อความใหม่ UserInput จะดำเนินการตรรกะ UI ในสถานะรายการ
แอปแชทที่มีปุ่ม JumpToBottom และเลื่อนไปด้านล่างเมื่อมีข้อความใหม่
รูปที่ 1 แอปแชทที่มีปุ่ม JumpToBottom และเลื่อนลงไปด้านล่างเมื่อมีข้อความใหม่

ลำดับชั้นของ Composable มีดังนี้

โครงสร้าง Composable ของ Chat
รูปที่ 2 ต้นไม้ที่ประกอบกันได้ของ Chat

สถานะ LazyColumn จะถูกยกขึ้นไปยังหน้าจอการสนทนาเพื่อให้แอปสามารถใช้ตรรกะ UI และอ่านสถานะจาก Composable ทั้งหมดที่ต้องใช้ได้

การยกสถานะ LazyColumn จาก LazyColumn ไปยัง ConversationScreen
รูปที่ 3 การยกสถานะ LazyColumn จาก LazyColumn ไปยัง ConversationScreen

ดังนั้น Composable สุดท้ายจะเป็นดังนี้

แผนผัง Composable ของแชทที่มี LazyListState ยกขึ้นไปยัง ConversationScreen
รูปที่ 4 แผนผัง Composable ของแชทที่มี LazyListState โฮสต์ไปยัง ConversationScreen

โค้ดมีดังนี้

@Composable
private fun ConversationScreen(/*...*/) {
    val scope = rememberCoroutineScope()

    val lazyListState = rememberLazyListState() // State hoisted to the ConversationScreen

    MessagesList(messages, lazyListState) // Reuse same state in MessageList

    UserInput(
        onMessageSent = { // Apply UI logic to lazyListState
            scope.launch {
                lazyListState.scrollToItem(0)
            }
        },
    )
}

@Composable
private fun MessagesList(
    messages: List<Message>,
    lazyListState: LazyListState = rememberLazyListState() // LazyListState has a default value
) {

    LazyColumn(
        state = lazyListState // Pass hoisted state to LazyColumn
    ) {
        items(messages, key = { message -> message.id }) { item ->
            Message(/*...*/)
        }
    }

    val scope = rememberCoroutineScope()

    JumpToBottom(onClicked = {
        scope.launch {
            lazyListState.scrollToItem(0) // UI logic being applied to lazyListState
        }
    })
}

LazyListState จะถูกยกขึ้นสูงเท่าที่จำเป็นสำหรับตรรกะ UI ที่ต้องใช้ เนื่องจากมีการเริ่มต้นในฟังก์ชันที่ประกอบกันได้ ระบบจึงจัดเก็บไว้ใน Composition ตามวงจรของฟังก์ชัน

โปรดทราบว่า lazyListState มีการกำหนดไว้ในเมธอด MessagesList โดยมีค่าเริ่มต้นเป็น rememberLazyListState() ซึ่งเป็นรูปแบบที่พบได้ทั่วไปใน Compose ซึ่งช่วยให้ Composable นำกลับมาใช้ใหม่ได้และมีความยืดหยุ่นมากขึ้น จากนั้นคุณจะใช้ Composable ในส่วนต่างๆ ของแอปซึ่งอาจไม่จำเป็นต้องควบคุมสถานะได้ ซึ่งมักจะเป็นกรณีนี้เมื่อทดสอบหรือแสดงตัวอย่างคอมโพสิเบิล นี่คือวิธีที่ LazyColumn กำหนดสถานะของตนเอง

บรรพบุรุษร่วมที่ต่ำที่สุดสำหรับ LazyListState คือ ConversationScreen
รูปที่ 5 บรรพบุรุษร่วมที่ต่ำที่สุดสำหรับ LazyListState คือ ConversationScreen

คลาสตัวเก็บสถานะธรรมดาเป็นเจ้าของสถานะ

เมื่อ Composable มีตรรกะ UI ที่ซับซ้อนซึ่งเกี่ยวข้องกับช่องสถานะอย่างน้อย 1 ช่องขององค์ประกอบ UI ก็ควรส่งต่อความรับผิดชอบนั้นไปยังตัวเก็บสถานะ เช่น คลาสตัวเก็บสถานะธรรมดา ซึ่งจะทำให้ตรรกะของ Composable ทดสอบได้ง่ายขึ้นแบบแยกต่างหาก และลดความซับซ้อนลง แนวทางนี้สนับสนุนหลักการแยกข้อกังวล: คอมโพสิเบิลมีหน้าที่แสดงองค์ประกอบ UI และตัวเก็บสถานะมีตรรกะ UI และสถานะองค์ประกอบ UI

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

ระบบจะสร้างและจดจำคลาสธรรมดาเหล่านี้ใน Composition เนื่องจากเป็นไปตามวงจรของ Composable จึงสามารถใช้ประเภทที่ไลบรารี Compose มีให้ เช่น rememberNavController() หรือ rememberLazyListState()

ตัวอย่างเช่น คลาสตัวเก็บสถานะธรรมดา LazyListState ซึ่งติดตั้งใช้งานใน Compose เพื่อควบคุมความซับซ้อนของ UI ของ LazyColumn หรือ LazyRow

// LazyListState.kt

@Stable
class LazyListState constructor(
    firstVisibleItemIndex: Int = 0,
    firstVisibleItemScrollOffset: Int = 0
) : ScrollableState {
    /**
     *   The holder class for the current scroll position.
     */
    private val scrollPosition = LazyListScrollPosition(
        firstVisibleItemIndex, firstVisibleItemScrollOffset
    )

    suspend fun scrollToItem(/*...*/) { /*...*/ }

    override suspend fun scroll() { /*...*/ }

    suspend fun animateScrollToItem() { /*...*/ }
}

LazyListState จะรวมสถานะของ LazyColumn ที่จัดเก็บ scrollPosition สำหรับองค์ประกอบ UI นี้ นอกจากนี้ยังแสดงวิธีการแก้ไขตำแหน่งการเลื่อน เช่น การเลื่อนไปยังรายการที่ระบุ

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

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

ตรรกะทางธุรกิจ

หาก Composable และคลาสตัวเก็บสถานะธรรมดามีหน้าที่รับผิดชอบตรรกะ UI และสถานะองค์ประกอบ UI ตัวเก็บสถานะระดับหน้าจอจะมีหน้าที่รับผิดชอบงานต่อไปนี้

  • ให้สิทธิ์เข้าถึงตรรกะทางธุรกิจของแอปพลิเคชันที่มักจะอยู่ในเลเยอร์อื่นๆ ของลำดับชั้น เช่น เลเยอร์ธุรกิจและชั้นข้อมูล
  • การเตรียมข้อมูลแอปพลิเคชันสำหรับการนำเสนอในหน้าจอหนึ่งๆ ซึ่งจะกลายเป็นสถานะ UI ของหน้าจอ

ViewModel เป็นเจ้าของสถานะ

ประโยชน์ของ AAC ViewModel ในการพัฒนา Android ทำให้เหมาะสำหรับการให้สิทธิ์เข้าถึงตรรกะทางธุรกิจและการเตรียมข้อมูลแอปพลิเคชันสำหรับการนำเสนอในหน้าจอ

เมื่อคุณยกสถานะ UI ใน ViewModel คุณจะย้ายสถานะนั้นออกนอก Composition

ระบบจะจัดเก็บสถานะที่ย้ายไปยัง ViewModel ไว้นอก Composition
รูปที่ 6 สถานะที่ย้ายไปยัง ViewModel จะจัดเก็บไว้นอก Composition

ViewModel ไม่ได้จัดเก็บเป็นส่วนหนึ่งของ Composition ซึ่งเฟรมเวิร์กเป็นผู้จัดเตรียมให้และกำหนดขอบเขตไว้ที่ ViewModelStoreOwner ซึ่งอาจเป็นกิจกรรม, Fragment, กราฟการนำทาง หรือปลายทางของกราฟการนำทาง ดูข้อมูลเพิ่มเติมเกี่ยวกับขอบเขต ViewModel ได้ในเอกสารประกอบ

จากนั้น ViewModel จะเป็นแหล่งข้อมูลที่ถูกต้องและเป็นระดับบนสุดที่ใช้ร่วมกันสำหรับสถานะ UI

สถานะ UI ของหน้าจอ

ตามคำจำกัดความข้างต้น สถานะ UI ของหน้าจอจะสร้างขึ้นโดยใช้กฎทางธุรกิจ เนื่องจากตัวเก็บสถานะระดับหน้าจอเป็นผู้รับผิดชอบ จึงหมายความว่าสถานะ UI ของหน้าจอมักจะถูกโฮสต์ในตัวเก็บสถานะระดับหน้าจอ ซึ่งในกรณีนี้คือ ViewModel

พิจารณา ConversationViewModel ของแอปแชทและวิธีที่แอปแสดงสถานะ UI ของหน้าจอและเหตุการณ์เพื่อแก้ไขสถานะดังกล่าว

class ConversationViewModel(
    channelId: String,
    messagesRepository: MessagesRepository
) : ViewModel() {

    val messages = messagesRepository
        .getLatestMessages(channelId)
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5_000),
            initialValue = emptyList()
        )

    // Business logic
    fun sendMessage(message: Message) { /* ... */ }
}

Composable จะใช้สถานะ UI ของหน้าจอที่ย้ายไปยัง ViewModel คุณควรแทรกอินสแตนซ์ ViewModel ใน Composable ระดับหน้าจอเพื่อให้เข้าถึงตรรกะทางธุรกิจได้

ต่อไปนี้คือตัวอย่างของ ViewModel ที่ใช้ใน Composable ระดับหน้าจอ ในกรณีนี้ Composable ConversationScreen() จะใช้สถานะ UI ของหน้าจอที่ย้ายใน ViewModel ดังนี้

@Composable
private fun ConversationScreen(
    conversationViewModel: ConversationViewModel = viewModel()
) {

    val messages by conversationViewModel.messages.collectAsStateWithLifecycle()

    ConversationScreen(
        messages = messages,
        onSendMessage = { message: Message -> conversationViewModel.sendMessage(message) }
    )
}

@Composable
private fun ConversationScreen(
    messages: List<Message>,
    onSendMessage: (Message) -> Unit
) {

    MessagesList(messages, onSendMessage)
    /* ... */
}

การเจาะลึกพร็อพเพอร์ตี้

"การเจาะลึกพร็อพเพอร์ตี้" หมายถึงการส่งข้อมูลผ่านคอมโพเนนต์ย่อยที่ฝังอยู่หลายรายการไปยังตำแหน่งที่อ่านข้อมูลเหล่านั้น

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

แม้ว่าการแสดงเหตุการณ์เป็นพารามิเตอร์ Lambda แต่ละรายการอาจทำให้ซิกเนเจอร์ของฟังก์ชันมีภาระมากเกินไป แต่ก็ช่วยเพิ่มระดับการเข้าถึงหน้าที่ของฟังก์ชันที่ประกอบกันได้ให้มากที่สุด คุณจะเห็นสิ่งที่แอปทำได้อย่างรวดเร็ว

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

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

หากพบปัญหาด้านประสิทธิภาพ คุณอาจเลือกเลื่อนการอ่านสถานะออกไปได้ด้วย ดูข้อมูลเพิ่มเติมได้ในเอกสารประกอบเกี่ยวกับประสิทธิภาพ

สถานะองค์ประกอบ UI

คุณสามารถยกสถานะองค์ประกอบ UI ไปยังตัวเก็บสถานะระดับหน้าจอได้หากมีตรรกะทางธุรกิจที่ต้องอ่านหรือเขียนสถานะดังกล่าว

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

ฟีเจอร์ที่แสดงคำแนะนำผู้ใช้ในแชทเป็นกลุ่มเมื่อผู้ใช้พิมพ์ &quot;@&quot; และคำใบ้
รูปที่ 7 ฟีเจอร์ที่แสดงคำแนะนำผู้ใช้ในแชทเป็นกลุ่มเมื่อผู้ใช้พิมพ์ @ และคำแนะนำ

ViewModel ที่ใช้ฟีเจอร์นี้จะมีลักษณะดังนี้

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

    // Hoisted state
    var inputMessage by mutableStateOf("")
        private set

    val suggestions: StateFlow<List<Suggestion>> =
        snapshotFlow { inputMessage }
            .filter { hasSocialHandleHint(it) }
            .mapLatest { getHandle(it) }
            .mapLatest { repository.getSuggestions(it) }
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5_000),
                initialValue = emptyList()
            )

    fun updateInput(newInput: String) {
        inputMessage = newInput
    }
}

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

suggestions คือสถานะ UI ของหน้าจอและใช้จาก Compose UI โดยการรวบรวมจาก StateFlow

Caveat

สำหรับสถานะองค์ประกอบ UI ของ Compose บางสถานะ การย้ายไปยัง ViewModel อาจต้องพิจารณาเป็นพิเศษ เช่น ตัวเก็บสถานะบางตัวขององค์ประกอบ UI ของ Compose จะแสดงเมธอดเพื่อแก้ไขสถานะ บางฟังก์ชันอาจเป็นฟังก์ชันระงับที่ทริกเกอร์ภาพเคลื่อนไหว ฟังก์ชัน Suspend เหล่านี้อาจแสดงข้อยกเว้นหากคุณเรียกใช้จาก CoroutineScope ที่ไม่ได้กำหนดขอบเขตไว้ใน Composition

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

อย่างไรก็ตาม การเรียกใช้เมธอด close() ของ DrawerState โดยใช้ viewModelScope จาก Compose UI จะทำให้เกิดข้อยกเว้นรันไทม์ประเภท IllegalStateException พร้อมข้อความที่ระบุว่า "MonotonicFrameClock ไม่พร้อมใช้งานใน CoroutineContext” นี้

หากต้องการแก้ไขปัญหานี้ ให้ใช้ CoroutineScope ที่กำหนดขอบเขตเป็น Composition โดยจะให้ MonotonicFrameClock ใน CoroutineContext ซึ่งจำเป็นต่อการทำงานของฟังก์ชันระงับ

หากต้องการแก้ไขข้อขัดข้องนี้ ให้เปลี่ยน CoroutineContext ของ Coroutine ใน ViewModel เป็น Coroutine ที่กำหนดขอบเขตเป็น Composition ซึ่งอาจมีลักษณะดังนี้

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

    val drawerState = DrawerState(initialValue = DrawerValue.Closed)

    private val _drawerContent = MutableStateFlow(DrawerContent.Empty)
    val drawerContent: StateFlow<DrawerContent> = _drawerContent.asStateFlow()

    fun closeDrawer(uiScope: CoroutineScope) {
        viewModelScope.launch {
            withContext(uiScope.coroutineContext) { // Use instead of the default context
                drawerState.close()
            }
            // Fetch drawer content and update state
            _drawerContent.update { content }
        }
    }
}

// in Compose
@Composable
private fun ConversationScreen(
    conversationViewModel: ConversationViewModel = viewModel()
) {
    val scope = rememberCoroutineScope()

    ConversationScreen(onCloseDrawer = { conversationViewModel.closeDrawer(uiScope = scope) })
}

ดูข้อมูลเพิ่มเติม

ดูข้อมูลเพิ่มเติมเกี่ยวกับสถานะและ Jetpack Compose ได้ที่แหล่งข้อมูลเพิ่มเติมต่อไปนี้

ตัวอย่าง

Codelab

วิดีโอ