craft-native 0.0.236 → 0.0.238

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 ====================

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

@@ -43,6 +43,7 @@ import kotlin.math.roundToInt
 private const val CRAFT_NATIVE_FETCH_MAX_RESPONSE_BYTES = 8 * 1024 * 1024
 private const val CRAFT_NATIVE_FETCH_TIMEOUT_MS = 30_000
 private const val CRAFT_NATIVE_FILE_PICK_REQUEST = 4101
+private const val CRAFT_NATIVE_NOTIFICATION_PERMISSION_REQUEST = 4102
 private const val CRAFT_NATIVE_FILE_DEFAULT_MAX_PIXELS = 2048
 private const val CRAFT_NATIVE_FILE_LARGEST_MAX_PIXELS = 8192
 private const val CRAFT_NATIVE_FILE_DEFAULT_QUALITY = 0.85
@@ -88,6 +89,7 @@ internal class CraftNativeCapabilities(
     private val fetchConnections = ConcurrentHashMap<String, HttpURLConnection>()
     private val fileRoot by lazy { File(context.cacheDir, "craft-files").apply { mkdirs() } }
     private var pendingFilePick: PendingFilePick? = null
+    private var pendingNotificationPermission: ((Boolean) -> Unit)? = null
     private var database: SQLiteDatabase? = null
     private val biometricPrompts = ConcurrentHashMap<String, BiometricPrompt>()
 
@@ -114,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")
@@ -136,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)
@@ -646,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)
         }
@@ -664,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")
         }
     }
@@ -891,7 +924,16 @@ internal class CraftNativeCapabilities(
             return
         }
         when (method) {
-            "schedule" -> complete(requestToken, schedule(args.optJSONObject(0)), completion)
+            "schedule" -> {
+                val notification = args.optJSONObject(0)
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+                    val host = activity
+                    if (host == null) { complete(requestToken, failure("PERMISSION_DENIED", "Notification permission must be requested while the app is open"), completion); return }
+                    if (pendingNotificationPermission != null) { complete(requestToken, failure("BUSY", "A notification permission request is already open"), completion); return }
+                    pendingNotificationPermission = { granted -> complete(requestToken, if (granted) schedule(notification) else failure("PERMISSION_DENIED", "Notification permission denied"), completion) }
+                    mainHandler.post { androidx.core.app.ActivityCompat.requestPermissions(host, arrayOf(Manifest.permission.POST_NOTIFICATIONS), CRAFT_NATIVE_NOTIFICATION_PERMISSION_REQUEST) }
+                } else complete(requestToken, schedule(notification), completion)
+            }
             "cancel" -> {
                 val id = validKey(args.opt(0))
                 complete(requestToken, if (id == null) failure("INVALID_ARGUMENT", "Notifications.cancel needs an id")
@@ -909,6 +951,13 @@ internal class CraftNativeCapabilities(
         }
     }
 
+    fun onNotificationPermissions(requestCode: Int) {
+        if (requestCode != CRAFT_NATIVE_NOTIFICATION_PERMISSION_REQUEST) return
+        val complete = pendingNotificationPermission ?: return
+        pendingNotificationPermission = null
+        complete(Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU || ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED)
+    }
+
     private fun schedule(value: JSONObject?): CraftNativeCapabilityResult {
         val title = value?.optString("title").orEmpty()
         if (title.isEmpty()) return failure("INVALID_ARGUMENT", "Notifications.schedule needs a title")

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

@@ -1,5 +1,7 @@
 package {{PACKAGE_NAME}}
 
+import com.craft.runtime.CraftNative
+
 import android.Manifest
 import android.app.Activity
 import android.content.ActivityNotFoundException
@@ -29,6 +31,15 @@ import java.util.Locale
 import java.util.UUID
 {{NATIVE_PUSH_IMPORTS}}
 
+private fun craftLocationFix(location: android.location.Location): JSONObject = JSONObject()
+    .put("latitude", location.latitude)
+    .put("longitude", location.longitude)
+    .put("altitude", location.altitude)
+    .put("accuracy", location.accuracy.toDouble())
+    .put("speed", location.speed.toDouble())
+    .put("heading", location.bearing.toDouble())
+    .put("timestamp", location.time.toDouble())
+
 /**
  * The capabilities a native screen asks for beyond Craft's core set
  * (CraftNativeCapabilities): the system's dialogs, the in-app browser, the
@@ -59,6 +70,16 @@ internal class CraftNativeServices(
     private val speechQueue = mutableListOf<() -> Unit>()
     private val speeches = mutableMapOf<String, (CraftNativeCapabilityResult) -> Unit>()
 
+    init {
+        if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
+            // Native screens must also hear a recording started by the page.
+            // Keep this process sink independent from the page's listener.
+            com.craft.runtime.CraftLocationRecordingStore.nativeListener = { location, id ->
+                CraftNativeHub.broadcast("CRAFT_EVENT", JSONObject().put("event", "craftLocationUpdate").put("detail", craftLocationFix(location).put("recordingId", id)))
+            }
+        }
+    }
+
     /** `background.complete(ok, id)`: who is waiting for a background refresh's answer. */
     var onBackgroundComplete: ((Boolean, String?) -> Unit)? = null
 
@@ -84,7 +105,11 @@ internal class CraftNativeServices(
             add("healthAvailability")
         }
         if (config.optBoolean("enableKeepAwake")) add("keepAwake")
-        if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) add("geolocation")
+        if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
+            add("geolocation")
+            if (CraftNative.supportsRecordingOwnership()) add("locationRecordingOwnership")
+            if (CraftNative.supportsRecordingIntentIdentity()) add("locationRecordingIntentIdentity")
+        }
         if (config.optJSONObject("backgroundRefresh")?.optBoolean("enabled") == true || config.optBoolean("enablePushNotifications")) add("background")
         // craft.crashReporter: the app's crash and error reporter (bughq).
         if (CraftCrashReporter.enabled) add("crashReporter")
