peachsim 0.1.648 → 0.1.650

package/kotlin/AppSources/android/app/Activity.kt

@@ -0,0 +1,85 @@
+package android.app
+
+import android.content.ComponentName
+import android.content.ContextWrapper
+import android.content.Intent
+import android.os.Bundle
+import android.util.SuperNotCalledException
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
+
+// the cold-start half of Activity: ActivityThread attaches it, then drives the
+// perform calls in its own order. each lifecycle method must call through to
+// super, as Activity.mCalled enforces, and the post callbacks run after it
+// returns, where ActivityLifecycleCallbacks see them.
+open class Activity : ContextWrapper() {
+    private var called = false
+    private var attachedIntent: Intent? = null
+    private var attachedApplication: Application? = null
+    private var attachedWindow: Window? = null
+    private var attachedComponent: ComponentName? = null
+
+    val intent: Intent get() = checkNotNull(attachedIntent)
+    val application: Application get() = checkNotNull(attachedApplication)
+    val window: Window get() = checkNotNull(attachedWindow)
+
+    // the activity class that runs; launched through an alias, the intent
+    // still names the alias
+    val componentName: ComponentName get() = checkNotNull(attachedComponent)
+
+    internal fun attach(application: Application, component: ComponentName, intent: Intent, window: Window) {
+        attachedApplication = application
+        attachedComponent = component
+        attachedIntent = intent
+        attachedWindow = window
+    }
+
+    open fun setContentView(view: View) {
+        setContentView(view, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+    }
+
+    open fun setContentView(view: View, params: ViewGroup.LayoutParams) {
+        window.setContentView(view, params)
+    }
+
+    protected open fun onCreate(savedInstanceState: Bundle?) { called = true }
+    protected open fun onStart() { called = true }
+    protected open fun onPostCreate(savedInstanceState: Bundle?) { called = true }
+    protected open fun onResume() { called = true }
+    protected open fun onPostResume() { called = true }
+
+    // ActivityLifecycleCallbacks' post events; ComponentActivity's lifecycle
+    // moves on these, as its ReportFragment does from API 29.
+    internal open fun dispatchActivityPostCreated() {}
+    internal open fun dispatchActivityPostStarted() {}
+    internal open fun dispatchActivityPostResumed() {}
+
+    private fun require(method: String, call: () -> Unit) {
+        called = false
+        call()
+        if (!called) throw SuperNotCalledException(
+            "Activity {${componentName.flattenToShortString()}} did not call through to super.$method()"
+        )
+    }
+
+    internal fun performCreate(icicle: Bundle?) {
+        require("onCreate") { onCreate(icicle) }
+        dispatchActivityPostCreated()
+    }
+
+    internal fun performStart() {
+        require("onStart") { onStart() }
+        dispatchActivityPostStarted()
+    }
+
+    internal fun performPostCreate(icicle: Bundle?) {
+        require("onPostCreate") { onPostCreate(icicle) }
+    }
+
+    internal fun performResume() {
+        require("onResume") { onResume() }
+        require("onPostResume") { onPostResume() }
+        dispatchActivityPostResumed()
+    }
+}

package/kotlin/AppSources/android/app/Application.kt

@@ -0,0 +1,7 @@
+package android.app
+
+import android.content.ContextWrapper
+
+open class Application : ContextWrapper() {
+    open fun onCreate() {}
+}

package/kotlin/AppSources/android/content/Context.kt

@@ -0,0 +1,5 @@
+package android.content
+
+abstract class Context
+
+open class ContextWrapper : Context()

package/kotlin/AppSources/android/content/Intent.kt

@@ -0,0 +1,16 @@
+package android.content
+
+class ComponentName(val packageName: String, val className: String) {
+    fun flattenToShortString(): String =
+        if (className.startsWith("$packageName.")) "$packageName/${className.removePrefix(packageName)}"
+        else "$packageName/$className"
+}
+
+class Intent(val action: String?, val categories: Set<String>?, val component: ComponentName?) {
+    fun hasCategory(category: String): Boolean = categories?.contains(category) == true
+
+    companion object {
+        const val ACTION_MAIN = "android.intent.action.MAIN"
+        const val CATEGORY_LAUNCHER = "android.intent.category.LAUNCHER"
+    }
+}

package/kotlin/AppSources/android/os/Bundle.kt

@@ -0,0 +1,5 @@
+package android.os
+
+// a cold start has no saved instance state, so the launcher receives null;
+// the type exists for the signatures that name it.
+class Bundle

package/kotlin/AppSources/android/util/SuperNotCalledException.kt

@@ -0,0 +1,3 @@
+package android.util
+
+class SuperNotCalledException(message: String) : RuntimeException(message)

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

@@ -0,0 +1,72 @@
+package android.view
+
+import android.content.Context
+
+open class View(val context: Context) {
+    var parent: ViewGroup? = null
+        internal set
+    var layoutParams: ViewGroup.LayoutParams? = null
+    internal var attachedWindow: Window? = null
+
+    val isAttachedToWindow: Boolean get() = attachedWindow != null
+
+    // ViewRootImpl dispatches attach through the tree once the window is added
+    internal open fun dispatchAttachedToWindow(window: Window) {
+        attachedWindow = window
+        onAttachedToWindow()
+    }
+
+    internal open fun dispatchDetachedFromWindow() {
+        onDetachedFromWindow()
+        attachedWindow = null
+    }
+
+    protected open fun onAttachedToWindow() {}
+    protected open fun onDetachedFromWindow() {}
+}
+
+open class ViewGroup(context: Context) : View(context) {
+    open class LayoutParams(val width: Int, val height: Int) {
+        companion object {
+            const val MATCH_PARENT = -1
+            const val WRAP_CONTENT = -2
+        }
+    }
+
+    private val children = mutableListOf<View>()
+
+    val childCount: Int get() = children.size
+    fun getChildAt(index: Int): View? = children.getOrNull(index)
+
+    fun addView(child: View, params: LayoutParams) {
+        child.layoutParams = params
+        addView(child)
+    }
+
+    open fun addView(child: View) {
+        check(child.parent == null) {
+            "The specified child already has a parent. You must call removeView() on the child's parent first."
+        }
+        children += child
+        child.parent = this
+        attachedWindow?.let { child.dispatchAttachedToWindow(it) }
+    }
+
+    fun removeAllViews() {
+        for (child in children) {
+            if (child.isAttachedToWindow) child.dispatchDetachedFromWindow()
+            child.parent = null
+        }
+        children.clear()
+    }
+
+    override fun dispatchAttachedToWindow(window: Window) {
+        super.dispatchAttachedToWindow(window)
+        for (child in children.toList()) child.dispatchAttachedToWindow(window)
+    }
+
+    override fun dispatchDetachedFromWindow() {
+        for (child in children.toList()) child.dispatchDetachedFromWindow()
+        super.dispatchDetachedFromWindow()
+    }
+}

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

@@ -0,0 +1,44 @@
+package android.view
+
+import android.content.Context
+import android.widget.FrameLayout
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import dev.peach.app.PeachWindowHost
+
+// PhoneWindow's content parent (android.R.id.content) inside its decor. the
+// window is added, and its views attached, after the activity resumes.
+class Window internal constructor(
+    context: Context,
+    private val edgeToEdgeEnforced: Boolean,
+    internal val host: PeachWindowHost,
+) {
+    internal val contentParent = FrameLayout(context)
+    val decorView: View get() = contentParent
+
+    // PhoneWindow fits system windows unless told otherwise, and applies that
+    // only while edge to edge is not enforced for the app's target SDK
+    private var decorFitsSystemWindows by mutableStateOf(true)
+    internal val fitsSystemWindows: Boolean get() = decorFitsSystemWindows && !edgeToEdgeEnforced
+
+    fun setDecorFitsSystemWindows(decorFitsSystemWindows: Boolean) {
+        val before = fitsSystemWindows
+        this.decorFitsSystemWindows = decorFitsSystemWindows
+        if (fitsSystemWindows != before) host.windowChanged()
+    }
+
+    // Activity.setContentView(View) fills the content parent
+    internal fun setContentView(view: View, params: ViewGroup.LayoutParams) {
+        contentParent.removeAllViews()
+        contentParent.addView(view, params)
+    }
+
+    internal fun addToWindowManager() {
+        contentParent.dispatchAttachedToWindow(this)
+    }
+
+    internal fun removeFromWindowManager() {
+        if (contentParent.isAttachedToWindow) contentParent.dispatchDetachedFromWindow()
+    }
+}

package/kotlin/AppSources/android/widget/FrameLayout.kt

@@ -0,0 +1,6 @@
+package android.widget
+
+import android.content.Context
+import android.view.ViewGroup
+
+open class FrameLayout(context: Context) : ViewGroup(context)

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

@@ -0,0 +1,57 @@
+package androidx.activity
+
+import android.app.Activity
+import android.os.Bundle
+import androidx.lifecycle.HasDefaultViewModelProviderFactory
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.SAVED_STATE_REGISTRY_OWNER_KEY
+import androidx.lifecycle.SavedStateViewModelFactory
+import androidx.lifecycle.VIEW_MODEL_STORE_OWNER_KEY
+import androidx.lifecycle.ViewModelStore
+import androidx.lifecycle.ViewModelStoreOwner
+import androidx.lifecycle.enableSavedStateHandles
+import androidx.lifecycle.viewmodel.CreationExtras
+import androidx.lifecycle.viewmodel.MutableCreationExtras
+import androidx.savedstate.SavedStateRegistry
+import androidx.savedstate.SavedStateRegistryController
+import androidx.savedstate.SavedStateRegistryOwner
+
+// androidx.activity's ComponentActivity owners, on the multiplatform
+// lifecycle, viewmodel and savedstate libraries: the registry attaches in the
+// constructor and restores in onCreate before super, the lifecycle moves on
+// the post callbacks, and destroy clears the view model store.
+open class ComponentActivity : Activity(), LifecycleOwner, ViewModelStoreOwner,
+    HasDefaultViewModelProviderFactory, SavedStateRegistryOwner {
+    private val lifecycleRegistry = LifecycleRegistry(this)
+    private val savedStateRegistryController = SavedStateRegistryController.create(this)
+
+    override val lifecycle: Lifecycle get() = lifecycleRegistry
+    override val viewModelStore: ViewModelStore = ViewModelStore()
+    override val savedStateRegistry: SavedStateRegistry get() = savedStateRegistryController.savedStateRegistry
+    override val defaultViewModelProviderFactory = SavedStateViewModelFactory()
+    override val defaultViewModelCreationExtras: CreationExtras
+        get() = MutableCreationExtras().also {
+            it[SAVED_STATE_REGISTRY_OWNER_KEY] = this
+            it[VIEW_MODEL_STORE_OWNER_KEY] = this
+        }
+
+    init {
+        lifecycleRegistry.addObserver(LifecycleEventObserver { _, event ->
+            if (event == Lifecycle.Event.ON_DESTROY) viewModelStore.clear()
+        })
+        savedStateRegistryController.performAttach()
+        enableSavedStateHandles()
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        savedStateRegistryController.performRestore(null)
+        super.onCreate(savedInstanceState)
+    }
+
+    override fun dispatchActivityPostCreated() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    override fun dispatchActivityPostStarted() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+    override fun dispatchActivityPostResumed() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
+}

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

@@ -0,0 +1,29 @@
+package androidx.activity.compose
+
+import android.view.ViewGroup
+import androidx.activity.ComponentActivity
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionContext
+import androidx.compose.ui.platform.ComposeView
+
+private val DefaultActivityContentLayoutParams =
+    ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+
+// activity-compose's setContent: reuse the ComposeView already in the content
+// parent, otherwise create one and set it as the content view. the activity
+// itself supplies the view tree owners.
+fun ComponentActivity.setContent(
+    parent: CompositionContext? = null,
+    content: @Composable () -> Unit,
+) {
+    val existingComposeView =
+        (window.decorView as ViewGroup).getChildAt(0) as? ComposeView
+    if (existingComposeView != null) with(existingComposeView) {
+        setParentCompositionContext(parent)
+        setContent(content)
+    } else ComposeView(this).apply {
+        setParentCompositionContext(parent)
+        setContent(content)
+        setContentView(this, DefaultActivityContentLayoutParams)
+    }
+}

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

@@ -0,0 +1,67 @@
+package androidx.compose.ui.platform
+
+import android.content.Context
+import android.view.ViewGroup
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionContext
+import androidx.compose.runtime.mutableStateOf
+
+// AbstractComposeView and ComposeView as compose-ui's Android source has them:
+// setContent stores a state-backed lambda, composition starts when the view
+// attaches to a window, a later setContent replaces the lambda inside the same
+// composition, and detaching disposes it (the default view composition
+// strategy).
+class ComposeView(context: Context) : ViewGroup(context) {
+    private val content = mutableStateOf<(@Composable () -> Unit)?>(null)
+    private var shouldCreateCompositionOnAttachedToWindow = false
+    private var parentContext: CompositionContext? = null
+    private var composition: AutoCloseable? = null
+
+    val hasComposition: Boolean get() = composition != null
+
+    @Composable
+    internal fun Content() {
+        content.value?.invoke()
+    }
+
+    fun setParentCompositionContext(parent: CompositionContext?) {
+        parentContext = parent
+    }
+
+    fun setContent(content: @Composable () -> Unit) {
+        shouldCreateCompositionOnAttachedToWindow = true
+        this.content.value = content
+        if (isAttachedToWindow) createComposition()
+    }
+
+    fun createComposition() {
+        check(parentContext != null || isAttachedToWindow) {
+            "createComposition requires a previous call to createComposition(ComposeViewContext)," +
+                " a parent reference, or the View to be attached to a window. Attach the View or " +
+                "call setParentCompositionReference."
+        }
+        ensureCompositionCreated()
+    }
+
+    fun disposeComposition() {
+        composition?.close()
+        composition = null
+    }
+
+    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" }
+        composition = window.host.compose(this)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        if (shouldCreateCompositionOnAttachedToWindow) ensureCompositionCreated()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        disposeComposition()
+    }
+}

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

