craft-native 0.0.115 → 0.0.119

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

@@ -0,0 +1,455 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.app.AlarmManager
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.database.Cursor
+import android.database.sqlite.SQLiteCursor
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteQuery
+import android.database.sqlite.SQLiteStatement
+import android.os.Build
+import android.net.Uri
+import android.util.Base64
+import androidx.core.content.ContextCompat
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricPrompt
+import androidx.fragment.app.FragmentActivity
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import org.json.JSONArray
+import org.json.JSONObject
+import org.json.JSONTokener
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+
+internal const val CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION = 1
+
+internal data class CraftNativeCapabilityResult(
+    val data: Any? = null,
+    val code: String? = null,
+    val message: String? = null,
+)
+
+/** Process-wide persistence and OS services shared by every native route. */
+internal class CraftNativeCapabilities(
+    private val activity: MainActivity,
+    private val config: JSONObject,
+) {
+    private val storage = activity.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)
+            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+            .build()
+        EncryptedSharedPreferences.create(
+            activity,
+            "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 databaseExecutor = Executors.newSingleThreadExecutor()
+    private val cancelled = ConcurrentHashMap.newKeySet<String>()
+    private var database: SQLiteDatabase? = null
+    private val biometricPrompts = ConcurrentHashMap<String, BiometricPrompt>()
+
+    init { restoreNotifications() }
+
+    fun names(): JSONArray = JSONArray().apply {
+        listOf("device", "clipboard", "haptics", "storage", "lifecycle").forEach(::put)
+        if (config.optBoolean("enableBiometric")) put("biometric")
+        if (config.optBoolean("enableSecureStorage")) put("secureStorage")
+        if (config.optBoolean("enableLocalDatabase")) put("database")
+        if (config.optBoolean("enableDeepLinks")) put("deepLinks")
+        if (config.optBoolean("enableLocalNotifications")) put("notifications")
+    }
+
+    fun perform(
+        requestToken: String,
+        version: Int,
+        module: String,
+        method: String,
+        args: JSONArray,
+        completion: (CraftNativeCapabilityResult) -> Unit,
+    ) {
+        cancelled.remove(requestToken)
+        if (version != CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION) {
+            complete(requestToken, failure("UNSUPPORTED_VERSION", "Unsupported native capability protocol version"), completion)
+            return
+        }
+        when (module) {
+            "Storage" -> complete(requestToken, storage(method, args), completion)
+            "SecureStorage" -> {
+                if (!config.optBoolean("enableSecureStorage")) complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
+                else complete(requestToken, secureStorage(method, args), completion)
+            }
+            "Biometrics" -> biometrics(requestToken, method, args, completion)
+            "Database" -> {
+                if (!config.optBoolean("enableLocalDatabase")) {
+                    complete(requestToken, failure("CAPABILITY_DISABLED", "Local database is disabled"), completion)
+                }
+                else databaseExecutor.execute {
+                    complete(requestToken, database(method, args), completion)
+                }
+            }
+            "Lifecycle" -> complete(requestToken, if (method == "getState") success(activity.nativeAppState)
+                else failure("UNKNOWN_ACTION", "Unsupported Lifecycle method"), completion)
+            "DeepLinks" -> complete(requestToken, deepLinks(method), completion)
+            "Notifications" -> notifications(requestToken, method, args, completion)
+            else -> complete(requestToken, activity.performImmediateCapability(module, method, args), completion)
+        }
+    }
+
+    fun cancel(requestToken: String) {
+        cancelled.add(requestToken)
+        biometricPrompts.remove(requestToken)?.cancelAuthentication()
+    }
+
+    fun close() {
+        databaseExecutor.shutdownNow()
+        database?.close()
+        database = null
+        biometricPrompts.values.forEach { it.cancelAuthentication() }
+        biometricPrompts.clear()
+    }
+
+    private fun complete(
+        requestToken: String,
+        result: CraftNativeCapabilityResult,
+        completion: (CraftNativeCapabilityResult) -> Unit,
+    ) {
+        activity.runOnUiThread {
+            if (!cancelled.remove(requestToken)) completion(result)
+        }
+    }
+
+    private fun storage(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (method == "clear") {
+            storage.edit().clear().commit()
+            return success(true)
+        }
+        if (method == "keys") return success(JSONArray(storage.all.keys.sorted()))
+        val key = validKey(args.opt(0)) ?: return failure("INVALID_ARGUMENT", "Storage needs a non-empty key")
+        return when (method) {
+            "get" -> {
+                val raw = storage.getString(key, null) ?: return success(JSONObject.NULL)
+                runCatching { success(JSONTokener(raw).nextValue()) }
+                    .getOrElse { failure("STORAGE_CORRUPT", "Stored value is not valid JSON") }
+            }
+            "set" -> {
+                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)
+                else failure("STORAGE_ERROR", "Storage could not persist the value")
+            }
+            "remove" -> success(storage.edit().remove(key).commit())
+            else -> failure("UNKNOWN_ACTION", "Unsupported Storage method")
+        }
+    }
+
+    private fun secureStorage(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (method == "clear") {
+            return try {
+                success(encryptedSecureStorage.edit().clear().commit())
+            } catch (error: Exception) {
+                failure("SECURE_STORAGE_ERROR", error.message ?: "Secure storage could not be cleared")
+            }
+        }
+        val key = validKey(args.opt(0)) ?: return failure("INVALID_ARGUMENT", "Secure storage needs a non-empty key")
+        return try {
+            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)
+                    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())
+                else -> failure("UNKNOWN_ACTION", "Unsupported SecureStorage method")
+            }
+        } catch (error: Exception) {
+            failure("SECURE_STORAGE_ERROR", error.message ?: "Secure storage operation failed")
+        }
+    }
+
+    private fun biometrics(
+        requestToken: String,
+        method: String,
+        args: JSONArray,
+        completion: (CraftNativeCapabilityResult) -> Unit,
+    ) {
+        if (!config.optBoolean("enableBiometric")) {
+            complete(requestToken, failure("CAPABILITY_DISABLED", "Biometric authentication is disabled"), completion)
+            return
+        }
+        val manager = BiometricManager.from(activity)
+        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"
+                    else -> "fingerprint"
+                }
+                complete(requestToken, success(type), completion)
+            }
+            "authenticate" -> {
+                if (activity !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
+                    try {
+                        val prompt = BiometricPrompt(activity, ContextCompat.getMainExecutor(activity), object : BiometricPrompt.AuthenticationCallback() {
+                            override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
+                                biometricPrompts.remove(requestToken)
+                                complete(requestToken, success(true), completion)
+                            }
+                            override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
+                                biometricPrompts.remove(requestToken)
+                                complete(requestToken, failure("AUTHENTICATION_FAILED", errString.toString()), completion)
+                            }
+                        })
+                        biometricPrompts[requestToken] = prompt
+                        prompt.authenticate(BiometricPrompt.PromptInfo.Builder()
+                            .setTitle("Authenticate")
+                            .setSubtitle(reason)
+                            .setNegativeButtonText("Cancel")
+                            .setAllowedAuthenticators(BiometricManager.Authenticators.BIOMETRIC_STRONG)
+                            .build())
+                    } catch (error: Exception) {
+                        complete(requestToken, failure("AUTHENTICATION_FAILED", error.message ?: "Biometric authentication failed"), completion)
+                    }
+                }
+            }
+            else -> complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Biometrics method"), completion)
+        }
+    }
+
+    private fun database(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        val db = database ?: runCatching {
+            activity.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 {
+            when (method) {
+                "execute" -> {
+                    val sql = args.optString(0).trim()
+                    if (sql.isEmpty()) return failure("INVALID_ARGUMENT", "Database.execute needs a SQL statement")
+                    execute(db, sql, args.optJSONArray(1) ?: JSONArray())
+                }
+                "query" -> {
+                    val sql = args.optString(0).trim()
+                    if (sql.isEmpty()) return failure("INVALID_ARGUMENT", "Database.query needs a SQL statement")
+                    query(db, sql, args.optJSONArray(1) ?: JSONArray())
+                }
+                "beginTransaction" -> { db.beginTransaction(); success(true) }
+                "commit" -> {
+                    if (!db.inTransaction()) failure("DATABASE_ERROR", "No transaction is active")
+                    else { db.setTransactionSuccessful(); db.endTransaction(); success(true) }
+                }
+                "rollback" -> {
+                    if (!db.inTransaction()) failure("DATABASE_ERROR", "No transaction is active")
+                    else { db.endTransaction(); success(true) }
+                }
+                else -> failure("UNKNOWN_ACTION", "Unsupported Database method")
+            }
+        }
+        catch (error: Exception) {
+            failure("DATABASE_ERROR", error.message ?: "Database operation failed")
+        }
+    }
+
+    private fun execute(db: SQLiteDatabase, sql: String, params: JSONArray): CraftNativeCapabilityResult {
+        val statement = db.compileStatement(sql)
+        statement.use {
+            if (!bind(it, params)) return failure("INVALID_ARGUMENT", "Database parameters must be strings, numbers, booleans, or null")
+            val verb = sql.trimStart().substringBefore(' ').uppercase()
+            val insertId: Long
+            val rows: Int
+            when (verb) {
+                "INSERT", "REPLACE" -> { insertId = it.executeInsert(); rows = if (insertId < 0) 0 else 1 }
+                "UPDATE", "DELETE" -> { rows = it.executeUpdateDelete(); insertId = 0 }
+                else -> { it.execute(); rows = changes(db); insertId = lastInsertId(db) }
+            }
+            return success(JSONObject().put("rowsAffected", rows).put("lastInsertId", insertId))
+        }
+    }
+
+    private fun query(db: SQLiteDatabase, sql: String, params: JSONArray): CraftNativeCapabilityResult {
+        val cursor = db.rawQueryWithFactory({ _, driver, editTable, query ->
+            if (!bind(query, params)) throw IllegalArgumentException("Unsupported database parameter")
+            SQLiteCursor(driver, editTable, query)
+        }, sql, emptyArray<String>(), "")
+        cursor.use {
+            val rows = JSONArray()
+            while (it.moveToNext()) {
+                val row = JSONObject()
+                for (column in 0 until it.columnCount) {
+                    row.put(it.getColumnName(column), when (it.getType(column)) {
+                        Cursor.FIELD_TYPE_NULL -> JSONObject.NULL
+                        Cursor.FIELD_TYPE_INTEGER -> it.getLong(column)
+                        Cursor.FIELD_TYPE_FLOAT -> it.getDouble(column)
+                        Cursor.FIELD_TYPE_BLOB -> Base64.encodeToString(it.getBlob(column), Base64.NO_WRAP)
+                        else -> it.getString(column)
+                    })
+                }
+                rows.put(row)
+            }
+            return success(rows)
+        }
+    }
+
+    private fun bind(statement: SQLiteStatement, params: JSONArray): Boolean {
+        for (offset in 0 until params.length()) {
+            val index = offset + 1
+            when (val value = params.opt(offset)) {
+                null, JSONObject.NULL -> statement.bindNull(index)
+                is String -> statement.bindString(index, value)
+                is Boolean -> statement.bindLong(index, if (value) 1 else 0)
+                is ByteArray -> statement.bindBlob(index, value)
+                is Float, is Double -> statement.bindDouble(index, (value as Number).toDouble())
+                is Number -> statement.bindLong(index, value.toLong())
+                else -> return false
+            }
+        }
+        return true
+    }
+
+    private fun bind(query: SQLiteQuery, params: JSONArray): Boolean {
+        for (offset in 0 until params.length()) {
+            val index = offset + 1
+            when (val value = params.opt(offset)) {
+                null, JSONObject.NULL -> query.bindNull(index)
+                is String -> query.bindString(index, value)
+                is Boolean -> query.bindLong(index, if (value) 1 else 0)
+                is Float, is Double -> query.bindDouble(index, (value as Number).toDouble())
+                is Number -> query.bindLong(index, value.toLong())
+                else -> return false
+            }
+        }
+        return true
+    }
+
+    private fun changes(db: SQLiteDatabase): Int = db.rawQuery("SELECT changes()", null).use {
+        if (it.moveToFirst()) it.getInt(0) else 0
+    }
+
+    private fun lastInsertId(db: SQLiteDatabase): Long = db.rawQuery("SELECT last_insert_rowid()", null).use {
+        if (it.moveToFirst()) it.getLong(0) else 0
+    }
+
+    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)
+    }
+
+    private fun notifications(
+        requestToken: String,
+        method: String,
+        args: JSONArray,
+        completion: (CraftNativeCapabilityResult) -> Unit,
+    ) {
+        if (!config.optBoolean("enableLocalNotifications")) {
+            complete(requestToken, failure("CAPABILITY_DISABLED", "Local notifications are disabled"), completion)
+            return
+        }
+        when (method) {
+            "schedule" -> complete(requestToken, schedule(args.optJSONObject(0)), completion)
+            "cancel" -> {
+                val id = validKey(args.opt(0))
+                complete(requestToken, if (id == null) failure("INVALID_ARGUMENT", "Notifications.cancel needs an id")
+                    else { cancelNotification(id); success(true) }, completion)
+            }
+            "cancelAll" -> {
+                notificationStorage.all.keys.forEach(::cancelNotification)
+                (activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).cancelAll()
+                complete(requestToken, success(true), completion)
+            }
+            "pending" -> complete(requestToken, success(JSONArray(notificationStorage.all.values.mapNotNull {
+                runCatching { JSONObject(it as String) }.getOrNull()
+            })), completion)
+            else -> complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Notifications method"), completion)
+        }
+    }
+
+    private fun schedule(value: JSONObject?): CraftNativeCapabilityResult {
+        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) {
+            return failure("PERMISSION_DENIED", "Notification permission denied")
+        }
+        val id = validKey(value?.opt("id")) ?: UUID.randomUUID().toString()
+        val fireAt = System.currentTimeMillis() + value!!.optLong("delay", 0).coerceAtLeast(0)
+        val stored = JSONObject(value.toString()).put("id", id).put("fireAt", fireAt)
+        notificationStorage.edit().putString(id, stored.toString()).commit()
+        scheduleStored(stored)
+        return success(id)
+    }
+
+    private fun restoreNotifications() {
+        notificationStorage.all.values.forEach { raw ->
+            runCatching { JSONObject(raw as String) }.getOrNull()?.let(::scheduleStored)
+        }
+    }
+
+    private fun scheduleStored(value: JSONObject) {
+        val id = value.optString("id")
+        if (id.isEmpty()) return
+        val alarm = activity.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        alarm.setAndAllowWhileIdle(
+            AlarmManager.RTC_WAKEUP,
+            value.optLong("fireAt").coerceAtLeast(System.currentTimeMillis()),
+            notificationIntent(id),
+        )
+    }
+
+    private fun cancelNotification(id: String) {
+        val alarm = activity.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)
+    }
+
+    private fun notificationIntent(id: String): PendingIntent = PendingIntent.getBroadcast(
+        activity,
+        0,
+        Intent(activity, 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,
+    )
+
+    private fun validKey(value: Any?): String? = (value as? String)?.takeIf {
+        it.isNotEmpty() && it.length <= 512 && !it.contains('\u0000')
+    }
+
+    private fun jsonString(value: Any?): String? = when (value) {
+        null, JSONObject.NULL -> "null"
+        is JSONObject, is JSONArray -> value.toString()
+        is String -> JSONObject.quote(value)
+        is Boolean -> value.toString()
+        is Number -> value.toString().takeUnless { it == "NaN" || it == "Infinity" || it == "-Infinity" }
+        else -> null
+    }
+
+    private fun success(data: Any?) = CraftNativeCapabilityResult(data = data)
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+}

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