@@ -130,6 +155,8 @@ internal class CraftNativeServices(
                 "CrashReporter" -> crashReporter(method, args, done)
                 else -> done(failure("UNKNOWN_ACTION", "Unsupported native API"))
             }
+        } catch (error: com.craft.runtime.CraftRecordingException) {
+            done(failure(error.code, error.message ?: "Recording failed"))
         } catch (error: Exception) {
             Log.e("CraftNativeAndroid", "$module.$method failed", error)
             done(failure("CRAFT_ERROR", error.message ?: "$module.$method failed"))
@@ -359,14 +386,6 @@ internal class CraftNativeServices(
     private var watchCallback: com.google.android.gms.location.LocationCallback? = null
     private var pendingLocationPermission: ((Boolean) -> Unit)? = null
 
-    private fun fix(location: android.location.Location): JSONObject = JSONObject()
-        .put("latitude", location.latitude)
-        .put("longitude", location.longitude)
-        .put("altitude", location.altitude)
-        .put("accuracy", location.accuracy.toDouble())
-        .put("speed", location.speed.toDouble())
-        .put("heading", location.bearing.toDouble())
-        .put("timestamp", location.time.toDouble())
 
     private fun hasLocation(): Boolean =
         ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
@@ -374,10 +393,15 @@ internal class CraftNativeServices(
 
     /** Location, asked for once a person starts something that needs it. */
     private fun withLocation(done: (CraftNativeCapabilityResult) -> Unit, then: () -> Unit) {
-        if (hasLocation()) return then()
+        val authorized = {
+            try { then() }
+            catch (error: com.craft.runtime.CraftRecordingException) { done(failure(error.code, error.message ?: "Recording failed")) }
+            catch (error: Exception) { done(failure("CRAFT_ERROR", error.message ?: "Location failed")) }
+        }
+        if (hasLocation()) return authorized()
         val host = activity() ?: return done(failure("PERMISSION_DENIED", "Location is not allowed"))
         pendingLocationPermission?.invoke(false)
-        pendingLocationPermission = { granted -> if (granted) then() else done(failure("PERMISSION_DENIED", "Location is not allowed")) }
+        pendingLocationPermission = { granted -> if (granted) authorized() else done(failure("PERMISSION_DENIED", "Location is not allowed")) }
         ActivityCompat.requestPermissions(host, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION), LOCATION_PERMISSION_REQUEST)
     }
 
@@ -396,7 +420,7 @@ internal class CraftNativeServices(
                 val priority = if (options.optBoolean("enableHighAccuracy", true)) com.google.android.gms.location.Priority.PRIORITY_HIGH_ACCURACY
                 else com.google.android.gms.location.Priority.PRIORITY_BALANCED_POWER_ACCURACY
                 locationClient.getCurrentLocation(priority, null)
-                    .addOnSuccessListener { location -> done(if (location != null) success(fix(location)) else failure("POSITION_UNAVAILABLE", "No location fix")) }
+                    .addOnSuccessListener { location -> done(if (location != null) success(craftLocationFix(location)) else failure("POSITION_UNAVAILABLE", "No location fix")) }
                     .addOnFailureListener { error -> done(failure("POSITION_UNAVAILABLE", error.message ?: "No location fix")) }
             }
             "watchPosition" -> withLocation(done) {
@@ -404,7 +428,7 @@ internal class CraftNativeServices(
                 val callback = object : com.google.android.gms.location.LocationCallback() {
                     override fun onLocationResult(result: com.google.android.gms.location.LocationResult) {
                         for (location in result.locations) {
-                            CraftNativeHub.broadcast("CRAFT_EVENT", JSONObject().put("event", "craftLocationUpdate").put("detail", fix(location)))
+                            CraftNativeHub.broadcast("CRAFT_EVENT", JSONObject().put("event", "craftLocationUpdate").put("detail", craftLocationFix(location)))
                         }
                     }
                 }
@@ -418,29 +442,15 @@ internal class CraftNativeServices(
                 watchCallback = null
                 done(success(true))
             }
-            "startRecording" -> withLocation(done) {
-                val options = args.optJSONObject(0) ?: JSONObject()
-                val id = options.optString("id").ifBlank { UUID.randomUUID().toString() }
-                store.start(context, id, System.currentTimeMillis())
-                store.listener = { location -> CraftNativeHub.broadcast("CRAFT_EVENT", JSONObject().put("event", "craftLocationUpdate").put("detail", fix(location))) }
-                val intent = Intent(context, com.craft.runtime.LocationRecordingService::class.java).setAction(com.craft.runtime.LocationRecordingService.ACTION_START)
-                runCatching { ContextCompat.startForegroundService(context, intent) }
-                    .onFailure { store.stop(context) }
-                done(success(store.state(context)))
-            }
-            "pauseRecording", "resumeRecording" -> {
-                store.setPaused(context, method == "pauseRecording")
-                done(success(store.state(context)))
-            }
-            "stopRecording" -> {
-                val state = store.state(context, includeLocations = true)
-                store.stop(context)
-                store.listener = null
-                runCatching { context.startService(Intent(context, com.craft.runtime.LocationRecordingService::class.java).setAction(com.craft.runtime.LocationRecordingService.ACTION_STOP)) }
-                done(success(state.put("active", false).put("paused", false)))
+            "startRecording", "pauseRecording", "resumeRecording", "stopRecording", "getRecordingState", "readRecording", "acknowledgeRecording" -> {
+                val invoke = {
+                    val answer = JSONObject(store.perform(context, method, (args.optJSONObject(0) ?: JSONObject()).toString()))
+                    if (answer.optBoolean("ok")) {
+                        done(success(answer.opt("data")))
+                    } else done(failure(answer.optString("code"), answer.optString("message")))
+                }
+                if (method == "startRecording") withLocation(done, invoke) else invoke()
             }
-            "getRecordingState" -> done(success(store.state(context)))
-            "readRecording" -> done(success(store.locations(context)))
             else -> done(failure("UNKNOWN_ACTION", "Unsupported Location method"))
         }
     }