[AN] 스터디 개설 뷰 리펙터링

android/app/src/main/java/com/created/team201/presentation/common/BindingViewBottomSheetFragment.kt

@@ -0,0 +1,30 @@
+package com.created.team201.presentation.common
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.viewbinding.ViewBinding
+import com.created.team201.R
+import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+
+abstract class BindingViewBottomSheetFragment<VB : ViewBinding>(
+    private val bindingInflater: (LayoutInflater) -> VB
+) : BottomSheetDialogFragment() {
+    private var _binding: VB? = null
+    val binding get() = _binding ?: error(R.string.error_baseFragment)
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?,
+    ): View {
+        _binding = bindingInflater(inflater)
+        return binding.root
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+}

android/app/src/main/java/com/created/team201/presentation/createStudy/CreateStudyActivity.kt

@@ -11,37 +11,40 @@ import androidx.activity.viewModels
 import androidx.annotation.StringRes
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.commit
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
 import com.created.team201.R
 import com.created.team201.databinding.ActivityCreateStudyBinding
-import com.created.team201.presentation.common.BindingActivity
-import com.created.team201.presentation.createStudy.model.CreateStudyUiState.Fail
-import com.created.team201.presentation.createStudy.model.CreateStudyUiState.Idle
-import com.created.team201.presentation.createStudy.model.CreateStudyUiState.Success
+import com.created.team201.presentation.common.BindingViewActivity
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.CreateStudyState.Failure
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.CreateStudyState.Idle
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.CreateStudyState.Loading
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.CreateStudyState.Success
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.Event.CreateStudyFailure
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.Event.CreateStudySuccess
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.Event.NavigateToBefore
+import com.created.team201.presentation.createStudy.CreateStudyViewModel.Event.NavigateToNext
+import com.created.team201.presentation.createStudy.model.FragmentState
 import com.created.team201.presentation.createStudy.model.FragmentState.FirstFragment
 import com.created.team201.presentation.createStudy.model.FragmentState.SecondFragment
 import com.created.team201.presentation.createStudy.model.FragmentType
 import com.created.team201.presentation.createStudy.model.FragmentType.FIRST
 import com.created.team201.presentation.createStudy.model.FragmentType.SECOND
 import com.created.team201.presentation.studyDetail.StudyDetailActivity
+import com.created.team201.util.collectLatestOnStarted
+import com.created.team201.util.collectOnStarted
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.launch
 
 @AndroidEntryPoint
 class CreateStudyActivity :
-    BindingActivity<ActivityCreateStudyBinding>(R.layout.activity_create_study) {
+    BindingViewActivity<ActivityCreateStudyBinding>(ActivityCreateStudyBinding::inflate) {
     private val createStudyViewModel: CreateStudyViewModel by viewModels()
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        initBinding()
         initActionBar()
-        setupCollectCreateStudyState()
-        setupCollectCreateStudyUiState()
+        showFragment(createStudyViewModel.fragmentState.value.type)
+        collectCreateStudyState()
+        collectCreateStudyEvent()
     }
 
     override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
@@ -51,8 +54,9 @@ class CreateStudyActivity :
         return super.dispatchTouchEvent(ev)
     }
 
-    private fun initBinding() {
-        binding.lifecycleOwner = this
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        createStudyViewModel.navigateToBefore()
+        return true
     }
 
     private fun initActionBar() {
@@ -62,67 +66,61 @@ class CreateStudyActivity :
         supportActionBar?.setHomeAsUpIndicator(R.drawable.ic_back)
     }
 
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        return when (createStudyViewModel.fragmentState.value) {
-            is FirstFragment -> {
-                finish()
-                true
-            }
-
-            is SecondFragment -> {
-                createStudyViewModel.navigateToBefore()
-                true
-            }
-        }
-    }
-
     private fun setProgressIndicator(type: FragmentType) {
         binding.lpiCreateStudyProgress.progress = when (type) {
             FIRST -> PROGRESS_FIRST
             SECOND -> PROGRESS_SECOND
         }
     }
 
