react-native-hubspot-wrapper 0.1.0

package/ios/HubspotMobileSDK/HubspotConfig.swift

@@ -0,0 +1,145 @@
+// HubspotConfig.swift
+// Hubspot Mobile SDK
+//
+// Copyright © 2024 Hubspot, Inc.
+
+import Foundation
+
+/// Enum used during configuration. The default is production - if in doubt choose production
+public enum HubspotEnvironment: String, Codable, CustomStringConvertible, Sendable {
+    /// QA environment , mostly for internal use
+    case qa
+    /// Production environment, the most commonly used environment
+    case production = "prod"
+
+    /// Display friendly name for the environment
+    public var description: String {
+        switch self {
+        case .production:
+            return "Production"
+        case .qa:
+            return "QA"
+        }
+    }
+}
+
+/// Encapsulates some of the logic around hublets, as some are treated differently than others. Right now we know of only 2, but this might expand in the future?
+struct Hublet {
+    /// This is the default(?) hublet, it uses just plain sub domain
+    let defaultUS = "na1"
+
+    let id: String
+    let environment: HubspotEnvironment
+
+    /// The format of subdomain varies between hublets
+    private var appsSubDomain: String {
+        let id = id.lowercased()
+        if id == defaultUS {
+            return "app"
+        } else {
+            // other hublets like eu1 have hublet in the subdomain
+            return "app-\(id)"
+        }
+    }
+
+    private var appsDomain: String {
+        // Right now, qa env has its own domain
+        switch environment {
+        case .production:
+            return "hubspot.com"
+        case .qa:
+            return "hubspotqa.com"
+        }
+    }
+
+    /// The format of subdomain varies between hublets
+    private var apiSubDomain: String {
+        let id = id.lowercased()
+        if id == defaultUS {
+            return "api"
+        } else {
+            // other hublets like eu1 have hublet in the subdomain
+            return "api-\(id)"
+        }
+    }
+
+    private var apiDomain: String {
+        // Right now, qa env has its own domain
+        switch environment {
+        case .production:
+            return "hubapi.com"
+        case .qa:
+            return "hubapiqa.com"
+        }
+    }
+
+    /// hostname used for the embedded chat page
+    var hostname: String {
+        return appsSubDomain + "." + appsDomain
+    }
+
+    /// hostname used for api calls
+    var apiHostname: String {
+        return apiSubDomain + "." + apiDomain
+    }
+
+    /// base url for api calls - append path before using
+    var apiURL: URL {
+        var components = URLComponents()
+        components.scheme = "https"
+        components.host = apiHostname
+        guard let url = components.url else {
+            fatalError("Unable to build URL from configuration")
+        }
+        return url
+    }
+}
+
+/// Errors relating to setting up SDK
+public enum HubspotConfigError: LocalizedError, Sendable {
+    /// Missing config file, or missing value within - if this error occurs, make sure hubspot info file is bundled in app, and that  the manager configure method  ``HubspotManager/configure()-swift.type.method`` has been called .
+    case missingConfiguration
+
+    /// Chat flow is needed to correctly show a chat
+    case missingChatFlow
+
+    /// Description of the error and reason for failure, same as ``failureReason`` currently.
+    public var errorDescription: String? {
+        switch self {
+        case .missingConfiguration:
+            return "Couldn't find a configuration at the expected path \(HubspotConfig.defaultConfigFileName)"
+        case .missingChatFlow:
+            return "No chat flow provided, and no default found"
+        }
+    }
+    /// Description of the error and reason for failure, same as ``errorDescription`` currently.
+    public var failureReason: String? {
+        switch self {
+        case .missingConfiguration:
+            return "Couldn't find a configuration at the expected path \(HubspotConfig.defaultConfigFileName)"
+        case .missingChatFlow:
+            return "No chat flow provided, and no default found"
+        }
+    }
+}
+
+/// This struct for decoding the config file bundled in app - the config file contains the required pieces of info needed to connect to the correct hubspot endponts like that , account specific info like portal id and hublet
+///
+/// By default, the SDK will initialise using a known file path, Hubspot-Info.plist
+///
+public struct HubspotConfig: Codable, Sendable {
+    /// This is the default, assumed filename for the plist bunded in app containing the config values
+    public static let defaultConfigFileName: String = "Hubspot-Info.plist"
+
+    /// The hubspot environment to use
+    public let environment: HubspotEnvironment
+
+    /// The hublet the portal is in, for example "na1" or "eu1"
+    public let hublet: String
+
+    /// The unique id for the customers hubspot portal
+    public let portalId: String
+
+    /// The default chat flow value to use if not specified when creating a chat view
+    public let defaultChatFlow: String?
+}

package/ios/HubspotMobileSDK/HubspotManager+Notifications.swift

