@primer-io/react-native 0.16.2 → 2.1.0

package/ios/RNTPrimer.swift

@@ -11,30 +11,33 @@ import UIKit
 
 @objc
 enum PrimerEvents: Int, CaseIterable {
-    case onClientTokenCallback = 0
-    case onClientSessionActions
-    case onTokenizeSuccessCallback
-    case onVaultSuccess
+    
+    case onCheckoutComplete = 0
+    case onBeforeClientSessionUpdate
+    case onClientSessionUpdate
+    case onBeforePaymentCreate
+    case onDismiss
+    case onTokenizeSuccess
     case onResumeSuccess
-    case onCheckoutDismissed
     case onError
-    
     case detectImplementedRNCallbacks
     
     var stringValue: String {
         switch self {
-        case .onClientTokenCallback:
-            return "onClientTokenCallback"
-        case .onClientSessionActions:
-            return "onClientSessionActions"
-        case .onTokenizeSuccessCallback:
-            return "onTokenizeSuccessCallback"
-        case .onVaultSuccess:
-            return "onVaultSuccess"
+        case .onCheckoutComplete:
+            return "onCheckoutComplete"
+        case .onBeforeClientSessionUpdate:
+            return "onBeforeClientSessionUpdate"
+        case .onClientSessionUpdate:
+            return "onClientSessionUpdate"
+        case .onBeforePaymentCreate:
+            return "onBeforePaymentCreate"
+        case .onDismiss:
+            return "onDismiss"
+        case .onTokenizeSuccess:
+            return "onTokenizeSuccess"
         case .onResumeSuccess:
             return "onResumeSuccess"
-        case .onCheckoutDismissed:
-            return "onCheckoutDismissed"
         case .onError:
             return "onError"
         case .detectImplementedRNCallbacks:
@@ -45,14 +48,12 @@ enum PrimerEvents: Int, CaseIterable {
 
 @objc(NativePrimer)
 class RNTPrimer: RCTEventEmitter {
-    
-    private var isClientTokenCallbackImplementedInRN: Bool?
-    private var clientTokenCallback: ((String?, Error?) -> Void)?
-    private var isOnClientSessionActionsImplementedInRN: Bool?
-    private var onClientSessionActions: ((String?, Error?) -> Void)?
-    private var onTokenizeSuccess: ((String?, Error?) -> Void)?
-    private var onResumeSuccess: ((String?, Error?) -> Void)?
-    private var implementedReactNativeCallbacks: ImplementedReactNativeCallbacks?
+
+    private var primerWillCreatePaymentWithDataDecisionHandler: ((_ errorMessage: String?) -> Void)?
+    private var primerDidTokenizePaymentMethodDecisionHandler: ((_ resumeToken: String?, _ errorMessage: String?) -> Void)?
+    private var primerDidResumeWithDecisionHandler: ((_ resumeToken: String?, _ errorMessage: String?) -> Void)?
+    private var primerDidFailWithErrorDecisionHandler: ((_ errorMessage: String) -> Void)?
+    private var implementedRNCallbacks: ImplementedRNCallbacks?
     
     // MARK: - INITIALIZATION & REACT NATIVE SUPPORT
     
@@ -73,127 +74,192 @@ class RNTPrimer: RCTEventEmitter {
         return PrimerEvents.allCases.compactMap({ $0.stringValue })
     }
     
-    // MARK: - API
+    // MARK: - SDK API
     
     @objc
-    public func configureWithSettings(_ settingsStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func configure(_ settingsStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
             do {
-                try self.configure(settingsStr: settingsStr)
+                try self.configure(settingsStr: settingsStr.isEmpty ? nil : settingsStr)
                 resolver(nil)
             } catch {
-                self.checkoutFailed(with: error)
                 rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
             }
         }
     }
     
     @objc
-    public func configureWithTheme(_ themeStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func showUniversalCheckoutWithClientToken(_ clientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            PrimerSDK.Primer.shared.showUniversalCheckout(clientToken: clientToken) { err in
+                DispatchQueue.main.async {
+                    if let err = err {
+                        rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+                    } else {
+                        resolver(nil)
+                    }
+                }
+            }
+        }
+    }
+    
+    @objc
+    public func showVaultManagerWithClientToken(_ clientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            PrimerSDK.Primer.shared.showVaultManager(clientToken: clientToken) { err in
+                DispatchQueue.main.async {
+                    if let err = err {
+                        rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+                    } else {
+                        resolver(nil)
+                    }
+                }
+            }
+        }
+    }
+    
+    @objc
+    public func showPaymentMethod(_ paymentMethodStr: String, intent: String, clientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
             do {
-                try self.configure(themeStr: themeStr)
-                resolver(nil)
+                let paymentMethodType = PrimerPaymentMethodType(rawValue: paymentMethodStr)
+                
+                guard paymentMethodType != PrimerPaymentMethodType.other(rawValue: paymentMethodStr) else {
+                    let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Payment method type \(paymentMethodStr) is not valid."])
+                    throw err
+                }
+                
+                guard let primerIntent = PrimerSessionIntent(rawValue: intent) else {
+                    let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Intent \(intent) is not valid."])
+                    throw err
+                }
+                
+                PrimerSDK.Primer.shared.showPaymentMethod(paymentMethodType, withIntent: primerIntent, andClientToken: clientToken) { err in
+                    DispatchQueue.main.async {
+                        if let err = err {
+                            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+                        } else {
+                            resolver(nil)
+                        }
+                    }
+                }
             } catch {
-                self.checkoutFailed(with: error)
                 rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
             }
         }
     }
     
     @objc
-    public func showUniversalCheckout(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func dismiss() {
+        Primer.shared.dismiss()
+    }
+    
+    @objc
+    public func dispose() {
+        Primer.shared.dismiss()
+    }
+    
+    // MARK: - DECISION HANDLERS
+    
+    // MARK: Tokenization
+    
+    @objc
+    public func handleTokenizationNewClientToken(_ newClientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            PrimerSDK.Primer.shared.showUniversalCheckout(on: UIViewController(), clientToken: nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler?(newClientToken, nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
             resolver(nil)
         }
     }
     
     @objc
-    public func showUniversalCheckoutWithClientToken(_ clientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handleTokenizationSuccess(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            PrimerSDK.Primer.shared.showUniversalCheckout(on: UIViewController(), clientToken: clientToken)
+            self.primerDidTokenizePaymentMethodDecisionHandler?(nil, nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
             resolver(nil)
         }
     }
     
     @objc
-    public func showVaultManager(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handleTokenizationFailure(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            PrimerSDK.Primer.shared.showVaultManager(on: UIViewController(), clientToken: nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler?(nil, errorMessage ?? "")
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
             resolver(nil)
         }
     }
     
+    // MARK: Resume Payment
+    
     @objc
-    public func showVaultManager(_ clientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handleResumeWithNewClientToken(_ newClientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            PrimerSDK.Primer.shared.showVaultManager(on: UIViewController(), clientToken: clientToken)
+            self.primerDidResumeWithDecisionHandler?(newClientToken, nil)
+            self.primerDidResumeWithDecisionHandler = nil
             resolver(nil)
         }
     }
     
     @objc
-    public func showPaymentMethod(_ clientToken: String, paymentMethodStr: String, intentStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handleResumeSuccess(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            do {
-                let paymentMethodConfigType = PaymentMethodConfigType(rawValue: paymentMethodStr)
-                
-                guard paymentMethodConfigType != PaymentMethodConfigType.other(rawValue: paymentMethodStr) else {
-                    let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Payment method type \(paymentMethodStr) is not valid."])
-                    throw err
-                }
-                
-                guard let intent = PrimerSessionIntent(rawValue: intentStr) else {
-                    let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Intent \(intentStr) is not valid."])
-                    throw err
-                }
-                
-                PrimerSDK.Primer.shared.showPaymentMethod(paymentMethodConfigType, withIntent: intent, on: UIViewController(), with: clientToken)
-                resolver(nil)
-            } catch {
-                self.checkoutFailed(with: error)
-                rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-            }
-            
+            self.primerDidResumeWithDecisionHandler?(nil, nil)
+            self.primerDidResumeWithDecisionHandler = nil
+            resolver(nil)
         }
     }
     
     @objc
-    public func handleNewClientToken(_ clientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handleResumeFailure(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            self.callCallbackWithClientToken(clientToken)
+            self.primerDidResumeWithDecisionHandler?(nil, errorMessage ?? "")
+            self.primerDidResumeWithDecisionHandler = nil
             resolver(nil)
         }
     }
     
+    // MARK: Payment Creation
+    
     @objc
-    public func handleError(_ errorStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handlePaymentCreationAbort(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            do {
-                guard let errorData = errorStr.data(using: .utf8) else {
-                    let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to convert string to data"])
-                    throw err
-                }
-                
-                let err = try JSONDecoder().decode(NativeError.self, from: errorData)
-                self.callCallbackWithError(err)
-                resolver(nil)
-            } catch {
-                self.checkoutFailed(with: error)
-                rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-            }
+            self.primerWillCreatePaymentWithDataDecisionHandler?(errorMessage ?? "")
+            self.primerWillCreatePaymentWithDataDecisionHandler = nil
+            resolver(nil)
         }
     }
     
     @objc
-    public func handleSuccess(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    public func handlePaymentCreationContinue(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
-            self.callCallbackToContinueFlow()
+            self.primerWillCreatePaymentWithDataDecisionHandler?(nil)
+            self.primerWillCreatePaymentWithDataDecisionHandler = nil
             resolver(nil)
         }
     }
     
+    // MARK: Error Handler
+    
+    @objc
+    public func showErrorMessage(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidFailWithErrorDecisionHandler?(errorMessage ?? "")
+            self.primerDidFailWithErrorDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+    
+    // MARK: Helpers
+        
+    private func configure(settingsStr: String? = nil) throws {
+        try PrimerSDK.Primer.shared.configure(settings: PrimerSettings.initialize(with: settingsStr), delegate: self)
+    }
+    
+    private func detectImplemetedCallbacks() {
+        sendEvent(withName: PrimerEvents.detectImplementedRNCallbacks.stringValue, body: nil)
+    }
+    
     @objc
     public func setImplementedRNCallbacks(_ implementedRNCallbacksStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
         DispatchQueue.main.async {
@@ -202,207 +268,192 @@ class RNTPrimer: RCTEventEmitter {
                     let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to convert string to data"])
                     throw err
                 }
-                self.implementedReactNativeCallbacks = try JSONDecoder().decode(ImplementedReactNativeCallbacks.self, from: implementedRNCallbacksData)
-                Primer.shared.setImplementedReactNativeCallbacks(self.implementedReactNativeCallbacks!)
+                self.implementedRNCallbacks = try JSONDecoder().decode(ImplementedRNCallbacks.self, from: implementedRNCallbacksData)
                 resolver(nil)
             } catch {
-                self.checkoutFailed(with: error)
+                self.primerDidFailWithError(error, data: nil) { decisionHandler in
+                    
+                }
                 rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
             }
         }
     }
     
-    // MARK: - HELPERS
-    
-    private func configure(settingsStr: String? = nil, themeStr: String? = nil) throws {
-        var settings: PrimerSettings?
-        if let settingsStr = settingsStr {
-            guard let settingsData = settingsStr.data(using: .utf8) else {
-                let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to convert string to data"])
-                throw err
+    private func handleRNBridgeError(_ error: Error, checkoutData: PrimerCheckoutData?, stopOnDebug: Bool) {
+        DispatchQueue.main.async {
+            if stopOnDebug {
+                assertionFailure(error.localizedDescription)
             }
-            let settingsRN = try JSONDecoder().decode(PrimerSettingsRN.self, from: settingsData)
-            settings = settingsRN.asPrimerSettings()
-        }
-        
-        var theme: PrimerTheme?
-        if let themeStr = themeStr {
-            guard let themeData = themeStr.data(using: .utf8) else {
-                let err = NSError(domain: "native-bridge", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to convert string to data"])
-                throw err
+            
+            var body: [String: Any] = ["error": error.rnError]
+            if let checkoutData = checkoutData,
+               let data = try? JSONEncoder().encode(checkoutData),
+               let json = try? JSONSerialization.jsonObject(with: data){
+                body["checkoutData"] = json
             }
-            let themeRN = try JSONDecoder().decode(PrimerThemeRN.self, from: themeData)
-            theme = themeRN.asPrimerTheme()
+            print(body)
+            self.sendEvent(withName: PrimerEvents.onError.stringValue, body: body)
         }
-    
-        PrimerSDK.Primer.shared.configure(settings: settings, theme: theme)
-    }
-    
-    private func detectImplemetedCallbacks() {
-        sendEvent(withName: PrimerEvents.detectImplementedRNCallbacks.stringValue, body: nil)
-    }
-    
-    private func callCallbackWithClientToken(_ clientToken: String) {
-        self.clientTokenCallback?(clientToken, nil)
-        self.onClientSessionActions?(clientToken, nil)
-        self.onTokenizeSuccess?(clientToken, nil)
-        self.onResumeSuccess?(clientToken, nil)
-        self.removeCallbacksAndHandlers()
-    }
-    
-    private func callCallbackWithError(_ err: Error) {
-        self.clientTokenCallback?(nil, err)
-        self.onClientSessionActions?(nil, err)
-        self.onTokenizeSuccess?(nil, err)
-        self.onResumeSuccess?(nil, err)
-        self.removeCallbacksAndHandlers()
-    }
-    
-    private func callCallbackToContinueFlow() {
-        self.clientTokenCallback?(nil, nil)
-        self.onClientSessionActions?(nil, nil)
-        self.onTokenizeSuccess?(nil, nil)
-        self.onResumeSuccess?(nil, nil)
-        self.removeCallbacksAndHandlers()
-    }
-    
-    private func removeCallbacksAndHandlers() {
-        self.clientTokenCallback = nil
-        self.onClientSessionActions = nil
-        self.onTokenizeSuccess = nil
-        self.onResumeSuccess = nil
     }
-
 }
 
+// MARK: - PRIMER DELEGATE
+
 extension RNTPrimer: PrimerDelegate {
     
-    func clientTokenCallback(_ completion: @escaping (String?, Error?) -> Void) {
+    func primerDidCompleteCheckoutWithData(_ data: PrimerCheckoutData) {
         DispatchQueue.main.async {
-            if self.implementedReactNativeCallbacks?.isClientTokenCallbackImplemented == true {
-                self.clientTokenCallback = { (clientToken, err) in
-                    completion(clientToken, err)
-                    self.removeCallbacksAndHandlers()
+            if self.implementedRNCallbacks?.isOnCheckoutCompleteImplemented == true {
+                do {
+                    let checkoutData = try JSONEncoder().encode(data)
+                    let checkoutJson = try JSONSerialization.jsonObject(with: checkoutData, options: .allowFragments)
+                    self.sendEvent(withName: PrimerEvents.onCheckoutComplete.stringValue, body: checkoutJson)
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: data, stopOnDebug: true)
                 }
-                self.sendEvent(withName: PrimerEvents.onClientTokenCallback.stringValue, body: nil)
             } else {
-                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [clientTokenCallback] should had been implemented."])
-                completion(nil, err)
+                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [onCheckoutComplete] should be implemented."])
+                self.handleRNBridgeError(err, checkoutData: data, stopOnDebug: false)
             }
         }
     }
     
-    func onClientSessionActions(_ actions: [ClientSession.Action], resumeHandler: ResumeHandlerProtocol?) {
-        DispatchQueue.main.async {
-            if self.implementedReactNativeCallbacks?.isClientSessionActionsImplemented == true {
-                self.onClientSessionActions = { (newClientToken, err) in
-                    if let err = err {
-                        resumeHandler?.handle(error: err)
-                    } else if let newClientToken = newClientToken {
-                        resumeHandler?.handle(newClientToken: newClientToken)
+    func primerWillCreatePaymentWithData(_ data: PrimerCheckoutPaymentMethodData, decisionHandler: @escaping (PrimerPaymentCreationDecision) -> Void) {
+        if self.implementedRNCallbacks?.isOnBeforePaymentCreateImplemented == true {
+            self.primerWillCreatePaymentWithDataDecisionHandler = { errorMessage in
+                DispatchQueue.main.async {
+                    if let errorMessage = errorMessage {
+                        decisionHandler(.abortPaymentCreation(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
                     } else {
-                        resumeHandler?.handleSuccess()
+                        decisionHandler(.continuePaymentCreation())
                     }
                 }
-                
+            }
+            
+            DispatchQueue.main.async {
                 do {
-                    let actionsData = try JSONEncoder().encode(actions)
-                    let actionsJson = try JSONSerialization.jsonObject(with: actionsData, options: .allowFragments)
-                    self.sendEvent(withName: PrimerEvents.onClientSessionActions.stringValue, body: actionsJson)
+                    let checkoutPaymentmethodData = try JSONEncoder().encode(data)
+                    let checkoutPaymentmethodJson = try JSONSerialization.jsonObject(with: checkoutPaymentmethodData, options: .allowFragments)
+                    self.sendEvent(withName: PrimerEvents.onBeforePaymentCreate.stringValue, body: checkoutPaymentmethodJson)
                 } catch {
-                    self.checkoutFailed(with: error)
+                    self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
                 }
-            } else {
-                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [onClientSessionActions] should had been implemented."])
-                resumeHandler?.handle(error: err)
             }
-            
+        } else {
+            // RN Dev hasn't implemented this callback, send a decision to continue the flow.
+            DispatchQueue.main.async {
+                decisionHandler(.continuePaymentCreation())
+            }
         }
     }
     
-    func tokenAddedToVault(_ token: PaymentMethodToken) {
-        DispatchQueue.main.async {
-            if self.implementedReactNativeCallbacks?.isTokenAddedToVaultImplemented == true {
-                do {
-                    let paymentMethodTokenData = try JSONEncoder().encode(token)
-                    let paymentMethodTokenJson = try JSONSerialization.jsonObject(with: paymentMethodTokenData, options: .allowFragments)
-                    self.sendEvent(withName: PrimerEvents.onVaultSuccess.stringValue, body: paymentMethodTokenJson)
-                } catch {
-                    self.checkoutFailed(with: error)
-                }
+    func primerClientSessionWillUpdate() {
+        if self.implementedRNCallbacks?.isOnBeforeClientSessionUpdateImplemented == true {
+            DispatchQueue.main.async {
+                self.sendEvent(withName: PrimerEvents.onBeforeClientSessionUpdate.stringValue, body: nil)
             }
+        } else {
+            // RN Dev hasn't implemented this callback, ignore.
         }
     }
     
-    func onTokenizeSuccess(_ paymentMethodToken: PaymentMethodToken, resumeHandler: ResumeHandlerProtocol) {
-        DispatchQueue.main.async {
-            self.onTokenizeSuccess = { (newClientToken, err) in
-                if let err = err {
-                    resumeHandler.handle(error: err)
-                } else if let newClientToken = newClientToken {
-                    resumeHandler.handle(newClientToken: newClientToken)
-                } else {
-                    resumeHandler.handleSuccess()
-                }
-            }
-            
+    func primerClientSessionDidUpdate(_ clientSession: PrimerClientSession) {
+        if self.implementedRNCallbacks?.isOnClientSessionUpdateImplemented == true {
             do {
-                let paymentMethodTokenData = try JSONEncoder().encode(paymentMethodToken)
-                let paymentMethodTokenJson = try JSONSerialization.jsonObject(with: paymentMethodTokenData, options: .allowFragments)
-                self.sendEvent(withName: PrimerEvents.onTokenizeSuccessCallback.stringValue, body: paymentMethodTokenJson)
+                let data = try JSONEncoder().encode(clientSession)
+                let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
+                DispatchQueue.main.async {
+                    self.sendEvent(withName: PrimerEvents.onClientSessionUpdate.stringValue, body: json)
+                }
             } catch {
-                self.checkoutFailed(with: error)
+                self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
             }
+        } else {
+            // RN Dev hasn't implemented this callback, ignore.
         }
     }
     
-    func onResumeSuccess(_ clientToken: String, resumeHandler: ResumeHandlerProtocol) {
-        DispatchQueue.main.async {
-            if self.implementedReactNativeCallbacks?.isOnResumeSuccessImplemented == true {
-                self.onResumeSuccess = { (newClientToken, err) in
-                    if let err = err {
-                        resumeHandler.handle(error: err)
+    func primerDidTokenizePaymentMethod(_ paymentMethodTokenData: PrimerPaymentMethodTokenData, decisionHandler: @escaping (PrimerResumeDecision) -> Void) {
+        if self.implementedRNCallbacks?.isOnTokenizeSuccessImplemented == true {
+            self.primerDidTokenizePaymentMethodDecisionHandler = { (newClientToken, errorMessage) in
+                DispatchQueue.main.async {
+                    if let errorMessage = errorMessage {
+                        decisionHandler(.fail(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
                     } else if let newClientToken = newClientToken {
-                        resumeHandler.handle(newClientToken: newClientToken)
+                        decisionHandler(.continueWithNewClientToken(newClientToken))
                     } else {
-                        resumeHandler.handleSuccess()
+                        decisionHandler(.succeed())
                     }
                 }
-                
-                self.sendEvent(withName: PrimerEvents.onResumeSuccess.stringValue, body: ["resumeToken": clientToken])
-            } else {
-                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [onResumeSuccess] should had been implemented."])
-                resumeHandler.handle(error: err)
             }
+            
+            do {
+                let data = try JSONEncoder().encode(paymentMethodTokenData)
+                let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
+                DispatchQueue.main.async {
+                    self.sendEvent(withName: PrimerEvents.onTokenizeSuccess.stringValue, body: json)
+                }
+            } catch {
+                self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+            }
+        } else {
+            // RN dev hasn't opted in on listening the tokenization callback.
+            // Throw an error if it's the manual flow, ignore if it's the
+            // auto flow.
         }
     }
     
-    func onResumeError(_ error: Error) {
-        DispatchQueue.main.async {
-            if self.implementedReactNativeCallbacks?.isOnResumeErrorImplemented == true {
-                self.checkoutFailed(with: error)
-            } else {
-                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [onResumeError] should had been implemented."])
-                self.checkoutFailed(with: err)
+    func primerDidResumeWith(_ resumeToken: String, decisionHandler: @escaping (PrimerResumeDecision) -> Void) {
+        if self.implementedRNCallbacks?.isOnResumeSuccessImplemented == true {
+            self.primerDidResumeWithDecisionHandler = { (resumeToken, errorMessage) in
+                DispatchQueue.main.async {
+                    if let errorMessage = errorMessage {
+                        decisionHandler(.fail(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
+                    } else if let resumeToken = resumeToken {
+                        decisionHandler(.continueWithNewClientToken(resumeToken))
+                    } else {
+                        decisionHandler(.succeed())
+                    }
+                }
+            }
+            
+            DispatchQueue.main.async {
+                self.sendEvent(withName: PrimerEvents.onResumeSuccess.stringValue, body: ["resumeToken": resumeToken])
             }
+        } else {
+            // RN dev hasn't opted in on listening the tokenization callback.
+            // Throw an error if it's the manual flow.
         }
     }
     
-    func onCheckoutDismissed() {
-        DispatchQueue.main.async {
-            if self.implementedReactNativeCallbacks?.isOnCheckoutDismissedImplemented == true {
-                self.sendEvent(withName: PrimerEvents.onCheckoutDismissed.stringValue, body: nil)
-            } else {
-                let err = NSError(domain: "native-bridge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Callback [onCheckoutDismissed] should had been implemented."])
-                self.checkoutFailed(with: err)
+    func primerDidDismiss() {
+        if self.implementedRNCallbacks?.isOnDismissImplemented == true {
+            DispatchQueue.main.async {
+                self.sendEvent(withName: PrimerEvents.onDismiss.stringValue, body: nil)
             }
+        } else {
+            // RN dev hasn't opted in on listening SDK dismiss.
+            // Ignore!
         }
     }
     
-    func checkoutFailed(with error: Error) {
-        DispatchQueue.main.async {
-            self.sendEvent(withName: PrimerEvents.onError.stringValue, body: ["error": error.rnError])
+    func primerDidFailWithError(_ error: Error, data: PrimerCheckoutData?, decisionHandler: @escaping ((PrimerErrorDecision) -> Void)) {
+        if self.implementedRNCallbacks?.isOnErrorImplemented == true {
+            // Set up the callback that will be called by **handleErrorMessage** when the RN
+            // bridge invokes it.
+            self.primerDidFailWithErrorDecisionHandler = { errorMessage in
+                // Callback was called by **handleErrorMessage**.
+                DispatchQueue.main.async {
+                    decisionHandler(.fail(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
+                }
+            }
+            
+            // Send the error message to the RN bridge.
+            self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: false)
+            
+        } else {
+            // RN dev hasn't opted in on listening SDK dismiss.
+            // Ignore!
         }
     }
-    
 }

package/ios/ReactNative-Bridging-Header.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>