@kaleyra/video-react-native-module 1.0.0

package/native-bridge/iOS/Source/Events/Reporters/ClientState.swift

@@ -0,0 +1,61 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+import Bandyer
+
+@available(iOS 12.0, *)
+enum ClientState: String {
+    case stopped = "stopped"
+    case connecting = "connecting"
+    case ready = "ready"
+    case paused = "paused"
+    case reconnecting = "reconnecting"
+    case failed = "failed"
+}
+
+@available(iOS 12.0, *)
+extension ClientState {
+
+    init?(clientState: CallClientState) {
+        switch clientState {
+            case .stopped:
+                self = .stopped
+            case .starting:
+                self = .connecting
+            case .running:
+                self = .ready
+            case .resuming:
+                self = .connecting
+            case .paused:
+                self = .paused
+            case .reconnecting:
+                self = .reconnecting
+            case .failed:
+                self = .failed
+            default:
+                return nil
+        }
+    }
+
+    init?(clientState: ChatClientState) {
+        switch clientState {
+            case .stopped:
+                self = .stopped
+            case .starting:
+                self = .connecting
+            case .running:
+                self = .ready
+            case .resuming:
+                self = .connecting
+            case .paused:
+                self = .paused
+            case .reconnecting:
+                self = .reconnecting
+            case .failed:
+                self = .failed
+            default:
+                return nil
+        }
+    }
+}

package/native-bridge/iOS/Source/Events/Reporters/EventsReporter.swift

@@ -0,0 +1,69 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+import Bandyer
+
+@available(iOS 12.0, *)
+protocol SDKEventReporter {
+
+    func start()
+    func stop()
+}
+
+@available(iOS 12.0, *)
+class EventsReporter: SDKEventReporter {
+
+    // MARK: - Properties
+
+    private let emitter: EventEmitter
+    private let sdk: BandyerSDKProtocol
+
+    private(set) var callClientEventReporter: CallClientEventsReporter?
+    private(set) var chatClientEventReporter: ChatClientEventsReporter?
+
+    // MARK: - Init
+
+    init(emitter: EventEmitter, sdk: BandyerSDKProtocol) {
+        self.emitter = emitter
+        self.sdk = sdk
+    }
+
+    // MARK: - Start Reporting Events
+
+    func start() {
+        startReportingCallClientEvents(sdk.callClient)
+        startReportingChatClientEvents(sdk.chatClient)
+    }
+
+    private func startReportingCallClientEvents(_ callClient: CallClient) {
+        guard callClientEventReporter == nil else { return }
+
+        callClientEventReporter = .init(client: callClient, emitter: emitter)
+        callClientEventReporter?.start()
+    }
+
+    private func startReportingChatClientEvents(_ chatClient: ChatClient) {
+        guard chatClientEventReporter == nil else { return }
+
+        chatClientEventReporter = .init(client: chatClient, emitter: emitter)
+        chatClientEventReporter?.start()
+    }
+
+    // MARK: - Stop Reporting Events
+
+    func stop() {
+        stopCallClientEventReporter()
+        stopChatClientEventReporter()
+    }
+
+    private func stopCallClientEventReporter() {
+        callClientEventReporter?.stop()
+        callClientEventReporter = nil
+    }
+
+    private func stopChatClientEventReporter() {
+        chatClientEventReporter?.stop()
+        chatClientEventReporter = nil
+    }
+}

package/native-bridge/iOS/Source/Events/Reporters/PushTokenEventsReporter.swift

@@ -0,0 +1,34 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+import PushKit
+
+@available(iOS 12.0, *)
+class PushTokenEventsReporter: NSObject, PKPushRegistryDelegate {
+
+    private let emitter: EventEmitter
+    private(set) var lastToken: String?
+
+    init(emitter: EventEmitter) {
+        self.emitter = emitter
+        super.init()
+    }
+
+    // MARK: - Push registry delegate
+
+    func pushRegistry(_ registry: PKPushRegistry, didUpdate credentials: PKPushCredentials, for type: PKPushType) {
+        let token = credentials.tokenAsString
+
+        guard !token.isEmpty else { return }
+
+        emitter.sendEvent(Events.iOSVoipPushTokenUpdated, args: token)
+
+        lastToken = token
+    }
+
+    func pushRegistry(_ registry: PKPushRegistry, didInvalidatePushTokenFor type: PKPushType) {
+        emitter.sendEvent(Events.iOSVoipPushTokenInvalidated, args: nil)
+        lastToken = nil
+    }
+}

