edoctor-sendbird-calls 1.0.0

package/ios/RNSendBirdCalls.swift

@@ -0,0 +1,549 @@
+import Foundation
+import CallKit
+import PushKit
+import SendBirdCalls
+import UIKit
+import React
+import AVFoundation
+
+@objc(RNSendBirdCalls)
+class RNSendBirdCalls: RCTEventEmitter, SendBirdCallDelegate, DirectCallDelegate, PKPushRegistryDelegate, SendBirdRecordingDelegate {
+
+    var queue: DispatchQueue = DispatchQueue(label: "RNSendBirdCalls")
+    var voipPushRegistry: PKPushRegistry?
+    var HAS_LISTENER = false
+    var CALL_ACTIVE: DirectCall?
+
+    let TAG = "[RNSendBirdCalls]_"
+
+    static let onEnded = "onEnded"
+    static let onRinging = "onRinging"
+    static let onConnected = "onConnected"
+    static let onReconnected = "onReconnected"
+    static let onReconnecting = "onReconnecting"
+    static let onCallDidAccept = "onCallDidAccept"
+    static let onRemoteAudioSettingsChanged = "onRemoteAudioSettingsChanged"
+    static let onRemoteVideoSettingsChanged = "onRemoteVideoSettingsChanged"
+    static let onRecordingSucceeded = "onRecordingSucceeded"
+    static let onRecordingFailed = "onRecordingFailed"
+
+    let jsEvents: NSMutableArray = []
+
+    override init() {
+        super.init()
+        setupSendBird()
+    }
+    
+    deinit {
+        removeAllEvents()
+        voipPushRegistry?.delegate = nil
+        voipPushRegistry = nil
+        CALL_ACTIVE?.delegate = nil
+        CALL_ACTIVE = nil
+    }
+    
+    private func setupSendBird() {
+        let userDefaults = UserDefaults(suiteName: "edoctorStorage")
+        let appId = "0BEF9C57-BA3B-474E-A40F-62B027AA47F6"
+
+        let config = SendBirdCall.configure(appId: appId)
+        if(config){
+            print(TAG + "CONFIG SUCCESS")
+        }else {
+            print(TAG + "CONFIG FAILED")
+        }
+        SendBirdCall.addDelegate(self, identifier: "RNSendBirdCalls")
+        SendBirdCall.setDirectCallDialingSoundOnWhenSilentMode(isEnabled: true)
+        SendBirdCall.addRecordingDelegate(self, identifier: "RNSendBirdRecording")
+    }
+
+    // MARK: - RCTEventEmitter overrides for RN 0.79.x
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override func supportedEvents() -> [String]! {
+        return [
+            RNSendBirdCalls.onEnded,
+            RNSendBirdCalls.onRinging,
+            RNSendBirdCalls.onConnected,
+            RNSendBirdCalls.onReconnected,
+            RNSendBirdCalls.onReconnecting,
+            RNSendBirdCalls.onCallDidAccept,
+            RNSendBirdCalls.onRemoteAudioSettingsChanged,
+            RNSendBirdCalls.onRemoteVideoSettingsChanged,
+            RNSendBirdCalls.onRecordingSucceeded,
+            RNSendBirdCalls.onRecordingFailed,
+        ]
+    }
+
+    override func startObserving() {
+        HAS_LISTENER = true
+    }
+
+    override func stopObserving() {
+        HAS_LISTENER = false
+    }
+
+    @objc func setNativeEvent(_ event: String) {
+        DispatchQueue.main.async {
+            if !self.jsEvents.contains(event) {
+                self.jsEvents.add(event)
+            }
+        }
+    }
+
+    @objc func removeNativeEvent(_ event: String) {
+        DispatchQueue.main.async {
+            let index = self.jsEvents.index(of: event)
+            if index != NSNotFound {
+                self.jsEvents.removeObject(at: index)
+            }
+        }
+    }
+
+    @objc func removeAllEvents() {
+        DispatchQueue.main.async {
+            self.jsEvents.removeAllObjects()
+        }
+        SendBirdCall.removeAllDelegates()
+        SendBirdCall.removeAllRecordingDelegates()
+    }
+
+    // MARK: - SendBird Methods
+    @objc func shareStorage(
+        _ appId: String
+    ) -> Void {
+        let userDefaults = UserDefaults(suiteName: "edoctorStorage")
+        userDefaults?.set(appId, forKey: "APP_ID_NATIVE")
+        userDefaults?.synchronize()
+    }
+
+    @objc func authenticate(_ userId: String, accessToken: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        let params = AuthenticateParams(userId: userId, accessToken: accessToken)
+
+        SendBirdCall.authenticate(with: params) { (user, error) in
+            guard let user = user, error == nil else {
+                let code = "\(error?.errorCode.rawValue ?? 0)"
+                let message = error?.localizedDescription ?? "Có lỗi xảy ra"
+                resolve(["succeeded": false , "errorCode": code, "errorMessage": message])
+                return
+            }
+
+            resolve(["succeeded": true ,"userId": user.userId, "nickname": user.nickname ?? ""])
+        }
+    }
+
+    @objc func deAuthenticate(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
+        SendBirdCall.unregisterAllVoIPPushTokens { error in
+            guard error == nil else {
+                print("RNSendBirdCalls" + "Cerror deauthen")
+                let message = error?.localizedDescription ?? "Có lỗi xảy ra"
+                print("RNSendBirdCalls" + message)
+                return
+            }
+        }
+        SendBirdCall.deauthenticate { (error) in
+            guard error == nil else {
+                let code = "\(error?.errorCode.rawValue ?? 0)"
+                let message = error?.localizedDescription ?? "Có lỗi xảy ra"
+                resolve(["succeeded": false , "errorCode": code, "errorMessage": message])
+                return
+            }
+
+            resolve(["succeeded": true ])
+        }
+    }
+
+    @objc func initSendBird(_ appId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        let config = SendBirdCall.configure(appId: appId)
+        if(config){
+            resolve(["succeeded": true ])
+        }else {
+            resolve(["succeeded": false ])
+        }
+    }
+
+    @objc func dial(_ calleeId: String, isVideoCall: Bool, isVideoEnable: Bool, isAudioEnable: Bool, appointmentScheduleId: String, eClinicId: String , resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock){
+        print(TAG + "DIAL")
+        let callOptions = CallOptions(isAudioEnabled: isAudioEnable, isVideoEnabled: isVideoEnable, useFrontCamera: true)
+        let customItems = [
+            "appointmentScheduleId": appointmentScheduleId,
+            "eClinicId": eClinicId
+        ]
+        let params = DialParams(calleeId: calleeId, isVideoCall: isVideoCall, callOptions: callOptions, customItems: customItems)
+
+        let directCall = SendBirdCall.dial(with: params) { call, error in
+            guard let call = call, error == nil else {
+                let code = "\(error?.errorCode.rawValue ?? 0)"
+                let message = error?.localizedDescription ?? "Có lỗi xảy ra"
+                resolve(["succeeded": false , "errorCode": code, "errorMessage": message])
+                return
+            }
+
+            resolve(["succeeded": true ,"callId": call.callId, "caller": call.caller?.userId ?? "", "callee": call.callee?.userId ?? ""])
+        }
+        CALL_ACTIVE = directCall;
+        directCall?.delegate = self
+    }
+
+    @objc func endCall(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "END CALL")
+        guard let call = CALL_ACTIVE else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+            return
+        }
+        call.end()
+        CXCallManager.shared.endCXCall(call)
+        let params = getParamFromDirectCall(call: call)
+        params.setValue(true, forKey: "succeeded")
+        resolve(params)
+    }
+
+    @objc func acceptCall(_ callId: String, isVideoEnable: Bool, isAudioEnable: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "ACCEPT CALL")
+        guard let call = SendBirdCall.getCall(forCallId: callId) else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+            return
+        }
+        let callOptions = CallOptions(isAudioEnabled: isAudioEnable, isVideoEnabled: isVideoEnable, useFrontCamera: true)
+        let acceptParams = AcceptParams(callOptions: callOptions)
+        call.accept(with: acceptParams)
+        let params = getParamFromDirectCall(call: call)
+        params.setValue(true, forKey: "succeeded")
+        resolve(params)
+    }
+
+    @objc func voipRegistry() {
+        self.voipPushRegistry = PKPushRegistry(queue: DispatchQueue.main)
+        self.voipPushRegistry?.delegate = self
+        self.voipPushRegistry?.desiredPushTypes = [.voIP]
+    }
+
+    @objc func addDirectCallSound(_ soundType: String, filename: String) {
+        if(soundType == "DIALING"){
+            SendBirdCall.addDirectCallSound(filename, forType: .dialing)
+        }else if(soundType == "RINGING"){
+            SendBirdCall.addDirectCallSound(filename, forType: .ringing)
+        }else if(soundType == "RECONNECTING"){
+            SendBirdCall.addDirectCallSound(filename, forType: .reconnecting)
+        }else if(soundType == "RECONNECTED"){
+            SendBirdCall.addDirectCallSound(filename, forType: .reconnected)
+        }
+    }
+
+    @objc func setDirectCallDialingSoundOnWhenSilentMode(_ isEnabled: Bool) {
+        SendBirdCall.setDirectCallDialingSoundOnWhenSilentMode(isEnabled: isEnabled)
+    }
+
+    @objc func getOngoingCalls(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let ongoingCalls = SendBirdCall.getOngoingCalls()
+        var resultData: [NSDictionary] = []
+        
+        if(ongoingCalls.count > 0){
+            ongoingCalls.forEach({ directCall in
+                resultData.append(getParamFromDirectCall(call: directCall))
+            })
+        }
+        resolve(resultData)
+    }
+
+    @objc func muteMicrophone(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "muteMicrophone")
+        if(CALL_ACTIVE != nil){
+            CALL_ACTIVE?.muteMicrophone()
+            resolve(["succeeded": true])
+        }else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+        }
+    }
+
+    @objc func unmuteMicrophone(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "unmuteMicrophone")
+        if(CALL_ACTIVE != nil){
+            CALL_ACTIVE?.unmuteMicrophone()
+            resolve(["succeeded": true])
+        }else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+        }
+    }
+
+    @objc func startVideo(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "startVideo")
+        if(CALL_ACTIVE != nil){
+            CALL_ACTIVE?.startVideo()
+            resolve(["succeeded": true])
+        }else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+        }
+    }
+
+    @objc func stopVideo(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "stopVideo")
+        if(CALL_ACTIVE != nil){
+            CALL_ACTIVE?.stopVideo()
+            resolve(["succeeded": true])
+        }else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+        }
+    }
+
+    @objc func switchCamera(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "switchCamera")
+        if(CALL_ACTIVE != nil){
+            CALL_ACTIVE?.switchCamera { error in
+                if(error != nil){
+                    let code = "\(error?.errorCode.rawValue ?? 0)"
+                    let message = error?.localizedDescription ?? "Có lỗi xảy ra"
+                    resolve(["succeeded": false , "errorCode": code, "errorMessage": message])
+                }else {
+                    resolve(["succeeded": true])
+                }
+            }
+        } else {
+            resolve(["succeeded": false , "errorMessage": "Cuộc gọi không tồn tại"])
+        }
+    }
+
+    @objc func startRecording(_ fileName: String, isRemote: Bool, resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        print(TAG + "startRecording")
+
+        let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+        let documentsDirectory = paths[0]
+
+        let options = isRemote ? RecordingOptions(recordingType: .localAudioRemoteAudioAndVideo, directoryPath: documentsDirectory, fileName: fileName) : RecordingOptions(recordingType: .localAudioAndVideoRemoteAudio, directoryPath: documentsDirectory, fileName: fileName)
+
+        if(CALL_ACTIVE != nil){
+            CALL_ACTIVE?.startRecording(options: options) { (recordingId, error) in
+                if(error == nil){
+                    let result: NSDictionary = [
+                        "succeeded": true,
+                        "recordingId": recordingId ?? "",
+                        "filePath": documentsDirectory.description,
+                    ]
+                    resolve(result)
+                }else {
+                    let result: NSDictionary = [
+                        "succeeded": false,
+                        "recordingId": recordingId ?? "",
+                    ]
+                    resolve(result)
+                }
+            }
+        }else {
+            let result: NSDictionary = [
+                "succeeded": false,
+            ]
+            resolve(result)
+        }
+    }
+
+    @objc func stopRecording(_ recordingId: String, isVideoCall: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock){
+        print(TAG + "stopRecording")
+        if(CALL_ACTIVE != nil){
+            let resultStop: Bool = ((CALL_ACTIVE?.stopRecording(recordingId: recordingId)) != nil)
+            let result: NSDictionary = [
+                "succeeded": resultStop,
+            ]
+            resolve(result)
+        }else {
+            let result: NSDictionary = [
+                "succeeded": false,
+            ]
+            resolve(result)
+        }
+    }
+
+    @objc func endAllCalls(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let ongoingCalls = SendBirdCall.getOngoingCalls()
+        if(ongoingCalls.count > 0){
+            ongoingCalls.forEach({ directCall in
+                directCall.end()
+                CXCallManager.shared.endCXCall(directCall)
+            })
+        }
+        resolve(["succeeded": true])
+    }
+
+    func endCalls() {
+        let ongoingCalls = SendBirdCall.getOngoingCalls()
+        if(ongoingCalls.count > 0){
+            ongoingCalls.forEach({ directCall in
+                directCall.end()
+                CXCallManager.shared.endCXCall(directCall)
+            })
+        }
+    }
+
+    // MARK: - PKPushRegistryDelegate
+    func pushRegistry(_ registry: PKPushRegistry, didUpdate pushCredentials: PKPushCredentials, for type: PKPushType) {
+        SendBirdCall.registerVoIPPush(token: pushCredentials.token, unique: true) { error in
+            guard error == nil else { return }
+        }
+    }
+
+    func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload, for type: PKPushType) {
+        print(TAG + "pushRegistry incoming push event")
+        SendBirdCall.pushRegistry(registry, didReceiveIncomingPushWith: payload, for: type, completionHandler: nil)
+    }
+
+    @available(iOS 10.0, *)
+    func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload, for type: PKPushType, completion: @escaping () -> Void) {
+        print(TAG + "pushRegistry pushRegistry incoming call")
+        SendBirdCall.addDelegate(self, identifier: "RNSendBirdCalls")
+        SendBirdCall.pushRegistry(registry, didReceiveIncomingPushWith: payload, for: type) { uuid in
+            guard uuid != nil else {
+                let update = CXCallUpdate()
+                update.remoteHandle = CXHandle(type: .generic, value: "invalid")
+                let randomUUID = UUID()
+
+                CXCallManager.shared.reportIncomingCall(with: randomUUID, update: update) { _ in
+                    CXCallManager.shared.endCall(for: randomUUID, endedAt: Date(), reason: .acceptFailed)
+                }
+                completion()
+                return
+            }
+            completion()
+        }
+    }
+
+    // MARK: - Helper Methods
+    func getParamFromDirectCall(call: DirectCall) -> NSMutableDictionary {
+        let calleeMap: NSDictionary = [
+            "userId": call.callee?.userId ?? "",
+            "nickname": call.callee?.nickname ?? "",
+            "profileURL": call.callee?.profileURL ?? "",
+        ]
+
+        let callerMap: NSDictionary = [
+            "userId": call.caller?.userId ?? "",
+            "nickname": call.caller?.nickname ?? "",
+            "profileURL": call.caller?.profileURL ?? "",
+        ]
+
+        let callId = call.callId
+        let isVideoCall = call.isVideoCall
+        let duration: Int64 = call.duration
+        let isRemoteAudioEnabled = call.isRemoteAudioEnabled
+        let isRemoteVideoEnabled = call.isRemoteVideoEnabled
+        let isLocalVideoEnabled = call.isLocalVideoEnabled
+        let isLocalAudioEnabled = call.isLocalAudioEnabled
+        let customItems = call.customItems
+
+        let params: NSMutableDictionary = [
+            "callId" : callId ?? "",
+            "duration": duration,
+            "isRemoteAudioEnabled": isRemoteAudioEnabled,
+            "isRemoteVideoEnabled": isRemoteVideoEnabled,
+            "isLocalVideoEnabled": isLocalVideoEnabled,
+            "isLocalAudioEnabled": isLocalAudioEnabled,
+            "isVideoCall": isVideoCall,
+            "callee" : calleeMap,
+            "caller" : callerMap,
+            "customItems": customItems ?? [:],
+        ]
+        return params
+    }
+
+    func sendEventWithName(eventName: String, params: NSDictionary) {
+        // Ensure we're on main queue for RN 0.79.x
+        DispatchQueue.main.async {
+            if self.jsEvents.contains(eventName) && self.HAS_LISTENER && self.bridge != nil {
+                self.sendEvent(withName: eventName, body: params)
+            }
+        }
+    }
+
+    // MARK: - SendBirdCallDelegate
+    func didStartRinging(_ directCall: DirectCall) {
+        print(TAG + "onRinging")
+        directCall.delegate = self
+        CALL_ACTIVE = directCall
+
+        guard let uuid = directCall.callUUID else { return }
+        guard CXCallManager.shared.shouldProcessCall(for: uuid) else { return }
+
+        let name = "BS. \(directCall.caller?.nickname ?? "Chưa xác định")"
+        let update = CXCallUpdate()
+        update.remoteHandle = CXHandle(type: .generic, value: name)
+        update.hasVideo = directCall.isVideoCall
+        update.localizedCallerName = "BS. \(directCall.caller?.nickname ?? "Chưa xác định")"
+
+        if SendBirdCall.getOngoingCallCount() > 1 {
+            CXCallManager.shared.reportIncomingCall(with: uuid, update: update) { _ in
+                CXCallManager.shared.endCall(for: uuid, endedAt: Date(), reason: .declined)
+            }
+            directCall.end()
+        } else {
+            CXCallManager.shared.reportIncomingCall(with: uuid, update: update)
+            let params = getParamFromDirectCall(call: directCall)
+            sendEventWithName(eventName: RNSendBirdCalls.onRinging, params: params)
+        }
+    }
+
+    func didEstablish(_ directCall: DirectCall) {
+        print(TAG + "onCallDidAccept")
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onCallDidAccept, params: params)
+    }
+
+    func didConnect(_ directCall: DirectCall) {
+        print(TAG + "onConnected")
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onConnected, params: params)
+    }
+
+    func didStartReconnecting(_ directCall: DirectCall) {
+        print(TAG + "onReconnecting")
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onReconnecting, params: params)
+    }
+
+    func didReconnect(_ directCall: DirectCall) {
+        print(TAG + "didReconnect")
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onReconnected, params: params)
+    }
+
+    func didRemoteAudioSettingsChange(_ directCall: DirectCall) {
+        print(TAG + "onRemoteAudioSettingsChanged")
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onRemoteAudioSettingsChanged, params: params)
+    }
+
+    func didRemoteVideoSettingsChange(_ directCall: DirectCall) {
+        print(TAG + "onRemoteVideoSettingsChanged")
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onRemoteVideoSettingsChanged, params: params)
+    }
+
+    func didEnd(_ directCall: DirectCall) {
+        var callId: UUID = UUID()
+        if let callUUID = directCall.callUUID {
+            callId = callUUID
+        }
+        print(TAG + "didEnd")
+        CALL_ACTIVE = nil
+        let params = getParamFromDirectCall(call: directCall)
+        sendEventWithName(eventName: RNSendBirdCalls.onEnded, params: params)
+        CXCallManager.shared.endCall(for: callId, endedAt: Date(), reason: directCall.endResult)
+        guard let callLog = directCall.callLog else { return }
+    }
+
+    // MARK: - SendBirdRecordingDelegate
+    func didSaveRecording(call: DirectCall, recordingId: String, options: RecordingOptions, outputURL: URL) {
+        print(TAG + "didSaveRecording")
+        let recordingMap: NSDictionary = [
+            "outputFilePath": outputURL.absoluteString,
+        ]
+        sendEventWithName(eventName: RNSendBirdCalls.onRecordingSucceeded, params: recordingMap)
+    }
+
+    func didFailToSaveRecording(call: DirectCall, recordingId: String, error: SBCError) {
+        print(TAG + "didFailToSaveRecording")
+        let recordingMap: NSDictionary = [
+            "errorMessage": error.localizedDescription,
+        ]
+        sendEventWithName(eventName: RNSendBirdCalls.onRecordingFailed, params: recordingMap)
+    }
+}

