appambit-push-notifications 0.3.1 → 1.0.0

package/ios/AppAmbitNotificationSwizzler.m

@@ -0,0 +1,290 @@
+#import <UIKit/UIKit.h>
+#import <UserNotifications/UserNotifications.h>
+#import <objc/runtime.h>
+#import <AppAmbitSdkPushNotifications-Swift.h>
+
+// ─── cold-start deduplication ─────────────────────────────────────────────────
+//
+// On a cold-start notification tap (app was killed), BOTH paths fire:
+//   1. appDidFinishLaunching: → launchOptions contains the payload (100% reliable)
+//   2. userNotificationCenter:didReceiveNotificationResponse: fires afterward
+//
+// We capture via (1) and use this flag to suppress the duplicate in (2).
+// For background→foreground taps, (1) does not fire, so the flag stays NO
+// and (2) is the only capture path.
+
+static BOOL _capturedFromLaunchOptions = NO;
+
+// ─── background remote notification swizzle ──────────────────────────────────
+
+typedef void (^RemoteNotificationCompletionHandler)(UIBackgroundFetchResult);
+typedef void (*RemoteNotificationIMPType)(id, SEL, UIApplication *, NSDictionary *, RemoteNotificationCompletionHandler);
+
+static RemoteNotificationIMPType _originalRemoteNotificationIMP = NULL;
+
+// ─── JS background handler completion ────────────────────────────────────────
+//
+// When no original AppDelegate implementation exists, we own the completion
+// handler. We hold it here until JS calls backgroundHandlerCompleted(), which
+// routes to AppAmbitNotifyJSBackgroundHandlerCompleted(). A 25-second safety
+// timeout fires if JS never resolves, and the OS expiration handler fires if
+// iOS needs the time back sooner.
+
+static void (^_pendingBGCompletionBlock)(void) = nil;
+static UIBackgroundTaskIdentifier _pendingBGTask = 0; // UIBackgroundTaskInvalid == 0; can't use extern const as static initializer
+static dispatch_block_t _pendingBGSafetyTimer = nil;
+
+static void AppAmbitFinishBackgroundTask(void) {
+    if (_pendingBGCompletionBlock) {
+        void (^block)(void) = _pendingBGCompletionBlock;
+        _pendingBGCompletionBlock = nil;
+        block();
+    }
+    if (_pendingBGSafetyTimer) {
+        dispatch_block_cancel(_pendingBGSafetyTimer);
+        _pendingBGSafetyTimer = nil;
+    }
+    if (_pendingBGTask != UIBackgroundTaskInvalid) {
+        [[UIApplication sharedApplication] endBackgroundTask:_pendingBGTask];
+        _pendingBGTask = UIBackgroundTaskInvalid;
+    }
+}
+
+// Called from AppambitPushNotifications.mm via the extern declaration.
+void AppAmbitNotifyJSBackgroundHandlerCompleted(void) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        AppAmbitFinishBackgroundTask();
+    });
+}
+
+static void AppAmbitRemoteNotificationIMP(
+    id self,
+    SEL _cmd,
+    UIApplication *application,
+    NSDictionary *userInfo,
+    RemoteNotificationCompletionHandler completionHandler
+) {
+    [AppAmbitPushWrapper didReceiveBackgroundNotification:userInfo];
+
+    if (_originalRemoteNotificationIMP != NULL) {
+        // AppDelegate already handles background time; call through.
+        _originalRemoteNotificationIMP(self, _cmd, application, userInfo, completionHandler);
+        return;
+    }
+
+    // No original implementation — we own the completion handler.
+    // Flush any previous task that JS never completed (shouldn't happen normally).
+    AppAmbitFinishBackgroundTask();
+
+    _pendingBGCompletionBlock = ^{
+        completionHandler(UIBackgroundFetchResultNewData);
+    };
+
+    // iOS expiration handler: system needs time back immediately.
+    _pendingBGTask = [application beginBackgroundTaskWithExpirationHandler:^{
+        AppAmbitFinishBackgroundTask();
+    }];
+
+    // Safety timeout: if JS doesn't call backgroundHandlerCompleted within 25s,
+    // complete anyway so future background wake-ups are not penalised by iOS.
+    dispatch_block_t timer = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS, ^{
+        AppAmbitFinishBackgroundTask();
+    });
+    _pendingBGSafetyTimer = timer;
+    dispatch_after(
+        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(25.0 * NSEC_PER_SEC)),
+        dispatch_get_main_queue(),
+        timer
+    );
+}
+
+// ─── UNUserNotificationCenter delegate proxy ─────────────────────────────────
+
+@interface AppAmbitNotificationProxy : NSObject <UNUserNotificationCenterDelegate>
+@property (nonatomic, weak) id<UNUserNotificationCenterDelegate> next;
++ (instancetype)shared;
+@end
+
+@implementation AppAmbitNotificationProxy
+
++ (instancetype)shared {
+    static AppAmbitNotificationProxy *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{ instance = [[AppAmbitNotificationProxy alloc] init]; });
+    return instance;
+}
+
+// Show notification banner/sound/badge when app is foreground
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
+    SEL sel = @selector(userNotificationCenter:willPresentNotification:withCompletionHandler:);
+    if ([self.next respondsToSelector:sel]) {
+        [self.next userNotificationCenter:center
+                  willPresentNotification:notification
+                    withCompletionHandler:completionHandler];
+    } else {
+        if (@available(iOS 14.0, *)) {
+            completionHandler(UNNotificationPresentationOptionBanner |
+                              UNNotificationPresentationOptionBadge |
+                              UNNotificationPresentationOptionSound);
+        } else {
+            completionHandler(UNNotificationPresentationOptionAlert |
+                              UNNotificationPresentationOptionBadge |
+                              UNNotificationPresentationOptionSound);
+        }
+    }
+}
+
+// Notification tap — background→foreground taps are captured here.
+// Cold-start taps are captured via launchOptions in appDidFinishLaunching: instead;
+// this path deduplicates them using _capturedFromLaunchOptions.
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+didReceiveNotificationResponse:(UNNotificationResponse *)response
+         withCompletionHandler:(void (^)(void))completionHandler {
+
+    if (_capturedFromLaunchOptions) {
+        // Cold-start: already captured via launchOptions — skip to avoid duplicate.
+        _capturedFromLaunchOptions = NO;
+    } else {
+        // Background→foreground tap: not captured yet, capture now.
+        NSDictionary *userInfo = response.notification.request.content.userInfo;
+        [AppAmbitPushWrapper didReceiveOpenedNotification:userInfo];
+    }
+
+    SEL sel = @selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:);
+    if ([self.next respondsToSelector:sel]) {
+        [self.next userNotificationCenter:center
+           didReceiveNotificationResponse:response
+                    withCompletionHandler:completionHandler];
+    } else {
+        completionHandler();
+    }
+}
+
+@end
+
+// ─── setDelegate: swizzle — pins proxy as permanent delegate ──────────────────
+//
+// React Native (RCTPushNotificationManager) and the AppAmbit native SDK both
+// call [UNUserNotificationCenter.current setDelegate:] during app startup.
+// Without this swizzle those calls would evict our proxy.
+//
+// With this swizzle, ANY setDelegate: call from ANY caller is intercepted:
+//   • the caller's delegate becomes proxy.next (chaining preserved)
+//   • proxy is (re-)installed as the actual delegate
+// The proxy forwards both delegate callbacks to proxy.next, so RN and the
+// native SDK still receive all the notifications they expect.
+
+typedef void (*SetDelegateIMPType)(id, SEL, id<UNUserNotificationCenterDelegate>);
+static SetDelegateIMPType _originalSetDelegateIMP = NULL;
+
+static void AppAmbitSetDelegateIMP(
+    UNUserNotificationCenter *center,
+    SEL _cmd,
+    id<UNUserNotificationCenterDelegate> newDelegate
+) {
+    AppAmbitNotificationProxy *proxy = [AppAmbitNotificationProxy shared];
+    if (newDelegate == proxy) {
+        _originalSetDelegateIMP(center, _cmd, newDelegate);
+        return;
+    }
+    proxy.next = newDelegate;
+    _originalSetDelegateIMP(center, _cmd, proxy);
+}
+
+// ─── main swizzler ────────────────────────────────────────────────────────────
+
+@interface AppAmbitNotificationSwizzler : NSObject
+@end
+
+@implementation AppAmbitNotificationSwizzler
+
++ (void)load {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        // Swizzle UNUserNotificationCenter.setDelegate: so proxy stays pinned
+        // regardless of when RN or the native SDK set their own delegates.
+        Class uncClass = [UNUserNotificationCenter class];
+        SEL setDelegateSel = @selector(setDelegate:);
+        Method setDelegateMethod = class_getInstanceMethod(uncClass, setDelegateSel);
+        if (setDelegateMethod) {
+            _originalSetDelegateIMP = (SetDelegateIMPType)method_getImplementation(setDelegateMethod);
+            method_setImplementation(setDelegateMethod, (IMP)AppAmbitSetDelegateIMP);
+        }
+
+        [[NSNotificationCenter defaultCenter]
+            addObserver:self
+               selector:@selector(appWillFinishLaunching:)
+                   name:@"UIApplicationWillFinishLaunchingNotification"
+                 object:nil];
+
+        [[NSNotificationCenter defaultCenter]
+            addObserver:self
+               selector:@selector(appDidFinishLaunching:)
+                   name:UIApplicationDidFinishLaunchingNotification
+                 object:nil];
+    });
+}
+
++ (void)appWillFinishLaunching:(NSNotification *)notification {
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                    name:@"UIApplicationWillFinishLaunchingNotification"
+                                                  object:nil];
+
+    // Start native SDK — if it calls setDelegate:, the swizzle intercepts and
+    // chains its delegate as proxy.next automatically.
+    [AppAmbitPushWrapper start];
+
+    // Ensure proxy is the actual delegate. If the SDK called setDelegate:
+    // the swizzle already installed proxy; this guard is a no-op in that case.
+    AppAmbitNotificationProxy *proxy = [AppAmbitNotificationProxy shared];
+    if (UNUserNotificationCenter.currentNotificationCenter.delegate != proxy) {
+        UNUserNotificationCenter.currentNotificationCenter.delegate = proxy;
+    }
+
+    // ── Cold-start notification tap capture ───────────────────────────────────
+    // UIApplicationWillFinishLaunchingNotification carries the same dictionary
+    // that was passed as launchOptions to application:willFinishLaunchingWithOptions:.
+    // We capture it here early, BEFORE the React Native bridge and its modules
+    // are initialized, so the module's init can successfully retrieve it.
+    NSDictionary *launchOptions = notification.userInfo;
+    NSDictionary *remoteNotification = launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey];
+    if (remoteNotification) {
+        _capturedFromLaunchOptions = YES;
+        [AppAmbitPushWrapper didReceiveOpenedNotification:remoteNotification];
+    }
+}
+
++ (void)appDidFinishLaunching:(NSNotification *)notification {
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                    name:UIApplicationDidFinishLaunchingNotification
+                                                  object:nil];
+
+    // ── Cold-start notification tap capture (fallback) ───────────────────────
+    if (!_capturedFromLaunchOptions) {
+        NSDictionary *launchOptions = notification.userInfo;
+        NSDictionary *remoteNotification = launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey];
+        if (remoteNotification) {
+            _capturedFromLaunchOptions = YES;
+            [AppAmbitPushWrapper didReceiveOpenedNotification:remoteNotification];
+        }
+    }
+
+    id<UIApplicationDelegate> delegate = UIApplication.sharedApplication.delegate;
+    if (!delegate) return;
+
+    Class delegateClass = object_getClass(delegate);
+
+    // ── Background remote notification swizzle ────────────────────────────────
+    SEL selector = @selector(application:didReceiveRemoteNotification:fetchCompletionHandler:);
+    Method existingMethod = class_getInstanceMethod(delegateClass, selector);
+    if (existingMethod) {
+        _originalRemoteNotificationIMP = (RemoteNotificationIMPType)method_getImplementation(existingMethod);
+        method_setImplementation(existingMethod, (IMP)AppAmbitRemoteNotificationIMP);
+    } else {
+        class_addMethod(delegateClass, selector, (IMP)AppAmbitRemoteNotificationIMP, "v@:@@@?");
+    }
+}
+
+@end