package/native-bridge/iOS/Source/Extensions/URL+FromString.swift

@@ -0,0 +1,26 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+
+@available(iOS 12.0, *)
+extension URL {
+
+    static func fromString(_ string: String) throws -> URL {
+        guard let url = URL(string: string.unescape()) else {
+            throw VideoHybridNativeBridgeError.unableToInitializeURLError(urlString: string)
+        }
+        return url
+    }
+}
+
+@available(iOS 12.0, *)
+private extension String {
+
+    func unescape() -> String {
+        guard let unescaped = try? JSONDecoder().decode(String.self, from: self.data(using: .utf8)!) else {
+            return self
+        }
+        return unescaped
+    }
+}

package/native-bridge/iOS/Source/KaleyraVideoHybridNativeBridge.h

@@ -0,0 +1,14 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+#import <Foundation/Foundation.h>
+
+//! Project version number for KaleyraVideoHybridNativeBridge.
+FOUNDATION_EXPORT double KaleyraVideoHybridNativeBridgeVersionNumber;
+
+//! Project version string for KaleyraVideoHybridNativeBridge.
+FOUNDATION_EXPORT const unsigned char KaleyraVideoHybridNativeBridgeVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <KaleyraVideoHybridNativeBridge/PublicHeader.h>
+
+

package/native-bridge/iOS/Source/NativeHybridBridge/VideoHybridNativeBridge.swift

