peachsim 0.1.657 → 0.1.659

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

@@ -0,0 +1,28 @@
+package androidx.activity
+
+// androidx.activity 1.9.3's OnBackPressedCallback
+abstract class OnBackPressedCallback(enabled: Boolean) {
+    var isEnabled: Boolean = enabled
+        set(value) {
+            field = value
+            enabledChangedCallback?.invoke()
+        }
+
+    private val cancellables = mutableListOf<Cancellable>()
+    internal var enabledChangedCallback: (() -> Unit)? = null
+
+    fun remove() = cancellables.toList().forEach { it.cancel() }
+
+    open fun handleOnBackStarted(backEvent: BackEventCompat) {}
+    open fun handleOnBackProgressed(backEvent: BackEventCompat) {}
+    abstract fun handleOnBackPressed()
+    open fun handleOnBackCancelled() {}
+
+    internal fun addCancellable(cancellable: Cancellable) {
+        cancellables.add(cancellable)
+    }
+
+    internal fun removeCancellable(cancellable: Cancellable) {
+        cancellables.remove(cancellable)
+    }
+}

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

@@ -0,0 +1,144 @@
+package androidx.activity
+
+import java.lang.Runnable
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.LifecycleOwner
+
+// androidx.activity 1.9.3's OnBackPressedDispatcher. the device's back
+// dispatch stands in for its OnBackInvokedDispatcher registration: a window
+// with predictive back gives this dispatcher the back only while it has an
+// enabled callback (hasEnabledCallbacks), as the registered callback does.
+class OnBackPressedDispatcher(
+    private val fallbackOnBackPressed: Runnable?,
+    private val onHasEnabledCallbacksChanged: ((Boolean) -> Unit)?,
+) {
+    private val onBackPressedCallbacks = ArrayDeque<OnBackPressedCallback>()
+    private var inProgressCallback: OnBackPressedCallback? = null
+    private var hasEnabledCallbacks = false
+
+    constructor(fallbackOnBackPressed: Runnable? = null) : this(fallbackOnBackPressed, null)
+
+    private fun updateEnabledCallbacks() {
+        val hadEnabledCallbacks = hasEnabledCallbacks
+        val hasEnabledCallbacks = onBackPressedCallbacks.any { it.isEnabled }
+        this.hasEnabledCallbacks = hasEnabledCallbacks
+        if (hasEnabledCallbacks != hadEnabledCallbacks)
+            onHasEnabledCallbacksChanged?.invoke(hasEnabledCallbacks)
+    }
+
+    fun addCallback(onBackPressedCallback: OnBackPressedCallback) {
+        addCancellableCallback(onBackPressedCallback)
+    }
+
+    internal fun addCancellableCallback(onBackPressedCallback: OnBackPressedCallback): Cancellable {
+        onBackPressedCallbacks.add(onBackPressedCallback)
+        val cancellable = OnBackPressedCancellable(onBackPressedCallback)
+        onBackPressedCallback.addCancellable(cancellable)
+        updateEnabledCallbacks()
+        onBackPressedCallback.enabledChangedCallback = ::updateEnabledCallbacks
+        return cancellable
+    }
+
+    fun addCallback(owner: LifecycleOwner, onBackPressedCallback: OnBackPressedCallback) {
+        val lifecycle = owner.lifecycle
+        if (lifecycle.currentState === Lifecycle.State.DESTROYED) return
+        onBackPressedCallback.addCancellable(LifecycleOnBackPressedCancellable(lifecycle, onBackPressedCallback))
+        updateEnabledCallbacks()
+        onBackPressedCallback.enabledChangedCallback = ::updateEnabledCallbacks
+    }
+
+    fun hasEnabledCallbacks(): Boolean = hasEnabledCallbacks
+
+    fun dispatchOnBackStarted(backEvent: BackEventCompat) {
+        val callback = onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        if (inProgressCallback != null) dispatchOnBackCancelled()
+        inProgressCallback = callback
+        callback?.handleOnBackStarted(backEvent)
+    }
+
+    fun dispatchOnBackProgressed(backEvent: BackEventCompat) {
+        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        callback?.handleOnBackProgressed(backEvent)
+    }
+
+    fun onBackPressed() {
+        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        inProgressCallback = null
+        if (callback != null) {
+            callback.handleOnBackPressed()
+            return
+        }
+        fallbackOnBackPressed?.run()
+    }
+
+    fun dispatchOnBackCancelled() {
+        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        inProgressCallback = null
+        callback?.handleOnBackCancelled()
+    }
+
+    private inner class OnBackPressedCancellable(
+        private val onBackPressedCallback: OnBackPressedCallback,
+    ) : Cancellable {
+        override fun cancel() {
+            onBackPressedCallbacks.remove(onBackPressedCallback)
+            if (inProgressCallback == onBackPressedCallback) {
+                onBackPressedCallback.handleOnBackCancelled()
+                inProgressCallback = null
+            }
+            onBackPressedCallback.removeCancellable(this)
+            onBackPressedCallback.enabledChangedCallback?.invoke()
+            onBackPressedCallback.enabledChangedCallback = null
+        }
+    }
+
+    // a lifecycle-bound callback receives back only between ON_START and ON_STOP
+    private inner class LifecycleOnBackPressedCancellable(
+        private val lifecycle: Lifecycle,
+        private val onBackPressedCallback: OnBackPressedCallback,
+    ) : LifecycleEventObserver, Cancellable {
+        private var currentCancellable: Cancellable? = null
+
+        init {
+            lifecycle.addObserver(this)
+        }
+
+        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
+            if (event === Lifecycle.Event.ON_START) {
+                currentCancellable = addCancellableCallback(onBackPressedCallback)
+            } else if (event === Lifecycle.Event.ON_STOP) {
+                currentCancellable?.cancel()
+            } else if (event === Lifecycle.Event.ON_DESTROY) {
+                cancel()
+            }
+        }
+
+        override fun cancel() {
+            lifecycle.removeObserver(this)
+            onBackPressedCallback.removeCancellable(this)
+            currentCancellable?.cancel()
+            currentCancellable = null
+        }
+    }
+}
+
+// androidx.activity's Kotlin registration: a callback from a lambda, bound to
+// owner's lifecycle when one is given
+fun OnBackPressedDispatcher.addCallback(
+    owner: LifecycleOwner? = null,
+    enabled: Boolean = true,
+    onBackPressed: OnBackPressedCallback.() -> Unit
+): OnBackPressedCallback {
+    val callback = object : OnBackPressedCallback(enabled) {
+        override fun handleOnBackPressed() {
+            onBackPressed()
+        }
+    }
+    if (owner != null) {
+        addCallback(owner, callback)
+    } else {
+        addCallback(callback)
+    }
+    return callback
+}

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

