...
import MobileMessaging
...

  // Push: forward device token to MobileMessaging
  public override func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
  ) {
    MobileMessaging.didRegisterForRemoteNotificationsWithDeviceToken(deviceToken)
    super.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken)
  }
  
    // Push: forward remote notifications to MobileMessaging
  public override func application(
    _ application: UIApplication,
    didReceiveRemoteNotification userInfo: [AnyHashable: Any],
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
  ) {
    MobileMessaging.didReceiveRemoteNotification(userInfo, fetchCompletionHandler: completionHandler)
    super.application(application, didReceiveRemoteNotification: userInfo, fetchCompletionHandler: completionHandler)
  }
  ...

//
//  NotificationService.swift
//  MobileMessagingReactNative
//
//  Copyright (c) 2016-2026 Infobip Limited
//  Licensed under the Apache License, Version 2.0
//

import UserNotifications
import MobileMessaging

class NotificationService: UNNotificationServiceExtension {

  var contentHandler: ((UNNotificationContent) -> Void)?
  var originalContent: UNNotificationContent?

  override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
    self.contentHandler = contentHandler
    self.originalContent = request.content

    // Check if notification is from Infobip
    if MM_MTMessage.isCorrectPayload(request.content.userInfo) {
        MobileMessagingNotificationServiceExtension.didReceive(request, withContentHandler: contentHandler)
    } else {
        // Pass through non-Infobip notifications
        contentHandler(request.content)
    }
  }

  override func serviceExtensionTimeWillExpire() {
    MobileMessagingNotificationServiceExtension.serviceExtensionTimeWillExpire()
    if let originalContent = originalContent {
      contentHandler?(originalContent)
    }
  }
}

