peachsim 0.1.939 → 0.1.1399

package/kotlin/AndroidViewSources/android/widget/LinearLayout.kt

@@ -0,0 +1,49 @@
+package android.widget
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+
+open class LinearLayout(context: Context) : ViewGroup(context) {
+    var orientation: Int = HORIZONTAL
+        set(value) { field = value; requestLayout() }
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        var usedWidth = 0
+        var usedHeight = 0
+        for (index in 0 until childCount) {
+            val child = checkNotNull(getChildAt(index))
+            val params = child.layoutParams
+            child.measure(
+                getChildMeasureSpec(widthMeasureSpec, paddingLeft + paddingRight + if (orientation == HORIZONTAL) usedWidth else 0, params?.width ?: LayoutParams.WRAP_CONTENT),
+                getChildMeasureSpec(heightMeasureSpec, paddingTop + paddingBottom + if (orientation == VERTICAL) usedHeight else 0, params?.height ?: LayoutParams.WRAP_CONTENT),
+            )
+            if (orientation == VERTICAL) {
+                usedHeight += child.measuredHeight
+                usedWidth = maxOf(usedWidth, child.measuredWidth)
+            } else {
+                usedWidth += child.measuredWidth
+                usedHeight = maxOf(usedHeight, child.measuredHeight)
+            }
+        }
+        setMeasuredDimension(
+            View.resolveSize(maxOf(minimumWidth, usedWidth + paddingLeft + paddingRight), widthMeasureSpec),
+            View.resolveSize(maxOf(minimumHeight, usedHeight + paddingTop + paddingBottom), heightMeasureSpec),
+        )
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        var x = paddingLeft
+        var y = paddingTop
+        for (index in 0 until childCount) {
+            val child = checkNotNull(getChildAt(index))
+            child.layout(x, y, x + child.measuredWidth, y + child.measuredHeight)
+            if (orientation == VERTICAL) y += child.measuredHeight else x += child.measuredWidth
+        }
+    }
+
+    companion object {
+        const val HORIZONTAL = 0
+        const val VERTICAL = 1
+    }
+}

package/kotlin/AppSources/android/view/Window.kt

