[Kotlin][Android] 안드로이드 Coroutine Flow 적용하기 (1) (네트워크 통신 Flow로 이전하기)

안녕하세요 👋

오늘은 안드로이드 MVVM패턴에서 Flow를 어떻게 적용하는지를 알아보려고 합니다 😎

Flow에 대한 기본 포스팅은 아래 링크를 참고 바랍니다 🙏

[Kotlin] 코틀린 Coroutine에 대하여 (3) - Coroutine Flow(플로우)

---

이번 포스팅에서는 이전 Clean Architecture에 대한 포스팅을 할 때 사용했던 예제를 Flow로 이전하며 사용할 예정입니다.

해당 예제의 전체 코드 및 설명은 아래 포스팅을 참고해주세요 🤩

[Android] 안드로이드 Clean Architecture에 대해서 (2) - 안드로이드 프로젝트에 적용하는 방법

 

구현체가 수정된 경우 interface도 함께 수정되었다는점 참고 바랍니다. 🤔

 

Data Layer

[MyApi.kt] Response에 객체를 담도록 수정

 

기존

interface MyApi {
    @GET(DataConst.GET_CONGESTION_URL)
    suspend fun getBeachCongestion() : BeachCongestionListDTO
}

 

변경 후

interface MyApi {
    @GET(DataConst.GET_CONGESTION_URL)
    suspend fun getBeachCongestion() : Response<BeachCongestionListDTO>
}

[BeachDataSourceImpl.kt] 반환값을 seald class로 감싸고 Flow로 반환하도록 수정

 

기존

class BeachDataSourceImpl @Inject constructor(
    private val myApi: MyApi
) : BeachDataSource{
    override suspend fun getCongestionList(): BeachCongestionList {
        return BeachMapper.mapperToBeachCongestionList(myApi.getBeachCongestion())
    }
}

변경 후

class BeachDataSourceImpl @Inject constructor(
    private val myApi: MyApi
) : BeachDataSource{
    override suspend fun getCongestionList(): Flow<NetworkResult<BeachCongestionList>> {
        return BeachMapper.mapperToBeachCongestionList(myApi.getBeachCongestion())
    }
}

[MainRepositoryImpl.kt] 반환값을 seald class로 감싸고 Flow로 반환하도록 수정

 

기존

class MainRepositoryImpl @Inject constructor(
    private val beachDataSource: BeachDataSource
) : MainRepository {
    override suspend fun getBeachCongestion(): BeachCongestionList {
        return beachDataSource.getCongestionList()
    }
}

변경 후

class MainRepositoryImpl @Inject constructor(
    private val beachDataSource: BeachDataSource
) : MainRepository {
    override suspend fun getBeachCongestion(): Flow<NetworkResult<BeachCongestionList>> {
        return beachDataSource.getCongestionList()
    }
}

 

[BeachMapper.kt]

전달받은 객체를 domain의 model과 mapping 후에 성공/실패/예외 여부에 따라 결괏값을 seald class에 담아 보내는 Flow를 생성하여 반환하도록 수정

 

기존

object BeachMapper {
    private fun mapperToBeach(beachDTO: BeachDTO) : Beach {
        val beach = beachDTO.run {
            Beach(poiNm, congestion)
        }
        return beach
    }

    fun mapperToBeachCongestionList(beachCongestionListDTO: BeachCongestionListDTO) : BeachCongestionList {
        val list = arrayListOf<Beach>()
        beachCongestionListDTO.getAllBeachList().forEach {
            val beach = mapperToBeach(it)
            list.add(beach)
        }

        return BeachCongestionList(list)
    }
}

변경 후

object BeachMapper {
    private fun mapperToBeach(beachDTO: BeachDTO) : Beach {
        val beach = beachDTO.run {
            Beach(poiNm, congestion)
        }
        return beach
    }

     fun mapperToBeachCongestionList(response : Response<BeachCongestionListDTO>) : Flow<NetworkResult<BeachCongestionList>> {
        if(response.isSuccessful){
            val list = arrayListOf<Beach>()
            response.body()?.getAllBeachList()?.forEach {
                val beach = mapperToBeach(it)
                list.add(beach)
            }
            val beachCongestionList = BeachCongestionList(list)
            return flow { // 성공시에 반환할 Flow
                emit(NetworkResult.Success(beachCongestionList))
            }
        } else {
            return flow<NetworkResult<BeachCongestionList>> {  // 실패시에 반환할 Flow
                emit(NetworkResult.Failure(response.code()))
            }.catch { exception -> // 예외처리
                emit(NetworkResult.Exception(exception.message!!))
            }
        }
    }
}

Domain Layer

[NetworkResult.kt] 네트워크 통신의 결과값을 담아 보내는 sealed class

/**
 * 네트워크 통신의 결과들을 모아놓은 sealed class
 * **/
