@craft-native/android 0.0.118 → 0.0.120

package/templates/MainActivityNative.kt.template

@@ -3,13 +3,17 @@ package {{PACKAGE_NAME}}
 import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
+import android.content.Intent
 import android.graphics.BitmapFactory
 import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Typeface
 import android.graphics.drawable.GradientDrawable
+import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.os.VibrationEffect
 import android.os.Vibrator
 import android.text.Editable
@@ -39,6 +43,7 @@ import androidx.javascriptengine.JavaScriptSandbox
 import androidx.javascriptengine.Message
 import androidx.javascriptengine.MessagePort
 import androidx.javascriptengine.MessagePortClient
+import com.google.common.util.concurrent.ListenableFuture
 import org.json.JSONArray
 import org.json.JSONObject
 import java.net.URL
@@ -46,6 +51,8 @@ import java.util.concurrent.Executors
 import java.util.concurrent.Future
 import java.util.UUID
 
+private const val CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS = 30_000L
+
 private class CraftNativeScrollView(context: Context) : FrameLayout(context) {
     val content = LinearLayout(context)
     private val vertical = ScrollView(context)
@@ -87,6 +94,9 @@ class MainActivity : AppCompatActivity() {
         val flatListOwners = mutableMapOf<String, String>()
         val flatListOwnerByView = mutableMapOf<CraftNativeFlatList, String>()
         val mutations = CraftNativeMutationDocument()
+        val capabilityScope = UUID.randomUUID().toString()
+        val pendingCapabilities = mutableSetOf<String>()
+        val capabilityTimeouts = mutableMapOf<String, Runnable>()
         var active = true
 
         fun close() {
@@ -100,7 +110,16 @@ class MainActivity : AppCompatActivity() {
     private var sandbox: JavaScriptSandbox? = null
     private val screens = mutableListOf<Screen>()
     private var bundle = ""
+    private lateinit var config: JSONObject
+    private lateinit var capabilities: CraftNativeCapabilities
+    private val capabilityHandler = Handler(Looper.getMainLooper())
     private var hapticsEnabled = false
+    private var clipboardEnabled = false
+    internal var nativeAppState = "inactive"
+        private set
+    private var deliveredInitialDeepLink = false
+    private var initialDeepLink: Uri? = null
+    private var initialDeepLinkClaimed = false
     private var defaultTextColor = Color.WHITE
     private var useMessagePorts = false
     private val imageExecutor = Executors.newFixedThreadPool(2)
@@ -110,14 +129,19 @@ class MainActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        initialDeepLink = savedInstanceState?.getString("craft.initialDeepLink")?.let(Uri::parse) ?: intent?.data
+        initialDeepLinkClaimed = savedInstanceState?.getBoolean("craft.initialDeepLinkClaimed", false) ?: false
+        deliveredInitialDeepLink = savedInstanceState?.getBoolean("craft.deliveredInitialDeepLink", false) ?: false
         setContentView(R.layout.activity_main)
         root = findViewById(R.id.native_root)
-        val config = runCatching {
+        config = runCatching {
             assets.open("craft.config.json").bufferedReader().use {
                 JSONObject(it.readText())
             }
         }.getOrDefault(JSONObject())
         hapticsEnabled = config.optBoolean("enableHaptics", false)
+        clipboardEnabled = config.optBoolean("enableClipboard", false)
+        capabilities = CraftNativeCapabilities(this, config)
         val background = color(config.optString("backgroundColor", "#1a1a2e"), Color.BLACK)
         root.setBackgroundColor(background)
         defaultTextColor = if (Color.luminance(background) < 0.5) Color.WHITE else Color.BLACK
@@ -131,29 +155,45 @@ class MainActivity : AppCompatActivity() {
             showError("Native STX requires Android JavaScriptSandbox, which is unavailable on this device.")
             return
         }
-        val connection = JavaScriptSandbox.createConnectedInstanceAsync(this)
-        connection.addListener({
-            try {
-                val engine = connection.get()
-                if (isDestroyed) {
-                    engine.close()
-                    return@addListener
-                }
-                useMessagePorts = engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_MESSAGE_PORTS)
-                    && engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_PROMISE_RETURN)
-                if (!useMessagePorts && !engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_CONSOLE_MESSAGING)) {
-                    engine.close()
-                    showError("Native STX requires JavaScript message ports or console messaging, unavailable on this device.")
-                    return@addListener
-                }
-                Log.i(TAG, "Native STX bridge: ${if (useMessagePorts) "message ports" else "console callback"}")
-                sandbox = engine
-                openScreen(null)
-            } catch (error: Exception) {
-                Log.e(TAG, "JavaScriptSandbox connection failed", error)
-                showError("Native STX JavaScript engine could not start: ${error.message}")
+        val connection = synchronized(SANDBOX_LOCK) {
+            sharedSandboxConnection ?: sharedSandbox?.let { existing ->
+                sandbox = existing
+                null
+            } ?: JavaScriptSandbox.createConnectedInstanceAsync(applicationContext).also {
+                sharedSandboxConnection = it
             }
-        }, ContextCompat.getMainExecutor(this))
+        }
+        if (connection == null) {
+            sandbox?.let(::attachSandbox)
+        } else {
+            connection.addListener({
+                try {
+                    val engine = connection.get()
+                    synchronized(SANDBOX_LOCK) {
+                        sharedSandbox = engine
+                    }
+                    if (!isDestroyed) {
+                        sandbox = engine
+                        attachSandbox(engine)
+                    }
+                } catch (error: Exception) {
+                    synchronized(SANDBOX_LOCK) { sharedSandboxConnection = null }
+                    Log.e(TAG, "JavaScriptSandbox connection failed", error)
+                    if (!isDestroyed) showError("Native STX JavaScript engine could not start: ${error.message}")
+                }
+            }, ContextCompat.getMainExecutor(this))
+        }
+    }
+
+    private fun attachSandbox(engine: JavaScriptSandbox) {
+        useMessagePorts = engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_MESSAGE_PORTS)
+            && engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_PROMISE_RETURN)
+        if (!useMessagePorts && !engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_CONSOLE_MESSAGING)) {
+            showError("Native STX requires JavaScript message ports or console messaging, unavailable on this device.")
+            return
+        }
+        Log.i(TAG, "Native STX bridge: ${if (useMessagePorts) "message ports" else "console callback"}")
+        openScreen(null)
     }
 
     private fun openScreen(route: String?, params: JSONObject = JSONObject()) {
@@ -170,13 +210,13 @@ class MainActivity : AppCompatActivity() {
         val port = if (useMessagePorts) {
             isolate.createMessageChannel("craft", executor, MessagePortClient { message ->
                 val current = screen ?: return@MessagePortClient
-                if (current.active && message.type == Message.TYPE_STRING) receive(current, message.string)
+                if (current.active && message.type == Message.TYPE_STRING) receiveSafely(current, message.string)
             })
         } else {
             isolate.setConsoleCallback(executor, JavaScriptConsoleCallback { entry ->
                 val current = screen ?: return@JavaScriptConsoleCallback
                 if (current.active && entry.message.startsWith(prefix)) {
-                    receive(current, entry.message.removePrefix(prefix))
+                    receiveSafely(current, entry.message.removePrefix(prefix))
                 }
             })
             null
@@ -194,7 +234,12 @@ class MainActivity : AppCompatActivity() {
               const port = await android.getNamedPort('craft');
               $routePrelude
               globalThis.__stxNativeBridge = {
+                platform: 'android',
                 mutationProtocolVersion: 1,
+                capabilityProtocolVersion: $CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION,
+                capabilityTimeoutMs: $CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS,
+                capabilities: ${capabilities.names()},
+                initialAppState: ${JSONObject.quote(nativeAppState)},
                 postMessage: function(value) { port.postMessage(value); },
                 onMessage: function(callback) { port.onmessage = function(event) { callback(event.data); }; }
               };
@@ -202,7 +247,12 @@ class MainActivity : AppCompatActivity() {
         """.trimIndent() else """
             $routePrelude
             globalThis.__stxNativeBridge = {
+              platform: 'android',
               mutationProtocolVersion: 1,
+              capabilityProtocolVersion: $CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION,
+              capabilityTimeoutMs: $CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS,
+              capabilities: ${capabilities.names()},
+              initialAppState: ${JSONObject.quote(nativeAppState)},
               postMessage: function(value) { console.log(${JSONObject.quote(prefix)} + value); },
               onMessage: function(callback) { globalThis.__stxNativeCallback = callback; }
             };
@@ -214,7 +264,18 @@ class MainActivity : AppCompatActivity() {
                 setup.get()
                 val load = isolate.evaluateJavaScriptAsync(bundle)
                 load.addListener({
-                    try { load.get() } catch (error: Exception) {
+                    try {
+                        load.get()
+                        val launchLink = initialDeepLink
+                        if (!deliveredInitialDeepLink
+                            && config.optBoolean("enableDeepLinks")
+                            && launchLink != null
+                            && screens.lastOrNull() === activeScreen
+                        ) {
+                            deliveredInitialDeepLink = true
+                            send(activeScreen, "DEEP_LINK", deepLinkData(launchLink).put("initial", true))
+                        }
+                    } catch (error: Exception) {
                         Log.e(TAG, "Native STX bundle failed", error)
                         if (activeScreen.active) showError("Native STX bundle failed: ${error.message}")
                     }
@@ -232,9 +293,17 @@ class MainActivity : AppCompatActivity() {
         root.addView(screen.view)
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        outState.putString("craft.initialDeepLink", initialDeepLink?.toString())
+        outState.putBoolean("craft.initialDeepLinkClaimed", initialDeepLinkClaimed)
+        outState.putBoolean("craft.deliveredInitialDeepLink", deliveredInitialDeepLink)
+        super.onSaveInstanceState(outState)
+    }
+
     private fun receive(screen: Screen, raw: String) {
         val message = runCatching { JSONObject(raw) }.getOrNull() ?: return
         val payload = message.optJSONObject("payload") ?: JSONObject()
+        Log.d(TAG, "Native STX ${message.optString("type")} (${raw.length} chars) for ${screen.route ?: "home"}")
         when (message.optString("type")) {
             "RENDER" -> payload.optJSONObject("document")?.let { render(screen, it) }
             "MUTATE" -> try {
@@ -270,6 +339,26 @@ class MainActivity : AppCompatActivity() {
             }
             "NAVIGATE_BACK" -> if (screens.lastOrNull() === screen) back()
             "API_REQUEST" -> answerAPI(screen, message, payload)
+            "API_CANCEL" -> {
+                val id = payload.optString("requestId")
+                if (id.isNotBlank()) {
+                    val token = "${screen.capabilityScope}/$id"
+                    screen.pendingCapabilities.remove(token)
+                    screen.capabilityTimeouts.remove(token)?.let(capabilityHandler::removeCallbacks)
+                    capabilities.cancel(token)
+                }
+            }
+        }
+    }
+
+    private fun receiveSafely(screen: Screen, raw: String) {
+        try {
+            receive(screen, raw)
+        }
+        catch (error: Exception) {
+            val route = screen.route ?: "home"
+            Log.e(TAG, "Native STX message failed for $route", error)
+            if (screen.active) showError("Native STX message failed for $route: ${error.message}")
         }
     }
 
@@ -728,34 +817,118 @@ class MainActivity : AppCompatActivity() {
         val id = message.optString("id")
         if (id.isBlank()) return
         val args = payload.optJSONArray("args") ?: JSONArray()
-        val response = JSONObject().put("requestId", id)
-        val result = when (payload.optString("module") to payload.optString("method")) {
-            "Device" to "getInfo" -> response.put("data", JSONObject()
+        val token = "${screen.capabilityScope}/$id"
+        screen.pendingCapabilities.add(token)
+        val timeout = Runnable {
+            if (!screen.active || !screen.pendingCapabilities.remove(token)) return@Runnable
+            screen.capabilityTimeouts.remove(token)
+            capabilities.cancel(token)
+            send(screen, "API_ERROR", JSONObject()
+                .put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION)
+                .put("requestId", id)
+                .put("code", "TIMEOUT")
+                .put("message", "Native API request timed out"), id)
+        }
+        screen.capabilityTimeouts[token] = timeout
+        capabilityHandler.postDelayed(timeout, CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS)
+        capabilities.perform(
+            token,
+            payload.optInt("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION),
+            payload.optString("module"),
+            payload.optString("method"),
+            args,
+        ) { result ->
+            if (!screen.active || !screen.pendingCapabilities.remove(token)) return@perform
+            screen.capabilityTimeouts.remove(token)?.let(capabilityHandler::removeCallbacks)
+            val response = JSONObject()
+                .put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION)
+                .put("requestId", id)
+            if (result.code == null) response.put("data", result.data ?: JSONObject.NULL)
+            else response.put("code", result.code).put("message", result.message ?: "Native API failed")
+            send(screen, if (result.code == null) "API_RESPONSE" else "API_ERROR", response, id)
+        }
+    }
+
+    internal fun performImmediateCapability(module: String, method: String, args: JSONArray): CraftNativeCapabilityResult =
+        when (module to method) {
+            "Device" to "getInfo" -> CraftNativeCapabilityResult(data = JSONObject()
                 .put("platform", "android")
                 .put("osVersion", Build.VERSION.RELEASE)
                 .put("model", Build.MODEL)
-                .put("manufacturer", Build.MANUFACTURER))
-            "Clipboard" to "write" -> {
+                .put("manufacturer", Build.MANUFACTURER)
+                .put("deviceId", android.provider.Settings.Secure.getString(contentResolver, android.provider.Settings.Secure.ANDROID_ID))
+                .put("isTablet", resources.configuration.smallestScreenWidthDp >= 600)
+                .put("screen", JSONObject()
+                    .put("width", resources.displayMetrics.widthPixels / resources.displayMetrics.density)
+                    .put("height", resources.displayMetrics.heightPixels / resources.displayMetrics.density)
+                    .put("scale", resources.displayMetrics.density)))
+            "Clipboard" to "write" -> if (!clipboardEnabled) {
+                CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Clipboard is disabled")
+            } else if (args.opt(0) !is String) {
+                CraftNativeCapabilityResult(code = "INVALID_ARGUMENT", message = "Clipboard.write needs text")
+            } else {
                 val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-                clipboard.setPrimaryClip(ClipData.newPlainText("", args.optString(0)))
-                response.put("data", JSONObject().put("ok", true))
+                clipboard.setPrimaryClip(ClipData.newPlainText("", args.getString(0)))
+                CraftNativeCapabilityResult(data = true)
             }
-            "Clipboard" to "read" -> {
+            "Clipboard" to "read" -> if (!clipboardEnabled) {
+                CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Clipboard is disabled")
+            } else {
                 val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-                response.put("data", clipboard.primaryClip?.getItemAt(0)?.coerceToText(this)?.toString() ?: "")
+                CraftNativeCapabilityResult(data = clipboard.primaryClip?.getItemAt(0)?.coerceToText(this)?.toString() ?: "")
             }
-            "Haptics" to "impact" -> {
-                if (!hapticsEnabled) response.put("code", "CAPABILITY_DISABLED")
-                    .put("message", "Haptics are disabled")
-                else {
-                    val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
-                    vibrator.vibrate(VibrationEffect.createOneShot(30, VibrationEffect.DEFAULT_AMPLITUDE))
-                    response.put("data", JSONObject().put("ok", true))
-                }
+            "Haptics" to "impact" -> if (!hapticsEnabled) {
+                CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Haptics are disabled")
+            } else {
+                val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+                vibrator.vibrate(VibrationEffect.createOneShot(30, VibrationEffect.DEFAULT_AMPLITUDE))
+                CraftNativeCapabilityResult(data = true)
             }
-            else -> response.put("code", "UNKNOWN_ACTION").put("message", "Unsupported native API")
+            else -> CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported native API")
         }
-        send(screen, if (result.has("code")) "API_ERROR" else "API_RESPONSE", result, id)
+
+    internal fun deepLinkData(uri: android.net.Uri): JSONObject = JSONObject()
+        .put("url", uri.toString())
+        .put("scheme", uri.scheme ?: "")
+        .put("host", uri.host ?: "")
+        .put("path", uri.path ?: "")
+        .put("query", uri.query ?: "")
+        .put("queryParams", JSONObject().apply {
+            uri.queryParameterNames.forEach { name -> put(name, uri.getQueryParameter(name) ?: "") }
+        })
+
+    private fun publish(type: String, payload: JSONObject) {
+        screens.lastOrNull()?.takeIf { it.active }?.let { send(it, type, payload) }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        nativeAppState = "active"
+        publish("APP_STATE", JSONObject().put("state", nativeAppState))
+    }
+
+    override fun onPause() {
+        nativeAppState = "inactive"
+        publish("APP_STATE", JSONObject().put("state", nativeAppState))
+        super.onPause()
+    }
+
+    override fun onStop() {
+        nativeAppState = "background"
+        publish("APP_STATE", JSONObject().put("state", nativeAppState))
+        super.onStop()
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        intent.data?.let { publish("DEEP_LINK", deepLinkData(it).put("initial", false)) }
+    }
+
+    internal fun consumeInitialDeepLink(): Uri? {
+        if (initialDeepLinkClaimed) return null
+        initialDeepLinkClaimed = true
+        return initialDeepLink
     }
 
     private fun send(screen: Screen, type: String, payload: JSONObject, correlationId: String? = null) {
@@ -804,6 +977,10 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun closeScreen(screen: Screen) {
+        screen.capabilityTimeouts.values.forEach(capabilityHandler::removeCallbacks)
+        screen.capabilityTimeouts.clear()
+        screen.pendingCapabilities.forEach(capabilities::cancel)
+        screen.pendingCapabilities.clear()
         releaseViewState(screen, retainedViews(screen).toList())
         screen.controls.clear()
         screen.handlers.clear()
@@ -833,9 +1010,14 @@ class MainActivity : AppCompatActivity() {
         imageJobs.values.forEach { it.cancel(true) }
         imageJobs.clear()
         imageExecutor.shutdownNow()
-        sandbox?.close()
+        capabilities.close()
         super.onDestroy()
     }
 
-    companion object { private const val TAG = "CraftNativeAndroid" }
+    companion object {
+        private const val TAG = "CraftNativeAndroid"
+        private val SANDBOX_LOCK = Any()
+        private var sharedSandbox: JavaScriptSandbox? = null
+        private var sharedSandboxConnection: ListenableFuture<JavaScriptSandbox>? = null
+    }
 }