Expose HostConfiguration type to Compose through Treehouse

redwood-treehouse-composeui/src/main/kotlin/app/cash/redwood/treehouse/composeui/TreehouseComposeView.kt

@@ -17,16 +17,22 @@ package app.cash.redwood.treehouse.composeui
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Configuration
+import android.content.res.Configuration.UI_MODE_NIGHT_MASK
+import android.content.res.Configuration.UI_MODE_NIGHT_YES
 import android.view.ViewGroup.LayoutParams.MATCH_PARENT
 import android.widget.FrameLayout
 import androidx.compose.foundation.layout.Column
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.platform.ComposeView
+import app.cash.redwood.treehouse.HostConfiguration
 import app.cash.redwood.treehouse.TreehouseApp
 import app.cash.redwood.treehouse.TreehouseView
 import app.cash.redwood.widget.Widget
 import app.cash.redwood.widget.compose.ComposeWidgetChildren
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 
 @SuppressLint("ViewConstructor")
 public class TreehouseComposeView<T : Any>(
@@ -62,6 +68,12 @@ public class TreehouseComposeView<T : Any>(
       }
     }
 
+  private val mutableHostConfiguration =
+    MutableStateFlow(computeHostConfiguration(context.resources.configuration))
+
+  override val hostConfiguration: StateFlow<HostConfiguration>
+    get() = mutableHostConfiguration
+
   public fun setContent(content: TreehouseView.Content<T>) {
     treehouseApp.dispatchers.checkUi()
     this.content = content
@@ -78,6 +90,19 @@ public class TreehouseComposeView<T : Any>(
     treehouseApp.onContentChanged(this)
   }
 
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+    mutableHostConfiguration.value = computeHostConfiguration(newConfig)
+  }
+
   override fun generateDefaultLayoutParams(): LayoutParams =
     LayoutParams(MATCH_PARENT, MATCH_PARENT)
 }
+
+private fun computeHostConfiguration(
+  config: Configuration,
+): HostConfiguration {
+  return HostConfiguration(
+    darkMode = (config.uiMode and UI_MODE_NIGHT_MASK) == UI_MODE_NIGHT_YES,
+  )
+}

redwood-treehouse/src/androidMain/kotlin/app/cash/redwood/treehouse/TreehouseWidgetView.kt

@@ -17,11 +17,16 @@ package app.cash.redwood.treehouse
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Configuration
+import android.content.res.Configuration.UI_MODE_NIGHT_MASK
+import android.content.res.Configuration.UI_MODE_NIGHT_YES
 import android.view.View
 import android.view.ViewGroup.LayoutParams.MATCH_PARENT
 import android.widget.FrameLayout
 import app.cash.redwood.widget.ViewGroupChildren
 import app.cash.redwood.widget.Widget
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 
 @SuppressLint("ViewConstructor")
 public class TreehouseWidgetView<T : Any>(
@@ -41,6 +46,12 @@ public class TreehouseWidgetView<T : Any>(
 
   override val children: Widget.Children<*> = ViewGroupChildren(this)
 
+  private val mutableHostConfiguration =
+    MutableStateFlow(computeHostConfiguration(context.resources.configuration))
+
+  override val hostConfiguration: StateFlow<HostConfiguration>
+    get() = mutableHostConfiguration
+
   public fun setContent(content: TreehouseView.Content<T>) {
     treehouseApp.dispatchers.checkUi()
     this.content = content
@@ -57,6 +68,19 @@ public class TreehouseWidgetView<T : Any>(
     treehouseApp.onContentChanged(this)
   }
 
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+    mutableHostConfiguration.value = computeHostConfiguration(newConfig)
+  }
+
   override fun generateDefaultLayoutParams(): LayoutParams =
     LayoutParams(MATCH_PARENT, MATCH_PARENT)
 }
+
+private fun computeHostConfiguration(
+  config: Configuration,
+): HostConfiguration {
+  return HostConfiguration(
+    darkMode = (config.uiMode and UI_MODE_NIGHT_MASK) == UI_MODE_NIGHT_YES,
+  )
+}

redwood-treehouse/src/commonMain/kotlin/app/cash/redwood/treehouse/FlowWithInitialValue.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2022 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package app.cash.redwood.treehouse
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+
+@Serializable
+public data class FlowWithInitialValue<T>(
+  val initial: T,
+  @Contextual val flow: Flow<T>,
+)
+
+public fun <T> StateFlow<T>.toFlowWithInitialValue(): FlowWithInitialValue<T> =
+  FlowWithInitialValue(value, this)

redwood-treehouse/src/commonMain/kotlin/app/cash/redwood/treehouse/HostConfiguration.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2022 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package app.cash.redwood.treehouse
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+public data class HostConfiguration(
+  val darkMode: Boolean = false,
+) {
+  public companion object
+}

redwood-treehouse/src/commonMain/kotlin/app/cash/redwood/treehouse/ZiplineTreehouseUi.kt

@@ -24,6 +24,9 @@ import app.cash.zipline.ZiplineService
  * Most callers shouldn't use this directly; instead use `TreehouseUi`.
  */
 public interface ZiplineTreehouseUi : ZiplineService {
-  public fun start(diffSink: DiffSinkService)
+  public fun start(
+    diffSink: DiffSinkService,
+    hostConfigurations: FlowWithInitialValue<HostConfiguration>,
+  )
   public fun sendEvent(event: Event)
 }

redwood-treehouse/src/hostMain/kotlin/app/cash/redwood/treehouse/TreehouseApp.kt

@@ -197,7 +197,7 @@ public class TreehouseApp<T : Any>(
         }
       }
 
