Support UiMediaScope (All Platforms)

compose/foundation/foundation/src/jsMain/kotlin/androidx/compose/foundation/text/ClipboardEventsHandler.js.kt

@@ -36,7 +36,7 @@ internal actual inline fun rememberClipboardEventsHandler(
     isEnabled: Boolean,
 ): Boolean {
     if (isEnabled) {
-        val clipEventsTargetProvider = LocalActiveClipEventsTarget.current
+        val clipEventsTarget = LocalActiveClipEventsTarget.current
         DisposableEffect(Unit) {
             val copyListener = EventListener { event ->
                 val textToCopy = onCopy()
@@ -62,15 +62,14 @@ internal actual inline fun rememberClipboardEventsHandler(
                 }
             }
 
-            val eventsTarget = clipEventsTargetProvider()
-            eventsTarget?.addEventListener("copy", copyListener)
-            eventsTarget?.addEventListener("paste", pasteListener)
-            eventsTarget?.addEventListener("cut", cutListener)
+            clipEventsTarget?.addEventListener("copy", copyListener)
+            clipEventsTarget?.addEventListener("paste", pasteListener)
+            clipEventsTarget?.addEventListener("cut", cutListener)
 
             onDispose {
-                eventsTarget?.removeEventListener("copy", copyListener)
-                eventsTarget?.removeEventListener("paste", pasteListener)
-                eventsTarget?.removeEventListener("cut", cutListener)
+                clipEventsTarget?.removeEventListener("copy", copyListener)
+                clipEventsTarget?.removeEventListener("paste", pasteListener)
+                clipEventsTarget?.removeEventListener("cut", cutListener)
             }
         }
     }

compose/foundation/foundation/src/wasmJsMain/kotlin/androidx/compose/foundation/text/ClipboardEventsHandler.wasm.kt

@@ -37,7 +37,7 @@ internal actual inline fun rememberClipboardEventsHandler(
     isEnabled: Boolean,
 ): Boolean {
     if (isEnabled) {
-        val clipEventsTargetProvider = LocalActiveClipEventsTarget.current
+        val clipEventsTarget = LocalActiveClipEventsTarget.current
         DisposableEffect(Unit) {
             val copyListener = EventListener { event ->
                 val textToCopy = onCopy()
@@ -63,15 +63,14 @@ internal actual inline fun rememberClipboardEventsHandler(
                 }
             }
 
-            val eventsTarget = clipEventsTargetProvider()
-            eventsTarget?.addEventListener("copy", copyListener)
-            eventsTarget?.addEventListener("paste", pasteListener)
-            eventsTarget?.addEventListener("cut", cutListener)
+            clipEventsTarget?.addEventListener("copy", copyListener)
+            clipEventsTarget?.addEventListener("paste", pasteListener)
+            clipEventsTarget?.addEventListener("cut", cutListener)
 
             onDispose {
-                eventsTarget?.removeEventListener("copy", copyListener)
-                eventsTarget?.removeEventListener("paste", pasteListener)
-                eventsTarget?.removeEventListener("cut", cutListener)
+                clipEventsTarget?.removeEventListener("copy", copyListener)
+                clipEventsTarget?.removeEventListener("paste", pasteListener)
+                clipEventsTarget?.removeEventListener("cut", cutListener)
             }
         }
     }

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/ProvideSystemTheme.desktop.kt

@@ -17,76 +17,24 @@
 package androidx.compose.ui
 
 
-import androidx.annotation.VisibleForTesting
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.mutableStateOf
-import kotlin.time.Duration.Companion.seconds
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import org.jetbrains.skiko.hostOs
-
-private var subscriberCount = 0
-private var pollingJob: Job? = null
-private val subscribeLock = Any()
-private var currentSystemTheme = mutableStateOf(org.jetbrains.skiko.currentSystemTheme)
-
-@OptIn(DelicateCoroutinesApi::class)
-private fun onSubscriberAdded() {
-    synchronized(subscribeLock) {
-        if (subscriberCount == 0) {
-            pollingJob = GlobalScope.launch {
-                withContext(Dispatchers.IO) {
-                    pollCurrentSystemTheme()
-                }
-            }
-        }
-        subscriberCount += 1
-    }
-}
-
-private fun onSubscriberRemoved() {
-    synchronized(subscribeLock) {
-        subscriberCount -= 1
-        if (subscriberCount == 0) {
-            pollingJob?.cancel()
-            pollingJob = null
-        }
-    }
-}
-
-private suspend fun pollCurrentSystemTheme() {
-    while (true) {
-        currentSystemTheme.value = org.jetbrains.skiko.currentSystemTheme
-        delay(1.seconds)
-    }
-}
+import androidx.compose.ui.platform.DesktopMediaEnvironment
 
 @Composable
-internal fun ProvideSystemTheme(content: @Composable () -> Unit) {
+internal fun ProvideSystemTheme(mediaEnvironment: DesktopMediaEnvironment, content: @Composable () -> Unit) {
     CompositionLocalProvider(
-        LocalSystemTheme provides currentSystemTheme.value,
+        LocalSystemTheme provides mediaEnvironment.systemTheme ,
         content = content
     )
 
     if (DesktopComposeUiFlags.pollSystemTheme) {
         DisposableEffect(Unit) {
-            onSubscriberAdded()
+            mediaEnvironment.onSystemThemeSubscriberAdded()
             onDispose {
-                onSubscriberRemoved()
+                mediaEnvironment.onSystemThemeSubscriberRemoved()
             }
         }
     }
 }
-
-@VisibleForTesting
-internal fun systemThemeSubscriberCount() = subscriberCount
-
-@VisibleForTesting
-internal fun systemThemePollingJob() = pollingJob

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/platform/PlatformMediaEnvironment.desktop.kt

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * 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.
+ */
+
+@file:OptIn(ExperimentalMediaQueryApi::class)
+
+package androidx.compose.ui.platform
+
+import androidx.annotation.VisibleForTesting
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.ExperimentalMediaQueryApi
+import androidx.compose.ui.UiMediaScope
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.window.GlobalDensity
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.jetbrains.skiko.SystemTheme
+
+internal class DesktopMediaEnvironment(val windowInfo: WindowInfo) : PlatformMediaEnvironment {
+
+
+
+    private var systemThemeSubscriberCount = 0
+    private var pollingSystemThemeJob: Job? = null
+    private val systemThemeSubscribeLock = Any()
+    private var currentSystemTheme = mutableStateOf(org.jetbrains.skiko.currentSystemTheme)
+
+    @OptIn(DelicateCoroutinesApi::class)
+    internal fun onSystemThemeSubscriberAdded() {
+        synchronized(systemThemeSubscribeLock) {
+            if (systemThemeSubscriberCount == 0) {
+                pollingSystemThemeJob = GlobalScope.launch {
+                    withContext(Dispatchers.IO) {
+                        pollCurrentSystemTheme()
+                    }
+                }
+            }
+            systemThemeSubscriberCount += 1
+        }
+    }
+
+    internal fun onSystemThemeSubscriberRemoved() {
+        synchronized(systemThemeSubscribeLock) {
+            systemThemeSubscriberCount -= 1
+            if (systemThemeSubscriberCount == 0) {
+                pollingSystemThemeJob?.cancel()
+                pollingSystemThemeJob = null
+            }
+        }
+    }
+
+    private suspend fun pollCurrentSystemTheme() {
+        while (true) {
+            currentSystemTheme.value = org.jetbrains.skiko.currentSystemTheme
+            delay(1.seconds)
+        }
+    }
+
+    @VisibleForTesting
+    internal fun systemThemeSubscriberCount() = systemThemeSubscriberCount
+
+    @VisibleForTesting
+    internal fun systemThemePollingJob() = pollingSystemThemeJob
+
+    override val systemTheme: SystemTheme
+        get() = currentSystemTheme.value
+
+    override val systemDensity: Density
+        get() = GlobalDensity
+
+    override val windowPosture: UiMediaScope.Posture
+        get() = UiMediaScope.Posture.Flat
+
+    override val windowWidth: Dp
+        get() = windowInfo.containerDpSize.width
+
+    override val windowHeight: Dp
+        get() = windowInfo.containerDpSize.height
+
+    override val pointerPrecision: UiMediaScope.PointerPrecision
+        get() = UiMediaScope.PointerPrecision.Fine
+
+    override val keyboardKind: UiMediaScope.KeyboardKind
+        get() = UiMediaScope.KeyboardKind.Physical
+
+    override val hasMicrophone: Boolean
+        get() = true //inferred as always having at least 1 microphone
+
+    override val hasCamera: Boolean
+        get() = false //no reliable way to get it
+
+    override val viewingDistance: UiMediaScope.ViewingDistance
+        get() = UiMediaScope.ViewingDistance.Near
+
+    fun dispose() {
+        pollingSystemThemeJob?.cancel()
+    }
+}

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/scene/ComposeSceneMediator.desktop.kt

@@ -51,13 +51,15 @@ import androidx.compose.ui.navigationevent.BackNavigationEventInput
 import androidx.compose.ui.platform.AwtDragAndDropManager
 import androidx.compose.ui.platform.DefaultInputModeManager
 import androidx.compose.ui.platform.DelegateRootForTestListener
+import androidx.compose.ui.platform.DesktopMediaEnvironment
 import androidx.compose.ui.platform.DesktopTextInputService
 import androidx.compose.ui.platform.DesktopTextInputService2
 import androidx.compose.ui.platform.FrameRecomposer
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
 import androidx.compose.ui.platform.PlatformComponent
 import androidx.compose.ui.platform.PlatformContext
 import androidx.compose.ui.platform.PlatformDragAndDropManager
+import androidx.compose.ui.platform.PlatformMediaEnvironment
 import androidx.compose.ui.platform.PlatformTextInputMethodRequest
 import androidx.compose.ui.platform.PlatformWindowContext
 import androidx.compose.ui.platform.ViewConfiguration
@@ -164,6 +166,8 @@ internal class ComposeSceneMediator(
         DesktopTextInputService2(platformComponent)
     }
 
+    private val desktopMediaEnvironment = DesktopMediaEnvironment(windowInfo = windowContext.windowInfo)
+
     // TODO: It must be shared between Compose instances.
     //  It's supposed to be stored in platform's root view or window.
     val frameRecomposer = FrameRecomposer(coroutineContext, ::needRender)
@@ -628,6 +632,8 @@ internal class ComposeSceneMediator(
         // Since rendering will not happen after, we need to execute all scheduled updates
         interopContainer.dispose()
 
+        desktopMediaEnvironment.dispose()
+
         _onComponentAttached = null
     }
 
@@ -678,7 +684,7 @@ internal class ComposeSceneMediator(
         runOnceComponentAttached {
             catchExceptions {
                 scene.setContent {
-                    ProvideSystemTheme {
+                    ProvideSystemTheme(desktopMediaEnvironment) {
                         interopContainer {
                             content()
                         }
@@ -832,6 +838,7 @@ internal class ComposeSceneMediator(
 
     private inner class DesktopPlatformContext : PlatformContext {
         override val windowInfo: WindowInfo get() = windowContext.windowInfo
+        override val mediaEnvironment: PlatformMediaEnvironment get() = desktopMediaEnvironment
         override val architectureComponentsOwner get() = this@ComposeSceneMediator.architectureComponentsOwner
         override val isWindowTransparent: Boolean get() = windowContext.isWindowTransparent
 

compose/ui/ui/src/desktopTest/kotlin/androidx/compose/ui/platform/SystemThemeTest.kt

@@ -22,8 +22,6 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.ComposeUiFlags
 import androidx.compose.ui.ProvideSystemTheme
 import androidx.compose.ui.pollSystemTheme
-import androidx.compose.ui.systemThemePollingJob
-import androidx.compose.ui.systemThemeSubscriberCount
 import androidx.compose.ui.test.ExperimentalTestApi
 import androidx.compose.ui.test.v2.runComposeUiTest
 import kotlin.test.Test
@@ -38,36 +36,37 @@ class SystemThemeTest {
         val prevValue = ComposeUiFlags.pollSystemTheme
         ComposeUiFlags.pollSystemTheme = true
         try {
+            val desktopMediaEnvironment = DesktopMediaEnvironment(WindowInfoImpl())
             runComposeUiTest {
                 var provideSystemTheme1 by mutableStateOf(false)
                 var provideSystemTheme2 by mutableStateOf(false)
                 setContent {
                     if (provideSystemTheme1) {
-                        ProvideSystemTheme { }
+                        ProvideSystemTheme(desktopMediaEnvironment) { }
                     }
                     if (provideSystemTheme2) {
-                        ProvideSystemTheme { }
+                        ProvideSystemTheme(desktopMediaEnvironment) { }
                     }
                 }
 
-                assertEquals(0, systemThemeSubscriberCount())
-                assertNull(systemThemePollingJob())
+                assertEquals(0, desktopMediaEnvironment.systemThemeSubscriberCount())
+                assertNull(desktopMediaEnvironment.systemThemePollingJob())
 
                 provideSystemTheme1 = true
                 waitForIdle()
-                assertEquals(1, systemThemeSubscriberCount())
-                assertNotNull(systemThemePollingJob())
+                assertEquals(1, desktopMediaEnvironment.systemThemeSubscriberCount())
+                assertNotNull(desktopMediaEnvironment.systemThemePollingJob())
 
                 provideSystemTheme2 = true
                 waitForIdle()
-                assertEquals(2, systemThemeSubscriberCount())
-                assertNotNull(systemThemePollingJob())
+                assertEquals(2, desktopMediaEnvironment.systemThemeSubscriberCount())
+                assertNotNull(desktopMediaEnvironment.systemThemePollingJob())
 
                 provideSystemTheme1 = false
                 provideSystemTheme2 = false
                 waitForIdle()
-                assertEquals(0, systemThemeSubscriberCount())
-                assertNull(systemThemePollingJob())
+                assertEquals(0, desktopMediaEnvironment.systemThemeSubscriberCount())
+                assertNull(desktopMediaEnvironment.systemThemePollingJob())
             }
         } finally {
             ComposeUiFlags.pollSystemTheme = prevValue