@craft-native/android 0.0.168 → 0.0.170

package/templates/CraftNativeBackground.kt.template

@@ -0,0 +1,296 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.core.content.ContextCompat
+import androidx.javascriptengine.JavaScriptConsoleCallback
+import androidx.javascriptengine.JavaScriptIsolate
+import androidx.javascriptengine.JavaScriptSandbox
+import androidx.work.Constraints
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import com.google.common.util.concurrent.ListenableFuture
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+/**
+ * One JavaScriptSandbox for the process: the screens' isolates and a
+ * background refresh's all live in it, since an app may hold only one.
+ */
+internal object CraftNativeSandbox {
+    private val lock = Any()
+    private var sandbox: JavaScriptSandbox? = null
+    private var connecting: ListenableFuture<JavaScriptSandbox>? = null
+
+    fun connect(context: Context, done: (JavaScriptSandbox?, Throwable?) -> Unit) {
+        val existing = synchronized(lock) { sandbox }
+        if (existing != null) return done(existing, null)
+        val future = synchronized(lock) {
+            connecting ?: JavaScriptSandbox.createConnectedInstanceAsync(context.applicationContext).also { connecting = it }
+        }
+        future.addListener({
+            try {
+                val engine = future.get()
+                synchronized(lock) { sandbox = engine }
+                done(engine, null)
+            } catch (error: Exception) {
+                synchronized(lock) { connecting = null }
+                done(null, error)
+            }
+        }, ContextCompat.getMainExecutor(context))
+    }
+}
+
+/**
+ * Background refresh, as iOS's BGAppRefreshTask gives it: WorkManager wakes
+ * the app every `backgroundRefresh.minimumIntervalMinutes` (15 at the
+ * least, with a network) and the app script (`nativeApp`) hears
+ * `craftBackgroundRefresh` with an `id`, does its work and answers
+ * `craft.background.complete(ok, id)`. With the app open, the running app
+ * script hears it; otherwise a script is started for the refresh alone
+ * ([CraftNativeHeadlessApp]) and closed when it answers. A silent push
+ * (`craftSilentPush`) runs the same way, once.
+ */
+internal object CraftNativeBackground {
+    private const val PERIODIC = "craft-native-background-refresh"
+    private const val ONCE = "craft-native-background-once"
+
+    /** The running app's script, when the activity has one: delivers an event and hears its answer. */
+    @Volatile var foreground: ((event: String, id: String, done: (Boolean) -> Unit) -> Boolean)? = null
+
+    fun schedule(context: Context, config: JSONObject) {
+        val refresh = config.optJSONObject("backgroundRefresh")
+        val work = WorkManager.getInstance(context)
+        if (refresh?.optBoolean("enabled") != true || config.optString("nativeApp").isBlank()) {
+            work.cancelUniqueWork(PERIODIC)
+            return
+        }
+        val minutes = refresh.optLong("minimumIntervalMinutes", 120).coerceAtLeast(15)
+        val request = PeriodicWorkRequestBuilder<CraftNativeRefreshWorker>(minutes, TimeUnit.MINUTES)
+            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            .setInputData(workDataOf("event" to "craftBackgroundRefresh"))
+            .build()
+        work.enqueueUniquePeriodicWork(PERIODIC, ExistingPeriodicWorkPolicy.UPDATE, request)
+    }
+
+    /** One run now (a silent push). */
+    fun runOnce(context: Context, event: String) {
+        val request = OneTimeWorkRequestBuilder<CraftNativeRefreshWorker>()
+            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            .setInputData(workDataOf("event" to event))
+            .build()
+        WorkManager.getInstance(context).enqueueUniqueWork(ONCE, ExistingWorkPolicy.APPEND_OR_REPLACE, request)
+    }
+}
+
+internal class CraftNativeRefreshWorker(context: Context, parameters: WorkerParameters) : CoroutineWorker(context, parameters) {
+    override suspend fun doWork(): Result {
+        val event = inputData.getString("event") ?: "craftBackgroundRefresh"
+        val id = UUID.randomUUID().toString()
+        val answer = CompletableDeferred<Boolean>()
+        val running = withContext(Dispatchers.Main) {
+            CraftNativeBackground.foreground?.invoke(event, id) { ok -> answer.complete(ok) } == true
+        }
+        Log.i("CraftNativeAndroid", "$event $id: ${if (running) "the running app script" else "a background app script"}")
+        var headless: CraftNativeHeadlessApp? = null
+        if (!running) {
+            headless = withContext(Dispatchers.Main) { CraftNativeHeadlessApp(applicationContext, event, id) { ok -> answer.complete(ok) } }
+            withContext(Dispatchers.Main) { headless.start() }
+        }
+        // WorkManager stops a worker at ten minutes; answer before that.
+        val ok = withTimeoutOrNull(9 * 60 * 1000L) { answer.await() }
+        Log.i("CraftNativeAndroid", "$event $id answered ${ok ?: "nothing in time"}")
+        headless?.let { withContext(Dispatchers.Main) { it.close() } }
+        return if (ok == false) Result.retry() else Result.success()
+    }
+}
+
+/**
+ * The app script with no activity: a background refresh's. It gets the
+ * same bridge as a screen's (CraftNativePrelude), Craft's core capabilities
+ * and this host's services, minus everything a person would have to see.
+ */
+internal class CraftNativeHeadlessApp(
+    private val context: Context,
+    private val event: String,
+    private val id: String,
+    private val onDone: (Boolean) -> Unit,
+) {
+    private val config: JSONObject = runCatching {
+        context.assets.open("craft.config.json").bufferedReader().use { JSONObject(it.readText()) }
+    }.getOrDefault(JSONObject())
+    private val stores = CraftNativeStores.get(context, config)
+    private val capabilities = CraftNativeCapabilities(context, config)
+    private val services = CraftNativeServices(context, config) { null }
+    private val scope = UUID.randomUUID().toString()
+    private val prefix = "CRAFT_STX_$scope:"
+    private val main = Handler(Looper.getMainLooper())
+    private var isolate: JavaScriptIsolate? = null
+    private var closed = false
+    private val timers = mutableMapOf<Int, Runnable>()
+    private val chunks = CraftNativeChunks()
+
+    init {
+        capabilities.storeObserver = { store, key, value -> stores.changed(store, key, value, scope) }
+        services.onBackgroundComplete = { ok, answered -> if (answered == null || answered == id) finish(ok) }
+    }
+
+    fun start() {
+        val route = config.optString("nativeApp")
+        if (route.isBlank() || !JavaScriptSandbox.isSupported()) return finish(true)
+        val bundle = runCatching { context.assets.open("native-screen.js").bufferedReader().use { it.readText() } }.getOrNull()
+            ?: return finish(true)
+        CraftNativeSandbox.connect(context) { engine, error ->
+            if (closed) return@connect
+            if (engine == null || !engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_CONSOLE_MESSAGING)) {
+                Log.w(TAG, "Background refresh has no JavaScript engine", error)
+                return@connect finish(true)
+            }
+            val created = engine.createIsolate()
+            isolate = created
+            created.setConsoleCallback(ContextCompat.getMainExecutor(context), JavaScriptConsoleCallback { entry ->
+                if (closed) return@JavaScriptConsoleCallback
+                if (entry.message.startsWith(prefix)) chunks.accept(entry.message.removePrefix(prefix))?.let(::receive)
+                else Log.i(TAG, "[background] ${entry.message}")
+            })
+            CraftNativeHub.register(scope) { type, payload -> send(type, payload) }
+            val names = capabilities.names().apply { services.names().forEach { put(it) } }
+            val bridgeFields = """
+                platform: 'android',
+                mutationProtocolVersion: 1,
+                capabilityProtocolVersion: $CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION,
+                capabilityTimeoutMs: 30000,
+                capabilities: $names,
+                initialAppState: 'background',
+                colorScheme: 'light',
+                appURL: ${JSONObject.quote(config.optString("devServerURL"))},
+                appVersion: '',
+                appBuild: ''
+            """.trimIndent()
+            val prelude = CraftNativePrelude.script(
+                bridgeFields,
+                CraftNativeChunks.consolePost(prefix),
+                "globalThis.__stxNativeCallback = deliver;",
+                stores.preloadText(),
+                "globalThis.__stxNativeRoute = ${JSONObject.quote(route)};\nglobalThis.__stxNativeParams = {};",
+            )
+            val setup = created.evaluateJavaScriptAsync(prelude)
+            setup.addListener({
+                if (closed) return@addListener
+                try {
+                    setup.get()
+                    val load = created.evaluateJavaScriptAsync(bundle)
+                    load.addListener({
+                        try {
+                            load.get()
+                            send("CRAFT_EVENT", JSONObject().put("event", event).put("detail", JSONObject().put("id", id)))
+                        } catch (failure: Exception) {
+                            Log.e(TAG, "Background refresh script failed", failure)
+                            finish(false)
+                        }
+                    }, ContextCompat.getMainExecutor(context))
+                } catch (failure: Exception) {
+                    Log.e(TAG, "Background refresh bridge failed", failure)
+                    finish(false)
+                }
+            }, ContextCompat.getMainExecutor(context))
+        }
+    }
+
+    private fun receive(raw: String) {
+        val message = runCatching { JSONObject(raw) }.getOrNull() ?: return
+        val payload = message.optJSONObject("payload") ?: JSONObject()
+        when (message.optString("type")) {
+            "API_REQUEST" -> answer(message.optString("id"), payload)
+            "SYNC_WRITE" -> {
+                val key = payload.optString("key")
+                val value = if (payload.isNull("value")) null else payload.optString("value")
+                val reply: (Boolean) -> Unit = { ok ->
+                    payload.optString("id").takeIf { it.isNotBlank() }?.let { send("SYNC_RESULT", JSONObject().put("id", it).put("ok", ok)) }
+                }
+                when (payload.optString("store")) {
+                    "storage" -> if (key.isNotBlank()) stores.setStorage(key, value, scope)
+                    "snapshots" -> if (payload.optBoolean("clear")) {
+                        val keep = payload.optJSONArray("keep") ?: JSONArray()
+                        stores.clearSnapshots((0 until keep.length()).map { keep.optString(it) }.toSet(), reply)
+                    } else stores.setSnapshot(key, value, scope, reply)
+                }
+            }
+            "TIMER" -> {
+                val id = payload.optInt("id")
+                timers.remove(id)?.let(main::removeCallbacks)
+                val fire = Runnable {
+                    timers.remove(id)
+                    send("TIMER_FIRE", JSONObject().put("id", id))
+                }
+                timers[id] = fire
+                main.postDelayed(fire, payload.optLong("ms", 0).coerceAtLeast(0))
+            }
+            "TIMER_CLEAR" -> timers.remove(payload.optInt("id"))?.let(main::removeCallbacks)
+            // Nothing is drawn in the background: frames come at a calm pace.
+            "FRAME" -> main.postDelayed({ send("FRAME_FIRE", JSONObject().put("time", android.os.SystemClock.uptimeMillis().toDouble())) }, 100)
+            // A background refresh shows nothing: navigation waits for the app.
+        }
+    }
+
+    private fun answer(requestId: String, payload: JSONObject) {
+        if (requestId.isBlank()) return
+        val module = payload.optString("module")
+        val method = payload.optString("method")
+        val args = payload.optJSONArray("args") ?: JSONArray()
+        val reply: (CraftNativeCapabilityResult) -> Unit = { result ->
+            val response = JSONObject().put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION).put("requestId", requestId)
+            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(if (result.code == null) "API_RESPONSE" else "API_ERROR", response, requestId)
+        }
+        if (services.handles(module)) services.perform(module, method, args, reply)
+        else capabilities.perform("$scope/$requestId", payload.optInt("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION), module, method, args, reply)
+    }
+
+    private fun send(type: String, payload: JSONObject, correlationId: String? = null) {
+        val target = isolate ?: return
+        if (closed) return
+        val message = JSONObject().put("type", type).put("payload", payload)
+        if (correlationId != null) message.put("correlationId", correlationId)
+        runCatching { target.evaluateJavaScriptAsync("globalThis.__stxNativeCallback && globalThis.__stxNativeCallback(${JSONObject.quote(message.toString())})") }
+    }
+
+    private fun finish(ok: Boolean) {
+        main.post { onDone(ok) }
+    }
+
+    fun close() {
+        if (closed) return
+        closed = true
+        CraftNativeHub.unregister(scope)
+        timers.values.forEach(main::removeCallbacks)
+        timers.clear()
+        services.close()
+        capabilities.close()
+        isolate?.let { target ->
+            runCatching { target.evaluateJavaScriptAsync("globalThis.__stxNativeUnmount && globalThis.__stxNativeUnmount()") }
+            main.postDelayed({ runCatching { target.close() } }, 500)
+        }
+        isolate = null
+    }
+
+    companion object {
+        private const val TAG = "CraftNativeAndroid"
+    }
+}

