IssueTracker

snapshot: 6759487

Requesting a new API to scope ViewModel lifecycle to a composable scope.

example of incorrect usage

This came up when a ViewModel was incorrectly being re-used for the same screen with different parameters:

@Composable
fun ArticleScreen(
    postId: String,
    postsRepository: PostsRepository,
    onBack: () -> Unit
) {
    val articleViewModel =
        viewModel<ArticleViewModel>(factory = ArticleViewModelFactory(postId, postsRepository))

This code incorrectly re-uses postId for multiple copies of the same composable, when it instead expects a new ViewModel for this screen.

example of correct usage

Fixed in JetNews sample in https://github.com/android/compose-samples/pull/116/commits/80a400ab9ea615a5f2bb5b90166951d97ed08ec3

New call with correct behavior scopes the ViewModel to the composable lifecycle:

@Composable
fun ArticleScreen(
    postId: String,
    postsRepository: PostsRepository,
    onBack: () -> Unit
) = ViewModelLifecycleScope {
    val articleViewModel =
        viewModel<ArticleViewModel>(factory = ArticleViewModelFactory(postId, postsRepository))

sample API (that doesn't retain on configuration changes)

/**
 * Creates a composition-based scope lifecycle for [viewModel] in compose.
 *
 * All ViewModels created in this scope will be cleared when [ViewModelLifecycleScope] leaves the
 * composition tree.
 *
 * The scoped view model store is isolated from the current [ViewModelStoreOwnerAmbient]. It will
 * not attempt to lookup existing ViewModel instances in any parent [ViewModelStoreOwnerAmbient].
 *
 * Usage:
 *
 * ```
 * @Composable
 * fun UsesViewModelScope() = ViewModelLifecycleScope {
 *     // This instance of myViewModel will call [onCleared] as soon as this composable leaves the
 *     // composition tree.
 *     //
 *     // If this composable is added to the composition tree multiple times it will create multiple
 *     // MyViewModels, one for each instance of this composable.
 *     //
 *     // If this composable is removed and added to the composition tree, the MyViewModel will call
 *     // [onCleared] and then a new MyViewModel will be created.
 *     val myViewModel = viewModels<MyViewModel>()
 *     ...
 * }
 * ```
 *
 * @param content composable lambda that uses the new view model scope
 */
@Composable
fun ViewModelLifecycleScope(content: @Composable () -> Unit) = Providers(
    ViewModelStoreOwnerAmbient provides rememberScopedViewModelStore(),
    children = content
)

/**
 * Returns a [ViewModelStoreOwner] that will match the lifecycle of the call to
 * [rememberScopedViewModelStore].
 *
 * All [ViewModel]s created in this store will be cleared when the call to
 * [rememberScopedViewModelStore] leaves the composition tree.
 *
 * This store is independent of any other [ViewModelStoreOwner] and will not attempt to lookup
 * ViewModels created in another store.
 *
 * @see ViewModelLifecycleScope for usage example
 */
@Composable
fun rememberScopedViewModelStore(): ViewModelStoreOwner = remember { ScopedViewModelStoreOwner() }

/**
 * A ViewModelStoreOwner that will automatically clear the store when removed from composition.
 */
private class ScopedViewModelStoreOwner : ViewModelStoreOwner, CompositionLifecycleObserver {
    private val viewModelStore = ViewModelStore()

    /**
     * Called when CompositionLifecycleObserver is notified that this scope is no longer remembered.
     *
     * @see [CompositionLifecycleObserver.onLeave]
     */
    override fun onLeave() {
        viewModelStore.clear()
    }

    /**
     * @see [ViewModelStoreOwner.getViewModelStore]
     */
    override fun getViewModelStore(): ViewModelStore = viewModelStore
}

We should create a public API that allows developers to conveniently scope ViewModel to composition lifecycle.