craft-native 0.0.244 → 0.0.246

package/dist/android/src/index.d.ts

@@ -11,6 +11,20 @@ export type { AndroidMapProvider } from './native-map.js';
  * route's file. Stacks asks for route bundles only when this is true.
  */
 export declare const nativeRouteBundles = true;
+/**
+ * The app evaluates stx's shared runtime (`__runtime.js`, stx's
+ * `sharedRuntime`) in each screen's context before the route's own file.
+ * Stacks asks stx for it only when this is true: a route file built so
+ * refuses to run without it.
+ */
+export declare const nativeRouteRuntime = true;
+/**
+ * The app gives a screen its messages a language at a time (stx's
+ * `messages`, `native-screens/__messages/`): the areas its route uses,
+ * evaluated ahead of it (an isolate cannot read a file when asked). Stacks leaves the languages
+ * out of the screens' code only when this is true.
+ */
+export declare const nativeMessages = true;
 /** Providers this published builder can generate as real Android map views. */
 export declare const nativeMapProviders: readonly ['google', 'maplibre'];
 export { runKotlinFixture } from './testing.js';
@@ -118,6 +132,12 @@ export interface CraftAndroidConfig {
         selectedIconPulse?: boolean;
     }>;
     nativeApp?: string;
+    /**
+     * The secure-storage key the signed-in account's token lives under
+     * (default `auth.token`). `craft.session` follows it on every native
+     * screen, and a change of it is `SESSION_CHANGED { key, token, previous }`.
+     */
+    sessionTokenKey?: string;
     /** Wake the app script every so often (`craftBackgroundRefresh`), through WorkManager. */
     backgroundRefresh?: {
         enabled?: boolean;

package/dist/android/src/index.js

@@ -360,6 +360,8 @@ async function createAndroidEmulator(options) {
 
 // ../android/src/index.ts
 var nativeRouteBundles = true;
+var nativeRouteRuntime = true;
+var nativeMessages = true;
 var nativeMapProviders = ["google", "maplibre"];
 function syncNativeFonts(fonts, output) {
   const destination = join3(output, "app/src/main/assets/NativeFonts");
@@ -808,6 +810,7 @@ function writeNativeShellSources(output, packagePath, packageName, config) {
   write("CraftBluetooth.kt.template", "CraftBluetooth.kt");
   write("CraftNativeShell.kt.template", "CraftNativeShell.kt");
   write("CraftNativeImageCache.kt.template", "CraftNativeImageCache.kt");
+  write("CraftNativeHaptics.kt.template", "CraftNativeHaptics.kt");
   write("CraftNativeBackground.kt.template", "CraftNativeBackground.kt");
   write(config.enableHealthConnect ? "CraftNativeHealth.kt.template" : "CraftNativeHealthStub.kt.template", "CraftNativeHealth.kt");
   write("CraftNativeServices.kt.template", "CraftNativeServices.kt", (source) => source.replace("{{NATIVE_PUSH_IMPORTS}}", config.enablePushNotifications ? "import com.google.firebase.messaging.FirebaseMessaging" : "").replace("{{NATIVE_PUSH_REGISTER}}", config.enablePushNotifications ? `        try {
@@ -1379,7 +1382,9 @@ export {
   renderAndroidPermissions,
   renderAndroidDeepLinks,
   open,
+  nativeRouteRuntime,
   nativeRouteBundles,
+  nativeMessages,
   nativeMapProviders,
   installRuntime,
   init,

package/dist/android/templates/CraftNativeBackground.kt.template

@@ -71,13 +71,46 @@ internal object CraftNativeBundle {
     private fun read(context: Context, asset: String): String? = sources.get(asset)
         ?: runCatching { context.assets.open(asset).bufferedReader().use { it.readText() } }.getOrNull()?.also { sources.put(asset, it) }
 
+    /**
+     * A route's file runs on the runtime stx writes beside it
+     * (`native-screens/__runtime.js`), so the two go to the isolate together,
+     * runtime first, then the route's messages. A one-file bundle carries its
+     * runtime itself.
+     */
     fun source(context: Context, route: String?): String? {
         if (!route.isNullOrBlank() && !route.contains('/') && !route.startsWith('.')) {
-            read(context, "native-screens/$route.js")?.let { return it }
+            read(context, "native-screens/$route.js")?.let { own ->
+                val runtime = read(context, "native-screens/__runtime.js") ?: return own
+                val messages = messages(context, route)
+                return runtime + "\n;\n" + (if (messages != null) messages + "\n;\n" else "") + own
+            }
         }
         return read(context, "native-screen.js")
     }
 
+    /**
+     * The messages of the areas a route uses (stx's `messages`:
+     * `native-screens/__messages/routes.json` names them), in every language.
+     * On iOS a screen reads one language's area the first time it looks
+     * inside it; an isolate cannot call back into the app and wait for an
+     * answer, so here they are evaluated ahead of the route, as
+     * `__stxNativeMessages`, which the runtime reads first.
+     */
+    private fun messages(context: Context, route: String): String? {
+        val listing = read(context, "native-screens/__messages/routes.json") ?: return null
+        val areas = runCatching { org.json.JSONObject(listing).optJSONArray(route) }.getOrNull() ?: return null
+        if (areas.length() == 0) return null
+        val languages = context.assets.list("native-screens/__messages")?.filter { !it.contains('.') }?.sorted() ?: return null
+        val tables = languages.joinToString(",") { language ->
+            val entries = (0 until areas.length()).mapNotNull { index ->
+                val area = areas.optString(index)
+                read(context, "native-screens/__messages/$language/$area.json")?.let { "${org.json.JSONObject.quote(area)}:$it" }
+            }
+            "${org.json.JSONObject.quote(language)}:{${entries.joinToString(",")}}"
+        }
+        return "globalThis.__stxNativeMessages={$tables};"
+    }
+
     fun isAvailable(context: Context): Boolean =
         runCatching { context.assets.open("native-screen.js").close(); true }.getOrDefault(false)
             || (context.assets.list("native-screens")?.isNotEmpty() == true)
@@ -206,7 +239,8 @@ internal class CraftNativeHeadlessApp(
                 colorScheme: 'light',
                 appURL: ${JSONObject.quote(config.optString("devServerURL"))},
                 appVersion: '',
-                appBuild: ''
+                appBuild: '',
+                sessionTokenKey: ${JSONObject.quote(CraftNativePrelude.sessionTokenKey(config))}
             """.trimIndent()
             val prelude = CraftNativePrelude.script(
                 bridgeFields,

package/dist/android/templates/CraftNativeHaptics.kt.template

@@ -0,0 +1,124 @@
+package {{PACKAGE_NAME}}
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+import android.view.HapticFeedbackConstants
+import android.view.View
+
+/**
+ * A native screen's haptics, in the names iOS plays (CraftNativeActions.swift,
+ * `CraftHaptics.play`): an impact weight (`light`, `medium`, `heavy`, `soft`,
+ * `rigid`), a notification type (`success`, `warning`, `error`) or
+ * `selection`. Anything else plays a medium impact, as an unknown style does
+ * on iOS.
+ *
+ * The screen's own haptic feedback comes first. It needs no VIBRATE
+ * permission and follows the system's touch-feedback setting, the way UIKit's
+ * feedback generators follow System Haptics, so a person who turned haptics
+ * off feels nothing. A style with no feedback constant on the device's API
+ * level (a warning on every version, success and error before Android 11)
+ * goes to the vibrator: a predefined effect from Android 10, timings before.
+ */
+internal object CraftNativeHaptics {
+    val impactStyles = setOf("light", "medium", "heavy", "soft", "rigid")
+    val notificationTypes = setOf("success", "warning", "error")
+
+    // Lazy, so the pure mappings load in a JVM unit test with no main looper.
+    private val main by lazy { Handler(Looper.getMainLooper()) }
+
+    /**
+     * The style a `Haptics.<method>(args[0])` call plays, or null for a method
+     * that plays nothing (`prepare`; Android has no engine to warm). `impact`
+     * takes any style, as iOS's does: stx's bridge sends every kind through it.
+     */
+    fun style(method: String, argument: String?): String? = when (method) {
+        "impact" -> argument?.takeIf { it.isNotBlank() } ?: "medium"
+        "notification" -> argument?.takeIf { it in notificationTypes } ?: "success"
+        "selection" -> "selection"
+        else -> null
+    }
+
+    /** The view feedback constant for `style` on API level `sdk`, or null when there is none. */
+    @SuppressLint("InlinedApi")
+    fun feedbackConstant(style: String, sdk: Int): Int? = when (style) {
+        "light" -> HapticFeedbackConstants.KEYBOARD_TAP
+        "medium" -> HapticFeedbackConstants.VIRTUAL_KEY
+        "heavy" -> HapticFeedbackConstants.LONG_PRESS
+        "soft" -> if (sdk >= 27) HapticFeedbackConstants.TEXT_HANDLE_MOVE else HapticFeedbackConstants.CLOCK_TICK
+        "rigid" -> HapticFeedbackConstants.CONTEXT_CLICK
+        "selection" -> if (sdk >= 34) HapticFeedbackConstants.SEGMENT_TICK else HapticFeedbackConstants.CLOCK_TICK
+        "success" -> if (sdk >= 30) HapticFeedbackConstants.CONFIRM else null
+        "error" -> if (sdk >= 30) HapticFeedbackConstants.REJECT else null
+        "warning" -> null
+        else -> HapticFeedbackConstants.VIRTUAL_KEY
+    }
+
+    /** The predefined `VibrationEffect.EFFECT_*` for `style`, Android 10 and later. */
+    @SuppressLint("InlinedApi")
+    fun predefinedEffect(style: String): Int = when (style) {
+        "light", "soft", "selection" -> VibrationEffect.EFFECT_TICK
+        "heavy", "error" -> VibrationEffect.EFFECT_HEAVY_CLICK
+        "success", "warning" -> VibrationEffect.EFFECT_DOUBLE_CLICK
+        else -> VibrationEffect.EFFECT_CLICK
+    }
+
+    /**
+     * Before Android 10: one duration for a one-shot, or a waveform
+     * `[wait, vibrate, wait, vibrate]`. The weights the WebView bridge and the
+     * Zig runtime already play (bridge_android_haptics.zig's effectForStyle).
+     */
+    fun timings(style: String): LongArray = when (style) {
+        "light" -> longArrayOf(10)
+        "soft" -> longArrayOf(8)
+        "selection" -> longArrayOf(5)
+        "rigid" -> longArrayOf(25)
+        "heavy" -> longArrayOf(50)
+        "success" -> longArrayOf(0, 30, 50, 30)
+        "warning" -> longArrayOf(0, 50, 100, 50)
+        "error" -> longArrayOf(0, 100, 50, 100)
+        else -> longArrayOf(20)
+    }
+
+    /**
+     * Play `style`: true when the screen or the vibrator took it. False is
+     * "nothing played" (touch feedback off, no vibrator, no permission), never
+     * an error, because haptics decorate a flow rather than carry it.
+     */
+    fun play(context: Context, view: View?, style: String): Boolean {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            main.post { play(context, view, style) }
+            return true
+        }
+        val constant = feedbackConstant(style, Build.VERSION.SDK_INT)
+        if (constant != null && view != null && view.isAttachedToWindow)
+            return view.performHapticFeedback(constant)
+        val vibrator = vibrator(context) ?: return false
+        if (!vibrator.hasVibrator()) return false
+        return runCatching {
+            vibrator.vibrate(effect(style))
+            true
+        }.getOrDefault(false)
+    }
+
+    private fun effect(style: String): VibrationEffect {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) return VibrationEffect.createPredefined(predefinedEffect(style))
+        val timings = timings(style)
+        return if (timings.size == 1) VibrationEffect.createOneShot(timings[0], VibrationEffect.DEFAULT_AMPLITUDE)
+        else VibrationEffect.createWaveform(timings, -1)
+    }
+
+    private fun vibrator(context: Context): Vibrator? = runCatching {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            (context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager)?.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION")
+            context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+        }
+    }.getOrNull()
+}