@craft-native/android 0.0.451 → 0.0.467

package/templates/CraftNativeNotificationReceiver.kt.template

@@ -15,30 +15,228 @@ 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) {
+        intent.getStringExtra("craft.dismissedId")?.let {
+            CraftNativeNotifications.cancel(context, it, intent.getStringExtra("craft.dismissedThread"))
+            return
+        }
+        if (intent.hasExtra("craft.actionToken")) {
+            val pending = goAsync()
+            CraftNativeNotifications.receiveAction(context, intent) { pending.finish() }
+            return
+        }
         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()
+        CraftNativeNotifications.show(context, value, id, "craft_notifications")
+    }
+}
+
+/** Shared by scheduled locals and app-rendered FCM data messages. */
+internal object CraftNativeNotifications {
+    private const val REPLY = "craft.reply"
+
+    private fun config(context: Context): JSONObject = runCatching {
+        context.assets.open("craft.config.json").bufferedReader().use { JSONObject(it.readText()) }
+    }.getOrDefault(JSONObject())
+
+    internal fun actions(config: JSONObject, categoryId: String): List<JSONObject> {
+        val categories = config.optJSONArray("notificationCategories") ?: return emptyList()
+        for (index in 0 until categories.length()) {
+            val category = categories.optJSONObject(index) ?: continue
+            if (category.optString("id") != categoryId) continue
+            val entries = category.optJSONArray("actions") ?: return emptyList()
+            return (0 until entries.length()).mapNotNull { entries.optJSONObject(it) }
+        }
+        return emptyList()
+    }
+
+    internal fun actionDetail(config: JSONObject, value: JSONObject, actionId: String, reply: CharSequence?): JSONObject? {
+        val categoryId = value.optString("categoryId")
+        val action = actions(config, categoryId).firstOrNull { it.optString("id") == actionId } ?: return null
+        val detail = JSONObject().put("actionId", actionId).put("notificationId", value.optString("id"))
+            .put("categoryId", categoryId).put("data", value.optJSONObject("data") ?: JSONObject())
+        if (reply != null && action.optJSONObject("textInput") != null) detail.put("userText", reply.toString())
+        return detail
+    }
+
+    internal fun invalidOptions(value: JSONObject): String? {
+        for (key in listOf("categoryId", "threadIdentifier")) {
+            if (value.has(key) && value.opt(key) !is String) return "$key must be a string"
+        }
+        if (value.has("interruptionLevel") && value.opt("interruptionLevel") !in listOf("passive", "active", "timeSensitive")) {
+            return "interruptionLevel must be passive, active or timeSensitive"
+        }
+        return null
+    }
+
+    internal fun consumeAction(storage: android.content.SharedPreferences, token: String): JSONObject? {
+        val saved = storage.getString(token, null)?.let { runCatching { JSONObject(it) }.getOrNull() } ?: return null
+        if (!storage.edit().remove(token).commit()) return null
+        return saved
+    }
+
+    @Synchronized
+    fun receiveAction(context: Context, intent: Intent?, queued: (() -> Unit)? = null): Boolean {
+        val token = intent?.getStringExtra("craft.actionToken") ?: return false.also { queued?.invoke() }
+        val storage = context.getSharedPreferences("craft-native-notification-actions", Context.MODE_PRIVATE)
+        // MainActivity is exported. Never turn arbitrary launch extras into
+        // an authenticated notification action: only a token we minted can
+        // name an action/payload. RemoteInput supplies just the reply text.
+        val saved = consumeAction(storage, token)
+        if (saved == null) { queued?.invoke(); return true }
+        intent.removeExtra("craft.actionToken")
+        val value = saved.optJSONObject("value") ?: return true.also { queued?.invoke() }
+        val actionId = saved.optString("actionId")
+        val detail = actionDetail(config(context), value, actionId,
+            androidx.core.app.RemoteInput.getResultsFromIntent(intent)?.getCharSequence(REPLY))
+        if (detail == null) { queued?.invoke(); return true }
+        cancel(context, detail.optString("notificationId"))
+        CraftNativeBackground.runOnce(context, "craftNotificationAction", detail, queued)
+        return true
+    }
+
+    @Synchronized
+    fun revoke(context: Context, notificationId: String? = null) {
+        val storage = context.getSharedPreferences("craft-native-notification-actions", Context.MODE_PRIVATE)
+        if (notificationId == null) { storage.edit().clear().commit(); return }
+        val tokens = storage.all.filter { (key, raw) ->
+            !key.startsWith("index:") && runCatching { JSONObject(raw as String).optJSONObject("value")?.optString("id") == notificationId }.getOrDefault(false)
+        }.keys
+        val edit = storage.edit()
+        storage.all.forEach { (key, value) -> if (key in tokens || (key.startsWith("index:") && value is String && value in tokens)) edit.remove(key) }
+        edit.commit()
+    }
+
+    @Synchronized
+    fun clearEmptyGroup(context: Context, thread: String?) {
+        if (thread.isNullOrEmpty()) return
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val children = notificationGroups(context).all.any { (key, value) ->
+            key.startsWith("notification:") && value == thread
+        }
+        if (!children) manager.cancel("craft.group:$thread", 1)
+    }
+
+    @Synchronized
+    fun cancel(context: Context, id: String, dismissedThread: String? = null) {
+        revoke(context, id)
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val groups = notificationGroups(context)
+        val thread = groups.getString("notification:$id", null) ?: dismissedThread
+        check(groups.edit().remove("notification:$id").commit()) { "Could not save notification cancellation" }
+        manager.cancel(id, 0)
+        clearEmptyGroup(context, thread)
+    }
+
+    @Synchronized
+    fun cancelAll(context: Context) {
+        revoke(context)
+        check(notificationGroups(context).edit().clear().putBoolean("initialized", true).commit()) { "Could not clear notification groups" }
+        (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).cancelAll()
+    }
+
+    private fun notificationGroups(context: Context): android.content.SharedPreferences {
+        val storage = context.getSharedPreferences("craft-native-notification-groups", Context.MODE_PRIVATE)
+        if (!storage.getBoolean("initialized", false)) {
+            // Adopt notifications posted by earlier app versions once. After
+            // migration, our durable intent owns membership: OS snapshots can
+            // lag both notify() and cancel(), including across receiver calls.
+            val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            val edit = storage.edit().putBoolean("initialized", true)
+            manager.activeNotifications.filter {
+                it.tag != null && it.id == 0 && (it.notification.flags and android.app.Notification.FLAG_GROUP_SUMMARY) == 0
+            }.forEach { entry ->
+                entry.notification.group?.takeIf { it.isNotEmpty() }?.let { edit.putString("notification:${entry.tag}", it) }
+            }
+            check(edit.commit()) { "Could not initialize notification groups" }
+        }
+        return storage
+    }
+
+    private fun pending(context: Context, value: JSONObject, action: JSONObject?): android.app.PendingIntent? {
+        val foreground = action == null || action.optBoolean("foreground", false)
+        val target = if (foreground) Intent(context, MainActivity::class.java)
+            .addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        else Intent(context, CraftNativeNotificationReceiver::class.java)
+        target.action = "craft.notification:" + android.net.Uri.encode(value.optString("id")) + ":" +
+            (if (action == null) "tap" else "action:" + android.net.Uri.encode(action.optString("id")))
+        target.putExtra("craft.notification", true)
+        if (action == null) target.putExtra("craft.notification.data", (value.optJSONObject("data") ?: JSONObject()).toString())
+        else {
+            val token = java.util.UUID.randomUUID().toString()
+            val storage = context.getSharedPreferences("craft-native-notification-actions", Context.MODE_PRIVATE)
+            val index = "index:" + target.action
+            val edit = storage.edit()
+            storage.getString(index, null)?.let { edit.remove(it) }
+            if (!edit.putString(index, token).putString(token, JSONObject().put("actionId", action.optString("id"))
+                .put("value", value).toString()).commit()) return null
+            target.putExtra("craft.actionToken", token)
+        }
+        val mutable = action?.optJSONObject("textInput") != null
+        val flags = android.app.PendingIntent.FLAG_UPDATE_CURRENT or
+            (if (mutable) android.app.PendingIntent.FLAG_MUTABLE else android.app.PendingIntent.FLAG_IMMUTABLE)
+        return if (foreground) android.app.PendingIntent.getActivity(context, 0, target, flags)
+        else android.app.PendingIntent.getBroadcast(context, 0, target, flags)
+    }
+
+    @Synchronized
+    fun show(context: Context, original: JSONObject, id: String, channel: String) {
+        if (invalidOptions(original) != null) return
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
             ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) return
-
+        revoke(context, id) // replacing a notification also invalidates removed actions
+        val value = JSONObject(original.toString()).put("id", id)
         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")
+        val level = value.optString("interruptionLevel", "active")
+        val channelId = if (level == "active") channel else "$channel.$level"
+        val importance = when (level) {
+            "passive" -> NotificationManager.IMPORTANCE_LOW
+            "timeSensitive" -> NotificationManager.IMPORTANCE_HIGH
+            else -> NotificationManager.IMPORTANCE_DEFAULT
+        }
+        manager.createNotificationChannel(NotificationChannel(channelId, "${context.applicationInfo.loadLabel(context.packageManager)} ($level)", importance))
+        val notification = NotificationCompat.Builder(context, channelId)
             .setSmallIcon(R.drawable.craft_notification_icon)
             .setColor(ContextCompat.getColor(context, R.color.craft_notification_color))
-            .setContentTitle(value.optString("title"))
-            .setContentText(value.optString("body"))
-            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
-            .setAutoCancel(true)
-            .build()
-        manager.notify(id, 0, notification)
+            .setContentTitle(value.optString("title")).setContentText(value.optString("body"))
+            .setStyle(NotificationCompat.BigTextStyle().bigText(value.optString("body")))
+            .setContentIntent(pending(context, value, null)).setAutoCancel(true)
+        val thread = value.optString("threadIdentifier")
+        if (thread.isNotEmpty()) notification.setGroup(thread)
+        actions(config(context), value.optString("categoryId")).filter {
+            // API <31 cannot enforce action authentication. Omit the action
+            // instead of silently weakening the app's request.
+            !it.optBoolean("authenticationRequired", false) || Build.VERSION.SDK_INT >= 31
+        }.forEach { item ->
+            val target = pending(context, value, item) ?: return@forEach
+            val action = NotificationCompat.Action.Builder(0, item.optString("title"), target)
+                .setAuthenticationRequired(item.optBoolean("authenticationRequired", false))
+            if (item.optBoolean("destructive", false)) action.setSemanticAction(NotificationCompat.Action.SEMANTIC_ACTION_DELETE)
+            item.optJSONObject("textInput")?.let { input ->
+                action.addRemoteInput(androidx.core.app.RemoteInput.Builder(REPLY)
+                    .setLabel(input.optString("placeholder", item.optString("title"))).build())
+                action.setAllowGeneratedReplies(true)
+            }
+            notification.addAction(action.build())
+        }
+        val dismissed = Intent(context, CraftNativeNotificationReceiver::class.java)
+            .setAction("craft.notification.dismiss:" + android.net.Uri.encode(id)).putExtra("craft.dismissedId", id).putExtra("craft.dismissedThread", thread)
+        notification.setDeleteIntent(android.app.PendingIntent.getBroadcast(context, 0, dismissed,
+            android.app.PendingIntent.FLAG_UPDATE_CURRENT or android.app.PendingIntent.FLAG_IMMUTABLE))
+        val groups = notificationGroups(context)
+        val previousThread = groups.getString("notification:$id", null)
+        val edit = groups.edit()
+        if (thread.isEmpty()) edit.remove("notification:$id") else edit.putString("notification:$id", thread)
+        check(edit.commit()) { "Could not save notification group" }
+        manager.notify(id, 0, notification.build())
+        if (thread.isNotEmpty()) {
+            manager.notify("craft.group:$thread", 1, NotificationCompat.Builder(context, channelId)
+                .setSmallIcon(R.drawable.craft_notification_icon)
+                .setContentTitle(context.applicationInfo.loadLabel(context.packageManager))
+                .setContentIntent(pending(context, value, null)).setGroup(thread).setGroupSummary(true).setAutoCancel(true).build())
+        }
+        if (previousThread != thread) clearEmptyGroup(context, previousThread)
     }
 }