package/templates/CraftNativeCapabilities.kt.template

@@ -58,34 +58,44 @@ internal data class CraftNativeCapabilityResult(
 
 /** Process-wide persistence and OS services shared by every native route. */
 internal class CraftNativeCapabilities(
-    private val activity: MainActivity,
+    private val context: Context,
     private val config: JSONObject,
 ) {
-    private val storage = activity.getSharedPreferences("craft-native-storage", Context.MODE_PRIVATE)
+    /** The screen's activity; null in a background refresh, where nothing can be shown. */
+    private val activity: MainActivity? get() = context as? MainActivity
+    private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
+    private val storage = context.getSharedPreferences("craft-native-storage", Context.MODE_PRIVATE)
     // The typed native renderer has no CraftNative Zig holder. Keep its
     // values encrypted at rest with AndroidX's AES-256 GCM/SIV preferences.
     private val encryptedSecureStorage by lazy {
-        val masterKey = MasterKey.Builder(activity)
+        val masterKey = MasterKey.Builder(context)
             .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
             .build()
         EncryptedSharedPreferences.create(
-            activity,
+            context,
             "craft_secure_prefs",
             masterKey,
             EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
             EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
         )
     }
-    private val notificationStorage = activity.getSharedPreferences("craft-native-notifications", Context.MODE_PRIVATE)
+    private val notificationStorage = context.getSharedPreferences("craft-native-notifications", Context.MODE_PRIVATE)
     private val databaseExecutor = Executors.newSingleThreadExecutor()
     private val networkExecutor = Executors.newCachedThreadPool()
     private val cancelled = ConcurrentHashMap.newKeySet<String>()
     private val fetchConnections = ConcurrentHashMap<String, HttpURLConnection>()
-    private val fileRoot by lazy { File(activity.cacheDir, "craft-files").apply { mkdirs() } }
+    private val fileRoot by lazy { File(context.cacheDir, "craft-files").apply { mkdirs() } }
     private var pendingFilePick: PendingFilePick? = null
     private var database: SQLiteDatabase? = null
     private val biometricPrompts = ConcurrentHashMap<String, BiometricPrompt>()
 
+    /**
+     * Hears each change to `Storage` and `SecureStorage` (store, key or null
+     * for a clear, the new value or null), so every isolate's synchronous
+     * copy follows it (CraftNativeStores).
+     */
+    var storeObserver: ((String, String?, String?) -> Unit)? = null
+
     private data class PendingFilePick(
         val requestToken: String,
         val source: String,
@@ -136,7 +146,7 @@ internal class CraftNativeCapabilities(
                     complete(requestToken, database(method, args), completion)
                 }
             }
-            "Lifecycle" -> complete(requestToken, if (method == "getState") success(activity.nativeAppState)
+            "Lifecycle" -> complete(requestToken, if (method == "getState") success(activity?.nativeAppState ?: "background")
                 else failure("UNKNOWN_ACTION", "Unsupported Lifecycle method"), completion)
             "DeepLinks" -> complete(requestToken, deepLinks(method), completion)
             "Notifications" -> notifications(requestToken, method, args, completion)
@@ -154,7 +164,8 @@ internal class CraftNativeCapabilities(
                 }
                 else -> complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Files method"), completion)
             }
-            else -> complete(requestToken, activity.performImmediateCapability(module, method, args), completion)
+            else -> complete(requestToken, activity?.performImmediateCapability(module, method, args)
+                ?: failure("NEEDS_ACTIVITY", "$module.$method needs a screen"), completion)
         }
     }
 
