@capgo/capacitor-stream-call 0.0.5 → 0.0.18

package/android/src/main/java/ee/forgr/capacitor/streamcall/StreamCallPlugin.kt

@@ -6,6 +6,8 @@ import android.app.Application
 import android.app.KeyguardManager
 import android.content.Context
 import android.graphics.Color
+import android.media.RingtoneManager
+import android.net.Uri
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
@@ -20,13 +22,11 @@ import com.getcapacitor.Plugin
 import com.getcapacitor.PluginCall
 import com.getcapacitor.PluginMethod
 import com.getcapacitor.annotation.CapacitorPlugin
-import io.getstream.android.push.firebase.FirebasePushDeviceGenerator
 import io.getstream.android.push.permissions.ActivityLifecycleCallbacks
 import io.getstream.video.android.core.Call
 import io.getstream.video.android.core.GEO
 import io.getstream.video.android.core.StreamVideo
 import io.getstream.video.android.core.StreamVideoBuilder
-import io.getstream.video.android.core.model.RejectReason
 import io.getstream.video.android.core.notifications.NotificationConfig
 import io.getstream.video.android.core.notifications.NotificationHandler
 import io.getstream.video.android.core.sounds.emptyRingingConfig
@@ -35,16 +35,21 @@ import io.getstream.video.android.model.StreamCallId
 import io.getstream.video.android.model.User
 import io.getstream.video.android.model.streamCallId
 import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
-import org.openapitools.client.models.CallAcceptedEvent
-import org.openapitools.client.models.CallEndedEvent
-import org.openapitools.client.models.CallMissedEvent
-import org.openapitools.client.models.CallRejectedEvent
-import org.openapitools.client.models.CallSessionEndedEvent
-import org.openapitools.client.models.VideoEvent
 import io.getstream.video.android.model.Device
-import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.tasks.await
+import com.google.firebase.messaging.FirebaseMessaging
+import io.getstream.android.push.PushProvider
+import io.getstream.android.push.firebase.FirebasePushDeviceGenerator
+import io.getstream.android.video.generated.models.CallAcceptedEvent
+import io.getstream.android.video.generated.models.CallCreatedEvent
+import io.getstream.android.video.generated.models.CallEndedEvent
+import io.getstream.android.video.generated.models.CallMissedEvent
+import io.getstream.android.video.generated.models.CallRejectedEvent
+import io.getstream.android.video.generated.models.CallSessionEndedEvent
+import io.getstream.android.video.generated.models.CallSessionStartedEvent
+import io.getstream.android.video.generated.models.VideoEvent
+import io.getstream.video.android.core.sounds.RingingConfig
 
 // I am not a religious pearson, but at this point, I am not sure even god himself would understand this code
 // It's a spaghetti-like, tangled, unreadable mess and frankly, I am deeply sorry for the code crimes commited in the Android impl