@@ -0,0 +1,173 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+import Bandyer
+
+@available(iOS 12.0, *)
+class VideoHybridNativeBridge {
+
+    // MARK: - Properties
+
+    private let sdk: BandyerSDKProtocol
+    private let reporter: SDKEventReporter
+    private let emitter: EventEmitter
+    private let uiPresenter: UserInterfacePresenter
+    private let formatterProxy: FormatterProxy
+    private let usersCache: UsersDetailsCache
+    private let accessTokenProviderFactory: () -> AccessTokenProvider
+
+    private var pushTokenEventReporter: PushTokenEventsReporter?
+
+    private var isConfigured: Bool {
+        sdk.config != nil
+    }
+
+    //  MARK: - Init
+
+    init(sdk: BandyerSDKProtocol,
+         reporter: SDKEventReporter,
+         emitter: EventEmitter,
+         uiPresenter: UserInterfacePresenter,
+         formatterProxy: FormatterProxy,
+         usersCache: UsersDetailsCache,
+         accessTokenProviderFactory: @escaping () -> AccessTokenProvider) {
+        self.sdk = sdk
+        self.reporter = reporter
+        self.emitter = emitter
+        self.uiPresenter = uiPresenter
+        self.formatterProxy = formatterProxy
+        self.usersCache = usersCache
+        self.accessTokenProviderFactory = accessTokenProviderFactory
+    }
+
+    convenience init(emitter: EventEmitter,
+                     rootViewController: UIViewController?,
+                     accessTokenProviderFactory: @escaping () -> AccessTokenProvider) {
+        let sdk = BandyerSDK.instance
+        let formatterProxy = FormatterProxy()
+
+        self.init(sdk: sdk,
+                  reporter: EventsReporter(emitter: emitter, sdk: sdk),
+                  emitter: emitter,
+                  uiPresenter: MainQueueRelay(KaleyraVideoSDKUserInterfacePresenter(rootViewController: rootViewController, formatter: formatterProxy)),
+                  formatterProxy: formatterProxy,
+                  usersCache: .init(),
+                  accessTokenProviderFactory: accessTokenProviderFactory)
+    }
+
+    // MARK: - Plugin Implementation
+
+    func configureSDK(_ config: KaleyraVideoConfiguration) throws {
+        configurePushEventsReporterIfNeeded(config: config)
+
+        if config.logEnabled ?? false {
+            BandyerSDK.logLevel = .all
+        }
+
+        let sdkConfig = try config.makeBandyerConfig(registryDelegate: pushTokenEventReporter)
+
+        sdk.userDetailsProvider = UsersDetailsProvider(cache: usersCache, formatter: formatterProxy)
+        sdk.configure(sdkConfig)
+
+        reporter.start()
+
+        uiPresenter.configure(with: config.uiPresenterConfiguration())
+    }
+
+    func callClientStateDescription() throws -> String {
+        try checkIsConfigured()
+
+        return sdk.callClient.state.description
+    }
+
+    func connect(userID: String) throws {
+        try checkIsConfigured()
+
+        let provider = accessTokenProviderFactory()
+        sdk.connect(Bandyer.Session(userId: userID, tokenProvider: provider))
+    }
+
+    func getCurrentVoIPPushToken() throws -> String? {
+        try checkIsConfigured()
+
+        return pushTokenEventReporter?.lastToken
+    }
+
+    func setUserDetailsFormat(_ format: UserDetailsFormat) {
+        formatterProxy.formatter = UserDetailsFormatter(format: format.userDetailsFormatDefault)
+    }
+
+    func startCall(_ options: CreateCallOptions) throws {
+        try checkIsConfigured()
+
+        uiPresenter.presentCall(options)
+    }
+
+    func startChat(_ userID: String) throws {
+        try checkIsConfigured()
+
+        uiPresenter.presentChat(with: userID)
+    }
+
+    func startCallUrl(_ url: URL) throws {
+        try checkIsConfigured()
+
+        uiPresenter.presentCall(url)
+    }
+
+    func disconnect() throws {
+        try checkIsConfigured()
+
+        sdk.disconnect()
+        reporter.stop()
+    }
+
+    func addUsersDetails(_ details: [UserDetails]) {
+        usersCache.setItems(details.map(\.bandyerDetails))
+    }
+
+    func removeUsersDetails() {
+        usersCache.purge()
+    }
+
+    func verifyCurrentCall(_ verify: Bool) throws {
+        try checkIsConfigured()
+        guard let call = sdk.callRegistry.calls.first else { return }
+
+        sdk.verifiedUser(verify, for: call, completion: nil)
+    }
+
+    // MARK: - Private Functions
+
+    private func configurePushEventsReporterIfNeeded(config: KaleyraVideoConfiguration) {
+        guard config.voipStrategy == .automatic else { return }
+        guard pushTokenEventReporter == nil else { return }
+
+        pushTokenEventReporter = PushTokenEventsReporter(emitter: emitter)
+    }
+
+    private func checkIsConfigured() throws {
+        guard isConfigured else {
+            throw VideoHybridNativeBridgeError.sdkNotConfiguredError()
+        }
+    }
+
+    // MARK: - Unsupported Features on iOS Platform
+
+    func reset() {
+        debugPrint("Reset is not supported for iOS platform.")
+    }
+
+    func clearUserCache() {
+        debugPrint("clearUserCache() is not supported for iOS platform.")
+    }
+
+    func handlePushNotificationPayload(_ json: String) {
+        debugPrint("handlePushNotificationPayload(_) is not supported for iOS platform - json: \(json)")
+    }
+
+    func setDisplayModeForCurrentCall(_ mode: String) {
+        debugPrint("setDisplayModeForCurrentCall(_) is not supported for iOS platform - mode: \(mode)")
+    }
+}

package/native-bridge/iOS/Source/NativeHybridBridge/VideoHybridNativeBridgeError.swift

@@ -0,0 +1,33 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+
+@available(iOS 12.0, *)
+struct VideoHybridNativeBridgeError: Error, Equatable {
+
+    private enum ErrorCodes: String {
+
+        case unsupportedFunction = "UNSUPPORTED_FUNCTION_CALL"
+        case invalidUrl = "INVALID_URL_ERROR"
+        case sdkNotConfiguredError = "SDK_NOT_CONFIGURED_ERROR"
+    }
+
+    let code: String
+    let message: String
+
+    static func unsupportedFunctionCallError(method: String) -> VideoHybridNativeBridgeError {
+        .init(code: ErrorCodes.unsupportedFunction.rawValue,
+              message: "Calling \(method) function is not supported")
+    }
+
+    static func unableToInitializeURLError(urlString: String) -> VideoHybridNativeBridgeError {
+        .init(code: ErrorCodes.invalidUrl.rawValue,
+              message: "Unable to convert the provided string \"\(urlString)\" to URL object")
+    }
+
+    static func sdkNotConfiguredError() -> VideoHybridNativeBridgeError {
+        .init(code: ErrorCodes.sdkNotConfiguredError.rawValue,
+              message: "Kaleyra Video SDK must be configured before performing this action")
+    }
+}

package/native-bridge/iOS/Source/UI/KaleyraVideoSDKUserInterfacePresenter.swift

