StateFlow vs LiveData

1.StateFlow vs LiveData

항목	StateFlow	LiveData
데이터 방식	StateFlow / SharedFlow (코루틴 기반)	LiveData (Lifecycle-aware)
실행 시점	항상 최신값을 유지하고, collect하는 순간 바로 전달/ ViewModel 안에서 계속 돌아가고, collect만 있으면 언제든 반응	Observer가 활성 상태일 때만 자동 반영/ LiveData는 onStart()~onStop() 사이만 반응
선언 방식	MutableStateFlow, MutableSharedFlow 사용	MutableLiveData 사용
관찰 방법	collect 사용 (예: lifecycleScope.launch { flow.collect {} })	observe 사용 (예: liveData.observe(...))
	- 비동기 스트림 처리에 적합	- Android 생명주기 자동 관리
특징	- Kotlin Coroutines 친화적	- UI 컨트롤러에 최적화
	- 중복 이벤트 방지 유연함 (SharedFlow)
ViewModel-UI 연결 방식	Flow로 비동기 연속성 / 상태 변경 대응	UI 중심의 단일 응답 처리에 적합
데이터 누적 처리	기존 데이터를 누적해서 저장 / .update로 간편	이전 값을 덮어씀 (누적 X) / 누적하려면 별도 로직 필요 (ex. .value = value + 새 항목)

1-1) StateFlow

💡 핵심

• StateFlow는 항상 현재 값을 가지고 있는 데이터 흐름(Flow)
• 값이 계속 바뀌면, 계속 반응함 (실시간으로)
• Activity/Fragment가 꺼져 있어도 데이터는 계속 유지됨
• 지속적으로 바뀌는 상태를 보여줄 때 사용
• StateFlow는 꼭 컬렉션(collect)과 함께 써야 하는 건 아님 하지만 대부분 경우에 collect를 써서 값을 받아옴 → 실시간으로 바뀌는 값을 관찰할 때 사용하기 때문
• stateFlow.value : 지금 현재 값 → 그냥 꺼내 쓰는 것
  stateFlow.collect { ... } : 값이 바뀔 때마다 하고 싶은 동작 → 흐름 감지

📍예제

class ContentsViewModel : ViewModel() {
    private val repository = ContentsRepository()

    private val _contentsGenreListStateFlow = MutableStateFlow<List<ContentsGenreData>>(emptyList())
    val contentsGenreListStateFlow: StateFlow<List<ContentsGenreData>> = _contentsGenreListStateFlow

    private val _contentsGenreErrorFlow = MutableSharedFlow<String>()
    val contentsGenreErrorFlow: SharedFlow<String> = _contentsGenreErrorFlow

    private val _contentsListStateFlow = MutableStateFlow<Map<String, List<String>>>(emptyMap())
    val contentsListStateFlow: StateFlow<Map<String, List<String>>> = _contentsListStateFlow

    private val _contentsListErrorFlow = MutableSharedFlow<String>()
    val contentsListErrorFlow: SharedFlow<String> = _contentsListErrorFlow

    fun getGenreList() {
        viewModelScope.launch {
            try {
                val response = repository.getGenreList()
                if (response.isSuccess) {
                    _contentsGenreListStateFlow.value = response.getOrThrow().data.genre
                } else {
                    _contentsGenreErrorFlow.emit("장르 목록 불러오기 실패")
                }
            } catch (e: Exception) {
                _contentsGenreErrorFlow.emit("에러: ${e.message}")
            }
        }
    }

    fun getContentsList(genreCode: String) {
        viewModelScope.launch {
            try {
                val response = repository.getContentsList(genreCode)
                if (response.isSuccess) {
                    val contentsMap = response.getOrThrow().data.contents.associate {
                        it.contentsName to listOf(it.contentsCode, it.developmentalElementName)
                    }
                    _contentsListStateFlow.update { it + contentsMap } // 누적 저장
                } else {
                    _contentsListErrorFlow.emit("콘텐츠 목록 실패 (장르코드: $genreCode)")
                }
            } catch (e: Exception) {
                _contentsListErrorFlow.emit("에러: ${e.message}")
            }
        }
    }

}


### 뷰에서
contentsViewModel = ViewModelProvider(this)[ContentsViewModel::class.java]
 
Common.getGenreCode(requireContext(),binding.tvTitle.text.toString())
            ?.let {
                Log.d("SmartFragment","확인 : $it")
                Common.GENRE_CODE = it
                contentsViewModel.getContentsList(it)
            } 
 
private fun observeContents() {
        // 콘텐츠 리스트 수신
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                contentsViewModel.contentsListStateFlow.collect { contentsMap ->
                    Common.CONTENTS_LIST_MAP.clear()
                    Common.CONTENTS_LIST_MAP.putAll(contentsMap)
                    // UI 반영하거나 로그 찍기 등 필요 작업 수행
                    Log.d("SmartFragment","SmartFragment => ${contentsMap}")
                    if (contentsMap.isNotEmpty()) {
                        withContext(Dispatchers.Main) {
                            attachMainStagePlayFragment(contentsMap)
                        }
                    }
                }
            }
        }
        lifecycleScope.launch {
            contentsViewModel.contentsListErrorFlow.collect {
                Toast.makeText(requireContext(), it, Toast.LENGTH_SHORT).show()
            }
        }
    }