@@ -63,6 +68,12 @@ public class StreamCallPlugin : Plugin() {
     private var savedActivity: Activity? = null
     private var savedActivityPaused = false
     private var savedCallsToEndOnResume = mutableListOf<Call>()
+    private val callStates: MutableMap<String, LocalCallState> = mutableMapOf()
+    
+    // Store current call info
+    private var currentCallId: String = ""
+    private var currentCallType: String = ""
+    private var currentCallState: String = ""
 
     private enum class State {
         NOT_INITIALIZED,
@@ -70,6 +81,11 @@ public class StreamCallPlugin : Plugin() {
         INITIALIZED
     }
 
+    public fun incomingOnlyRingingConfig(): RingingConfig = object : RingingConfig {
+        override val incomingCallSoundUri: Uri? = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+        override val outgoingCallSoundUri: Uri? = null
+    }
+
     private fun runOnMainThread(action: () -> Unit) {
         mainHandler.post { action() }
     }
@@ -210,12 +226,8 @@ public class StreamCallPlugin : Plugin() {
                 // Stop ringtone
                 ringtonePlayer?.stopRinging()
                 
-                // Notify that call has ended
-                val data = JSObject().apply {
-                    put("callId", call.id)
-                    put("state", "rejected")
-                }
-                notifyListeners("callEvent", data)
+                // Notify that call has ended using our helper
+                updateCallStatusAndNotify(call.id, "rejected")
                 
                 hideIncomingCall()
             } catch (e: Exception) {
@@ -249,14 +261,6 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
-//    private fun remoteIncomingCallNotif() {
-//        CallService.removeIncomingCall(
-//            context,
-//            StreamCallId.fromCallCid(call.cid),
-//            StreamVideo.instance().state.callConfigRegistry.get(call.type),
-//        )
-//    }
-
     private fun setupViews() {
         val context = context
         val parent = bridge?.webView?.parent as? ViewGroup ?: return
@@ -342,7 +346,7 @@ public class StreamCallPlugin : Plugin() {
             SecureUserRepository.getInstance(context).save(credentials)
 
             // Initialize Stream Video with new credentials
-            if (!hadSavedCredentials || (savedCredentials!!.user.id !== userId)) {
+            if (!hadSavedCredentials || (savedCredentials!!.user.id != userId)) {
                 initializeStreamVideo()
             }
 
@@ -467,16 +471,17 @@ public class StreamCallPlugin : Plugin() {
             )
 
             val notificationConfig = NotificationConfig(
-                pushDeviceGenerators = listOf(FirebasePushDeviceGenerator(
+                pushDeviceGenerators = listOf(
+                    FirebasePushDeviceGenerator(
                     providerName = "firebase",
                     context = contextToUse
-                )),
+                )
+                ),
                 requestPermissionOnAppLaunch = { true },
                 notificationHandler = notificationHandler,
             )
 
-            val soundsConfig = emptyRingingConfig()
-            soundsConfig.incomingCallSoundUri
+            val soundsConfig = incomingOnlyRingingConfig()
             // Initialize StreamVideo client
             streamVideoClient = StreamVideoBuilder(
                 context = contextToUse,
@@ -560,89 +565,109 @@ public class StreamCallPlugin : Plugin() {
             client.subscribe { event: VideoEvent ->
                 android.util.Log.v("StreamCallPlugin", "Received an event ${event.getEventType()} $event")
                 when (event) {
-                    is CallEndedEvent -> {
-                        runOnMainThread {
-                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallEndedEvent for call ${event.call.cid}")
-                            overlayView?.setContent {
-                                CallOverlayView(
-                                    context = context,
-                                    streamVideo = streamVideoClient,
-                                    call = null
-                                )
-                            }
-                            overlayView?.isVisible = false
-                            // Stop ringtone if it's still playing
-                            ringtonePlayer?.stopRinging()
-                            // Hide incoming call view if visible
-                            incomingCallView?.isVisible = false
-                        }
-                        val data = JSObject().apply {
-                            put("callId", event.call.cid)
-                            put("state", "left")
-                        }
-                        notifyListeners("callEvent", data)
+                    // Handle CallCreatedEvent differently - only log it but don't try to access members yet
+                    is CallCreatedEvent -> {
+                        val callCid = event.callCid
+                        android.util.Log.d("StreamCallPlugin", "Call created: $callCid")
+
+                        // let's get the members
+                        val callParticipants = event.members.filter{ it.user.id != this@StreamCallPlugin.streamVideoClient?.userId }.map { it.user.id }
+                        android.util.Log.d("StreamCallPlugin", "Call created for $callCid with ${callParticipants.size} participants")
+
+                        // Start tracking this call now that we have the member list
+                        startCallTimeoutMonitor(callCid, callParticipants)
+                        
+                        // Use direction from event if available
+                        val callType = callCid.split(":").firstOrNull() ?: "default"
+                        updateCallStatusAndNotify(callCid, "created")
                     }
-                    is CallSessionEndedEvent -> {
-                        runOnMainThread {
-                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallSessionEndedEvent for call ${event.call.cid}")
-                            overlayView?.setContent {
-                                CallOverlayView(
-                                    context = context,
-                                    streamVideo = streamVideoClient,
-                                    call = null
-                                )
-                            }
-                            overlayView?.isVisible = false
-                            // Stop ringtone if it's still playing
-                            ringtonePlayer?.stopRinging()
-                            // Hide incoming call view if visible
-                            incomingCallView?.isVisible = false
-                        }
-                        val data = JSObject().apply {
-                            put("callId", event.call.cid)
-                            put("state", "left")
-                        }
-                        notifyListeners("callEvent", data)
+                    // Add handler for CallSessionStartedEvent which contains participant information
+                    is CallSessionStartedEvent -> {
+                        val callCid = event.callCid
+                        updateCallStatusAndNotify(callCid, "session_started")
                     }
+                    
                     is CallRejectedEvent -> {
-                        runOnMainThread {
-                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallRejectedEvent for call ${event.call.cid}")
-                            overlayView?.setContent {
-                                CallOverlayView(
-                                    context = context,
-                                    streamVideo = streamVideoClient,
-                                    call = null
-                                )
-                            }
-                            overlayView?.isVisible = false
-
-                            val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-                            if (keyguardManager.isKeyguardLocked) {
-                                android.util.Log.d("StreamCallPlugin", "Stop ringing and move to background")
-                                this@StreamCallPlugin.ringtonePlayer?.stopRinging()
-                                moveAllActivitiesToBackgroundOrKill(context)
-                            }
-                        }
-                        val data = JSObject().apply {
-                            put("callId", event.call.cid)
-                            put("state", "rejected")
+                        val userId = event.user.id
+                        val callCid = event.callCid
+                        
+                        // Update call state
+                        callStates[callCid]?.let { callState ->
+                            callState.participantResponses[userId] = "rejected"
                         }
-                        notifyListeners("callEvent", data)
+                        
+                        updateCallStatusAndNotify(callCid, "rejected", userId)
+                        
+                        // Check if all participants have responded
+                        checkAllParticipantsResponded(callCid)
                     }
+                    
                     is CallMissedEvent -> {
+                        val userId = event.user.id
+                        val callCid = event.callCid
+                        
+                        // Update call state
+                        callStates[callCid]?.let { callState ->
+                            callState.participantResponses[userId] = "missed"
+                        }
+                        
                         val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
                         if (keyguardManager.isKeyguardLocked) {
                             android.util.Log.d("StreamCallPlugin", "Stop ringing and move to background")
                             this.ringtonePlayer?.stopRinging()
                             moveAllActivitiesToBackgroundOrKill(context)
                         }
+                        
+                        updateCallStatusAndNotify(callCid, "missed", userId)
+                        
+                        // Check if all participants have responded
+                        checkAllParticipantsResponded(callCid)
+                    }
+                    
+                    is CallAcceptedEvent -> {
+                        val userId = event.user.id
+                        val callCid = event.callCid
+                        
+                        // Update call state
+                        callStates[callCid]?.let { callState ->
+                            callState.participantResponses[userId] = "accepted"
+                            
+                            // Since someone accepted, cancel the timeout timer
+                            android.util.Log.d("StreamCallPlugin", "Call accepted by $userId, canceling timeout timer for $callCid")
+                            callState.timer?.removeCallbacksAndMessages(null)
+                            callState.timer = null
+                        }
+                        
+                        updateCallStatusAndNotify(callCid, "accepted", userId)
+                    }
+                    
+                    is CallEndedEvent -> {
+                        runOnMainThread {
+                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallEndedEvent for call ${event.callCid}")
+                            // Clean up call resources
+                            val callCid = event.callCid
+                            cleanupCall(callCid)
+                        }
+                        updateCallStatusAndNotify(event.callCid, "left")
+                    }
+                    
+                    is CallSessionEndedEvent -> {
+                        runOnMainThread {
+                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallSessionEndedEvent for call ${event.callCid}. Test session: ${event.call.session?.endedAt}")
+                            // Clean up call resources
+                            val callCid = event.callCid
+                            cleanupCall(callCid)
+                        }
+                        updateCallStatusAndNotify(event.callCid, "left")
+                    }
+                    
+                    else -> {
+                        updateCallStatusAndNotify(
+                            streamVideoClient?.state?.activeCall?.value?.cid ?: "",
+                            event.getEventType()
+                        )
                     }
                 }
-                val data = JSObject().apply {
-                    put("callId", streamVideoClient?.state?.activeCall?.value?.cid)
-                    put("state", event.getEventType())
-                }
-                notifyListeners("callEvent", data)
             }
 
             // Add call state subscription using collect
@@ -657,19 +682,11 @@ public class StreamCallPlugin : Plugin() {
                         android.util.Log.d("StreamCallPlugin", "- All participants: ${state.participants}")
                         android.util.Log.d("StreamCallPlugin", "- Remote participants: ${state.remoteParticipants}")
 
-                        // Notify that a call has started
-                        val data = JSObject().apply {
-                            put("callId", call.cid)
-                            put("state", "joined")
-                        }
-                        notifyListeners("callEvent", data)
+                        // Notify that a call has started using our helper
+                        updateCallStatusAndNotify(call.cid, "joined")
                     } ?: run {
-                        // Notify that call has ended
-                        val data = JSObject().apply {
-                            put("callId", "")
-                            put("state", "left")
-                        }
-                        notifyListeners("callEvent", data)
+                        // Notify that call has ended using our helper
+                        updateCallStatusAndNotify("", "left")
                     }
                 }
             }
@@ -743,12 +760,8 @@ public class StreamCallPlugin : Plugin() {
                 // Join the call without affecting others
                 call.accept()
 
-                // Notify that call has started
-                val data = JSObject().apply {
-                    put("callId", call.id)
-                    put("state", "joined")
-                }
-                notifyListeners("callEvent", data)
+                // Notify that call has started using helper
+                updateCallStatusAndNotify(call.id, "joined")
 
                 // Show overlay view with the active call
                 runOnMainThread {
@@ -871,7 +884,6 @@ public class StreamCallPlugin : Plugin() {
         val callId = call.id
         android.util.Log.d("StreamCallPlugin", "Attempting to end call $callId")
         call.leave()
-        call.reject(reason = RejectReason.Cancel)
         
         // Capture context from the overlayView
         val currentContext = overlayView?.context ?: this.savedContext
@@ -924,12 +936,8 @@ public class StreamCallPlugin : Plugin() {
             incomingCallView?.isVisible = false
         }
         
-        // Notify that call has ended
-        val data = JSObject().apply {
-            put("callId", callId)
-            put("state", "left")
-        }
-        notifyListeners("callEvent", data)
+        // Notify that call has ended using helper
+        updateCallStatusAndNotify(callId, "left")
     }
 
     @OptIn(DelicateCoroutinesApi::class)
@@ -1015,6 +1023,7 @@ public class StreamCallPlugin : Plugin() {
             val callType = call.getString("type") ?: "default"
             val shouldRing = call.getBoolean("ring") ?: true
             val callId = java.util.UUID.randomUUID().toString()
+            val team = call.getString("team");
 
             android.util.Log.d("StreamCallPlugin", "Creating call:")
             android.util.Log.d("StreamCallPlugin", "- Call ID: $callId")
@@ -1027,70 +1036,29 @@ public class StreamCallPlugin : Plugin() {
                 try {
                     // Create the call object
                     val streamCall = streamVideoClient?.call(type = callType, id = callId)
-
-                    // Track participants responses
-                    val participantResponses = mutableMapOf<String, String>()
-                    val totalParticipants = userIds.size
-
-                    // Subscribe to call events for this specific call
-                    streamCall?.subscribe { event ->
-                        when (event) {
-                            is CallRejectedEvent -> {
-                                val userId = event.user.id
-                                android.util.Log.d("StreamCallPlugin", "Call was rejected by user: $userId")
-                                participantResponses[userId] = "rejected"
-                                
-                                val data = JSObject().apply {
-                                    put("callId", callId)
-                                    put("state", "rejected")
-                                    put("userId", userId)
-                                }
-                                notifyListeners("callEvent", data)
-
-                                // Check if all participants have rejected or missed
-                                checkAllParticipantsResponded(participantResponses, totalParticipants, streamCall)
-                            }
-                            is CallMissedEvent -> {
-                                val userId = event.user.id
-                                android.util.Log.d("StreamCallPlugin", "Call was missed by user: $userId")
-                                participantResponses[userId] = "missed"
-                                
-                                val data = JSObject().apply {
-                                    put("callId", callId)
-                                    put("state", "missed")
-                                    put("userId", userId)
-                                }
-                                notifyListeners("callEvent", data)
-
-                                // Check if all participants have rejected or missed
-                                checkAllParticipantsResponded(participantResponses, totalParticipants, streamCall)
-                            }
-                            is CallAcceptedEvent -> {
-                                val userId = event.user.id
-                                android.util.Log.d("StreamCallPlugin", "Call was accepted by user: $userId")
-                                participantResponses[userId] = "accepted"
-                                
-                                val data = JSObject().apply {
-                                    put("callId", callId)
-                                    put("state", "accepted")
-                                    put("userId", userId)
-                                }
-                                notifyListeners("callEvent", data)
-                            }
-                        }
-                    }
-
+                    
+                    // Note: We no longer start tracking here - we'll wait for CallSessionStartedEvent
+                    // instead, which contains the actual participant list
+                    
                     android.util.Log.d("StreamCallPlugin", "Creating call with members...")
                     // Create the call with all members
-                    streamCall?.create(
+                    val createResult = streamCall?.create(
                         memberIds = userIds + selfUserId,
                         custom = emptyMap(),
-                        ring = shouldRing
+                        ring = shouldRing,
+                        team = team,
                     )
+                    
+                    if (createResult?.isFailure == true) {
+                       throw (createResult.errorOrNull() ?: RuntimeException("Unknown error creating call")) as Throwable
+                    }
 
                     android.util.Log.d("StreamCallPlugin", "Setting overlay visible for outgoing call $callId")
                     // Show overlay view
                     activity?.runOnUiThread {
+                        streamCall?.microphone?.setEnabled(true)
+                        streamCall?.camera?.setEnabled(true)
+
                         overlayView?.setContent {
                             CallOverlayView(
                                 context = context,
@@ -1115,104 +1083,214 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
-    @OptIn(DelicateCoroutinesApi::class)
-    private fun checkAllParticipantsResponded(
-        participantResponses: Map<String, String>,
-        totalParticipants: Int,
-        streamCall: Call
-    ) {
-        kotlinx.coroutines.GlobalScope.launch {
-            try {
-                val allResponded = participantResponses.size == totalParticipants
-                val allRejectedOrMissed = participantResponses.values.all { it == "rejected" || it == "missed" }
+    private fun startCallTimeoutMonitor(callCid: String, memberIds: List<String>) {
+        val callState = LocalCallState(members = memberIds)
+        
+        val handler = Handler(Looper.getMainLooper())
+        val timeoutRunnable = object : Runnable {
+            override fun run() {
+                checkCallTimeout(callCid)
+                handler.postDelayed(this, 1000)
+            }
+        }
+        
+        handler.postDelayed(timeoutRunnable, 1000)
+        callState.timer = handler
+        
+        callStates[callCid] = callState
+        
+        android.util.Log.d("StreamCallPlugin", "Started timeout monitor for call $callCid with ${memberIds.size} members")
+    }
+
+    private fun checkCallTimeout(callCid: String) {
+        val callState = callStates[callCid] ?: return
+        
+        val now = System.currentTimeMillis()
+        val elapsedSeconds = (now - callState.createdAt) / 1000
+        
+        if (elapsedSeconds >= 30) {
+            android.util.Log.d("StreamCallPlugin", "Call $callCid has timed out after $elapsedSeconds seconds")
+            
+            val hasAccepted = callState.participantResponses.values.any { it == "accepted" }
+            
+            if (!hasAccepted) {
+                android.util.Log.d("StreamCallPlugin", "No one accepted call $callCid, marking all non-responders as missed")
                 
-                if (allResponded && allRejectedOrMissed) {
-                    android.util.Log.d("StreamCallPlugin", "All participants have rejected or missed the call")
-                    streamCall.leave()
-                    activity?.runOnUiThread {
-                        overlayView?.setContent {
-                            CallOverlayView(
-                                context = context,
-                                streamVideo = streamVideoClient,
-                                call = null
-                            )
-                        }
-                        overlayView?.isVisible = false
+                // First, remove the timer to prevent further callbacks
+                callState.timer?.removeCallbacksAndMessages(null)
+                callState.timer = null
+                
+                callState.members.forEach { memberId ->
+                    if (memberId !in callState.participantResponses) {
+                        callState.participantResponses[memberId] = "missed"
+                        
+                        updateCallStatusAndNotify(callCid, "missed", memberId)
                     }
+                }
+                
+                val callIdParts = callCid.split(":")
+                if (callIdParts.size >= 2) {
+                    val callType = callIdParts[0]
+                    val callId = callIdParts[1]
                     
-                    val data = JSObject().apply {
-                        put("callId", streamCall.id)
-                        put("state", "ended")
-                        put("reason", "all_rejected_or_missed")
+                    streamVideoClient?.call(type = callType, id = callId)?.let { call ->
+                        kotlinx.coroutines.GlobalScope.launch {
+                            try {
+                                // Use endCallRaw instead of manual cleanup
+                                endCallRaw(call)
+                                
+                                // Clean up state - we don't need to do this in endCallRaw because we already did it here
+                                callStates.remove(callCid)
+                                
+                                // Notify that call has ended using helper
+                                updateCallStatusAndNotify(callCid, "ended", null, "timeout")
+                            } catch (e: Exception) {
+                                android.util.Log.e("StreamCallPlugin", "Error ending timed out call", e)
+                            }
+                        }
                     }
-                    notifyListeners("callEvent", data)
                 }
-            } catch (e: Exception) {
-                android.util.Log.e("StreamCallPlugin", "Error checking participant responses: ${e.message}")
             }
         }
     }
 
-    private suspend fun magicDeviceDelete(streamVideoClient: StreamVideo) {
-        try {
-            android.util.Log.d("StreamCallPlugin", "Starting magicDeviceDelete reflection operation")
-            
-            // Get the streamNotificationManager field from StreamVideo
-            val streamVideoClass = streamVideoClient.javaClass
-            val notificationManagerField = streamVideoClass.getDeclaredField("streamNotificationManager")
-            notificationManagerField.isAccessible = true
-            val notificationManager = notificationManagerField.get(streamVideoClient)
-            
-            if (notificationManager == null) {
-                android.util.Log.e("StreamCallPlugin", "streamNotificationManager is null")
-                return
-            }
-            
-            android.util.Log.d("StreamCallPlugin", "Successfully accessed streamNotificationManager")
-            
-            // Get deviceTokenStorage from notification manager
-            val notificationManagerClass = notificationManager.javaClass
-            val deviceTokenStorageField = notificationManagerClass.getDeclaredField("deviceTokenStorage")
-            deviceTokenStorageField.isAccessible = true
-            val deviceTokenStorage = deviceTokenStorageField.get(notificationManager)
-            
-            if (deviceTokenStorage == null) {
-                android.util.Log.e("StreamCallPlugin", "deviceTokenStorage is null")
-                return
-            }
-            
-            android.util.Log.d("StreamCallPlugin", "Successfully accessed deviceTokenStorage")
-            
-            // Access the DeviceTokenStorage object dynamically without hardcoding class
-            val deviceTokenStorageClass = deviceTokenStorage.javaClass
-            
-            // Get the userDevice Flow from deviceTokenStorage
-            val userDeviceField = deviceTokenStorageClass.getDeclaredField("userDevice")
-            userDeviceField.isAccessible = true
-            val userDeviceFlow = userDeviceField.get(deviceTokenStorage)
+    private fun cleanupCall(callCid: String) {
+        // Get the call state
+        val callState = callStates[callCid]
+        
+        if (callState != null) {
+            // Ensure timer is properly canceled
+            android.util.Log.d("StreamCallPlugin", "Stopping timer for call: $callCid")
+            callState.timer?.removeCallbacksAndMessages(null)
+            callState.timer = null
+        }
+        
+        // Remove from callStates
+        callStates.remove(callCid)
+        
+        // Hide UI elements directly without setting content
+        runOnMainThread {
+            android.util.Log.d("StreamCallPlugin", "Hiding UI elements for call $callCid (one-time cleanup)")
+            overlayView?.isVisible = false
+            ringtonePlayer?.stopRinging()
+            incomingCallView?.isVisible = false
+        }
+        
+        android.util.Log.d("StreamCallPlugin", "Cleaned up resources for ended call: $callCid")
+    }
+
+    private fun checkAllParticipantsResponded(callCid: String) {
+        val callState = callStates[callCid] ?: return
+        
+        val totalParticipants = callState.members.size
+        val responseCount = callState.participantResponses.size
+        
+        android.util.Log.d("StreamCallPlugin", "Checking responses for call $callCid: $responseCount / $totalParticipants")
+        
+        val allResponded = responseCount >= totalParticipants
+        val allRejectedOrMissed = allResponded && 
+            callState.participantResponses.values.all { it == "rejected" || it == "missed" }
+        
+        if (allResponded && allRejectedOrMissed) {
+            android.util.Log.d("StreamCallPlugin", "All participants have rejected or missed the call $callCid")
             
-            if (userDeviceFlow == null) {
-                android.util.Log.e("StreamCallPlugin", "userDevice Flow is null")
-                return
-            }
+            // Cancel the timer immediately to prevent further callbacks
+            callState.timer?.removeCallbacksAndMessages(null)
+            callState.timer = null
             
-            android.util.Log.d("StreamCallPlugin", "Successfully accessed userDevice Flow: $userDeviceFlow")
-
-            val castedUserDeviceFlow = userDeviceFlow as Flow<Device?>
-            try {
-                castedUserDeviceFlow.first {
-                    if (it == null) {
-                        android.util.Log.d("StreamCallPlugin", "Device is null. Nothing to remove")
-                        return@first true;
+            // End the call using endCallRaw
+            val callIdParts = callCid.split(":")
+            if (callIdParts.size >= 2) {
+                val callType = callIdParts[0]
+                val callId = callIdParts[1]
+                
+                streamVideoClient?.call(type = callType, id = callId)?.let { call ->
+                    kotlinx.coroutines.GlobalScope.launch {
+                        try {
+                            // Use endCallRaw instead of manual cleanup
+                            endCallRaw(call)
+                            
+                            // Clean up state - we don't need to do this in endCallRaw because we already did it here
+                            callStates.remove(callCid)
+                            
+                            // Notify that call has ended using helper
+                            updateCallStatusAndNotify(callCid, "ended", null, "all_rejected_or_missed")
+                        } catch (e: Exception) {
+                            android.util.Log.e("StreamCallPlugin", "Error ending call after all rejected/missed", e)
+                        }
                     }
-                    streamVideoClient.deleteDevice(it)
-                    return@first true;
                 }
-            } catch (e: Throwable) {
-                android.util.Log.e("StreamCallPlugin", "Cannot collect flow in magicDeviceDelete", e)
+            }
+        }
+    }
+
+    private suspend fun magicDeviceDelete(streamVideoClient: StreamVideo) {
+        try {
+            android.util.Log.d("StreamCallPlugin", "Starting magicDeviceDelete operation")
+
+            FirebaseMessaging.getInstance().token.await()?.let {
+                android.util.Log.d("StreamCallPlugin", "Found firebase token")
+                val device = Device(
+                    id = it,
+                    pushProvider = PushProvider.FIREBASE.key,
+                    pushProviderName = "firebase",
+                )
+
+                streamVideoClient.deleteDevice(device)
             }
         } catch (e: Exception) {
             android.util.Log.e("StreamCallPlugin", "Error in magicDeviceDelete", e)
         }
     }
+
+    @PluginMethod
+    fun getCallStatus(call: PluginCall) {
+        // If not in a call, reject
+        if (currentCallId.isEmpty() || currentCallState == "left") {
+            call.reject("Not in a call")
+            return
+        }
+
+        val result = JSObject()
+        result.put("callId", currentCallId)
+        result.put("state", currentCallState)
+        
+        // No additional fields to ensure compatibility with CallEvent interface
+        
+        call.resolve(result)
+    }
+
+    // Helper method to update call status and notify listeners
+    private fun updateCallStatusAndNotify(callId: String, state: String, userId: String? = null, reason: String? = null) {
+        // Update stored call info
+        currentCallId = callId
+        currentCallState = state
+        
+        // Get call type from call ID if available
+        if (callId.contains(":")) {
+            currentCallType = callId.split(":").firstOrNull() ?: ""
+        }
+        
+        // Create data object with only the fields in the CallEvent interface
+        val data = JSObject().apply {
+            put("callId", callId)
+            put("state", state)
+            userId?.let {
+                put("userId", it)
+            }
+            reason?.let {
+                put("reason", it)
+            }
+        }
+        
+        // Notify listeners
+        notifyListeners("callEvent", data)
+    }
+
+    data class LocalCallState(
+        val members: List<String>,
+        val participantResponses: MutableMap<String, String> = mutableMapOf(),
+        val createdAt: Long = System.currentTimeMillis(),
+        var timer: Handler? = null
+    )
 }