@@ -0,0 +1,136 @@
+@file:OptIn(androidx.compose.ui.InternalComposeUiApi::class)
+
+package dev.peach.app
+
+import android.app.Activity
+import android.app.Application
+import android.content.ComponentName
+import android.content.Intent
+import android.view.ViewGroup
+import android.view.Window
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.platform.ComposeView
+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.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.Lifecycle
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventDispatcherOwner
+import PeachComposeMount
+import addMount
+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
+// Application and that class (wasm has no reflection).
+internal class PeachAppSpec(
+    val launcher: ComponentName,
+    val component: ComponentName,
+    val targetSdk: Int,
+    val optOutEdgeToEdge: Boolean,
+    val createApplication: () -> Application,
+    val createActivity: () -> Activity,
+)
+
+// the system bars 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.
+private class SystemBarInsets(
+    private val window: Window,
+    private val status: Int,
+    private val navigation: Int,
+) : PlatformWindowInsets {
+    // read when compose lays out, so a later change to the window applies
+    private fun delivered(pixels: Int) = if (window.fitsSystemWindows) 0 else pixels
+    override val statusBars = PlatformInsets(getTop = { delivered(status) })
+    override val navigationBars = PlatformInsets(getBottom = { delivered(navigation) })
+    override val systemBars =
+        PlatformInsets(getTop = { delivered(status) }, getBottom = { delivered(navigation) })
+}
+
+private class ActivityOwners(activity: ComponentActivity) : PlatformArchitectureComponentsOwner {
+    override val lifecycleOwner = activity
+    override val viewModelStoreOwner = activity
+    override val savedStateRegistryOwner = activity
+    override val navigationEventDispatcherOwner = object : NavigationEventDispatcherOwner {
+        override val navigationEventDispatcher = NavigationEventDispatcher()
+    }
+}
+
+// a cold start in ActivityThread's order: the Application and its onCreate,
+// then the launcher activity attached to its window and launcher intent,
+// onCreate, onStart, onPostCreate, onResume and onPostResume, and only then the
+// 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,
+    statusBar: Int, navigationBar: Int,
+    invalidate: (Boolean) -> Unit,
+): String {
+    try {
+        require(backend == "graphite" || backend == "raster")
+        preparePeachDevice(locale)
+        val fonts = robotoFamily(regular, medium, bold)
+        val application = spec.createApplication()
+        application.onCreate()
+        val activity = spec.createActivity()
+        val componentActivity = activity as? ComponentActivity
+        lateinit var window: Window
+        lateinit var mount: PeachComposeMount
+        var mountId = 0
+        // the window's one scene composes the ComposeView it holds; a new
+        // view starts a new composition, as on the device
+        var held by mutableStateOf<ComposeView?>(null)
+        val host = object : PeachWindowHost {
+            override fun compose(view: ComposeView): AutoCloseable {
+                held = view
+                return AutoCloseable { if (held === view) held = null }
+            }
+
+            override fun windowChanged() {
+                if (mountId != 0)
+                    mount.emit("window", JSONObject().put("decorFitsSystemWindows", window.fitsSystemWindows).toString())
+            }
+        }
+        val enforced = spec.targetSdk > 35 || (spec.targetSdk == 35 && !spec.optOutEdgeToEdge)
+        window = Window(activity, enforced, host)
+        activity.attach(
+            application,
+            spec.component,
+            Intent(Intent.ACTION_MAIN, setOf(Intent.CATEGORY_LAUNCHER), spec.launcher),
+            window,
+        )
+        activity.performCreate(null)
+        activity.performStart()
+        activity.performPostCreate(null)
+        activity.performResume()
+        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() } } }
+        mountId = addMount(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)
+            .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
+            .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
+            .toString()
+    } catch (error: Throwable) {
+        return JSONObject().put("ok", false).put("code", "E_KOTLIN_APP")
+            .put("error", "${error::class.simpleName}: ${error.message}").toString()
+    }
+}

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

@@ -0,0 +1,13 @@
+package dev.peach.app
+
+import androidx.compose.ui.platform.ComposeView
+
+// the device side of a window: one Peach scene for the window's life, which
+// composes whichever ComposeView the window holds once that view attaches.
+// the composition ends when the view disposes it.
+internal interface PeachWindowHost {
+    fun compose(view: ComposeView): AutoCloseable
+
+    // the window's inset policy changed after it was added
+    fun windowChanged()
+}