@capgo/capacitor-stream-call 0.0.3 → 0.0.5

package/README.md

@@ -337,6 +337,7 @@ isCameraEnabled() => Promise<CameraEnabledResponse>
 | **`callId`** | <code>string</code> | ID of the call                                                 |
 | **`state`**  | <code>string</code> | Current state of the call                                      |
 | **`userId`** | <code>string</code> | User ID of the participant in the call who triggered the event |
+| **`reason`** | <code>string</code> | Reason for the call state change                               |
 
 
 #### CameraEnabledResponse

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

@@ -206,22 +206,11 @@ fun CallOverlayView(
                     floatingVideoRenderer = floatingVideoRender
                 )
             } else {
-                if (connection != RealtimeConnection.Connected) {
-                    android.util.Log.d("CallOverlayView", "Showing waiting message - not connected")
-                    Text(
-                        text = "waiting for a remote participant...",
-                        fontSize = 30.sp,
-                        color = VideoTheme.colors.basePrimary
-                    )
-                } else {
-                    Text(
-                        modifier = Modifier.padding(30.dp),
-                        text = "Join call ${call.id} in your browser to see the video here",
-                        fontSize = 30.sp,
-                        color = VideoTheme.colors.basePrimary,
-                        textAlign = TextAlign.Center
-                    )
-                }
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .background(VideoTheme.colors.baseSenary)
+                )
             }
         }
     }

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

