@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/ios/HydraSDK/HydraInboxUI.swift

@@ -0,0 +1,105 @@
+//
+//  HydraInboxUI.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 01/01/25.
+//
+
+import Foundation
+import HydraCore
+import HydraInboxUI
+import React
+
+@objc public final class HydraInboxUI : NSObject{
+  @objc public static let shared = HydraInboxUI()
+  
+  private var inboxUICore : InboxUICore? = nil
+  private var navigationController : UINavigationController? = nil
+  private var hydraNotificationController : UIViewController? = nil
+  
+  private override init(){
+    
+  }
+  
+  func setNavigationController(navController : UINavigationController){
+    self.navigationController = navController
+  }
+  
+  func initializeInboxUICore(inboxUIConfigDict : [String : Any]?){
+    let placeholderImage: UIImage? = UIImage(named: "inboxUIPlaceholder")
+    if placeholderImage == nil{
+      Logger.info("HydraLib: HydraInboxUI.initializeInboxUICore: inboxUIPlaceholder image for InboxUI not found in Images.xcassets, the image must be named \"inboxUIPlaceholder\"")
+    }
+    
+    var inboxUnreadConfig: HydraReactNativeInboxUIConfiguration? = nil
+    var inboxReadConfig: HydraReactNativeInboxUIConfiguration? = nil
+    var emptyNotificationsConfig: HydraInboxEmptyNotificationsConfiguration? = nil
+    
+    
+    if let unreadMessageConfigDict = inboxUIConfigDict?["UNREAD_MESSAGE_CONFIG"] as? Dictionary<String, Any>{
+      inboxUnreadConfig = unreadMessageConfigDict.toHydraRNInboxUIConfiguration(InboxUIConfigurationType.unread)
+    }
+    else{
+      Logger.info("HydraLib: HydraInboxUI.initializeInboxUICore: UNREAD_MESSAGE_CONFIG missing")
+    }
+    
+    if let readMessageConfigDict = inboxUIConfigDict?["READ_MESSAGE_CONFIG"] as? Dictionary<String, Any>{
+      inboxReadConfig = readMessageConfigDict.toHydraRNInboxUIConfiguration(InboxUIConfigurationType.read)
+    }
+    else{
+      Logger.info("HydraLib: HydraInboxUI.initializeInboxUICore: READ_MESSAGE_CONFIG missing")
+    }
+    
+    if let emptyNotificationsConfigDict = inboxUIConfigDict?["EMPTY_INBOX_CONFIG"] as? Dictionary<String, Any>{
+      emptyNotificationsConfig = emptyNotificationsConfigDict.toHydraInboxEmptyNotificationsConfig()
+    }
+    else{
+      Logger.info("HydraLib: HydraInboxUI.initializeInboxUICore: EMPTY_INBOX_CONFIG missing")
+    }
+    
+    
+    let inboxUIConfig = HydraInboxUIConfiguration(
+      unreadMessageConfigType: inboxUnreadConfig != nil ? .customReactNativeConfiguration(inboxUnreadConfig!) : .defaultUnreadConfiguration,
+      readMessageConfigType: inboxReadConfig != nil ?.customReactNativeConfiguration(inboxReadConfig!) : .defaultReadConfiguration,
+      notificationsNotFoundConfiguration:emptyNotificationsConfig,
+      placeholderImage: placeholderImage
+    )
+    
+    inboxUICore = InboxUICore(with: HydraInbox.shared.inboxCore!, configuration: inboxUIConfig)
+    Logger.info("HydraLib: HydraInboxUI.initializeInboxUICore: Created InboxUICore")
+  }
+  
+  @objc public func showNotificationCenter(_ resolve : RCTPromiseResolveBlock?, reject : RCTPromiseRejectBlock? ){
+    if self.inboxUICore != nil{
+      DispatchQueue.main.async{
+        guard let notificationCenter = self.inboxUICore?.getNotificationCenter() else { return}
+        self.navigationController?.pushViewController(notificationCenter, animated: true)
+        self.hydraNotificationController = notificationCenter
+      }
+      resolve?(true)
+      return
+    }
+    resolve?(false)
+  }
+  
+  @objc public func hideNotificationCenterIfShowing(_ resolve : RCTPromiseResolveBlock?, reject : RCTPromiseRejectBlock? ){
+    if self.navigationController != nil && self.hydraNotificationController != nil{
+      DispatchQueue.main.async{
+        self.navigationController?.popViewController(animated: true)
+      }
+      resolve?(true)
+      return
+    }
+    resolve?(false)
+    
+  }
+  
+  func navigationControllerViewWillChange(_ upcomingViewController: UIViewController){
+    if hydraNotificationController != nil && upcomingViewController != hydraNotificationController{
+      hydraNotificationController = nil
+      HydraInbox.shared.setHydraInboxUIDelegate()
+      HydraEventEmitter.shared.sendEvent(HydraEventType.ON_NOTIFICATION_CENTER_DISMISSED.rawValue, body: "")
+    }
+    navigationController?.setNavigationBarHidden(hydraNotificationController == nil || upcomingViewController != hydraNotificationController, animated: false)
+  }
+}

