peachsim 0.1.660 → 0.1.662

package/src/kotlin-host.ts

@@ -12,6 +12,11 @@ import path from 'node:path'
 import { promisify } from 'node:util'
 import { rnxHomeDir } from './home-paths'
 import { isRecord } from './is-record'
+import {
+  readAbiClasses,
+  viewModelClasses,
+  type ViewModelClass,
+} from './kotlin-view-models'
 import type { KotlinAppProject } from './kotlin-app'
 import type { ServerResponse } from 'node:http'
 
@@ -262,7 +267,7 @@ function entrySource(ids: string[]): string {
   ].join('\n')
 }
 
-const BUILD_FORMAT = 7
+const BUILD_FORMAT = 8
 const builds = new Map<string, Promise<KotlinArtifact>>()
 
 function buildsDir(): string {
@@ -320,8 +325,30 @@ function viewsSource(viewIds: string[]): string {
   ].join('\n')
 }
 
+// the call SavedStateViewModelFactory makes for each constructor it finds, or
+// its error for one that takes the application and handle in another order
+function viewModelInitializer({ name, signature }: ViewModelClass): string {
+  const call = (args: string) =>
+    `            addInitializer(${name}::class) { ${name}(${args}) }`
+  switch (signature) {
+    case 'none':
+      return call('')
+    case 'handle':
+      return call('createSavedStateHandle()')
+    case 'application':
+      return call('dev.peach.app.peachApplication()')
+    case 'application-handle':
+      return call('dev.peach.app.peachApplication(), createSavedStateHandle()')
+    case 'misordered':
+      return `            addInitializer(${name}::class) { throw UnsupportedOperationException(${JSON.stringify(
+        `Class ${name.split('.').pop()} must have parameters in the proper order: [class android.app.Application, class androidx.lifecycle.SavedStateHandle]`,
+      )}) }`
+  }
+}
+
 // a pure Kotlin app: its module's sources, the Android platform actuals and
 // the compose host, with an entry that cold-starts the resolved launcher
