@capawesome/capacitor-intercom 0.0.1

package/ios/Plugin/Intercom.swift

@@ -0,0 +1,323 @@
+import Foundation
+import Capacitor
+import Intercom
+
+@objc public class IntercomImpl: NSObject {
+    private var initialized = false
+    private let plugin: IntercomPlugin
+
+    init(plugin: IntercomPlugin) {
+        self.plugin = plugin
+        super.init()
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleUnreadConversationCountDidChange),
+            name: NSNotification.Name.IntercomUnreadConversationCountDidChange,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleWindowDidShow),
+            name: NSNotification.Name.IntercomWindowDidShow,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleWindowDidHide),
+            name: NSNotification.Name.IntercomWindowDidHide,
+            object: nil
+        )
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc public func getUnreadConversationCount(completion: @escaping (_ result: GetUnreadConversationCountResult?, _ error: Error?) -> Void) {
+        guard initialized else {
+            completion(nil, CustomError.notInitialized)
+            return
+        }
+        let count = Int(Intercom.unreadConversationCount())
+        completion(GetUnreadConversationCountResult(count: count), nil)
+    }
+
+    @objc public func handlePushNotification(_ options: HandlePushNotificationOptions, completion: @escaping (_ error: Error?) -> Void) {
+        Intercom.handlePushNotification(options.data)
+        completion(nil)
+    }
+
+    @objc public func hide(completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        DispatchQueue.main.async {
+            Intercom.hide()
+            completion(nil)
+        }
+    }
+
+    @objc public func initialize(_ options: InitializeOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard let iosApiKey = options.iosApiKey else {
+            completion(CustomError.iosApiKeyMissing)
+            return
+        }
+        Intercom.setApiKey(iosApiKey, forAppId: options.appId)
+        initialized = true
+        completion(nil)
+    }
+
+    @objc public func isIntercomPushNotification(_ options: IsIntercomPushNotificationOptions, completion: @escaping (_ result: IsIntercomPushNotificationResult?, _ error: Error?) -> Void) {
+        let isIntercom = Intercom.isIntercomPushNotification(options.data)
+        completion(IsIntercomPushNotificationResult(intercom: isIntercom), nil)
+    }
+
+    @objc public func logEvent(_ options: LogEventOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        if let data = options.data {
+            Intercom.logEvent(withName: options.name, metaData: data)
+        } else {
+            Intercom.logEvent(withName: options.name)
+        }
+        completion(nil)
+    }
+
+    @objc public func loginUnidentifiedUser(completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        Intercom.loginUnidentifiedUser { result in
+            switch result {
+            case .success:
+                completion(nil)
+            case .failure(let error):
+                completion(CustomError.loginFailed(message: error.localizedDescription))
+            }
+        }
+    }
+
+    @objc public func loginUser(_ options: LoginUserOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        let attributes = ICMUserAttributes()
+        attributes.userId = options.userId
+        attributes.email = options.email
+        Intercom.loginUser(with: attributes) { result in
+            switch result {
+            case .success:
+                completion(nil)
+            case .failure(let error):
+                completion(CustomError.loginFailed(message: error.localizedDescription))
+            }
+        }
+    }
+
+    @objc public func logout(completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        Intercom.logout()
+        completion(nil)
+    }
+
+    @objc public func present(_ options: PresentOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        DispatchQueue.main.async {
+            Intercom.present(self.mapSpace(options.space))
+            completion(nil)
+        }
+    }
+
+    @objc public func presentContent(_ options: PresentContentOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        guard let content = mapContent(options) else {
+            completion(CustomError.typeInvalid)
+            return
+        }
+        DispatchQueue.main.async {
+            Intercom.presentContent(content)
+            completion(nil)
+        }
+    }
+
+    @objc public func presentMessageComposer(_ options: PresentMessageComposerOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        DispatchQueue.main.async {
+            Intercom.presentMessageComposer(options.initialMessage)
+            completion(nil)
+        }
+    }
+
+    @objc public func sendPushTokenToIntercom(_ options: SendPushTokenToIntercomOptions, completion: @escaping (_ error: Error?) -> Void) {
+        let deviceToken = IntercomHelper.hexStringToData(options.token)
+        Intercom.setDeviceToken(deviceToken) { result in
+            switch result {
+            case .success:
+                completion(nil)
+            case .failure(let error):
+                completion(error)
+            }
+        }
+    }
+
+    @objc public func setBottomPadding(_ options: SetBottomPaddingOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            Intercom.setBottomPadding(options.padding)
+            completion(nil)
+        }
+    }
+
+    @objc public func setInAppMessagesVisible(_ options: SetInAppMessagesVisibleOptions, completion: @escaping (_ error: Error?) -> Void) {
+        Intercom.setInAppMessagesVisible(options.visible)
+        completion(nil)
+    }
+
+    @objc public func setLauncherVisible(_ options: SetLauncherVisibleOptions, completion: @escaping (_ error: Error?) -> Void) {
+        Intercom.setLauncherVisible(options.visible)
+        completion(nil)
+    }
+
+    @objc public func setUserHash(_ options: SetUserHashOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        Intercom.setUserHash(options.userHash)
+        completion(nil)
+    }
+
+    @objc public func setUserJwt(_ options: SetUserJwtOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        Intercom.setUserJwt(options.jwt)
+        completion(nil)
+    }
+
+    @objc public func updateUser(_ options: UpdateUserOptions, completion: @escaping (_ error: Error?) -> Void) {
+        guard initialized else {
+            completion(CustomError.notInitialized)
+            return
+        }
+        let attributes: ICMUserAttributes
+        do {
+            attributes = try buildUserAttributes(options)
+        } catch {
+            completion(error)
+            return
+        }
+        Intercom.updateUser(with: attributes) { result in
+            switch result {
+            case .success:
+                completion(nil)
+            case .failure(let error):
+                completion(CustomError.updateFailed(message: error.localizedDescription))
+            }
+        }
+    }
+
+    private func buildCompany(_ company: JSObject) throws -> ICMCompany {
+        guard let id = company["id"] as? String else {
+            throw CustomError.companyIdMissing
+        }
+        let result = ICMCompany()
+        result.companyId = id
+        if let name = company["name"] as? String {
+            result.name = name
+        }
+        if let plan = company["plan"] as? String {
+            result.plan = plan
+        }
+        if let monthlySpend = company["monthlySpend"] as? NSNumber {
+            result.monthlySpend = monthlySpend
+        }
+        if let createdAt = company["createdAt"] as? NSNumber {
+            result.createdAt = Date(timeIntervalSince1970: createdAt.doubleValue)
+        }
+        if let customAttributes = company["customAttributes"] as? JSObject {
+            result.customAttributes = customAttributes
+        }
+        return result
+    }
+
+    private func buildUserAttributes(_ options: UpdateUserOptions) throws -> ICMUserAttributes {
+        let attributes = ICMUserAttributes()
+        attributes.name = options.name
+        attributes.email = options.email
+        attributes.userId = options.userId
+        attributes.phone = options.phone
+        attributes.languageOverride = options.languageOverride
+        attributes.signedUpAt = options.signedUpAt
+        if let unsubscribedFromEmails = options.unsubscribedFromEmails {
+            attributes.unsubscribedFromEmails = unsubscribedFromEmails
+        }
+        if let customAttributes = options.customAttributes {
+            attributes.customAttributes = customAttributes
+        }
+        if let companies = options.companies {
+            attributes.companies = try companies.map { try buildCompany($0) }
+        }
+        return attributes
+    }
+
+    @objc private func handleUnreadConversationCountDidChange() {
+        let count = Int(Intercom.unreadConversationCount())
+        plugin.notifyUnreadConversationCountChangeListeners(UnreadConversationCountChangeEvent(count: count))
+    }
+
+    @objc private func handleWindowDidHide() {
+        plugin.notifyMessengerHiddenListeners()
+    }
+
+    @objc private func handleWindowDidShow() {
+        plugin.notifyMessengerShownListeners()
+    }
+
+    private func mapContent(_ options: PresentContentOptions) -> Intercom.Content? {
+        switch options.type {
+        case "article":
+            return .article(id: options.id ?? "")
+        case "carousel":
+            return .carousel(id: options.id ?? "")
+        case "survey":
+            return .survey(id: options.id ?? "")
+        case "conversation":
+            return .conversation(id: options.id ?? "")
+        case "help-center-collections":
+            return .helpCenterCollections(ids: options.ids ?? [])
+        default:
+            return nil
+        }
+    }
+
+    private func mapSpace(_ space: String) -> Space {
+        switch space {
+        case "messages":
+            return .messages
+        case "help-center":
+            return .helpCenter
+        case "tickets":
+            return .tickets
+        default:
+            return .home
+        }
+    }
+}