package/ios/AppAmbitPushWrapper.swift

@@ -1,18 +1,76 @@
 import Foundation
 import UserNotifications
+import Network
 import AppAmbitPushNotifications
+import AppAmbit
 
 @objc(AppAmbitPushWrapper)
 public class AppAmbitPushWrapper: NSObject {
 
+  // MARK: - Network monitoring
+  //
+  // The AppAmbit SDK's ConsumerService has no offline retry queue and dedups
+  // consumer updates against its local DB, so an update attempted while offline
+  // poisons that cache and is never re-sent. We therefore gate consumer updates
+  // on real connectivity and replay them when the network returns.
+  private static let pathMonitor = NWPathMonitor()
+  private static let monitorQueue = DispatchQueue(label: "com.appambit.push.netmonitor")
+  private static var monitorStarted = false
+  private static var lastSatisfied = false
+
+  @objc public static func startNetworkMonitor() {
+    if monitorStarted { return }
+    monitorStarted = true
+    pathMonitor.pathUpdateHandler = { path in
+      let satisfied = path.status == .satisfied
+      let becameAvailable = satisfied && !lastSatisfied
+      lastSatisfied = satisfied
+      if becameAvailable {
+        NotificationCenter.default.post(
+          name: NSNotification.Name("AppAmbit_networkAvailable"),
+          object: nil
+        )
+      }
+    }
+    pathMonitor.start(queue: monitorQueue)
+  }
+
+  @objc public static func isNetworkAvailable() -> Bool {
+    if !monitorStarted { startNetworkMonitor() }
+    return pathMonitor.currentPath.status == .satisfied
+  }
+
   @objc public static func start() {
+    startNetworkMonitor()
+    // In Debug builds enable the SDK's verbose logging so its native logs are
+    // visible in the simulator/device log stream during development.
+    #if DEBUG
+    PushNotifications.start(debugMode: true)
+    #else
     PushNotifications.start()
+    #endif
   }
 
   @objc public static func setNotificationsEnabled(_ enabled: Bool) {
     PushNotifications.setNotificationsEnabled(enabled)
   }
 
+  /// Persists the enabled flag locally (UserDefaults only — no network call).
+  /// Used so the SDK's cold-start token sync knows the user's intent without
+  /// triggering an offline-poisoning consumer update.
+  @objc public static func setNotificationsEnabledLocal(_ enabled: Bool) {
+    PushKernel.setNotificationsEnabled(enabled)
+  }
+
+  /// Completion-based variant: reports whether the backend network call succeeded.
+  /// Used by the offline-retry path so it knows when to clear the pending flag.
+  @objc(setNotificationsEnabled:completion:)
+  public static func setNotificationsEnabled(_ enabled: Bool, completion: @escaping (Bool) -> Void) {
+    PushKernel.setNotificationsEnabled(enabled)
+    let token = PushKernel.getCurrentToken()
+    ConsumerService.shared.updateConsumer(deviceToken: token, pushEnabled: enabled, completion: completion)
+  }
+
   @objc public static func isNotificationsEnabled() -> Bool {
     return PushNotifications.isNotificationsEnabled()
   }
@@ -21,38 +79,120 @@ public class AppAmbitPushWrapper: NSObject {
     PushNotifications.requestNotificationPermission(listener: listener)
   }
 
-  @objc(setNotificationCustomizer:)
-  public static func setNotificationCustomizer(listener: ((NSDictionary) -> Void)?) {
-    PushNotifications.setNotificationCustomizer { notification in
-      let content = notification.request.content
-      let userInfo = content.userInfo
+  @objc public static func hasNotificationPermission(completion: @escaping (Bool) -> Void) {
+    UNUserNotificationCenter.current().getNotificationSettings { settings in
+      let granted = settings.authorizationStatus == .authorized
+        || settings.authorizationStatus == .provisional
+      if granted {
+        // Cache the grant so we can survive simulator reinstalls where the
+        // system returns .notDetermined even though permission was given before.
+        UserDefaults.standard.set(true, forKey: "appambit_push_has_permission")
+      }
+      // If the system says .denied, the user explicitly revoked — always return false.
+      // If the system says .notDetermined AND we have a cached grant, the app was
+      // likely reinstalled (common on iOS Simulator) — return true as fallback.
+      let fallback = settings.authorizationStatus == .notDetermined
+        && UserDefaults.standard.bool(forKey: "appambit_push_has_permission")
+      completion(granted || fallback)
+    }
+  }
 
-      var notificationData: [String: String] = [
-        "title": content.title,
-        "body": content.body
-      ]
+  @objc(setNotificationListener:)
+  public static func setNotificationListener(listener: @escaping ((NSDictionary, Int) -> Void)) {
+    PushNotifications.setNotificationListener { userInfo, state in
+      let payload = formatNotificationPayload(userInfo)
+      listener(payload as NSDictionary, state.rawValue)
+    }
+  }
 
-      if !content.subtitle.isEmpty {
-        notificationData["subtitle"] = content.subtitle
-      }
+  public static var pendingBackgroundPayloads: [[String: Any]] = []
 
-      var customData: [String: String] = [:]
-      for (key, value) in userInfo {
-        guard let keyStr = key as? String else { continue }
-        // Exclude only the standard Apple payload. We keep the rest to see exactly what comes.
-        if keyStr == "aps" { continue }
-        customData[keyStr] = "\(value)"
-      }
+  public static var pendingOpenedPayloads: [[String: Any]] = []
+
+  @objc(didReceiveBackgroundNotification:)
+  public static func didReceiveBackgroundNotification(_ userInfo: [AnyHashable: Any]) {
+    let payload = formatNotificationPayload(userInfo)
+    pendingBackgroundPayloads.append(payload)
+
+    NotificationCenter.default.post(
+      name: NSNotification.Name("AppAmbit_onBackgroundNotification"),
+      object: nil,
+      userInfo: payload
+    )
+  }
+
+  @objc(didReceiveOpenedNotification:)
+  public static func didReceiveOpenedNotification(_ userInfo: [AnyHashable: Any]) {
+    let payload = formatNotificationPayload(userInfo)
+    pendingOpenedPayloads.append(payload)
+
+    NotificationCenter.default.post(
+      name: NSNotification.Name("AppAmbit_onOpenedNotification"),
+      object: nil,
+      userInfo: payload
+    )
+  }
+  
+  @objc public static func getAndClearPendingBackgroundPayloads() -> [[String: Any]] {
+    let payloads = pendingBackgroundPayloads
+    pendingBackgroundPayloads.removeAll()
+    return payloads
+  }
 
-      var payload: [String: Any] = [
-        "notification": notificationData
-      ]
+  @objc public static func getAndClearPendingOpenedPayloads() -> [[String: Any]] {
+    let payloads = pendingOpenedPayloads
+    pendingOpenedPayloads.removeAll()
+    return payloads
+  }
+
+  @objc(formatNotificationPayload:)
+  public static func formatNotificationPayload(_ userInfo: [AnyHashable: Any]) -> [String: Any] {
+    var title: String? = nil
+    var body: String? = nil
+    var imageUrl: String? = nil
+    var customData: [String: Any] = [:]
 
-      if !customData.isEmpty {
-        payload["data"] = customData
+    let aps = userInfo["aps"] as? [String: Any]
+    if let aps = aps {
+      if let alert = aps["alert"] as? [String: Any] {
+        title    = alert["title"] as? String
+        body     = alert["body"] as? String
+      } else if let alertStr = aps["alert"] as? String {
+        body = alertStr
       }
+    }
+
+    let imageUrlKeys: Set<String> = ["image_url", "imageUrl", "image"]
+    for (key, value) in userInfo {
+      let keyStr = (key as? String) ?? "\(key)"
+      if keyStr == "aps" { continue }
 
-      listener?(payload as NSDictionary)
+      if imageUrlKeys.contains(keyStr) {
+        if imageUrl == nil { imageUrl = value as? String }
+      } else if keyStr == "data", let nestedData = value as? [String: Any] {
+        for (nestedKey, nestedValue) in nestedData {
+          customData[nestedKey] = (nestedValue as? String) ?? String(describing: nestedValue)
+        }
+      } else {
+        customData[keyStr] = (value as? String) ?? String(describing: value)
+      }
     }
+
+    var iosMap: [String: Any] = [:]
+    if let badge = aps?["badge"] as? Int       { iosMap["badge"]    = badge }
+    if let sound = aps?["sound"] as? String    { iosMap["sound"]    = sound }
+    if let cat   = aps?["category"] as? String { iosMap["category"] = cat }
+    if let tid   = aps?["thread-id"] as? String { iosMap["threadId"] = tid }
+
+    var payload: [String: Any] = [
+      "title":    title as Any,
+      "body":     body as Any,
+      "imageUrl": imageUrl as Any,
+      "data":     customData,
+      "android":  NSNull(),
+      "ios":      iosMap,
+    ]
+
+    return payload
   }
 }

package/ios/AppAmbitRNNotificationService.swift

@@ -0,0 +1,46 @@
+import AppAmbitPushNotifications
+import UserNotifications
+
+/// RN-layer NSE base class. Subclass and override `appGroupIdentifier`
+/// with the App Group shared between the main app and the NSE target.
+open class AppAmbitRNNotificationService: AppAmbitNotificationService {
+
+    open var appGroupIdentifier: String { "" }
+
+    private static let storageKey = "com.appambit.pendingNotifications"
+    private static let maxStored  = 50
+
+    open override func handlePayload(_ notification: AppAmbitNotification,
+                                     content: UNMutableNotificationContent) {
+        guard !appGroupIdentifier.isEmpty,
+              let defaults = UserDefaults(suiteName: appGroupIdentifier) else { return }
+        let entry = buildEntry(notification)
+        persist(entry, to: defaults)
+    }
+
+    private func buildEntry(_ notification: AppAmbitNotification) -> [String: Any] {
+        var data: [String: Any] = [:]
+        for (k, v) in notification.data {
+            if let key = k as? String,
+               JSONSerialization.isValidJSONObject([key: v]) {
+                data[key] = v
+            }
+        }
+        var entry: [String: Any] = [
+            "receivedAt": ISO8601DateFormatter().string(from: Date()),
+            "data": data,
+        ]
+        if let t = notification.title    { entry["title"]    = t }
+        if let b = notification.body     { entry["body"]     = b }
+        if let u = notification.imageUrl { entry["imageUrl"] = u }
+        return entry
+    }
+
+    private func persist(_ entry: [String: Any], to defaults: UserDefaults) {
+        var list = (defaults.array(forKey: Self.storageKey) as? [[String: Any]]) ?? []
+        list.insert(entry, at: 0)
+        if list.count > Self.maxStored { list = Array(list.prefix(Self.maxStored)) }
+        defaults.set(list, forKey: Self.storageKey)
+        defaults.synchronize()
+    }
+}