@@ -0,0 +1,178 @@
+// HubspotManager+Notifications.swift
+// Hubspot Mobile SDK
+//
+// Copyright © 2024 Hubspot, Inc.
+
+import Foundation
+import NotificationCenter
+
+extension HubspotManager {
+    /// Alternative to ``newMessage`` publisher or ``newMessageCallback`` property , potentially useful in a SwiftUI view
+    ///
+    /// This could be used in a stand alone task like so:
+    ///
+    /// ```swift
+    /// Task {
+    ///    for await notification in HubspotManager.shared.newMessages() {
+    ///       self.triggerChatFlow()
+    ///    }
+    ///
+    /// }
+    /// ```
+    /// or attached to a view:
+    /// ```swift
+    /// myView
+    ///   .frame(...)
+    ///   .background(...)
+    ///   .task {
+    ///     for await _ in HubspotManager.shared.newMessages() {
+    ///        presentChatView = true
+    ///     }
+    /// }
+    /// ```
+    /// > Warning: This async stream normally will never terminate.
+    ///
+    public func newMessages() -> AsyncStream<PushNotificationChatData> {
+        return AsyncStream { cont in
+
+            // Supressing sendability issue with cancellable - should be ok to send to the onTermination, as nothing else will have a reference to it
+            nonisolated(unsafe) let pubCancellable = self.newMessage.sink(
+                receiveCompletion: { _ in
+                    // doesn't matter if the subscription fails or finishes, our sequence is done - in this specific case we expect it never to do either , but just incase, end the stream.
+                    cont.finish()
+                },
+                receiveValue: { data in
+                    cont.yield(data)
+                })
+
+            cont.onTermination = { termination in
+                switch termination {
+                case .cancelled:
+                    // If the termination was from the task / stream side , the subscription itself is still active, so attempt to cancel it
+                    pubCancellable.cancel()
+                case .finished:
+                    // Do nothing if we finished the stream - that only happens when the subscription itself finished
+                    break
+                @unknown default:
+                    pubCancellable.cancel()
+                }
+            }
+        }
+    }
+
+    /// This is a convenience method for allowing this HubspotManager instance to act as your UNUserNotificationCenterDelegate. This will check any notifications received for hubspot messages.
+    ///
+    ///  If using the HubspotManager to handle notifications, call this before the end of app launch to ensure all notifications are handled.
+    ///
+    /// If you would prefer to present notification permission dialog at a specific time, or as part of a primer screen, set promptForNotificationPermissions to false. If you have no preference for when to prompt the user , set promptForNotificationPermissions to true, and the user will be prompted if permissions are not yet granted.
+    ///
+    /// It's also ok to call this multiple times - you might call `configurePushMessaging(promptForNotificationPermissions: false, allowProvisionalNotifications: true, newMessageCallback: myHandler)` during your app start up or initial setup, and later after user enables a setting or accesses a particular feature, call `configurePushMessaging(promptForNotificationPermissions: true, allowProvisionalNotifications: true, newMessageCallback: myHandler)` to trigger the prompt for permissions.
+    ///
+    /// **Warning** This will set the delegate for the current UNUserNotificationCenter - if you need to handle UNUserNotificationCenterDelegate callbacks in your app, do not use this method.
+    ///
+    /// If the app should show chat UI in response to the user tapping a notification, newMessageCallback is triggered. Use this closure to configure your UI.
+    /// - Parameters:
+    ///   - promptForNotificationPermissions: If true, and notification permissions are not yet granted, the user is prompted to allow notifications
+    ///   - allowProvisionalNotifications: If `promptForNotificationPermissions` is false, set this to true to enable provisional notifications if not already granted. Has no effect if `promptForNotificationPermissions` is true.
+    ///   - newMessageCallback: Use this closure to configure your UI to show chat view. Called on the main thread. If nil, the call back isn't changed from any previous configuration. Alternatively, leave as nil , and set ``HubspotManager/newMessageCallback`` property directly.  or use the ``HubspotManager/newMessage`` publisher property
+    public func configurePushMessaging(
+        promptForNotificationPermissions: Bool,
+        allowProvisionalNotifications: Bool,
+        newMessageCallback: ((PushNotificationChatData) -> Void)? = nil
+    ) {
+        UIApplication.shared.registerForRemoteNotifications()
+
+        // Act as the delegate for opening notifications so we can tell when someone opens one.
+        UNUserNotificationCenter.current().delegate = self
+
+        if promptForNotificationPermissions {
+            Task.detached {
+                let currentSettings = await UNUserNotificationCenter.current().notificationSettings()
+                // We only want to request auth if not yet asked or just provisional
+                if currentSettings.authorizationStatus == .notDetermined || currentSettings.authorizationStatus == .provisional {
+                    do {
+                        let authorized = try await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge])
+                        if authorized {
+                            await self.logger.trace("Notification permission granted")
+                        }
+                    } catch {
+                        await self.logger.error("Unable to request notification permissions: \(error)")
+                    }
+                }
+            }
+        } else if allowProvisionalNotifications {
+            Task.detached {
+                let currentSettings = await UNUserNotificationCenter.current().notificationSettings()
+                // We only want to request auth if not yet asked
+                if currentSettings.authorizationStatus == .notDetermined {
+                    do {
+                        let authorized = try await UNUserNotificationCenter.current().requestAuthorization(options: [.provisional])
+                        if authorized {
+                            await self.logger.trace("Provisional notification settings enabled")
+                        }
+                    } catch {
+                        await self.logger.error("Unable to request notification permissions: \(error)")
+                    }
+                }
+            }
+        }
+
+        if let newMessageCallback {
+            self.newMessageCallback = newMessageCallback
+        }
+    }
+}
+
+/// Making the `HubspotManager` your user notification delete is not required, but its an option for convenience in situations where another delegate doesn't already exist.
+extension HubspotManager: UNUserNotificationCenterDelegate {
+    /// Use this method to help identify incoming notifications that are hubspot related , incase you wish to handle them differently
+    public nonisolated func isHubspotNotification(notification: UNNotification) -> Bool {
+        let notificationData = notification.request.content.userInfo
+        return isHubspotNotification(notificationData: notificationData)
+    }
+
+    /// Use this method to help identify incoming notifications that are hubspot related , incase you wish to handle them differently
+    public nonisolated func isHubspotNotification(notificationData: [AnyHashable: Any]) -> Bool {
+        let hasAHubspotKey = notificationData.contains(where: { key, _ in
+            guard let key = key as? String else {
+                return false
+            }
+
+            // There's a few of keys we can potentially have here
+            return
+                key.hasPrefix(PushNotificationChatData.chatflowIdKey) || key.hasPrefix(PushNotificationChatData.chatflowKey) || key.hasPrefix(PushNotificationChatData.portalIdKey) || key.hasPrefix(PushNotificationChatData.threadIdKey)
+        })
+
+        return hasAHubspotKey
+    }
+
+    /// A ``HubspotManager`` instanance, like ``HubspotManager/shared`` can be used as a notification centre delegate, in situations where all notifications are from hubspot. If you have your own notification delegate, instead call this method from within your own delegate for notifications that are hubspot related.
+    ///
+    ///
+    public nonisolated func userNotificationCenter(_: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
+        if isHubspotNotification(notification: response.notification) {
+            guard let chatData = PushNotificationChatData(notification: response.notification) else {
+                // none of the expected data in the message
+                return
+            }
+
+            // dispatching on main as most likely will result in ui changes - incase not everyone remembers to enforce processing on main thread for presentations
+            DispatchQueue.main.async {
+                self.newMessageCallback(chatData)
+                self.newMessage.send(chatData)
+            }
+        } else {
+            let requestId = response.notification.request.identifier
+            Task {
+                await self.logger.info("Push message handled by HubspotManager that isn't detected as as Hubspot notifiation. This may be a misconfiguration. Response id: \(requestId)")
+            }
+        }
+        completionHandler()
+    }
+
+    /// A ``HubspotManager`` instanance, like ``HubspotManager/shared`` can be used as a notification centre delegate, in situations where all notifications are from hubspot. If you have your own notification delegate, instead call this method from within your own delegate for notifications that are hubspot related.
+    ///
+    public nonisolated func userNotificationCenter(_: UNUserNotificationCenter, willPresent _: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        completionHandler([.banner, .sound])
+    }
+}