@@ -0,0 +1,7 @@
+package androidx.activity
+
+import androidx.lifecycle.LifecycleOwner
+
+interface OnBackPressedDispatcherOwner : LifecycleOwner {
+    val onBackPressedDispatcher: OnBackPressedDispatcher
+}

package/kotlin/AppSources/androidx/activity/compose/BackHandler.kt

@@ -0,0 +1,55 @@
+package androidx.activity.compose
+
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.OnBackPressedDispatcherOwner
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.ProvidedValue
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.lifecycle.compose.LocalLifecycleOwner
+
+// activity-compose 1.9.3's LocalOnBackPressedDispatcherOwner. on the device
+// an unprovided value resolves from the view tree or the context, both of
+// which reach the activity that set the content; the window host provides that
+// activity here.
+object LocalOnBackPressedDispatcherOwner {
+    private val LocalOnBackPressedDispatcherOwner =
+        compositionLocalOf<OnBackPressedDispatcherOwner?> { null }
+
+    val current: OnBackPressedDispatcherOwner?
+        @Composable
+        get() = LocalOnBackPressedDispatcherOwner.current
+
+    infix fun provides(dispatcherOwner: OnBackPressedDispatcherOwner): ProvidedValue<OnBackPressedDispatcherOwner?> =
+        LocalOnBackPressedDispatcherOwner.provides(dispatcherOwner)
+}
+
+// activity-compose 1.9.3's BackHandler
+@Composable
+fun BackHandler(enabled: Boolean = true, onBack: () -> Unit) {
+    val currentOnBack by rememberUpdatedState(onBack)
+    val backCallback = remember {
+        object : OnBackPressedCallback(enabled) {
+            override fun handleOnBackPressed() {
+                currentOnBack()
+            }
+        }
+    }
+    SideEffect {
+        backCallback.isEnabled = enabled
+    }
+    val backDispatcher = checkNotNull(LocalOnBackPressedDispatcherOwner.current) {
+        "No OnBackPressedDispatcherOwner was provided via LocalOnBackPressedDispatcherOwner"
+    }.onBackPressedDispatcher
+    val lifecycleOwner = LocalLifecycleOwner.current
+    DisposableEffect(lifecycleOwner, backDispatcher) {
+        backDispatcher.addCallback(lifecycleOwner, backCallback)
+        onDispose {
+            backCallback.remove()
+        }
+    }
+}

