omikit-plugin 0.3.1 → 1.0.1

package/android/src/main/java/com/omikitplugin/OmikitPluginModule.kt

@@ -1,46 +1,160 @@
 package com.omikitplugin
 
 import android.Manifest
+import android.content.Context
+import android.hardware.camera2.CameraManager
+import android.os.Build
+import android.util.Log
 import androidx.core.app.ActivityCompat
 import com.facebook.react.ReactActivity
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.RCTNativeAppEventEmitter
+import com.omikitplugin.constants.*
 import vn.vihat.omicall.omisdk.OmiClient
 import vn.vihat.omicall.omisdk.OmiListener
-import vn.vihat.omicall.omisdk.OmiSDKUtils
+import vn.vihat.omicall.omisdk.utils.OmiSDKUtils
 
 
 class OmikitPluginModule(reactContext: ReactApplicationContext?) :
-  ReactContextBaseJavaModule(reactContext), OmiListener {
+  ReactContextBaseJavaModule(reactContext) {
+
+
+  private var icSpeaker = false
+  private var isMute = false
+
+  private val callListener = object : OmiListener {
+
+    override fun incomingReceived(callerId: Int, phoneNumber: String?, isVideo: Boolean?) {
+      val map: WritableMap = WritableNativeMap()
+      map.putBoolean("isVideo", isVideo ?: true)
+      map.putString("callerNumber", phoneNumber)
+      sendEvent(INCOMING_RECEIVED, map)
+      Log.d("omikit", "incomingReceived: ")
+    }
+
+    override fun onCallEnd() {
+      sendEvent(CALL_END, null)
+    }
+
+    override fun onCallEstablished(
+      callerId: Int,
+      phoneNumber: String?,
+      isVideo: Boolean?,
+      startTime: Long,
+    ) {
+      val map: WritableMap = WritableNativeMap()
+      val sipNumber = OmiClient.instance.callUUID
+      map.putString("callerNumber", sipNumber)
+      map.putBoolean("isVideo", isVideo ?: true)
+      sendEvent(CALL_ESTABLISHED, map)
+    }
+
+    override fun onConnectionTimeout() {
+//      sendEvent("onConnectionTimeout", null)
+    }
+
+    override fun onHold(isHold: Boolean) {
+      val map: WritableMap = WritableNativeMap()
+      map.putBoolean("isHold", isHold)
+      sendEvent(HOLD, map)
+    }
+
+    override fun onMuted(isMuted: Boolean) {
+//      val map: WritableMap = WritableNativeMap()
+//      map.putBoolean("isMuted", isMuted)
+//      sendEvent(MUTED, map)
+    }
+
+    override fun onOutgoingStarted(callerId: Int, phoneNumber: String?, isVideo: Boolean?) {
+
+    }
+
+    override fun onRinging() {
+//      sendEvent("onRinging", null)
+    }
+
+    override fun onVideoSize(width: Int, height: Int) {
+
+    }
+  }
 
   override fun getName(): String {
     return NAME
   }
 
+  override fun initialize() {
+    super.initialize()
+    OmiClient(reactApplicationContext!!)
+    OmiClient.instance.setListener(callListener)
+  }
+
   @ReactMethod
   fun initCall(data: ReadableMap, promise: Promise) {
     currentActivity?.runOnUiThread {
-      val userName = data.getString("userName") as String
-      val password = data.getString("password") as String
-      val realm = data.getString("realm") as String
-      OmiClient.register(reactApplicationContext, userName, password, realm)
-      ActivityCompat.requestPermissions(
-        currentActivity!!,
-        arrayOf(
-          Manifest.permission.USE_SIP,
-          Manifest.permission.CALL_PHONE,
-          Manifest.permission.POST_NOTIFICATIONS,
-          Manifest.permission.CAMERA,
-          Manifest.permission.MODIFY_AUDIO_SETTINGS,
-          Manifest.permission.RECORD_AUDIO,
-        ),
-        0,
-      )
-      OmiClient.instance.setListener(this)
+      val userName = data.getString("userName")
+      val password = data.getString("password")
+      val realm = data.getString("realm")
+      val host = data.getString("host")
+      val isVideo = data.getBoolean("isVideo")
+      if (userName != null && password != null && realm != null && host != null) {
+        OmiClient.register(
+          reactApplicationContext!!,
+          userName,
+          password,
+          isVideo,
+          realm,
+          host = host,
+          customUI = true,
+          isTcp = true
+        )
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        ActivityCompat.requestPermissions(
+          currentActivity!!,
+          arrayOf(
+            Manifest.permission.USE_SIP,
+            Manifest.permission.CALL_PHONE,
+            Manifest.permission.CAMERA,
+            Manifest.permission.MODIFY_AUDIO_SETTINGS,
+            Manifest.permission.RECORD_AUDIO,
+            Manifest.permission.POST_NOTIFICATIONS,
+          ),
+          0,
+        )
+      } else {
+        ActivityCompat.requestPermissions(
+          currentActivity!!,
+          arrayOf(
+            Manifest.permission.USE_SIP,
+            Manifest.permission.CALL_PHONE,
+            Manifest.permission.CAMERA,
+            Manifest.permission.MODIFY_AUDIO_SETTINGS,
+            Manifest.permission.RECORD_AUDIO,
+          ),
+          0,
+        )
+      }
+      if (isVideo) {
+        val cm = currentActivity!!.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+        OmiClient.instance.setCameraManager(cm)
+      }
       promise.resolve(true)
     }
   }
 
+  @ReactMethod
+  fun getInitialCall(promise: Promise) {
+    currentActivity?.runOnUiThread {
+      promise.resolve(false)
+    }
+  }
+
+  @ReactMethod
+  fun joinCall(promise: Promise) {
+    OmiClient.instance.pickUp(true)
+    promise.resolve(true)
+  }
+
   @ReactMethod
   fun updateToken(data: ReadableMap, promise: Promise) {
     currentActivity?.runOnUiThread {
@@ -51,21 +165,18 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
         "",
         deviceTokenAndroid,
         deviceId,
-        appId
+        appId,
       )
       promise.resolve(true)
     }
   }
 
-
   @ReactMethod
   fun startCall(data: ReadableMap, promise: Promise) {
     val phoneNumber = data.getString("phoneNumber") as String
     val isVideo = data.getBoolean("isVideo")
-    if (!isVideo) {
-      OmiClient.instance.startCall(phoneNumber)
-      promise.resolve(true)
-    }
+    OmiClient.instance.startCall(phoneNumber, isVideo)
+    promise.resolve(true)
   }
 
   @ReactMethod
@@ -78,48 +189,16 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   fun toggleMute(promise: Promise) {
     OmiClient.instance.toggleMute()
     promise.resolve(true)
+    isMute = !isMute
+    sendEvent(MUTED, isMute)
   }
 
   @ReactMethod
-  fun toggleSpeak(data: ReadableMap, promise: Promise) {
-    val useSpeaker = data.getBoolean("useSpeaker")
-    OmiClient.instance.toggleSpeaker(useSpeaker)
-    promise.resolve(true)
-  }
-
-  @ReactMethod
-  fun decline(promise: Promise) {
-    OmiClient.instance.decline()
-    promise.resolve(true)
-  }
-
-  @ReactMethod
-  fun hangup(data: ReadableMap, promise: Promise) {
-    val callId = data.getInt("callId")
-    OmiClient.instance.hangUp(callId)
-    promise.resolve(true)
-  }
-
-
-  @ReactMethod
-  fun onCallStart(data: ReadableMap, promise: Promise) {
-    val callId = data.getInt("callId")
-    OmiClient.instance.onCallStarted(callId)
-    promise.resolve(true)
-  }
-
-  @ReactMethod
-  fun onHold(data: ReadableMap, promise: Promise) {
-    val isHold = data.getBoolean("isHold")
-    OmiClient.instance.onHold(isHold)
-    promise.resolve(true)
-  }
-
-  @ReactMethod
-  fun onMute(data: ReadableMap, promise: Promise) {
-    val isMute = data.getBoolean("isMute")
-    OmiClient.instance.onMuted(isMute)
+  fun toggleSpeak(promise: Promise) {
+    icSpeaker = !icSpeaker
+    OmiClient.instance.toggleSpeaker(icSpeaker)
     promise.resolve(true)
+    sendEvent(SPEAKER, icSpeaker)
   }
 
   @ReactMethod
@@ -141,7 +220,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   companion object {
     const val NAME = "OmikitPlugin"
     fun onDestroy() {
-      OmiClient.instance.disconnect()
+
     }
 
     fun onRequestPermissionsResult(
@@ -156,38 +235,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     }
   }
 
-  override fun incomingReceived(callerId: Int, phoneNumber: String?) {
-    val map: WritableMap = WritableNativeMap()
-    map.putInt("callerId", callerId)
-    sendEvent("phoneNumber", phoneNumber)
-  }
-
-  override fun onCallEnd() {
-    sendEvent("onCallEnd", false)
-  }
-
-  override fun onCallEstablished() {
-    sendEvent("onCallEstablished", null)
-  }
-
-  override fun onConnectionTimeout() {
-    sendEvent("onConnectionTimeout", null)
-  }
-
-  override fun onHold(isHold: Boolean) {
-    sendEvent("onHold", null)
-  }
-
-  override fun onMuted(isMuted: Boolean) {
-    val map: WritableMap = WritableNativeMap()
-    map.putBoolean("isMuted", isMuted)
-    sendEvent("onMuted", map)
-  }
-
-  override fun onRinging() {
-    sendEvent("onRinging", null)
-  }
-
   private fun sendEvent(eventName: String?, params: Any?) {
     currentActivity?.runOnUiThread {
       reactApplicationContext.getJSModule(RCTNativeAppEventEmitter::class.java)

package/android/src/main/java/com/omikitplugin/constants/constant.kt

@@ -3,29 +3,18 @@ package com.omikitplugin.constants
 //EVENT
 const val INIT_CALL = "INIT_CALL";
 const val UPDATE_TOKEN = "UPDATE_TOKEN";
-const val START_OMI_SERVICE = "START_OMI_SERVICE";
 const val START_CALL = "START_CALL";
 const val END_CALL = "END_CALL";
 const val TOGGLE_MUTE = "TOGGLE_MUTE";
 const val TOGGLE_SPEAK = "TOGGLE_SPEAK";
-const val CHECK_ON_GOING_CALL = "CHECK_ON_GOING_CALL";
-const val DECLINE = "DECLINE";
-const val FORWARD_CALL_TO = "FORWARD_CALL_TO";
-const val HANGUP = "HANGUP";
-const val ON_CALL_STARTED = "ON_CALL_STARTED";
-const val ON_HOLD = "ON_HOLD";
-const val ON_IN_COMING_RECEIVE = "ON_IN_COMING_RECEIVE";
-const val ON_MUTE = "ON_MUTE";
-const val ON_OUT_GOING = "ON_OUT_GOING";
 const val REGISTER = "REGISTER";
 const val SEND_DTMF = "SEND_DTMF";
 
 //LISTENER
-const val onCallEstablished = "CALL_ESTABLISHED"
-const val onCallEnd = "CALL_END"
-const val incomingReceived = "INCOMING_RECEIVED"
-const val onRinging = "RINGING"
-const val onConnectionTimeout = "CONNECTION_TIMEOUT"
-const val onHold = "HOLD"
-const val onMuted = "MUTED"
-
+const val CALL_ESTABLISHED = "CALL_ESTABLISHED"
+const val CALL_END = "CALL_END"
+const val INCOMING_RECEIVED = "INCOMING_RECEIVED"
+//const val CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT"
+const val HOLD = "HOLD"
+const val MUTED = "MUTED"
+const val SPEAKER = "SPEAKER"

package/ios/CallProcess/CallManager.swift

@@ -15,15 +15,10 @@ 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 isSpeaker = false
     var videoManager: OMIVideoViewManager?
     
-    
     /// Get instance
     static func shareInstance() -> CallManager {
         if (instance == nil) {
@@ -32,6 +27,14 @@ class CallManager {
         return instance!
     }
     
+    func getAvailableCall() -> OMICall? {
+        var currentCall = omiLib.getCurrentConfirmCall()
+        if (currentCall == nil) {
+            currentCall = omiLib.getNewestCall()
+        }
+        return currentCall
+    }
+    
     func updateToken(params: [String: Any]) {
         if let apnsToken = params["apnsToken"] as? String {
             OmiClient.setUserPushNotificationToken(apnsToken)
@@ -39,19 +42,14 @@ class CallManager {
     }
     
     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()
         }
+        if let isVideoCall = params["isVideo"] as? Bool, isVideoCall == true {
+            OmiClient.startOmiService(true)
+            videoManager = OMIVideoViewManager.init()
+        }
+        registerNotificationCenter()
     }
     
     func registerNotificationCenter() {
@@ -70,7 +68,7 @@ class CallManager {
             )
         }
     }
-    
+
     @objc func callDealloc(_ notification: NSNotification) {
         guard let userInfo = notification.userInfo,
               let call     = userInfo[OMINotificationUserInfoCallKey] as? OMICall else {
@@ -79,7 +77,6 @@ class CallManager {
         if (call.callState == .disconnected) {
             DispatchQueue.main.async {
                 OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
-                self.currentConfirmedCall = nil
             }
         }
     }
@@ -95,7 +92,6 @@ class CallManager {
         case .calling:
             if (!call.isIncoming) {
                 NSLog("Outgoing call, in CALLING state, with UUID \(call.uuid)")
-                OmikitPlugin.instance.sendEvent(withName: onRinging, body: [:])
             }
             break
         case .early:
@@ -109,19 +105,10 @@ class CallManager {
             }
             break
         case .confirmed:
-            DispatchQueue.main.async {
-                if (!call.isIncoming) {
-                    NSLog("Outgoing call, in CONFIRMED state, with UUID: \(call.uuid)")
-                    OmikitPlugin.instance.sendEvent(withName: onCallEstablished, body: [:])
-                    OmikitPlugin.instance.sendEvent(withName: onMuted, body: ["isMuted": call.muted])
-                    self.currentConfirmedCall = call
-                    return
-                }
-                NSLog("Outgoing call, in CONFIRMED state, with UUID: \(call.uuid)")
-                OmikitPlugin.instance.sendEvent(withName: onCallEstablished, body: [:])
-                OmikitPlugin.instance.sendEvent(withName: onMuted, body: ["isMuted": call.muted])
-                self.currentConfirmedCall = call
-            }
+            NSLog("Outgoing call, in CONFIRMED state, with UUID: \(call.uuid)")
+            OmikitPlugin.instance.sendEvent(withName: onCallEstablished, body: ["isVideo": call.isVideo, "callerNumber": call.callerNumber])
+            print(call.muted)
+            OmikitPlugin.instance.sendOnMuteStatus()
             break
         case .disconnected:
             if (!call.connected) {
@@ -129,36 +116,26 @@ class CallManager {
             } 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 {
-                OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
-                currentConfirmedCall = nil
-                break
-            }
-            if currentConfirmedCall == nil {
-                OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
-                break
-            }
-            print(omiLib.getNewestCall()?.uuid.uuidString)
+            OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
             break
         case .incoming:
-            OmikitPlugin.instance.sendEvent(withName: incomingReceived, body: ["callerId": call.callId,"phoneNumber": call.callerNumber])
+            OmikitPlugin.instance.sendEvent(withName: incomingReceived, body: ["isVideo": call.isVideo, "callerNumber": call.callerNumber ?? ""])
             break
         case .muted:
-            OmikitPlugin.instance.sendEvent(withName: onMuted, body: ["isMuted": call.muted])
+            print("muteddddddd")
             break
         case .hold:
-            OmikitPlugin.instance.sendEvent(withName: onHold, body: ["isHold": call.onHold])
+            print("holdddddddd")
             break
-        @unknown default:
+        default:
             NSLog("Default call state")
+            break
         }
     }
     
     /// Start call
     func startCall(_ phoneNumber: String, isVideo: Bool) {
-        registerNotificationCenter()
         if (isVideo) {
             OmiClient.startVideoCall(phoneNumber)
             return
@@ -166,82 +143,49 @@ class CallManager {
         OmiClient.startCall(phoneNumber)
     }
     
-    /// End call
-    func endNewestCall() {
-        guard let call = omiLib.getNewestCall() else {
+    func endAvailableCall() {
+        guard let call = getAvailableCall() else {
+            OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
             return
         }
-        omiLib.callManager.end(call) { error in
-            if error != nil {
-                NSLog("error hanging up call(\(call.uuid.uuidString)): \(error!)")
-            }
-        }
-        OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
-        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!)")
-            }
-        }
-        OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
-        NotificationCenter.default.removeObserver(self)
+        omiLib.callManager.end(call)
     }
     
     
     func endAllCalls() {
         omiLib.callManager.endAllCalls()
-        OmikitPlugin.instance.sendEvent(withName: onCallEnd, body: [:])
-        NotificationCenter.default.removeObserver(self)
+    }
+    
+    func joinCall() {
+        guard let call = getAvailableCall() else {
+            return
+        }
+        OmiClient.answerIncommingCall(call.uuid)
     }
     
     func sendDTMF(character: String) {
-        guard let call = omiLib.getCurrentCall() else {
+        guard let call = getAvailableCall() 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))")
-            }
+    func toggleMute() {
+        guard let call = getAvailableCall() else {
+            return 
         }
-        
+        try? call.toggleMute()
     }
     
     /// Toogle hold
-    func toggleHold(completion: @escaping () -> Void?) {
-        guard let omicall = OMISIPLib.sharedInstance().getCurrentCall() else {
+    func toggleHold() {
+        guard let call = getAvailableCall() 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()
-                }
-            }
-        }
+        try? call.toggleHold()
     }
     
-    
     /// Toogle speaker
     func toogleSpeaker() {
         do {
@@ -255,22 +199,21 @@ class CallManager {
             }
         } 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
+        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}) {
@@ -281,10 +224,10 @@ class CallManager {
     func outputs() -> [[String: String]] {
         let outputs = AVAudioSession.sharedInstance().currentRoute.outputs
         var results = outputs.map { item in
-           return [
-              "name": item.portName,
-              "id": item.uid,
-           ]
+            return [
+                "name": item.portName,
+                "id": item.uid,
+            ]
         }
         let hasSpeaker = results.contains{ $0["name"] == "Speaker" }
         if (!hasSpeaker) {
@@ -334,29 +277,29 @@ class CallManager {
         }
     }
     
-//    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!)
-//                }
-//            }
-//        }
-//    }
+    //    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!)
+    //                }
+    //            }
+    //        }
+    //    }
 }