craft-native 0.0.237 → 0.0.241

package/dist/android/src/native-map.d.ts

@@ -0,0 +1,7 @@
+/** Build-time native map selection. Both providers are native Android views. */
+export type AndroidMapProvider = 'google' | 'maplibre';
+export declare function androidMapHost(provider?: AndroidMapProvider): {
+    template: string;
+    imports: string;
+    dependency: string;
+};

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

@@ -410,6 +410,9 @@ class CraftBridge(
                     pushNotifications: {{ENABLE_PUSH}},
                     secureStorage: {{ENABLE_SECURE_STORAGE}},
                     geolocation: {{ENABLE_GEOLOCATION}},
+                    crypto: true,
+                    locationRecordingOwnership: {{ENABLE_GEOLOCATION}} && ${CraftNative.supportsRecordingOwnership()},
+                    locationRecordingIntentIdentity: {{ENABLE_GEOLOCATION}} && ${CraftNative.supportsRecordingIntentIdentity()},
                     backgroundLocation: {{ENABLE_BACKGROUND_LOCATION}},
                     clipboard: false,
                     deviceInfo: true,
@@ -1769,16 +1772,41 @@ class CraftBridge(
                         return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.crashReporterContext()); });
                     }
                 };
+                function recordingCall(method, options) {
+                    return Promise.resolve().then(function() {
+                        if (options && Object.prototype.hasOwnProperty.call(options, 'expectedId') &&
+                            (typeof options.expectedId !== 'string' || !options.expectedId.trim())) {
+                            var invalid = new Error('expectedId must be a nonempty recording ID');
+                            invalid.code = 'INVALID_ARGUMENT';
+                            throw invalid;
+                        }
+                        if (options && Object.prototype.hasOwnProperty.call(options, 'recordingId') &&
+                            (typeof options.recordingId !== 'string' || !options.recordingId.trim())) {
+                            var invalidStart = new Error('recordingId must be a nonempty recording ID');
+                            invalidStart.code = 'INVALID_ARGUMENT';
+                            throw invalidStart;
+                        }
+                        var result = JSON.parse(CraftAndroid.recordingAction(method, JSON.stringify(options || {})));
+                        if (!result.ok) {
+                            var error = new Error(result.message || 'Recording failed');
+                            error.code = result.code;
+                            throw error;
+                        }
+                        return result.data;
+                    });
+                }
+                craft.crypto = { randomUUID: function() { return Promise.resolve().then(function() { return CraftAndroid.randomUUID(); }); } };
                 craft.location = {
                     getCurrentPosition: craft.getCurrentPosition,
                     watchPosition: craft.watchPosition,
                     clearWatch: craft.clearWatch,
-                    startRecording: function(options) { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.startLocationRecording(JSON.stringify(options || {}))); }); },
-                    pauseRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.pauseLocationRecording()); }); },
-                    resumeRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.resumeLocationRecording()); }); },
-                    stopRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.stopLocationRecording()); }); },
-                    getRecordingState: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.getLocationRecordingState()); }); },
-                    readRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.readLocationRecording()); }); }
+                    startRecording: function(options) { return recordingCall('startRecording', options); },
+                    pauseRecording: function(options) { return recordingCall('pauseRecording', options); },
+                    resumeRecording: function(options) { return recordingCall('resumeRecording', options); },
+                    stopRecording: function(options) { return recordingCall('stopRecording', options); },
+                    getRecordingState: function(options) { return recordingCall('getRecordingState', options); },
+                    readRecording: function(options) { return recordingCall('readRecording', options); },
+                    acknowledgeRecording: function(options) { return recordingCall('acknowledgeRecording', options); }
                 };
                 var shareApi = function(text, title) { return legacyShare(text, title); };
                 shareApi.share = function(options) {
@@ -1840,6 +1868,9 @@ class CraftBridge(
         navigationGeneration += 1
     }
 
+    @JavascriptInterface
+    fun randomUUID(): String = CraftNative.randomUUID() ?: java.util.UUID.randomUUID().toString()
+
     // ==================== Haptics ====================
 
     /**
@@ -2738,75 +2769,55 @@ class CraftBridge(
     }
 
     @JavascriptInterface
-    fun startLocationRecording(optionsJson: String): String {
-        // Null is "Zig declined". A permission-denied answer is not null — it
-        // is a state object saying so, and returning it here is the answer.
-        CraftNative.startLocationRecording(activity)?.let { return it }
+    fun recordingAction(method: String, optionsJson: String): String {
+        if (!{{ENABLE_GEOLOCATION}}) return JSONObject().put("ok", false).put("code", "CAPABILITY_DISABLED").put("message", "Geolocation is disabled").toString()
+        val result = CraftNative.recordingAction(activity, method, optionsJson)
+            ?: CraftLocationRecordingStore.perform(activity, method, optionsJson)
+        if (method == "startRecording" && JSONObject(result).optBoolean("ok")) {
+            CraftLocationRecordingStore.listen(activity, JSONObject(result).getJSONObject("data").getString("id")) { location, id ->
+                val detail = mapOf<String, Any>("latitude" to location.latitude, "longitude" to location.longitude,
+                    "accuracy" to location.accuracy, "altitude" to location.altitude, "speed" to location.speed,
+                    "heading" to location.bearing, "timestamp" to location.time, "recordingId" to id)
+                sendEvent("craftLocationUpdate", detail)
+            }
+        }
+        return result
+    }
 
-        if (!hasForegroundLocationPermission()) {
-            return JSONObject().apply {
-                put("id", JSONObject.NULL)
-                put("active", false)
-                put("paused", false)
-                put("startedAt", JSONObject.NULL)
-                put("sampleCount", 0)
-            }.toString()
-        }
-        val id = UUID.randomUUID().toString()
-        CraftLocationRecordingStore.start(activity, id, System.currentTimeMillis())
-        ContextCompat.startForegroundService(
-            activity,
-            Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_START)
-        )
-        return CraftLocationRecordingStore.state(activity).toString()
+    private fun legacyRecordingAction(method: String, optionsJson: String = "{}"): String {
+        val answer = JSONObject(recordingAction(method, optionsJson))
+        if (!answer.optBoolean("ok")) throw com.craft.runtime.CraftRecordingException(answer.optString("code"), answer.optString("message"))
+        return answer.get("data").toString()
     }
 
     @JavascriptInterface
-    fun pauseLocationRecording(): String {
-        CraftNative.pauseLocationRecording(activity)?.let { return it }
+    fun startLocationRecording(optionsJson: String): String {
+        return legacyRecordingAction("startRecording", optionsJson)
+    }
 
-        CraftLocationRecordingStore.setPaused(activity, true)
-        return CraftLocationRecordingStore.state(activity).toString()
+    @JavascriptInterface
+    fun pauseLocationRecording(): String {
+        return legacyRecordingAction("pauseRecording")
     }
 
     @JavascriptInterface
     fun resumeLocationRecording(): String {
-        CraftNative.resumeLocationRecording(activity)?.let { return it }
-
-        CraftLocationRecordingStore.setPaused(activity, false)
-        if (CraftLocationRecordingStore.isActive(activity)) {
-            ContextCompat.startForegroundService(
-                activity,
-                Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_START)
-            )
-        }
-        return CraftLocationRecordingStore.state(activity).toString()
+        return legacyRecordingAction("resumeRecording")
     }
 
     @JavascriptInterface
     fun stopLocationRecording(): String {
-        CraftNative.stopLocationRecording(activity)?.let { return it }
-
-        CraftLocationRecordingStore.stop(activity)
-        val result = CraftLocationRecordingStore.state(activity, includeLocations = true).toString()
-        activity.stopService(Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_STOP))
-        return result
+        return legacyRecordingAction("stopRecording")
     }
 
     @JavascriptInterface
     fun getLocationRecordingState(): String {
-        // Null is "Zig declined", not "no recording" — an absent recording is
-        // a state object saying so, and returning it here is the answer.
-        CraftNative.getLocationRecordingState(activity)?.let { return it }
-
-        return CraftLocationRecordingStore.state(activity).toString()
+        return legacyRecordingAction("getRecordingState")
     }
 
     @JavascriptInterface
     fun readLocationRecording(): String {
-        CraftNative.readLocationRecording(activity)?.let { return it }
-
-        return CraftLocationRecordingStore.locations(activity).toString()
+        return legacyRecordingAction("readRecording")
     }
 
     // ==================== Clipboard ====================
@@ -3464,7 +3475,8 @@ class CraftBridge(
             val notificationManager = activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
             val builder = androidx.core.app.NotificationCompat.Builder(activity, notificationChannelId)
-                .setSmallIcon(android.R.drawable.ic_dialog_info)
+                .setSmallIcon(R.drawable.craft_notification_icon)
+                .setColor(ContextCompat.getColor(activity, R.color.craft_notification_color))
                 .setContentTitle(title)
                 .setContentText(body)
                 .setPriority(androidx.core.app.NotificationCompat.PRIORITY_DEFAULT)

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

@@ -230,6 +230,7 @@ object CraftNative {
     }
 
     private external fun nativeGetDeviceInfo(activity: Activity): String?
+    private external fun nativeRandomUUID(): String?
     private external fun nativeGetMemoryUsage(): String?
     private external fun nativeLog(message: String): Boolean
     private external fun nativeFlexRow(
@@ -437,6 +438,8 @@ object CraftNative {
     private external fun nativeSetKeepAwake(activity: Activity, enabled: Boolean): Boolean
     private external fun nativeDownloadFile(activity: Activity, url: String, filename: String): Boolean
     private external fun nativeSaveFile(activity: Activity, data: String, filename: String): Boolean
+    private external fun nativeRecordingAction(activity: Activity, method: String, options: String): String?
+    private external fun nativeRecordingOwnershipVersion(): Int
     private external fun nativeGetLocationRecordingState(activity: Activity): String?
     private external fun nativeReadLocationRecording(activity: Activity): String?
     private external fun nativeStartLocationRecording(activity: Activity): String?
@@ -487,6 +490,11 @@ object CraftNative {
         }
     }
 
+    fun randomUUID(): String? {
+        if (!isAvailable) return null
+        return try { nativeRandomUUID() } catch (_: UnsatisfiedLinkError) { null }
+    }
+
     /** The JVM heap as JSON, or null to use the Kotlin implementation. */
     fun getMemoryUsage(): String? {
         if (!isAvailable) return null
@@ -1921,6 +1929,25 @@ object CraftNative {
      * The read side of the recording store. Null is "Zig declined", not "no
      * recording" — an absent recording is a state object saying so.
      */
+    fun supportsRecordingOwnership(): Boolean {
+        if (!isAvailable) return true
+        return try { nativeRecordingOwnershipVersion() >= 1 } catch (_: UnsatisfiedLinkError) { false }
+    }
+
+    fun supportsRecordingIntentIdentity(): Boolean {
+        if (!isAvailable) return true
+        return try { nativeRecordingOwnershipVersion() >= 2 } catch (_: UnsatisfiedLinkError) { false }
+    }
+
+    fun recordingAction(activity: Activity, method: String, options: String): String? {
+        if (!isAvailable) return null
+        return try { nativeRecordingAction(activity, method, options)
+            ?: org.json.JSONObject().put("ok", false).put("code", "RECORDING_OWNERSHIP_UNSUPPORTED").put("message", "The linked runtime did not serve the recorder request").toString() }
+        catch (error: UnsatisfiedLinkError) {
+            org.json.JSONObject().put("ok", false).put("code", "RECORDING_OWNERSHIP_UNSUPPORTED").put("message", "The linked runtime lacks the shared recorder API").toString()
+        }
+    }
+
     fun getLocationRecordingState(activity: Activity): String? {
         if (!isAvailable) return null
         return try {

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

@@ -116,6 +116,9 @@ internal class CraftNativeCapabilities(
 
     fun names(): JSONArray = JSONArray().apply {
         listOf("device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "files").forEach(::put)
+        put("storageCompareAndSet")
+        put("storageSetIfAbsent")
+        put("crypto")
         if (config.optBoolean("enableBluetooth")) put("bluetooth")
         if (config.optBoolean("enableBiometric")) put("biometric")
         if (config.optBoolean("enableSecureStorage")) put("secureStorage")
@@ -138,11 +141,19 @@ internal class CraftNativeCapabilities(
             return
         }
         when (module) {
+            "Crypto" -> {
+                if (method == "randomUUID") complete(requestToken, success(UUID.randomUUID().toString()), completion)
+                else complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Crypto method"), completion)
+            }
             "Bluetooth" -> {
                 if (!config.optBoolean("enableBluetooth")) complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
                 else bluetooth.perform(method, args) { complete(requestToken, it, completion) }
             }
-            "Storage" -> complete(requestToken, storage(method, args), completion)
+            "Storage" -> mainHandler.post {
+                val answer = runCatching { storage(method, args) }
+                    .getOrElse { failure("STORAGE_ERROR", it.message ?: "Storage operation failed") }
+                complete(requestToken, answer, completion)
+            }
             "SecureStorage" -> {
                 if (!config.optBoolean("enableSecureStorage")) complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
                 else complete(requestToken, secureStorage(method, args), completion)
@@ -648,9 +659,9 @@ internal class CraftNativeCapabilities(
         }
     }
 
-    private fun storage(method: String, args: JSONArray): CraftNativeCapabilityResult {
+    private fun storage(method: String, args: JSONArray): CraftNativeCapabilityResult = synchronized(CraftNativeStorage.lock) {
         if (method == "clear") {
-            storage.edit().clear().commit()
+            if (!CraftNativeStorage.commit(storage) { it.clear() }) return failure("STORAGE_ERROR", "Storage could not be cleared")
             storeObserver?.invoke("storage", null, null)
             return success(true)
         }
@@ -666,13 +677,33 @@ internal class CraftNativeCapabilities(
                 if (args.length() != 2) return failure("INVALID_ARGUMENT", "Storage.set needs a key and value")
                 val value = jsonString(args.opt(1))
                     ?: return failure("INVALID_ARGUMENT", "Storage values must be JSON serializable")
-                if (storage.edit().putString(key, value).commit()) {
+                if (CraftNativeStorage.commit(storage) { it.putString(key, value) }) {
                     storeObserver?.invoke("storage", key, value)
                     success(true)
                 }
                 else failure("STORAGE_ERROR", "Storage could not persist the value")
             }
-            "remove" -> success(storage.edit().remove(key).commit().also { storeObserver?.invoke("storage", key, null) })
+            "compareAndSet" -> {
+                if (args.length() != 3) return failure("INVALID_ARGUMENT", "Storage.compareAndSet needs a key, expected value and next value")
+                val current = storage.getString(key, null) ?: return success(false)
+                if (!CraftNativeStorage.jsonEqual(JSONTokener(current).nextValue(), args.opt(1))) return success(false)
+                val next = jsonString(args.opt(2)) ?: return failure("INVALID_ARGUMENT", "Storage values must be JSON serializable")
+                if (!CraftNativeStorage.commit(storage) { it.putString(key, next) }) return failure("STORAGE_ERROR", "Storage could not persist the checkpoint")
+                storeObserver?.invoke("storage", key, next)
+                success(true)
+            }
+            "setIfAbsent" -> {
+                if (args.length() != 2) return failure("INVALID_ARGUMENT", "Storage.setIfAbsent needs a key and value")
+                if (storage.contains(key)) return success(false)
+                val value = jsonString(args.opt(1)) ?: return failure("INVALID_ARGUMENT", "Storage values must be JSON serializable")
+                if (!CraftNativeStorage.commit(storage) { it.putString(key, value) }) return failure("STORAGE_ERROR", "Storage could not persist the new intent")
+                storeObserver?.invoke("storage", key, value)
+                success(true)
+            }
+            "remove" -> if (CraftNativeStorage.commit(storage) { it.remove(key) }) {
+                storeObserver?.invoke("storage", key, null)
+                success(true)
+            } else failure("STORAGE_ERROR", "Storage could not remove the value")
             else -> failure("UNKNOWN_ACTION", "Unsupported Storage method")
         }
     }