akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/local-notifications/android/LocalNotificationsPlugin.kt

@@ -0,0 +1,248 @@
+package com.akanjs.plugins.localnotifications
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import com.akanjs.runtime.AkanNativeCall
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePermission
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeVoidReply
+import java.lang.ref.WeakReference
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+/**
+ * Local notifications: NotificationManager + AlarmManager (LocalNotifications.kt), a manifest
+ * receiver for alarms and boots (LocalNotificationReceiver.kt). The page sends `at` as epoch ms.
+ * - POST_NOTIFICATIONS is a runtime permission (API 33+). schedule() rejects PERMISSION_DENIED
+ *   without it, like iOS; Capacitor rejects when areNotificationsEnabled() is false
+ *   (capacitor-plugins/local-notifications/android/.../LocalNotificationManager.java:132-137).
+ * - Tap: a PendingIntent to the launcher activity. A cold start brings it in the creating intent,
+ *   a running app through onNewIntent (launchMode singleTask), plugins.md C3. It is kept until the
+ *   page listens for "action" (C2), like capacitor-plugins/app keeps deep links.
+ * - "received" is sent when a notification is shown while the app is in the foreground (iOS
+ *   willPresent is foreground-only too); Capacitor also sends it from the background.
+ * Arguments arrive decoded by the generated LocalNotificationsPluginSpec (PL-10), except schedule's:
+ * its `at` is `string | number` in the spec, which the bindings cannot type, so it keeps the AkanNativeCall.
+ */
+class LocalNotificationsPlugin(private val context: AkanNativePluginContext) : LocalNotificationsPluginSpec {
+    private val app: Context = context.activity.applicationContext
+    private val manager: NotificationManager = app.getSystemService(NotificationManager::class.java)
+    private val events = LocalNotificationsEvents(context)
+    private var actionListening = false
+    private var receivedListening = false
+
+    init {
+        instance = WeakReference(this)
+        // What a boot would do: alarms are gone after a force stop, and due items were missed.
+        // Created reflectively, as the system creates it: R8 then keeps the no-argument constructor.
+        // The release build's R8 does not read the manifest, and a plain LocalNotificationReceiver()
+        // call got the constructor inlined and removed ("Unable to instantiate receiver", verified).
+        LocalNotificationReceiver::class.java.getDeclaredConstructor().newInstance()
+            .onReceive(app, Intent(LocalNotifications.ACTION_RESTORE))
+        tapOf(context.activity.intent)?.let(pendingActions::add)
+    }
+
+    override fun cancel(args: LocalNotificationsCancelArgs, reply: AkanNativeVoidReply) {
+        val ids = ids(args.ids, reply) ?: return
+        LocalNotifications.cancel(app, ids)
+        reply.resolve()
+    }
+
+    override fun getPending(reply: AkanNativeReply<LocalNotificationsGetPendingResult>) =
+        reply.resolve(LocalNotificationsGetPendingResult(notifications = LocalNotifications.pending(app).map(::pending)))
+
+    override fun getDelivered(reply: AkanNativeReply<LocalNotificationsGetDeliveredResult>) =
+        reply.resolve(LocalNotificationsGetDeliveredResult(notifications = delivered()))
+
+    override fun removeDelivered(args: LocalNotificationsRemoveDeliveredArgs, reply: AkanNativeVoidReply) {
+        val ids = ids(args.ids, reply) ?: return
+        for (id in ids) manager.cancel(id)
+        reply.resolve()
+    }
+
+    override fun removeAllDelivered(reply: AkanNativeVoidReply) {
+        for (sbn in manager.activeNotifications) if (sbn.notification.extras.getBoolean(LocalNotifications.EXTRA_MARKER)) manager.cancel(sbn.tag, sbn.id)
+        reply.resolve()
+    }
+
+    override fun checkPermission(reply: AkanNativeReply<LocalNotificationsCheckPermissionResult>) =
+        reply.resolve(LocalNotificationsCheckPermissionResult(display = display()))
+
+    override fun requestPermission(args: LocalNotificationsRequestPermissionArgs, reply: AkanNativeReply<LocalNotificationsRequestPermissionResult>) {
+        val state = display()
+        // "denied" is permanent (C1): the system would not show the prompt again. Below API 33 there is
+        // no runtime permission to ask for: asking would be refused at once without a dialog, and the
+        // refusal would stay in the permission history after an upgrade to 13.
+        if (Build.VERSION.SDK_INT < 33 || state == LocalNotificationsPermissionState.GRANTED || state == LocalNotificationsPermissionState.DENIED) {
+            return reply.resolve(LocalNotificationsRequestPermissionResult(display = state))
+        }
+        context.requestPermissions(arrayOf(Manifest.permission.POST_NOTIFICATIONS)) {
+            reply.resolve(LocalNotificationsRequestPermissionResult(display = display()))
+        }
+    }
+
+    /** granted | denied | prompt | prompt-with-rationale. Also "denied" when blocked in the settings. */
+    private fun display(): LocalNotificationsPermissionState {
+        if (manager.areNotificationsEnabled()) return LocalNotificationsPermissionState.GRANTED
+        if (Build.VERSION.SDK_INT < 33) return LocalNotificationsPermissionState.DENIED // turned off in the settings
+        val state = context.permissionState(Manifest.permission.POST_NOTIFICATIONS)
+        if (state == AkanNativePermission.GRANTED) return LocalNotificationsPermissionState.DENIED
+        return LocalNotificationsPermissionState.entries.first { it.json == state } // one of the four AkanNativePermission values
+    }
+
+    /** Untyped in the spec (`at: string | number`); the page has already turned `at` into epoch ms. */
+    override fun schedule(call: AkanNativeCall) {
+        val list = call.args.optJSONArray("notifications")
+        if (list == null || list.length() == 0) return call.reject(AkanNativeErrorCode.INVALID_ARGS, "schedule: notifications must be a non-empty array")
+        val items = ArrayList<LocalNotifications.Item>()
+        for (i in 0 until list.length()) {
+            val raw = list.optJSONObject(i) ?: return call.reject(AkanNativeErrorCode.INVALID_ARGS, "notifications[$i] must be an object")
+            val id = int32(raw.opt("id"))
+            val title = raw.opt("title") as? String
+            val at = (raw.opt("at") as? Number)?.toLong()
+            if (id == null || title == null || at == null) return call.reject(AkanNativeErrorCode.INVALID_ARGS, "notifications[$i] needs id, title and at (epoch ms)")
+            val every = raw.opt("every") as? String
+            if (every != null && every !in listOf("minute", "hour", "day", "week")) return call.reject(AkanNativeErrorCode.INVALID_ARGS, "notifications[$i].every must be minute, hour, day or week")
+            val channelId = raw.opt("channelId") as? String
+            if (channelId != null && manager.getNotificationChannel(channelId) == null) {
+                return call.reject(AkanNativeErrorCode.INVALID_ARGS, "notifications[$i]: no channel \"$channelId\" (createChannel first)")
+            }
+            items.add(LocalNotifications.Item(id, title, raw.opt("body") as? String ?: "", at, every, channelId, raw.optJSONObject("data")?.toString()))
+        }
+        if (!manager.areNotificationsEnabled()) return call.reject(AkanNativeErrorCode.PERMISSION_DENIED, "notification permission is not granted (call requestPermission)")
+        LocalNotifications.schedule(app, items)
+        call.resolve(JSONObject().put("ids", JSONArray(items.map { it.id })))
+    }
+
+    private fun pending(item: LocalNotifications.Item) = LocalNotificationsPendingNotification(
+        id = item.id.toDouble(),
+        title = item.title,
+        body = item.body,
+        at = item.at.toDouble(),
+        every = item.every?.let { every -> LocalNotificationsRepeat.entries.firstOrNull { it.json == every } }, // always one: schedule() checks it
+        channelId = item.channelId,
+        data = item.data?.let { dataOf(JSONObject(it)) },
+    )
+
+    private fun delivered(): List<LocalNotificationsDeliveredNotification> {
+        val out = ArrayList<LocalNotificationsDeliveredNotification>()
+        for (sbn in manager.activeNotifications) {
+            val extras = sbn.notification.extras
+            if (!extras.getBoolean(LocalNotifications.EXTRA_MARKER)) continue
+            out.add(
+                LocalNotificationsDeliveredNotification(
+                    id = sbn.id.toDouble(),
+                    title = extras.getCharSequence(android.app.Notification.EXTRA_TITLE)?.toString() ?: "",
+                    body = extras.getCharSequence(android.app.Notification.EXTRA_TEXT)?.toString() ?: "",
+                    at = sbn.postTime.toDouble(),
+                    data = extras.getString(LocalNotifications.EXTRA_DATA)?.let { text -> runCatching { dataOf(JSONObject(text)) }.getOrNull() },
+                ),
+            )
+        }
+        return out
+    }
+
+    override fun createChannel(args: LocalNotificationsChannelOptions, reply: AkanNativeVoidReply) {
+        if (args.id.isEmpty() || args.name.isEmpty()) return reply.reject(AkanNativeErrorCode.INVALID_ARGS, "createChannel: id and name are required")
+        val importance = when (args.importance ?: LocalNotificationsImportance.DEFAULT) {
+            LocalNotificationsImportance.MIN -> NotificationManager.IMPORTANCE_MIN
+            LocalNotificationsImportance.LOW -> NotificationManager.IMPORTANCE_LOW
+            LocalNotificationsImportance.DEFAULT -> NotificationManager.IMPORTANCE_DEFAULT
+            LocalNotificationsImportance.HIGH -> NotificationManager.IMPORTANCE_HIGH
+        }
+        // Creating an existing channel only updates its name and description: the user owns the rest.
+        manager.createNotificationChannel(NotificationChannel(args.id, args.name, importance).apply { description = args.description })
+        reply.resolve()
+    }
+
+    // ------------------------------------------------------------ events
+
+    override fun onNewIntent(intent: Intent) {
+        val event = tapOf(intent) ?: return
+        if (actionListening) events.action(event) else pendingActions.add(event)
+    }
+
+    override fun startListening(event: String) {
+        when (event) {
+            "action" -> {
+                actionListening = true
+                for (data in pendingActions) events.action(data)
+                pendingActions.clear()
+            }
+            "received" -> receivedListening = true
+        }
+    }
+
+    override fun stopListening(event: String) {
+        when (event) {
+            "action" -> actionListening = false
+            "received" -> receivedListening = false
+        }
+    }
+
+    override fun destroy() {
+        if (instance?.get() === this) instance = null
+    }
+
+    /** The "action" event of a notification tap intent, once per delivery. */
+    private fun tapOf(intent: Intent?): LocalNotificationsNotificationEvent? {
+        val text = intent?.getStringExtra(LocalNotifications.EXTRA_TAP) ?: return null
+        // Reopening from Recents after the process died replays the intent that started the task.
+        if (intent.flags and Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY != 0) return null
+        // Only a tap of a notification this app posted, once (LocalNotifications.EXTRA_TOKEN).
+        val token = intent.getStringExtra(LocalNotifications.EXTRA_TOKEN) ?: return null
+        if (!LocalNotifications.redeemToken(context.activity, token)) return null
+        return try {
+            notificationEvent(JSONObject(text))
+        } catch (e: JSONException) {
+            null
+        }
+    }
+
+    /** The ids as notification ids, or null (rejected) unless every one is a 32-bit integer. */
+    private fun ids(values: List<Double>, reply: AkanNativeReply<*>): List<Int>? {
+        val ids = values.map { int32(it) }
+        if (ids.any { it == null }) {
+            reply.reject(AkanNativeErrorCode.INVALID_ARGS, "${reply.call.method}: ids must be an array of 32-bit integers")
+            return null
+        }
+        return ids.filterNotNull()
+    }
+
+    private fun int32(value: Any?): Int? {
+        if (value !is Number) return null
+        val d = value.toDouble()
+        return if (d == Math.rint(d) && d >= Int.MIN_VALUE && d <= Int.MAX_VALUE) d.toInt() else null
+    }
+
+    companion object {
+        /** Taps before the page listened (C2), the process's: an activity made again keeps them. Main thread only. */
+        private val pendingActions = ArrayList<LocalNotificationsNotificationEvent>()
+
+        private var instance: WeakReference<LocalNotificationsPlugin>? = null
+
+        /** Called on the main thread after a notification was posted, from the plugin or the receiver. */
+        internal fun delivered(context: Context, item: LocalNotifications.Item) {
+            val plugin = instance?.get() ?: return
+            if (plugin.receivedListening && LocalNotifications.isForeground()) plugin.events.received(notificationEvent(item.event()))
+        }
+
+        /** The JSON of LocalNotifications.Item.event() (also the tap intent's), typed. */
+        private fun notificationEvent(json: JSONObject) = LocalNotificationsNotificationEvent(
+            id = json.getDouble("id"),
+            title = json.getString("title"),
+            body = json.getString("body"),
+            data = json.optJSONObject("data")?.let(::dataOf),
+        )
+
+        /** A data object as the generated Map; values stay org.json values (JSONObject.NULL for null), written back as they are. */
+        private fun dataOf(json: JSONObject): Map<String, Any> = json.keys().asSequence().associateWith { json.get(it) }
+    }
+}