package/templates/CraftNativeServices.kt.template

@@ -119,6 +119,8 @@ internal class CraftNativeServices(
         if (config.optBoolean("enableAudioRecording")) add("audioRecording")
         // Videos kept on the phone for offline (CraftNativeMedia).
         add("media")
+        add("media-cache-key")
+        add("media-remove")
         if (config.optBoolean("enableShare")) add("share")
         if (config.optBoolean("enablePushNotifications")) add("push")
         if (health != null || healthServices != null) {
@@ -139,7 +141,8 @@ internal class CraftNativeServices(
             if (CraftNative.supportsRecordingIntentIdentity()) add("locationRecordingIntentIdentity")
             if (CraftNative.supportsRecordingPowerMode()) add("locationRecordingPowerMode")
         }
-        if (config.optJSONObject("backgroundRefresh")?.optBoolean("enabled") == true || config.optBoolean("enablePushNotifications")) add("background")
+        if (config.optJSONObject("backgroundRefresh")?.optBoolean("enabled") == true || config.optBoolean("enablePushNotifications") ||
+            (config.optJSONArray("notificationCategories")?.length() ?: 0) > 0) add("background")
         // A Bluetooth heart-rate strap (CraftHeartRate.kt), the app's own
         // service: one connection and one recording for every screen.
         if (heartRateEnabled) addAll(listOf("heartRate", "heartRateRecordingOwnership", "heartRateRecordingIntentIdentity"))
@@ -179,14 +182,29 @@ internal class CraftNativeServices(
                 "Location" -> location(method, args, done)
                 "HeartRate" -> heartRate(method, args, done)
                 "Media" -> when (method) {
-                    "keep" -> CraftNativeMedia.keep(context, args.optString(0), args.optJSONObject(1)?.optJSONObject("headers") ?: JSONObject(), args.optJSONObject(1)?.optBoolean("cellular", true) ?: true, done)
-                    "path" -> done(success(CraftNativeMedia.local(context, args.optString(0))?.absolutePath ?: JSONObject.NULL))
+                    "keep" -> CraftNativeMedia.keep(context, args.optString(0), args.optJSONObject(1)?.optJSONObject("headers") ?: JSONObject(), args.optJSONObject(1)?.optBoolean("cellular", true) ?: true, cacheKey = args.optJSONObject(1)?.optString("cacheKey"), done = done)
+                    "path" -> done(success(CraftNativeMedia.local(context, CraftNativeMedia.identity(args.optString(0), args.optJSONObject(1)))?.absolutePath ?: JSONObject.NULL))
                     "prune" -> {
                         val keep = args.optJSONArray(0) ?: JSONArray()
-                        done(success(CraftNativeMedia.prune(context, (0 until keep.length()).map { keep.optString(it) })))
+                        done(success(CraftNativeMedia.prune(context, (0 until keep.length()).map { index -> keep.optJSONObject(index)?.let { CraftNativeMedia.identity(it.optString("url"), it) } ?: keep.optString(index) })))
                     }
                     "usage" -> done(success(CraftNativeMedia.usage(context)))
-                    "clear" -> done(success(CraftNativeMedia.clear(context)))
+                    "clear" -> {
+                        try { done(success(CraftNativeMedia.clear(context))) }
+                        catch (error: java.io.IOException) { done(failure("IO_ERROR", error.message ?: "The media cache could not be cleared")) }
+                    }
+                    "remove" -> {
+                        val options = args.optJSONObject(1)
+                        val key = options?.opt("cacheKey")
+                        if (key != null && key != JSONObject.NULL && (key !is String || key.isEmpty() || key.toByteArray().size > 1024)) {
+                            done(failure("INVALID_ARGUMENT", "media.remove cacheKey must be a nonempty string of at most 1024 bytes"))
+                        } else {
+                            val address = CraftNativeMedia.identity(args.optString(0), options)
+                            if (address.isBlank()) done(failure("INVALID_ARGUMENT", "media.remove needs a source or cache key"))
+                            else try { done(success(CraftNativeMedia.remove(context, address))) }
+                            catch (error: java.io.IOException) { done(failure("IO_ERROR", error.message ?: "The media copy could not be removed")) }
+                        }
+                    }
                     else -> done(failure("UNKNOWN_ACTION", "Unsupported Media method"))
                 }
                 "Background" -> {