@qusaieilouti99/call-manager 0.1.50 → 0.1.52

package/android/src/main/java/com/margelo/nitro/qusaieilouti99/callmanager/CallEngine.kt

@@ -13,6 +13,7 @@ import android.graphics.Color
 import android.media.AudioAttributes
 import android.media.AudioDeviceCallback
 import android.media.AudioDeviceInfo
+import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.media.MediaPlayer
 import android.media.RingtoneManager
@@ -53,6 +54,7 @@ object CallEngine {
     private var audioManager: AudioManager? = null
     private var wakeLock: PowerManager.WakeLock? = null
     private var appContext: Context? = null
+    private var audioFocusRequest: AudioFocusRequest? = null
 
     // Call State Management
     private val activeCalls = ConcurrentHashMap<String, CallInfo>()
@@ -63,6 +65,11 @@ object CallEngine {
     // Audio State Tracking
     private var lastAudioRoutesInfo: AudioRoutesInfo? = null
     private var lastMuteState: Boolean = false
+    private var hasAudioFocus: Boolean = false
+
+    // System Call State Tracking
+    private var isSystemCallActive: Boolean = false
+    private var wasHeldBySystem: Boolean = false
 
     // Lock Screen Bypass
     private var lockScreenBypassActive = false
@@ -80,19 +87,147 @@ object CallEngine {
         val callData: String,
         var state: CallState,
         val callType: String = "Audio",
-        val timestamp: Long = System.currentTimeMillis()
+        val timestamp: Long = System.currentTimeMillis(),
+        var wasHeldBySystem: Boolean = false
     )
 
     enum class CallState {
-        INCOMING, DIALING, ACTIVE, HELD, ENDED
+        INCOMING, DIALING, ACTIVE, HELD, HELD_BY_SYSTEM, ENDED
     }
 
     interface LockScreenBypassCallback {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    interface ServerCallRejectCallback {
-        fun onRejectCall(callId: String, reason: String)
+    // --- Audio Focus Management ---
+    private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+        Log.d(TAG, "Audio focus changed: $focusChange")
+        when (focusChange) {
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                // Lost focus permanently - likely due to phone call
+                handleAudioFocusLoss()
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                // Lost focus temporarily
+                handleAudioFocusLossTransient()
+            }
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                // Regained focus
+                handleAudioFocusGain()
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                // Can duck audio
+                handleAudioFocusLossCanDuck()
+            }
+        }
+    }
+
+    private fun handleAudioFocusLoss() {
+        Log.d(TAG, "Audio focus lost permanently - likely system call active")
+        hasAudioFocus = false
+        isSystemCallActive = true
+
+        // Hold all active calls instead of ending them
+        activeCalls.values.filter { it.state == CallState.ACTIVE }.forEach { call ->
+            if (!call.wasHeldBySystem) {
+                call.wasHeldBySystem = true
+                call.state = CallState.HELD_BY_SYSTEM
+
+                val connection = telecomConnections[call.callId]
+                connection?.setOnHold()
+
+                emitEvent(CallEventType.CALL_HELD, JSONObject().apply {
+                    put("callId", call.callId)
+                    put("reason", "system_call_active")
+                })
+
+                notifySpecificCallStateChanged(appContext!!, call.callId, CallState.HELD_BY_SYSTEM)
+                Log.d(TAG, "Call ${call.callId} held by system due to audio focus loss")
+            }
+        }
+
+        stopRingback()
+        updateForegroundNotification(appContext!!)
+    }
+
+    private fun handleAudioFocusLossTransient() {
+        // Similar to permanent loss but may be temporary
+        handleAudioFocusLoss()
+    }
+
+    private fun handleAudioFocusGain() {
+        Log.d(TAG, "Audio focus regained - system call likely ended")
+        hasAudioFocus = true
+        isSystemCallActive = false
+
+        // Resume calls that were held by system
+        activeCalls.values.filter { it.state == CallState.HELD_BY_SYSTEM && it.wasHeldBySystem }.forEach { call ->
+            call.wasHeldBySystem = false
+            call.state = CallState.ACTIVE
+
+            val connection = telecomConnections[call.callId]
+            connection?.setActive()
+
+            emitEvent(CallEventType.CALL_UNHELD, JSONObject().apply {
+                put("callId", call.callId)
+                put("reason", "system_call_ended")
+            })
+
+            notifySpecificCallStateChanged(appContext!!, call.callId, CallState.ACTIVE)
+            Log.d(TAG, "Call ${call.callId} resumed after system call ended")
+        }
+
+        updateForegroundNotification(appContext!!)
+    }
+
+    private fun handleAudioFocusLossCanDuck() {
+        // Lower volume but continue
+        Log.d(TAG, "Audio focus loss - can duck")
+    }
+
+    private fun requestAudioFocus(): Boolean {
+        audioManager = audioManager ?: appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            if (audioFocusRequest == null) {
+                audioFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                    .setAudioAttributes(
+                        AudioAttributes.Builder()
+                            .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                            .build()
+                    )
+                    .setOnAudioFocusChangeListener(audioFocusChangeListener)
+                    .build()
+            }
+            val result = audioManager?.requestAudioFocus(audioFocusRequest!!)
+            hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+            Log.d(TAG, "Audio focus request result: $result")
+            hasAudioFocus
+        } else {
+            @Suppress("DEPRECATION")
+            val result = audioManager?.requestAudioFocus(
+                audioFocusChangeListener,
+                AudioManager.STREAM_VOICE_CALL,
+                AudioManager.AUDIOFOCUS_GAIN
+            )
+            hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+            Log.d(TAG, "Audio focus request result (legacy): $result")
+            hasAudioFocus
+        }
+    }
+
+    private fun abandonAudioFocus() {
+        audioManager = audioManager ?: appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            audioFocusRequest?.let { request ->
+                audioManager?.abandonAudioFocusRequest(request)
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            audioManager?.abandonAudioFocus(audioFocusChangeListener)
+        }
+        hasAudioFocus = false
+        Log.d(TAG, "Audio focus abandoned")
     }
 
     // --- Event System ---