import Foundation
  import UserNotifications

  extension MobileMessaging {
      public func withAppGroupId(_ appGroupId: String) -> MobileMessaging {
          NSLog("[MM-NSE] withAppGroupId called with: %@", appGroupId)
          self.appGroupId = appGroupId
          self.sharedNotificationExtensionStorage = DefaultSharedDataStorage(applicationCode: applicationCode, appGroupId: appGroupId)
          return self
      }
  }

  extension MM_MTMessage {

      @discardableResult func downloadImageAttachment(appGroupId: String? = nil, completion: @escaping (URL?, Error?) -> Void) -> RetryableDownloadTask? {
          guard let contentURL = contentUrl?.safeUrl else {
              NSLog("[MM-NSE] downloadImageAttachment: no contentUrl, skipping download")
              logDebug("could not init content url to download")
              completion(nil, nil)
              return nil
          }

          NSLog("[MM-NSE] downloadImageAttachment: downloading from %@", contentURL.absoluteString)

          let destinationResolver: (URL, URLResponse) -> URL = { _, _ -> URL in
              let ret = URL.attachmentDownloadDestinatioUrl(sourceUrl: contentURL, appGroupId: nil)
              NSLog("[MM-NSE] downloadImageAttachment: destination URL = %@", ret.absoluteString)
              return ret
          }

          let task = RetryableDownloadTask(attemptsCount: 3, contentUrl: contentURL, destinationResolver: destinationResolver, completion: { url, error in
              if let error = error {
                  NSLog("[MM-NSE] downloadImageAttachment: FAILED with error: %@", error.localizedDescription)
              } else if let url = url {
                  NSLog("[MM-NSE] downloadImageAttachment: SUCCESS, file at %@", url.absoluteString)
              } else {
                  NSLog("[MM-NSE] downloadImageAttachment: completed with no URL and no error")
              }
              completion(url, error)
          })
          logDebug("downloading rich content for message...")
          task.resume()

          return task
      }

  }

  @objcMembers
  final public class MobileMessagingNotificationServiceExtension: NSObject, NamedLogger {

      @available(*, deprecated, message: "The function is deprecated. You can safely delete the invocation from your code.")
      public class func startWithApplicationCode(_ code: String, appGroupId: String) { }

      @available(*, deprecated, message: "The function is deprecated. You can safely delete the invocation from your code.")
      public class func startWithApplicationCode(_ applicationCode: String) { }

      public class func didReceive(_ request: UNNotificationRequest,
                                   withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
          NSLog("[MM-NSE] didReceive(request) called, delegating to didReceive(content)")
          logDebug("did receive request \(request)")
          didReceive(content: request.content, withContentHandler: contentHandler)
      }

      public class func didReceive(content: UNNotificationContent,
                                   withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
          NSLog("[MM-NSE] didReceive(content) called")
          NSLog("[MM-NSE] sharedInstance is %@", sharedInstance == nil ? "nil" : "exists")

          if (sharedInstance == nil) {
              NSLog("[MM-NSE] initializing sharedInstance...")

              let applicationCode = MobileMessaging.keychain.applicationCode
              NSLog("[MM-NSE] applicationCode from keychain: %@", applicationCode ?? "nil ❌")

              guard let applicationCode = applicationCode else {
                  NSLog("[MM-NSE] ❌ FATAL: ApplicationCode not found in keychain. Extension CANNOT proceed.")
                  NSLog("[MM-NSE] ❌ contentHandler will NOT be called — notification will timeout after 30s")
                  return
              }

              let appGroupId = Bundle.mainAppBundle.appGroupId
              NSLog("[MM-NSE] appGroupId from mainAppBundle info.plist: %@", appGroupId ?? "nil ❌")

              guard let appGroupId = appGroupId else {
                  NSLog("[MM-NSE] ❌ FATAL: AppGroupId not defined in info.plist (key: com.mobilemessaging.app_group)")
                  NSLog("[MM-NSE] ❌ contentHandler will NOT be called — notification will timeout after 30s")
                  return
              }

              if sharedInstance == nil {
                  NSLog("[MM-NSE] creating new sharedInstance with appCode=%@ appGroupId=%@", applicationCode, appGroupId)
                  sharedInstance = MobileMessagingNotificationServiceExtension(appCode: applicationCode, appGroupId: appGroupId)
              }

              let storage = DefaultSharedDataStorage(applicationCode: applicationCode, appGroupId: appGroupId)
              NSLog("[MM-NSE] sharedNotificationExtensionStorage initialized: %@", storage != nil ? "YES" : "NO ❌")
              sharedInstance?.sharedNotificationExtensionStorage = storage
          }

          var result = content

          guard let sharedInstance = sharedInstance else {
              NSLog("[MM-NSE] ❌ sharedInstance is nil after init attempt")
              contentHandler(result)
              return
          }

          guard let mtMessage = MM_MTMessage(payload: result.userInfo,
                                      deliveryMethod: .push,
                                      seenDate: nil,
                                      deliveryReportDate: nil,
                                      seenStatus: .NotSeen,
                                      isDeliveryReportSent: false) else {
              NSLog("[MM-NSE] ❌ could not create MM_MTMessage from payload")
              logDebug("could not recognize message")
              contentHandler(result)
              return
          }

          NSLog("[MM-NSE] ✅ MM_MTMessage created, messageId: %@", mtMessage.messageId)
          NSLog("[MM-NSE] contentUrl: %@", mtMessage.contentUrl ?? "nil")

          let handlingGroup = DispatchGroup()

          NSLog("[MM-NSE] starting delivery report...")
          handlingGroup.enter()
          sharedInstance.reportDelivery(mtMessage) { error in
              if let error = error {
                  NSLog("[MM-NSE] delivery report FAILED: %@", error.localizedDescription)
              } else {
                  NSLog("[MM-NSE] ✅ delivery report succeeded")
              }
              mtMessage.isDeliveryReportSent = error == nil
              mtMessage.deliveryReportedDate = mtMessage.isDeliveryReportSent ? MobileMessaging.date.now : nil
              NSLog("[MM-NSE] saving message to shared storage...")
              logDebug("saving message to shared storage \(sharedInstance.sharedNotificationExtensionStorage.orNil)")
              sharedInstance.sharedNotificationExtensionStorage?.save(message: mtMessage)
              NSLog("[MM-NSE] message saved to shared storage")
              handlingGroup.leave()
          }

          NSLog("[MM-NSE] starting content retrieval (rich media download)...")
          handlingGroup.enter()
          sharedInstance.retrieveNotificationContent(for: mtMessage, originalContent: result) { updatedContent in
              NSLog("[MM-NSE] content retrieval completed")
              NSLog("[MM-NSE] attachments count: %d", updatedContent.attachments.count)
              result = updatedContent
              handlingGroup.leave()
          }

          handlingGroup.notify(queue: DispatchQueue.main) {
              NSLog("[MM-NSE] ✅ all async work done, calling contentHandler")
              NSLog("[MM-NSE] final title: %@", result.title)
              NSLog("[MM-NSE] final body: %@", result.body)
              logDebug("message handling finished")
              contentHandler(result)
          }
      }

      public class func serviceExtensionTimeWillExpire() {
          NSLog("[MM-NSE] ⚠️ serviceExtensionTimeWillExpire called!")
          sharedInstance?.currentTask?.cancel()
      }

      //MARK: Internal
      let sessionManager: DynamicBaseUrlHTTPSessionManager
      static var sharedInstance: MobileMessagingNotificationServiceExtension?
      init(appCode: String, appGroupId: String) {
          self.applicationCode = appCode
          self.appGroupId = appGroupId
          self.sessionManager = DynamicBaseUrlHTTPSessionManager(baseURL: URL(string: Consts.APIValues.prodDynamicBaseURLString)!, sessionConfiguration: MobileMessaging.urlSessionConfiguration, appGroupId:
  appGroupId)
          NSLog("[MM-NSE] sessionManager created with baseURL: %@", Consts.APIValues.prodDynamicBaseURLString)
      }

      private func retrieveNotificationContent(for message: MM_MTMessage, originalContent: UNNotificationContent, completion: @escaping (UNNotificationContent) -> Void) {
          NSLog("[MM-NSE] retrieveNotificationContent called")

          currentTask = message.downloadImageAttachment(appGroupId: appGroupId) { (downloadedFileUrl, error) in
              guard let downloadedFileUrl = downloadedFileUrl,
                  let mContent = (originalContent.mutableCopy() as? UNMutableNotificationContent),
                  let attachment = try? UNNotificationAttachment(identifier: downloadedFileUrl.absoluteString.sha256(), url: downloadedFileUrl, options: nil)
                  else
              {
                  if let error = error {
                      NSLog("[MM-NSE] retrieveNotificationContent: attachment creation failed with error: %@", error.localizedDescription)
                  } else {
                      NSLog("[MM-NSE] retrieveNotificationContent: no downloadedFileUrl or could not create attachment")
                  }
                  self.logDebug("rich content downloading completed, could not init content attachment")
                  completion(originalContent)
                  return
              }

              mContent.attachments = [attachment]
              NSLog("[MM-NSE] ✅ rich content attachment created successfully")
              self.logDebug("rich content downloading completed succesfully")
              completion((mContent.copy() as? UNNotificationContent) ?? originalContent)
          }
      }

      private func reportDelivery(_ message: MM_MTMessage, completion: @escaping (NSError?) -> Void) {
          NSLog("[MM-NSE] reportDelivery called for messageId: %@", message.messageId)
          deliveryReporter.report(applicationCode: applicationCode, messageIds: [message.messageId], completion: completion)
      }

      let appGroupId: String
      let applicationCode: String
      var currentTask: RetryableDownloadTask?
      var sharedNotificationExtensionStorage: AppGroupMessageStorage?
      lazy var deliveryReporter: DeliveryReporting! = DeliveryReporter()
  }

  protocol DeliveryReporting {
      func report(applicationCode: String, messageIds: [String], completion: @escaping (NSError?) -> Void)
  }

  class DeliveryReporter: DeliveryReporting, NamedLogger {
      func report(applicationCode: String, messageIds: [String], completion: @escaping (NSError?) -> Void) {
          NSLog("[MM-NSE] DeliveryReporter: reporting for messageIds: %@", messageIds.joined(separator: ", "))
          logDebug("reporting delivery for message ids \(messageIds)")
          guard let extensionInstance = MobileMessagingNotificationServiceExtension.sharedInstance, !messageIds.isEmpty else
          {
              NSLog("[MM-NSE] DeliveryReporter: ❌ no sharedInstance or empty messageIds")
              logDebug("[Notification Extension] could not report delivery")
              completion(nil)
              return
          }

          let pushRegId = MobileMessaging.keychain.pushRegId
          NSLog("[MM-NSE] DeliveryReporter: pushRegId = %@", pushRegId ?? "nil")
          logDebug("[Notification Extension] using pushRegId: \(pushRegId ?? "nil") for delivery report")

          let request = DeliveryReportRequest(applicationCode: applicationCode, pushRegistrationId: pushRegId, body: [Consts.DeliveryReport.dlrMessageIds: messageIds])

          extensionInstance.sessionManager.getDataResponse(request, queue: DispatchQueue.global(), completion: { (response, error) in
              if let error = error {
                  NSLog("[MM-NSE] DeliveryReporter: ❌ request failed: %@", error.localizedDescription)
              } else {
                  NSLog("[MM-NSE] DeliveryReporter: ✅ request succeeded")
              }
              completion(error)
          })
      }

  }

  protocol AppGroupMessageStorage {
      init?(applicationCode: String, appGroupId: String)
      func save(message: MM_MTMessage)
      func retrieveMessages() -> [MM_MTMessage]
      func cleanupMessages()
  }

  class DefaultSharedDataStorage: AppGroupMessageStorage {
      let applicationCode: String
      let appGroupId: String
      let storage: UserDefaults
      required init?(applicationCode: String, appGroupId: String) {
          guard let ud = UserDefaults.init(suiteName: appGroupId) else {
              NSLog("[MM-NSE] DefaultSharedDataStorage: ❌ could not init UserDefaults for suite: %@", appGroupId)
              return nil
          }
          NSLog("[MM-NSE] DefaultSharedDataStorage: ✅ UserDefaults initialized for suite: %@", appGroupId)
          self.appGroupId = appGroupId
          self.applicationCode = applicationCode
          self.storage = ud
      }

      func save(message: MM_MTMessage) {
          NSLog("[MM-NSE] DefaultSharedDataStorage: saving message %@", message.messageId)
          var savedMessageDicts = retrieveSavedPayloadDictionaries()
          var msgDict: MMStringKeyPayload = ["p": message.originalPayload, "dlr": message.isDeliveryReportSent]
          msgDict["dlrd"] = message.deliveryReportedDate
          savedMessageDicts.append(msgDict)
          if let data = try? NSKeyedArchiver.archivedData(withRootObject: savedMessageDicts, requiringSecureCoding: true) {
              storage.set(data, forKey: applicationCode)
              storage.synchronize()
              NSLog("[MM-NSE] DefaultSharedDataStorage: ✅ message saved, total messages: %d", savedMessageDicts.count)
          } else {
              NSLog("[MM-NSE] DefaultSharedDataStorage: ❌ failed to archive message data")
          }
      }

      func retrieveMessages() -> [MM_MTMessage] {
          let messageDataDicts = retrieveSavedPayloadDictionaries()
          let messages = messageDataDicts.compactMap({ messageDataTuple -> MM_MTMessage? in
              guard let payload = messageDataTuple["p"] as? MMStringKeyPayload, let dlrSent =  messageDataTuple["dlr"] as? Bool else
              {
                  return nil
              }
              let newMessage = MM_MTMessage(payload: payload,
                                         deliveryMethod: .local,
                                         seenDate: nil,
                                         deliveryReportDate: messageDataTuple["dlrd"] as? Date,
                                         seenStatus: .NotSeen,
                                         isDeliveryReportSent: dlrSent)
              return newMessage
          })
          NSLog("[MM-NSE] DefaultSharedDataStorage: retrieved %d messages", messages.count)
          return messages
      }

      func cleanupMessages() {
          storage.removeObject(forKey: applicationCode)
          NSLog("[MM-NSE] DefaultSharedDataStorage: messages cleaned up")
      }

      private func retrieveSavedPayloadDictionaries() -> [MMStringKeyPayload] {
          var payloadDictionaries = [MMStringKeyPayload]();
          if let data = storage.object(forKey: applicationCode) as? Data,
             let dictionaries = unarchiveMessageDictionaries(fromeData: data) {
              payloadDictionaries = dictionaries
          } else if let dictionaries = storage.object(forKey: applicationCode) as? [MMStringKeyPayload] {
              payloadDictionaries = dictionaries
          }
          return payloadDictionaries
      }

      private func unarchiveMessageDictionaries(fromeData data: Data) -> [MMStringKeyPayload]? {
          do {
              return try NSKeyedUnarchiver.unarchivedObject(ofClasses: [NSArray.self, NSDictionary.self, NSNull.self, NSString.self, NSNumber.self, NSDate.self], from: data) as? [MMStringKeyPayload]
          } catch {
              NSLog("[MM-NSE] DefaultSharedDataStorage: ❌ unarchive failed: %@", error.localizedDescription)
              MMLogError("[AppGroupMessageStorage] couldn't unarchive message objects with error: \(error)")
          }
          return nil
      }
  }