@@ -44,15 +44,26 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
             val item = getItem(position)
             if (holder.identity != null && holder.identity != item.identity) release(holder)
             val view = renderItem?.invoke(item.node, item.identity, holder.hostedView) ?: View(holder.host.context)
+            val renderedLayout = view.layoutParams
+            val hostedLayout = FrameLayout.LayoutParams(
+                renderedLayout?.width ?: LayoutParams.MATCH_PARENT,
+                renderedLayout?.height ?: LayoutParams.WRAP_CONTENT,
+            )
+            if (renderedLayout is ViewGroup.MarginLayoutParams) {
+                hostedLayout.setMargins(
+                    renderedLayout.leftMargin,
+                    renderedLayout.topMargin,
+                    renderedLayout.rightMargin,
+                    renderedLayout.bottomMargin,
+                )
+            }
             holder.identity = item.identity
             if (holder.hostedView !== view) {
                 (view.parent as? ViewGroup)?.removeView(view)
                 holder.host.removeAllViews()
-                holder.host.addView(view, FrameLayout.LayoutParams(
-                    LayoutParams.MATCH_PARENT,
-                    LayoutParams.WRAP_CONTENT,
-                ))
+                holder.host.addView(view, hostedLayout)
             }
+            else view.layoutParams = hostedLayout
         }
 
         override fun onViewRecycled(holder: Holder) {
@@ -74,6 +85,8 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
     private var endReachedSignature: String? = null
     private var horizontal = false
     private var columns = 1
+    private var submissionGeneration = 0
+    private var isSubmittingList = false
 
     init {
         adapter = listAdapter
@@ -121,15 +134,23 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
         val dataItems = next.filterNot { it.chrome }
         val contentSignature = "${dataItems.size}:${dataItems.lastOrNull()?.identity.orEmpty()}"
         if (contentSignature != endReachedSignature) endReachedSignature = null
+        val generation = ++submissionGeneration
+        isSubmittingList = true
         listAdapter.submitList(next) {
+            if (generation != submissionGeneration) return@submitList
             retainedState?.let { layoutManager?.onRestoreInstanceState(it) }
+            isSubmittingList = false
             evaluateEndReached()
         }
     }
 
     fun discardAll() {
         listAdapter.currentList.forEach { recycleItem?.invoke(it.identity) }
-        listAdapter.submitList(emptyList())
+        val generation = ++submissionGeneration
+        isSubmittingList = true
+        listAdapter.submitList(emptyList()) {
+            if (generation == submissionGeneration) isSubmittingList = false
+        }
         renderItem = null
         recycleItem = null
         endReached = null
@@ -149,6 +170,7 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
     }
 
     private fun evaluateEndReached() {
+        if (isSubmittingList) return
         val manager = layoutManager as? LinearLayoutManager ?: return
         val lastVisible = manager.findLastVisibleItemPosition()
         val dataPositions = listAdapter.currentList.indices.filter { !listAdapter.currentList[it].chrome }

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

@@ -0,0 +1,43 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import org.json.JSONObject
+
+/** Delivers native-runtime notifications even when the app process has exited. */
+internal class CraftNativeNotificationReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val id = intent.getStringExtra("id").orEmpty()
+        if (id.isEmpty()) return
+        val storage = context.getSharedPreferences("craft-native-notifications", Context.MODE_PRIVATE)
+        val value = storage.getString(id, null)?.let { runCatching { JSONObject(it) }.getOrNull() } ?: return
+        storage.edit().remove(id).commit()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) return
+
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            manager.createNotificationChannel(NotificationChannel(
+                "craft_notifications",
+                "Craft Notifications",
+                NotificationManager.IMPORTANCE_DEFAULT,
+            ))
+        }
+        val notification = NotificationCompat.Builder(context, "craft_notifications")
+            .setSmallIcon(android.R.drawable.ic_dialog_info)
+            .setContentTitle(value.optString("title"))
+            .setContentText(value.optString("body"))
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setAutoCancel(true)
+            .build()
+        manager.notify(id, 0, notification)
+    }
+}