sealed class NetworkResult<T> {
    data class Loading<T>(val isLoading: Boolean) : NetworkResult<T>()
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Exception<T>(val errorMessage: String) : NetworkResult<T>()
    data class Failure<T>(val code: Int) : NetworkResult<T>()
}

[GetBeachCongstionList.kt] 반환값을 seald class로 감싸고 Flow로 반환하도록 수정

 

기존

class GetBeachCongestionList @Inject constructor(
    private val repository: MainRepository
) {
    suspend fun invoke() : BeachCongestionList {
        return repository.getBeachCongestion()
    }
}

 

변경 후

class GetBeachCongestionList @Inject constructor(
    private val repository: MainRepository
) {
    suspend fun invoke() : Flow<NetworkResult<BeachCongestionList>> {
        return repository.getBeachCongestion()
    }
}

Presantation Layer

[MyViewModel.kt] 결과값을 받는 LiveData를 추가하여 값을 setting 하도록 수정

 

기존

@HiltViewModel
class MyViewModel @Inject constructor(
    private val getBeachCongestionList: GetBeachCongestionList
) : ViewModel(){
    private val _beachCongestionList = MutableLiveData<BeachCongestionList>()
    val beachCongestionList : LiveData<BeachCongestionList>
    get() = _beachCongestionList

    private val _toastMessage = MutableLiveData<String>()
    val toastMessage : LiveData<String>
    get() = _toastMessage

    fun getBeachInfo(){
        val exceptionHandler = CoroutineExceptionHandler{ _ , exception ->
            when(exception){
                is SocketTimeoutException -> {onError("통신시간 초과!")}
            }
        }
        viewModelScope.launch(exceptionHandler) {
            _beachCongestionList.value = getBeachCongestionList.invoke()
        }
    }

    private fun onError(message : String) {
        _toastMessage.value = message
    }
}

변경 후

@HiltViewModel
class MyViewModel @Inject constructor(
    private val getBeachCongestionList: GetBeachCongestionList
) : ViewModel(){
    private val _networkResult = MutableLiveData<NetworkResult<BeachCongestionList>>()
    val networkResult : LiveData<NetworkResult<BeachCongestionList>>
    get() = _networkResult

    private val _beachCongestionList = MutableLiveData<BeachCongestionList>()
    val beachCongestionList : LiveData<BeachCongestionList>
    get() = _beachCongestionList
    fun setBeachCongestionList(beachCongestionList: BeachCongestionList){
        _beachCongestionList.value = beachCongestionList
    }

    private val _toastMessage = MutableLiveData<String>()
    val toastMessage : LiveData<String>
    get() = _toastMessage

    fun getBeachInfo(){
        viewModelScope.launch {
            getBeachCongestionList.invoke().collect{ result ->
                _networkResult.value = result
            }
        }
    }

    fun onError(message : String) {
        _toastMessage.value = message
    }
}

 

[MainActivity.kt] LiveData에 전달된 결과값에 따라 각각의 처리를 하도록 수정

 

기존

private const val TAG = "MainActivity"

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private lateinit var binding : ActivityMainBinding
    private val viewModel : MyViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater).also {
            setContentView(it.root)
        }
        observeData()
    }

    override fun onResume() {
        super.onResume()
        viewModel.getBeachInfo()
    }

    private fun observeData() {
        with(viewModel){
            beachCongestionList.observe(this@MainActivity){
                Log.d(TAG, "observeData: $it")
            }
            toastMessage.observe(this@MainActivity){
                Toast.makeText(this@MainActivity , it , Toast.LENGTH_SHORT).show()
            }
        }
    }
}

변경 후

private const val TAG = "MainActivity"

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private lateinit var binding : ActivityMainBinding
    private val viewModel : MyViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater).also {
            setContentView(it.root)
        }
        observeData()
    }

    override fun onResume() {
        super.onResume()
        viewModel.getBeachInfo()
    }

    private fun observeData() {
        with(viewModel){
            networkResult.observe(this@MainActivity){ result ->
                when(result){
                    is NetworkResult.Success -> setBeachCongestionList(result.data) // 성공시
                    is NetworkResult.Failure -> onError(result.code.toString()) // 실패시
                    is NetworkResult.Exception -> onError(result.errorMessage) // 예외 발생시
                    is NetworkResult.Loading -> { // 통신중
                        // 현재 프로젝트에서는 할일이 없음
                    }
                }
            }

            beachCongestionList.observe(this@MainActivity){
                Log.d(TAG, "observeData: $it")
            }
            toastMessage.observe(this@MainActivity){
                Toast.makeText(this@MainActivity , it , Toast.LENGTH_SHORT).show()
            }
        }
    }
}

---

이번 포스팅에서는 네트워크 통신 동작을 Flow로 이전해보는 방법에 대해 다뤄보았습니다.

다음 포스팅에서는 LiveData를 Flow로 변경하여 사용하는 방법에 대해 알아보도록 하겠습니다 😃

 

그럼 오늘도 즐코하세요 :)