[Feat] ChatViewModel 및 TyprWriterFlow 작성

app/build.gradle.kts

@@ -65,6 +65,7 @@ dependencies {
     implementation(projects.core.navigation)
     implementation(projects.core.designsystem)
     implementation(projects.feature.auth)
+    implementation(projects.feature.chat)
 
     implementation(libs.androidx.navigation3.runtime)
     implementation(libs.androidx.navigation3.ui)

feature/chat/build.gradle.kts

@@ -0,0 +1,20 @@
+plugins {
+    alias(libs.plugins.todakun.feature)
+}
+
+android {
+    namespace = "com.kikidan.chat"
+
+    defaultConfig {
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles("consumer-rules.pro")
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.compose.material3)
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.kotlinx.coroutines.core)
+
+    testImplementation(libs.kotlinx.coroutines.test)
+}

feature/chat/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest />

feature/chat/src/main/java/com/kikidan/chat/ChatViewModel.kt

@@ -0,0 +1,234 @@
+package com.kikidan.chat
+
+import androidx.lifecycle.ViewModel
+import com.kikidan.chat.model.ChatSideEffect
+import com.kikidan.chat.model.ChatState
+import com.kikidan.chat.model.StreamingChatState
+import com.kikidan.domain.model.chat.ChatAction
+import com.kikidan.domain.model.chat.ChatMessage
+import com.kikidan.domain.model.chat.ChatStreamEvent
+import com.kikidan.domain.model.chat.MessageRole
+import com.kikidan.domain.model.chat.MessageStatus
+import com.kikidan.domain.usecase.GetChatEntryUseCase
+import com.kikidan.domain.usecase.GetConversationDetailUseCase
+import com.kikidan.domain.usecase.SendChatMessageUseCase
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toPersistentList
+import kotlinx.coroutines.flow.transform
+import org.orbitmvi.orbit.ContainerHost
+import org.orbitmvi.orbit.syntax.Syntax
+import org.orbitmvi.orbit.viewmodel.container
+import java.time.Instant
+import javax.inject.Inject
+import kotlin.coroutines.cancellation.CancellationException
+
+@HiltViewModel
+class ChatViewModel
+    @Inject
+    constructor(
+        private val getChatEntry: GetChatEntryUseCase,
+        private val getConversationDetail: GetConversationDetailUseCase,
+        private val sendChatMessage: SendChatMessageUseCase,
+    ) : ViewModel(),
+        ContainerHost<ChatState, ChatSideEffect> {
+        override val container = container<ChatState, ChatSideEffect>(ChatState())
+
+        /** 화면 진입 시 1회. conversationId가 있으면 과거 대화를 먼저 채운다. */
+        fun load(conversationId: String?) =
+            intent {
+                reduce { state.copy(conversationId = conversationId, isLoading = true) }
+
+                getChatEntry()
+                    .onSuccess { entry ->
+                        reduce {
+                            state.copy(
+                                greeting = entry.greeting,
+                                suggestions = entry.suggestions.toPersistentList(),
+                                quota = entry.quota,
+                            )
+                        }
+                    }.onFailure { postSideEffect(ChatSideEffect.Error(it)) }
+
+                if (conversationId != null) {
+                    getConversationDetail(conversationId)
+                        .onSuccess { reduce { state.copy(messages = it.messages.toPersistentList()) } }
+                        .onFailure { postSideEffect(ChatSideEffect.Error(it)) }
+                }
+
+                reduce { state.copy(isLoading = false) }
+            }
+
+        fun onInputChange(value: String) =
+            intent {
+                reduce { state.copy(input = value.take(SendChatMessageUseCase.MAX_CONTENT_LENGTH)) }
+            }
+
+        fun onSendClick() =
+            intent {
+                val content = state.input
+                reduce { state.copy(input = "") }
+                send(content)
+            }
+
+        fun onSuggestionClick(seedPrompt: String) = intent { send(seedPrompt) }
+
+        fun startNewConversation() =
+            intent {
+                reduce {
+                    state.copy(
+                        conversationId = null,
+                        messages = persistentListOf(),
+                        streamingChatState = StreamingChatState.Idle,
+                        input = "",
+                    )
+                }
+            }
+
+        // 전송 진입점이 여러 개이므로 가드를 여기 한 곳에만 둔다 (설계 2-7).
+        private suspend fun Syntax<ChatState, ChatSideEffect>.send(content: String) {
+            if (state.streamingChatState !is StreamingChatState.Idle) return
+
+            val conversationId = state.conversationId
+            val placeholder = localUserMessage(content.trim())
+            reduce {
+                state.copy(
+                    messages = state.messages.adding(placeholder),
+                    streamingChatState = StreamingChatState.Thinking,
+                )
+            }
+
+            var streamConversationId: String? = conversationId
+            var assistantMessageId: String? = null
+            var pendingAction: ChatAction? = null
+
+            try {
+                sendChatMessage(conversationId, content)
+                    .transform { result ->
+                        when (val event = result.getOrElse { throw it }) {
+                            is ChatStreamEvent.Start -> {
+                                val result = onStreamingStart(placeholder, event)
+                                streamConversationId = result.first
+                                assistantMessageId = result.second
+                            }
+
+                            is ChatStreamEvent.Delta -> {
+                                emit(event.text)
+                            }
+
+                            is ChatStreamEvent.Action -> {
+                                pendingAction = event.action
+                            }
+
+                            is ChatStreamEvent.Done -> {
+                                assistantMessageId = event.assistantMessageId
+                            }
+
+                            is ChatStreamEvent.Error -> {
+                                postSideEffect(ChatSideEffect.ShowStreamingErrorMessage(event.message))
+                            }
+                        }
+                    }.typewriter()
+                    .collect { shown ->
+                        reduce {
+                            state.copy(
+                                streamingChatState = StreamingChatState.Typing(shown),
+                            )
+                        }
+                    }
+
+                onSteamingDone(
+                    streamConversationId,
+                    assistantMessageId,
+                    pendingAction,
+                )
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Throwable) {
+                reduce {
+                    state.copy(
+                        streamingChatState = StreamingChatState.Idle,
+                    )
+                }
+                postSideEffect(ChatSideEffect.Error(e))
+            }
+        }
+
+        private suspend fun Syntax<ChatState, ChatSideEffect>.onStreamingStart(
+            placeholder: ChatMessage,
+            event: ChatStreamEvent.Start,
+        ): Pair<String, String> {
+            reduce {
+                state.copy(
+                    // 낙관적 메시지의 로컬 id를 서버가 준 진짜 id로 교체.
+                    messages =
+                        state.messages
+                            .map { msg ->
+                                if (msg.id == placeholder.id) {
+                                    msg.copy(
+                                        id = event.userMessageId,
+                                        status = MessageStatus.COMPLETED,
+                                    )
+                                } else {
+                                    msg
+                                }
+                            }.toPersistentList(),
+                    quota = event.quota,
+                )
+            }
+            return event.conversationId to event.assistantMessageId
+        }
+
+        private suspend fun Syntax<ChatState, ChatSideEffect>.onSteamingDone(
+            streamConversationId: String?,
+            assistantMessageId: String?,
+            pendingAction: ChatAction?,
+        ) {
+            reduce {
+                val currentStreamingState = state.streamingChatState
+                state.copy(
+                    conversationId = streamConversationId,
+                    messages =
+                        if (currentStreamingState is StreamingChatState.Typing) {
+                            state.messages.adding(
+                                assistantMessage(
+                                    id = assistantMessageId,
+                                    content = currentStreamingState.streamingText,
+                                    action = pendingAction,
+                                ),
+                            )
+                        } else {
+                            state.messages
+                        },
+                    streamingChatState = StreamingChatState.Idle,
+                )
+            }
+        }
+    }
+
+private fun localUserMessage(content: String) =
+    ChatMessage(
+        id = "local-user-${System.currentTimeMillis()}",
+        role = MessageRole.USER,
+        content = content,
+        status = MessageStatus.COMPLETED,
+        action = null,
+        createdAt = Instant.now(),
+    )
+
+/**
+ * 서버는 done에 텍스트/시각을 싣지 않으므로(assistantMessageId만 전달) 최종 메시지는 여기서 조립한다.
+ * id는 start/done이 준 값을 쓰되, start도 못 받고 스트림이 끝난 경우를 대비해 로컬 id로 폴백한다.
+ */
+private fun assistantMessage(
+    id: String?,
+    content: String,
+    action: ChatAction?,
+) = ChatMessage(
+    id = id ?: "local-assistant-${System.currentTimeMillis()}",
+    role = MessageRole.ASSISTANT,
+    content = content,
+    status = MessageStatus.COMPLETED,
+    action = action,
+    createdAt = Instant.now(),
+)