-    private fun setupCollectCreateStudyUiState() {
-        lifecycleScope.launch {
-            createStudyViewModel.createStudyUiState.collectLatest { createStudyUiState ->
-                lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                    when (createStudyUiState) {
-                        is Success -> {
-                            showToast(R.string.create_study_toast_create_study_success)
-                            startActivity(
-                                StudyDetailActivity.getIntent(
-                                    this@CreateStudyActivity,
-                                    createStudyUiState.studyId
-                                ),
-                            )
-
-                            finish()
-                        }
-
-                        is Fail -> {
-                            showToast(R.string.create_study_toast_create_study_fail)
-                            finish()
-                        }
-
-                        is Idle -> throw IllegalArgumentException()
-                    }
+    private fun collectCreateStudyState() {
+        createStudyViewModel.createStudyState
+            .collectLatestOnStarted(this) { createStudyState ->
+                when (createStudyState) {
+                    is Success -> navigateToStudyDetail(createStudyState.studyId)
+                    Loading -> Unit
+                    Idle -> Unit
+                    Failure -> finish()
                 }
             }
+    }
+
+    private fun navigateToStudyDetail(studyId: Long) {
+        startActivity(
+            StudyDetailActivity.getIntent(
+                this@CreateStudyActivity,
+                studyId
+            ),
+        )
+        finish()
+    }
+
+    private fun collectCreateStudyEvent() {
+        createStudyViewModel.createStudyEvent.collectOnStarted(this) { event ->
+            when (event) {
+                CreateStudySuccess -> showToast(R.string.create_study_toast_create_study_success)
+                CreateStudyFailure -> showToast(R.string.create_study_toast_create_study_fail)
+                is NavigateToBefore -> navigateToBefore(event.fragmentState)
+                is NavigateToNext -> navigateToNext(event.fragmentState)
+            }
         }
     }
 
     private fun showToast(@StringRes messageRes: Int) {
         Toast.makeText(this, getString(messageRes), Toast.LENGTH_SHORT).show()
     }
 
-    private fun setupCollectCreateStudyState() {
-        lifecycleScope.launch {
-            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                createStudyViewModel.fragmentState.collect { fragmentState ->
-                    showFragment(fragmentState.type)
-                }
-            }
+    private fun navigateToBefore(fragmentState: FragmentState) {
+        when (fragmentState) {
+            FirstFragment -> finish()
+            SecondFragment -> showFragment(FirstFragment.type)
+        }
+    }
+
+    private fun navigateToNext(fragmentState: FragmentState) {
+        when (fragmentState) {
+            FirstFragment -> showFragment(SecondFragment.type)
+            SecondFragment -> Unit
         }
     }
 

android/app/src/main/java/com/created/team201/presentation/createStudy/CreateStudyViewModel.kt

@@ -4,19 +4,19 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.created.domain.model.CreateStudy
 import com.created.team201.data.repository.CreateStudyRepository
-import com.created.team201.presentation.createStudy.model.CreateStudyUiState
 import com.created.team201.presentation.createStudy.model.FragmentState
 import com.created.team201.presentation.createStudy.model.FragmentState.FirstFragment
 import com.created.team201.presentation.createStudy.model.FragmentState.SecondFragment
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
@@ -44,20 +44,22 @@ class CreateStudyViewModel @Inject constructor(
         MutableStateFlow(DEFAULT_STRING_VALUE)
     val studyIntroduction: StateFlow<String> get() = _studyIntroduction.asStateFlow()
 
-    val isEnableFirstCreateStudyNext: Flow<Boolean> =
+    val isEnableFirstCreateStudyNext: StateFlow<Boolean> =
         combine(peopleCount, studyDate, cycle) { peopleCount, studyDate, cycle ->
-            return@combine peopleCount != DEFAULT_INT_VALUE && studyDate != DEFAULT_INT_VALUE && cycle != DEFAULT_INT_VALUE
-        }
+            peopleCount != DEFAULT_INT_VALUE && studyDate != DEFAULT_INT_VALUE && cycle != DEFAULT_INT_VALUE
+        }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), false)
 
-    val isEnableSecondCreateStudyNext: Flow<Boolean> =
+    val isEnableSecondCreateStudyNext: StateFlow<Boolean> =
         combine(studyName, studyIntroduction) { studyName, studyIntroduction ->
-            return@combine studyName.isNotBlankAndEmpty() && studyIntroduction.isNotBlankAndEmpty()
-        }
+            studyName.isNotBlankAndEmpty() && studyIntroduction.isNotBlankAndEmpty()
+        }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(), false)
 
