Refactor: TermsAgreement MviViewModel 제거

Author: wjdrjs00

presentation/src/main/java/com/threegap/bitnagil/presentation/terms/TermsAgreementScreen.kt

@@ -1,6 +1,5 @@
 package com.threegap.bitnagil.presentation.terms
 
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -15,83 +14,55 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.threegap.bitnagil.designsystem.BitnagilTheme
 import com.threegap.bitnagil.designsystem.component.atom.BitnagilTextButton
 import com.threegap.bitnagil.designsystem.component.block.BitnagilTopBar
 import com.threegap.bitnagil.presentation.terms.component.TermsAgreementItem
 import com.threegap.bitnagil.presentation.terms.component.ToggleAllAgreementsItem
-import com.threegap.bitnagil.presentation.terms.model.TermsAgreementIntent
 import com.threegap.bitnagil.presentation.terms.model.TermsAgreementSideEffect
 import com.threegap.bitnagil.presentation.terms.model.TermsAgreementState
+import org.orbitmvi.orbit.compose.collectAsState
 import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun TermsAgreementScreenContainer(
+    viewModel: TermsAgreementViewModel = hiltViewModel(),
     navigateToTermsOfService: () -> Unit,
     navigateToPrivacyPolicy: () -> Unit,
     navigateToOnBoarding: () -> Unit,
     navigateToBack: () -> Unit,
-    viewmodel: TermsAgreementViewModel = hiltViewModel(),
 ) {
-    val uiState by viewmodel.stateFlow.collectAsStateWithLifecycle()
+    val uiState by viewModel.collectAsState()
 
-    viewmodel.collectSideEffect { sideEffect ->
+    viewModel.collectSideEffect { sideEffect ->
         when (sideEffect) {
-            is TermsAgreementSideEffect.NavigateToPrivacyPolicy -> {
-                navigateToPrivacyPolicy()
-            }
-
-            is TermsAgreementSideEffect.NavigateToTermsOfService -> {
-                navigateToTermsOfService()
-            }
-
-            is TermsAgreementSideEffect.NavigateToOnBoarding -> {
-                navigateToOnBoarding()
-            }
-
-            is TermsAgreementSideEffect.NavigateToBack -> {
-                navigateToBack()
-            }
+            is TermsAgreementSideEffect.NavigateToPrivacyPolicy -> navigateToPrivacyPolicy()
+            is TermsAgreementSideEffect.NavigateToTermsOfService -> navigateToTermsOfService()
+            is TermsAgreementSideEffect.NavigateToOnBoarding -> navigateToOnBoarding()
+            is TermsAgreementSideEffect.NavigateToBack -> navigateToBack()
         }
     }
 
     TermsAgreementScreen(
         uiState = uiState,
-        onToggleAllAgreements = {
-            viewmodel.sendIntent(TermsAgreementIntent.ToggleAllAgreements(it))
-        },
-        onToggleTermsOfService = {
-            viewmodel.sendIntent(TermsAgreementIntent.ToggleTermsOfService(it))
-        },
-        onTogglePrivacyPolicy = {
-            viewmodel.sendIntent(TermsAgreementIntent.TogglePrivacyPolicy(it))
-        },
-        onToggleOverFourteen = {
-            viewmodel.sendIntent(TermsAgreementIntent.ToggleOverFourteen(it))
-        },
-        onShowTermsOfService = {
-            viewmodel.sendIntent(TermsAgreementIntent.ShowTermsOfService)
-        },
-        onShowPrivacyPolicy = {
-            viewmodel.sendIntent(TermsAgreementIntent.ShowPrivacyPolicy)
-        },
-        onStartButtonClick = {
-            viewmodel.submitTermsAgreement()
-        },
-        onBackButtonClick = {
-            viewmodel.sendIntent(TermsAgreementIntent.BackButtonClick)
-        },
+        onToggleAllAgreements = viewModel::updateAllAgreements,
+        onToggleTermsOfService = viewModel::updateTermsOfService,
+        onTogglePrivacyPolicy = viewModel::updatePrivacyPolicy,
+        onToggleOverFourteen = viewModel::updateOverFourteen,
+        onShowTermsOfService = viewModel::navigateToTermsOfService,
+        onShowPrivacyPolicy = viewModel::navigateToPrivacyPolicy,
+        onStartButtonClick = viewModel::submitTermsAgreement,
+        onBackButtonClick = viewModel::navigateToBack,
     )
 }
 
 @Composable
 private fun TermsAgreementScreen(
     uiState: TermsAgreementState,
     onToggleAllAgreements: (Boolean) -> Unit,
-    onToggleTermsOfService: (Boolean) -> Unit,
-    onTogglePrivacyPolicy: (Boolean) -> Unit,
-    onToggleOverFourteen: (Boolean) -> Unit,
+    onToggleTermsOfService: () -> Unit,
+    onTogglePrivacyPolicy: () -> Unit,
+    onToggleOverFourteen: () -> Unit,
     onShowTermsOfService: () -> Unit,
     onShowPrivacyPolicy: () -> Unit,
     onStartButtonClick: () -> Unit,
@@ -101,7 +72,6 @@ private fun TermsAgreementScreen(
     Column(
         modifier = modifier
             .fillMaxSize()
-            .background(BitnagilTheme.colors.white)
             .statusBarsPadding(),
     ) {
         BitnagilTopBar(
@@ -117,7 +87,7 @@ private fun TermsAgreementScreen(
         ) {
             Text(
                 text = "빛나길 이용을 위해\n필수 약관에 동의해 주세요.",
-                color = BitnagilTheme.colors.navy500,
+                color = BitnagilTheme.colors.coolGray10,
                 style = BitnagilTheme.typography.title2Bold,
             )
 
@@ -132,23 +102,23 @@ private fun TermsAgreementScreen(
 
             TermsAgreementItem(
                 title = "(필수) 서비스 이용약관 동의",
-                onCheckedChange = { onToggleTermsOfService(!uiState.agreedTermsOfService) },
+                onCheckedChange = { onToggleTermsOfService() },
                 isChecked = uiState.agreedTermsOfService,
                 showMore = true,
                 onClickShowMore = onShowTermsOfService,
             )
 
             TermsAgreementItem(
                 title = "(필수) 개인정보 수집·이용 동의",
-                onCheckedChange = { onTogglePrivacyPolicy(!uiState.agreedPrivacyPolicy) },
+                onCheckedChange = { onTogglePrivacyPolicy() },
                 isChecked = uiState.agreedPrivacyPolicy,
                 showMore = true,
                 onClickShowMore = onShowPrivacyPolicy,
             )
 
             TermsAgreementItem(
                 title = "(필수) 만 14세 이상입니다.",
-                onCheckedChange = { onToggleOverFourteen(!uiState.agreedOverFourteen) },
+                onCheckedChange = { onToggleOverFourteen() },
                 isChecked = uiState.agreedOverFourteen,
             )
         }
@@ -167,11 +137,11 @@ private fun TermsAgreementScreen(
     }
 }
 
-@Preview
+@Preview(showBackground = true)
 @Composable
 private fun TermsAgreementScreenPreview() {
     TermsAgreementScreen(
-        uiState = TermsAgreementState(),
+        uiState = TermsAgreementState.INIT,
         onToggleAllAgreements = {},
         onToggleTermsOfService = {},
         onTogglePrivacyPolicy = {},

presentation/src/main/java/com/threegap/bitnagil/presentation/terms/TermsAgreementViewModel.kt

@@ -1,116 +1,94 @@
 package com.threegap.bitnagil.presentation.terms
 
 import android.util.Log
-import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.ViewModel
 import com.threegap.bitnagil.domain.auth.model.TermsAgreement
 import com.threegap.bitnagil.domain.auth.usecase.SubmitTermsAgreementUseCase
-import com.threegap.bitnagil.presentation.common.mviviewmodel.MviViewModel
-import com.threegap.bitnagil.presentation.terms.model.TermsAgreementIntent
 import com.threegap.bitnagil.presentation.terms.model.TermsAgreementSideEffect
 import com.threegap.bitnagil.presentation.terms.model.TermsAgreementState
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.launch
-import org.orbitmvi.orbit.syntax.Syntax
+import org.orbitmvi.orbit.Container
+import org.orbitmvi.orbit.ContainerHost
+import org.orbitmvi.orbit.viewmodel.container
 import javax.inject.Inject
 
 @HiltViewModel
 class TermsAgreementViewModel @Inject constructor(
-    private val savedStateHandle: SavedStateHandle,
     private val submitTermsAgreementUseCase: SubmitTermsAgreementUseCase,
-) : MviViewModel<TermsAgreementState, TermsAgreementSideEffect, TermsAgreementIntent>(
-    initState = TermsAgreementState(),
-    savedStateHandle = savedStateHandle,
-) {
-    override suspend fun Syntax<TermsAgreementState, TermsAgreementSideEffect>.reduceState(
-        intent: TermsAgreementIntent,
-        state: TermsAgreementState,
-    ): TermsAgreementState? = when (intent) {
-        is TermsAgreementIntent.SetLoading -> {
-            state.copy(isLoading = intent.isLoading)
-        }
+) : ContainerHost<TermsAgreementState, TermsAgreementSideEffect>, ViewModel() {
+
+    override val container: Container<TermsAgreementState, TermsAgreementSideEffect> = container(initialState = TermsAgreementState.INIT)
 
-        is TermsAgreementIntent.ToggleAllAgreements -> {
-            if (state.isLoading) {
-                null
-            } else {
+    fun updateAllAgreements(agreed: Boolean) {
+        intent {
+            if (state.isLoading) return@intent
+            reduce {
                 state.copy(
-                    agreedTermsOfService = intent.agreed,
-                    agreedPrivacyPolicy = intent.agreed,
-                    agreedOverFourteen = intent.agreed,
+                    agreedTermsOfService = agreed,
+                    agreedPrivacyPolicy = agreed,
+                    agreedOverFourteen = agreed,
                 )
             }
         }
+    }
 
-        is TermsAgreementIntent.ToggleTermsOfService -> {
-            if (state.isLoading) {
-                null
-            } else {
-                state.copy(agreedTermsOfService = intent.agreed)
-            }
-        }
-
-        is TermsAgreementIntent.TogglePrivacyPolicy -> {
-            if (state.isLoading) {
-                null
-            } else {
-                state.copy(agreedPrivacyPolicy = intent.agreed)
-            }
-        }
-
-        is TermsAgreementIntent.ToggleOverFourteen -> {
-            if (state.isLoading) {
-                null
-            } else {
-                state.copy(agreedOverFourteen = intent.agreed)
-            }
+    fun updateTermsOfService() {
+        intent {
+            if (state.isLoading) return@intent
+            reduce { state.copy(agreedTermsOfService = !state.agreedTermsOfService) }
         }
+    }
 
-        is TermsAgreementIntent.ShowTermsOfService -> {
-            sendSideEffect(TermsAgreementSideEffect.NavigateToTermsOfService)
-            null
+    fun updatePrivacyPolicy() {
+        intent {
+            if (state.isLoading) return@intent
+            reduce { state.copy(agreedPrivacyPolicy = !state.agreedPrivacyPolicy) }
         }
+    }
 
-        is TermsAgreementIntent.ShowPrivacyPolicy -> {
-            sendSideEffect(TermsAgreementSideEffect.NavigateToPrivacyPolicy)
-            null
+    fun updateOverFourteen() {
+        intent {
+            if (state.isLoading) return@intent
+            reduce { state.copy(agreedOverFourteen = !state.agreedOverFourteen) }
         }
+    }
 
-        is TermsAgreementIntent.SubmitSuccess -> {
-            sendSideEffect(TermsAgreementSideEffect.NavigateToOnBoarding)
-            state.copy(isLoading = false)
+    fun submitTermsAgreement() {
+        intent {
+            reduce { state.copy(isLoading = true) }
+            val agreement = TermsAgreement(
+                agreedToTermsOfService = state.agreedTermsOfService,
+                agreedToPrivacyPolicy = state.agreedPrivacyPolicy,
+                isOverFourteen = state.agreedOverFourteen,
+            )
+            submitTermsAgreementUseCase(agreement).fold(
+                onSuccess = {
+                    reduce { state.copy(isLoading = false) }
+                    postSideEffect(TermsAgreementSideEffect.NavigateToOnBoarding)
+                },
+                onFailure = { error ->
+                    Log.e("TermsAgreement", "Submit failed: ${error.message}")
+                    reduce { state.copy(isLoading = false) }
+                },
+            )
         }
+    }
 
-        is TermsAgreementIntent.SubmitFailure -> {
-            state.copy(isLoading = false)
+    fun navigateToTermsOfService() {
+        intent {
+            postSideEffect(TermsAgreementSideEffect.NavigateToTermsOfService)
         }
+    }
 
-        is TermsAgreementIntent.BackButtonClick -> {
-            sendSideEffect(TermsAgreementSideEffect.NavigateToBack)
-            null
+    fun navigateToPrivacyPolicy() {
+        intent {
+            postSideEffect(TermsAgreementSideEffect.NavigateToPrivacyPolicy)
         }
     }
 
-    fun submitTermsAgreement() {
-        sendIntent(TermsAgreementIntent.SetLoading(true))
-        viewModelScope.launch {
-            val currentState = container.stateFlow.value
-            val agreement = TermsAgreement(
-                agreedToTermsOfService = currentState.agreedTermsOfService,
-                agreedToPrivacyPolicy = currentState.agreedPrivacyPolicy,
-                isOverFourteen = currentState.agreedOverFourteen,
-            )
-
-            submitTermsAgreementUseCase(agreement)
-                .fold(
-                    onSuccess = {
-                        sendIntent(TermsAgreementIntent.SubmitSuccess)
-                    },
-                    onFailure = { error ->
-                        Log.e("TermsAgreement", "Submit failed: ${error.message}")
-                        sendIntent(TermsAgreementIntent.SubmitFailure)
-                    },
-                )
+    fun navigateToBack() {
+        intent {
+            postSideEffect(TermsAgreementSideEffect.NavigateToBack)
         }
     }
 }

presentation/src/main/java/com/threegap/bitnagil/presentation/terms/model/TermsAgreementIntent.kt

@@ -1,8 +1,6 @@
 package com.threegap.bitnagil.presentation.terms.model
 
-import com.threegap.bitnagil.presentation.common.mviviewmodel.MviSideEffect
-
-sealed interface TermsAgreementSideEffect : MviSideEffect {
+sealed interface TermsAgreementSideEffect {
     data object NavigateToTermsOfService : TermsAgreementSideEffect
     data object NavigateToPrivacyPolicy : TermsAgreementSideEffect
     data object NavigateToOnBoarding : TermsAgreementSideEffect