@@ -176,6 +311,7 @@ object CallEngine {
             obj.put("callData", it.callData)
             obj.put("state", it.state.name)
             obj.put("callType", it.callType)
+            obj.put("wasHeldBySystem", it.wasHeldBySystem)
             jsonArray.put(obj)
         }
         val result = jsonArray.toString()
@@ -192,15 +328,13 @@ object CallEngine {
         val incomingCall = activeCalls.values.find { it.state == CallState.INCOMING }
         if (incomingCall != null && incomingCall.callId != callId) {
             Log.d(TAG, "Incoming call collision detected. Auto-rejecting new call: $callId")
-
-            // Auto-reject the new call
             rejectIncomingCallCollision(callId, "Another call is already incoming")
             return
         }
 
         // Check if there's an active call when receiving incoming
-        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
-        if (activeCall != null) {
+        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE || it.state == CallState.HELD_BY_SYSTEM }
+        if (activeCall != null && !canMakeMultipleCalls) {
             Log.d(TAG, "Active call exists when receiving incoming call. Auto-rejecting: $callId")
             rejectIncomingCallCollision(callId, "Another call is already active")
             return
@@ -212,7 +346,11 @@ object CallEngine {
 
         if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
             Log.d(TAG, "Can't make multiple calls, holding existing calls.")
-            activeCalls.values.forEach { it.state = CallState.HELD }
+            activeCalls.values.forEach {
+                if (it.state == CallState.ACTIVE) {
+                    it.state = CallState.HELD
+                }
+            }
         }
 
         activeCalls[callId] = CallInfo(callId, callData, CallState.INCOMING, parsedCallType)
@@ -266,7 +404,11 @@ object CallEngine {
 
         if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
             Log.d(TAG, "Can't make multiple calls, holding existing calls before outgoing.")
-            activeCalls.values.forEach { it.state = CallState.HELD }
+            activeCalls.values.forEach {
+                if (it.state == CallState.ACTIVE) {
+                    it.state = CallState.HELD
+                }
+            }
         }
 
         activeCalls[callId] = CallInfo(callId, callData, CallState.DIALING, parsedCallType)
@@ -290,10 +432,14 @@ object CallEngine {
             startForegroundService(context)
             Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
 
-            startRingback()
+            // Request audio focus for outgoing call
+            if (requestAudioFocus()) {
+                startRingback()
+                setInitialAudioRoute(context, parsedCallType)
+            }
+
             bringAppToForeground(context)
             keepScreenAwake(context, true)
-            setInitialAudioRoute(context, parsedCallType)
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to start outgoing call via placeCall. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
             endCall(context, callId)
@@ -331,12 +477,21 @@ object CallEngine {
         stopRingback()
         cancelIncomingCallUI(context)
 
+        // Request audio focus when answering
+        if (!hasAudioFocus) {
+            requestAudioFocus()
+        }
+
         // Update call state
         activeCalls[callId]?.state = CallState.ACTIVE
         currentCallId = callId
 
         if (!canMakeMultipleCalls) {
-            activeCalls.filter { it.key != callId }.values.forEach { it.state = CallState.HELD }
+            activeCalls.filter { it.key != callId }.values.forEach {
+                if (it.state == CallState.ACTIVE) {
+                    it.state = CallState.HELD
+                }
+            }
         }
 
         // Bring app to foreground when call is answered
@@ -347,6 +502,9 @@ object CallEngine {
 
         updateLockScreenBypass()
 
+        // Update foreground notification with call info
+        updateForegroundNotification(context)
+
         // Emit event with full call data instead of just callId
         emitEvent(CallEventType.CALL_ANSWERED, JSONObject().apply {
             put("callId", callId)
@@ -363,7 +521,7 @@ object CallEngine {
         Log.d(TAG, "holdCall: $callId")
         val callInfo = activeCalls[callId]
         if (callInfo?.state != CallState.ACTIVE) {
-            Log.w(TAG, "Cannot hold call $callId - not in active state")
+            Log.w(TAG, "Cannot hold call $callId - not in active state (current: ${callInfo?.state})")
             return
         }
 
@@ -380,12 +538,35 @@ object CallEngine {
     fun unholdCall(context: Context, callId: String) {
         Log.d(TAG, "unholdCall: $callId")
         val callInfo = activeCalls[callId]
-        if (callInfo?.state != CallState.HELD) {
-            Log.w(TAG, "Cannot unhold call $callId - not in held state")
+        if (callInfo?.state != CallState.HELD && callInfo?.state != CallState.HELD_BY_SYSTEM) {
+            Log.w(TAG, "Cannot unhold call $callId - not in held state (current: ${callInfo?.state})")
             return
         }
 
+        // If call was held by system, don't allow manual unhold until system allows it
+        if (callInfo.state == CallState.HELD_BY_SYSTEM && isSystemCallActive) {
+            Log.w(TAG, "Cannot unhold call $callId - held by system and system call still active")
+            emitEvent(CallEventType.CALL_UNHOLD_FAILED, JSONObject().apply {
+                put("callId", callId)
+                put("reason", "system_call_active")
+            })
+            return
+        }
+
+        // Request audio focus before unholding
+        if (!hasAudioFocus) {
+            if (!requestAudioFocus()) {
+                Log.w(TAG, "Cannot unhold call $callId - failed to gain audio focus")
+                emitEvent(CallEventType.CALL_UNHOLD_FAILED, JSONObject().apply {
+                    put("callId", callId)
+                    put("reason", "audio_focus_failed")
+                })
+                return
+            }
+        }
+
         activeCalls[callId]?.state = CallState.ACTIVE
+        activeCalls[callId]?.wasHeldBySystem = false
         val connection = telecomConnections[callId]
         connection?.setActive()
 
@@ -619,6 +800,7 @@ object CallEngine {
             audioManager?.stopBluetoothSco()
             audioManager?.isBluetoothScoOn = false
             audioManager?.isSpeakerphoneOn = false
+            abandonAudioFocus()
         } else {
             Log.d(TAG, "Audio mode not reset; ${activeCalls.size} calls still active.")
         }
@@ -697,7 +879,9 @@ object CallEngine {
     fun isCallActive(): Boolean = activeCalls.any {
         it.value.state == CallState.ACTIVE ||
         it.value.state == CallState.INCOMING ||
-        it.value.state == CallState.DIALING
+        it.value.state == CallState.DIALING ||
+        it.value.state == CallState.HELD ||
+        it.value.state == CallState.HELD_BY_SYSTEM
     }
 
     private fun validateOutgoingCallRequest(): Boolean {
@@ -727,8 +911,6 @@ object CallEngine {
         CoroutineScope(Dispatchers.IO).launch {
             try {
                 // TODO: Add your server HTTP request here
-                // Example:
-                // ApiService.rejectCall(callId, reason)
                 Log.d(TAG, "Server rejection request would be made here for callId: $callId, reason: $reason")
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to send rejection to server", e)
@@ -851,7 +1033,23 @@ object CallEngine {
     // --- Service Management ---
     fun startForegroundService(context: Context) {
         Log.d(TAG, "Starting CallForegroundService.")
+
+        // Find the current active call to pass its info
+        val currentCall = activeCalls.values.find {
+            it.state == CallState.ACTIVE || it.state == CallState.INCOMING ||
+            it.state == CallState.DIALING || it.state == CallState.HELD ||
+            it.state == CallState.HELD_BY_SYSTEM
+        }
+
         val intent = Intent(context, CallForegroundService::class.java)
+
+        if (currentCall != null) {
+            intent.putExtra("callId", currentCall.callId)
+            intent.putExtra("callData", currentCall.callData)
+            intent.putExtra("state", currentCall.state.name)
+            Log.d(TAG, "Starting foreground service with call info: ${currentCall.callId}")
+        }
+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             context.startForegroundService(intent)
         } else {
@@ -1005,6 +1203,7 @@ object CallEngine {
             put("callData", callInfo.callData)
             put("state", newState.name)
             put("callType", callInfo.callType)
+            put("wasHeldBySystem", callInfo.wasHeldBySystem)
         }
 
         Log.d(TAG, "Specific call state changed. Emitting CALL_STATE_CHANGED for $callId: $newState")
@@ -1014,8 +1213,9 @@ object CallEngine {
     private fun updateForegroundNotification(context: Context) {
         val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
         val heldCall = activeCalls.values.find { it.state == CallState.HELD }
+        val heldBySystemCall = activeCalls.values.find { it.state == CallState.HELD_BY_SYSTEM }
 
-        val callToShow = activeCall ?: heldCall
+        val callToShow = activeCall ?: heldCall ?: heldBySystemCall
         callToShow?.let {
             val intent = Intent(context, CallForegroundService::class.java)
             intent.putExtra("UPDATE_NOTIFICATION", true)
@@ -1036,5 +1236,8 @@ object CallEngine {
         stopForegroundService(context)
         keepScreenAwake(context, false)
         resetAudioMode(context)
+        abandonAudioFocus()
+        isSystemCallActive = false
+        wasHeldBySystem = false
     }
 }

package/android/src/main/java/com/margelo/nitro/qusaieilouti99/callmanager/CallForegroundService.kt

@@ -30,20 +30,20 @@ class CallForegroundService : Service() {
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         Log.d(TAG, "Service onStartCommand")
 
-        if (intent?.getBooleanExtra("UPDATE_NOTIFICATION", false) == true) {
-            // Update existing notification with new call data
-            val callId = intent.getStringExtra("callId") ?: ""
-            val callData = intent.getStringExtra("callData") ?: ""
-            val state = intent.getStringExtra("state") ?: "ACTIVE"
-
-            val notification = buildEnhancedNotification(callId, callData, state)
-            startForeground(NOTIFICATION_ID, notification)
+        // Check if we have call info in the intent
+        val callId = intent?.getStringExtra("callId")
+        val callData = intent?.getStringExtra("callData")
+        val state = intent?.getStringExtra("state")
+
+        val notification = if (callId != null && callData != null && state != null) {
+            Log.d(TAG, "Building enhanced notification with call info: $callId")
+            buildEnhancedNotification(callId, callData, state)
         } else {
-            // Start with basic notification, will be updated when call info is available
-            val notification = buildBasicNotification()
-            startForeground(NOTIFICATION_ID, notification)
+            Log.d(TAG, "Building basic notification - no call info available")
+            buildBasicNotification()
         }
 
+        startForeground(NOTIFICATION_ID, notification)
         return START_STICKY
     }
 
@@ -56,12 +56,12 @@ class CallForegroundService : Service() {
         Log.d(TAG, "Building basic foreground notification.")
 
         return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("Call in Progress")
-            .setContentText("Managing call...")
+            .setContentTitle("Call Service")
+            .setContentText("Call service is running...")
             .setSmallIcon(android.R.drawable.sym_call_incoming)
             .setOngoing(true)
             .setCategory(NotificationCompat.CATEGORY_CALL)
-            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
             .setWhen(System.currentTimeMillis())
             .build()
     }
@@ -117,37 +117,58 @@ class CallForegroundService : Service() {
         }
 
         val statusText = when (state) {
-            "ACTIVE" -> "In call with $callerName"
+            "ACTIVE" -> "$callerName"
             "HELD" -> "$callerName (on hold)"
             "DIALING" -> "Calling $callerName..."
-            else -> "Call with $callerName"
+            "INCOMING" -> "Incoming call from $callerName"
+            else -> callerName
+        }
+
+        val titleText = when (state) {
+            "ACTIVE" -> "$callType Call Active"
+            "HELD" -> "$callType Call Held"
+            "DIALING" -> "Outgoing $callType Call"
+            "INCOMING" -> "Incoming $callType Call"
+            else -> "$callType Call"
         }
 
-        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("$callType Call")
+        val notificationBuilder = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(titleText)
             .setContentText(statusText)
             .setSmallIcon(android.R.drawable.sym_call_incoming)
             .setOngoing(true)
             .setCategory(NotificationCompat.CATEGORY_CALL)
             .setPriority(NotificationCompat.PRIORITY_HIGH)
             .setWhen(System.currentTimeMillis())
-            .addAction(
-                android.R.drawable.ic_menu_call,
-                holdText,
-                holdPendingIntent
-            )
-            .addAction(
+
+        // Add actions for ACTIVE and HELD calls only
+        if (state == "ACTIVE" || state == "HELD") {
+            notificationBuilder
+                .addAction(
+                    if (isHeld) android.R.drawable.ic_media_play else android.R.drawable.ic_media_pause,
+                    holdText,
+                    holdPendingIntent
+                )
+                .addAction(
+                    android.R.drawable.sym_call_outgoing,
+                    "End Call",
+                    endCallPendingIntent
+                )
+        } else if (state == "DIALING") {
+            // For dialing calls, only show end call
+            notificationBuilder.addAction(
                 android.R.drawable.sym_call_outgoing,
                 "End Call",
                 endCallPendingIntent
             )
+        }
 
         // Set content intent to open the main app
         mainPendingIntent?.let {
-            notification.setContentIntent(it)
+            notificationBuilder.setContentIntent(it)
         }
 
-        return notification.build()
+        return notificationBuilder.build()
     }
 
     private fun createNotificationChannel() {

package/android/src/main/java/com/margelo/nitro/qusaieilouti99/callmanager/MyConnection.kt

@@ -33,7 +33,9 @@ class MyConnection(
         } catch (e: Exception) { "Audio" }
 
         connectionProperties = Connection.PROPERTY_SELF_MANAGED
-        connectionCapabilities = Connection.CAPABILITY_SUPPORT_HOLD or Connection.CAPABILITY_MUTE
+        connectionCapabilities = Connection.CAPABILITY_SUPPORT_HOLD or
+                                Connection.CAPABILITY_MUTE or
+                                Connection.CAPABILITY_HOLD
 
         if (currentCallType == "Video") {
             Log.d(TAG, "MyConnection for callId $callId initialized as VIDEO call.")
@@ -70,12 +72,18 @@ class MyConnection(
     override fun onHold() {
         super.onHold()
         Log.d(TAG, "Call held via Telecom for callId: $callId")
+
+        // This is called by the system when it wants to hold our call
+        // Usually happens when a phone call comes in
         CallEngine.holdCall(context, callId)
     }
 
     override fun onUnhold() {
         super.onUnhold()
         Log.d(TAG, "Call unheld via Telecom for callId: $callId")
+
+        // This is called by the system when it's safe to resume our call
+        // Usually happens when a phone call ends
         CallEngine.unholdCall(context, callId)
     }
 
@@ -130,4 +138,22 @@ class MyConnection(
         Log.d(TAG, "onShowIncomingCallUi for callId: $callId")
         // Don't bring app to foreground for incoming calls automatically
     }
+
+    override fun onStateChanged(state: Int) {
+        super.onStateChanged(state)
+        Log.d(TAG, "Connection state changed for callId: $callId. New state: $state")
+
+        when (state) {
+            STATE_HOLDING -> {
+                Log.d(TAG, "Connection is now holding for callId: $callId")
+            }
+            STATE_ACTIVE -> {
+                Log.d(TAG, "Connection is now active for callId: $callId")
+            }
+            STATE_DISCONNECTED -> {
+                Log.d(TAG, "Connection is now disconnected for callId: $callId")
+                CallEngine.removeTelecomConnection(callId)
+            }
+        }
+    }
 }

package/lib/typescript/src/CallEventType.d.ts

@@ -1,2 +1,2 @@
-export type CallEventType = 'INITIAL_CALL_STATE' | 'CALL_STATE_CHANGED' | 'AUDIO_DEVICES_CHANGED' | 'AUDIO_ROUTE_CHANGED' | 'CALL_HELD' | 'CALL_UNHELD' | 'CALL_MUTED' | 'CALL_UNMUTED' | 'CALL_ANSWERED' | 'CALL_REJECTED' | 'CALL_ENDED' | 'DTMF_TONE';
+export type CallEventType = 'INITIAL_CALL_STATE' | 'CALL_STATE_CHANGED' | 'AUDIO_DEVICES_CHANGED' | 'AUDIO_ROUTE_CHANGED' | 'CALL_HELD' | 'CALL_UNHELD' | 'CALL_UNHOLD_FAILED' | 'CALL_MUTED' | 'CALL_UNMUTED' | 'CALL_ANSWERED' | 'CALL_REJECTED' | 'CALL_ENDED' | 'DTMF_TONE';
 //# sourceMappingURL=CallEventType.d.ts.map

package/lib/typescript/src/CallEventType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallEventType.d.ts","sourceRoot":"","sources":["../../../src/CallEventType.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,aAAa,GACrB,oBAAoB,GACpB,oBAAoB,GACpB,uBAAuB,GACvB,qBAAqB,GACrB,WAAW,GACX,aAAa,GACb,YAAY,GACZ,cAAc,GACd,eAAe,GACf,eAAe,GACf,YAAY,GACZ,WAAW,CAAC"}
+{"version":3,"file":"CallEventType.d.ts","sourceRoot":"","sources":["../../../src/CallEventType.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,aAAa,GACrB,oBAAoB,GACpB,oBAAoB,GACpB,uBAAuB,GACvB,qBAAqB,GACrB,WAAW,GACX,aAAa,GACb,oBAAoB,GACpB,YAAY,GACZ,cAAc,GACd,eAAe,GACf,eAAe,GACf,YAAY,GACZ,WAAW,CAAC"}

package/nitrogen/generated/android/c++/JCallEventType.hpp

@@ -47,6 +47,7 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
       static const auto fieldAUDIO_ROUTE_CHANGED = clazz->getStaticField<JCallEventType>("AUDIO_ROUTE_CHANGED");
       static const auto fieldCALL_HELD = clazz->getStaticField<JCallEventType>("CALL_HELD");
       static const auto fieldCALL_UNHELD = clazz->getStaticField<JCallEventType>("CALL_UNHELD");
+      static const auto fieldCALL_UNHOLD_FAILED = clazz->getStaticField<JCallEventType>("CALL_UNHOLD_FAILED");
       static const auto fieldCALL_MUTED = clazz->getStaticField<JCallEventType>("CALL_MUTED");
       static const auto fieldCALL_UNMUTED = clazz->getStaticField<JCallEventType>("CALL_UNMUTED");
       static const auto fieldCALL_ANSWERED = clazz->getStaticField<JCallEventType>("CALL_ANSWERED");
@@ -67,6 +68,8 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
           return clazz->getStaticFieldValue(fieldCALL_HELD);
         case CallEventType::CALL_UNHELD:
           return clazz->getStaticFieldValue(fieldCALL_UNHELD);
+        case CallEventType::CALL_UNHOLD_FAILED:
+          return clazz->getStaticFieldValue(fieldCALL_UNHOLD_FAILED);
         case CallEventType::CALL_MUTED:
           return clazz->getStaticFieldValue(fieldCALL_MUTED);
         case CallEventType::CALL_UNMUTED:

package/nitrogen/generated/android/kotlin/com/margelo/nitro/qusaieilouti99/callmanager/CallEventType.kt

@@ -22,6 +22,7 @@ enum class CallEventType {
   AUDIO_ROUTE_CHANGED,
   CALL_HELD,
   CALL_UNHELD,
+  CALL_UNHOLD_FAILED,
   CALL_MUTED,
   CALL_UNMUTED,
   CALL_ANSWERED,

package/nitrogen/generated/ios/swift/CallEventType.swift

@@ -29,6 +29,8 @@ public extension CallEventType {
         self = .callHeld
       case "CALL_UNHELD":
         self = .callUnheld
+      case "CALL_UNHOLD_FAILED":
+        self = .callUnholdFailed
       case "CALL_MUTED":
         self = .callMuted
       case "CALL_UNMUTED":
@@ -63,6 +65,8 @@ public extension CallEventType {
         return "CALL_HELD"
       case .callUnheld:
         return "CALL_UNHELD"
+      case .callUnholdFailed:
+        return "CALL_UNHOLD_FAILED"
       case .callMuted:
         return "CALL_MUTED"
       case .callUnmuted:

package/nitrogen/generated/shared/c++/CallEventType.hpp

@@ -35,12 +35,13 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
     AUDIO_ROUTE_CHANGED      SWIFT_NAME(audioRouteChanged) = 3,
     CALL_HELD      SWIFT_NAME(callHeld) = 4,
     CALL_UNHELD      SWIFT_NAME(callUnheld) = 5,
-    CALL_MUTED      SWIFT_NAME(callMuted) = 6,
-    CALL_UNMUTED      SWIFT_NAME(callUnmuted) = 7,
-    CALL_ANSWERED      SWIFT_NAME(callAnswered) = 8,
-    CALL_REJECTED      SWIFT_NAME(callRejected) = 9,
-    CALL_ENDED      SWIFT_NAME(callEnded) = 10,
-    DTMF_TONE      SWIFT_NAME(dtmfTone) = 11,
+    CALL_UNHOLD_FAILED      SWIFT_NAME(callUnholdFailed) = 6,
+    CALL_MUTED      SWIFT_NAME(callMuted) = 7,
+    CALL_UNMUTED      SWIFT_NAME(callUnmuted) = 8,
+    CALL_ANSWERED      SWIFT_NAME(callAnswered) = 9,
+    CALL_REJECTED      SWIFT_NAME(callRejected) = 10,
+    CALL_ENDED      SWIFT_NAME(callEnded) = 11,
+    DTMF_TONE      SWIFT_NAME(dtmfTone) = 12,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::qusaieilouti99_callmanager
@@ -61,6 +62,7 @@ namespace margelo::nitro {
         case hashString("AUDIO_ROUTE_CHANGED"): return CallEventType::AUDIO_ROUTE_CHANGED;
         case hashString("CALL_HELD"): return CallEventType::CALL_HELD;
         case hashString("CALL_UNHELD"): return CallEventType::CALL_UNHELD;
+        case hashString("CALL_UNHOLD_FAILED"): return CallEventType::CALL_UNHOLD_FAILED;
         case hashString("CALL_MUTED"): return CallEventType::CALL_MUTED;
         case hashString("CALL_UNMUTED"): return CallEventType::CALL_UNMUTED;
         case hashString("CALL_ANSWERED"): return CallEventType::CALL_ANSWERED;
@@ -79,6 +81,7 @@ namespace margelo::nitro {
         case CallEventType::AUDIO_ROUTE_CHANGED: return JSIConverter<std::string>::toJSI(runtime, "AUDIO_ROUTE_CHANGED");
         case CallEventType::CALL_HELD: return JSIConverter<std::string>::toJSI(runtime, "CALL_HELD");
         case CallEventType::CALL_UNHELD: return JSIConverter<std::string>::toJSI(runtime, "CALL_UNHELD");
+        case CallEventType::CALL_UNHOLD_FAILED: return JSIConverter<std::string>::toJSI(runtime, "CALL_UNHOLD_FAILED");
         case CallEventType::CALL_MUTED: return JSIConverter<std::string>::toJSI(runtime, "CALL_MUTED");
         case CallEventType::CALL_UNMUTED: return JSIConverter<std::string>::toJSI(runtime, "CALL_UNMUTED");
         case CallEventType::CALL_ANSWERED: return JSIConverter<std::string>::toJSI(runtime, "CALL_ANSWERED");
@@ -102,6 +105,7 @@ namespace margelo::nitro {
         case hashString("AUDIO_ROUTE_CHANGED"):
         case hashString("CALL_HELD"):
         case hashString("CALL_UNHELD"):
+        case hashString("CALL_UNHOLD_FAILED"):
         case hashString("CALL_MUTED"):
         case hashString("CALL_UNMUTED"):
         case hashString("CALL_ANSWERED"):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qusaieilouti99/call-manager",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Call manager",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/CallEventType.ts

@@ -6,6 +6,7 @@ export type CallEventType =
   | 'AUDIO_ROUTE_CHANGED'
   | 'CALL_HELD'
   | 'CALL_UNHELD'
+  | 'CALL_UNHOLD_FAILED'
   | 'CALL_MUTED'
   | 'CALL_UNMUTED'
   | 'CALL_ANSWERED'