feature/chat/src/main/java/com/kikidan/chat/TypewriterFlow.kt

@@ -0,0 +1,37 @@
+package com.kikidan.chat
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.launch
+
+/**
+ * 도착 속도(네트워크)와 표시 속도(화면)를 분리한다.
+ * 업스트림 청크를 버퍼에 쌓고 tick마다 조금씩 잘라 지금까지 보여줄 전체 텍스"를 방출한다.
+ */
+internal fun Flow<String>.typewriter(tickMillis: Long = 16L): Flow<String> =
+    channelFlow {
+        val buffered = StringBuffer()
+        val upstream = launch { this@typewriter.collect { chunk -> buffered.append(chunk) } }
+        var shown = 0
+        while (true) {
+            val upstreamDone = !upstream.isActive
+            when {
+                shown < buffered.length -> {
+                    shown =
+                        (((buffered.length - shown) / CATCH_UP_DIVISOR) + shown + 1)
+                            .coerceAtMost(buffered.length)
+                    send(buffered.substring(0, shown))
+                }
+
+                upstreamDone -> {
+                    return@channelFlow
+                }
+            }
+            delay(tickMillis)
+        }
+    }
+
+// 남은 글자의 1/32 를 매 틱 추가 방출,
+// 약 0.35초에 남은 buffer의 절반을 채우는 속도, tickMillis 파라미터와 더불어 실기기에서 체크 후 조정 요망
+private const val CATCH_UP_DIVISOR = 32