@@ -403,16 +414,17 @@ internal class CraftNativeCapabilities(
         args: JSONArray,
         completion: (CraftNativeCapabilityResult) -> Unit,
     ) {
-        activity.runOnUiThread {
+        mainHandler.post {
+            val host = activity ?: return@post complete(requestToken, failure("NEEDS_ACTIVITY", "No screen is showing to pick from"), completion)
             if (pendingFilePick != null) {
                 complete(requestToken, failure("BUSY", "Another file picker is already open"), completion)
-                return@runOnUiThread
+                return@post
             }
             val options = args.optJSONObject(0) ?: JSONObject()
             val source = options.optString("source", "library")
             if (source != "library" && source != "camera") {
                 complete(requestToken, failure("INVALID_ARGUMENT", "files.pickImage source is 'library' or 'camera'"), completion)
-                return@runOnUiThread
+                return@post
             }
             val maxPixels = options.optInt("maxPixels", CRAFT_NATIVE_FILE_DEFAULT_MAX_PIXELS)
                 .coerceIn(64, CRAFT_NATIVE_FILE_LARGEST_MAX_PIXELS)
@@ -420,7 +432,7 @@ internal class CraftNativeCapabilities(
                 .coerceIn(0.1, 1.0).toFloat()
             if (source == "camera" && !config.optBoolean("enableCamera")) {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Camera is disabled"), completion)
-                return@runOnUiThread
+                return@post
             }
             pendingFilePick = PendingFilePick(requestToken, source, maxPixels, quality, completion)
             val intent = if (source == "camera") Intent(MediaStore.ACTION_IMAGE_CAPTURE)
@@ -429,7 +441,7 @@ internal class CraftNativeCapabilities(
                 type = "image/*"
             }
             try {
-                activity.startActivityForResult(intent, CRAFT_NATIVE_FILE_PICK_REQUEST)
+                host.startActivityForResult(intent, CRAFT_NATIVE_FILE_PICK_REQUEST)
             } catch (error: Exception) {
                 pendingFilePick = null
                 complete(requestToken, failure("PICKER_UNAVAILABLE", error.message ?: "Image picker could not be opened"), completion)
@@ -457,16 +469,16 @@ internal class CraftNativeCapabilities(
     }
 
     private fun copyUri(uri: Uri, maxPixels: Int, quality: Float): JSONObject? {
-        val name = activity.contentResolver.query(uri, arrayOf(android.provider.OpenableColumns.DISPLAY_NAME), null, null, null)?.use {
+        val name = context.contentResolver.query(uri, arrayOf(android.provider.OpenableColumns.DISPLAY_NAME), null, null, null)?.use {
             if (it.moveToFirst()) it.getString(0) else null
         } ?: "photo"
         val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-        activity.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, bounds) } ?: return null
+        context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, bounds) } ?: return null
         if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null
         var sample = 1
         while (max(bounds.outWidth / sample, bounds.outHeight / sample) > maxPixels * 2) sample *= 2
         val options = BitmapFactory.Options().apply { inSampleSize = sample }
-        val bitmap = activity.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, options) } ?: return null
+        val bitmap = context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, options) } ?: return null
         return writeImage(bitmap, maxPixels, quality, jpegName(name))
     }
 
