omikit-plugin 0.1.0

package/ios/CallProcess/CallManager.swift

@@ -0,0 +1,367 @@
+//
+//  CallUtils.swift
+//  OMICall Contact Center
+//
+//  Created by Tuan on 22/03/2022.
+//
+
+import Foundation
+import AVFoundation
+import MediaPlayer
+import SwiftUI
+import OmiKit
+import AVFoundation
+
+class CallManager {
+    
+    static private var instance: CallManager? = nil // Instance
+    var call: OMICall? // Call
+    private var numberRetry: Int = 0
+    var isCallError: Bool = false  // check when call error
+    private let omiLib = OMISIPLib.sharedInstance()
+    private var isSpeaker = false
+    var currentConfirmedCall : OMICall?
+    var videoManager: OMIVideoViewManager?
+    
+    
+    /// Get instance
+    static func shareInstance() -> CallManager {
+        if (instance == nil) {
+            instance = CallManager()
+        }
+        return instance!
+    }
+    
+    func updateToken(params: [String: Any]) {
+        if let apnsToken = params["apnsToken"] as? String {
+            OmiClient.setUserPushNotificationToken(apnsToken)
+        }
+    }
+    
+    func initEndpoint(params: [String: Any]){
+        var isSupportVideoCall = false
+        if let userName = params["userName"] as? String, let password = params["password"] as? String, let realm = params["realm"] as? String {
+            OmiClient.initWithUsername(userName, password: password, realm: realm)
+            if let isVideoCall = params["isVideo"] as? Bool {
+                isSupportVideoCall = isVideoCall
+            }
+            OmiClient.startOmiService(isSupportVideoCall)
+            if (isSupportVideoCall) {
+                OmiClient.registerAccount()
+                videoManager = OMIVideoViewManager.init()
+            }
+            registerNotificationCenter()
+        }
+    }
+    
+    func registerNotificationCenter() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            NotificationCenter.default.removeObserver(CallManager.instance!)
+            NotificationCenter.default.addObserver(CallManager.instance!,
+                                                   selector: #selector(self.callStateChanged(_:)),
+                                                   name: NSNotification.Name.OMICallStateChanged,
+                                                   object: nil
+            )
+            NotificationCenter.default.addObserver(CallManager.instance!,
+                                                   selector: #selector(self.callDealloc(_:)),
+                                                   name: NSNotification.Name.OMICallDealloc,
+                                                   object: nil
+            )
+        }
+    }
+    
+    @objc func callDealloc(_ notification: NSNotification) {
+        guard let userInfo = notification.userInfo,
+              let call     = userInfo[OMINotificationUserInfoCallKey] as? OMICall else {
+            return;
+        }
+        if (call.callState == .disconnected) {
+            DispatchQueue.main.async {
+//                SwiftOmikitPlugin.instance?.sendEvent(onCallEnd, [:])
+                self.currentConfirmedCall = nil
+            }
+        }
+    }
+    
+    @objc fileprivate func callStateChanged(_ notification: NSNotification) {
+        guard let userInfo = notification.userInfo,
+              let call     = userInfo[OMINotificationUserInfoCallKey] as? OMICall else {
+            return;
+        }
+        print("call state")
+        print(call.callState)
+        switch (call.callState) {
+        case .calling:
+            if (!call.isIncoming) {
+                NSLog("Outgoing call, in CALLING state, with UUID \(call.uuid)")
+//                SwiftOmikitPlugin.instance?.sendEvent(onRinging, [:])
+            }
+            break
+        case .early:
+            if (!call.isIncoming) {
+                NSLog("Outgoing call, in EARLY state, with UUID: \(call.uuid)")
+            }
+            break
+        case .connecting:
+            if (!call.isIncoming) {
+                NSLog("Outgoing call, in CONNECTING state, with UUID: \(call.uuid)")
+            }
+            break
+        case .confirmed:
+            DispatchQueue.main.async {
+                if (!call.isIncoming) {
+                    NSLog("Outgoing call, in CONFIRMED state, with UUID: \(call.uuid)")
+//                    SwiftOmikitPlugin.instance?.sendEvent(onCallEstablished, [:])
+//                    SwiftOmikitPlugin.instance?.sendEvent(onMuted, ["isMuted": call.muted])
+                    self.currentConfirmedCall = call
+                    return
+                }
+                //call video
+                NSLog("Outgoing call, in CONFIRMED state, with UUID: \(call.uuid)")
+//                SwiftOmikitPlugin.instance?.sendEvent(onCallEstablished, [:])
+//                SwiftOmikitPlugin.instance?.sendEvent(onMuted, ["isMuted": call.muted])
+                self.currentConfirmedCall = call
+            }
+            break
+        case .disconnected:
+            if (!call.connected) {
+                NSLog("Call never connected, in DISCONNECTED state, with UUID: \(call.uuid)")
+            } else if (!call.userDidHangUp) {
+                NSLog("Call remotly ended, in DISCONNECTED state, with UUID: \(call.uuid)")
+            }
+            print(omiLib.getCurrentCall()?.uuid.uuidString)
+            print(call.uuid.uuidString)
+            if let currentActiveCall = currentConfirmedCall, currentActiveCall.uuid.uuidString == call.uuid.uuidString {
+//                SwiftOmikitPlugin.instance?.sendEvent(onCallEnd, [:])
+                currentConfirmedCall = nil
+                break
+            }
+            if currentConfirmedCall == nil {
+//                SwiftOmikitPlugin.instance?.sendEvent(onCallEnd, [:])
+                break
+            }
+            print(omiLib.getNewestCall()?.uuid.uuidString)
+            break
+        case .incoming:
+//            SwiftOmikitPlugin.instance?.sendEvent(incomingReceived, [
+//                "callerId": call.callId,
+//                "phoneNumber": call.callerNumber
+//            ])SwiftOmikitPlugin.instance?.sendEvent(incomingReceived, [
+//                "callerId": call.callId,
+//                "phoneNumber": call.callerNumber
+//            ])
+            break
+        case .muted:
+//            SwiftOmikitPlugin.instance?.sendEvent(onMuted, ["isMuted": call.muted])
+            break
+        case .hold:
+//            SwiftOmikitPlugin.instance?.sendEvent(onHold, ["isHold": call.onHold])
+            break
+        @unknown default:
+            NSLog("Default call state")
+        }
+    }
+    
+    /// Start call
+    func startCall(_ phoneNumber: String, isVideo: Bool) {
+        registerNotificationCenter()
+        if (isVideo) {
+            OmiClient.startVideoCall(phoneNumber)
+            return
+        }
+        OmiClient.startCall(phoneNumber)
+    }
+    
+    /// End call
+    func endNewestCall() {
+        guard let call = omiLib.getNewestCall() else {
+            return
+        }
+        omiLib.callManager.end(call) { error in
+            if error != nil {
+                NSLog("error hanging up call(\(call.uuid.uuidString)): \(error!)")
+            }
+        }
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    func endCurrentConfirmCall() {
+        guard let call = omiLib.getCurrentCall() else {
+            endNewestCall()
+            return
+        }
+        omiLib.callManager.end(call) { error in
+            if error != nil {
+                NSLog("error hanging up call(\(call.uuid.uuidString)): \(error!)")
+            }
+        }
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    
+    func endAllCalls() {
+        omiLib.callManager.endAllCalls()
+//        SwiftOmikitPlugin.instance?.sendEvent("onCallEnd", [:])
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    func sendDTMF(character: String) {
+        guard let call = omiLib.getCurrentCall() else {
+            return
+        }
+        try? call.sendDTMF(character)
+    }
+    
+    
+    /// Toogle mtue
+    func toggleMute(completion: @escaping () -> Void?) {
+        guard let omicall = OMISIPLib.sharedInstance().getCurrentCall() else {
+            return
+        }
+        
+        omiLib.callManager.toggleMute(for: omicall) { error in
+            if error != nil {
+                NSLog("toggle mute error:  \(error))")
+            }
+        }
+        
+    }
+    
+    /// Toogle hold
+    func toggleHold(completion: @escaping () -> Void?) {
+        guard let omicall = OMISIPLib.sharedInstance().getCurrentCall() else {
+            return
+        }
+        DispatchQueue.main.async {[weak self] in
+            guard let self = self else { return }
+            self.omiLib.callManager.toggleHold(for: omicall) { error in
+                if error != nil {
+                    NSLog("Error holding current call: \(error!)")
+                    return
+                } else {
+                    completion()
+                }
+            }
+        }
+    }
+    
+    
+    /// Toogle speaker
+    func toogleSpeaker() {
+        do {
+            if (!isSpeaker) {
+                isSpeaker = true
+                try AVAudioSession.sharedInstance().overrideOutputAudioPort(.speaker)
+                
+            } else {
+                isSpeaker = false
+                try AVAudioSession.sharedInstance().overrideOutputAudioPort(.none)
+            }
+        } catch (let error){
+            NSLog("Error toogleSpeaker current call: \(error)")
+
+        }
+    }
+    
+    
+    func inputs() -> [[String: String]] {
+          let inputs = AVAudioSession.sharedInstance().availableInputs ?? []
+          let results = inputs.map { item in
+              return [
+                  "name": item.portName,
+                  "id": item.uid,
+              ]
+          }
+          return results
+    }
+      
+    func setInput(id: String) {
+        let inputs = AVAudioSession.sharedInstance().availableInputs ?? []
+        if let newOutput = inputs.first(where: {$0.uid == id}) {
+            try? AVAudioSession.sharedInstance().setPreferredInput(newOutput)
+        }
+    }
+    
+    func outputs() -> [[String: String]] {
+        let outputs = AVAudioSession.sharedInstance().currentRoute.outputs
+        var results = outputs.map { item in
+           return [
+              "name": item.portName,
+              "id": item.uid,
+           ]
+        }
+        let hasSpeaker = results.contains{ $0["name"] == "Speaker" }
+        if (!hasSpeaker) {
+            results.append([
+                "name": "Speaker",
+                "id": "Speaker",
+            ])
+        } else {
+            results.append([
+                "name": "Off Speaker",
+                "id": "Off Speaker",
+            ])
+        }
+        return results
+    }
+    
+    func setOutput(id: String) {
+        if (id == "Speaker") {
+            try? AVAudioSession.sharedInstance().overrideOutputAudioPort(.speaker)
+            return
+        }
+        if (id == "Off Speaker") {
+            try? AVAudioSession.sharedInstance().overrideOutputAudioPort(.none)
+            return
+        }
+        let outputs = AVAudioSession.sharedInstance().currentRoute.outputs
+        if let newOutput = outputs.first(where: {$0.uid == id}) {
+            try? AVAudioSession.sharedInstance().setPreferredInput(newOutput)
+        }
+    }
+    
+    //video call
+    func toggleCamera() {
+        if let videoManager = videoManager {
+            videoManager.toggleCamera()
+        }
+    }
+    
+    func getCameraStatus() -> Bool {
+        guard let videoManager = videoManager else { return false }
+        return videoManager.isCameraOn
+    }
+    
+    func switchCamera() {
+        if let videoManager = videoManager {
+            videoManager.switchCamera()
+        }
+    }
+    
+//    func getLocalPreviewView(callback: @escaping (UIView) -> Void) {
+//        guard let videoManager = videoManager  else { return }
+//        videoManager.localView {previewView in
+//            DispatchQueue.main.async {
+//                if (previewView != nil) {
+//                    previewView!.contentMode = .scaleAspectFill
+//                    callback(previewView!)
+//                }
+//            }
+//        }
+//    }
+//
+//    func getRemotePreviewView(callback: @escaping (UIView) -> Void) {
+//        guard let videoManager = videoManager  else { return }
+//        videoManager.remoteView { previewView in
+//            DispatchQueue.main.async {
+//                if (previewView != nil) {
+//                    previewView!.contentMode = .scaleAspectFill
+//                    callback(previewView!)
+//                }
+//            }
+//        }
+//    }
+}
+
+

package/ios/CallProcess/NSUserActivity.swift

@@ -0,0 +1,58 @@
+//
+//  NSUserActivity.swift
+//  Runner
+//
+//  Created by Hien Nguyen on 20/02/2022.
+//
+
+import Foundation
+import Intents
+
+extension NSUserActivity: StartCallConvertible {
+
+    public var handle: String? {
+        guard
+          let interaction = interaction,
+          let startCallIntent = interaction.intent as? SupportedStartCallIntent,
+          let contact = startCallIntent.contacts?.first
+        else {
+            return nil
+        }
+        print(interaction.intent)
+        return contact.personHandle?.value
+    }
+
+    public var isVideo: Bool? {
+        guard
+          let interaction = interaction,
+          let startCallIntent = interaction.intent as? SupportedStartCallIntent
+        else {
+            return nil
+        }
+
+        return startCallIntent is INStartVideoCallIntent
+    }
+    
+}
+
+
+protocol StartCallConvertible {
+    var handle: String? { get }
+    var isVideo: Bool? { get }
+}
+
+extension StartCallConvertible {
+
+    var isVideo: Bool? {
+        return nil
+    }
+
+}
+
+
+protocol SupportedStartCallIntent {
+    var contacts: [INPerson]? { get }
+}
+
+extension INStartAudioCallIntent: SupportedStartCallIntent {}
+extension INStartVideoCallIntent: SupportedStartCallIntent {}

package/ios/CallProcess/StringUtils.swift

@@ -0,0 +1,18 @@
+
+import Foundation
+
+extension String {
+    
+    func fromBase64() -> String {
+        guard let data = Foundation.Data(base64Encoded: self) else {
+            return ""
+        }
+        
+        return String(data: data, encoding: .utf8)!
+    }
+    
+    func toBase64() -> String {
+        return Foundation.Data(self.utf8).base64EncodedString()
+    }
+
+}

package/ios/Constant/Constant.swift

@@ -0,0 +1,47 @@
+//
+//  Constant.swift
+//  omicallsdk
+//
+//  Created by LV on 12/12/2022.
+//
+
+import Foundation
+
+
+let INIT_CALL = "INIT_CALL"
+let UPDATE_TOKEN = "UPDATE_TOKEN"
+let START_OMI_SERVICE = "START_OMI_SERVICE"
+let START_CALL = "START_CALL"
+let END_CALL = "END_CALL"
+let TOGGLE_MUTE = "TOGGLE_MUTE"
+let TOGGLE_SPEAK = "TOGGLE_SPEAK"
+let CHECK_ON_GOING_CALL = "CHECK_ON_GOING_CALL"
+let DECLINE = "DECLINE"
+let FORWARD_CALL_TO = "FORWARD_CALL_TO"
+let HANGUP = "HANGUP"
+let ON_CALL_STARTED = "ON_CALL_STARTED"
+let ON_HOLD = "ON_HOLD"
+let ON_IN_COMING_RECEIVE = "ON_IN_COMING_RECEIVE"
+let ON_MUTE = "ON_MUTE"
+let ON_OUT_GOING = "ON_OUT_GOING"
+let ON_OUT_GOING_STARTED = "ON_OUT_GOING"
+let REGISTER = "REGISTER"
+let SEND_DTMF = "SEND_DTMF"
+let SWITCH_CAMERA = "SWITCH_CAMERA"
+let CAMERA_STATUS = "CAMERA_STATUS"
+let TOGGLE_VIDEO = "TOGGLE_VIDEO"
+let INPUTS = "INPUTS"
+let OUTPUTS = "OUTOUTS"
+let SETINPUT = "SET_INPUT"
+let SETOUTPUT = "SET_OUTPUT"
+
+//LISTENER
+let onCallEstablished = "CALL_ESTABLISHED"
+let onCallEnd = "CALL_END"
+let incomingReceived = "INCOMING_RECEIVED"
+let onRinging = "RINGING"
+let onConnectionTimeout = "CONNECTION_TIMEOUT"
+let onHold = "HOLD"
+let onMuted = "MUTED"
+
+

package/ios/OmikitPlugin-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/OmikitPlugin.m

@@ -0,0 +1,17 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(OmikitPlugin, NSObject)
+
+RCT_EXTERN_METHOD(updateToken:(id)data
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(initCall:(id)data
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/OmikitPlugin.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+@objc(OmikitPlugin)
+class OmikitPlugin: NSObject {
+    @objc(initCall:withResolver:withRejecter:)
+    func initCall(data: Any, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Void {
+        if let dataOmi = data as? [String: Any] {
+            CallManager.shareInstance().initEndpoint(params: dataOmi)
+            resolve(true)
+        }
+    }
+    @objc(updateToken:withResolver:withRejecter:)
+    func updateToken(data: Any, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Void {
+        if let dataOmi = data as? [String: Any] {
+            CallManager.shareInstance().updateToken(params: dataOmi)
+            resolve(true)
+        }
+    }
+}