@virex-tech/paywallo-sdk 2.0.0 → 2.0.1

package/ios/PaywalloNotifications.m

@@ -3,7 +3,7 @@
 
 @interface RCT_EXTERN_MODULE(PaywalloNotifications, RCTEventEmitter)
 
-RCT_EXTERN_METHOD(requestPermission:(NSDictionary *)options
+RCT_EXTERN_METHOD(requestPermission:(nonnull NSDictionary *)options
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 
@@ -13,6 +13,9 @@ RCT_EXTERN_METHOD(hasPermission:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(getToken:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(registerForPush:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getInitialNotification:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 

package/ios/PaywalloNotifications.swift

@@ -10,9 +10,7 @@ class PaywalloNotifications: RCTEventEmitter {
     private static let messageReceivedEvent = "PaywalloMessageReceived"
     private static let notificationOpenedEvent = "PaywalloNotificationOpened"
 
-    // MARK: - Pre-subscribe buffer (same pattern as PaywalloStoreKit)
-    // hasListeners is read/written from bufferQueue to avoid races between
-    // startObserving (main thread) and bufferOrEmit (NotificationCenter delivery thread).
+    // MARK: - Pre-subscribe buffer
     private var _hasListeners = false
     private var preSubscribeBuffer: [[String: Any]] = []
     private let bufferQueue = DispatchQueue(label: "com.paywallo.notifications.buffer")
@@ -24,7 +22,7 @@ class PaywalloNotifications: RCTEventEmitter {
 
     // MARK: - RCTEventEmitter Overrides
 
-    override static func requiresMainQueueSetup() -> Bool { return false }
+    override static func requiresMainQueueSetup() -> Bool { return true }
 
     override func supportedEvents() -> [String] {
         return [
@@ -46,13 +44,8 @@ class PaywalloNotifications: RCTEventEmitter {
     // MARK: - Buffer Management
 
     private func bufferOrEmit(eventName: String, body: [String: Any]) {
-        // Determine whether to emit or buffer inside the lock, but never call
-        // sendEvent (which may dispatch back to main) while holding the lock —
-        // that would risk deadlock or re-entrancy on a sync queue.
         let shouldEmit: Bool = bufferQueue.sync {
-            if _hasListeners {
-                return true
-            }
+            if _hasListeners { return true }
             var entry = body
             entry["_eventName"] = eventName
             if preSubscribeBuffer.count >= PaywalloNotifications.maxBufferSize {
@@ -62,12 +55,13 @@ class PaywalloNotifications: RCTEventEmitter {
             return false
         }
         if shouldEmit {
-            sendEvent(withName: eventName, body: body)
+            DispatchQueue.main.async {
+                self.sendEvent(withName: eventName, body: body)
+            }
         }
     }
 
     private func drainPreSubscribeBuffer() {
-        // Copy and clear while holding the lock; emit outside the lock.
         let drained: [[String: Any]] = bufferQueue.sync {
             let copy = preSubscribeBuffer
             preSubscribeBuffer.removeAll()
@@ -76,13 +70,16 @@ class PaywalloNotifications: RCTEventEmitter {
         for entry in drained {
             var body = entry
             guard let eventName = body.removeValue(forKey: "_eventName") as? String else { continue }
-            sendEvent(withName: eventName, body: body)
+            DispatchQueue.main.async {
+                self.sendEvent(withName: eventName, body: body)
+            }
         }
     }
 
     // MARK: - Public Methods (exposed to JS)
 
-    @objc func requestPermission(
+    @objc(requestPermission:resolve:reject:)
+    func requestPermission(
         _ options: NSDictionary,
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
@@ -95,52 +92,70 @@ class PaywalloNotifications: RCTEventEmitter {
             authOptions.insert(.provisional)
         }
 
-        center.requestAuthorization(options: authOptions) { granted, error in
-            if let error = error {
-                reject("PERMISSION_ERROR", error.localizedDescription, error)
+        center.requestAuthorization(options: authOptions) { [weak self] _, error in
+            guard let self = self else {
+                DispatchQueue.main.async { reject("MODULE_RELEASED", "Module was released", nil) }
                 return
             }
 
-            DispatchQueue.main.async {
-                UIApplication.shared.registerForRemoteNotifications()
+            if let error = error {
+                DispatchQueue.main.async { reject("PERMISSION_ERROR", error.localizedDescription, error) }
+                return
             }
 
-            // Return status string matching SDK's PushPermissionStatus type
             self.getPermissionStatusString { status in
-                resolve(status)
+                DispatchQueue.main.async { resolve(status) }
             }
         }
     }
 
-    @objc func hasPermission(
+    @objc(hasPermission:reject:)
+    func hasPermission(
         _ resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
         getPermissionStatusString { status in
-            resolve(status)
+            DispatchQueue.main.async { resolve(status) }
         }
     }
 
-    @objc func getToken(
+    @objc(getToken:reject:)
+    func getToken(
         _ resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
-        if let token = PaywalloNotifications.latestAPNSToken {
-            resolve(token)
-        } else {
-            resolve(nil)
+        DispatchQueue.main.async {
+            if let token = PaywalloNotifications.latestAPNSToken {
+                resolve(token)
+            } else {
+                resolve(nil)
+            }
         }
     }
 
-    @objc func getInitialNotification(
+    @objc(registerForPush:reject:)
+    func registerForPush(
         _ resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
-        if let notification = PaywalloNotifications.initialNotification {
-            PaywalloNotifications.initialNotification = nil // consume once
-            resolve(notification)
-        } else {
-            resolve(nil)
+        DispatchQueue.main.async {
+            UIApplication.shared.registerForRemoteNotifications()
+            resolve(true)
+        }
+    }
+
+    @objc(getInitialNotification:reject:)
+    func getInitialNotification(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            if let notification = PaywalloNotifications.initialNotification {
+                PaywalloNotifications.initialNotification = nil
+                resolve(notification)
+            } else {
+                resolve(nil)
+            }
         }
     }
 
@@ -157,44 +172,10 @@ class PaywalloNotifications: RCTEventEmitter {
             case .ephemeral: status = "ephemeral"
             @unknown default: status = "notDetermined"
             }
-            completion(status)
+            DispatchQueue.main.async { completion(status) }
         }
     }
 
-    // MARK: - Static methods called from swizzled AppDelegate
-
-    @objc static func didRegisterForRemoteNotifications(deviceToken: Data) {
-        let token = deviceToken.map { String(format: "%02x", $0) }.joined()
-        latestAPNSToken = token
-        // Emit to JS — need to find the module instance through the bridge
-        // This is handled via NotificationCenter since we can't access the bridge statically
-        NotificationCenter.default.post(
-            name: NSNotification.Name("PaywalloAPNSTokenReceived"),
-            object: nil,
-            userInfo: ["token": token]
-        )
-    }
-
-    @objc static func didReceiveRemoteNotification(userInfo: [AnyHashable: Any]) {
-        let payload = extractPayload(from: userInfo)
-        NotificationCenter.default.post(
-            name: NSNotification.Name("PaywalloRemoteNotificationReceived"),
-            object: nil,
-            userInfo: ["payload": payload]
-        )
-    }
-
-    @objc static func didOpenNotification(userInfo: [AnyHashable: Any]) {
-        let payload = extractPayload(from: userInfo)
-        // If module not ready yet, store as initial notification
-        initialNotification = payload
-        NotificationCenter.default.post(
-            name: NSNotification.Name("PaywalloNotificationOpened"),
-            object: nil,
-            userInfo: ["payload": payload]
-        )
-    }
-
     // MARK: - Payload Extraction
 
     private static func extractPayload(from userInfo: [AnyHashable: Any]) -> [String: Any] {
@@ -209,7 +190,6 @@ class PaywalloNotifications: RCTEventEmitter {
             }
         }
 
-        // Extract custom data (everything except "aps")
         var data: [String: String] = [:]
         for (key, value) in userInfo {
             guard let key = key as? String, key != "aps" else { continue }
@@ -222,11 +202,10 @@ class PaywalloNotifications: RCTEventEmitter {
         return payload
     }
 
-    // MARK: - NotificationCenter observers (bridge between static calls and instance)
+    // MARK: - Init: observe token from AppDelegate
 
     override init() {
         super.init()
-        PaywalloNotificationsSwizzle.swizzleIfNeeded()
 
         NotificationCenter.default.addObserver(
             self, selector: #selector(onAPNSTokenReceived(_:)),
@@ -240,6 +219,11 @@ class PaywalloNotifications: RCTEventEmitter {
             self, selector: #selector(onNotificationOpened(_:)),
             name: NSNotification.Name("PaywalloNotificationOpened"), object: nil
         )
+
+        // Check if a token was already captured before this observer registered (race condition fix)
+        if let existing = PaywalloNotifications.latestAPNSToken {
+            bufferOrEmit(eventName: PaywalloNotifications.tokenRefreshEvent, body: ["token": existing])
+        }
     }
 
     deinit {
@@ -248,7 +232,10 @@ class PaywalloNotifications: RCTEventEmitter {
 
     @objc private func onAPNSTokenReceived(_ notification: Notification) {
         guard let token = notification.userInfo?["token"] as? String else { return }
-        bufferOrEmit(eventName: PaywalloNotifications.tokenRefreshEvent, body: ["token": token])
+        DispatchQueue.main.async {
+            PaywalloNotifications.latestAPNSToken = token
+            self.bufferOrEmit(eventName: PaywalloNotifications.tokenRefreshEvent, body: ["token": token])
+        }
     }
 
     @objc private func onRemoteNotificationReceived(_ notification: Notification) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virex-tech/paywallo-sdk",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "SDK React Native para integração com Paywallo - Paywalls, Subscriptions e Analytics",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/ios/PaywalloNotificationsSwizzle.swift

@@ -1,126 +0,0 @@
-import Foundation
-import UIKit
-
-/// Swizzles UIApplicationDelegate methods to intercept APNS callbacks.
-/// Runs automatically at load time via swizzleIfNeeded() called from PaywalloNotifications.init().
-/// Same approach used by OneSignal, Firebase, and other push SDKs.
-@objc class PaywalloNotificationsSwizzle: NSObject {
-
-    private static var hasSwizzled = false
-
-    /// Call once at module init time to swizzle AppDelegate APNS methods.
-    @objc static func swizzleIfNeeded() {
-        guard !hasSwizzled else { return }
-
-        // Defer to main queue — UIApplication.shared.delegate is set after app launch.
-        // Set hasSwizzled only after the delegate is confirmed, so a nil-delegate
-        // early call doesn't permanently suppress swizzling.
-        DispatchQueue.main.async {
-            guard let delegate = UIApplication.shared.delegate else { return }
-            guard !hasSwizzled else { return }
-            hasSwizzled = true
-            let delegateClass: AnyClass = type(of: delegate)
-
-            swizzleDidRegisterForRemoteNotifications(delegateClass)
-            swizzleDidFailToRegisterForRemoteNotifications(delegateClass)
-            swizzleDidReceiveRemoteNotification(delegateClass)
-        }
-    }
-
-    // MARK: - didRegisterForRemoteNotificationsWithDeviceToken
-
-    private static func swizzleDidRegisterForRemoteNotifications(_ cls: AnyClass) {
-        let original = #selector(UIApplicationDelegate.application(_:didRegisterForRemoteNotificationsWithDeviceToken:))
-        let swizzled = #selector(PaywalloNotificationsSwizzle.pw_didRegisterForRemoteNotifications(_:deviceToken:))
-        swizzle(cls: cls, original: original, swizzled: swizzled)
-    }
-
-    // MARK: - didFailToRegisterForRemoteNotificationsWithError
-
-    private static func swizzleDidFailToRegisterForRemoteNotifications(_ cls: AnyClass) {
-        let original = #selector(UIApplicationDelegate.application(_:didFailToRegisterForRemoteNotificationsWithError:))
-        let swizzled = #selector(PaywalloNotificationsSwizzle.pw_didFailToRegisterForRemoteNotifications(_:error:))
-        swizzle(cls: cls, original: original, swizzled: swizzled)
-    }
-
-    // MARK: - didReceiveRemoteNotification (with completion handler)
-
-    private static func swizzleDidReceiveRemoteNotification(_ cls: AnyClass) {
-        let original = #selector(UIApplicationDelegate.application(_:didReceiveRemoteNotification:fetchCompletionHandler:))
-        let swizzled = #selector(PaywalloNotificationsSwizzle.pw_didReceiveRemoteNotification(_:userInfo:completionHandler:))
-        swizzle(cls: cls, original: original, swizzled: swizzled)
-    }
-
-    // MARK: - Core swizzle helper
-
-    /// Track whether the original method existed before swizzle for each selector,
-    /// so the pw_ implementations know whether to forward (exchange case) or not (add case).
-    private static var didExchange: [String: Bool] = [:]
-
-    /// Exchanges implementations if the method exists on cls, otherwise adds it directly.
-    private static func swizzle(cls: AnyClass, original: Selector, swizzled: Selector) {
-        guard let swizzledMethod = class_getInstanceMethod(PaywalloNotificationsSwizzle.self, swizzled) else {
-            return
-        }
-
-        let key = NSStringFromSelector(original)
-
-        if let originalMethod = class_getInstanceMethod(cls, original) {
-            // Method exists on the AppDelegate — exchange so both run.
-            // After exchange: calling `original` runs our pw_ body,
-            // calling `pw_` from within pw_ runs the ORIGINAL body (not recursion).
-            method_exchangeImplementations(originalMethod, swizzledMethod)
-            didExchange[key] = true
-        } else {
-            // Method not implemented in the host AppDelegate — add our impl directly.
-            // pw_ methods must NOT call themselves here (no original to forward to).
-            let types = method_getTypeEncoding(swizzledMethod)
-            class_addMethod(cls, original, method_getImplementation(swizzledMethod), types)
-            didExchange[key] = false
-        }
-    }
-
-    // MARK: - Swizzled implementations
-    // After method_exchangeImplementations:
-    //   - The original selector on AppDelegate points to our pw_ body
-    //   - Calling pw_ from within itself calls the ORIGINAL AppDelegate implementation
-    //     (because the IMP under pw_ was exchanged to the original). Not infinite recursion.
-    //
-    // When class_addMethod was used instead (no original method):
-    //   - There is no original to forward to, so we skip the self-call to avoid
-    //     actual infinite recursion / stack overflow.
-
-    // All pw_ methods are called on the main thread (UIApplicationDelegate callbacks
-    // are main-thread-only). didExchange is written on main by swizzleIfNeeded, so
-    // reading it here is safe without additional locking.
-
-    @objc func pw_didRegisterForRemoteNotifications(_ application: UIApplication, deviceToken: Data) {
-        PaywalloNotifications.didRegisterForRemoteNotifications(deviceToken: deviceToken)
-        let key = NSStringFromSelector(#selector(UIApplicationDelegate.application(_:didRegisterForRemoteNotificationsWithDeviceToken:)))
-        if PaywalloNotificationsSwizzle.didExchange[key] == true {
-            pw_didRegisterForRemoteNotifications(application, deviceToken: deviceToken)
-        }
-    }
-
-    @objc func pw_didFailToRegisterForRemoteNotifications(_ application: UIApplication, error: Error) {
-        let key = NSStringFromSelector(#selector(UIApplicationDelegate.application(_:didFailToRegisterForRemoteNotificationsWithError:)))
-        if PaywalloNotificationsSwizzle.didExchange[key] == true {
-            pw_didFailToRegisterForRemoteNotifications(application, error: error)
-        }
-    }
-
-    @objc func pw_didReceiveRemoteNotification(
-        _ application: UIApplication,
-        userInfo: [AnyHashable: Any],
-        completionHandler: @escaping (UIBackgroundFetchResult) -> Void
-    ) {
-        PaywalloNotifications.didReceiveRemoteNotification(userInfo: userInfo)
-        let key = NSStringFromSelector(#selector(UIApplicationDelegate.application(_:didReceiveRemoteNotification:fetchCompletionHandler:)))
-        if PaywalloNotificationsSwizzle.didExchange[key] == true {
-            pw_didReceiveRemoteNotification(application, userInfo: userInfo, completionHandler: completionHandler)
-        } else {
-            // No original handler — we must call the completion handler ourselves
-            completionHandler(.noData)
-        }
-    }
-}