@capgo/capacitor-stream-call 0.0.2 → 0.0.3

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

@@ -6,7 +6,6 @@ import android.app.Application
 import android.app.KeyguardManager
 import android.content.Context
 import android.graphics.Color
-import android.os.Build
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
@@ -25,7 +24,6 @@ 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.RingingState
 import io.getstream.video.android.core.StreamVideo
 import io.getstream.video.android.core.StreamVideoBuilder
 import io.getstream.video.android.core.model.RejectReason
@@ -36,7 +34,9 @@ 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.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
@@ -86,7 +86,7 @@ public class StreamCallPlugin : Plugin() {
         ringtonePlayer = RingtonePlayer(
             this.activity.application,
             cancelIncomingCallService = {
-                var streamVideoClient = this.streamVideoClient
+                val streamVideoClient = this.streamVideoClient
                 if (streamVideoClient == null) {
                     android.util.Log.d("StreamCallPlugin", "StreamVideo SDK client is null, no incoming call notification can be constructed")
                     return@RingtonePlayer
@@ -116,7 +116,7 @@ public class StreamCallPlugin : Plugin() {
                     val defaultConfig = defaultMethod.invoke(defaultInstance)
 
                     val app = this.activity.application
-                    val cId = streamVideoClient?.state?.ringingCall?.value?.cid?.let { StreamCallId.fromCallCid(it) }
+                    val cId = streamVideoClient.state.ringingCall.value?.cid?.let { StreamCallId.fromCallCid(it) }
                     if (app == null || cId == null || defaultConfig == null) {
                         android.util.Log.e("StreamCallPlugin", "Some required parameters are null - app: ${app == null}, cId: ${cId == null}, defaultConfig: ${defaultConfig == null}")
                     }
@@ -136,6 +136,7 @@ public class StreamCallPlugin : Plugin() {
         activity?.intent?.let { handleOnNewIntent(it) }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     override fun handleOnNewIntent(intent: android.content.Intent) {
         super.handleOnNewIntent(intent)
         
@@ -197,21 +198,26 @@ public class StreamCallPlugin : Plugin() {
         android.util.Log.d("StreamCallPlugin", "New Intent - Extras: $extras")
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     private fun declineCall(call: Call) {
         kotlinx.coroutines.GlobalScope.launch {
-            call.reject(RejectReason.Decline)
-            
-            // Stop ringtone
-            ringtonePlayer?.stopRinging()
-            
-            // Notify that call has ended
-            val data = JSObject().apply {
-                put("callId", call.id)
-                put("state", "rejected")
+            try {
+                call.leave()
+                
+                // Stop ringtone
+                ringtonePlayer?.stopRinging()
+                
+                // Notify that call has ended
+                val data = JSObject().apply {
+                    put("callId", call.id)
+                    put("state", "rejected")
+                }
+                notifyListeners("callEvent", data)
+                
+                hideIncomingCall()
+            } catch (e: Exception) {
+                android.util.Log.e("StreamCallPlugin", "Error declining call: ${e.message}")
             }
-            notifyListeners("callEvent", data)
-            
-            hideIncomingCall()
         }
     }
 
@@ -366,6 +372,7 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     public fun initializeStreamVideo(passedContext: Context? = null, passedApplication: Application? = null) {
         android.util.Log.v("StreamCallPlugin", "Attempting to initialize streamVideo")
         if (state == State.INITIALIZING) {
@@ -505,18 +512,14 @@ public class StreamCallPlugin : Plugin() {
                         // Get the ActivityManager
                         val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as android.app.ActivityManager
                         // Remove the task
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-                            val tasks = activityManager.appTasks
-                            tasks.forEach { task ->
-                                task.finishAndRemoveTask()
-                            }
+                        val tasks = activityManager.appTasks
+                        tasks.forEach { task ->
+                            task.finishAndRemoveTask()
                         }
                         // Finish the activity
                         act.finish()
                         // Remove from recents
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-                            act.finishAndRemoveTask()
-                        }
+                        act.finishAndRemoveTask()
                         // Give a small delay for cleanup
                         Handler(Looper.getMainLooper()).postDelayed({
                             // Kill the process
@@ -542,6 +545,7 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     private fun registerEventHandlers() {
         // Subscribe to call events
         streamVideoClient?.let { client ->
@@ -559,6 +563,10 @@ public class StreamCallPlugin : Plugin() {
                                 )
                             }
                             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)
@@ -577,6 +585,10 @@ public class StreamCallPlugin : Plugin() {
                                 )
                             }
                             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)
@@ -707,9 +719,9 @@ public class StreamCallPlugin : Plugin() {
         })
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     private fun acceptCall(call: Call) {
         kotlinx.coroutines.GlobalScope.launch {
-            android.util.Log.i("StreamCallPlugin", "Attempting to accept call ${call.id}")
             try {
                 // Stop ringtone
                 ringtonePlayer?.stopRinging()
@@ -720,8 +732,8 @@ public class StreamCallPlugin : Plugin() {
                     incomingCallView?.isVisible = false
                 }
 
-                // Accept the call
-                call.accept()
+                // Join the call without affecting others
+                call.join()
 
                 // Notify that call has started
                 val data = JSObject().apply {
@@ -755,6 +767,7 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     @PluginMethod
     fun setMicrophoneEnabled(call: PluginCall) {
         val enabled = call.getBoolean("enabled") ?: run {
@@ -785,6 +798,37 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
+    @PluginMethod
+    fun isCameraEnabled(call: PluginCall) {
+        try {
+            val activeCall = streamVideoClient?.state?.activeCall
+            if (activeCall == null) {
+                call.reject("No active call")
+                return
+            }
+
+            kotlinx.coroutines.GlobalScope.launch {
+                try {
+                    val enabled = activeCall.value?.camera?.isEnabled?.value
+                    if (enabled == null) {
+                        call.reject("Cannot figure out if camera is enabled or not")
+                        return@launch
+                    }
+                    call.resolve(JSObject().apply {
+                        put("enabled", enabled)
+                    })
+                } catch (e: Exception) {
+                    android.util.Log.e("StreamCallPlugin", "Error checking the camera status: ${e.message}")
+                    call.reject("Failed to check if camera is enabled: ${e.message}")
+                }
+            }
+        } catch (e: Exception) {
+            call.reject("StreamVideo not initialized")
+        }
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
     @PluginMethod
     fun setCameraEnabled(call: PluginCall) {
         val enabled = call.getBoolean("enabled") ?: run {
@@ -815,7 +859,7 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
-    suspend fun endCallRaw(call: Call) {
+    private suspend fun endCallRaw(call: Call) {
         val callId = call.id
         android.util.Log.d("StreamCallPlugin", "Attempting to end call $callId")
         call.leave()
@@ -844,7 +888,7 @@ public class StreamCallPlugin : Plugin() {
                 }
             }
 
-            var savedCapacitorActivity = savedActivity
+            val savedCapacitorActivity = savedActivity
             if (savedCapacitorActivity != null) {
 
                 if (savedActivityPaused) {
@@ -880,9 +924,10 @@ public class StreamCallPlugin : Plugin() {
         notifyListeners("callEvent", data)
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     private fun transEndCallRaw(call: Call) {
         val callId = call.id
-        var savedCapacitorActivity = savedActivity
+        val savedCapacitorActivity = savedActivity
         if (savedCapacitorActivity == null) {
             android.util.Log.d("StreamCallPlugin", "Cannot perform transEndCallRaw for call $callId. savedCapacitorActivity is null")
             return
@@ -911,6 +956,7 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     @PluginMethod
     fun endCall(call: PluginCall) {
         try {
@@ -937,11 +983,12 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     @PluginMethod
     fun call(call: PluginCall) {
-        val userId = call.getString("userId")
-        if (userId == null) {
-            call.reject("Missing required parameter: userId")
+        val userIds = call.getArray("userIds")?.toList<String>()
+        if (userIds.isNullOrEmpty()) {
+            call.reject("Missing required parameter: userIds (array of user IDs)")
             return
         }
 
@@ -964,7 +1011,7 @@ public class StreamCallPlugin : Plugin() {
             android.util.Log.d("StreamCallPlugin", "Creating call:")
             android.util.Log.d("StreamCallPlugin", "- Call ID: $callId")
             android.util.Log.d("StreamCallPlugin", "- Call Type: $callType")
-            android.util.Log.d("StreamCallPlugin", "- User ID: $userId")
+            android.util.Log.d("StreamCallPlugin", "- Users: $userIds")
             android.util.Log.d("StreamCallPlugin", "- Should Ring: $shouldRing")
 
             // Create and join call in a coroutine
@@ -973,18 +1020,66 @@ public class StreamCallPlugin : Plugin() {
                     // Create the call object
                     val streamCall = streamVideoClient?.call(type = callType, id = callId)
 
-                    android.util.Log.d("StreamCallPlugin", "Creating call with member...")
-                    // Create the call with the member
+                    // 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)
+                            }
+                        }
+                    }
+
+                    android.util.Log.d("StreamCallPlugin", "Creating call with members...")
+                    // Create the call with all members
                     streamCall?.create(
-                        memberIds = listOf(userId, selfUserId),
+                        memberIds = userIds + selfUserId,
                         custom = emptyMap(),
                         ring = shouldRing
                     )
 
-//                    streamCall?.let {
-//                        this@StreamCallPlugin.streamVideoClient?.state?.setActiveCall(it)
-//                    }
-
                     android.util.Log.d("StreamCallPlugin", "Setting overlay visible for outgoing call $callId")
                     // Show overlay view
                     activity?.runOnUiThread {
@@ -1011,4 +1106,42 @@ public class StreamCallPlugin : Plugin() {
             call.reject("Failed to make call: ${e.message}")
         }
     }
+
+    @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" }
+                
+                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
+                    }
+                    
+                    val data = JSObject().apply {
+                        put("callId", streamCall.id)
+                        put("state", "ended")
+                        put("reason", "all_rejected_or_missed")
+                    }
+                    notifyListeners("callEvent", data)
+                }
+            } catch (e: Exception) {
+                android.util.Log.e("StreamCallPlugin", "Error checking participant responses: ${e.message}")
+            }
+        }
+    }
 }

package/dist/docs.json

@@ -281,6 +281,18 @@
           "SuccessResponse"
         ],
         "slug": "rejectcall"
+      },
+      {
+        "name": "isCameraEnabled",
+        "signature": "() => Promise<CameraEnabledResponse>",
+        "parameters": [],
+        "returns": "Promise<CameraEnabledResponse>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "CameraEnabledResponse"
+        ],
+        "slug": "iscameraenabled"
       }
     ],
     "properties": []
@@ -351,18 +363,6 @@
         {
           "text": "{string} [magicDivId] - DOM element ID where video will be rendered",
           "name": "property"
-        },
-        {
-          "text": "{Object} [refreshToken] - Token refresh configuration",
-          "name": "property"
-        },
-        {
-          "text": "{string} refreshToken.url - Endpoint URL for token refresh",
-          "name": "property"
-        },
-        {
-          "text": "{Record<string, string>} [refreshToken.headers] - Custom headers for refresh request",
-          "name": "property"
         }
       ],
       "methods": [],
@@ -408,15 +408,6 @@
           "docs": "ID of the HTML element where the video will be rendered",
           "complexTypes": [],
           "type": "string | undefined"
-        },
-        {
-          "name": "refreshToken",
-          "tags": [],
-          "docs": "Configuration for token refresh",
-          "complexTypes": [
-            "Record"
-          ],
-          "type": "{ url: string; headers?: Record<string, string> | undefined; } | undefined"
         }
       ]
     },
@@ -449,11 +440,11 @@
       "methods": [],
       "properties": [
         {
-          "name": "userId",
+          "name": "userIds",
           "tags": [],
           "docs": "User ID of the person to call",
           "complexTypes": [],
-          "type": "string"
+          "type": "string[]"
         },
         {
           "name": "type",
@@ -508,26 +499,34 @@
           "docs": "Current state of the call",
           "complexTypes": [],
           "type": "string"
+        },
+        {
+          "name": "userId",
+          "tags": [],
+          "docs": "User ID of the participant in the call who triggered the event",
+          "complexTypes": [],
+          "type": "string | undefined"
         }
       ]
-    }
-  ],
-  "enums": [],
-  "typeAliases": [
+    },
     {
-      "name": "Record",
-      "slug": "record",
-      "docs": "Construct a type with a set of properties K of type T",
-      "types": [
-        {
-          "text": "{\r\n    [P in K]: T;\r\n}",
-          "complexTypes": [
-            "K",
-            "T"
-          ]
+      "name": "CameraEnabledResponse",
+      "slug": "cameraenabledresponse",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "enabled",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
         }
       ]
     }
   ],
+  "enums": [],
+  "typeAliases": [],
   "pluginConfigs": []
 }

package/dist/esm/definitions.d.ts

@@ -7,9 +7,6 @@
  * @property {string} [imageURL] - Avatar URL for the current user
  * @property {string} apiKey - Stream Video API key for your application
  * @property {string} [magicDivId] - DOM element ID where video will be rendered
- * @property {Object} [refreshToken] - Token refresh configuration
- * @property {string} refreshToken.url - Endpoint URL for token refresh
- * @property {Record<string, string>} [refreshToken.headers] - Custom headers for refresh request
  */
 export interface LoginOptions {
     /** Stream Video API token */
@@ -24,13 +21,6 @@ export interface LoginOptions {
     apiKey: string;
     /** ID of the HTML element where the video will be rendered */
     magicDivId?: string;
-    /** Configuration for token refresh */
-    refreshToken?: {
-        /** URL to call for refreshing the token */
-        url: string;
-        /** Optional headers to include in the refresh request */
-        headers?: Record<string, string>;
-    };
 }
 /**
  * @interface CallOptions
@@ -41,7 +31,7 @@ export interface LoginOptions {
  */
 export interface CallOptions {
     /** User ID of the person to call */
-    userId: string;
+    userIds: string[];
     /** Type of call, defaults to 'default' */
     type?: string;
     /** Whether to ring the other user, defaults to true */
@@ -67,6 +57,11 @@ export interface CallEvent {
     callId: string;
     /** Current state of the call */
     state: string;
+    /** User ID of the participant in the call who triggered the event */
+    userId?: string;
+}
+export interface CameraEnabledResponse {
+    enabled: boolean;
 }
 /**
  * @interface StreamCallPlugin
@@ -166,4 +161,5 @@ export interface StreamCallPlugin {
      * await StreamCall.rejectCall();
      */
     rejectCall(): Promise<SuccessResponse>;
+    isCameraEnabled(): Promise<CameraEnabledResponse>;
 }

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 * @property {Object} [refreshToken] - Token refresh configuration\n * @property {string} refreshToken.url - Endpoint URL for token refresh\n * @property {Record<string, string>} [refreshToken.headers] - Custom headers for refresh request\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  /** Configuration for token refresh */\n  refreshToken?: {\n    /** URL to call for refreshing the token */\n    url: string;\n    /** Optional headers to include in the refresh request */\n    headers?: Record<string, string>;\n  };\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  userId: 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}\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}\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}\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

@@ -1,5 +1,5 @@
 import { WebPlugin } from '@capacitor/core';
-import type { CallOptions, StreamCallPlugin, SuccessResponse, LoginOptions } from './definitions';
+import type { CallOptions, StreamCallPlugin, SuccessResponse, LoginOptions, CameraEnabledResponse } from './definitions';
 export declare class StreamCallWeb extends WebPlugin implements StreamCallPlugin {
     private client?;
     private currentCall?;
@@ -29,4 +29,5 @@ export declare class StreamCallWeb extends WebPlugin implements StreamCallPlugin
     }): Promise<SuccessResponse>;
     acceptCall(): Promise<SuccessResponse>;
     rejectCall(): Promise<SuccessResponse>;
+    isCameraEnabled(): Promise<CameraEnabledResponse>;
 }

package/dist/esm/web.js

@@ -239,8 +239,8 @@ export class StreamCallWeb extends WebPlugin {
             throw new Error('Client not initialized - Please login first');
         }
         const call = this.client.call(options.type || 'default', crypto.randomUUID());
-        const members = [{ user_id: options.userId }];
-        if (this.client.streamClient.userID && options.userId !== this.client.streamClient.userID) {
+        const members = options.userIds.map((userId) => ({ user_id: 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 } });
@@ -319,5 +319,13 @@ export class StreamCallWeb extends WebPlugin {
         this.cleanupCall();
         return { success: true };
     }
+    async isCameraEnabled() {
+        if (!this.currentCall) {
+            console.log('No active call', this.currentCall);
+            throw new Error('No active call');
+        }
+        const enabled = await this.currentCall.camera.enabled;
+        return { enabled };
+    }
 }
 //# sourceMappingURL=web.js.map