@kaleyra/video-react-native-module 1.6.0 → 2.0.1

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

@@ -2,60 +2,32 @@
 // See LICENSE for licensing information
 
 import Foundation
-import Bandyer
+import KaleyraVideoSDK
 
-@available(iOS 12.0, *)
 enum ClientState: String {
-    case stopped = "stopped"
+    case disconnected = "disconnected"
     case connecting = "connecting"
-    case ready = "ready"
-    case paused = "paused"
+    case connected = "connected"
     case reconnecting = "reconnecting"
     case failed = "failed"
 }
 
-@available(iOS 12.0, *)
 extension ClientState {
 
-    init?(clientState: CallClientState) {
-        switch clientState {
-            case .stopped:
-                self = .stopped
-            case .starting:
+    init?(state: KaleyraVideoSDK.ClientState) {
+        switch state {
+            case .disconnected(error: let error):
+                if error != nil {
+                    self = .failed
+                } else {
+                    self = .disconnected
+                }
+            case .connecting:
                 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 .connected:
+                self = .connected
             case .reconnecting:
                 self = .reconnecting
-            case .failed:
-                self = .failed
-            default:
-                return nil
         }
     }
 }

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

@@ -2,29 +2,33 @@
 // See LICENSE for licensing information
 
 import Foundation
-import Bandyer
+import KaleyraVideoSDK
 
-@available(iOS 12.0, *)
 protocol SDKEventReporter {
 
+    var lastVoIPToken: String? { get }
+
     func start()
     func stop()
 }
 
-@available(iOS 12.0, *)
 class EventsReporter: SDKEventReporter {
 
     // MARK: - Properties
 
     private let emitter: EventEmitter
-    private let sdk: BandyerSDKProtocol
+    private let sdk: KaleyraVideoSDKProtocol
 
     private(set) var callClientEventReporter: CallClientEventsReporter?
     private(set) var chatClientEventReporter: ChatClientEventsReporter?
 
+    var lastVoIPToken: String? {
+        callClientEventReporter?.lastVoIPToken
+    }
+
     // MARK: - Init
 
-    init(emitter: EventEmitter, sdk: BandyerSDKProtocol) {
+    init(emitter: EventEmitter, sdk: KaleyraVideoSDKProtocol) {
         self.emitter = emitter
         self.sdk = sdk
     }
@@ -32,21 +36,21 @@ class EventsReporter: SDKEventReporter {
     // MARK: - Start Reporting Events
 
     func start() {
-        startReportingCallClientEvents(sdk.callClient)
-        startReportingChatClientEvents(sdk.chatClient)
+        startReportingCallClientEvents(sdk.conference)
+        startReportingChatClientEvents(sdk.conversation)
     }
 
-    private func startReportingCallClientEvents(_ callClient: CallClient) {
-        guard callClientEventReporter == nil else { return }
+    private func startReportingCallClientEvents(_ conference: Conference?) {
+        guard let conference, callClientEventReporter == nil else { return }
 
-        callClientEventReporter = .init(client: callClient, emitter: emitter)
+        callClientEventReporter = .init(conference: conference, emitter: emitter)
         callClientEventReporter?.start()
     }
 
-    private func startReportingChatClientEvents(_ chatClient: ChatClient) {
-        guard chatClientEventReporter == nil else { return }
+    private func startReportingChatClientEvents(_ conversation: Conversation?) {
+        guard let conversation, chatClientEventReporter == nil else { return }
 
-        chatClientEventReporter = .init(client: chatClient, emitter: emitter)
+        chatClientEventReporter = .init(conversation: conversation, emitter: emitter)
         chatClientEventReporter?.start()
     }
 

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

@@ -3,7 +3,6 @@
 
 import Foundation
 
-@available(iOS 12.0, *)
 extension URL {
 
     static func fromString(_ string: String) throws -> URL {
@@ -14,7 +13,6 @@ extension URL {
     }
 }
 
-@available(iOS 12.0, *)
 private extension String {
 
     func unescape() -> String {

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

@@ -2,41 +2,35 @@
 // See LICENSE for licensing information
 
 import Foundation
-import Bandyer
+import KaleyraVideoSDK
 
-@available(iOS 12.0, *)
 class VideoHybridNativeBridge {
 
     // MARK: - Properties
 
-    private let sdk: BandyerSDKProtocol
+    private let sdk: KaleyraVideoSDKProtocol
     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,
+    init(sdk: KaleyraVideoSDKProtocol,
          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
     }
@@ -44,14 +38,12 @@ class VideoHybridNativeBridge {
     convenience init(emitter: EventEmitter,
                      rootViewController: UIViewController?,
                      accessTokenProviderFactory: @escaping () -> AccessTokenProvider) {
-        let sdk = BandyerSDK.instance
-        let formatterProxy = FormatterProxy()
+        let sdk = KaleyraVideo.instance
 
         self.init(sdk: sdk,
                   reporter: EventsReporter(emitter: emitter, sdk: sdk),
                   emitter: emitter,
-                  uiPresenter: MainQueueRelay(KaleyraVideoSDKUserInterfacePresenter(rootViewController: rootViewController, formatter: formatterProxy)),
-                  formatterProxy: formatterProxy,
+                  uiPresenter: MainQueueRelay(KaleyraVideoSDKUserInterfacePresenter(rootViewController: rootViewController)),
                   usersCache: .init(),
                   accessTokenProviderFactory: accessTokenProviderFactory)
     }
@@ -59,16 +51,17 @@ class VideoHybridNativeBridge {
     // MARK: - Plugin Implementation
 
     func configureSDK(_ config: KaleyraVideoConfiguration) throws {
-        configurePushEventsReporterIfNeeded(config: config)
 
         if config.logEnabled ?? false {
-            BandyerSDK.logLevel = .all
+            KaleyraVideo.logLevel = .all
+
         }
 
-        let sdkConfig = try config.makeBandyerConfig(registryDelegate: pushTokenEventReporter)
+        let sdkConfig = try config.makeKaleyraVideoSDKConfig()
 
-        sdk.userDetailsProvider = UsersDetailsProvider(cache: usersCache, formatter: formatterProxy)
-        sdk.configure(sdkConfig)
+        sdk.userDetailsProvider = UsersDetailsProvider(cache: usersCache)
+        try sdk.configure(sdkConfig)
+        sdk.conference?.settings.tools = config.makeToolsConfig()
 
         reporter.start()
 
@@ -78,23 +71,19 @@ class VideoHybridNativeBridge {
     func callClientStateDescription() throws -> String {
         try checkIsConfigured()
 
-        return sdk.callClient.state.description
+        return sdk.conference?.state.description ?? ""
     }
 
     func connect(userID: String) throws {
         try checkIsConfigured()
         let provider = accessTokenProviderFactory()
-        sdk.connect(Bandyer.Session(userId: userID, tokenProvider: provider))
+        try sdk.connect(userId: userID, provider: provider)
     }
 
     func getCurrentVoIPPushToken() throws -> String? {
         try checkIsConfigured()
 
-        return pushTokenEventReporter?.lastToken
-    }
-
-    func setUserDetailsFormat(_ format: UserDetailsFormat) {
-        formatterProxy.formatter = UserDetailsFormatter(format: format.userDetailsFormatDefault)
+        return reporter.lastVoIPToken
     }
 
     func startCall(_ options: CreateCallOptions) throws {
@@ -129,26 +118,12 @@ class VideoHybridNativeBridge {
         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)
-    }
-
     func reset() {
         sdk.reset()
     }
 
     // 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()
@@ -161,10 +136,6 @@ class VideoHybridNativeBridge {
         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

@@ -3,7 +3,6 @@
 
 import Foundation
 
-@available(iOS 12.0, *)
 struct VideoHybridNativeBridgeError: Error, Equatable {
 
     private enum ErrorCodes: String {

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

@@ -2,9 +2,9 @@
 // See LICENSE for licensing information
 
 import Foundation
-import Bandyer
+import Combine
+import KaleyraVideoSDK
 
-@available(iOS 12.0, *)
 struct UserInterfacePresenterConfiguration: Equatable {
 
     enum ChatAudioButtonConfiguration: Equatable {
@@ -32,48 +32,44 @@ struct UserInterfacePresenterConfiguration: Equatable {
     }
 }
 
-@available(iOS 12.0, *)
 class KaleyraVideoSDKUserInterfacePresenter: NSObject, UserInterfacePresenter {
 
     // MARK: - Properties
 
-    private let sdk: BandyerSDKProtocol
+    private let sdk: KaleyraVideoSDKProtocol
     private let viewControllerPresenter: ViewControllerPresenter
     private let callWindow: CallWindowProtocol
-    private let formatter: Formatter
 
     private var configuration = UserInterfacePresenterConfiguration(showsFeedbackWhenCallEnds: false,
                                                                     chatAudioButtonConf: .disabled,
                                                                     chatVideoButtonConf: .disabled)
 
+    private lazy var subscriptions = Set<AnyCancellable>()
+
     // MARK: - Init
 
-    init(sdk: BandyerSDKProtocol,
+    init(sdk: KaleyraVideoSDKProtocol,
          viewControllerPresenter: ViewControllerPresenter,
-         callWindow: CallWindowProtocol,
-         formatter: Formatter) {
+         callWindow: CallWindowProtocol) {
         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,
+    convenience init(rootViewController: UIViewController?) {
+        self.init(sdk: KaleyraVideo.instance,
                   viewControllerPresenter: KaleyraVideoSDKUserInterfacePresenter.makeViewControllerPresenter(rootViewController),
-                  callWindow: KaleyraVideoSDKUserInterfacePresenter.makeCallWindow(),
-                  formatter: formatter)
+                  callWindow: KaleyraVideoSDKUserInterfacePresenter.makeCallWindow())
     }
 
     private static func makeCallWindow() -> CallWindow {
-        guard let instance = CallWindow.instance else {
-            return CallWindow()
+        guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene else {
+            return .init()
         }
-        return instance
+
+        return .init(windowScene: windowScene)
     }
 
     private static func makeViewControllerPresenter(_ rootViewController: UIViewController?) -> ViewControllerPresenter {
@@ -86,19 +82,15 @@ class KaleyraVideoSDKUserInterfacePresenter: NSObject, UserInterfacePresenter {
 
     // MARK: - Setup
 
-    private func setupCallWindow() {
-        callWindow.callDelegate = self
-    }
-
     private func setupSDK() {
-        sdk.callClient.addIncomingCall(observer: self, queue: .main)
+        sdk.conference?.callPublisher.compactMap({ $0 }).receive(on: RunLoop.main).sink { [weak self] call in
+            self?.present(call: call)
+        }.store(in: &subscriptions)
     }
 
     private func setupNotificationCoordinator() {
-        sdk.notificationsCoordinator?.chatListener = self
-        sdk.notificationsCoordinator?.fileShareListener = self
-        sdk.notificationsCoordinator?.formatter = formatter
-        sdk.notificationsCoordinator?.start()
+        sdk.conversation?.notifications.delegate = self
+        sdk.conversation?.notifications.start()
     }
 
     // MARK: - Configuration
@@ -113,46 +105,59 @@ class KaleyraVideoSDKUserInterfacePresenter: NSObject, UserInterfacePresenter {
     // MARK: - Presenting Call UI
 
     func presentCall(_ options: CreateCallOptions) {
-        let intent = options.makeStartOutgoingCallIntent()
-        handleCallIntent(intent)
+        startCall(callees: options.callees, options: options.makeCallOptions())
     }
 
     func presentCall(_ url: URL) {
-        let intent = JoinURLIntent(url: url)
-        handleCallIntent(intent)
+        sdk.conference?.join(url: url) { result in
+            do {
+                try result.get()
+            } catch {
+                debugPrint("An error occurred while starting join call \(error)")
+            }
+        }
     }
 
-    private func makeCallViewControllerConfiguration() -> CallViewControllerConfiguration {
-        let builder = CallViewControllerConfigurationBuilder().withFormatter(formatter)
-
-        if configuration.showsFeedbackWhenCallEnds {
-            _ = builder.withFeedbackEnabled()
+    private func startCall(callees: [String], options: KaleyraVideoSDK.CallOptions) {
+        sdk.conference?.call(callees: callees,
+                             options: options) { result in
+            do {
+                try result.get()
+            } catch {
+                debugPrint("An error occurred while starting call \(error)")
+            }
         }
+    }
 
-        return builder.build()
+    private func present(call: Call) {
+        let controller = CallViewController(call: call, configuration: makeCallViewControllerConfiguration())
+        controller.delegate = self
+        callWindow.makeKeyAndVisible()
+        callWindow.set(rootViewController: controller, animated: true, completion: nil)
+    }
+
+    private func makeCallViewControllerConfiguration() -> CallViewController.Configuration {
+        .init(feedback: configuration.showsFeedbackWhenCallEnds ? .init() : nil)
     }
 
     // MARK: - Presenting Chat UI
 
     func presentChat(with userID: String) {
-        let intent = OpenChatIntent.openChat(with: userID)
+        let intent = ChatViewController.Intent.participant(id: userID)
         handleChatIntent(intent)
     }
 
-    private func makeChannelViewController(intent: OpenChatIntent) -> ChannelViewController {
-        let config = ChannelViewControllerConfiguration(audioButton: configuration.chatHasAudioButton,
-                                                        videoButton: configuration.chatHasVideoButton,
-                                                        formatter: formatter)
-        let controller = ChannelViewController()
+    private func makeChannelViewController(intent: ChatViewController.Intent) -> ChatViewController {
+        let controller = ChatViewController(intent: intent,
+                                            configuration: .init(audioButton: configuration.chatHasAudioButton,
+                                                                 videoButton: configuration.chatHasVideoButton))
         controller.delegate = self
-        controller.configuration = config
-        controller.intent = intent
         return controller
     }
 
     // MARK: - Intents
 
-    private func handleChatIntent(_ intent: OpenChatIntent) {
+    private func handleChatIntent(_ intent: ChatViewController.Intent) {
         let channelViewController = makeChannelViewController(intent: intent)
 
         let continueWith: (() -> Void) = { [weak self] in
@@ -165,85 +170,48 @@ class KaleyraVideoSDKUserInterfacePresenter: NSObject, UserInterfacePresenter {
             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
+// MARK: - CallViewControllerDelegate
 
-@available(iOS 12.0, *)
-extension KaleyraVideoSDKUserInterfacePresenter: CallWindowDelegate {
+extension KaleyraVideoSDKUserInterfacePresenter: CallViewControllerDelegate {
 
-    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))
+    func callViewControllerDidFinish(_ controller: KaleyraVideoSDK.CallViewController) {
+        callWindow.set(rootViewController: nil, animated: true) { _ in
+            self.callWindow.isHidden = true
+        }
     }
 }
 
 // MARK: - InAppChatNotificationTouchListener
 
-@available(iOS 12.0, *)
-extension KaleyraVideoSDKUserInterfacePresenter: InAppChatNotificationTouchListener {
+extension KaleyraVideoSDKUserInterfacePresenter: InAppNotificationsDelegate {
 
-    func onTouch(_ notification: Bandyer.ChatNotification) {
-        guard let intent = OpenChatIntent.openChat(from: notification) else { return }
+    func onTouch(_ notification: ChatNotification) {
+        let intent = ChatViewController.Intent.chat(id: notification.chatId)
         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 {
+extension KaleyraVideoSDKUserInterfacePresenter: ChatViewControllerDelegate {
 
-    func channelViewControllerDidFinish(_ controller: Bandyer.ChannelViewController) {
+    func chatViewControllerDidFinish(_ controller: KaleyraVideoSDK.ChatViewController) {
         viewControllerPresenter.dismiss(controller, animated: true, completion: nil)
     }
 
-    func channelViewController(_ controller: Bandyer.ChannelViewController, didTapAudioCallWith users: [String]) {
+    func chatViewControllerDidTapAudioCallButton(_ controller: KaleyraVideoSDK.ChatViewController) {
         guard case let .enabled(audioOptions) = configuration.chatAudioButtonConf else { return }
 
-        let options = audioOptions.callOptions
-        let intent = StartOutgoingCallIntent(callees: users, options: options)
-        handleCallIntent(intent)
+        startCall(callees: controller.participants, options: .init(type: audioOptions.type.callType,
+                                                                   recording: audioOptions.recordingType?.callRecordingType))
     }
 
-    func channelViewController(_ controller: Bandyer.ChannelViewController, didTapVideoCallWith users: [String]) {
+    func chatViewControllerDidTapVideoCallButton(_ controller: KaleyraVideoSDK.ChatViewController) {
         guard case let .enabled(videoOptions) = configuration.chatVideoButtonConf else { return }
 
-        let options = videoOptions.callOptions
-        let intent = StartOutgoingCallIntent(callees: users, options: options)
-        handleCallIntent(intent)
+        startCall(callees: controller.participants, options: .init(type: .audioVideo,
+                                                                   recording: videoOptions.recordingType?.callRecordingType))
     }
 }

package/native-bridge/iOS/Source/UI/Presenters/PresentingViewControllerViewControllerPresenter.swift

@@ -4,7 +4,6 @@
 import Foundation
 import UIKit
 
-@available(iOS 12.0, *)
 class PresentingViewControllerViewControllerPresenter: ViewControllerPresenter {
 
     // MARK: - Properties

package/native-bridge/iOS/Source/UI/Presenters/ViewControllerPresenter.swift

@@ -4,7 +4,6 @@
 import Foundation
 import UIKit
 
-@available(iOS 12.0, *)
 protocol ViewControllerPresenter {
 
     var isPresenting: Bool { get }

package/native-bridge/iOS/Source/UI/Presenters/WindowViewControllerPresenter.swift

@@ -4,7 +4,6 @@
 import Foundation
 import UIKit
 
-@available(iOS 12.0, *)
 class WindowViewControllerPresenter: ViewControllerPresenter {
 
     // MARK: - Nested Types

package/native-bridge/iOS/Source/UI/UserInterfacePresenter+MainQueueRelay.swift

@@ -3,7 +3,6 @@
 
 import Foundation
 
-@available(iOS 12.0, *)
 extension MainQueueRelay: UserInterfacePresenter where Decoratee: UserInterfacePresenter {
 
     func configure(with configuration: UserInterfacePresenterConfiguration) {

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

@@ -3,7 +3,6 @@
 
 import Foundation
 
-@available(iOS 12.0, *)
 protocol UserInterfacePresenter {
 
     func configure(with configuration: UserInterfacePresenterConfiguration)

package/native-bridge/iOS/Source/User Details/Cache/UsersDetailsCache.swift

@@ -2,27 +2,26 @@
 // See LICENSE for licensing information
 
 import Foundation
-import Bandyer
+import KaleyraVideoSDK
 
-@available(iOS 12.0, *)
 class UsersDetailsCache {
 
-    private lazy var items = [String : Bandyer.UserDetails]()
+    private lazy var items = [String : KaleyraVideoSDK.UserDetails]()
     private let lock: Locking = NSRecursiveLock()
 
-    func setItem(_ item: Bandyer.UserDetails, forKey key: String) {
+    func setItem(_ item: KaleyraVideoSDK.UserDetails, forKey key: String) {
         lock.sync {
             items[key] = item
         }
     }
 
-    func setItems(_ items: [Bandyer.UserDetails]) {
+    func setItems(_ items: [KaleyraVideoSDK.UserDetails]) {
         lock.sync {
-            items.forEach { setItem($0, forKey: $0.userID) }
+            items.forEach { setItem($0, forKey: $0.userId) }
         }
     }
 
-    func item(forKey key: String) -> Bandyer.UserDetails? {
+    func item(forKey key: String) -> KaleyraVideoSDK.UserDetails? {
         lock.sync {
             items[key]
         }