package/ios/Plugin/IntercomHelper.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+public class IntercomHelper {
+    public static func hexStringToData(_ hexString: String) -> Data {
+        var data = Data()
+        var index = hexString.startIndex
+        while index < hexString.endIndex {
+            let nextIndex = hexString.index(index, offsetBy: 2, limitedBy: hexString.endIndex) ?? hexString.endIndex
+            let byteString = hexString[index..<nextIndex]
+            if let byte = UInt8(byteString, radix: 16) {
+                data.append(byte)
+            }
+            index = nextIndex
+        }
+        return data
+    }
+}

package/ios/Plugin/IntercomPlugin.swift

@@ -0,0 +1,261 @@
+import Foundation
+import Capacitor
+
+@objc(IntercomPlugin)
+public class IntercomPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "IntercomPlugin"
+    public let jsName = "Intercom"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getUnreadConversationCount", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "handlePushNotification", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "hide", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "initialize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isIntercomPushNotification", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "logEvent", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "loginUnidentifiedUser", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "loginUser", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "logout", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "present", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "presentContent", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "presentMessageComposer", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "sendPushTokenToIntercom", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setBottomPadding", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setInAppMessagesVisible", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setLauncherVisible", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setUserHash", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setUserJwt", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "updateUser", returnType: CAPPluginReturnPromise)
+    ]
+    public static let eventMessengerHidden = "messengerHidden"
+    public static let eventMessengerShown = "messengerShown"
+    public static let eventUnreadConversationCountChange = "unreadConversationCountChange"
+    public let tag = "Intercom"
+    private var implementation: IntercomImpl?
+
+    override public func load() {
+        super.load()
+        self.implementation = IntercomImpl(plugin: self)
+    }
+
+    @objc func getUnreadConversationCount(_ call: CAPPluginCall) {
+        implementation?.getUnreadConversationCount(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call, result)
+            }
+        })
+    }
+
+    @objc func handlePushNotification(_ call: CAPPluginCall) {
+        do {
+            let options = try HandlePushNotificationOptions(call)
+            implementation?.handlePushNotification(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func hide(_ call: CAPPluginCall) {
+        implementation?.hide(completion: { error in
+            self.handleCompletion(call, error)
+        })
+    }
+
+    @objc func initialize(_ call: CAPPluginCall) {
+        do {
+            let options = try InitializeOptions(call)
+            implementation?.initialize(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func isIntercomPushNotification(_ call: CAPPluginCall) {
+        do {
+            let options = try IsIntercomPushNotificationOptions(call)
+            implementation?.isIntercomPushNotification(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func logEvent(_ call: CAPPluginCall) {
+        do {
+            let options = try LogEventOptions(call)
+            implementation?.logEvent(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func loginUnidentifiedUser(_ call: CAPPluginCall) {
+        implementation?.loginUnidentifiedUser(completion: { error in
+            self.handleCompletion(call, error)
+        })
+    }
+
+    @objc func loginUser(_ call: CAPPluginCall) {
+        do {
+            let options = try LoginUserOptions(call)
+            implementation?.loginUser(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func logout(_ call: CAPPluginCall) {
+        implementation?.logout(completion: { error in
+            self.handleCompletion(call, error)
+        })
+    }
+
+    public func notifyMessengerHiddenListeners() {
+        notifyListeners(Self.eventMessengerHidden, data: [:])
+    }
+
+    public func notifyMessengerShownListeners() {
+        notifyListeners(Self.eventMessengerShown, data: [:])
+    }
+
+    public func notifyUnreadConversationCountChangeListeners(_ event: UnreadConversationCountChangeEvent) {
+        notifyListeners(Self.eventUnreadConversationCountChange, data: event.toJSObject() as? [String: Any])
+    }
+
+    @objc func present(_ call: CAPPluginCall) {
+        let options = PresentOptions(call)
+        implementation?.present(options, completion: { error in
+            self.handleCompletion(call, error)
+        })
+    }
+
+    @objc func presentContent(_ call: CAPPluginCall) {
+        do {
+            let options = try PresentContentOptions(call)
+            implementation?.presentContent(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func presentMessageComposer(_ call: CAPPluginCall) {
+        let options = PresentMessageComposerOptions(call)
+        implementation?.presentMessageComposer(options, completion: { error in
+            self.handleCompletion(call, error)
+        })
+    }
+
+    @objc func sendPushTokenToIntercom(_ call: CAPPluginCall) {
+        do {
+            let options = try SendPushTokenToIntercomOptions(call)
+            implementation?.sendPushTokenToIntercom(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setBottomPadding(_ call: CAPPluginCall) {
+        do {
+            let options = try SetBottomPaddingOptions(call)
+            implementation?.setBottomPadding(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setInAppMessagesVisible(_ call: CAPPluginCall) {
+        do {
+            let options = try SetInAppMessagesVisibleOptions(call)
+            implementation?.setInAppMessagesVisible(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setLauncherVisible(_ call: CAPPluginCall) {
+        do {
+            let options = try SetLauncherVisibleOptions(call)
+            implementation?.setLauncherVisible(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setUserHash(_ call: CAPPluginCall) {
+        do {
+            let options = try SetUserHashOptions(call)
+            implementation?.setUserHash(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setUserJwt(_ call: CAPPluginCall) {
+        do {
+            let options = try SetUserJwtOptions(call)
+            implementation?.setUserJwt(options, completion: { error in
+                self.handleCompletion(call, error)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func updateUser(_ call: CAPPluginCall) {
+        let options = UpdateUserOptions(call)
+        implementation?.updateUser(options, completion: { error in
+            self.handleCompletion(call, error)
+        })
+    }
+
+    private func handleCompletion(_ call: CAPPluginCall, _ error: Error?) {
+        if let error = error {
+            rejectCall(call, error)
+        } else {
+            resolveCall(call)
+        }
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", self.tag, "] ", error)
+        call.reject(error.localizedDescription, (error as? CustomError)?.code)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}