OS logging integrated with trace for iOS

compose/mpp/demo/src/uikitMain/kotlin/androidx/compose/mpp/demo/main.uikit.kt

@@ -4,7 +4,11 @@ package androidx.compose.mpp.demo
 import NativeModalWithNaviationExample
 import SwiftUIInteropExample
 import UIKitViewOrder
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.ExperimentalComposeApi
+import androidx.compose.runtime.ExperimentalComposeRuntimeApi
+import androidx.compose.runtime.remember
+import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.main.defaultUIKitMain
 import androidx.compose.ui.platform.AccessibilityDebugLogger
 import androidx.compose.ui.platform.AccessibilitySyncOptions
@@ -16,8 +20,11 @@ import bugs.StartRecompositionCheck
 import platform.UIKit.UIViewController
 
 
-@OptIn(ExperimentalComposeApi::class)
+@OptIn(ExperimentalComposeApi::class, ExperimentalComposeUiApi::class)
 fun main(vararg args: String) {
+    androidx.compose.runtime.enableTraceOSLog()
+    androidx.compose.ui.util.enableTraceOSLog()
+
     val arg = args.firstOrNull() ?: ""
     defaultUIKitMain("ComposeDemo", ComposeUIViewController(configure = {
         accessibilitySyncOptions = AccessibilitySyncOptions.WhenRequiredByAccessibilityServices(object: AccessibilityDebugLogger {

compose/runtime/runtime/build.gradle

@@ -126,6 +126,11 @@ if(AndroidXComposePlugin.isMultiplatformEnabled(project)) {
                     api("androidx.annotation:annotation:1.1.0")
                 }
             }
+            uikitMain {
+                dependencies {
+                    api project(":compose:ui:ui-uikit")
+                }
+            }
 
             commonTest.dependencies {
                 implementation kotlin("test")
@@ -180,10 +185,19 @@ if(AndroidXComposePlugin.isMultiplatformEnabled(project)) {
             desktopMain.dependsOn(jbMain)
             jsNativeMain.dependsOn(jbMain)
 
-            linuxArm64Main.dependsOn(nativeMain)
-            linuxArm64Test.dependsOn(nativeTest)
-            linuxX64Main.dependsOn(nativeMain)
-            linuxX64Test.dependsOn(nativeTest)
+            linuxMain {
+                dependsOn(nativeMain)
+            }
+
+            linuxTest {
+                dependsOn(nativeTest)
+            }
+
+            linuxArm64Main.dependsOn(linuxMain)
+            linuxArm64Test.dependsOn(linuxTest)
+            linuxX64Main.dependsOn(linuxMain)
+            linuxX64Test.dependsOn(linuxTest)
+
             mingwX64Main.dependsOn(nativeMain)
             mingwX64Test.dependsOn(nativeTest)
 

compose/runtime/runtime/src/linuxMain/kotlin/androidx/compose/runtime/Trace.linux.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2024 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.
+ */
+
+package androidx.compose.runtime
+
+internal actual object Trace {
+    /**
+     * Writes a trace message to indicate that a given section of code has begun.
+     * This call must be followed by a corresponding call to [endSection] on the same thread.
+     *
+     * @return An arbitrary token which will be supplied to the corresponding call
+     * to [endSection]. May be null.
+     */
+    actual fun beginSection(name: String): Any? {
+        return null
+    }
+
+    /**
+     * Writes a trace message to indicate that a given section of code has ended.
+     * This call must be preceded by a corresponding call to [beginSection].
+     * Calling this method will mark the end of the most recently begun section of code, so care
+     * must be taken to ensure that `beginSection` / `endSection` pairs are properly nested and
+     * called from the same thread.
+     *
+     * @param token The instance returned from the corresponding call to [beginSection].
+     */
+    actual fun endSection(token: Any?) {
+    }
+
+}

compose/runtime/runtime/src/macosMain/kotlin/androidx/compose/runtime/Trace.macos.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 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.
+ */
+
+package androidx.compose.runtime
+
+internal actual object Trace {
+    /**
+     * Writes a trace message to indicate that a given section of code has begun.
+     * This call must be followed by a corresponding call to [endSection] on the same thread.
+     *
+     * @return An arbitrary token which will be supplied to the corresponding call
+     * to [endSection]. May be null.
+     */
+    actual fun beginSection(name: String): Any? {
+        return null
+    }
+
+    /**
+     * Writes a trace message to indicate that a given section of code has ended.
+     * This call must be preceded by a corresponding call to [beginSection].
+     * Calling this method will mark the end of the most recently begun section of code, so care
+     * must be taken to ensure that `beginSection` / `endSection` pairs are properly nested and
+     * called from the same thread.
+     *
+     * @param token The instance returned from the corresponding call to [beginSection].
+     */
+    actual fun endSection(token: Any?) {
+    }
+}

compose/runtime/runtime/src/mingwX64Main/kotlin/androidx/compose/runtime/Trace.mingwX64.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 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.
+ */
+
+package androidx.compose.runtime
+
+internal actual object Trace {
+    /**
+     * Writes a trace message to indicate that a given section of code has begun.
+     * This call must be followed by a corresponding call to [endSection] on the same thread.
+     *
+     * @return An arbitrary token which will be supplied to the corresponding call
+     * to [endSection]. May be null.
+     */
+    actual fun beginSection(name: String): Any? {
+        return null
+    }
+
+    /**
+     * Writes a trace message to indicate that a given section of code has ended.
+     * This call must be preceded by a corresponding call to [beginSection].
+     * Calling this method will mark the end of the most recently begun section of code, so care
+     * must be taken to ensure that `beginSection` / `endSection` pairs are properly nested and
+     * called from the same thread.
+     *
+     * @param token The instance returned from the corresponding call to [beginSection].
+     */
+    actual fun endSection(token: Any?) {
+    }
+}

compose/runtime/runtime/src/nativeMain/kotlin/androidx/compose/runtime/ActualNative.native.kt

@@ -58,15 +58,6 @@ private class MonotonicClockImpl : MonotonicFrameClock {
     }
 }
 
-internal actual object Trace {
-    actual fun beginSection(name: String): Any? {
-        return null
-    }
-
-    actual fun endSection(token: Any?) {
-    }
-}
-
 actual annotation class CheckResult actual constructor(actual val suggest: String)
 
 @ExperimentalComposeApi

compose/runtime/runtime/src/tvOsMain/kotlin/androidx/compose/runtime/Trace.tvOs.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 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.
+ */
+
+package androidx.compose.runtime
+
+internal actual object Trace {
+    /**
+     * Writes a trace message to indicate that a given section of code has begun.
+     * This call must be followed by a corresponding call to [endSection] on the same thread.
+     *
+     * @return An arbitrary token which will be supplied to the corresponding call
+     * to [endSection]. May be null.
+     */
+    actual fun beginSection(name: String): Any? {
+        return null
+    }
+
+    /**
+     * Writes a trace message to indicate that a given section of code has ended.
+     * This call must be preceded by a corresponding call to [beginSection].
+     * Calling this method will mark the end of the most recently begun section of code, so care
+     * must be taken to ensure that `beginSection` / `endSection` pairs are properly nested and
+     * called from the same thread.
+     *
+     * @param token The instance returned from the corresponding call to [beginSection].
+     */
+    actual fun endSection(token: Any?) {
+    }
+}

compose/runtime/runtime/src/uikitMain/kotlin/androidx/compose/runtime/Trace.uikit.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2024 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.
+ */
+
+package androidx.compose.runtime
+
+import androidx.compose.ui.uikit.utils.CMPOSLogger
+import androidx.compose.ui.uikit.utils.CMPOSLoggerInterval
+
+
+/**
+ * Enables iOS OS logging for the `androidx.compose.runtime` APIs.
+ *
+ * Tracing allows logging detailed information about the Compose UI framework, which can be further
+ * analyzed using the XCode Instruments tool.
+ *
+ * This method is an [ExperimentalComposeApi], which means it is subject to change without notice in major, minor, or patch releases.
+ *
+ * @see ExperimentalComposeApi
+ */
+@ExperimentalComposeApi
+fun enableTraceOSLog() {
+    if (traceImpl == null) {
+        traceImpl = CMPOSLogger(categoryName = "androidx.compose.runtime")
+    }
+}
+
+private var traceImpl: CMPOSLogger? = null
+
+internal actual object Trace {
+    /**
+     * Writes a trace message to indicate that a given section of code has begun.
+     * This call must be followed by a corresponding call to [endSection] on the same thread.
+     *
+     * @return An arbitrary token which will be supplied to the corresponding call
+     * to [endSection]. May be null.
+     */
+    actual fun beginSection(name: String): Any? {
+        return traceImpl?.beginIntervalNamed(name)
+    }
+
+    /**
+     * Writes a trace message to indicate that a given section of code has ended.
+     * This call must be preceded by a corresponding call to [beginSection].
+     * Calling this method will mark the end of the most recently begun section of code, so care
+     * must be taken to ensure that `beginSection` / `endSection` pairs are properly nested and
+     * called from the same thread.
+     *
+     * @param token The instance returned from the corresponding call to [beginSection].
+     */
+    actual fun endSection(token: Any?) {
+        token?.let {
+            traceImpl?.endInterval(it as CMPOSLoggerInterval)
+        }
+    }
+}

compose/runtime/runtime/src/watchOsMain/kotlin/androidx/compose/runtime/Trace.watchOs.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 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.
+ */
+
+package androidx.compose.runtime
+
+internal actual object Trace {
+    /**
+     * Writes a trace message to indicate that a given section of code has begun.
+     * This call must be followed by a corresponding call to [endSection] on the same thread.
+     *
+     * @return An arbitrary token which will be supplied to the corresponding call
+     * to [endSection]. May be null.
+     */
+    actual fun beginSection(name: String): Any? {
+        return null
+    }
+
+    /**
+     * Writes a trace message to indicate that a given section of code has ended.
+     * This call must be preceded by a corresponding call to [beginSection].
+     * Calling this method will mark the end of the most recently begun section of code, so care
+     * must be taken to ensure that `beginSection` / `endSection` pairs are properly nested and
+     * called from the same thread.
+     *
+     * @param token The instance returned from the corresponding call to [beginSection].
+     */
+    actual fun endSection(token: Any?) {
+    }
+}