Best Practice for Cancelling DataStore Flow When Component Is Destroyed Using Decompose 🛠️✨

[OsmanMusse]

Hi Arkivanov, 👋

I'm using the Decompose library and implementing a HomeListComponent where I need to cancel a DataStore flow when the component is destroyed or cleared. I noticed the onCleared function in ViewModels seems analogous to doOnDestroy in Decompose.

I’ve implemented something similar to how this would be handled with ViewModel, but using Decompose instead. The reason for this approach is that flows should ideally not be collected in ViewModels, and if they are, their jobs must be controlled and canceled when they are no longer needed to avoid memory leaks or unexpected behavior.

Before I proceed, I wanted to confirm if this looks like a good approach or if there’s a better way to handle flow cancellation in such a scenario with Decompose.

Here's the relevant code snippet:

    interface HomeListComponent: BackHandlerOwner {
     val stack: Value<ChildStack<*, Child>>
     val posts: Flow<PagingData<Post>>
     val state: Value<HomeScreenState>

    fun navigateToFilterScreen(selectedPropertyType: PropertyType?, selectedCategoryType: CategoryType?)
    fun navigateToDetailsScreen(postID: Long?)
    fun navigateToLocationScreen(location: String)
    fun emptyPagingData()

    fun onCleared()
    fun onBackPressed()

    sealed interface Child {
        data object DefaultChild: Child
        class FilterChild(val component: FilterComponent): Child
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class DefaultHomeListComponent(
    private val componentContext: ComponentContext,
    private val filterFactory: DefaultFilterComponent.Factory,
    private val postRepo: PostRepository,
    private val appPreferenceRepo: AppPreferencesRepository,
    private val onPushScreen: (String) -> Unit,
    private val onPushLocationScreen: (String) -> Unit
) : HomeListComponent, ComponentContext by componentContext {

    private val componentScope = coroutineScope(Dispatchers.IO)

    private var appPreferenceCollectorJob: Job? = null

    init {
        observeAppPreference()
        observeLikedPosts()
    }

    private fun observeAppPreference() {
        appPreferenceCollectorJob = componentScope.launch {
            appPreferenceRepo.appPreferenceFlow.collectLatest { appSettings ->
                println("App Preference Updated == $appSettings")
                updateCurrentCity(location = appSettings.defaultCity.displayName)
            }
        }
    }

    override fun onCleared() {
        componentContext.lifecycle.doOnDestroy {
            appPreferenceCollectorJob?.cancel()
        }
    }

    private fun updateCurrentCity(location: String) {
        _state.value = _state.value.copy(currentCity = location)
        currentCity.value = location
    }
}

[arkivanov]

As mentioned in the docs, if you are using coroutineScope(...) extension function, the scope is cancelled automatically when the component is destroyed. So there should be no need to manually cancel the jobs.

Also, most likely you want to use Dispatchers.Main.immediate instead of Dispatchers.IO. DataStore should switch the threads on its own anyway, and you should have less problems with threading when updating states etc. In particular, _state.value = _state.value.copy(currentCity = location) is not atomic, you may have problems when that code is called concurrently.

[OsmanMusse]

Thank you for the detailed reply! Your points are spot on, and I appreciate the clarification. I'll make sure to rely on the automatic cancellation provided by coroutineScope and adjust to using Dispatchers.Main.immediate where appropriate. Thanks again for the insights! 🙏🏽