OS logging integrated with trace for iOS (#1140)

## Proposed Changes

Integrate iOS logging with traces API in `ui:util` modules.
Additional traces in `ui` in `skikoMain` source set.

## Testing

Test: N/A

## API Change

API added to iOS source set

```
// androidx.compose.ui.util
@ExperimentalComposeUiApi
fun enableTraceOSLog()
```

---------

Co-authored-by: Andrei.Salavei <andrei.salavei@jetbrains.com>
Co-authored-by: Igor Demin <igordmn@users.noreply.github.com>

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,10 @@ import bugs.StartRecompositionCheck
 import platform.UIKit.UIViewController
 
 
-@OptIn(ExperimentalComposeApi::class)
+@OptIn(ExperimentalComposeApi::class, ExperimentalComposeUiApi::class)
 fun main(vararg args: String) {
+    androidx.compose.ui.util.enableTraceOSLog()
+
     val arg = args.firstOrNull() ?: ""
     defaultUIKitMain("ComposeDemo", ComposeUIViewController(configure = {
         accessibilitySyncOptions = AccessibilitySyncOptions.WhenRequiredByAccessibilityServices(object: AccessibilityDebugLogger {

compose/runtime/runtime/build.gradle

@@ -180,10 +180,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,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/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?) {
+    }
+}