+
 export async function kotlinAppArtifact(
   app: KotlinAppProject,
   moduleRoot: string,
@@ -329,29 +356,33 @@ export async function kotlinAppArtifact(
 ): Promise<KotlinArtifact> {
   const toolchain = readToolchain(moduleRoot)
   const kotlinString = (value: string) => JSON.stringify(value).replaceAll('$', '\\$')
-  const generated: Record<string, string> = {
-    'PeachEntry.kt': entrySource([]),
-    'PeachViews.kt': viewsSource([]),
-    'PeachAppEntry.kt': [
+  const appEntry = (viewModels: ViewModelClass[]) =>
+    [
       '@file:OptIn(kotlin.js.ExperimentalJsExport::class)',
       '',
+      'import androidx.lifecycle.createSavedStateHandle',
+      '',
       '@JsExport',
       'fun peachAppMount(density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,',
-      '    regular: String, medium: String, bold: String, statusBar: Int, navigationBar: Int, night: Boolean,',
+      '    regular: String, medium: String, bold: String, insets: String, night: Boolean,',
       '    invalidate: (Boolean) -> Unit): String = dev.peach.app.peachStartApp(',
       '    dev.peach.app.PeachAppSpec(',
       `        android.content.ComponentName(${kotlinString(app.packageName)}, ${kotlinString(app.launcher.name)}),`,
       `        android.content.ComponentName(${kotlinString(app.packageName)}, ${kotlinString(app.launcher.targetClass)}),`,
       '        android.view.WindowTheme(',
       `            ${app.window.edgeToEdgeEnforced}, 0x${app.window.statusBarColor.toString(16).padStart(8, '0')}.toInt(),`,
+      `            0x${app.window.navigationBarColor.toString(16).padStart(8, '0')}.toInt(),`,
       `            ${app.window.statusBarContrastEnforced}, ${app.window.navigationBarContrastEnforced},`,
       `            ${app.window.lightStatusBar}, ${app.window.lightNavigationBar},`,
       '        ),',
       `        { ${app.applicationClass ?? 'android.app.Application'}() },`,
       `        { ${app.launcher.targetClass}() },`,
       `        ${app.handlesUiMode},`,
+      '        androidx.lifecycle.viewmodel.viewModelFactory {',
+      ...viewModels.map(viewModelInitializer),
+      '        },',
       '    ),',
-      '    density, fontScale, locale, backend, stencilBits, regular, medium, bold, statusBar, navigationBar, night, invalidate,',
+      '    density, fontScale, locale, backend, stencilBits, regular, medium, bold, insets, night, invalidate,',
       ')',
       '',
       '@JsExport',
@@ -363,7 +394,11 @@ export async function kotlinAppArtifact(
       '@JsExport',
       'fun peachAppNight(night: Boolean) = dev.peach.app.peachAppNight(night)',
       '',
-    ].join('\n'),
+    ].join('\n')
+  const generated: Record<string, string> = {
+    'PeachEntry.kt': entrySource([]),
+    'PeachViews.kt': viewsSource([]),
+    'PeachAppEntry.kt': appEntry([]),
   }
   const shims = [
     ...kotlinSources(path.join(moduleRoot, 'Sources')),
@@ -379,6 +414,11 @@ export async function kotlinAppArtifact(
       generated,
       shims,
       usesCompose: true,
+      viewModels: {
+        file: 'PeachAppEntry.kt',
+        render: appEntry,
+        script: path.join(moduleRoot, 'tools/abi-classes.main.kts'),
+      },
     },
     origin,
   )
@@ -393,10 +433,26 @@ async function compileKotlin(
     generated: Record<string, string>
     shims: string[]
     usesCompose: boolean
+    // a generated file that names the app's view models: rendered empty for a
+    // first compile, then from that klib's ABI
+    viewModels?: {
+      file: string
+      render: (classes: ViewModelClass[]) => string
+      script: string
+    }
   },
   origin: string,
 ): Promise<KotlinArtifact> {
-  const { root, toolchain, language, sources, generated, shims, usesCompose } = input
+  const {
+    root,
+    toolchain,
+    language,
+    sources,
+    generated,
+    shims,
+    usesCompose,
+    viewModels,
+  } = input
   const digest = createHash('sha256')
   // BUILD_FORMAT moves when this host changes what it does to a build
   digest.update(JSON.stringify({ format: BUILD_FORMAT, toolchain, language }))
@@ -443,8 +499,8 @@ async function compileKotlin(
       '-libraries',
       libraries.join(path.delimiter),
     ]
-    try {
-      await run(
+    const compileKlib = (outputDir: string) =>
+      run(
         kotlinc,
         [
           ...common,
@@ -460,7 +516,7 @@ async function compileKotlin(
           '-nowarn',
           '-nopack',
           '-ir-output-dir',
-          path.join(work, 'klib'),
+          outputDir,
           '-ir-output-name',
           'app',
           ...shims,
@@ -469,6 +525,32 @@ async function compileKotlin(
         ],
         { maxBuffer: 16 * 1024 * 1024 },
       )
+    try {
+      // the compiler resolves the app's classes and constructors: a first
+      // klib's ABI names the view models the generated factory builds. an app
+      // whose sources never name ViewModel declares none and skips it
+      if (
+        viewModels &&
+        sources.some((file) => fs.readFileSync(file, 'utf8').includes('ViewModel'))
+      ) {
+        await compileKlib(path.join(work, 'abi'))
+        const { stdout } = await run(
+          path.join(path.dirname(kotlinc), 'kotlinc'),
+          [
+            '-cp',
+            path.resolve(path.dirname(kotlinc), '../lib/kotlin-compiler.jar'),
+            '-script',
+            viewModels.script,
+            path.join(work, 'abi'),
+          ],
+          { maxBuffer: 64 * 1024 * 1024 },
+        )
+        fs.writeFileSync(
+          path.join(generatedDir, viewModels.file),
+          viewModels.render(viewModelClasses(readAbiClasses(stdout))),
+        )
+      }
+      await compileKlib(path.join(work, 'klib'))
       await run(
         kotlinc,
         [

package/src/kotlin-view-models.ts

@@ -0,0 +1,133 @@
+// the ViewModel classes an app declares, read from its compiled klib's ABI
+// (`kotlin/tools/abi-classes.main.kts`), each with the constructor androidx's
+// SavedStateViewModelFactory finds by reflection: an AndroidViewModel takes a
+// public (Application, SavedStateHandle) constructor, else AndroidViewModel
+// Factory's public (Application) one; any other view model a public
+// (SavedStateHandle) one, else NewInstanceFactory's no-argument one, which
+// kotlin adds when every parameter has a default. Kotlin/Wasm has no
+// reflection, so the host generates these calls. a class the factory cannot
+// build is left out and fails when created, as it does on the device; the
+// ABI lists public declarations only, so an internal class is left out too.
+import { isRecord } from './is-record'
+
+export type ViewModelSignature =
+  | 'none'
+  | 'handle'
+  | 'application'
+  | 'application-handle'
+  | 'misordered'
+
+export interface ViewModelClass {
+  name: string
+  signature: ViewModelSignature
+}
+
+interface AbiClass {
+  name: string
+  kind: string
+  modality: string
+  inner: boolean
+  generic: boolean
+  supers: string[]
+  constructors: Array<{ parameters: string[]; defaulted: boolean }>
+}
+
+const VIEW_MODEL = 'androidx.lifecycle.ViewModel'
+const ANDROID_VIEW_MODEL = 'androidx.lifecycle.AndroidViewModel'
+const APPLICATION = 'android.app.Application'
+const HANDLE = 'androidx.lifecycle.SavedStateHandle'
+
+function strings(value: unknown): string[] {
+  if (!Array.isArray(value) || !value.every((item) => typeof item === 'string'))
+    throw new Error('abi-classes printed an invalid list')
+  return value
+}
+
+export function readAbiClasses(output: string): AbiClass[] {
+  return output
+    .split('\n')
+    .filter((line) => line.startsWith('{'))
+    .map((line) => {
+      const row: unknown = JSON.parse(line)
+      if (
+        !isRecord(row) ||
+        typeof row.name !== 'string' ||
+        typeof row.kind !== 'string' ||
+        typeof row.modality !== 'string' ||
+        typeof row.inner !== 'boolean' ||
+        typeof row.generic !== 'boolean' ||
+        !Array.isArray(row.constructors)
+      )
+        throw new Error(`abi-classes printed an invalid class: ${line}`)
+      return {
+        name: row.name,
+        kind: row.kind,
+        modality: row.modality,
+        inner: row.inner,
+        generic: row.generic,
+        supers: strings(row.supers),
+        constructors: row.constructors.map((constructor: unknown) => {
+          if (!isRecord(constructor) || typeof constructor.defaulted !== 'boolean')
+            throw new Error(`abi-classes printed an invalid constructor: ${line}`)
+          return {
+            parameters: strings(constructor.parameters),
+            defaulted: constructor.defaulted,
+          }
+        }),
+      }
+    })
+}
+
+// SavedStateViewModelFactory's findMatchingConstructor: an exact match, or an
+// error when a constructor takes the same types in another order
+function matching(row: AbiClass, signature: string[]): 'match' | 'misordered' | null {
+  for (const { parameters } of row.constructors) {
+    if (parameters.join() === signature.join()) return 'match'
+    if (
+      parameters.length === signature.length &&
+      signature.every((type) => parameters.includes(type))
+    )
+      return 'misordered'
+  }
+  return null
+}
+
+function signatureOf(row: AbiClass, android: boolean): ViewModelSignature | null {
+  const handled = matching(row, android ? [APPLICATION, HANDLE] : [HANDLE])
+  if (handled === 'misordered') return 'misordered'
+  if (handled) return android ? 'application-handle' : 'handle'
+  if (android)
+    return row.constructors.some(({ parameters }) => parameters.join() === APPLICATION)
+      ? 'application'
+      : null
+  return row.constructors.some(
+    ({ parameters, defaulted }) => parameters.length === 0 || defaulted,
+  )
+    ? 'none'
+    : null
+}
+
+export function viewModelClasses(rows: AbiClass[]): ViewModelClass[] {
+  const byName = new Map(rows.map((row) => [row.name, row]))
+  // the framework base a class reaches through the app's own classes
+  const base = (row: AbiClass, seen: Set<string>): string | null => {
+    for (const name of row.supers) {
+      if (name === VIEW_MODEL || name === ANDROID_VIEW_MODEL) return name
+      const parent = byName.get(name)
+      if (parent && !seen.has(name)) {
+        seen.add(name)
+        const found = base(parent, seen)
+        if (found) return found
+      }
+    }
+    return null
+  }
+  return rows.flatMap((row) => {
+    if (row.kind !== 'CLASS' || row.inner || row.generic) return []
+    if (row.modality === 'ABSTRACT' || row.modality === 'SEALED') return []
+    const root = base(row, new Set())
+    if (!root) return []
+    const signature = signatureOf(row, root === ANDROID_VIEW_MODEL)
+    return signature ? [{ name: row.name, signature }] : []
+  })
+}