@@ -34,7 +34,7 @@ class CustomNotificationHandler(
         shouldHaveContentIntent: Boolean,
     ): Notification {
 
-        customCreateIncomingCallChannel(channelId, showAsHighPriority)
+        customCreateIncomingCallChannel()
 
         return buildNotification(
             fullScreenPendingIntent,

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

@@ -136,8 +136,13 @@ fun IncomingCallView(
                         isCameraEnabled = isCameraEnabled,
                         onCallAction = { action ->
                             when (action) {
-                                DeclineCall -> onDeclineCall?.invoke(call)
-                                AcceptCall -> onAcceptCall?.invoke(call)
+                                DeclineCall -> {
+                                    onDeclineCall?.invoke(call)
+                                }
+                                AcceptCall -> {
+                                    call.camera.setEnabled(isCameraEnabled)
+                                    onAcceptCall?.invoke(call)
+                                }
                                 is ToggleCamera -> {
                                     call.camera.setEnabled(action.isEnabled)
                                 }

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

@@ -35,6 +35,7 @@ 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
@@ -42,6 +43,8 @@ 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
 
 // 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
@@ -202,7 +205,7 @@ public class StreamCallPlugin : Plugin() {
     private fun declineCall(call: Call) {
         kotlinx.coroutines.GlobalScope.launch {
             try {
-                call.leave()
+                call.reject()
                 
                 // Stop ringtone
                 ringtonePlayer?.stopRinging()
@@ -339,7 +342,7 @@ public class StreamCallPlugin : Plugin() {
             SecureUserRepository.getInstance(context).save(credentials)
 
             // Initialize Stream Video with new credentials
-            if (!hadSavedCredentials) {
+            if (!hadSavedCredentials || (savedCredentials!!.user.id !== userId)) {
                 initializeStreamVideo()
             }
 
@@ -358,15 +361,20 @@ public class StreamCallPlugin : Plugin() {
             SecureUserRepository.getInstance(context).removeCurrentUser()
             
             // Properly cleanup the client
-            streamVideoClient?.let {
-                StreamVideo.removeClient()
-            }
-            streamVideoClient = null
-            state = State.NOT_INITIALIZED
+            kotlinx.coroutines.GlobalScope.launch {
+                streamVideoClient?.let {
+                    magicDeviceDelete(it)
+                    it.logOut()
+                    StreamVideo.removeClient()
+                }
 
-            val ret = JSObject()
-            ret.put("success", true)
-            call.resolve(ret)
+                streamVideoClient = null
+                state = State.NOT_INITIALIZED
+
+                val ret = JSObject()
+                ret.put("success", true)
+                call.resolve(ret)
+            }
         } catch (e: Exception) {
             call.reject("Failed to logout", e)
         }
@@ -733,7 +741,7 @@ public class StreamCallPlugin : Plugin() {
                 }
 
                 // Join the call without affecting others
-                call.join()
+                call.accept()
 
                 // Notify that call has started
                 val data = JSObject().apply {
@@ -1144,4 +1152,67 @@ 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")
+
+            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)
+            }
+        } catch (e: Exception) {
+            android.util.Log.e("StreamCallPlugin", "Error in magicDeviceDelete", e)
+        }
+    }
 }

package/dist/docs.json

@@ -506,6 +506,13 @@
           "docs": "User ID of the participant in the call who triggered the event",
           "complexTypes": [],
           "type": "string | undefined"
+        },
+        {
+          "name": "reason",
+          "tags": [],
+          "docs": "Reason for the call state change",
+          "complexTypes": [],
+          "type": "string | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -59,6 +59,8 @@ export interface CallEvent {
     state: string;
     /** User ID of the participant in the call who triggered the event */
     userId?: string;
+    /** Reason for the call state change */
+    reason?: string;
 }
 export interface CameraEnabledResponse {
     enabled: boolean;

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * @interface LoginOptions\n * @description Configuration options for logging into the Stream Video service\n * @property {string} token - Stream Video API token for authentication\n * @property {string} userId - Unique identifier for the current user\n * @property {string} name - Display name for the current user\n * @property {string} [imageURL] - Avatar URL for the current user\n * @property {string} apiKey - Stream Video API key for your application\n * @property {string} [magicDivId] - DOM element ID where video will be rendered\n */\nexport interface LoginOptions {\n  /** Stream Video API token */\n  token: string;\n  /** User ID for the current user */\n  userId: string;\n  /** Display name for the current user */\n  name: string;\n  /** Optional avatar URL for the current user */\n  imageURL?: string;\n  /** Stream Video API key */\n  apiKey: string;\n  /** ID of the HTML element where the video will be rendered */\n  magicDivId?: string;\n}\n\n/**\n * @interface CallOptions\n * @description Options for initiating a video call\n * @property {string} userId - ID of the user to call\n * @property {string} [type=default] - Type of call\n * @property {boolean} [ring=true] - Whether to send ring notification\n */\nexport interface CallOptions {\n  /** User ID of the person to call */\n  userIds: string[];\n  /** Type of call, defaults to 'default' */\n  type?: string;\n  /** Whether to ring the other user, defaults to true */\n  ring?: boolean;\n}\n\n/**\n * @interface SuccessResponse\n * @description Standard response indicating operation success/failure\n * @property {boolean} success - Whether the operation succeeded\n */\nexport interface SuccessResponse {\n  /** Whether the operation was successful */\n  success: boolean;\n}\n\n/**\n * @interface CallEvent\n * @description Event emitted when call state changes\n * @property {string} callId - Unique identifier of the call\n * @property {string} state - Current state of the call (joined, left, ringing, etc)\n */\nexport interface CallEvent {\n  /** ID of the call */\n  callId: string;\n  /** Current state of the call */\n  state: string;\n  /** User ID of the participant in the call who triggered the event */\n  userId?: string\n}\n\nexport interface CameraEnabledResponse {\n  enabled: boolean;\n}\n\n/**\n * @interface StreamCallPlugin\n * @description Capacitor plugin for Stream Video calling functionality\n */\nexport interface StreamCallPlugin {\n  /**\n   * Login to Stream Video service\n   * @param {LoginOptions} options - Login configuration\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.login({\n   *   token: 'your-token',\n   *   userId: 'user-123',\n   *   name: 'John Doe',\n   *   apiKey: 'your-api-key'\n   * });\n   */\n  login(options: LoginOptions): Promise<SuccessResponse>;\n\n  /**\n   * Logout from Stream Video service\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.logout();\n   */\n  logout(): Promise<SuccessResponse>;\n\n  /**\n   * Initiate a call to another user\n   * @param {CallOptions} options - Call configuration\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.call({\n   *   userId: 'user-456',\n   *   type: 'video',\n   *   ring: true\n   * });\n   */\n  call(options: CallOptions): Promise<SuccessResponse>;\n\n  /**\n   * End the current call\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.endCall();\n   */\n  endCall(): Promise<SuccessResponse>;\n\n  /**\n   * Enable or disable microphone\n   * @param {{ enabled: boolean }} options - Microphone state\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.setMicrophoneEnabled({ enabled: false });\n   */\n  setMicrophoneEnabled(options: { enabled: boolean }): Promise<SuccessResponse>;\n\n  /**\n   * Enable or disable camera\n   * @param {{ enabled: boolean }} options - Camera state\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.setCameraEnabled({ enabled: false });\n   */\n  setCameraEnabled(options: { enabled: boolean }): Promise<SuccessResponse>;\n\n  /**\n   * Add listener for call events\n   * @param {'callEvent'} eventName - Name of the event to listen for\n   * @param {(event: CallEvent) => void} listenerFunc - Callback function\n   * @returns {Promise<{ remove: () => Promise<void> }>} Function to remove listener\n   * @example\n   * const listener = await StreamCall.addListener('callEvent', (event) => {\n   *   console.log(`Call ${event.callId} is now ${event.state}`);\n   * });\n   */\n  addListener(\n    eventName: 'callEvent',\n    listenerFunc: (event: CallEvent) => void,\n  ): Promise<{ remove: () => Promise<void> }>;\n\n  /**\n   * Remove all event listeners\n   * @returns {Promise<void>}\n   * @example\n   * await StreamCall.removeAllListeners();\n   */\n  removeAllListeners(): Promise<void>;\n\n  /**\n   * Accept an incoming call\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.acceptCall();\n   */\n  acceptCall(): Promise<SuccessResponse>;\n\n  /**\n   * Reject an incoming call\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.rejectCall();\n   */\n  rejectCall(): Promise<SuccessResponse>;\n  isCameraEnabled(): Promise<CameraEnabledResponse>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * @interface LoginOptions\n * @description Configuration options for logging into the Stream Video service\n * @property {string} token - Stream Video API token for authentication\n * @property {string} userId - Unique identifier for the current user\n * @property {string} name - Display name for the current user\n * @property {string} [imageURL] - Avatar URL for the current user\n * @property {string} apiKey - Stream Video API key for your application\n * @property {string} [magicDivId] - DOM element ID where video will be rendered\n */\nexport interface LoginOptions {\n  /** Stream Video API token */\n  token: string;\n  /** User ID for the current user */\n  userId: string;\n  /** Display name for the current user */\n  name: string;\n  /** Optional avatar URL for the current user */\n  imageURL?: string;\n  /** Stream Video API key */\n  apiKey: string;\n  /** ID of the HTML element where the video will be rendered */\n  magicDivId?: string;\n}\n\n/**\n * @interface CallOptions\n * @description Options for initiating a video call\n * @property {string} userId - ID of the user to call\n * @property {string} [type=default] - Type of call\n * @property {boolean} [ring=true] - Whether to send ring notification\n */\nexport interface CallOptions {\n  /** User ID of the person to call */\n  userIds: string[];\n  /** Type of call, defaults to 'default' */\n  type?: string;\n  /** Whether to ring the other user, defaults to true */\n  ring?: boolean;\n}\n\n/**\n * @interface SuccessResponse\n * @description Standard response indicating operation success/failure\n * @property {boolean} success - Whether the operation succeeded\n */\nexport interface SuccessResponse {\n  /** Whether the operation was successful */\n  success: boolean;\n}\n\n/**\n * @interface CallEvent\n * @description Event emitted when call state changes\n * @property {string} callId - Unique identifier of the call\n * @property {string} state - Current state of the call (joined, left, ringing, etc)\n */\nexport interface CallEvent {\n  /** ID of the call */\n  callId: string;\n  /** Current state of the call */\n  state: string;\n  /** User ID of the participant in the call who triggered the event */\n  userId?: string\n  /** Reason for the call state change */\n  reason?: string;\n}\n\nexport interface CameraEnabledResponse {\n  enabled: boolean;\n}\n\n/**\n * @interface StreamCallPlugin\n * @description Capacitor plugin for Stream Video calling functionality\n */\nexport interface StreamCallPlugin {\n  /**\n   * Login to Stream Video service\n   * @param {LoginOptions} options - Login configuration\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.login({\n   *   token: 'your-token',\n   *   userId: 'user-123',\n   *   name: 'John Doe',\n   *   apiKey: 'your-api-key'\n   * });\n   */\n  login(options: LoginOptions): Promise<SuccessResponse>;\n\n  /**\n   * Logout from Stream Video service\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.logout();\n   */\n  logout(): Promise<SuccessResponse>;\n\n  /**\n   * Initiate a call to another user\n   * @param {CallOptions} options - Call configuration\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.call({\n   *   userId: 'user-456',\n   *   type: 'video',\n   *   ring: true\n   * });\n   */\n  call(options: CallOptions): Promise<SuccessResponse>;\n\n  /**\n   * End the current call\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.endCall();\n   */\n  endCall(): Promise<SuccessResponse>;\n\n  /**\n   * Enable or disable microphone\n   * @param {{ enabled: boolean }} options - Microphone state\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.setMicrophoneEnabled({ enabled: false });\n   */\n  setMicrophoneEnabled(options: { enabled: boolean }): Promise<SuccessResponse>;\n\n  /**\n   * Enable or disable camera\n   * @param {{ enabled: boolean }} options - Camera state\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.setCameraEnabled({ enabled: false });\n   */\n  setCameraEnabled(options: { enabled: boolean }): Promise<SuccessResponse>;\n\n  /**\n   * Add listener for call events\n   * @param {'callEvent'} eventName - Name of the event to listen for\n   * @param {(event: CallEvent) => void} listenerFunc - Callback function\n   * @returns {Promise<{ remove: () => Promise<void> }>} Function to remove listener\n   * @example\n   * const listener = await StreamCall.addListener('callEvent', (event) => {\n   *   console.log(`Call ${event.callId} is now ${event.state}`);\n   * });\n   */\n  addListener(\n    eventName: 'callEvent',\n    listenerFunc: (event: CallEvent) => void,\n  ): Promise<{ remove: () => Promise<void> }>;\n\n  /**\n   * Remove all event listeners\n   * @returns {Promise<void>}\n   * @example\n   * await StreamCall.removeAllListeners();\n   */\n  removeAllListeners(): Promise<void>;\n\n  /**\n   * Accept an incoming call\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.acceptCall();\n   */\n  acceptCall(): Promise<SuccessResponse>;\n\n  /**\n   * Reject an incoming call\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.rejectCall();\n   */\n  rejectCall(): Promise<SuccessResponse>;\n  isCameraEnabled(): Promise<CameraEnabledResponse>;\n}\n"]}

package/dist/esm/web.d.ts

@@ -11,11 +11,21 @@ export declare class StreamCallWeb extends WebPlugin implements StreamCallPlugin
     private audioBindings;
     private participantJoinedListener?;
     private participantLeftListener?;
+    private participantResponses;
+    private callMembersExpected;
     private setupCallRingListener;
+    private setupCallEventListeners;
     private ringCallback;
     private setupParticipantListener;
     private setupParticipantVideo;
     private setupParticipantAudio;
+    private callSessionStartedCallback;
+    private callRejectedCallback;
+    private callAcceptedCallback;
+    private callMissedCallback;
+    private callStates;
+    private checkCallTimeout;
+    private checkAllParticipantsResponded;
     private cleanupCall;
     login(options: LoginOptions): Promise<SuccessResponse>;
     logout(): Promise<SuccessResponse>;

package/dist/esm/web.js

@@ -5,6 +5,8 @@ export class StreamCallWeb extends WebPlugin {
         super(...arguments);
         this.videoBindings = new Map();
         this.audioBindings = new Map();
+        this.participantResponses = new Map();
+        this.callMembersExpected = new Map();
         this.ringCallback = (event) => {
             var _a, _b;
             console.log('Call ringing', event, this.currentCall);
@@ -12,7 +14,10 @@ export class StreamCallWeb extends WebPlugin {
             if (!this.currentCall) {
                 console.log('Creating new call', event.call.id);
                 this.currentCall = (_a = this.client) === null || _a === void 0 ? void 0 : _a.call(event.call.type, event.call.id);
+                // this.currentActiveCallId = this.currentCall?.cid;
                 this.notifyListeners('callEvent', { callId: event.call.id, state: CallingState.RINGING });
+                // Clear previous responses when a new call starts
+                this.participantResponses.clear();
             }
             if (this.currentCall) {
                 console.log('Call found', this.currentCall.id);
@@ -21,6 +26,7 @@ export class StreamCallWeb extends WebPlugin {
                     console.log('Call state', s);
                     if (s === CallingState.JOINED) {
                         this.setupParticipantListener();
+                        this.setupCallEventListeners();
                     }
                     else if (s === CallingState.LEFT || s === CallingState.RECONNECTING_FAILED) {
                         this.cleanupCall();
@@ -34,11 +40,110 @@ export class StreamCallWeb extends WebPlugin {
                 });
             }
         };
+        this.callSessionStartedCallback = (event) => {
+            console.log('Call created (session started)', event);
+            if (event.call && event.call.session && event.call.session.participants) {
+                // Store the number of expected participants for this call
+                const callCid = event.call.cid;
+                const memberCount = event.call.session.participants.length;
+                console.log(`Call ${callCid} created with ${memberCount} members`);
+                this.callMembersExpected.set(callCid, memberCount);
+                // Store call members in callStates
+                this.callStates.set(callCid, {
+                    members: event.call.session.participants.map(p => { var _a; return ({ user_id: ((_a = p.user) === null || _a === void 0 ? void 0 : _a.id) || '' }); }),
+                    participantResponses: new Map(),
+                    expectedMemberCount: memberCount,
+                    createdAt: new Date(),
+                });
+                // Start a timeout task that runs every second
+                const timeoutTask = setInterval(() => this.checkCallTimeout(callCid), 1000);
+                // Update the callState with the timeout task
+                const callState = this.callStates.get(callCid);
+                if (callState) {
+                    callState.timer = timeoutTask;
+                    this.callStates.set(callCid, callState);
+                }
+            }
+        };
+        this.callRejectedCallback = (event) => {
+            console.log('Call rejected', event);
+            if (event.user && event.user.id) {
+                this.participantResponses.set(event.user.id, 'rejected');
+                // Update the combined callStates map
+                const callState = this.callStates.get(event.call_cid);
+                if (callState) {
+                    callState.participantResponses.set(event.user.id, 'rejected');
+                    this.callStates.set(event.call_cid, callState);
+                }
+                this.notifyListeners('callEvent', {
+                    callId: event.call_cid,
+                    state: 'rejected',
+                    userId: event.user.id
+                });
+                this.checkAllParticipantsResponded();
+            }
+        };
+        this.callAcceptedCallback = (event) => {
+            console.log('Call accepted', event);
+            if (event.user && event.user.id) {
+                this.participantResponses.set(event.user.id, 'accepted');
+                // Update the combined callStates map
+                const callState = this.callStates.get(event.call_cid);
+                if (callState) {
+                    callState.participantResponses.set(event.user.id, 'accepted');
+                    // If someone accepted, clear the timer as we don't need to check anymore
+                    if (callState.timer) {
+                        clearInterval(callState.timer);
+                        callState.timer = undefined;
+                    }
+                    this.callStates.set(event.call_cid, callState);
+                }
+                this.notifyListeners('callEvent', {
+                    callId: event.call_cid,
+                    state: 'accepted',
+                    userId: event.user.id
+                });
+            }
+        };
+        this.callMissedCallback = (event) => {
+            console.log('Call missed', event);
+            if (event.user && event.user.id) {
+                this.participantResponses.set(event.user.id, 'missed');
+                // Update the combined callStates map
+                const callState = this.callStates.get(event.call_cid);
+                if (callState) {
+                    callState.participantResponses.set(event.user.id, 'missed');
+                    this.callStates.set(event.call_cid, callState);
+                }
+                this.notifyListeners('callEvent', {
+                    callId: event.call_cid,
+                    state: 'missed',
+                    userId: event.user.id
+                });
+                this.checkAllParticipantsResponded();
+            }
+        };
+        // Add a combined map for call states, mirroring the iOS implementation
+        this.callStates = new Map();
     }
+    //  private currentActiveCallId?: string;
     setupCallRingListener() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         (_a = this.client) === null || _a === void 0 ? void 0 : _a.off('call.ring', this.ringCallback);
-        (_b = this.client) === null || _b === void 0 ? void 0 : _b.on('call.ring', this.ringCallback);
+        (_b = this.client) === null || _b === void 0 ? void 0 : _b.off('call.session_started', this.callSessionStartedCallback);
+        (_c = this.client) === null || _c === void 0 ? void 0 : _c.on('call.ring', this.ringCallback);
+        (_d = this.client) === null || _d === void 0 ? void 0 : _d.on('call.session_started', this.callSessionStartedCallback);
+    }
+    setupCallEventListeners() {
+        var _a, _b, _c, _d, _e, _f;
+        // Clear previous listeners if any
+        (_a = this.client) === null || _a === void 0 ? void 0 : _a.off('call.rejected', this.callRejectedCallback);
+        (_b = this.client) === null || _b === void 0 ? void 0 : _b.off('call.accepted', this.callAcceptedCallback);
+        (_c = this.client) === null || _c === void 0 ? void 0 : _c.off('call.missed', this.callMissedCallback);
+        // Register event listeners
+        (_d = this.client) === null || _d === void 0 ? void 0 : _d.on('call.rejected', this.callRejectedCallback);
+        (_e = this.client) === null || _e === void 0 ? void 0 : _e.on('call.accepted', this.callAcceptedCallback);
+        (_f = this.client) === null || _f === void 0 ? void 0 : _f.on('call.missed', this.callMissedCallback);
     }
     setupParticipantListener() {
         // Subscribe to participant changes
@@ -55,6 +160,7 @@ export class StreamCallWeb extends WebPlugin {
             }
         };
         this.participantLeftListener = (event) => {
+            var _a, _b;
             if (this.magicDivId && event.participant) {
                 const videoId = `video-${event.participant.sessionId}`;
                 const audioId = `audio-${event.participant.sessionId}`;
@@ -70,10 +176,9 @@ export class StreamCallWeb extends WebPlugin {
                     if (tracks) {
                         tracks.getTracks().forEach((track) => {
                             track.stop();
-                            track.enabled = false;
                         });
-                        videoEl.srcObject = null;
                     }
+                    videoEl.srcObject = null;
                     videoEl.remove();
                 }
                 // Remove audio element
@@ -88,13 +193,44 @@ export class StreamCallWeb extends WebPlugin {
                     if (tracks) {
                         tracks.getTracks().forEach((track) => {
                             track.stop();
-                            track.enabled = false;
                         });
-                        audioEl.srcObject = null;
                     }
+                    audioEl.srcObject = null;
                     audioEl.remove();
                 }
             }
+            // Check if we're the only participant left in the call
+            if (this.currentCall && this.currentCall.state.session) {
+                // Get the remaining participants count (we need to subtract 1 as we haven't been removed from the list yet)
+                const remainingParticipants = this.currentCall.state.session.participants.length - 1;
+                // If we're the only one left, end the call
+                if (remainingParticipants <= 1) {
+                    console.log(`We are left solo in a call. Ending. cID: ${this.currentCall.cid}`);
+                    // End the call
+                    this.currentCall.leave();
+                    // Clean up resources
+                    const callCid = this.currentCall.cid;
+                    // Invalidate and remove timer
+                    const callState = (_a = this.callStates) === null || _a === void 0 ? void 0 : _a.get(callCid);
+                    if (callState === null || callState === void 0 ? void 0 : callState.timer) {
+                        clearInterval(callState.timer);
+                    }
+                    // Remove from callStates
+                    (_b = this.callStates) === null || _b === void 0 ? void 0 : _b.delete(callCid);
+                    // Reset the current call
+                    this.currentCall = undefined;
+                    // this.currentActiveCallId = undefined;
+                    // Clean up
+                    this.cleanupCall();
+                    console.log(`Cleaned up resources for ended call: ${callCid}`);
+                    // Notify that the call has ended
+                    this.notifyListeners('callEvent', {
+                        callId: callCid,
+                        state: 'left',
+                        reason: 'participant_left'
+                    });
+                }
+            }
         };
         this.currentCall.on('participantJoined', this.participantJoinedListener);
         this.currentCall.on('participantLeft', this.participantLeftListener);
@@ -139,6 +275,101 @@ export class StreamCallWeb extends WebPlugin {
                 this.audioBindings.set(id, unbind);
         }
     }
+    checkCallTimeout(callCid) {
+        const callState = this.callStates.get(callCid);
+        if (!callState)
+            return;
+        // Calculate time elapsed since call creation
+        const now = new Date();
+        const elapsedSeconds = (now.getTime() - callState.createdAt.getTime()) / 1000;
+        // Check if 30 seconds have passed
+        if (elapsedSeconds >= 30) {
+            console.log(`Call ${callCid} has timed out after ${elapsedSeconds} seconds`);
+            // Check if anyone has accepted
+            const hasAccepted = Array.from(callState.participantResponses.values())
+                .some(response => response === 'accepted');
+            if (!hasAccepted) {
+                console.log(`No one accepted call ${callCid}, marking all non-responders as missed`);
+                // Mark all members who haven't responded as "missed"
+                callState.members.forEach(member => {
+                    if (!callState.participantResponses.has(member.user_id)) {
+                        callState.participantResponses.set(member.user_id, 'missed');
+                        this.participantResponses.set(member.user_id, 'missed');
+                        this.notifyListeners('callEvent', {
+                            callId: callCid,
+                            state: 'missed',
+                            userId: member.user_id
+                        });
+                    }
+                });
+                // End the call
+                if (this.currentCall && this.currentCall.cid === callCid) {
+                    this.currentCall.leave();
+                }
+                // Clear the timeout task
+                if (callState.timer) {
+                    clearInterval(callState.timer);
+                    callState.timer = undefined;
+                }
+                // Remove from callStates
+                this.callStates.delete(callCid);
+                // Clean up
+                this.cleanupCall();
+                // Notify that the call has ended
+                this.notifyListeners('callEvent', {
+                    callId: callCid,
+                    state: 'ended',
+                    reason: 'timeout'
+                });
+            }
+        }
+    }
+    checkAllParticipantsResponded() {
+        if (!this.currentCall)
+            return;
+        const callCid = this.currentCall.cid;
+        const totalParticipants = this.callMembersExpected.get(callCid);
+        if (!totalParticipants) {
+            console.log(`No expected participant count found for call: ${callCid}`);
+            return;
+        }
+        console.log(`Total expected participants: ${totalParticipants}`);
+        // Count rejections and misses
+        let rejectedOrMissedCount = 0;
+        this.participantResponses.forEach(response => {
+            if (response === 'rejected' || response === 'missed') {
+                rejectedOrMissedCount++;
+            }
+        });
+        console.log(`Participants responded: ${this.participantResponses.size}/${totalParticipants}`);
+        console.log(`Rejected or missed: ${rejectedOrMissedCount}`);
+        const allResponded = this.participantResponses.size >= totalParticipants;
+        const allRejectedOrMissed = allResponded &&
+            Array.from(this.participantResponses.values()).every(response => response === 'rejected' || response === 'missed');
+        // If all participants have rejected or missed the call
+        if (allResponded && allRejectedOrMissed) {
+            console.log('All participants have rejected or missed the call');
+            // End the call
+            this.currentCall.leave();
+            // Clean up the timer if exists in callStates
+            const callState = this.callStates.get(callCid);
+            if (callState === null || callState === void 0 ? void 0 : callState.timer) {
+                clearInterval(callState.timer);
+            }
+            // Remove from callStates
+            this.callStates.delete(callCid);
+            // Clear the responses
+            this.participantResponses.clear();
+            // Clean up
+            this.cleanupCall();
+            // Notify that the call has ended
+            this.notifyListeners('callEvent', {
+                callId: callCid,
+                state: 'ended',
+                reason: 'all_rejected_or_missed'
+            });
+        }
+    }
     cleanupCall() {
         var _a;
         // First cleanup the call listeners
@@ -240,10 +471,14 @@ export class StreamCallWeb extends WebPlugin {
         }
         const call = this.client.call(options.type || 'default', crypto.randomUUID());
         const members = options.userIds.map((userId) => ({ user_id: userId }));
-        if (this.client.streamClient.userID && options.userIds.includes(this.client.streamClient.userID)) {
+        if (this.client.streamClient.userID && !options.userIds.includes(this.client.streamClient.userID)) {
             members.push({ user_id: this.client.streamClient.userID });
         }
         await call.getOrCreate({ data: { members } });
+        // Store the expected member count for this call
+        // -1, because we don't count the caller themselves
+        this.callMembersExpected.set(call.cid, members.length);
+        console.log(`Setting expected members for call ${call.cid}: ${members.length}`);
         this.currentCall = call;
         if (options.ring) {
             this.outgoingCall = call.cid;
@@ -312,7 +547,7 @@ export class StreamCallWeb extends WebPlugin {
         console.log('Rejecting call', this.incomingCall);
         const call = this.client.call(this.incomingCall.type, this.incomingCall.id);
         console.log('Leaving call', call);
-        await call.leave();
+        await call.reject();
         this.incomingCall = undefined;
         console.log('Rejected call', call);
         this.notifyListeners('callEvent', { callId: call.id, state: CallingState.LEFT });