@@ -536,7 +548,9 @@ internal class CraftNativeCapabilities(
         result: CraftNativeCapabilityResult,
         completion: (CraftNativeCapabilityResult) -> Unit,
     ) {
-        activity.runOnUiThread {
+        if (android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) {
+            if (!cancelled.remove(requestToken)) completion(result)
+        } else mainHandler.post {
             if (!cancelled.remove(requestToken)) completion(result)
         }
     }
@@ -544,6 +558,7 @@ internal class CraftNativeCapabilities(
     private fun storage(method: String, args: JSONArray): CraftNativeCapabilityResult {
         if (method == "clear") {
             storage.edit().clear().commit()
+            storeObserver?.invoke("storage", null, null)
             return success(true)
         }
         if (method == "keys") return success(JSONArray(storage.all.keys.sorted()))
@@ -558,10 +573,13 @@ 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()) success(true)
+                if (storage.edit().putString(key, value).commit()) {
+                    storeObserver?.invoke("storage", key, value)
+                    success(true)
+                }
                 else failure("STORAGE_ERROR", "Storage could not persist the value")
             }
-            "remove" -> success(storage.edit().remove(key).commit())
+            "remove" -> success(storage.edit().remove(key).commit().also { storeObserver?.invoke("storage", key, null) })
             else -> failure("UNKNOWN_ACTION", "Unsupported Storage method")
         }
     }
