Merge pull request #969 from arkivanov/LocalLifecycleOwner-docs

Add docs for LocalLifecycleOwner

Author: arkivanov

docs/component/jetpack-component-context.md

@@ -102,3 +102,58 @@ private class RootViewModel(
     val state: MutableStateFlow<Int> = savedStateHandle.getMutableStateFlow(key = "state", initialValue = 0)
 }
 ```
+
+### LocalLifecycleOwner in Compose
+
+By default, Decompose does nothing with `LocalLifecycleOwner`. Most likely you will get the hosting Activity (or Fragment) `Lifecycle`, it will not respond to screen changes. You can use the following approach to overcome this limitation.
+
+```kotlin
+interface RootComponent {
+    val stack: Value<ChildStack<*, Child>>
+
+    // Child implements LifecycleOwner via delegation
+    sealed class Child(lifecycleOwner: LifecycleOwner) : LifecycleOwner by lifecycleOwner {
+        class HomeChild(val component: HomeComponent, lifecycleOwner: LifecycleOwner) : Child(lifecycleOwner)
+    }
+}
+
+class DefaultRootComponent(
+    componentContext: JetpackComponentContext,
+) : RootComponent, JetpackComponentContext by componentContext {
+
+    private val nav = StackNavigation<Config>()
+
+    override val stack: Value<ChildStack<*, RootComponent.Child>> =
+        childStack(
+            source = nav,
+            serializer = Config.serializer(),
+            initialConfiguration = Config.Home,
+        ) { cfg, ctx ->
+            when (cfg) {
+                is Config.Home ->
+                    RootComponent.Child.HomeChild(
+                        component = DefaultHomeComponent(ctx),
+                        lifecycleOwner = ctx, // The child JetpackComponentContext implements LifecycleOwner
+                    )
+            }
+        }
+
+    @Serializable
+    private sealed interface Config {
+        @Serializable
+        data object Home : Config
+    }
+}
+
+@Composable
+fun RootContent(component: RootComponent) {
+    Children(stack = component.stack) {
+        // Provide LocalLifecycleOwner for child screens
+        CompositionLocalProvider(LocalLifecycleOwner provides it.instance) {
+            when (val child = it.instance) {
+                is RootComponent.Child.HomeChild -> HomeContent(child.component)
+            }
+        }
+    }
+}
+```

sample/app-android/build.gradle.kts

@@ -3,6 +3,7 @@ import com.arkivanov.gradle.setupAndroidApp
 plugins {
     id("com.android.application")
     id("kotlin-android")
+    id("kotlinx-serialization")
     id("org.jetbrains.compose")
     id("org.jetbrains.kotlin.plugin.compose")
     id("com.arkivanov.gradle.setup")
@@ -27,7 +28,9 @@ android {
 
 dependencies {
     implementation(project(":decompose"))
+    implementation(project(":jetpack-component-context"))
     implementation(project(":extensions-android"))
+    implementation(project(":extensions-compose"))
     implementation(project(":sample:shared:shared"))
     implementation(project(":sample:shared:compose"))
     implementation(compose.runtime)

sample/app-android/src/main/java/com/arkivanov/sample/app/Foo.kt

@@ -0,0 +1,64 @@
+package com.arkivanov.sample.app
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import com.arkivanov.decompose.extensions.compose.stack.Children
+import com.arkivanov.decompose.jetpackcomponentcontext.JetpackComponentContext
+import com.arkivanov.decompose.router.stack.ChildStack
+import com.arkivanov.decompose.router.stack.StackNavigation
+import com.arkivanov.decompose.router.stack.childStack
+import com.arkivanov.decompose.value.Value
+import kotlinx.serialization.Serializable
+
+interface HomeComponent
+
+class DefaultHomeComponent(ctx: JetpackComponentContext) : HomeComponent
+
+@Composable
+fun HomeContent(component: HomeComponent) {
+}
+
+interface RootComponent {
+    val stack: Value<ChildStack<*, Child>>
+
+    sealed class Child(lifecycleOwner: LifecycleOwner) : LifecycleOwner by lifecycleOwner {
+        class HomeChild(val component: HomeComponent, lifecycleOwner: LifecycleOwner) : Child(lifecycleOwner)
+    }
+}
+
+class DefaultRootComponent(
+    componentContext: JetpackComponentContext,
+) : RootComponent, JetpackComponentContext by componentContext {
+
+    private val nav = StackNavigation<Config>()
+
+    override val stack: Value<ChildStack<*, RootComponent.Child>> =
+        childStack(
+            source = nav,
+            serializer = Config.serializer(),
+            initialConfiguration = Config.Home,
+        ) { cfg, ctx ->
+            when (cfg) {
+                is Config.Home -> RootComponent.Child.HomeChild(DefaultHomeComponent(ctx), ctx)
+            }
+        }
+
+    @Serializable
+    private sealed interface Config {
+        @Serializable
+        data object Home : Config
+    }
+}
+
+@Composable
+fun RootContent(component: RootComponent) {
+    Children(stack = component.stack) {
+        CompositionLocalProvider(LocalLifecycleOwner provides it.instance) {
+            when (val child = it.instance) {
+                is RootComponent.Child.HomeChild -> HomeContent(child.component)
+            }
+        }
+    }
+}