📌 앱이 실행 중인 내내 계속 상태를 유지하고, 누가 새로 들어와도 가장 최신 상태를 보여줘야 할 때

cf) SharedFlow

• 누군가 emit("에러 났어요!")라고 말하면, 그 순간 듣고 있던 사람 들음
• StateFlow랑 비슷하지만 이전에 말한 건 기억 안함 (값 저장 안 함)
• 에러 메시지, 토스트 알림 등 한 번만 보여줄 이벤트에 적합

val toastMessage = MutableSharedFlow<String>(
    replay = 0,       // 과거 메시지 저장 안 함
    extraBufferCapacity = 1 // 버퍼 1개 허용
)
// 화면에서 collect
lifecycleScope.launch {
    viewModel.toastMessage.collect {
        Toast.makeText(context, it, LENGTH_SHORT).show()
    }
}

1-2) LiveData

💡 핵심

• 값이 한 번 바뀔 때 한 번만 반응함
• "값이 바뀌면 UI가 한번 반응하고 끝!"
• 화면(Activity/Fragment)이 켜져 있을 때만 반응함

class CompareRecordViewModel : ViewModel() {

    private val repository = CompareRecordRepository()

    private val _compareRecordLiveData = MutableLiveData<CompareRecordResponse>()
    val compareRecordLiveData: LiveData<CompareRecordResponse> get() = _compareRecordLiveData

    private val _compareRecordErrorLiveData = MutableLiveData<String>()  // 실패 메시지 저장용
    val compareRecordErrorLiveData: LiveData<String> get() = _compareRecordErrorLiveData

    fun getCompareRecord(genreCode:String,childId:String) {
        viewModelScope.launch {
            try {
                val response = repository.getCompareRecord(genreCode,childId)
                if (response.isSuccess) {
                    _compareRecordLiveData.postValue(response.getOrThrow())
                } else {
                    val errorMessage = response.exceptionOrNull()?.message ?: "알 수 없는 오류 발생"
                    _compareRecordErrorLiveData.postValue(errorMessage)
                }
            } catch (e: Exception) {
                val errorMessage = "비교 기록 파싱 중 오류 발생: ${e.message}"
                Log.d("TAG", errorMessage)
                _compareRecordErrorLiveData.postValue(errorMessage)
            }
        }
    }

}

####화면
private lateinit var compareViewModel: CompareRecordViewModel

compareViewModel = ViewModelProvider(this)[CompareRecordViewModel::class.java]

private fun registerViewModelObserve() {
        compareViewModel.compareRecordLiveData.observe(viewLifecycleOwner) { response ->
            if (response.status) {

                //뷰 페이저의 캐싱 삭제 후 !! 여기가 아주 필수
                binding.radarChart.options.series = arrayListOf()
                binding.radarChart.update(binding.radarChart.options, true, true)

                val newData = response.data
                updateRadarDataToUi(newData)

            }
        }

        compareViewModel.compareRecordErrorLiveData.observe(viewLifecycleOwner) { error ->
            Toast.makeText(requireContext(), error, Toast.LENGTH_SHORT).show()
            Log.e("ERROR", "RadarChartFragment compareRecordError : $error")
        }
    }
    
    private fun updateRadarData() {
        compareViewModel.getCompareRecord(
            Common.GENRE_CODE,
            Common.getSharedPreferencesAiFitParent(requireContext(), "selectedChildId").toString()
        )
    }

📌 화면이 꺼졌다가 다시 켜질 때 자동으로 다시 데이터를 보여줘야 할 때, 데이터가 그렇게 자주 바뀌지 않을 때

2.에러 처리 방식

항목	StateFlow	LiveData
에러 전달 방식	MutableSharedFlow<'String> 사용 → 여러 번 발행 가능, 수집자 필요	MutableLiveData<'Sting> 사용 → UI에서 단순 관찰
처리 방식	.emit(...)	.postValue(...)

3.어떤 것을 언제 써야 할까?

상황	권장 방식
UI 생명주기 따라 안전하게 데이터 처리	LiveData (예: 비교 기록)
비동기/스트림/중복 이벤트 처리 필요	StateFlow / SharedFlow (예: 콘텐츠 목록, 장르, 에러 처리 등)
여러 값 누적 및 실시간 업데이트 필요	StateFlow + .update { } 사용
단일 값 응답 처리에 충분한 경우	LiveData로 간단 처리

💡요약 정리

구분	StateFlow	LiveData
목적	상태 스트림, 여러 장르/콘텐츠 누적	단건 비교 기록 응답
코루틴	코루틴 기반, StateFlow/SharedFlow	LiveData 기반
수신 방식	collect {}	observe(...)
에러 처리	SharedFlow.emit(...)	LiveData.postValue(...)
데이터 구조	Map, List 등을 누적 처리	단일 객체 처리