package/kotlin/AppSources/androidx/core/view/WindowCompat.kt

@@ -0,0 +1,32 @@
+package androidx.core.view
+
+import android.view.View
+import android.view.Window
+import android.view.WindowInsetsController
+
+// androidx.core's window helpers as they run from API 30, on the platform
+// window and its insets controller
+object WindowCompat {
+    fun setDecorFitsSystemWindows(window: Window, decorFitsSystemWindows: Boolean) {
+        window.setDecorFitsSystemWindows(decorFitsSystemWindows)
+    }
+
+    fun getInsetsController(window: Window, view: View): WindowInsetsControllerCompat =
+        WindowInsetsControllerCompat(window, view)
+}
+
+class WindowInsetsControllerCompat(window: Window, @Suppress("UNUSED_PARAMETER") view: View) {
+    private val controller = window.insetsController
+
+    private fun appearance(flag: Int) = controller.systemBarsAppearance and flag != 0
+    private fun setAppearance(flag: Int, light: Boolean) =
+        controller.setSystemBarsAppearance(if (light) flag else 0, flag)
+
+    var isAppearanceLightStatusBars: Boolean
+        get() = appearance(WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS)
+        set(light) = setAppearance(WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS, light)
+
+    var isAppearanceLightNavigationBars: Boolean
+        get() = appearance(WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS)
+        set(light) = setAppearance(WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS, light)
+}

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

@@ -2,13 +2,22 @@
 
 package dev.peach.app
 
+import android.os.Bundle
+
 import android.app.Activity
 import android.app.Application
 import android.content.ComponentName
 import android.content.Intent
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.content.res.processResources
 import android.view.ViewGroup
 import android.view.Window
+import android.view.WindowTheme
 import androidx.activity.ComponentActivity
+import androidx.activity.compose.LocalOnBackPressedDispatcherOwner
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
 import androidx.compose.ui.platform.PlatformInsets
@@ -26,15 +35,14 @@ import preparePeachDevice
 import robotoFamily
 import org.json.JSONObject
 
-// what the manifest and Gradle files resolved: the launcher component the
-// intent names (an alias stays the alias), the activity class it runs, the
-// app's target SDK and theme opt-out, and constructors for the manifest's
+// what the manifest, Gradle files and theme resolved: the launcher component
+// the intent names (an alias stays the alias), the activity class it runs, what
+// its window read from the theme, and constructors for the manifest's
 // Application and that class (wasm has no reflection).
 internal class PeachAppSpec(
     val launcher: ComponentName,
     val component: ComponentName,
-    val targetSdk: Int,
-    val optOutEdgeToEdge: Boolean,
+    val window: WindowTheme,
     val createApplication: () -> Application,
     val createActivity: () -> Activity,
 )