@@ -0,0 +1,249 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+import Foundation
+import Bandyer
+
+@available(iOS 12.0, *)
+struct UserInterfacePresenterConfiguration: Equatable {
+
+    enum ChatAudioButtonConfiguration: Equatable {
+
+        case disabled
+        case enabled(AudioCallOptions)
+    }
+
+    enum ChatVideoButtonConfiguration: Equatable {
+
+        case disabled
+        case enabled(CallOptions)
+    }
+
+    let showsFeedbackWhenCallEnds: Bool
+    let chatAudioButtonConf: ChatAudioButtonConfiguration
+    let chatVideoButtonConf: ChatVideoButtonConfiguration
+
+    var chatHasAudioButton: Bool {
+        chatAudioButtonConf != .disabled
+    }
+
+    var chatHasVideoButton: Bool {
+        chatVideoButtonConf != .disabled
+    }
+}
+
+@available(iOS 12.0, *)
+class KaleyraVideoSDKUserInterfacePresenter: NSObject, UserInterfacePresenter {
+
+    // MARK: - Properties
+
+    private let sdk: BandyerSDKProtocol
+    private let viewControllerPresenter: ViewControllerPresenter
+    private let callWindow: CallWindowProtocol
+    private let formatter: Formatter
+
+    private var configuration = UserInterfacePresenterConfiguration(showsFeedbackWhenCallEnds: false,
+                                                                    chatAudioButtonConf: .disabled,
+                                                                    chatVideoButtonConf: .disabled)
+
+    // MARK: - Init
+
+    init(sdk: BandyerSDKProtocol,
+         viewControllerPresenter: ViewControllerPresenter,
+         callWindow: CallWindowProtocol,
+         formatter: Formatter) {
+        self.sdk = sdk
+        self.viewControllerPresenter = viewControllerPresenter
+        self.callWindow = callWindow
+        self.formatter = formatter
+
+        super.init()
+
+        setupCallWindow()
+    }
+
+    convenience init(rootViewController: UIViewController?, formatter: Formatter) {
+        self.init(sdk: BandyerSDK.instance,
+                  viewControllerPresenter: KaleyraVideoSDKUserInterfacePresenter.makeViewControllerPresenter(rootViewController),
+                  callWindow: KaleyraVideoSDKUserInterfacePresenter.makeCallWindow(),
+                  formatter: formatter)
+    }
+
+    private static func makeCallWindow() -> CallWindow {
+        guard let instance = CallWindow.instance else {
+            return CallWindow()
+        }
+        return instance
+    }
+
+    private static func makeViewControllerPresenter(_ rootViewController: UIViewController?) -> ViewControllerPresenter {
+        if let rootViewController = rootViewController {
+            return PresentingViewControllerViewControllerPresenter(presentingViewController: rootViewController)
+        } else {
+            return WindowViewControllerPresenter()
+        }
+    }
+
+    // MARK: - Setup
+
+    private func setupCallWindow() {
+        callWindow.callDelegate = self
+    }
+
+    private func setupSDK() {
+        sdk.callClient.addIncomingCall(observer: self, queue: .main)
+    }
+
+    private func setupNotificationCoordinator() {
+        sdk.notificationsCoordinator?.chatListener = self
+        sdk.notificationsCoordinator?.fileShareListener = self
+        sdk.notificationsCoordinator?.formatter = formatter
+        sdk.notificationsCoordinator?.start()
+    }
+
+    // MARK: - Configuration
+
+    func configure(with configuration: UserInterfacePresenterConfiguration) {
+        self.configuration = configuration
+
+        setupSDK()
+        setupNotificationCoordinator()
+    }
+
+    // MARK: - Presenting Call UI
+
+    func presentCall(_ options: CreateCallOptions) {
+        let intent = options.makeStartOutgoingCallIntent()
+        handleCallIntent(intent)
+    }
+
+    func presentCall(_ url: URL) {
+        let intent = JoinURLIntent(url: url)
+        handleCallIntent(intent)
+    }
+
+    private func makeCallViewControllerConfiguration() -> CallViewControllerConfiguration {
+        let builder = CallViewControllerConfigurationBuilder().withFormatter(formatter)
+
+        if configuration.showsFeedbackWhenCallEnds {
+            _ = builder.withFeedbackEnabled()
+        }
+
+        return builder.build()
+    }
+
+    // MARK: - Presenting Chat UI
+
+    func presentChat(with userID: String) {
+        let intent = OpenChatIntent.openChat(with: userID)
+        handleChatIntent(intent)
+    }
+
+    private func makeChannelViewController(intent: OpenChatIntent) -> ChannelViewController {
+        let config = ChannelViewControllerConfiguration(audioButton: configuration.chatHasAudioButton,
+                                                        videoButton: configuration.chatHasVideoButton,
+                                                        formatter: formatter)
+        let controller = ChannelViewController()
+        controller.delegate = self
+        controller.configuration = config
+        controller.intent = intent
+        return controller
+    }
+
+    // MARK: - Intents
+
+    private func handleChatIntent(_ intent: OpenChatIntent) {
+        let channelViewController = makeChannelViewController(intent: intent)
+
+        let continueWith: (() -> Void) = { [weak self] in
+            self?.viewControllerPresenter.present(channelViewController, animated: true, completion: nil)
+        }
+
+        if viewControllerPresenter.isPresenting {
+            viewControllerPresenter.dismissAll(animated: true, completion: continueWith)
+        } else {
+            continueWith()
+        }
+    }
+
+    private func handleCallIntent(_ intent: Intent) {
+        callWindow.setConfiguration(makeCallViewControllerConfiguration())
+        callWindow.presentCallViewController(for: intent) { [weak self] error in
+            guard let self = self else { return }
+            guard error != nil else { return }
+
+            self.viewControllerPresenter.displayAlert(title: "Warning", message: "Another call ongoing", dismissButtonText: "OK")
+        }
+    }
+}
+
+// MARK: - CallWindowDelegate
+
+@available(iOS 12.0, *)
+extension KaleyraVideoSDKUserInterfacePresenter: CallWindowDelegate {
+
+    func callWindowDidFinish(_ window: Bandyer.CallWindow) {
+        callWindow.isHidden = true
+    }
+
+    func callWindow(_ window: CallWindow, openChatWith intent: OpenChatIntent) {
+        handleChatIntent(intent)
+    }
+}
+
+// MARK: - IncomingCallObserver
+
+@available(iOS 12.0, *)
+extension KaleyraVideoSDKUserInterfacePresenter: IncomingCallObserver {
+
+    func callClient(_ client: Bandyer.CallClient, didReceiveIncomingCall call: Bandyer.Call) {
+        handleCallIntent(HandleIncomingCallIntent(call: call))
+    }
+}
+
+// MARK: - InAppChatNotificationTouchListener
+
+@available(iOS 12.0, *)
+extension KaleyraVideoSDKUserInterfacePresenter: InAppChatNotificationTouchListener {
+
+    func onTouch(_ notification: Bandyer.ChatNotification) {
+        guard let intent = OpenChatIntent.openChat(from: notification) else { return }
+        handleChatIntent(intent)
+    }
+}
+
+// MARK: - InAppFileShareNotificationTouchListener
+
+@available(iOS 12.0, *)
+extension KaleyraVideoSDKUserInterfacePresenter: InAppFileShareNotificationTouchListener {
+
+    func onTouch(_ notification: Bandyer.FileShareNotification) {
+        callWindow.presentCallViewController(for: OpenDownloadsIntent()) { _ in }
+    }
+}
+
+// MARK: - ChannelViewControllerDelegate
+
+@available(iOS 12.0, *)
+extension KaleyraVideoSDKUserInterfacePresenter: ChannelViewControllerDelegate {
+
+    func channelViewControllerDidFinish(_ controller: Bandyer.ChannelViewController) {
+        viewControllerPresenter.dismiss(controller, animated: true, completion: nil)
+    }
+
+    func channelViewController(_ controller: Bandyer.ChannelViewController, didTapAudioCallWith users: [String]) {
+        guard case let .enabled(audioOptions) = configuration.chatAudioButtonConf else { return }
+
+        let options = audioOptions.callOptions
+        let intent = StartOutgoingCallIntent(callees: users, options: options)
+        handleCallIntent(intent)
+    }
+
+    func channelViewController(_ controller: Bandyer.ChannelViewController, didTapVideoCallWith users: [String]) {
+        guard case let .enabled(videoOptions) = configuration.chatVideoButtonConf else { return }
+
+        let options = videoOptions.callOptions
+        let intent = StartOutgoingCallIntent(callees: users, options: options)
+        handleCallIntent(intent)
+    }
+}