package/ios/RNSendBirdCallsHelper.swift

@@ -0,0 +1,28 @@
+import SendBirdCalls
+@objc(RNSendBirdCallsHelper)
+public class RNSendBirdCallsHelper: NSObject {
+    @objc public static func applicationWillTerminate(application: UIApplication?) -> Void {
+        print("sayHello2")
+
+     // This method will be called when the app is forcefully terminated.
+     // End all ongoing calls in this method.
+     let callManager = CXCallManager.shared
+     let ongoingCalls = callManager.currentCalls.compactMap { SendBirdCall.getCall(forUUID: $0.uuid) }
+
+     ongoingCalls.forEach { directCall in
+         // Sendbird Calls: End call
+         directCall.end()
+
+         // CallKit: Request End transaction
+         callManager.endCXCall(directCall)
+
+         // CallKit: Report End if uuid is valid
+         if let uuid = directCall.callUUID {
+             callManager.endCall(for: uuid, endedAt: Date(), reason: .none)
+         }
+     }
+     // However, because iOS gives a limited time to perform remaining tasks,
+     // There might be some calls failed to be ended
+     // In this case, I recommend that you register local notification to notify the unterminated calls.
+    }
+}

package/ios/RNVSendBirdCallsVideo.swift

@@ -0,0 +1,55 @@
+import SendBirdCalls
+import CoreGraphics
+
+@objc(RNVSendBirdCallsVideo)
+class RNVSendBirdCallsVideo : UIView {
+    @objc var callId: String = ""
+    @objc var local: Bool = true
+    @objc var scaleFit: Bool = true
+    var videoView: SendBirdVideoView!
+
+    override init(frame: CGRect) {
+        super.init(frame: frame);
+        videoView = SendBirdVideoView(frame: self.frame)
+        videoView.backgroundColor = UIColor.gray
+        videoView.frame = self.bounds
+        self.addSubview(videoView)
+    }
+       required init?(coder aDecoder: NSCoder) {
+          fatalError("init(coder:) has not been implemented")
+        }
+
+    override func layoutSubviews() {
+        videoView.frame = self.bounds
+       }
+
+    override func didSetProps(_ changedProps: [String]!) {
+        guard let call = SendBirdCall.getCall(forCallId: self.callId) else {
+            return
+        }
+
+        if (self.scaleFit) {
+          self.videoView.videoContentMode = UIView.ContentMode.scaleAspectFit
+        } else {
+          self.videoView.videoContentMode = UIView.ContentMode.scaleAspectFill
+        }
+
+        if self.local {
+            call.updateLocalVideoView(self.videoView)
+        }else{
+            call.updateRemoteVideoView(self.videoView)
+        }
+    }
+
+	  func setCallId(callId: String) {
+	      self.callId = callId
+	  }
+
+	  func setScaleFit(scaleFit: Bool) {
+        self.scaleFit = scaleFit
+    }
+
+    func setLocal(local: Bool) {
+        self.local = local
+    }
+}

package/ios/RNVSendBirdCallsVideoManager.mm

@@ -0,0 +1,6 @@
+#import "React/RCTViewManager.h"
+@interface RCT_EXTERN_MODULE(RNVSendBirdCallsVideoManager, RCTViewManager)
+    RCT_EXPORT_VIEW_PROPERTY(callId, NSString)
+    RCT_EXPORT_VIEW_PROPERTY(local, BOOL)
+    RCT_EXPORT_VIEW_PROPERTY(scaleFit, BOOL)
+@end

package/ios/RNVSendBirdCallsVideoManager.swift

@@ -0,0 +1,15 @@
+import SendBirdCalls
+
+@objc(RNVSendBirdCallsVideoManager)
+class RNVSendBirdCallsVideoManager: RCTViewManager {
+
+    override static func requiresMainQueueSetup() -> Bool{
+        return true
+    }
+
+  override func view() -> UIView! {
+      return RNVSendBirdCallsVideo()
+
+  }
+}
+