@@ -569,7 +587,7 @@ internal class CraftNativeCapabilities(
     private fun secureStorage(method: String, args: JSONArray): CraftNativeCapabilityResult {
         if (method == "clear") {
             return try {
-                success(encryptedSecureStorage.edit().clear().commit())
+                success(encryptedSecureStorage.edit().clear().commit().also { storeObserver?.invoke("secure", null, null) })
             } catch (error: Exception) {
                 failure("SECURE_STORAGE_ERROR", error.message ?: "Secure storage could not be cleared")
             }
@@ -579,11 +597,14 @@ internal class CraftNativeCapabilities(
             when (method) {
                 "set" -> {
                     if (args.length() != 2 || args.opt(1) !is String) return failure("INVALID_ARGUMENT", "SecureStorage.set needs a key and string value")
-                    if (encryptedSecureStorage.edit().putString(key, args.getString(1)).commit()) success(true)
+                    if (encryptedSecureStorage.edit().putString(key, args.getString(1)).commit()) {
+                        storeObserver?.invoke("secure", key, args.getString(1))
+                        success(true)
+                    }
                     else failure("SECURE_STORAGE_ERROR", "Secure storage could not be written")
                 }
                 "get" -> success(encryptedSecureStorage.getString(key, null) ?: JSONObject.NULL)
-                "remove" -> success(encryptedSecureStorage.edit().remove(key).commit())
+                "remove" -> success(encryptedSecureStorage.edit().remove(key).commit().also { storeObserver?.invoke("secure", key, null) })
                 else -> failure("UNKNOWN_ACTION", "Unsupported SecureStorage method")
             }
         } catch (error: Exception) {
@@ -601,28 +622,29 @@ internal class CraftNativeCapabilities(
             complete(requestToken, failure("CAPABILITY_DISABLED", "Biometric authentication is disabled"), completion)
             return
         }
-        val manager = BiometricManager.from(activity)
+        val manager = BiometricManager.from(context)
         when (method) {
             "isAvailable" -> complete(requestToken, success(manager.canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_STRONG) == BiometricManager.BIOMETRIC_SUCCESS), completion)
             "getBiometricType" -> {
                 val available = manager.canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_STRONG) == BiometricManager.BIOMETRIC_SUCCESS
                 val type = when {
                     !available -> "none"
-                    activity.packageManager.hasSystemFeature("android.hardware.biometrics.face") -> "faceId"
+                    context.packageManager.hasSystemFeature("android.hardware.biometrics.face") -> "faceId"
                     else -> "fingerprint"
                 }
                 complete(requestToken, success(type), completion)
             }
             "authenticate" -> {
-                if (activity !is FragmentActivity) {
+                val host = activity
+                if (host !is FragmentActivity) {
                     complete(requestToken, failure("AUTHENTICATION_FAILED", "Activity does not support biometric prompts"), completion)
                     return
                 }
                 val reason = args.optString(0).ifBlank { "Authenticate to continue" }
-                activity.runOnUiThread {
-                    if (cancelled.contains(requestToken)) return@runOnUiThread
+                mainHandler.post {
+                    if (cancelled.contains(requestToken)) return@post
                     try {
-                        val prompt = BiometricPrompt(activity, ContextCompat.getMainExecutor(activity), object : BiometricPrompt.AuthenticationCallback() {
+                        val prompt = BiometricPrompt(host, ContextCompat.getMainExecutor(host), object : BiometricPrompt.AuthenticationCallback() {
                             override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
                                 biometricPrompts.remove(requestToken)
                                 complete(requestToken, success(true), completion)
@@ -650,7 +672,7 @@ internal class CraftNativeCapabilities(
 
     private fun database(method: String, args: JSONArray): CraftNativeCapabilityResult {
         val db = database ?: runCatching {
-            activity.openOrCreateDatabase("craft-native.sqlite", Context.MODE_PRIVATE, null)
+            context.openOrCreateDatabase("craft-native.sqlite", Context.MODE_PRIVATE, null)
         }.getOrElse { return failure("DATABASE_ERROR", it.message ?: "Could not open the local database") }
             .also { database = it }
         return try {
@@ -764,7 +786,7 @@ internal class CraftNativeCapabilities(
     private fun deepLinks(method: String): CraftNativeCapabilityResult {
         if (!config.optBoolean("enableDeepLinks")) return failure("CAPABILITY_DISABLED", "Deep links are disabled")
         if (method != "getInitialURL") return failure("UNKNOWN_ACTION", "Unsupported DeepLinks method")
-        return success(activity.consumeInitialDeepLink()?.let(activity::deepLinkData) ?: JSONObject.NULL)
+        return success(activity?.let { host -> host.consumeInitialDeepLink()?.let(host::deepLinkData) } ?: JSONObject.NULL)
     }
 
     private fun notifications(
@@ -786,7 +808,7 @@ internal class CraftNativeCapabilities(
             }
             "cancelAll" -> {
                 notificationStorage.all.keys.forEach(::cancelNotification)
-                (activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).cancelAll()
+                (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).cancelAll()
                 complete(requestToken, success(true), completion)
             }
             "pending" -> complete(requestToken, success(JSONArray(notificationStorage.all.values.mapNotNull {
@@ -800,7 +822,7 @@ internal class CraftNativeCapabilities(
         val title = value?.optString("title").orEmpty()
         if (title.isEmpty()) return failure("INVALID_ARGUMENT", "Notifications.schedule needs a title")
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
-            ContextCompat.checkSelfPermission(activity, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
             return failure("PERMISSION_DENIED", "Notification permission denied")
         }
         val id = validKey(value?.opt("id")) ?: UUID.randomUUID().toString()
@@ -820,7 +842,7 @@ internal class CraftNativeCapabilities(
     private fun scheduleStored(value: JSONObject) {
         val id = value.optString("id")
         if (id.isEmpty()) return
-        val alarm = activity.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        val alarm = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
         alarm.setAndAllowWhileIdle(
             AlarmManager.RTC_WAKEUP,
             value.optLong("fireAt").coerceAtLeast(System.currentTimeMillis()),
@@ -829,18 +851,18 @@ internal class CraftNativeCapabilities(
     }
 
     private fun cancelNotification(id: String) {
-        val alarm = activity.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        val alarm = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
         val intent = notificationIntent(id)
         alarm.cancel(intent)
         intent.cancel()
         notificationStorage.edit().remove(id).commit()
-        (activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).cancel(id, 0)
+        (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).cancel(id, 0)
     }
 
     private fun notificationIntent(id: String): PendingIntent = PendingIntent.getBroadcast(
-        activity,
+        context,
         0,
-        Intent(activity, CraftNativeNotificationReceiver::class.java)
+        Intent(context, CraftNativeNotificationReceiver::class.java)
             .setData(Uri.Builder().scheme("craft-native").authority("notification").appendPath(id).build())
             .putExtra("id", id),
         PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,