package/ios/HydraSDK/HydraPushNotification.swift

@@ -0,0 +1,476 @@
+//
+//  HydraPushNotification.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 01/01/25.
+//
+
+import Foundation
+import HydraPushNotification
+import HydraCore
+import React
+import HydraInAppMessage
+
+@objc public final class HydraPushNotification : NSObject{
+  
+  @objc public static let shared = HydraPushNotification()
+  
+  private var fcmToken : String?
+  let notificationCore: NotificationCore?
+  var fcmTokenSetInNotificationCore: Bool = false
+  
+  private override init() {
+    notificationCore = NotificationCore.shared
+    super.init()
+    notificationCore?.setNotificationCallbackDelagte(delegate: self)
+  }
+  
+  @objc public func openExternalUrl(_ url: String, resolve: RCTPromiseResolveBlock?, reject: RCTPromiseRejectBlock?) {
+    guard let targetURL = URL(string: url) else {
+      reject?("INVALID_URL", "Invalid URL: \(url)", nil)
+      return
+    }
+    DispatchQueue.main.async {
+      UIApplication.shared.open(targetURL, options: [:], completionHandler: nil)
+    }
+    resolve?(nil)
+  }
+
+  @objc public func requestPermission(_ resolve : RCTPromiseResolveBlock?, reject : RCTPromiseRejectBlock? ) {
+    let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
+    let center = UNUserNotificationCenter.current()
+    center.requestAuthorization(options: authOptions) { granted, error in
+      if let error = error {
+        // Handle the error here.
+        Logger.error("HydraPushNotification: requestPermission: Error occurred due to :\(error.localizedDescription)")
+        reject?("ERROR", "Error requesting permission", error)
+        return
+      }
+      
+      // Enable or disable features based on the authorization.
+//      if granted{
+//        Logger.info("HydraPushNotification: requestPermission: Application Granted permissions:\(granted)")
+//        DispatchQueue.main.async {
+//          UIApplication.shared.registerForRemoteNotifications()
+//        }
+//      }
+      HydraSDKCore.shared.hydra?.update(notificationSupport: granted )
+      resolve?(granted)
+    }
+  }
+  
+  @objc public func getFCMToken(_ resolve : RCTPromiseResolveBlock?, reject : RCTPromiseRejectBlock? ){
+    guard fcmToken != nil else{
+      Logger.debug("HydraPushNotification: getFCMToken: Did not receive the token yet")
+      reject?( "TOKEN_NOT_AVAILABLE", "Did not receive the token yet", nil)
+      return
+    }
+    
+    Logger.debug("HydraPushNotification: getFCMToken: returning fcm token = \(fcmToken!)")
+    resolve?(fcmToken!)
+  }
+  
+  
+  @objc public func messaging(_ messaging: Messaging, didReceiveRegistrationToken token: String?) {
+    Logger.debug("HydraPushNotification:  messaging:didReceiveRegistrationToken: token registered")
+    fcmToken = token
+    if let token, HydraSDKCore.shared.hydra != nil {
+      Task{
+        await HydraSDKCore.shared.hydra?.update(interfaceID: token)
+//        HydraSDKCore.shared.hydra?.reportUserSettingsUpdate()
+        fcmTokenSetInNotificationCore = true
+      }
+    }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 0.8){
+      HydraEventEmitter.shared.sendEvent(HydraEventType.ON_TOKEN_AVAILABLE.rawValue, body: self.fcmToken)
+    }
+  }
+  
+  func isCapillaryNotification(_ notification: UNNotification) -> Bool{
+    let senderSource = notification.request.content.userInfo[HydraConstants.Keys.APIRequestKeys.senderSource] as? String ?? ""
+    return senderSource.hasPrefix("capillary")
+  }
+  
+  func canSendNotificationEventToRN(_ payload: HydraNotificationPayload) -> Bool{
+    let loggedInUserId = Hydra.getSharedUserDefaults()?.customerId() ?? ""
+    return NotificationCore.isAllowed() && payload.cuid == loggedInUserId && Hydra.isValidNotification(notification: payload)
+  }
+  
+  @objc public func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
+    Logger.debug("HydraPushNotification: userNotificationCenter:willPresent:withCompletionHandler received notification \n notification = \(notification)")
+    
+    if isCapillaryNotification(notification){
+      let payload = HydraNotificationPayload.generate(from: notification.request.content.userInfo)
+      if canSendNotificationEventToRN(payload){
+        HydraEventEmitter.shared.sendEvent(HydraEventType.ON_HYDRA_NOTIFICATION_RECEIVED.rawValue, body: payload.toDict())
+      }
+    }
+    else{
+      HydraEventEmitter.shared.sendEvent(HydraEventType.ON_NON_HYDRA_NOTIFICATION_RECEIVED.rawValue, body: nonHydraNotificationDict(from: notification.request.content.userInfo))
+    }
+    
+    let handler = notificationCore?.userNotification(center: center, willPresent: notification, withCompletionHandler: completionHandler)
+    if handler != nil{
+      getNotificationSettings { settings in
+        var allowedSettings = [UNNotificationPresentationOptions]()
+        if settings.soundSetting == .enabled {
+          allowedSettings.append(.sound)
+        }
+        if settings.badgeSetting == .enabled {
+          allowedSettings.append(.badge)
+        }
+        if settings.alertSetting == .enabled {
+          if #available(iOS 14.0, *) {
+            allowedSettings.append(.banner)
+          } else {
+            // Fallback on earlier versions
+            allowedSettings.append(.alert)
+          }
+        }
+        switch settings.authorizationStatus {
+          case .denied:
+              handler!([])
+          case .notDetermined:
+            Logger.debug("Permission not determined")
+            fallthrough
+          default:
+            handler!(.init(allowedSettings))
+        }
+      }
+    }
+    
+    if isCapillaryNotification(notification){
+      let payload = HydraNotificationPayload.generate(from: notification.request.content.userInfo)
+      if canSendNotificationEventToRN(payload){
+        HydraEventEmitter.shared.sendEvent(HydraEventType.ON_HYDRA_NOTIFICATION_SHOWN.rawValue, body: payload.toDict())
+      }
+    }
+  }
+  
+  @objc public func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void){
+    
+    if HydraSDKCore.shared.hydra == nil{
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.3){
+        self.userNotificationCenter(center, didReceive: response, withCompletionHandler: completionHandler)
+      }
+      return
+    }
+    
+    Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler notification reponse = \(response)")
+    let handler = notificationCore?.userNotification(center: center, didReceive: response, withCompletionHandler: completionHandler)
+    if handler != nil{
+      handler!()
+    }
+    
+    if isCapillaryNotification(response.notification){
+      
+      let payload = HydraNotificationPayload.generate(from: response.notification.request.content.userInfo)
+      
+      if canSendNotificationEventToRN(payload){
+        switch response.actionIdentifier {
+            
+          case UNNotificationDefaultActionIdentifier:
+            Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler: Default action identifier Hydra")
+            
+          case UNNotificationDismissActionIdentifier:
+            Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler: Dismiss action identifier Hydra")
+            HydraEventEmitter.shared.sendEvent(HydraEventType.ON_HYDRA_NOTIFICATION_DISMISSED.rawValue, body: payload.toDict())
+            
+          default:
+            Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler: Custom action identifier Hydra")
+        }
+      }
+    }
+    else{
+      switch response.actionIdentifier {
+          
+        case UNNotificationDefaultActionIdentifier:
+          Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler: Default action identifier NonHydra")
+          HydraEventEmitter.shared.sendEvent(HydraEventType.ON_NON_HYDRA_NOTIFICATION_CLICKED.rawValue, body: nonHydraNotificationDict(from: response.notification.request.content.userInfo))
+          
+        case UNNotificationDismissActionIdentifier:
+          Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler: Dismiss action identifier NonHydra")
+          
+        default:
+          Logger.debug("HydraPushNotification: userNotificationCenter:didReceive:withCompletionHandler: Custom action identifier NonHydra")
+      }
+    }
+  }
+  
+  func updateFcmToken() {
+    if !fcmTokenSetInNotificationCore && fcmToken != nil{
+      Task{
+        await HydraSDKCore.shared.hydra?.update(interfaceID: fcmToken!)
+        fcmTokenSetInNotificationCore = true
+      }
+    }
+  }
+  
+  func forceUpdateFcmToken() {
+    fcmTokenSetInNotificationCore = false
+    updateFcmToken()
+  }
+  
+  func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+  ){
+    Logger.debug("HydraPushNotification: application:didFinishLaunchingWithOptions")
+    notificationCore?.application(application, didFinishLaunchingWithOptions:launchOptions)
+    updateFcmToken()
+  }
+  
+  @objc public func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+    Logger.debug("HydraPushNotification: application:didRegisterForRemoteNotificationsWithDeviceToken")
+    if HydraSDKCore.shared.hydra == nil{
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.3){
+        self.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken)
+      }
+      return
+    }
+    Messaging.messaging().apnsToken = deviceToken
+    HydraSDKCore.shared.hydra?.application(application, didRegisterForRemoteNotificationsWithToken: deviceToken)
+//    notificationCore?.application(application, didRegisterForRemoteNotificationsWithToken: deviceToken)
+  }
+  
+  @objc public func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error) {
+    Logger.debug("HydraPushNotification: application:didFailToRegisterForRemoteNotificationsWithError error = \(error.localizedDescription)")
+//    if HydraSDKCore.shared.hydra == nil{
+//      DispatchQueue.main.asyncAfter(deadline: .now() + 0.3){
+//        self.application(application, didFailToRegisterForRemoteNotificationsWithError: error)
+//      }
+//      return
+//    }
+//    notificationCore?.application(application, didFailToRegisterForRemoteNotificationsWithError: error)
+  }
+  
+  @objc public func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    Logger.debug("HydraPushNotification: application:didReceiveRemoteNotification:fetchCompletionHandler: userInfo = \(userInfo) ")
+//    if HydraSDKCore.shared.hydra == nil{
+//      DispatchQueue.main.asyncAfter(deadline: .now() + 0.3){
+//        self.application(application, didReceiveRemoteNotification: userInfo, fetchCompletionHandler: completionHandler)
+//      }
+//      return
+//    }
+    Messaging.messaging().appDidReceiveMessage(userInfo)
+    let _ = InAppMessagingCore.application(application, didReceiveRemoteNotification: userInfo, fetchCompletionHandler: completionHandler)
+  }
+  
+  func nonHydraNotificationDict(from rawUserInfo : [AnyHashable : Any] ) -> [String: Any]{
+    var message : [String: Any] = [:]
+    var data : [String: Any] = [:]
+    var notification : [String: Any] = [:]
+    var notificationIOS : [String: Any] = [:]
+    
+    let userInfo = Dictionary(uniqueKeysWithValues: rawUserInfo.compactMap { k, v -> (String, Any)? in
+      if let ks = k as? String {
+        return (ks, v)
+      }
+      return nil
+    })
+    
+    // message.data
+    userInfo.forEach{ key, value in
+      // message.messageId
+      if key == "gcm.message_id" || key == "google.message_id" ||
+          key == "message_id" {
+        message["messageId"] = userInfo[key]
+        return
+      }
+      
+      // message.messageType
+      if key == "message_type" {
+        message["messageType"] = userInfo[key]
+        return
+      }
+      
+      // message.collapseKey
+      if key == "collapse_key" {
+        message["collapseKey"] = userInfo[key]
+        return
+      }
+      
+      // message.from
+      if key == "from" {
+        message["from"] = userInfo[key]
+        return
+      }
+      
+      // message.sentTime
+      if key  == "google.c.a.ts" {
+        message["sentTime"] = userInfo[key]
+        return
+      }
+      
+      // message.to
+      if key == "to" || key == "google.to" {
+        message["to"] = userInfo[key]
+        return
+      }
+      
+      // build data dict from remaining keys but skip keys that shouldn't be included in data
+      if key == "aps" || key.hasPrefix("gcm.") || key.hasPrefix("google.") {
+        return
+      }
+      
+      // message.apple.imageUrl
+      if key == "fcm_options" {
+        if userInfo[key] != nil && (userInfo[key] as! [String : Any])["image"] != nil {
+          notificationIOS["imageUrl"] = (userInfo[key] as! [String : Any])["image"]
+        }
+        return
+      }
+      
+      data[key] = userInfo[key];
+    }
+    message["data"] = data;
+    
+    if userInfo["aps"] != nil {
+      let apsDict : [String : Any] = userInfo["aps"] as! [String : Any]
+      // message.category
+      if apsDict["category"] != nil {
+        message["category"] = apsDict["category"]
+      }
+      
+      // message.threadId
+      if apsDict["thread-id"] != nil {
+        message["threadId"] = apsDict["thread-id"]
+      }
+      
+      // message.contentAvailable
+      if apsDict["content-available"] != nil {
+        message["contentAvailable"] = (apsDict["content-available"] as! Bool)
+      }
+      
+      // message.mutableContent
+      if apsDict["mutable-content"] != nil && apsDict["mutable-content"] as! Int == 1 {
+        message["mutableContent"] = (apsDict["mutable-content"] as! Int) == 1
+      }
+      
+      // message.notification.*
+      if apsDict["alert"] != nil {
+        // can be a string or dictionary
+        if apsDict["alert"] is String {
+          // message.notification.title
+          notification["title"] = apsDict["alert"]
+        } else if apsDict["alert"] is [String:Any] {
+          let apsAlertDict = apsDict["alert"] as! [String:Any]
+          
+          // message.notification.title
+          if apsAlertDict["title"] != nil {
+            notification["title"] = apsAlertDict["title"]
+          }
+          
+          // message.notification.titleLocKey
+          if apsAlertDict["title-loc-key"] != nil {
+            notification["titleLocKey"] = apsAlertDict["title-loc-key"]
+          }
+          
+          // message.notification.titleLocArgs
+          if apsAlertDict["title-loc-args"] != nil {
+            notification["titleLocArgs"] = apsAlertDict["title-loc-args"]
+          }
+          
+          // message.notification.body
+          if apsAlertDict["body"] != nil {
+            notification["body"] = apsAlertDict["body"]
+          }
+          
+          // message.notification.bodyLocKey
+          if apsAlertDict["loc-key"] != nil {
+            notification["bodyLocKey"] = apsAlertDict["loc-key"]
+          }
+          
+          // message.notification.bodyLocArgs
+          if apsAlertDict["loc-args"] != nil {
+            notification["bodyLocArgs"] = apsAlertDict["loc-args"]
+          }
+          
+          // Apple only
+          // message.notification.apple.subtitle
+          if apsAlertDict["subtitle"] != nil {
+            notificationIOS["subtitle"] = apsAlertDict["subtitle"]
+          }
+          
+          // Apple only
+          // message.notification.apple.subtitleLocKey
+          if apsAlertDict["subtitle-loc-key"] != nil {
+            notificationIOS["subtitleLocKey"] = apsAlertDict["subtitle-loc-key"]
+          }
+          
+          // Apple only
+          // message.notification.apple.subtitleLocArgs
+          if apsAlertDict["subtitle-loc-args"] != nil {
+            notificationIOS["subtitleLocArgs"] = apsAlertDict["subtitle-loc-args"]
+          }
+          
+          // Apple only
+          // message.notification.apple.badge
+          if apsDict["badge"] != nil {
+            notificationIOS["badge"] = "\(apsDict["badge"] ?? "")"
+          }
+        }
+        
+        notification["apple"] = notificationIOS;
+        message["notification"] = notification;
+      }
+      
+      // message.notification.apple.sound
+      if apsDict["sound"] != nil {
+        if apsDict["sound"] is String {
+          // message.notification.apple.sound
+          notification["sound"] = [
+            "name" : apsDict["sound"],
+            "critical" : false,
+            "volume" : 1,
+          ];
+        } else if apsDict["sound"] is Dictionary<String, Any> {
+          let apsSoundDict = apsDict["sound"] as! [String:Any]
+          var notificationIOSSound : [String:Any] = [:]
+          
+          // message.notification.apple.sound.name String
+          if apsSoundDict["name"] != nil {
+            notificationIOSSound["name"] = apsSoundDict["name"]
+          }
+          
+          // message.notification.apple.sound.critical Boolean
+          if apsSoundDict["critical"] != nil {
+            notificationIOSSound["critical"] = (apsSoundDict["critical"] as! Bool)
+          }
+          
+          // message.notification.apple.sound.volume Number
+          if apsSoundDict["volume"] != nil {
+            notificationIOSSound["volume"] = apsSoundDict["volume"]
+          }
+          
+          // message.notification.apple.sound
+          notificationIOS["sound"] = notificationIOSSound
+        }
+        
+        notification["apple"] = notificationIOS
+        message["notification"] = notification
+      }
+    }
+    
+    return message;
+  }
+
+  fileprivate func getNotificationSettings(completionHandler: @escaping (UNNotificationSettings) -> Void) {
+    UNUserNotificationCenter.current().getNotificationSettings { settings in
+      completionHandler(settings)
+    }
+  }
+}
+
+extension HydraPushNotification : HydraNotificationCallbackDelegate{
+  public func process(cta: CTA, notificationPayload payload: Any) -> Bool {
+    var notificationDict: [String:Any] = [:]
+    notificationDict["cta"] = cta.toDict()
+    if payload is HydraNotificationPayload{
+      notificationDict["payload"] = (payload as? HydraNotificationPayload)!.toDict()
+    }
+    Logger.debug("HydraPushNotification: processCta: Hydra Notification Clicked: notification = \(notificationDict)")
+    HydraEventEmitter.shared.sendEvent(HydraEventType.ON_HYDRA_NOTIFICATION_CLICKED.rawValue, body: notificationDict)
+    return true
+  }
+}