@@ -71,12 +79,16 @@ internal fun peachStartApp(
     spec: PeachAppSpec,
     density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
     regular: String, medium: String, bold: String,
-    statusBar: Int, navigationBar: Int,
+    statusBar: Int, navigationBar: Int, night: Boolean,
     invalidate: (Boolean) -> Unit,
 ): String {
     try {
         require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
+        processResources = Resources(Configuration().apply {
+            uiMode = Configuration.UI_MODE_TYPE_NORMAL or
+                if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
+        })
         val fonts = robotoFamily(regular, medium, bold)
         val application = spec.createApplication()
         application.onCreate()
@@ -96,11 +108,10 @@ internal fun peachStartApp(
 
             override fun windowChanged() {
                 if (mountId != 0)
-                    mount.emit("window", JSONObject().put("decorFitsSystemWindows", window.fitsSystemWindows).toString())
+                    mount.emitAtFrame("window") { window.describe().toString() }
             }
         }
-        val enforced = spec.targetSdk > 35 || (spec.targetSdk == 35 && !spec.optOutEdgeToEdge)
-        window = Window(activity, enforced, host)
+        window = Window(activity, spec.window, host)
         activity.attach(
             application,
             spec.component,
@@ -111,21 +122,28 @@ internal fun peachStartApp(
         activity.performStart()
         activity.performPostCreate(null)
         activity.performResume()
+        running = activity
         mount = PeachComposeMount(
             density, fontScale, locale, backend == "graphite", stencilBits, fonts, invalidate,
             owners = componentActivity?.let(::ActivityOwners),
             insets = SystemBarInsets(window, statusBar, navigationBar),
             clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
         )
-        mount.setContent { held?.let { view -> key(view) { view.Content() } } }
+        mount.setContent {
+            val content = @Composable { held?.let { view -> key(view) { view.Content() } }; Unit }
+            // the content view's tree resolves the activity as its back dispatcher owner
+            if (componentActivity != null)
+                CompositionLocalProvider(LocalOnBackPressedDispatcherOwner provides componentActivity, content = content)
+            else content()
+        }
         mountId = addMount(mount)
+        runningMount = mount
         window.addToWindowManager()
         val view = checkNotNull(held) {
             "${spec.component.flattenToShortString()} set no ComposeView as its content; Peach composes only ComposeView content"
         }
         val params = view.layoutParams
-        return JSONObject().put("ok", true).put("id", mountId)
-            .put("decorFitsSystemWindows", window.fitsSystemWindows)
+        return window.describe().put("ok", true).put("id", mountId)
             .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
             .toString()
@@ -134,3 +152,40 @@ internal fun peachStartApp(
             .put("error", "${error::class.simpleName}: ${error.message}").toString()
     }
 }
+
+// the activity the app runs, once started, and the scene its window composes
+private var running: Activity? = null
+private var runningMount: PeachComposeMount? = null
+
+// the device's back: an activity with predictive back gets it through its
+// window's back dispatch, where ComponentActivity's dispatcher takes it only
+// while a callback is enabled and the activity's own default handles the
+// rest; without predictive back the key reaches onBackPressed. false when the
+// task moved to the back, which the device then shows as home.
+internal fun peachAppBack(predictive: Boolean): Boolean {
+    val activity = checkNotNull(running) { "the app is not running" }
+    activity.movedTaskToBack = false
+    val dispatcher = (activity as? ComponentActivity)?.onBackPressedDispatcher
+    if (!predictive) activity.onBackPressed()
+    else if (dispatcher?.hasEnabledCallbacks() == true) dispatcher.onBackPressed()
+    else activity.movedTaskToBack = true
+    return !activity.movedTaskToBack
+}
+
+// the task left the foreground (onPause, onStop, onSaveInstanceState) or came back to it
+// (onRestart, onStart, onResume, onPostResume), as ActivityThread drives it
+internal fun peachAppTask(foreground: Boolean) {
+    val activity = checkNotNull(running) { "the app is not running" }
+    if (foreground) {
+        activity.performRestart()
+        activity.performResume()
+        // the frame clock runs again once the activity is started
+        checkNotNull(runningMount).invalidate(false)
+    } else {
+        activity.performPause()
+        activity.performStop()
+        // from API 28 an activity that stops saves its state after onStop;
+        // ActivityThread keeps it for a relaunch, which no path here takes yet
+        activity.performSaveInstanceState(Bundle())
+    }
+}

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

@@ -8,6 +8,7 @@ import androidx.compose.ui.platform.ComposeView
 internal interface PeachWindowHost {
     fun compose(view: ComposeView): AutoCloseable
 
-    // the window's inset policy changed after it was added
+    // the inset policy or status bar the window asks the device for changed
+    // after it was added
     fun windowChanged()
 }

package/kotlin/AppSources/java/lang/Runnable.kt

@@ -0,0 +1,6 @@
+package java.lang
+
+// java.lang.Runnable, which the platform and androidx signatures name
+fun interface Runnable {
+    fun run()
+}

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -131,6 +131,9 @@ internal class PeachComposeMount(
     var constraints = Constraints()
         set(value) { if (field != value) { field = value; needsMeasure = true } }
     private val events = mutableListOf<JSONObject>()
+    // state reported once a frame, read when the frame draws: like the decor,
+    // the device sees the state a frame ends with, not each step to it
+    private val frameState = linkedMapOf<String, () -> Any?>()
     private val platform = PeachComposePlatform(Density(density, fontScale), LocaleList(locale), IntSize.Zero, owners, insets)
     private val recomposer = FrameRecomposer(Dispatchers.Main) { invalidate(false) }
     private var needsMeasure = true
@@ -159,6 +162,11 @@ internal class PeachComposeMount(
         invalidate(false)
     }
 
+    fun emitAtFrame(name: String, args: () -> Any?) {
+        frameState[name] = args
+        invalidate(false)
+    }
+
     fun measure(): IntSize {
         val measured = scene.measureContent(constraints)
         scene.size = measured
@@ -198,7 +206,9 @@ internal class PeachComposeMount(
         scene.draw(canvas.asComposeCanvas())
         val reply = JSONObject().put("width", measured.width).put("height", measured.height)
             .put("pending", recomposer.hasPendingWork() || scene.hasInvalidations())
-            .put("events", JSONArray(events))
+        for ((name, args) in frameState) events.add(JSONObject().put("name", name).put("args", args()))
+        frameState.clear()
+        reply.put("events", JSONArray(events))
         events.clear()
         if (gpu) checkNotNull(surface).flushAndSubmit()
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.657",
+  "version": "0.1.659",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -84,6 +84,13 @@
       "import": "./dist-lib/metro-production-bundle.mjs",
       "default": "./dist-lib/metro-production-bundle.cjs"
     },
+    "./plist": {
+      "types": "./src/plist.ts",
+      "source": "./src/plist.ts",
+      "bun": "./src/plist.ts",
+      "import": "./dist-lib/plist.mjs",
+      "default": "./dist-lib/plist.cjs"
+    },
     "./native-app-identity": {
       "types": "./src/native-app-identity.ts",
       "source": "./src/native-app-identity.ts",

package/skills/peach-setup/SKILL.md

@@ -113,6 +113,33 @@ peach open https://my-app.local  # load a hosted bundle
 - the compatibility scan's partial, unsupported, unknown, and version-mismatched
   packages have been summarized without treating its aggregate score as a pass/fail gate
 
+## the app's own native code
+
+an app's own native modules and views (a local Expo module, a
+`requireNativeComponent` view written in Swift or Kotlin) have no Peach
+implementation until the app supplies one. when the scan or the running app
+shows one missing (an empty view where content belongs, a "native module not
+found" error), add it to `peach.config.ts` at the app root:
+
+```ts
+import { defineConfig } from 'peachsim/config'
+
+export default defineConfig({
+  nativeModules: { MyAppModule: { file: './peach/my-app-module.ts' } },
+  nativeViews: {
+    RNBalanceLabel: { file: './peach/BalanceLabel.tsx' }, // requireNativeComponent name
+    MyModule_StatusView: { file: './peach/StatusView.tsx' }, // requireNativeView('MyModule', 'StatusView')
+  },
+})
+```
+
+a `nativeViews` file default-exports a component that receives the native
+view's props and renders what it shows on device, using `react-native` and
+`contrast-kit` primitives. a `nativeModules` file exports the module's
+methods, served to `NativeModules` and to Expo's `requireNativeModule`. a
+file may import other project files by relative path, so a large view splits
+into components and helpers. reopen the app to load the change.
+
 ## compatibility feedback requires approval
 
 run `peach compat --json` from the app project root during setup. if the scan