-    private val _createStudyUiState: MutableSharedFlow<CreateStudyUiState> = MutableSharedFlow()
-    val createStudyUiState: SharedFlow<CreateStudyUiState> get() = _createStudyUiState.asSharedFlow()
+    private val _createStudyState: MutableStateFlow<CreateStudyState> =
+        MutableStateFlow(CreateStudyState.Idle)
+    val createStudyState: StateFlow<CreateStudyState> get() = _createStudyState.asStateFlow()
 
-    private var isOpenStudy: Boolean = false
+    private val _createStudyEvent: MutableSharedFlow<Event> = MutableSharedFlow()
+    val createStudyEvent: SharedFlow<Event> get() = _createStudyEvent.asSharedFlow()
 
     fun setPeopleCount(peopleCount: Int) {
         _peopleCount.value = peopleCount
@@ -80,28 +82,29 @@ class CreateStudyViewModel @Inject constructor(
     }
 
     fun navigateToNext() {
-        when (_fragmentState.value) {
-            is FirstFragment -> {
-                _fragmentState.value = SecondFragment
-            }
+        viewModelScope.launch {
+            when (_fragmentState.value) {
+                is FirstFragment -> {
+                    _createStudyEvent.emit(Event.NavigateToNext(fragmentState.value))
+                    _fragmentState.value = SecondFragment
+                }
 
-            else -> Unit
+                else -> Unit
+            }
         }
     }
 
     fun navigateToBefore() {
-        when (_fragmentState.value) {
-            is SecondFragment -> {
-                _fragmentState.value = FirstFragment
-            }
-
-            else -> Unit
+        viewModelScope.launch {
+            _createStudyEvent.emit(Event.NavigateToBefore(fragmentState.value))
+            _fragmentState.value = FirstFragment
         }
     }
 
     fun createStudy() {
-        if (isOpenStudy) return
-        isOpenStudy = true
+        if (createStudyState.value == CreateStudyState.Loading)
+            return
+        _createStudyState.value = CreateStudyState.Loading
         viewModelScope.launch {
             val study = CreateStudy(
                 name = studyName.value.trim(),
@@ -112,18 +115,37 @@ class CreateStudyViewModel @Inject constructor(
             )
             createStudyRepository.createStudy(study)
                 .onSuccess { studyId ->
-                    _createStudyUiState.emit(CreateStudyUiState.Success(studyId))
+                    _createStudyEvent.emit(Event.CreateStudySuccess)
+                    _createStudyState.value = CreateStudyState.Success(studyId)
                 }
                 .onFailure {
-                    _createStudyUiState.emit(CreateStudyUiState.Fail)
+                    _createStudyEvent.emit(Event.CreateStudyFailure)
+                    _createStudyState.value = CreateStudyState.Failure
                 }
         }
     }
 
-    private fun String.isNotBlankAndEmpty(): Boolean = isNotBlank().and(isNotEmpty())
+    private fun String.isNotBlankAndEmpty(): Boolean = isNotBlank() and isNotEmpty()
+
+    sealed interface Event {
+        object CreateStudySuccess : Event
+        object CreateStudyFailure : Event
+        data class NavigateToBefore(val fragmentState: FragmentState) : Event
+        data class NavigateToNext(val fragmentState: FragmentState) : Event
+    }
+
+    sealed interface CreateStudyState {
+        class Success(val studyId: Long) : CreateStudyState
+
+        object Loading : CreateStudyState
+
+        object Failure : CreateStudyState
+
+        object Idle : CreateStudyState
+    }
 
     companion object {
-        private const val DEFAULT_INT_VALUE = -1
+        const val DEFAULT_INT_VALUE = -1
         private const val DEFAULT_STRING_VALUE = ""
     }
 }