@tokamakdev/plugin-notifications 0.1.0-beta.50

package/android/Push.kt

@@ -0,0 +1,87 @@
+package com.tokamak.plugins.notifications
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.pm.PackageManager
+import android.database.Cursor
+import android.net.Uri
+import com.google.firebase.FirebaseApp
+import com.google.firebase.FirebaseOptions
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import com.tokamak.runtime.tokamakHost
+import java.util.UUID
+import org.json.JSONObject
+
+private const val APPLICATION_ID = "com.tokamak.notifications.fcm.application-id"
+private const val PROJECT_ID = "com.tokamak.notifications.fcm.project-id"
+private const val API_KEY = "com.tokamak.notifications.fcm.api-key"
+
+/**
+ * Starts Firebase from the Firebase project values in the app's manifest when the process
+ * starts, before FCM delivers anything. FCM takes the sender ID from the application ID.
+ */
+class TokamakFirebaseInitializer : ContentProvider() {
+    override fun onCreate(): Boolean {
+        val context = context ?: return false
+        val metadata =
+            context.packageManager
+                .getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
+                .metaData ?: return true
+        val applicationId = metadata.getString(APPLICATION_ID)
+        val projectId = metadata.getString(PROJECT_ID)
+        val apiKey = metadata.getString(API_KEY)
+        if (applicationId == null || projectId == null || apiKey == null) return true
+        val options =
+            FirebaseOptions.Builder()
+                .setApplicationId(applicationId)
+                .setProjectId(projectId)
+                .setApiKey(apiKey)
+                .build()
+        FirebaseApp.initializeApp(context, options)
+        return true
+    }
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String>?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+        sortOrder: String?,
+    ): Cursor? = null
+
+    override fun getType(uri: Uri): String? = null
+
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+    ): Int = 0
+}
+
+/** Receives FCM tokens and messages, including when FCM starts the app to deliver one. */
+class TokamakPushService : FirebaseMessagingService() {
+    private val plugin: TokamakNotificationsPlugin?
+        get() = tokamakHost.plugin("notifications") as? TokamakNotificationsPlugin
+
+    override fun onNewToken(token: String) {
+        plugin?.onNewToken(token)
+    }
+
+    override fun onMessageReceived(message: RemoteMessage) {
+        plugin?.onMessageReceived(message(message), message.notification != null)
+    }
+
+    /** The page's view of an FCM message: its data is the message's data map. */
+    private fun message(message: RemoteMessage): JSONObject =
+        JSONObject()
+            .put("id", message.messageId ?: UUID.randomUUID().toString())
+            .put("title", message.notification?.title ?: JSONObject.NULL)
+            .put("body", message.notification?.body ?: JSONObject.NULL)
+            .put("data", JSONObject(message.data as Map<*, *>))
+}

package/android/Schedule.kt

@@ -0,0 +1,77 @@
+package com.tokamak.plugins.notifications
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import org.json.JSONObject
+
+private const val PREFERENCES = "tokamak.notifications.schedule"
+private const val ID_EXTRA = "com.tokamak.notifications.scheduled"
+
+/**
+ * Scheduled notifications, stored so they survive restarts, each with an inexact alarm
+ * allowed while idle. Use it on the main thread.
+ */
+internal class Schedule(private val context: Context) {
+    private val preferences = context.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE)
+    private val alarms = context.getSystemService(AlarmManager::class.java)
+
+    fun all(): List<Content> =
+        preferences.all.values.map { Content.fromJson(JSONObject(it as String)) }
+
+    fun add(content: Content) {
+        preferences.edit().putString(content.id, content.toJson().toString()).apply()
+        arm(content)
+    }
+
+    fun remove(id: String) {
+        preferences.edit().remove(id).apply()
+        alarms.cancel(alarm(id))
+    }
+
+    /** Removes and returns the notification scheduled as [id]. */
+    fun take(id: String): Content? {
+        val stored = preferences.getString(id, null) ?: return null
+        preferences.edit().remove(id).apply()
+        return Content.fromJson(JSONObject(stored))
+    }
+
+    /** Sets an alarm for every stored notification, as a restart clears them. */
+    fun armAll() = all().forEach(::arm)
+
+    private fun arm(content: Content) {
+        alarms.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, content.at ?: 0, alarm(content.id))
+    }
+
+    private fun alarm(id: String): PendingIntent =
+        PendingIntent.getBroadcast(
+            context,
+            0,
+            Intent(context, TokamakAlarmReceiver::class.java).setIdentifier(id).putExtra(ID_EXTRA, id),
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+        )
+
+    companion object {
+        fun scheduledId(intent: Intent): String? = intent.getStringExtra(ID_EXTRA)
+    }
+}
+
+/** Shows a scheduled notification when its alarm fires. */
+class TokamakAlarmReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val id = Schedule.scheduledId(intent) ?: return
+        val content = Schedule(context).take(id) ?: return
+        Notifier(context).post(content, "local")
+    }
+}
+
+/** Restores the schedule's alarms after the device restarts or the app updates. */
+class TokamakBootReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action == Intent.ACTION_BOOT_COMPLETED || intent.action == Intent.ACTION_MY_PACKAGE_REPLACED) {
+            Schedule(context).armAll()
+        }
+    }
+}

package/apple/Info.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>remote-notification</string>
+	</array>
+</dict>
+</plist>

package/apple/NotificationContent.swift