-      content.start(diffSinkService)
+      content.start(diffSinkService, view.hostConfiguration.toFlowWithInitialValue())
     }
 
     fun cancel() {

redwood-treehouse/src/hostMain/kotlin/app/cash/redwood/treehouse/TreehouseView.kt

@@ -16,11 +16,13 @@
 package app.cash.redwood.treehouse
 
 import app.cash.redwood.widget.Widget
+import kotlinx.coroutines.flow.StateFlow
 
 public interface TreehouseView<T : Any> {
   /** This is the actual content, or null if not attached to the screen. */
   public val boundContent: Content<T>?
   public val children: Widget.Children<*>
+  public val hostConfiguration: StateFlow<HostConfiguration>
 
   public interface Content<T : Any> {
     public fun get(app: T): ZiplineTreehouseUi

redwood-treehouse/src/iosMain/kotlin/app/cash/redwood/treehouse/TreehouseUIKitView.kt

@@ -19,7 +19,11 @@ import app.cash.redwood.widget.MutableListChildren
 import app.cash.redwood.widget.Widget
 import kotlinx.cinterop.ObjCAction
 import kotlinx.cinterop.cValue
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import platform.CoreGraphics.CGRectZero
+import platform.UIKit.UITraitCollection
+import platform.UIKit.UIUserInterfaceStyle.UIUserInterfaceStyleDark
 import platform.UIKit.UIView
 import platform.UIKit.addSubview
 import platform.UIKit.removeFromSuperview
@@ -48,6 +52,11 @@ public class TreehouseUIKitView<T : Any>(
       newViews.forEach(view::addSubview)
     }
 
+  private val mutableHostConfiguration = MutableStateFlow(HostConfiguration())
+
+  override val hostConfiguration: StateFlow<HostConfiguration>
+    get() = mutableHostConfiguration
+
   public fun setContent(content: TreehouseView.Content<T>) {
     treehouseApp.dispatchers.checkUi()
     this.content = content
@@ -57,6 +66,12 @@ public class TreehouseUIKitView<T : Any>(
   internal fun superviewChanged() {
     treehouseApp.onContentChanged(this)
   }
+
+  internal fun updateHostConfiguration(traitCollection: UITraitCollection) {
+    mutableHostConfiguration.value = HostConfiguration(
+      darkMode = traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark,
+    )
+  }
 }
 
 @Suppress("unused") // cinterop erroneously exposes these as extension functions.
@@ -71,5 +86,13 @@ private class RootUiView(
 
   @ObjCAction fun didMoveToSuperview() {
     treehouseView.superviewChanged()
+    if (superview != null) {
+      treehouseView.updateHostConfiguration(traitCollection)
+    }
+  }
+
+  override fun traitCollectionDidChange(previousTraitCollection: UITraitCollection?) {
+    super.traitCollectionDidChange(previousTraitCollection)
+    treehouseView.updateHostConfiguration(traitCollection)
   }
 }

redwood-treehouse/src/jsMain/kotlin/app/cash/redwood/treehouse/HostConfiguration.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2022 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package app.cash.redwood.treehouse
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.ProvidableCompositionLocal
+import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.runtime.compositionLocalOf
+import app.cash.redwood.compose.WidgetVersion
+
+/**
+ * Provide the configuration of the host display.
+ * This value will be bound automatically when Treehouse is used.
+ * Custom values should only be provided into a composition for testing purposes!
+ *
+ * @see WidgetVersion
+ */
+public val LocalHostConfiguration: ProvidableCompositionLocal<HostConfiguration> =
+  compositionLocalOf {
+    throw AssertionError("HostConfiguration was not provided!")
+  }
+
+/**
+ * Expose various configuration properties of the host.
+ *
+ * @see HostConfiguration
+ */
+@Suppress("unused") // Emulating a CompositionLocal.
+public val HostConfiguration.Companion.current: HostConfiguration
+  @Composable
+  @ReadOnlyComposable
+  get() = LocalHostConfiguration.current

redwood-treehouse/src/jsMain/kotlin/app/cash/redwood/treehouse/treehouseCompose.kt

@@ -16,6 +16,9 @@
 package app.cash.redwood.treehouse
 
 import androidx.compose.runtime.BroadcastFrameClock
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import app.cash.redwood.protocol.Event
 import app.cash.redwood.protocol.compose.DiffProducingWidget
 import app.cash.redwood.protocol.compose.ProtocolRedwoodComposition
@@ -37,37 +40,39 @@ public fun TreehouseUi.asZiplineTreehouseUi(
     factory = factory,
     widgetVersion = widgetVersion,
   )
-
-  return composition.asZiplineTreehouseUi {
-    composition.setContent {
-      Show()
-    }
-  }
+  return RedwoodZiplineTreehouseUi(composition, this)
 }
 
-private fun ProtocolRedwoodComposition.asZiplineTreehouseUi(
-  startSignal: () -> Unit = {},
-): ZiplineTreehouseUi {
-  val delegate = this
+private class RedwoodZiplineTreehouseUi(
+  private val composition: ProtocolRedwoodComposition,
+  private val treehouseUi: TreehouseUi,
+) : ZiplineTreehouseUi {
+  private var diffSinkToClose: DiffSinkService? = null
 
-  return object : ZiplineTreehouseUi {
-    var diffSinkToClose: DiffSinkService? = null
+  override fun sendEvent(event: Event) {
+    composition.sendEvent(event)
+  }
 
-    override fun sendEvent(event: Event) {
-      delegate.sendEvent(event)
-    }
+  override fun start(
+    diffSink: DiffSinkService,
+    hostConfigurations: FlowWithInitialValue<HostConfiguration>,
+  ) {
+    check(diffSinkToClose == null)
+    diffSinkToClose = diffSink
+    composition.start(diffSink)
 
-    override fun start(diffSink: DiffSinkService) {
-      check(diffSinkToClose == null)
-      diffSinkToClose = diffSink
-      delegate.start(diffSink)
-      startSignal()
+    val (initialHostConfiguration, hostConfigurationFlow) = hostConfigurations
+    composition.setContent {
+      val hostConfiguration by hostConfigurationFlow.collectAsState(initialHostConfiguration)
+      CompositionLocalProvider(LocalHostConfiguration provides hostConfiguration) {
+        treehouseUi.Show()
+      }
     }
+  }
 
-    override fun close() {
-      delegate.cancel()
-      diffSinkToClose?.close()
-    }
+  override fun close() {
+    composition.cancel()
+    diffSinkToClose?.close()
   }
 }