feature/chat/src/main/java/com/kikidan/chat/model/ChatSideEffect.kt

@@ -0,0 +1,11 @@
+package com.kikidan.chat.model
+
+sealed interface ChatSideEffect {
+    data class ShowStreamingErrorMessage(
+        val message: String,
+    ) : ChatSideEffect
+
+    data class Error(
+        val e: Throwable,
+    ) : ChatSideEffect
+}

feature/chat/src/main/java/com/kikidan/chat/model/ChatState.kt

@@ -0,0 +1,28 @@
+package com.kikidan.chat.model
+
+import com.kikidan.domain.model.chat.ChatMessage
+import com.kikidan.domain.model.chat.ChatQuota
+import com.kikidan.domain.model.chat.ChatSuggestion
+import kotlinx.collections.immutable.PersistentList
+import kotlinx.collections.immutable.persistentListOf
+
+data class ChatState(
+    val conversationId: String? = null,
+    val isLoading: Boolean = true,
+    val greeting: String = "",
+    val suggestions: PersistentList<ChatSuggestion> = persistentListOf(),
+    val quota: ChatQuota? = null,
+    val messages: PersistentList<ChatMessage> = persistentListOf(),
+    val input: String = "",
+    val streamingChatState: StreamingChatState = StreamingChatState.Idle,
+)
+
+sealed interface StreamingChatState {
+    data object Idle : StreamingChatState
+
+    data object Thinking : StreamingChatState
+
+    data class Typing(
+        val streamingText: String = "",
+    ) : StreamingChatState
+}