react-native-qpush 0.0.0-stage → 1.0.0

package/ios/Extension/QPushNotificationServiceExtension.swift

@@ -0,0 +1,261 @@
+import Foundation
+import UserNotifications
+
+/// Helper for the Notification Service Extension (NSE) target.
+///
+/// Shipped as the `QPushPushExtension` pod (no React Native dependency, app
+/// extension safe). For each QPush notification it:
+///  - downloads `qpush.image` and attaches it,
+///  - registers a category `qpush_<notification id>` with the `buttons`,
+///  - calls `PUT /notifications/{id}/report_received`,
+/// then hands the content back to the system.
+///
+/// The config (`app_id`, `server_url`, `subscription_id`) is read from the App
+/// Group `group.{main app bundle id}.qpush` written by the main app SDK.
+@objc(QPushNotificationServiceExtension)
+public final class QPushNotificationServiceExtension: NSObject {
+  private static let lock = NSLock()
+  private static var completedRequests: [String] = []
+  private static let downloadTimeout: TimeInterval = 20
+  private static let reportTimeout: TimeInterval = 10
+  private static let maxCategories = 30
+  private static let categoryListKey = "qpush_nse_category_ids"
+
+  /// Call from `didReceive(_:withContentHandler:)`.
+  @objc(didReceiveNotificationExtensionRequest:withMutableNotificationContent:withContentHandler:)
+  public static func didReceiveNotificationExtensionRequest(
+    _ request: UNNotificationRequest,
+    with content: UNMutableNotificationContent,
+    withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void
+  ) {
+    let userInfo = request.content.userInfo
+    guard let qpush = userInfo["qpush"] as? [String: Any],
+          let notificationId = qpush["id"] as? String,
+          !notificationId.isEmpty
+    else {
+      // Not a QPush notification: deliver untouched.
+      deliver(request.identifier, content, contentHandler)
+      return
+    }
+
+    let group = DispatchGroup()
+    let resultLock = NSLock()
+    var attachment: UNNotificationAttachment?
+    var categoryIdentifier: String?
+
+    group.enter()
+    reportReceived(notificationId: notificationId) { group.leave() }
+
+    if let image = qpush["image"] as? String, !image.isEmpty, let url = URL(string: image) {
+      group.enter()
+      downloadAttachment(from: url) { downloaded in
+        resultLock.lock()
+        attachment = downloaded
+        resultLock.unlock()
+        group.leave()
+      }
+    }
+
+    if let buttons = qpush["buttons"] as? [[String: Any]], !buttons.isEmpty {
+      group.enter()
+      registerCategory(identifier: "qpush_\(notificationId)", buttons: buttons) { identifier in
+        resultLock.lock()
+        categoryIdentifier = identifier
+        resultLock.unlock()
+        group.leave()
+      }
+    }
+
+    group.notify(queue: .main) {
+      resultLock.lock()
+      let finalAttachment = attachment
+      let finalCategory = categoryIdentifier
+      resultLock.unlock()
+      QPushNotificationServiceExtension.deliver(request.identifier, content, contentHandler) {
+        if let finalAttachment = finalAttachment { content.attachments = [finalAttachment] }
+        if let finalCategory = finalCategory { content.categoryIdentifier = finalCategory }
+      }
+    }
+  }
+
+  /// Call from `serviceExtensionTimeWillExpire()`. Returns `true` when the
+  /// caller must still call the content handler (QPush did not deliver yet).
+  @discardableResult
+  @objc(serviceExtensionTimeWillExpireRequest:withMutableNotificationContent:)
+  public static func serviceExtensionTimeWillExpireRequest(
+    _ request: UNNotificationRequest,
+    with content: UNMutableNotificationContent?
+  ) -> Bool {
+    return markCompleted(request.identifier)
+  }
+
+  // MARK: - Delivery bookkeeping (the content handler must be called once)
+
+  private static func markCompleted(_ identifier: String) -> Bool {
+    lock.lock()
+    defer { lock.unlock() }
+    if completedRequests.contains(identifier) { return false }
+    completedRequests.append(identifier)
+    if completedRequests.count > 50 { completedRequests.removeFirst(completedRequests.count - 50) }
+    return true
+  }
+
+  private static func deliver(
+    _ identifier: String,
+    _ content: UNMutableNotificationContent,
+    _ contentHandler: @escaping (UNNotificationContent) -> Void,
+    mutate: (() -> Void)? = nil
+  ) {
+    guard markCompleted(identifier) else { return }
+    mutate?()
+    contentHandler(content)
+  }
+
+  // MARK: - App Group config
+
+  /// `QPushAppGroup` in the extension's Info.plist, else `group.{host app bundle id}.qpush`.
+  static func appGroupName() -> String {
+    if let custom = Bundle.main.object(forInfoDictionaryKey: "QPushAppGroup") as? String, !custom.isEmpty {
+      return custom
+    }
+    return "group.\(hostAppBundleIdentifier()).qpush"
+  }
+
+  /// Bundle id of the containing app (`App.app/PlugIns/X.appex` -> `App.app`).
+  static func hostAppBundleIdentifier() -> String {
+    let bundleURL = Bundle.main.bundleURL
+    if bundleURL.pathExtension == "appex" {
+      let appURL = bundleURL.deletingLastPathComponent().deletingLastPathComponent()
+      if let identifier = Bundle(url: appURL)?.bundleIdentifier {
+        return identifier
+      }
+      // Fallback: com.example.app.NotificationExtension -> com.example.app
+      if let own = Bundle.main.bundleIdentifier, let dot = own.lastIndex(of: ".") {
+        return String(own[..<dot])
+      }
+    }
+    return Bundle.main.bundleIdentifier ?? ""
+  }
+
+  private static func sharedDefaults() -> UserDefaults? {
+    return UserDefaults(suiteName: appGroupName())
+  }
+
+  // MARK: - Delivery receipt
+
+  private static func reportReceived(notificationId: String, completion: @escaping () -> Void) {
+    guard let defaults = sharedDefaults(),
+          let appId = defaults.string(forKey: "app_id"), !appId.isEmpty,
+          let serverUrl = defaults.string(forKey: "server_url"), !serverUrl.isEmpty
+    else {
+      NSLog("[QPush] NSE: app_id/server_url missing in App Group %@ (open the app once after installing)", appGroupName())
+      completion()
+      return
+    }
+    var base = serverUrl
+    while base.hasSuffix("/") { base.removeLast() }
+    var allowed = CharacterSet.urlPathAllowed
+    allowed.remove(charactersIn: "/")
+    let encodedId = notificationId.addingPercentEncoding(withAllowedCharacters: allowed) ?? notificationId
+    guard let url = URL(string: "\(base)/notifications/\(encodedId)/report_received") else {
+      completion()
+      return
+    }
+    var body: [String: Any] = ["app_id": appId, "device_type": 0]
+    let subscriptionId = defaults.string(forKey: "subscription_id")
+    if let subscriptionId = subscriptionId { body["subscription_id"] = subscriptionId }
+
+    var request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: reportTimeout)
+    request.httpMethod = "PUT"
+    request.httpBody = try? JSONSerialization.data(withJSONObject: body, options: [])
+    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+    request.setValue("application/json", forHTTPHeaderField: "Accept")
+    request.setValue("qpush-react-native/1.0.0", forHTTPHeaderField: "SDK-Version")
+    if let subscriptionId = subscriptionId {
+      request.setValue(subscriptionId, forHTTPHeaderField: "QPush-Subscription-Id")
+    }
+    URLSession.shared.dataTask(with: request) { _, _, _ in
+      completion()
+    }.resume()
+  }
+
+  // MARK: - Image attachment
+
+  private static func downloadAttachment(from url: URL, completion: @escaping (UNNotificationAttachment?) -> Void) {
+    var request = URLRequest(url: url)
+    request.timeoutInterval = downloadTimeout
+    URLSession.shared.downloadTask(with: request) { location, response, error in
+      guard error == nil, let location = location else {
+        completion(nil)
+        return
+      }
+      let fileExtension = QPushNotificationServiceExtension.attachmentExtension(url: url, mimeType: response?.mimeType)
+      let destination = FileManager.default.temporaryDirectory
+        .appendingPathComponent("qpush-\(UUID().uuidString)")
+        .appendingPathExtension(fileExtension)
+      do {
+        // The downloaded file is deleted when this closure returns: move it now.
+        try FileManager.default.moveItem(at: location, to: destination)
+        let attachment = try UNNotificationAttachment(identifier: "qpush-image", url: destination, options: nil)
+        completion(attachment)
+      } catch {
+        NSLog("[QPush] NSE: could not attach %@: %@", url.absoluteString, error.localizedDescription)
+        completion(nil)
+      }
+    }.resume()
+  }
+
+  private static func attachmentExtension(url: URL, mimeType: String?) -> String {
+    let supported = ["jpg", "jpeg", "png", "gif", "heic", "mp4", "m4v", "mov", "mp3", "m4a", "wav", "aiff"]
+    let fromPath = url.pathExtension.lowercased()
+    if supported.contains(fromPath) { return fromPath }
+    switch mimeType?.lowercased() {
+    case "image/png": return "png"
+    case "image/gif": return "gif"
+    case "image/heic": return "heic"
+    case "video/mp4": return "mp4"
+    case "audio/mpeg": return "mp3"
+    default: return "jpg"
+    }
+  }
+
+  // MARK: - Action buttons
+
+  private static func registerCategory(
+    identifier: String,
+    buttons: [[String: Any]],
+    completion: @escaping (String?) -> Void
+  ) {
+    let actions: [UNNotificationAction] = buttons.compactMap { button in
+      guard let id = button["id"] as? String, !id.isEmpty,
+            let text = button["text"] as? String, !text.isEmpty
+      else { return nil }
+      return UNNotificationAction(identifier: id, title: text, options: [.foreground])
+    }
+    guard !actions.isEmpty else {
+      completion(nil)
+      return
+    }
+    let category = UNNotificationCategory(identifier: identifier, actions: actions, intentIdentifiers: [], options: [])
+    let center = UNUserNotificationCenter.current()
+
+    // Remember recent QPush categories so old ones can be pruned.
+    let defaults = sharedDefaults()
+    var recent = (defaults?.stringArray(forKey: categoryListKey) ?? []).filter { $0 != identifier }
+    recent.append(identifier)
+    if recent.count > maxCategories { recent.removeFirst(recent.count - maxCategories) }
+    defaults?.set(recent, forKey: categoryListKey)
+    let keep = Set(recent)
+
+    center.getNotificationCategories { existing in
+      var categories = existing.filter { !$0.identifier.hasPrefix("qpush_") || keep.contains($0.identifier) }
+      categories = categories.filter { $0.identifier != identifier }
+      categories.insert(category)
+      center.setNotificationCategories(categories)
+      // Reading back makes sure the new category is registered before delivery.
+      center.getNotificationCategories { _ in
+        completion(identifier)
+      }
+    }
+  }
+}

