@capgo/capacitor-stream-call 0.0.6 → 0.0.19

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,31 +22,34 @@ 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
 import io.getstream.video.android.core.sounds.toSounds
 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.CallRingEvent
+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,7 +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, CallState> = mutableMapOf()
+    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,
@@ -71,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() }
     }
@@ -170,7 +185,7 @@ public class StreamCallPlugin : Plugin() {
                                         declineCall(declinedCall)
                                     },
                                     onAcceptCall = { acceptedCall ->
-                                        acceptCall(acceptedCall)
+                                        internalAcceptCall(acceptedCall)
                                     },
                                     onHideIncomingCall = {
                                         hideIncomingCall()
@@ -192,7 +207,7 @@ public class StreamCallPlugin : Plugin() {
                 val call = streamVideoClient?.call(id = cid.id, type = cid.type)
                 kotlinx.coroutines.GlobalScope.launch {
                     call?.get()
-                    call?.let { acceptCall(it) }
+                    call?.let { internalAcceptCall(it) }
                 }
             }
         }
@@ -211,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) {
@@ -250,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
@@ -468,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,
@@ -561,62 +565,41 @@ public class StreamCallPlugin : Plugin() {
             client.subscribe { event: VideoEvent ->
                 android.util.Log.v("StreamCallPlugin", "Received an event ${event.getEventType()} $event")
                 when (event) {
+                    is CallRingEvent -> {
+                        updateCallStatusAndNotify(event.callCid, "ringing")
+                    }
                     // Handle CallCreatedEvent differently - only log it but don't try to access members yet
-                    is org.openapitools.client.models.CallCreatedEvent -> {
-                        val callCid = event.call.cid
+                    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 }
+                        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)
                         
-                        val data = JSObject().apply {
-                            put("callId", callCid)
-                            put("state", "created")
-                        }
-                        notifyListeners("callEvent", data)
+                        // Use direction from event if available
+                        val callType = callCid.split(":").firstOrNull() ?: "default"
+                        updateCallStatusAndNotify(callCid, "created")
                     }
                     // Add handler for CallSessionStartedEvent which contains participant information
-                    is org.openapitools.client.models.CallSessionStartedEvent -> {
-                        val callCid = event.call.cid
-                        
-                        val data = JSObject().apply {
-                            put("callId", callCid)
-                            put("state", "session_started")
-                        }
-                        notifyListeners("callEvent", data)
+                    is CallSessionStartedEvent -> {
+                        val callCid = event.callCid
+                        updateCallStatusAndNotify(callCid, "session_started")
                     }
                     
                     is CallRejectedEvent -> {
                         val userId = event.user.id
-                        val callCid = event.call.cid
+                        val callCid = event.callCid
                         
                         // Update call state
                         callStates[callCid]?.let { callState ->
                             callState.participantResponses[userId] = "rejected"
                         }
                         
-//                        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 data = JSObject().apply {
-                            put("callId", event.call.cid)
-                            put("state", "rejected")
-                            put("userId", userId)
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(callCid, "rejected", userId)
                         
                         // Check if all participants have responded
                         checkAllParticipantsResponded(callCid)
@@ -624,7 +607,7 @@ public class StreamCallPlugin : Plugin() {
                     
                     is CallMissedEvent -> {
                         val userId = event.user.id
-                        val callCid = event.call.cid
+                        val callCid = event.callCid
                         
                         // Update call state
                         callStates[callCid]?.let { callState ->
@@ -638,12 +621,7 @@ public class StreamCallPlugin : Plugin() {
                             moveAllActivitiesToBackgroundOrKill(context)
                         }
                         
-                        val data = JSObject().apply {
-                            put("callId", callCid)
-                            put("state", "missed")
-                            put("userId", userId)
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(callCid, "missed", userId)
                         
                         // Check if all participants have responded
                         checkAllParticipantsResponded(callCid)
@@ -651,7 +629,7 @@ public class StreamCallPlugin : Plugin() {
                     
                     is CallAcceptedEvent -> {
                         val userId = event.user.id
-                        val callCid = event.call.cid
+                        val callCid = event.callCid
                         
                         // Update call state
                         callStates[callCid]?.let { callState ->
@@ -663,48 +641,34 @@ public class StreamCallPlugin : Plugin() {
                             callState.timer = null
                         }
                         
-                        val data = JSObject().apply {
-                            put("callId", callCid)
-                            put("state", "accepted")
-                            put("userId", userId)
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(callCid, "accepted", userId)
                     }
                     
                     is CallEndedEvent -> {
                         runOnMainThread {
-                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallEndedEvent for call ${event.call.cid}")
+                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallEndedEvent for call ${event.callCid}")
                             // Clean up call resources
-                            val callCid = event.call.cid
+                            val callCid = event.callCid
                             cleanupCall(callCid)
                         }
-                        val data = JSObject().apply {
-                            put("callId", event.call.cid)
-                            put("state", "left")
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(event.callCid, "left")
                     }
                     
                     is CallSessionEndedEvent -> {
                         runOnMainThread {
-                            android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallSessionEndedEvent for call ${event.call.cid}")
+                            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.call.cid
+                            val callCid = event.callCid
                             cleanupCall(callCid)
                         }
-                        val data = JSObject().apply {
-                            put("callId", event.call.cid)
-                            put("state", "left")
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(event.callCid, "left")
                     }
                     
                     else -> {
-                        val data = JSObject().apply {
-                            put("callId", streamVideoClient?.state?.activeCall?.value?.cid)
-                            put("state", event.getEventType())
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(
+                            streamVideoClient?.state?.activeCall?.value?.cid ?: "",
+                            event.getEventType()
+                        )
                     }
                 }
             }
@@ -721,19 +685,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")
                     }
                 }
             }
@@ -791,8 +747,42 @@ public class StreamCallPlugin : Plugin() {
         })
     }
 
+    @PluginMethod
+    public fun acceptCall(call: PluginCall) {
+        try {
+            val streamVideoCall = streamVideoClient?.state?.ringingCall?.value
+            if (streamVideoCall == null) {
+                call.reject("Ringing call is null")
+                return
+            }
+            kotlinx.coroutines.GlobalScope.launch {
+                internalAcceptCall(streamVideoCall)
+            }
+        } catch (t: Throwable) {
+            android.util.Log.d("StreamCallPlugin", "JS -> acceptCall fail", t);
+            call.reject("Cannot acceptCall")
+        }
+    }
+
+    @PluginMethod
+    public fun rejectCall(call: PluginCall) {
+        try {
+            val streamVideoCall = streamVideoClient?.state?.ringingCall?.value
+            if (streamVideoCall == null) {
+                call.reject("Ringing call is null")
+                return
+            }
+            kotlinx.coroutines.GlobalScope.launch {
+                declineCall(streamVideoCall)
+            }
+        } catch (t: Throwable) {
+            android.util.Log.d("StreamCallPlugin", "JS -> rejectCall fail", t);
+            call.reject("Cannot rejectCall")
+        }
+    }
+
     @OptIn(DelicateCoroutinesApi::class)
-    private fun acceptCall(call: Call) {
+    private fun internalAcceptCall(call: Call) {
         kotlinx.coroutines.GlobalScope.launch {
             try {
                 // Stop ringtone
@@ -807,12 +797,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 {
@@ -935,7 +921,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
@@ -988,12 +973,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)
@@ -1079,7 +1060,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 callCid = "$callType:$callId"
+            val team = call.getString("team");
 
             android.util.Log.d("StreamCallPlugin", "Creating call:")
             android.util.Log.d("StreamCallPlugin", "- Call ID: $callId")
@@ -1098,15 +1079,23 @@ public class StreamCallPlugin : Plugin() {
                     
                     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,
@@ -1132,7 +1121,7 @@ public class StreamCallPlugin : Plugin() {
     }
 
     private fun startCallTimeoutMonitor(callCid: String, memberIds: List<String>) {
-        val callState = CallState(members = memberIds)
+        val callState = LocalCallState(members = memberIds)
         
         val handler = Handler(Looper.getMainLooper())
         val timeoutRunnable = object : Runnable {
@@ -1172,12 +1161,7 @@ public class StreamCallPlugin : Plugin() {
                     if (memberId !in callState.participantResponses) {
                         callState.participantResponses[memberId] = "missed"
                         
-                        val data = JSObject().apply {
-                            put("callId", callCid)
-                            put("state", "missed")
-                            put("userId", memberId)
-                        }
-                        notifyListeners("callEvent", data)
+                        updateCallStatusAndNotify(callCid, "missed", memberId)
                     }
                 }
                 
@@ -1195,13 +1179,8 @@ public class StreamCallPlugin : Plugin() {
                                 // 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
-                                val data = JSObject().apply {
-                                    put("callId", callCid)
-                                    put("state", "ended")
-                                    put("reason", "timeout")
-                                }
-                                notifyListeners("callEvent", data)
+                                // 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)
                             }
@@ -1271,13 +1250,8 @@ public class StreamCallPlugin : Plugin() {
                             // 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
-                            val data = JSObject().apply {
-                                put("callId", callCid)
-                                put("state", "ended")
-                                put("reason", "all_rejected_or_missed")
-                            }
-                            notifyListeners("callEvent", data)
+                            // 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)
                         }
@@ -1289,68 +1263,68 @@ public class StreamCallPlugin : Plugin() {
 
     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)
-            
-            if (userDeviceFlow == null) {
-                android.util.Log.e("StreamCallPlugin", "userDevice Flow is null")
-                return
-            }
-            
-            android.util.Log.d("StreamCallPlugin", "Successfully accessed userDevice Flow: $userDeviceFlow")
+            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",
+                )
 
-            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;
-                    }
-                    streamVideoClient.deleteDevice(it)
-                    return@first true;
-                }
-            } catch (e: Throwable) {
-                android.util.Log.e("StreamCallPlugin", "Cannot collect flow in magicDeviceDelete", e)
+                streamVideoClient.deleteDevice(device)
             }
         } catch (e: Exception) {
             android.util.Log.e("StreamCallPlugin", "Error in magicDeviceDelete", e)
         }
     }
 
-    data class CallState(
+    @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(),