package/vendor/@akanjs/native/plugins/local-notifications/ios/LocalNotificationsPlugin.swift

@@ -0,0 +1,279 @@
+import UIKit
+import UserNotifications
+
+/// UNUserNotificationCenter. The page sends `at` as epoch ms and `every` (schedule.ts), so no date
+/// parsing happens here.
+/// - Triggers: a one-shot is a UNTimeIntervalNotificationTrigger (an absolute instant, like Android's
+///   RTC alarm), none when due. `every` is a repeating UNCalendarNotificationTrigger on the components
+///   of `at` (second / minute+second / time of day / weekday+time), so day and week keep the local time
+///   across DST. capacitor-plugins/local-notifications/ios/.../LocalNotificationsPlugin.swift:310-324
+///   repeats a time-interval trigger whose interval is the time until `at` instead.
+/// - The target time is kept in userInfo: UNTimeIntervalNotificationTrigger.nextTriggerDate() counts
+///   from the moment it is asked, not from when the request was added (checked on the simulator).
+/// - Everything the events need is in userInfo (data as JSON text: userInfo must be a property list,
+///   and JSON null is not). tauri-plugins-workspace/plugins/notification/ios/Sources/NotificationHandler.swift:79
+///   force-unwraps an in-memory map instead, which is empty after a relaunch.
+/// - schedule() waits for every add() before resolving; Capacitor resolves first and may reject
+///   afterwards (LocalNotificationsPlugin.swift:100-118).
+/// - At most 64 requests stay pending per app; iOS keeps the ones that fire soonest.
+///
+/// Delegate: UNUserNotificationCenter has one delegate, which the shell owns from launch on
+/// (AkanNativeNotifications, plugins.md C5, like Capacitor's NotificationRouter.swift). This plugin
+/// registers a handler for the notifications it posted. Taps the page does not listen for yet (a
+/// cold start, a window that ended) stay with the shell until it does (plugins.md C2).
+///
+/// Arguments arrive decoded by the generated LocalNotificationsPluginSpec (PL-10), except schedule's:
+/// its `at` is `string | number` in the spec, which the bindings cannot type, so it keeps the AkanNativeCall.
+final class LocalNotificationsPlugin: NSObject, LocalNotificationsPluginSpec {
+    static let id = "local-notifications"
+
+    nonisolated private static let marker = "akan-native.ln"
+    nonisolated private static let dataKey = "akan-native.data"
+    nonisolated private static let everyKey = "akan-native.every"
+    nonisolated private static let atKey = "akan-native.at"
+
+    private let events: LocalNotificationsEvents
+    private var actionListening = false
+
+    private struct Item {
+        let id: Int32
+        let title: String
+        let body: String
+        let at: Double
+        let every: String?
+        let data: String?
+    }
+
+    init(context: AkanNativePluginContext) {
+        events = LocalNotificationsEvents(context)
+        super.init()
+        AkanNativeNotifications.shared.register(Self.id, owner: context.owner, AkanNativeNotifications.Handler(
+            claims: { Self.isOurs($0) },
+            // Foreground delivery: show it like in the background and tell the page.
+            willPresent: { [weak self] notification in
+                self?.events.received(Self.event(notification.request))
+                return [.banner, .list, .sound]
+            },
+            // Tap on the notification (the default action). Kept by the shell until the page listens.
+            didReceive: { [weak self] response in
+                guard let self, self.actionListening else { return false }
+                if response.actionIdentifier == UNNotificationDefaultActionIdentifier { self.events.action(Self.event(response.notification.request)) }
+                return true
+            }
+        ))
+    }
+
+    func cancel(_ args: LocalNotificationsCancelArgs, _ reply: AkanNativeReply<Void>) {
+        guard let ids = Self.ids(args.ids, reply) else { return }
+        UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: ids)
+        reply.resolve()
+    }
+
+    func removeDelivered(_ args: LocalNotificationsRemoveDeliveredArgs, _ reply: AkanNativeReply<Void>) {
+        guard let ids = Self.ids(args.ids, reply) else { return }
+        UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: ids)
+        reply.resolve()
+    }
+
+    func getPending(_ reply: AkanNativeReply<LocalNotificationsGetPendingResult>) {
+        Task {
+            let requests = await UNUserNotificationCenter.current().pendingNotificationRequests()
+            let list = requests.filter(Self.isOurs).map(Self.pending).sorted { $0.at < $1.at }
+            reply.resolve(LocalNotificationsGetPendingResult(notifications: list))
+        }
+    }
+
+    func getDelivered(_ reply: AkanNativeReply<LocalNotificationsGetDeliveredResult>) {
+        Task {
+            let delivered = await UNUserNotificationCenter.current().deliveredNotifications()
+            reply.resolve(LocalNotificationsGetDeliveredResult(notifications: delivered.filter { Self.isOurs($0.request) }.map(Self.delivered)))
+        }
+    }
+
+    func removeAllDelivered(_ reply: AkanNativeReply<Void>) {
+        Task {
+            let center = UNUserNotificationCenter.current()
+            let ours = await center.deliveredNotifications().filter { Self.isOurs($0.request) }
+            center.removeDeliveredNotifications(withIdentifiers: ours.map(\.request.identifier))
+            reply.resolve()
+        }
+    }
+
+    func createChannel(_ args: LocalNotificationsChannelOptions, _ reply: AkanNativeReply<Void>) {
+        reply.resolve() // Android only
+    }
+
+    func checkPermission(_ reply: AkanNativeReply<LocalNotificationsCheckPermissionResult>) {
+        Task {
+            let status = await UNUserNotificationCenter.current().notificationSettings().authorizationStatus
+            reply.resolve(LocalNotificationsCheckPermissionResult(display: Self.state(status)))
+        }
+    }
+
+    // MARK: schedule
+
+    /// Untyped in the spec (`at: string | number`); the page has already turned `at` into epoch ms.
+    func schedule(_ call: AkanNativeCall) {
+        guard let list = call.args["notifications"] as? [[String: Any]], !list.isEmpty else {
+            return call.reject(.invalidArgs, "schedule: notifications must be a non-empty array")
+        }
+        var items: [Item] = []
+        for (i, raw) in list.enumerated() {
+            guard let id = Self.int32(raw["id"]), let title = raw["title"] as? String,
+                  let at = (raw["at"] as? NSNumber)?.doubleValue, at.isFinite else {
+                return call.reject(.invalidArgs, "notifications[\(i)] needs id, title and at (epoch ms)")
+            }
+            let every = raw["every"] as? String
+            if let every, !["minute", "hour", "day", "week"].contains(every) {
+                return call.reject(.invalidArgs, "notifications[\(i)].every must be minute, hour, day or week")
+            }
+            var data: String?
+            if let object = raw["data"] as? [String: Any] {
+                guard let text = AkanNativeBridge.encode(object) else { return call.reject(.invalidArgs, "notifications[\(i)].data must be JSON") }
+                data = text
+            }
+            items.append(Item(id: id, title: title, body: raw["body"] as? String ?? "", at: at, every: every, data: data))
+        }
+        let requests = items.map(Self.request)
+        let ids = items.map { Int($0.id) }
+        Task {
+            let center = UNUserNotificationCenter.current()
+            // Checked first so every platform answers the same way without the permission.
+            let status = await center.notificationSettings().authorizationStatus
+            guard Self.state(status) == .granted else {
+                return call.reject(.permissionDenied, "notification permission is not granted (call requestPermission)")
+            }
+            do {
+                for request in requests { try await center.add(request) }
+                call.resolve(["ids": ids])
+            } catch {
+                let code = (error as? UNError)?.code == .notificationsNotAllowed ? AkanNativeErrorCode.permissionDenied : .internalError
+                call.reject(code, "scheduling failed: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    private static func request(_ item: Item) -> UNNotificationRequest {
+        let content = UNMutableNotificationContent()
+        content.title = item.title
+        content.body = item.body
+        content.sound = .default
+        var info: [String: Any] = [marker: 1, atKey: item.at]
+        if let data = item.data { info[dataKey] = data }
+        if let every = item.every { info[everyKey] = every }
+        content.userInfo = info
+
+        let date = Date(timeIntervalSince1970: item.at / 1000)
+        let trigger: UNNotificationTrigger?
+        if let every = item.every {
+            let units: Set<Calendar.Component> = switch every {
+            case "minute": [.second]
+            case "hour": [.minute, .second]
+            case "day": [.hour, .minute, .second]
+            default: [.weekday, .hour, .minute, .second]
+            }
+            trigger = UNCalendarNotificationTrigger(dateMatching: Calendar.current.dateComponents(units, from: date), repeats: true)
+        } else {
+            let interval = date.timeIntervalSinceNow
+            trigger = interval >= 1 ? UNTimeIntervalNotificationTrigger(timeInterval: interval, repeats: false) : nil
+        }
+        return UNNotificationRequest(identifier: String(item.id), content: content, trigger: trigger)
+    }
+
+    // MARK: permission
+
+    /// provisional: quiet delivery granted without a prompt (UNAuthorizationOptions.provisional).
+    /// A provisional app may still ask for the full permission, which shows the prompt.
+    func requestPermission(_ args: LocalNotificationsRequestPermissionArgs, _ reply: AkanNativeReply<LocalNotificationsRequestPermissionResult>) {
+        let provisional = args.provisional ?? false
+        Task {
+            let center = UNUserNotificationCenter.current()
+            let status = await center.notificationSettings().authorizationStatus
+            if status == .notDetermined || (status == .provisional && !provisional) {
+                do {
+                    var options: UNAuthorizationOptions = [.alert, .sound, .badge]
+                    if provisional { options.insert(.provisional) }
+                    _ = try await center.requestAuthorization(options: options)
+                } catch {
+                    return reply.reject(.internalError, "requestAuthorization failed: \(error.localizedDescription)")
+                }
+            }
+            reply.resolve(LocalNotificationsRequestPermissionResult(display: Self.state(await center.notificationSettings().authorizationStatus)))
+        }
+    }
+
+    nonisolated private static func state(_ status: UNAuthorizationStatus) -> LocalNotificationsPermissionState {
+        switch status {
+        case .authorized, .provisional, .ephemeral: .granted
+        case .denied: .denied
+        default: .prompt
+        }
+    }
+
+    // MARK: events
+
+    func startListening(_ event: String) {
+        guard event == "action" else { return }
+        actionListening = true
+        AkanNativeNotifications.shared.replay(Self.id)
+    }
+
+    func stopListening(_ event: String) {
+        if event == "action" { actionListening = false }
+    }
+
+    // MARK: JSON
+
+    nonisolated private static func isOurs(_ request: UNNotificationRequest) -> Bool {
+        request.content.userInfo[marker] != nil && Int32(request.identifier) != nil
+    }
+
+    nonisolated private static func event(_ request: UNNotificationRequest) -> LocalNotificationsNotificationEvent {
+        var event = LocalNotificationsNotificationEvent(id: Double(Int(request.identifier) ?? 0), title: request.content.title, body: request.content.body)
+        // Always an object: schedule() stores only data objects.
+        if let text = request.content.userInfo[dataKey] as? String, let raw = text.data(using: .utf8),
+           let object = try? JSONSerialization.jsonObject(with: raw) as? [String: Any] {
+            event.data = object
+        }
+        return event
+    }
+
+    nonisolated private static func pending(_ request: UNNotificationRequest) -> LocalNotificationsPendingNotification {
+        let e = event(request)
+        let info = request.content.userInfo
+        var n = LocalNotificationsPendingNotification(id: e.id, title: e.title, body: e.body, at: (info[atKey] as? NSNumber)?.doubleValue ?? 0, data: e.data)
+        if let every = info[everyKey] as? String {
+            n.every = LocalNotificationsRepeat(rawValue: every) // always one: schedule() checks it
+            // Calendar triggers do know their next date (unlike time-interval ones, see above).
+            if let next = (request.trigger as? UNCalendarNotificationTrigger)?.nextTriggerDate() {
+                n.at = (next.timeIntervalSince1970 * 1000).rounded()
+            }
+        }
+        return n
+    }
+
+    nonisolated private static func delivered(_ notification: UNNotification) -> LocalNotificationsDeliveredNotification {
+        let e = event(notification.request)
+        return LocalNotificationsDeliveredNotification(id: e.id, title: e.title, body: e.body, at: (notification.date.timeIntervalSince1970 * 1000).rounded(), data: e.data)
+    }
+
+    nonisolated private static func int32(_ value: Any?) -> Int32? {
+        guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else { return nil }
+        let double = number.doubleValue
+        guard double.rounded() == double, double >= Double(Int32.min), double <= Double(Int32.max) else { return nil }
+        return Int32(double)
+    }
+
+    /// The ids as request identifiers, or nil (rejected) unless every one is a 32-bit integer.
+    private static func ids<T>(_ values: [Double], _ reply: AkanNativeReply<T>) -> [String]? {
+        var ids: [String] = []
+        for value in values {
+            guard let id = Int32(exactly: value) else {
+                reply.reject(.invalidArgs, "\(reply.call.method): ids must be an array of 32-bit integers")
+                return nil
+            }
+            ids.append(String(id))
+        }
+        return ids
+    }
+}

package/vendor/@akanjs/native/plugins/local-notifications/native-plugin.json

@@ -0,0 +1,35 @@
+{
+  "id": "local-notifications",
+  "apiVersion": 1,
+  "methods": [
+    "schedule",
+    "cancel",
+    "getPending",
+    "getDelivered",
+    "removeDelivered",
+    "removeAllDelivered",
+    "createChannel",
+    "checkPermission",
+    "requestPermission"
+  ],
+  "events": ["received", "action"],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "macos": {
+    "infoPlist": {
+      "AkanNativeUserNotifications": true
+    }
+  },
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "LocalNotificationsPlugin",
+    "frameworks": ["UserNotifications"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.localnotifications.LocalNotificationsPlugin",
+    "permissions": ["android.permission.POST_NOTIFICATIONS", "android.permission.RECEIVE_BOOT_COMPLETED"],
+    "applicationXml": "<receiver android:name=\"com.akanjs.plugins.localnotifications.LocalNotificationReceiver\" android:exported=\"false\"><intent-filter><action android:name=\"android.intent.action.BOOT_COMPLETED\" /><action android:name=\"android.intent.action.MY_PACKAGE_REPLACED\" /></intent-filter></receiver>"
+  }
+}