package/ios/Extension/QPushPushExtension.podspec

@@ -0,0 +1,34 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+
+# Helper for the Notification Service Extension target. No React Native
+# dependency, app-extension safe. Add it to the NSE target in your Podfile:
+#
+#   target 'QPushNotificationServiceExtension' do
+#     pod 'QPushPushExtension', :path => '../node_modules/react-native-qpush/ios/Extension'
+#   end
+#
+# It lives here, not in the package root, so that autolinking (which picks a
+# podspec from the package root) always links react-native-qpush.podspec
+# into the app target.
+Pod::Spec.new do |s|
+  s.name         = "QPushPushExtension"
+  s.version      = package["version"]
+  s.summary      = "Notification Service Extension helper for react-native-qpush"
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "v#{s.version}" }
+
+  s.source_files  = "*.swift"
+  s.swift_version = "5.0"
+  s.frameworks    = "UserNotifications"
+
+  s.pod_target_xcconfig = {
+    "APPLICATION_EXTENSION_API_ONLY" => "YES",
+    "DEFINES_MODULE" => "YES",
+  }
+end

package/ios/QPushPush.m

@@ -0,0 +1,62 @@
+// Objective-C bridge exposing the Swift `QPushPush` module to React Native.
+// Every selector here must match the `@objc(...)` name in QPushPush.swift.
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(QPushPush, RCTEventEmitter)
+
+// Storage
+RCT_EXTERN_METHOD(getItem:(NSString *)key
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setItem:(NSString *)key
+                  value:(NSString *)value
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(removeItem:(NSString *)key
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Device & registration
+RCT_EXTERN_METHOD(getDeviceInfo:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(registerForPush:(NSDictionary *)fcmParams
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Permission
+RCT_EXTERN_METHOD(getPermissionStatus:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(requestPermission:(BOOL)fallbackToSettings
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(registerForProvisionalAuthorization:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(canRequestPermission:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Notifications
+RCT_EXTERN_METHOD(clearAll)
+RCT_EXTERN_METHOD(removeNotification:(NSString *)notificationId)
+RCT_EXTERN_METHOD(removeGroupedNotifications:(NSString *)groupKey)
+RCT_EXTERN_METHOD(clearBadge:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Events
+RCT_EXTERN_METHOD(setJsReady)
+RCT_EXTERN_METHOD(displayForegroundNotification:(NSString *)displayId)
+RCT_EXTERN_METHOD(preventForegroundDisplay:(NSString *)displayId)
+
+// Settings
+RCT_EXTERN_METHOD(setAutoOpenUrls:(BOOL)enabled)
+RCT_EXTERN_METHOD(setLogLevel:(double)level)
+
+// Background flush
+RCT_EXTERN_METHOD(beginBackgroundTask:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(endBackgroundTask:(double)taskId)
+
+// addListener: / removeListeners: are exported by RCTEventEmitter.
+
+@end

package/ios/QPushPush.swift

@@ -0,0 +1,186 @@
+import Foundation
+import UIKit
+import UserNotifications
+
+/// React Native module `QPushPush` (exported by QPushPush.m).
+///
+/// The user / subscription / HTTP state machine lives in TypeScript; this
+/// module only does what must be native: storage (+ App Group mirroring),
+/// APNs token, permission, notification center and events.
+@objc(QPushPush)
+class QPushPush: RCTEventEmitter {
+  private(set) var hasListeners = false
+
+  override init() {
+    super.init()
+    QPushPushCore.shared.attach(self)
+  }
+
+  // RCTEventEmitter adopts RCTBridgeModule, so Swift sees this as inherited.
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    // Touches UIApplication / UNUserNotificationCenter at init.
+    return true
+  }
+
+  override func supportedEvents() -> [String]! {
+    return QPushPushCore.supportedEvents
+  }
+
+  override func startObserving() {
+    hasListeners = true
+  }
+
+  override func stopObserving() {
+    hasListeners = false
+  }
+
+  // MARK: - Storage
+
+  @objc(getItem:resolver:rejecter:)
+  func getItem(_ key: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    resolve(QPushPushCore.orNull(QPushStorage.shared.string(key)))
+  }
+
+  @objc(setItem:value:resolver:rejecter:)
+  func setItem(
+    _ key: String,
+    value: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    QPushStorage.shared.set(value, forKey: key)
+    resolve(NSNull())
+  }
+
+  @objc(removeItem:resolver:rejecter:)
+  func removeItem(_ key: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    QPushStorage.shared.remove(key)
+    resolve(NSNull())
+  }
+
+  // MARK: - Device & registration
+
+  @objc(getDeviceInfo:rejecter:)
+  func getDeviceInfo(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      resolve(QPushDeviceInfo.collect())
+    }
+  }
+
+  /// `fcmParams` is Android only and ignored here.
+  @objc(registerForPush:resolver:rejecter:)
+  func registerForPush(
+    _ fcmParams: NSDictionary?,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    QPushPushCore.shared.registerForPush { result in
+      resolve(result)
+    }
+  }
+
+  // MARK: - Permission
+
+  @objc(getPermissionStatus:rejecter:)
+  func getPermissionStatus(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    QPushPushCore.shared.permissionStatus { status in
+      resolve(status)
+    }
+  }
+
+  @objc(requestPermission:resolver:rejecter:)
+  func requestPermission(
+    _ fallbackToSettings: Bool,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    QPushPushCore.shared.requestPermission(fallbackToSettings: fallbackToSettings) { granted in
+      resolve(granted)
+    }
+  }
+
+  @objc(registerForProvisionalAuthorization:rejecter:)
+  func registerForProvisionalAuthorization(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    QPushPushCore.shared.registerForProvisionalAuthorization { granted in
+      resolve(granted)
+    }
+  }
+
+  @objc(canRequestPermission:rejecter:)
+  func canRequestPermission(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    QPushPushCore.shared.canRequestPermission { canRequest in
+      resolve(canRequest)
+    }
+  }
+
+  // MARK: - Notifications
+
+  @objc(clearAll)
+  func clearAll() {
+    QPushPushCore.shared.clearAll()
+  }
+
+  @objc(removeNotification:)
+  func removeNotification(_ notificationId: String) {
+    QPushPushCore.shared.removeNotification(notificationId)
+  }
+
+  @objc(removeGroupedNotifications:)
+  func removeGroupedNotifications(_ groupKey: String) {
+    QPushPushCore.shared.removeGroupedNotifications(groupKey)
+  }
+
+  @objc(clearBadge:rejecter:)
+  func clearBadge(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    QPushPushCore.shared.clearBadge { previous in
+      resolve(previous)
+    }
+  }
+
+  // MARK: - Events
+
+  @objc(setJsReady)
+  func setJsReady() {
+    QPushPushCore.shared.setJsReady()
+  }
+
+  @objc(displayForegroundNotification:)
+  func displayForegroundNotification(_ displayId: String) {
+    QPushPushCore.shared.displayForeground(displayId)
+  }
+
+  @objc(preventForegroundDisplay:)
+  func preventForegroundDisplay(_ displayId: String) {
+    QPushPushCore.shared.preventForeground(displayId)
+  }
+
+  // MARK: - Settings
+
+  @objc(setAutoOpenUrls:)
+  func setAutoOpenUrls(_ enabled: Bool) {
+    QPushStorage.shared.autoOpenUrls = enabled
+  }
+
+  @objc(setLogLevel:)
+  func setLogLevel(_ level: Double) {
+    QPushLog.level = Int(level)
+  }
+
+  // MARK: - Background flush
+
+  @objc(beginBackgroundTask:rejecter:)
+  func beginBackgroundTask(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    QPushPushCore.shared.beginBackgroundTask { taskId in
+      resolve(taskId)
+    }
+  }
+
+  @objc(endBackgroundTask:)
+  func endBackgroundTask(_ taskId: Double) {
+    QPushPushCore.shared.endBackgroundTask(Int(taskId))
+  }
+}

package/ios/QPushPushBridge.h

@@ -0,0 +1,5 @@
+// Makes React Native's Objective-C API visible to the Swift files of this pod
+// (CocoaPods includes public headers in the pod's umbrella header, which the
+// Swift code of the same module can see).
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>