package/ios/HubspotMobileSDK/HubspotManager+Properties.swift

@@ -0,0 +1,53 @@
+// HubspotManager+Properties.swift
+// Hubspot Mobile SDK
+//
+// Copyright © 2024 Hubspot, Inc.
+
+import Foundation
+import UIKit  // Needed for UIDevice
+
+extension HubspotManager {
+    /// Called by ui components if a chat might potentially happen - allows manager class to enable anything that needs prep time - like battery monitoring ahead of gathering it.
+    /// Internal for now - if its not enough to be called in the chat view, it can be made public and a requirement to be called from custom components.
+    func prepareForPotentialChat() {
+        enableBatteryMonitoring()
+        enableOrientationMonitoring()
+    }
+
+    func enableOrientationMonitoring() {
+        if !UIDevice.current.isGeneratingDeviceOrientationNotifications {
+            didWeEnableOrientationMonitoring = true
+            UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+        }
+    }
+
+    func enableBatteryMonitoring() {
+        if !UIDevice.current.isBatteryMonitoringEnabled {
+            didWeEnableBatterMonitoring = true
+            UIDevice.current.isBatteryMonitoringEnabled = true
+        }
+    }
+
+    /// Fetch the system model , converting c struct into normal string. Uses utsname function and reflection.
+    /// The result is the apple model number, like iPhone15,4 , iPhone16,1 , etc rather than marketing name like "Pro Max"
+    func deviceModel() -> String {
+        var info = utsname()  // create empty struct
+        uname(&info)  // populate it
+
+        /// We can't iterate over a tuple of characters, nor can we use the init methods that take an array of cchars, so reflection to loop over them instead
+        let mirror = Mirror(reflecting: info.machine)
+        let parts: [String] = mirror.children.compactMap { charProperty -> String? in
+            // 0 would be end of string
+            guard let intChar = charProperty.value as? Int8, intChar > 0 else {
+                return nil
+            }
+
+            guard let scalar = UnicodeScalar(UInt32(intChar)) else {
+                return nil
+            }
+            return String(scalar)
+        }
+
+        return parts.joined()
+    }
+}