@@ -0,0 +1,151 @@
+import Foundation
+import UserNotifications
+
+/// Keys the plugin stores in a local notification's `userInfo`.
+private let dataKey = "tokamak.data"
+private let atKey = "tokamak.at"
+
+/// A notification the page asked to show or schedule.
+struct TokamakNotificationRequest {
+  let id: String
+  let title: String
+  let body: String?
+  let data: [String: Any]
+  /// Milliseconds since the epoch; nil to show now.
+  let at: Double?
+
+  init(_ arguments: Any, scheduled: Bool) throws(TokamakPluginError) {
+    let arguments = arguments as? [String: Any] ?? [:]
+    guard let id = arguments["id"] as? String, !id.isEmpty else {
+      throw typeError("id must be a non-empty string")
+    }
+    guard let title = arguments["title"] as? String else {
+      throw typeError("title must be a string")
+    }
+    self.id = id
+    self.title = title
+    body = arguments["body"] as? String
+    data = arguments["data"] as? [String: Any] ?? [:]
+    guard scheduled else {
+      at = nil
+      return
+    }
+    guard let at = (arguments["at"] as? NSNumber)?.doubleValue, at.isFinite else {
+      throw typeError("at must be a number of milliseconds since the epoch")
+    }
+    self.at = at
+  }
+
+  /// The system request, due now when `at` is absent or has passed.
+  func request() throws(TokamakPluginError) -> UNNotificationRequest {
+    let content = UNMutableNotificationContent()
+    content.title = title
+    content.body = body ?? ""
+    content.sound = .default
+    var userInfo: [String: Any] = [dataKey: try json(data)]
+    var trigger: UNNotificationTrigger?
+    if let at, at > Date().timeIntervalSince1970 * 1000 {
+      userInfo[atKey] = at
+      trigger = UNCalendarNotificationTrigger(dateMatching: components(at), repeats: false)
+    }
+    content.userInfo = userInfo
+    return UNNotificationRequest(identifier: id, content: content, trigger: trigger)
+  }
+
+  private func components(_ at: Double) -> DateComponents {
+    var calendar = Calendar(identifier: .gregorian)
+    calendar.timeZone = TimeZone(identifier: "UTC")!
+    return calendar.dateComponents(
+      [.calendar, .timeZone, .year, .month, .day, .hour, .minute, .second],
+      from: Date(timeIntervalSince1970: at / 1000)
+    )
+  }
+}
+
+/// The page's view of a notification: its content, and whether it came from a
+/// push message.
+struct TokamakNotificationFields {
+  let id: String
+  let title: String?
+  let body: String?
+  let data: [String: Any]
+  let isPush: Bool
+
+  init(_ notification: UNNotification) {
+    let content = notification.request.content
+    id = notification.request.identifier
+    title = content.title.isEmpty ? nil : content.title
+    body = content.body.isEmpty ? nil : content.body
+    (data, isPush) = Self.data(content.userInfo)
+  }
+
+  /// A push message delivered to the app without a notification.
+  init(remoteNotification userInfo: [AnyHashable: Any]) {
+    let alert = (userInfo["aps"] as? [String: Any])?["alert"]
+    id = UUID().uuidString
+    title = (alert as? [String: Any])?["title"] as? String
+    body = (alert as? [String: Any])?["body"] as? String ?? alert as? String
+    (data, isPush) = Self.data(userInfo)
+  }
+
+  /// A push message's data is every top-level key but `aps`; a local
+  /// notification's is the data the page gave it.
+  static func data(_ userInfo: [AnyHashable: Any]) -> ([String: Any], isPush: Bool) {
+    if userInfo["aps"] != nil {
+      var data: [String: Any] = [:]
+      for case (let key as String, let value) in userInfo where key != "aps" {
+        data[key] = value
+      }
+      return (data, true)
+    }
+    let json = (userInfo[dataKey] as? String)?.data(using: .utf8) ?? Data()
+    return ((try? JSONSerialization.jsonObject(with: json)) as? [String: Any] ?? [:], false)
+  }
+
+  var message: [String: Any] {
+    ["id": id, "title": title ?? NSNull(), "body": body ?? NSNull(), "data": data]
+  }
+
+  var opened: [String: Any] {
+    message.merging(["source": isPush ? "push" : "local"]) { current, _ in current }
+  }
+
+  var content: [String: Any] {
+    var content: [String: Any] = ["id": id, "title": title ?? "", "data": data]
+    content["body"] = body
+    return content
+  }
+}
+
+extension UNNotificationRequest {
+  /// The page's view of a pending request.
+  var scheduled: [String: Any] {
+    let at =
+      content.userInfo[atKey] as? Double
+      ?? (trigger as? UNCalendarNotificationTrigger)?.nextTriggerDate().map {
+        $0.timeIntervalSince1970 * 1000
+      } ?? 0
+    var scheduled: [String: Any] = [
+      "id": identifier,
+      "title": content.title,
+      "data": TokamakNotificationFields.data(content.userInfo).0,
+      "at": at,
+    ]
+    scheduled["body"] = content.body.isEmpty ? nil : content.body
+    return scheduled
+  }
+}
+
+private func json(_ value: [String: Any]) throws(TokamakPluginError) -> String {
+  guard
+    JSONSerialization.isValidJSONObject(value),
+    let data = try? JSONSerialization.data(withJSONObject: value)
+  else {
+    throw typeError("data must be a JSON object")
+  }
+  return String(decoding: data, as: UTF8.self)
+}
+
+private func typeError(_ message: String) -> TokamakPluginError {
+  TokamakPluginError(name: "TypeError", message: message)
+}