peachsim 0.1.666 → 0.1.668

package/kotlin/AppSources/dev/peach/app/PeachApp.kt

@@ -68,8 +68,9 @@ internal fun peachApplication(): Application = runningApp().application
 // them on an edge-to-edge window, none once the decor fits system windows.
 // insets lists the status bars, navigation bars, display cutout, system
 // gestures, mandatory system gestures and tappable element, each left, top,
-// right and bottom.
-private class DeviceInsets(private val window: Window, insets: String) : PlatformWindowInsets {
+// right and bottom. the IME's inset is the keyboard's height above the
+// screen's bottom edge, which moves with the keyboard frame by frame.
+private class DeviceInsets(private val window: Window, insets: String, imeBottom: () -> Int) : PlatformWindowInsets {
     private val pixels = insets.split(',').map { it.toInt() }.also { require(it.size == 24) }
 
     // read when compose lays out, so a later change to the window applies
@@ -84,6 +85,7 @@ private class DeviceInsets(private val window: Window, insets: String) : Platfor
     override val systemGestures = type(3)
     override val mandatorySystemGestures = type(4)
     override val tappableElement = type(5)
+    override val ime = PlatformInsets({ 0 }, { 0 }, { 0 }, { if (window.fitsSystemWindows) 0 else imeBottom() })
     override val systemBars = PlatformInsets(
         { maxOf(statusBars.left, navigationBars.left) },
         { maxOf(statusBars.top, navigationBars.top) },
@@ -127,6 +129,8 @@ private class AppProcess(
     // the night mode last reported to the activity: ActivityRecord compares
     // the configuration with it before a relaunch or onConfigurationChanged
     var reportedNight = false
+    // the software keyboard's height above the screen's bottom edge, in pixels
+    var ime by mutableIntStateOf(0)
 }
 
 private var process: AppProcess? = null
@@ -228,7 +232,7 @@ private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?):
         app.density, app.fontScale, app.locale, app.gpu, app.stencilBits, app.fonts, app.invalidate,
         night = isNight(activity.resources.configuration),
         owners = componentActivity?.let(::ActivityOwners),
-        insets = DeviceInsets(window, app.insets),
+        insets = DeviceInsets(window, app.insets) { app.ime },
         clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
     )
     mount.setContent {
@@ -322,6 +326,14 @@ private fun reportConfiguration(app: AppProcess): Boolean {
 private fun isNight(configuration: Configuration) =
     configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
 
+// the software keyboard moved: its inset reaches the window's content
+internal fun peachAppIme(bottom: Int) {
+    val app = runningApp()
+    if (app.ime == bottom) return
+    app.ime = bottom
+    app.invalidate(true)
+}
+
 // the device's night mode changed. the process's configuration changes in
 // place and the Application hears it first; a visible activity then takes it.
 // a stopped activity takes it once visible again, if it still differs.

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -9,9 +9,13 @@ import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshots.Snapshot
 import androidx.compose.ui.LocalSystemTheme
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.graphics.asComposeCanvas
 import androidx.compose.ui.input.InputMode
 import androidx.compose.ui.input.InputModeManager
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
 import androidx.compose.ui.input.pointer.PointerEventType
 import androidx.compose.ui.input.pointer.PointerType
 import androidx.compose.ui.platform.FrameRecomposer
@@ -19,6 +23,7 @@ import androidx.compose.ui.platform.LocalFontFamilyResolver
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
 import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.ui.platform.PlatformContext
+import androidx.compose.ui.platform.PlatformTextInputMethodRequest
 import androidx.compose.ui.platform.WindowInfo
 import androidx.compose.ui.platform.registerSkikoComposeImplementation
 import androidx.compose.ui.scene.CanvasLayersComposeScene
@@ -34,6 +39,19 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.font.PlatformTypefacesLoader
 import androidx.compose.ui.text.font.createPlatformFontFamilyResolver
 import androidx.compose.ui.text.font.platformTypefacesLoader
+import androidx.compose.ui.text.input.BackspaceCommand
+import androidx.compose.ui.text.input.CommitTextCommand
+import androidx.compose.ui.text.input.EditCommand
+import androidx.compose.ui.text.input.FinishComposingTextCommand
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.ImeOptions
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.input.PlatformTextInputService
+import androidx.compose.ui.text.input.SetComposingRegionCommand
+import androidx.compose.ui.text.input.SetComposingTextCommand
+import androidx.compose.ui.text.input.SetSelectionCommand
+import androidx.compose.ui.text.input.TextFieldValue
 import androidx.compose.ui.text.intl.LocaleList
 import androidx.compose.ui.text.intl.setPlatformLocaleProvider
 import androidx.compose.ui.text.platform.Font
@@ -45,6 +63,7 @@ import androidx.compose.ui.unit.LayoutDirection
 import dev.onejs.one.OneNativeSourceViewDispatch
 import kotlin.io.encoding.Base64
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.awaitCancellation
 import org.jetbrains.skiko.SystemTheme
 import org.jetbrains.skia.BackendRenderTarget
 import org.jetbrains.skia.Bitmap
@@ -94,6 +113,129 @@ internal class PeachComposePlatform(
     override fun onSemanticsOwnerRemoved(semanticsOwner: SemanticsOwner) { owners.remove(semanticsOwner) }
     override fun onSemanticsChange(semanticsOwner: SemanticsOwner) = Unit
     override fun onLayoutChange(semanticsOwner: SemanticsOwner, semanticsNodeId: Int) = Unit
+
+    // the input method session the focused text field holds, android's
+    // InputConnection. each session gets a new token, so the host can tell a
+    // late close from the session that replaced it
+    var input: PeachInputSession? = null
+        private set
+    var onInputChange: () -> Unit = {}
+    private var nextInput = 1
+
+    override suspend fun startInputMethod(request: PlatformTextInputMethodRequest): Nothing {
+        val session = PeachInputSession(nextInput++, request)
+        input = session
+        onInputChange()
+        try { awaitCancellation() }
+        finally {
+            if (input === session) input = null
+            onInputChange()
+        }
+    }
+
+    // compose's keyboard controller: show and hide move the keyboard and keep
+    // the session, as Done does on android. a session opens with the keyboard
+    // up, as android's legacy text input service shows it on startInput
+    @Suppress("DEPRECATION")
+    override val textInputService: PlatformTextInputService = object : PlatformTextInputService {
+        override fun startInput(value: TextFieldValue, imeOptions: ImeOptions,
+            onEditCommand: (List<EditCommand>) -> Unit, onImeActionPerformed: (ImeAction) -> Unit) = Unit
+        override fun stopInput() = Unit
+        override fun showSoftwareKeyboard() { input?.request(true); onInputChange() }
+        override fun hideSoftwareKeyboard() { input?.request(false); onInputChange() }
+        override fun updateState(oldValue: TextFieldValue?, newValue: TextFieldValue) = Unit
+    }
+}
+
+internal class PeachInputSession(val token: Int, val request: PlatformTextInputMethodRequest) {
+    var keyboard = true
+        private set
+    // each show or hide compose asks for, so a repeat still reaches the keyboard
+    private var keyboardRequest = 0
+    private val options get() = request.imeOptions
+
+    // EditorInfo.android.kt: a single line field's default action is Done; a
+    // multi line field's default has no enter action, so enter types a newline
+    private val action: ImeAction? get() = when (options.imeAction) {
+        ImeAction.Default -> if (options.singleLine) ImeAction.Done else null
+        ImeAction.None -> null
+        else -> options.imeAction
+    }
+
+    fun request(visible: Boolean) {
+        keyboard = visible
+        keyboardRequest++
+    }
+
+    private fun rect(rect: Rect?) = rect?.let { JSONArray().put(it.left).put(it.top).put(it.right).put(it.bottom) }
+
+    fun state(): JSONObject {
+        val value = request.value()
+        return JSONObject().put("token", token).put("keyboard", keyboard).put("keyboardRequest", keyboardRequest)
+            .put("value", value.text).put("selectionStart", value.selection.start).put("selectionEnd", value.selection.end)
+            .put("singleLine", options.singleLine).put("enterInsertsNewline", action == null && !options.singleLine)
+            .put("keyboardType", when (options.keyboardType) {
+                KeyboardType.Number -> "number"
+                KeyboardType.Phone -> "phone"
+                KeyboardType.Uri -> "uri"
+                KeyboardType.Email -> "email"
+                KeyboardType.Password -> "password"
+                KeyboardType.NumberPassword -> "number-password"
+                KeyboardType.Decimal -> "decimal"
+                KeyboardType.Ascii -> "ascii"
+                else -> "text"
+            })
+            .put("imeAction", when (action) {
+                ImeAction.Done -> "done"
+                ImeAction.Go -> "go"
+                ImeAction.Search -> "search"
+                ImeAction.Send -> "send"
+                ImeAction.Next -> "next"
+                ImeAction.Previous -> "previous"
+                else -> "default"
+            })
+            .put("capitalization", when (options.capitalization) {
+                KeyboardCapitalization.Characters -> "characters"
+                KeyboardCapitalization.Words -> "words"
+                KeyboardCapitalization.Sentences -> "sentences"
+                else -> "none"
+            })
+            .put("autoCorrect", options.autoCorrect)
+            .put("field", rect(request.textFieldRectInRoot()))
+            .put("caret", rect(request.focusedRectInRoot()))
+    }
+
+    // one keyboard edit, applied as one batch the way RecordingInputConnection
+    // ends a batch edit. typed text commits as an IME's commitText does; a
+    // composition replaces its own region, else the edit's range
+    fun edit(command: JSONObject): Boolean {
+        val value = request.value()
+        val start = command.optInt("start")
+        val end = command.optInt("end")
+        val composing = value.composition?.let { it.start == start && it.end == end } == true
+        val commands: List<EditCommand> = when (command.getString("kind")) {
+            "text" -> listOf(CommitTextCommand(command.getString("text"), 1))
+            "backspace" -> listOf(BackspaceCommand())
+            "enter" -> {
+                val performed = action
+                if (performed != null) {
+                    request.onImeAction?.invoke(performed)
+                    return true
+                }
+                if (options.singleLine) return false
+                listOf(CommitTextCommand("\n", 1))
+            }
+            "compositionStart" -> if (start == end) return true else listOf(SetComposingRegionCommand(start, end))
+            "replace" -> {
+                val text = command.getString("text")
+                val place = if (composing) emptyList() else listOf(FinishComposingTextCommand(), SetSelectionCommand(start, end))
+                place + if (command.getString("composition") == "update") SetComposingTextCommand(text, 1) else CommitTextCommand(text, 1)
+            }
+            else -> error("unknown input edit ${command.getString("kind")}")
+        }
+        request.onEditCommand(commands)
+        return true
+    }
 }
 
 // android's default and sans-serif families use the same device font bytes as
@@ -150,12 +292,16 @@ internal class PeachComposeMount(
         recomposer, platform.density, LayoutDirection.Ltr, null, platform,
         invalidateLayout = { needsMeasure = true; invalidate(true) }, invalidateDraw = { invalidate(false) },
     )
+    // the session's state as last reported; a change reports it again
+    private var reportedInput: String? = null
     private var surface: Surface? = null
     private var context: DirectContext? = null
     private var target: BackendRenderTarget? = null
     private var pixels: Bitmap? = null
     private var size = IntSize.Zero
 
+    init { platform.onInputChange = { invalidate(false) } }
+
     fun setContent(content: @Composable () -> Unit) {
         try {
             scene.setContent {
@@ -221,6 +367,11 @@ internal class PeachComposeMount(
         for ((name, args) in frameState) events.add(JSONObject().put("name", name).put("args", args()))
         frameState.clear()
         reply.put("events", JSONArray(events))
+        val input = platform.input?.state()?.toString()
+        if (input != reportedInput) {
+            reportedInput = input
+            reply.put("input", input?.let { JSONObject(it) } ?: JSONObject.NULL)
+        }
         events.clear()
         if (gpu) checkNotNull(surface).flushAndSubmit()
         else {
@@ -245,6 +396,37 @@ internal class PeachComposeMount(
         invalidate(false)
     }
 
+    private fun session(token: Int) = platform.input?.takeIf { it.token == token }
+
+    fun inputEdit(token: Int, command: String): Boolean {
+        val session = session(token) ?: return false
+        return session.edit(JSONObject(command)).also { invalidate(false) }
+    }
+
+    // a hardware key, pressed and released, through compose's key input as an
+    // android view dispatches it; true when compose consumed the press
+    fun inputKey(token: Int, name: String, ctrl: Boolean, shift: Boolean, alt: Boolean): Boolean {
+        if (session(token) == null) return false
+        val key = hardwareKeys[name] ?: name.singleOrNull()?.lowercaseChar()?.let { letterKeys["$it"] } ?: return false
+        val codePoint = name.singleOrNull()?.code ?: 0
+        fun send(type: KeyEventType) = scene.sendKeyEvent(KeyEvent(key, type, codePoint,
+            isCtrlPressed = ctrl, isAltPressed = alt, isShiftPressed = shift))
+        val consumed = send(KeyEventType.KeyDown)
+        send(KeyEventType.KeyUp)
+        invalidate(false)
+        return consumed
+    }
+
+    fun inputState(token: Int): String = session(token)?.state()?.toString() ?: ""
+
+    // the host gave focus to another input: the view loses focus, as
+    // View.clearFocus does, and compose closes the session itself
+    fun inputBlur(token: Int) {
+        if (session(token) == null) return
+        scene.focusManager.releaseFocus()
+        invalidate(false)
+    }
+
     fun semantics(): String {
         val nodes = JSONArray()
         fun collect(node: SemanticsNode) {
@@ -274,6 +456,19 @@ internal class PeachComposeMount(
     }
 }
 
+// the keys a hardware keyboard sends, by their DOM names
+private val hardwareKeys = mapOf(
+    "ArrowLeft" to Key.DirectionLeft, "ArrowRight" to Key.DirectionRight,
+    "ArrowUp" to Key.DirectionUp, "ArrowDown" to Key.DirectionDown,
+    "Home" to Key.MoveHome, "End" to Key.MoveEnd, "PageUp" to Key.PageUp, "PageDown" to Key.PageDown,
+    "Tab" to Key.Tab, "Delete" to Key.Delete, "Backspace" to Key.Backspace,
+    "Enter" to Key.Enter, "Escape" to Key.Escape,
+)
+private val letterKeys = listOf(
+    Key.A, Key.B, Key.C, Key.D, Key.E, Key.F, Key.G, Key.H, Key.I, Key.J, Key.K, Key.L, Key.M,
+    Key.N, Key.O, Key.P, Key.Q, Key.R, Key.S, Key.T, Key.U, Key.V, Key.W, Key.X, Key.Y, Key.Z,
+).mapIndexed { index, key -> "${'a' + index}" to key }.toMap()
+
 internal val mounts = mutableMapOf<Int, PeachComposeMount>()
 private var nextMount = 1
 private var deviceLocale: String? = null
@@ -330,6 +525,11 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
 }
 @JsExport fun peachViewFrame(id: Int, millis: Double): String = checkNotNull(mounts[id]).frame((millis * 1_000_000).toLong())
 @JsExport fun peachViewPointer(id: Int, phase: String, x: Float, y: Float, millis: Double) = checkNotNull(mounts[id]).pointer(phase, x, y, millis.toLong())
+@JsExport fun peachViewInputEdit(id: Int, token: Int, command: String): Boolean = checkNotNull(mounts[id]).inputEdit(token, command)
+@JsExport fun peachViewInputKey(id: Int, token: Int, key: String, ctrl: Boolean, shift: Boolean, alt: Boolean): Boolean =
+    checkNotNull(mounts[id]).inputKey(token, key, ctrl, shift, alt)
+@JsExport fun peachViewInputState(id: Int, token: Int): String = checkNotNull(mounts[id]).inputState(token)
+@JsExport fun peachViewInputBlur(id: Int, token: Int) = checkNotNull(mounts[id]).inputBlur(token)
 @JsExport fun peachViewSemantics(id: Int): String = checkNotNull(mounts[id]).semantics()
 @JsExport fun peachViewDispose(id: Int) { mounts.remove(id)?.close() }
 

package/kotlin/Sources/org/json/JSON.kt

@@ -207,6 +207,19 @@ class JSONObject() {
         return this
     }
 
+    // android's coercions: any value reads as its string; a number or a
+    // numeric string reads as an int, anything else as the fallback
+    fun getString(name: String): String = when (val value = get(name)) {
+        is String -> value
+        else -> value.toString()
+    }
+
+    fun optInt(name: String, fallback: Int = 0): Int = when (val value = opt(name)) {
+        is Number -> value.toInt()
+        is String -> value.toDoubleOrNull()?.toInt() ?: fallback
+        else -> fallback
+    }
+
     fun optBoolean(name: String): Boolean = when (val value = opt(name)) {
         is Boolean -> value
         is String -> value.equals("true", ignoreCase = true)

package/kotlin/fixtures/kotlin-app-variants/Anim.kt

@@ -0,0 +1,62 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt
+
+// a tap flips one state that AnimatedVisibility, animateDpAsState and
+// animateColorAsState each animate on the frame clock; the label reads the
+// animated width, so it settles only when the animation has finished. took
+// is the frame clock time and frame count from the flip to the width's arrival
+@Composable
+fun Anim() {
+    var on by remember { mutableStateOf(false) }
+    var flips by remember { mutableStateOf(0) }
+    var took by remember { mutableStateOf("none") }
+    val target = if (on) 240.dp else 80.dp
+    val width by animateDpAsState(target, label = "width")
+    LaunchedEffect(flips) {
+        if (flips == 0) return@LaunchedEffect
+        val start = withFrameNanos { it }
+        var count = 0
+        var end = start
+        while (width != target) end = withFrameNanos { count += 1; it }
+        took = "${(end - start) / 1_000_000}ms $count frames"
+    }
+    val color by animateColorAsState(if (on) Color(0xFF3F51B5) else Color(0xFFE91E63), label = "color")
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Anim: $on width ${if (width == target) "${target.value.roundToInt()}" else "moving"}")
+        Button(onClick = { on = !on; flips += 1 }) { Text("Animate") }
+        Text("Took: $took")
+        Box(Modifier.width(width).height(48.dp).background(color))
+        AnimatedVisibility(on) {
+            Text("Panel", Modifier.fillMaxWidth().background(Color(0xFF009688)).padding(24.dp), color = Color.White)
+        }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Controls.kt

@@ -0,0 +1,62 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.Badge
+import androidx.compose.material3.BadgedBox
+import androidx.compose.material3.DatePicker
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExtendedFloatingActionButton
+import androidx.compose.material3.SegmentedButton
+import androidx.compose.material3.SegmentedButtonDefaults
+import androidx.compose.material3.SingleChoiceSegmentedButtonRow
+import androidx.compose.material3.SuggestionChip
+import androidx.compose.material3.Text
+import androidx.compose.material3.rememberDatePickerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+// segmented buttons a tap selects, chips, a badge, an extended FAB and a date
+// picker showing a fixed past month, so no today marker depends on the clock
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun Controls() {
+    val options = listOf("Day", "Week", "Month")
+    var picked by remember { mutableStateOf(0) }
+    // march 2020, utc
+    val dates = rememberDatePickerState(initialSelectedDateMillis = 1584230400000L, initialDisplayedMonthMillis = 1583020800000L)
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Range: ${options[picked]}")
+        SingleChoiceSegmentedButtonRow {
+            options.forEachIndexed { index, label ->
+                SegmentedButton(
+                    selected = picked == index,
+                    onClick = { picked = index },
+                    shape = SegmentedButtonDefaults.itemShape(index, options.size),
+                ) { Text(label) }
+            }
+        }
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            AssistChip(onClick = {}, label = { Text("Assist") })
+            SuggestionChip(onClick = {}, label = { Text("Suggest") })
+            BadgedBox(badge = { Badge { Text("8") } }, Modifier.padding(top = 12.dp, start = 8.dp)) { Text("Inbox") }
+        }
+        ExtendedFloatingActionButton(onClick = {}) { Text("Compose") }
+        DatePicker(dates, showModeToggle = false)
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Drag.kt

@@ -0,0 +1,56 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt
+
+// a puck detectDragGestures moves, reporting the drag it received after the
+// touch slop in dp, and a slider a drag sets
+@Composable
+fun Drag() {
+    var puck by remember { mutableStateOf(Offset.Zero) }
+    var drags by remember { mutableStateOf(0) }
+    var slider by remember { mutableFloatStateOf(0f) }
+    val density = LocalDensity.current.density
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Drag: ${(puck.x / density).roundToInt()},${(puck.y / density).roundToInt()} ends $drags slider ${(slider * 100).roundToInt()}")
+        Box(
+            Modifier.fillMaxWidth().height(300.dp).background(Color(0xFFCFD8DC)).testTag("pad").pointerInput(Unit) {
+                detectDragGestures(onDragEnd = { drags += 1 }) { change, amount -> change.consume(); puck += amount }
+            },
+        ) {
+            Box(Modifier.offset { IntOffset(puck.x.roundToInt(), puck.y.roundToInt()) }.size(48.dp).background(Color(0xFF3F51B5), CircleShape))
+        }
+        Slider(slider, { slider = it }, Modifier.testTag("slider"))
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Draw.kt

@@ -0,0 +1,74 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt
+
+// a canvas of paths, arcs, gradients and strokes, transformed layers, and a
+// pointer input pad that reports where a tap lands in its own dp
+@Composable
+fun Draw() {
+    var tap by remember { mutableStateOf("none") }
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Tap: $tap")
+        Canvas(Modifier.fillMaxWidth().height(200.dp)) {
+            drawRect(Brush.linearGradient(listOf(Color(0xFF3F51B5), Color(0xFFE91E63)), Offset.Zero, Offset(size.width, size.height)))
+            drawCircle(Brush.radialGradient(listOf(Color.White, Color(0x00FFFFFF)), Offset(size.width * 0.25f, size.height * 0.5f), 120f), 120f, Offset(size.width * 0.25f, size.height * 0.5f))
+            drawArc(Color(0xFFFFC107), -90f, 250f, false, Offset(size.width * 0.55f, 40f), Size(240f, 240f), style = Stroke(24f, cap = StrokeCap.Round))
+            val path = Path().apply {
+                moveTo(size.width * 0.8f, 40f)
+                cubicTo(size.width, 80f, size.width * 0.7f, size.height - 80f, size.width * 0.95f, size.height - 30f)
+                lineTo(size.width * 0.75f, size.height - 30f)
+                close()
+            }
+            drawPath(path, Color(0xCC009688))
+            drawRoundRect(Color.White, Offset(30f, size.height - 90f), Size(200f, 60f), CornerRadius(30f), style = Stroke(6f))
+            drawLine(Color.Black, Offset(0f, size.height), Offset(size.width, 0f), 3f)
+        }
+        Row(horizontalArrangement = Arrangement.spacedBy(24.dp)) {
+            Box(Modifier.padding(12.dp).size(72.dp).rotate(30f).background(Color(0xFF673AB7)))
+            Box(Modifier.size(96.dp).graphicsLayer { alpha = 0.5f; scaleX = 0.8f; scaleY = 1.2f }.background(Color(0xFFFF5722)))
+            Box(Modifier.size(96.dp).graphicsLayer { rotationX = 40f; cameraDistance = 8 * density }.clip(RoundedCornerShape(16.dp)).background(Color(0xFF4CAF50)))
+        }
+        Box(
+            Modifier.fillMaxWidth().height(160.dp).background(Color(0xFFCFD8DC)).pointerInput(Unit) {
+                detectTapGestures { tap = "${(it.x / density).roundToInt()},${(it.y / density).roundToInt()}" }
+            },
+        ) { Text("Pad", Modifier.padding(8.dp)) }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Form.kt

@@ -0,0 +1,47 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.unit.dp
+
+// a single line field a tap focuses, typing fills and Done finishes, keeping
+// its focus as android does
+@Composable
+fun Form() {
+    var name by remember { mutableStateOf("") }
+    var focused by remember { mutableStateOf(false) }
+    var done by remember { mutableStateOf(0) }
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Name: ${name.ifEmpty { "empty" }} focus $focused done $done")
+        OutlinedTextField(
+            value = name,
+            onValueChange = { name = it },
+            label = { Text("Name") },
+            singleLine = true,
+            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+            keyboardActions = KeyboardActions(onDone = { done += 1; defaultKeyboardAction(ImeAction.Done) }),
+            modifier = Modifier.fillMaxWidth().onFocusChanged { focused = it.isFocused },
+        )
+    }
+}