@@ -30,10 +30,15 @@ class Window internal constructor(
     theme: WindowTheme,
     internal val host: PeachWindowHost,
 ) {
+    private companion object { var nextBackGeneration = 0 }
+    private val backGeneration = ++nextBackGeneration
     private val edgeToEdgeEnforced = theme.edgeToEdgeEnforced
     internal val contentParent = FrameLayout(context)
     val decorView: View get() = contentParent
     val attributes = WindowManager.LayoutParams()
+    private val backDispatcher = android.window.WindowOnBackInvokedDispatcher { host.windowChanged() }
+    val onBackInvokedDispatcher: android.window.OnBackInvokedDispatcher get() = backDispatcher
+    internal fun invokeBack(): Boolean = backDispatcher.invoke()
 
     // PhoneWindow fits system windows until told otherwise; an enforced edge
     // to edge window never does, and ignores the request
@@ -91,6 +96,20 @@ class Window internal constructor(
     fun setNavigationBarContrastEnforced(enforced: Boolean) { isNavigationBarContrastEnforced = enforced }
 
     val insetsController: WindowInsetsController = object : WindowInsetsController {
+        override fun hide(types: Int) = setSystemBarsVisible(types, false)
+        override fun show(types: Int) = setSystemBarsVisible(types, true)
+
+        override var systemBarsBehavior: Int = WindowInsetsController.BEHAVIOR_DEFAULT
+            set(value) {
+                require(value == WindowInsetsController.BEHAVIOR_DEFAULT ||
+                    value == WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE) {
+                    "unsupported system bar behavior: $value"
+                }
+                if (field == value) return
+                field = value
+                host.windowChanged()
+            }
+
         private var appearance =
             (if (theme.lightStatusBar) WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS else 0) or
                 (if (theme.lightNavigationBar) WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS else 0)
@@ -105,6 +124,17 @@ class Window internal constructor(
         }
     }
 
+    private var hiddenSystemBars = 0
+
+    private fun setSystemBarsVisible(types: Int, visible: Boolean) {
+        val supported = WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars()
+        require(types and supported.inv() == 0) { "unsupported window inset visibility types: $types" }
+        val next = if (visible) hiddenSystemBars and types.inv() else hiddenSystemBars or types
+        if (next == hiddenSystemBars) return
+        hiddenSystemBars = next
+        host.windowChanged()
+    }
+
     // DecorView.calculateBarColor for the status bar of a window that draws
     // its bar backgrounds: a transparent color under enforced contrast shows
     // the scrim for the bar's appearance
@@ -124,6 +154,11 @@ class Window internal constructor(
         .put("decorFitsSystemWindows", fits)
         .put("statusBarColor", drawnStatusBarColor().toLong() and 0xffffffffL)
         .put("navigationBarColor", navigationBarColor.toLong() and 0xffffffffL)
+        .put("systemBarsAppearance", insetsController.systemBarsAppearance)
+        .put("hiddenSystemBars", hiddenSystemBars)
+        .put("systemBarsBehavior", insetsController.systemBarsBehavior)
+        .put("backCallbacks", backDispatcher.registrations())
+        .put("backGeneration", backGeneration)
 
     // Activity.setContentView(View) fills the content parent
     internal fun setContentView(view: View, params: ViewGroup.LayoutParams) {
@@ -137,5 +172,6 @@ class Window internal constructor(
 
     internal fun removeFromWindowManager() {
         if (contentParent.isAttachedToWindow) contentParent.dispatchDetachedFromWindow()
+        backDispatcher.clear()
     }
 }

package/kotlin/AppSources/android/view/WindowInsets.kt

@@ -0,0 +1,9 @@
+package android.view
+
+// inset type masks accepted by the window's system bar controller
+class WindowInsets private constructor() {
+    object Type {
+        fun statusBars(): Int = 1
+        fun navigationBars(): Int = 1 shl 1
+    }
+}

package/kotlin/AppSources/android/view/WindowInsetsController.kt

@@ -2,11 +2,16 @@ package android.view
 
 // the window's requested system bar appearance: light bars ask for dark icons
 interface WindowInsetsController {
+    fun hide(types: Int)
+    fun show(types: Int)
     fun setSystemBarsAppearance(appearance: Int, mask: Int)
     val systemBarsAppearance: Int
+    var systemBarsBehavior: Int
 
     companion object {
         const val APPEARANCE_LIGHT_STATUS_BARS = 1 shl 3
         const val APPEARANCE_LIGHT_NAVIGATION_BARS = 1 shl 4
+        const val BEHAVIOR_DEFAULT = 1
+        const val BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE = 2
     }
 }

package/kotlin/AppSources/android/window/OnBackInvokedDispatcher.kt

@@ -0,0 +1,48 @@
+package android.window
+
+fun interface OnBackInvokedCallback {
+    fun onBackInvoked()
+}
+
+interface OnBackInvokedDispatcher {
+    fun registerOnBackInvokedCallback(priority: Int, callback: OnBackInvokedCallback)
+    fun unregisterOnBackInvokedCallback(callback: OnBackInvokedCallback)
+
+    companion object {
+        const val PRIORITY_DEFAULT = 0
+        const val PRIORITY_OVERLAY = 1000000
+    }
+}
+
+// the receiving window orders by priority, then latest registration.
+internal class WindowOnBackInvokedDispatcher(private val changed: () -> Unit) : OnBackInvokedDispatcher {
+    private data class Registration(val priority: Int, val order: Int)
+    private val callbacks = linkedMapOf<OnBackInvokedCallback, Registration>()
+    private var order = 0
+
+    override fun registerOnBackInvokedCallback(priority: Int, callback: OnBackInvokedCallback) {
+        require(priority >= 0) { "application back callback priority must be nonnegative" }
+        callbacks[callback] = Registration(priority, ++order)
+        changed()
+    }
+
+    override fun unregisterOnBackInvokedCallback(callback: OnBackInvokedCallback) {
+        if (callbacks.remove(callback) != null) changed()
+    }
+
+    fun registrations(): org.json.JSONArray = org.json.JSONArray().also { result ->
+        callbacks.values.sortedBy { it.order }.forEach {
+            result.put(org.json.JSONObject().put("priority", it.priority).put("registration", it.order))
+        }
+    }
+
+    fun invoke(): Boolean {
+        val callback = callbacks.maxWithOrNull(compareBy({ it.value.priority }, { it.value.order }))?.key ?: return false
+        callback.onBackInvoked()
+        return true
+    }
+
+    fun clear() {
+        callbacks.clear()
+    }
+}

package/kotlin/AppSources/androidx/activity/OnBackPressedDispatcher.kt

@@ -9,11 +9,8 @@ import androidx.navigationevent.NavigationEventInfo
 import androidx.navigationevent.NavigationEventInput
 import java.lang.Runnable
 
-// androidx.activity 1.13.0's OnBackPressedDispatcher, a NavigationEventInput
-// over its own NavigationEventDispatcher. the device's back dispatch stands in
-// for its OnBackInvokedDispatcher inputs: a window with predictive back gives
-// this dispatcher the back only while it has an enabled handler
-// (hasEnabledCallbacks), as the registered OnBackInvokedCallback does.
+// activity 1.13.0 routes legacy back through its navigation event input;
+// predictive back registers separate default and overlay inputs with the window.
 class OnBackPressedDispatcher(
     private val fallbackOnBackPressed: Runnable?,
     private val onHasEnabledCallbacksChanged: ((Boolean) -> Unit)?,
@@ -68,6 +65,12 @@ class OnBackPressedDispatcher(
 
     fun hasEnabledCallbacks(): Boolean = hasEnabledCallbacks
 
+    // activity 1.13 registers separate default and overlay platform inputs.
+    fun setOnBackInvokedDispatcher(invoker: android.window.OnBackInvokedDispatcher) {
+        eventDispatcher.addInput(WindowBackInput(invoker, android.window.OnBackInvokedDispatcher.PRIORITY_DEFAULT), NavigationEventDispatcher.PRIORITY_DEFAULT)
+        eventDispatcher.addInput(WindowBackInput(invoker, android.window.OnBackInvokedDispatcher.PRIORITY_OVERLAY), NavigationEventDispatcher.PRIORITY_OVERLAY)
+    }
+
     fun dispatchOnBackStarted(backEvent: BackEventCompat) {
         eventInput.backStarted(backEvent.toNavigationEvent())
     }
@@ -99,6 +102,18 @@ class OnBackPressedDispatcher(
     }
 }
 
+private class WindowBackInput(
+    private val invoker: android.window.OnBackInvokedDispatcher,
+    private val priority: Int,
+) : NavigationEventInput() {
+    private val callback = android.window.OnBackInvokedCallback { dispatchOnBackCompleted() }
+    override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+        if (hasEnabledHandlers) invoker.registerOnBackInvokedCallback(priority, callback)
+        else invoker.unregisterOnBackInvokedCallback(callback)
+    }
+    override fun onRemoved() { invoker.unregisterOnBackInvokedCallback(callback) }
+}
+
 // androidx.activity's Kotlin registration: a callback from a lambda, bound to
 // owner's lifecycle when one is given
 fun OnBackPressedDispatcher.addCallback(

package/kotlin/AppSources/androidx/compose/foundation/layout/WindowInsets.kt

@@ -0,0 +1,15 @@
+package androidx.compose.foundation.layout
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.NonRestartableComposable
+
+// android reports visibility from the content's insets after decor consumption
+val WindowInsets.Companion.isImeVisible: Boolean
+    @Composable @NonRestartableComposable get() = dev.peach.app.peachImeVisible()
+
+// bar visibility survives fitting decor consuming the content's inset sizes
+val WindowInsets.Companion.areStatusBarsVisible: Boolean
+    @Composable @NonRestartableComposable get() = dev.peach.app.peachSystemBarVisible(1)
+
+val WindowInsets.Companion.areNavigationBarsVisible: Boolean
+    @Composable @NonRestartableComposable get() = dev.peach.app.peachSystemBarVisible(2)

package/kotlin/AppSources/androidx/compose/ui/platform/ComposeView.kt

@@ -51,7 +51,8 @@ class ComposeView(context: Context) : ViewGroup(context) {
     private fun ensureCompositionCreated() {
         if (composition != null) return
         check(parentContext == null) { "a ComposeView composing into a parent composition is not supported in Peach yet" }
-        val window = checkNotNull(attachedWindow) { "ComposeView is not attached to a window" }
+        val window = attachedWindow
+        check(window is android.view.Window) { "ComposeView is not attached to an activity window" }
         composition = window.host.compose(this)
     }
 

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

@@ -23,8 +23,6 @@ import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
-import androidx.compose.ui.platform.PlatformInsets
-import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableIntStateOf
@@ -34,6 +32,8 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.text.font.FontFamily
 import androidx.lifecycle.Lifecycle
 import PeachComposeMount
+import PeachWindowInsets
+import readPeachWindowInsets
 import addMount
 import mounts
 import preparePeachDevice
@@ -64,42 +64,13 @@ internal class PeachAppSpec(
     // the app's view models, each built with the constructor the device's
     // default factory finds for it
     val viewModels: ViewModelProvider.Factory,
+    val predictiveBack: Boolean,
 )
 
 internal fun viewModelFactory(): ViewModelProvider.Factory = runningApp().spec.viewModels
 
 internal fun peachApplication(): Application = runningApp().application
 
-// the insets the device delivers to the window's content, in pixels: all of
-// 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. 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
-    private fun type(index: Int): PlatformInsets {
-        fun side(offset: Int) = { if (window.fitsSystemWindows) 0 else pixels[index * 4 + offset] }
-        return PlatformInsets(side(0), side(1), side(2), side(3))
-    }
-
-    override val statusBars = type(0)
-    override val navigationBars = type(1)
-    override val displayCutout = type(2)
-    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) },
-        { maxOf(statusBars.right, navigationBars.right) },
-        { maxOf(statusBars.bottom, navigationBars.bottom) },
-    )
-}
-
 private class ActivityOwners(activity: ComponentActivity) : PlatformArchitectureComponentsOwner {
     override val lifecycleOwner = activity
     override val viewModelStoreOwner = activity
@@ -113,11 +84,13 @@ private class ActivityOwners(activity: ComponentActivity) : PlatformArchitecture
 private class AppProcess(
     val spec: PeachAppSpec,
     val application: Application,
-    val density: Float, val fontScale: Float, val locale: String, val gpu: Boolean, val stencilBits: Int,
+    val density: Float, val fontScale: Float, val locale: String,
     val fonts: FontFamily,
-    val insets: String,
+    insets: String,
     val invalidate: (Boolean) -> Unit,
 ) {
+    var insets by mutableStateOf(readPeachWindowInsets(insets))
+    var visibleSystemBars by mutableStateOf(3)
     lateinit var activity: Activity
     lateinit var mount: PeachComposeMount
     // the window the device presents, once its scene is in place
@@ -135,6 +108,7 @@ private class AppProcess(
     var reportedNight = false
     // the software keyboard's height above the screen's bottom edge, in pixels
     var ime by mutableIntStateOf(0)
+    var imeVisible by mutableStateOf(false)
     // the configuration the content view composes with: a copy the view's
     // configuration change replaces, as AndroidComposeView's observer does
     val configuration = mutableStateOf(Configuration(), neverEqualPolicy())
@@ -154,28 +128,27 @@ private fun deviceConfiguration(night: Boolean, locale: String) = Configuration(
 // window added, which attaches the content view and composes it.
 internal fun peachStartApp(
     spec: PeachAppSpec,
-    density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
-    regular: String, medium: String, bold: String,
+    density: Float, fontScale: Float, locale: String,
+    font: String,
     insets: String, night: Boolean,
     invalidate: (Boolean) -> Unit,
 ): String {
     try {
-        require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
         val metrics = DisplayMetrics()
         metrics.densityDpi = (density * DisplayMetrics.DENSITY_DEFAULT).roundToInt()
         metrics.density = metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT.toFloat()
-        processResources = Resources(deviceConfiguration(night, locale), metrics)
+        processResources = Resources(deviceConfiguration(night, locale), metrics, peachAppStrings, peachAppPlurals, peachAppArrays, peachAppColors)
         val application = spec.createApplication()
         application.onCreate()
         val app = AppProcess(
-            spec, application, density, fontScale, locale, backend == "graphite", stencilBits,
-            robotoFamily(regular, medium, bold), insets, invalidate,
+            spec, application, density, fontScale, locale,
+            robotoFamily(font), insets, invalidate,
         )
         process = app
         val view = launchActivity(app, null)
         val params = view.layoutParams
-        return app.activity.window.describe().put("ok", true).put("id", app.mountId)
+        return app.activity.window.describe().put("dialogs", app.mount.dialogState()).put("ok", true).put("id", app.mountId)
             .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("softInputAdjust", spec.softInputAdjust)
@@ -216,7 +189,7 @@ private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?):
         // the window itself
         override fun windowChanged() {
             if (app.window === window)
-                mount.emitAtFrame("window") { window.describe().toString() }
+                mount.emitAtFrame("window") { window.describe().put("dialogs", mount.dialogState()).toString() }
         }
     }
     // the theme the activity is created under: a relaunch after a night
@@ -230,6 +203,7 @@ private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?):
         window,
         lastNonConfigurationInstance,
     )
+    if (spec.predictiveBack) componentActivity?.onBackPressedDispatcher?.setOnBackInvokedDispatcher(window.onBackInvokedDispatcher)
     activity.performCreate(state)
     activity.performStart()
     if (state != null) activity.performRestoreInstanceState(state)
@@ -241,10 +215,10 @@ private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?):
     app.state = null
     app.reportedNight = activity.resources.configuration.isNight()
     mount = PeachComposeMount(
-        app.density, app.fontScale, app.locale, app.gpu, app.stencilBits, app.fonts, app.invalidate,
+        app.density, app.fontScale, app.locale, app.fonts, app.invalidate,
         night = activity.resources.configuration.isNight(),
         owners = componentActivity?.let(::ActivityOwners),
-        insets = DeviceInsets(window, app.insets) { app.ime },
+        insets = PeachWindowInsets({ app.insets }, { app.ime }, { window.fitsSystemWindows }),
         clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
     )
     app.configuration.value = Configuration().apply { setTo(activity.resources.configuration) }
@@ -268,7 +242,7 @@ private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?):
         // window, which the new instance may have set differently
         mount.constraints = app.mount.constraints
         mounts[app.mountId] = mount
-        mount.emitAtFrame("window") { window.describe().toString() }
+        mount.emitAtFrame("window") { window.describe().put("dialogs", mount.dialogState()).toString() }
         app.invalidate(true)
     }
     app.mount = mount
@@ -289,9 +263,9 @@ private fun runningApp() = checkNotNull(process) { "the app is not running" }
 internal fun peachAppBack(predictive: Boolean): Boolean {
     val activity = runningApp().activity
     activity.movedTaskToBack = false
-    val dispatcher = (activity as? ComponentActivity)?.onBackPressedDispatcher
+    if (runningApp().mount.dialogBack()) return true
     if (!predictive) activity.onBackPressed()
-    else if (dispatcher?.hasEnabledCallbacks() == true) dispatcher.onBackPressed()
+    else if (activity.window.invokeBack()) Unit
     else activity.movedTaskToBack = true
     return !activity.movedTaskToBack
 }
@@ -344,11 +318,29 @@ private fun reportConfiguration(app: AppProcess): Boolean {
     return false
 }
 
-// the software keyboard moved: its inset reaches the window's content
-internal fun peachAppIme(bottom: Int) {
+internal fun peachImeVisible(): Boolean {
+    val app = runningApp()
+    return !app.activity.window.fitsSystemWindows && app.imeVisible
+}
+
+internal fun peachSystemBarVisible(type: Int): Boolean = runningApp().visibleSystemBars and type != 0
+
+internal fun peachAppInsets(insets: String, visibleSystemBars: Int) {
+    require(visibleSystemBars in 0..3) { "unsupported visible system bar types: $visibleSystemBars" }
+    val app = runningApp()
+    val next = readPeachWindowInsets(insets)
+    if (next == app.insets && visibleSystemBars == app.visibleSystemBars) return
+    app.insets = next
+    app.visibleSystemBars = visibleSystemBars
+    app.invalidate(true)
+}
+
+// keep visibility independent of height, then apply the content window's decor
+internal fun peachAppIme(bottom: Int, visible: Boolean) {
     val app = runningApp()
-    if (app.ime == bottom) return
+    if (app.ime == bottom && app.imeVisible == visible) return
     app.ime = bottom
+    app.imeVisible = visible
     app.invalidate(true)
 }