@capgo/capacitor-stream-call 0.0.69 → 0.0.71

package/README.md

@@ -787,7 +787,7 @@ The JSON representation for <a href="#listvalue">`ListValue`</a> is JSON array.
 
 #### CallState
 
-<code>'idle' | 'ringing' | 'joining' | 'reconnecting' | 'joined' | 'leaving' | 'left' | 'created' | 'session_started' | 'rejected' | 'missed' | 'accepted' | 'ended' | 'unknown'</code>
+<code>'idle' | 'ringing' | 'joining' | 'reconnecting' | 'joined' | 'leaving' | 'left' | 'created' | 'session_started' | 'rejected' | 'missed' | 'accepted' | 'ended' | 'camera_enabled' | 'camera_disabled' | 'microphone_enabled' | 'microphone_disabled' | 'unknown'</code>
 
 
 ### Enums

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

@@ -3,6 +3,7 @@ package ee.forgr.capacitor.streamcall
 import TouchInterceptWrapper
 import android.Manifest
 import android.app.Activity
+import android.app.AlertDialog
 import android.app.Application
 import android.app.KeyguardManager
 import android.content.BroadcastReceiver
@@ -17,12 +18,12 @@ import android.os.Build
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.provider.Settings
 import android.view.View
 import android.view.ViewGroup
 import android.view.WindowManager
 import android.widget.FrameLayout
 import androidx.compose.foundation.layout.fillMaxSize
-
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
@@ -52,11 +53,9 @@ 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.CallSessionParticipantCountsUpdatedEvent
 import io.getstream.android.video.generated.models.CallSessionParticipantLeftEvent
 import io.getstream.android.video.generated.models.CallSessionStartedEvent
 import io.getstream.android.video.generated.models.VideoEvent
-import io.getstream.log.Priority
 import io.getstream.video.android.compose.theme.VideoTheme
 import io.getstream.video.android.compose.ui.components.call.activecall.CallContent
 import io.getstream.video.android.compose.ui.components.call.renderer.FloatingParticipantVideo
@@ -69,18 +68,13 @@ import io.getstream.video.android.core.GEO
 import io.getstream.video.android.core.RealtimeConnection
 import io.getstream.video.android.core.StreamVideo
 import io.getstream.video.android.core.StreamVideoBuilder
-import io.getstream.video.android.core.call.CallType
 import io.getstream.video.android.core.events.ParticipantLeftEvent
 import io.getstream.video.android.core.internal.InternalStreamVideoApi
-import io.getstream.video.android.core.logging.LoggingLevel
 import io.getstream.video.android.core.notifications.NotificationConfig
 import io.getstream.video.android.core.notifications.NotificationHandler
-import io.getstream.video.android.core.notifications.internal.service.CallServiceConfigRegistry
-import io.getstream.video.android.core.notifications.internal.service.DefaultCallConfigurations
 import io.getstream.video.android.core.sounds.RingingConfig
 import io.getstream.video.android.core.sounds.toSounds
 import io.getstream.video.android.model.Device
-import io.getstream.video.android.model.StreamCallId
 import io.getstream.video.android.model.User
 import io.getstream.video.android.model.streamCallId
 import kotlinx.coroutines.CoroutineScope
@@ -88,6 +82,7 @@ import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.tasks.await
+import androidx.core.net.toUri
 
 // 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
@@ -115,6 +110,18 @@ public class StreamCallPlugin : Plugin() {
     private var callFragment: StreamCallFragment? = null
     private var streamVideo: StreamVideo? = null
     private var touchInterceptWrapper: TouchInterceptWrapper? = null
+    
+    // Track permission request timing and attempts
+    private var permissionRequestStartTime: Long = 0
+    private var permissionAttemptCount: Int = 0
+    
+    // Store pending call information for permission handling
+    private var pendingCall: PluginCall? = null
+    private var pendingCallUserIds: List<String>? = null
+    private var pendingCallType: String? = null
+    private var pendingCallShouldRing: Boolean? = null
+    private var pendingCallTeam: String? = null
+    private var pendingAcceptCall: Call? = null // Store the actual call object for acceptance
 
     private enum class State {
         NOT_INITIALIZED,
@@ -137,6 +144,43 @@ public class StreamCallPlugin : Plugin() {
 
     override fun handleOnResume() {
         super.handleOnResume()
+        
+        android.util.Log.d("StreamCallPlugin", "handleOnResume: App resumed, checking permissions and pending operations")
+        android.util.Log.d("StreamCallPlugin", "handleOnResume: Have pendingCall: ${pendingCall != null}")
+        android.util.Log.d("StreamCallPlugin", "handleOnResume: Have pendingCallUserIds: ${pendingCallUserIds != null}")
+        android.util.Log.d("StreamCallPlugin", "handleOnResume: Have pendingAcceptCall: ${pendingAcceptCall != null}")
+        android.util.Log.d("StreamCallPlugin", "handleOnResume: Permission attempt count: $permissionAttemptCount")
+        
+        // Check if permissions were granted after returning from settings or permission dialog
+        if (checkPermissions()) {
+            android.util.Log.d("StreamCallPlugin", "handleOnResume: Permissions are now granted")
+            // Handle any pending calls that were waiting for permissions
+            handlePermissionGranted()
+        } else if (pendingCall != null || pendingAcceptCall != null) {
+            android.util.Log.d("StreamCallPlugin", "handleOnResume: Permissions still not granted, but have pending operations")
+            // If we have pending operations but permissions are still not granted,
+            // it means the permission dialog was dismissed without granting
+            // We should trigger our retry logic if we haven't exhausted attempts
+            if (permissionAttemptCount > 0) {
+                android.util.Log.d("StreamCallPlugin", "handleOnResume: Permission dialog was dismissed, treating as denial (attempt: $permissionAttemptCount)")
+                val timeSinceRequest = System.currentTimeMillis() - permissionRequestStartTime
+                handlePermissionDenied(timeSinceRequest)
+            } else {
+                android.util.Log.d("StreamCallPlugin", "handleOnResume: No permission attempts yet, starting permission request")
+                // If we have pending operations but no attempts yet, start the permission flow
+                if (pendingAcceptCall != null) {
+                    android.util.Log.d("StreamCallPlugin", "handleOnResume: Have active call waiting for permissions, requesting now")
+                    permissionAttemptCount = 0
+                    requestPermissions()
+                } else if (pendingCall != null && pendingCallUserIds != null) {
+                    android.util.Log.d("StreamCallPlugin", "handleOnResume: Have outgoing call waiting for permissions, requesting now")
+                    permissionAttemptCount = 0
+                    requestPermissions()
+                }
+            }
+        } else {
+            android.util.Log.d("StreamCallPlugin", "handleOnResume: No pending operations, nothing to handle")
+        }
     }
 
     override fun load() {
@@ -238,7 +282,7 @@ public class StreamCallPlugin : Plugin() {
                         android.util.Log.d("StreamCallPlugin", "  [$index] ${element.className}.${element.methodName}(${element.fileName}:${element.lineNumber})")
                     }
                     kotlinx.coroutines.GlobalScope.launch {
-                        internalAcceptCall(call)
+                        internalAcceptCall(call, requestPermissionsAfter = !checkPermissions())
                     }
                     bringAppToForeground()
                 } else {
@@ -634,7 +678,7 @@ public class StreamCallPlugin : Plugin() {
 
             val intent = android.content.Intent(android.content.Intent.ACTION_MAIN).apply {
                 addCategory(android.content.Intent.CATEGORY_HOME)
-                flags = android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK
             }
             context.startActivity(intent)
             android.util.Log.d("StreamCallPlugin", "Moving app to background using HOME intent")
@@ -824,7 +868,7 @@ public class StreamCallPlugin : Plugin() {
                         updateCallStatusAndNotify(event.callCid, "left")
                     }
 
-                    is ParticipantLeftEvent, is CallSessionParticipantLeftEvent, is CallSessionParticipantCountsUpdatedEvent -> {
+                    is ParticipantLeftEvent, is CallSessionParticipantLeftEvent -> {
                         val activeCall = streamVideoClient?.state?.activeCall?.value
 
                         val callId = when (event) {
@@ -834,9 +878,6 @@ public class StreamCallPlugin : Plugin() {
                             is CallSessionParticipantLeftEvent -> {
                                 event.callCid
                             }
-                            is CallSessionParticipantCountsUpdatedEvent -> {
-                                event.callCid
-                            }
 
                             else -> {
                                 throw RuntimeException("Unreachable code reached when getting callId")
@@ -889,6 +930,22 @@ public class StreamCallPlugin : Plugin() {
                         updateCallStatusAndNotify(call.cid, "joined")
                         // Make sure activity is visible on lock screen
                         changeActivityAsVisibleOnLockScreen(this@StreamCallPlugin.activity, true)
+                        
+                        // Listen to camera status changes
+                        kotlinx.coroutines.GlobalScope.launch {
+                            call.camera.isEnabled.collect { isEnabled ->
+                                android.util.Log.d("StreamCallPlugin", "Camera status changed for call ${call.id}: enabled=$isEnabled")
+                                updateCallStatusAndNotify(call.cid, if (isEnabled) "camera_enabled" else "camera_disabled")
+                            }
+                        }
+                        
+                        // Listen to microphone status changes
+                        kotlinx.coroutines.GlobalScope.launch {
+                            call.microphone.isEnabled.collect { isEnabled ->
+                                android.util.Log.d("StreamCallPlugin", "Microphone status changed for call ${call.id}: enabled=$isEnabled")
+                                updateCallStatusAndNotify(call.cid, if (isEnabled) "microphone_enabled" else "microphone_disabled")
+                            }
+                        }
                     } ?: run {
                         // Notify that call has ended using our helper
                         updateCallStatusAndNotify("", "left")
@@ -959,8 +1016,20 @@ public class StreamCallPlugin : Plugin() {
                 call.reject("Ringing call is null")
                 return
             }
+            
+            android.util.Log.d("StreamCallPlugin", "acceptCall: Accepting call immediately, will handle permissions after")
+            
+            // Accept call immediately regardless of permissions - time is critical!
             kotlinx.coroutines.GlobalScope.launch {
-                internalAcceptCall(streamVideoCall)
+                try {
+                    internalAcceptCall(streamVideoCall, requestPermissionsAfter = !checkPermissions())
+                    call.resolve(JSObject().apply {
+                        put("success", true)
+                    })
+                } catch (e: Exception) {
+                    android.util.Log.e("StreamCallPlugin", "Error accepting call", e)
+                    call.reject("Failed to accept call: ${e.message}")
+                }
             }
         } catch (t: Throwable) {
             android.util.Log.d("StreamCallPlugin", "JS -> acceptCall fail", t);
@@ -987,8 +1056,8 @@ public class StreamCallPlugin : Plugin() {
     }
 
     @OptIn(DelicateCoroutinesApi::class, InternalStreamVideoApi::class)
-    internal fun internalAcceptCall(call: Call) {
-        android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Entered for call: ${call.id}")
+    internal fun internalAcceptCall(call: Call, requestPermissionsAfter: Boolean = false) {
+        android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Entered for call: ${call.id}, requestPermissionsAfter: $requestPermissionsAfter")
 
         kotlinx.coroutines.GlobalScope.launch {
             try {
@@ -1001,26 +1070,8 @@ public class StreamCallPlugin : Plugin() {
                 }
                 android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Incoming call view hidden for call ${call.id}")
 
-                // Check and request permissions before joining the call
-                val permissionsGranted = checkPermissions()
-                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: checkPermissions result for call ${call.id}: $permissionsGranted")
-                if (!permissionsGranted) {
-                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Permissions not granted for call ${call.id}. Requesting permissions.")
-                    requestPermissions()
-                    // Do not proceed with joining until permissions are granted
-                    runOnMainThread {
-                        android.widget.Toast.makeText(
-                            context,
-                            "Permissions required for call. Please grant them.",
-                            android.widget.Toast.LENGTH_LONG
-                        ).show()
-                    }
-                    android.util.Log.w("StreamCallPlugin", "internalAcceptCall: Permissions not granted for call ${call.id}. Aborting accept process.")
-                    return@launch
-                }
-
-                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Permissions are granted for call ${call.id}. Proceeding to accept.")
-                // Join the call without affecting others
+                // Accept and join call immediately - don't wait for permissions!
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Accepting call immediately for ${call.id}")
                 call.accept()
                 android.util.Log.d("StreamCallPlugin", "internalAcceptCall: call.accept() completed for call ${call.id}")
                 call.join()
@@ -1039,10 +1090,15 @@ public class StreamCallPlugin : Plugin() {
                     android.util.Log.d("StreamCallPlugin", "internalAcceptCall: WebView background set to transparent for call ${call.id}")
                     bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
                     android.util.Log.d("StreamCallPlugin", "internalAcceptCall: WebView brought to front for call ${call.id}")
-                    // Reusing the initialization logic from call method
-                    call.microphone?.setEnabled(true)
-                    call.camera?.setEnabled(true)
-                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Microphone and camera enabled for call ${call.id}")
+                    
+                    // Enable camera/microphone based on permissions
+                    val hasPermissions = checkPermissions()
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Has permissions: $hasPermissions for call ${call.id}")
+                    
+                    call.microphone?.setEnabled(hasPermissions)
+                    call.camera?.setEnabled(hasPermissions)
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Microphone and camera set to $hasPermissions for call ${call.id}")
+                    
                     android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Setting CallContent with active call ${call.id}")
                     setOverlayContent(call)
                     android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Content set for overlayView for call ${call.id}")
@@ -1054,6 +1110,7 @@ public class StreamCallPlugin : Plugin() {
                     parent?.removeView(overlayView)
                     parent?.addView(overlayView, 0) // Add at index 0 to ensure it's behind other views
                     android.util.Log.d("StreamCallPlugin", "internalAcceptCall: OverlayView re-added to parent at index 0 for call ${call.id}")
+                    
                     // Add a small delay to ensure UI refresh
                     mainHandler.postDelayed({
                         android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Delayed UI check, overlay visible: ${overlayView?.isVisible} for call ${call.id}")
@@ -1075,6 +1132,19 @@ public class StreamCallPlugin : Plugin() {
                         }
                     }, 1000) // Increased delay to ensure all events are processed
                 }
+
+                // Request permissions after joining if needed
+                if (requestPermissionsAfter) {
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Requesting permissions after call acceptance for ${call.id}")
+                    runOnMainThread {
+                        // Store reference to the active call for enabling camera/mic later
+                        pendingAcceptCall = call
+                        android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Set pendingAcceptCall to ${call.id}, resetting attempt count")
+                        permissionAttemptCount = 0
+                        requestPermissions()
+                    }
+                }
+                
             } catch (e: Exception) {
                 android.util.Log.e("StreamCallPlugin", "internalAcceptCall: Error accepting call ${call.id}: ${e.message}", e)
                 runOnMainThread {
@@ -1100,61 +1170,481 @@ public class StreamCallPlugin : Plugin() {
         return allGranted
     }
 
-    // Function to request required permissions
-    private fun requestPermissions() {
-        android.util.Log.d("StreamCallPlugin", "requestPermissions: Requesting RECORD_AUDIO and CAMERA permissions.")
-        ActivityCompat.requestPermissions(
-            activity,
-            arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA),
-            1001 // Request code for permission result handling
-        )
-        android.util.Log.d("StreamCallPlugin", "requestPermissions: ActivityCompat.requestPermissions called.")
-    }
-
     // Override to handle permission results
     override fun handleRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
         super.handleRequestPermissionsResult(requestCode, permissions, grantResults)
-        android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Entered. RequestCode: $requestCode")
-        if (requestCode == 1001) {
-            android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Matched requestCode 1001.")
+        android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Entered. RequestCode: $requestCode, Attempt: $permissionAttemptCount")
+        android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Expected requestCode: 9001")
+        
+        if (requestCode == 9001) {
+            val responseTime = System.currentTimeMillis() - permissionRequestStartTime
+            android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Response time: ${responseTime}ms")
+            
             logPermissionResults(permissions, grantResults)
+            
             if (grantResults.isNotEmpty() && grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                 android.util.Log.i("StreamCallPlugin", "handleRequestPermissionsResult: All permissions GRANTED.")
-                // Permissions granted, can attempt to join the call again if needed
+                // Reset attempt count on success
+                permissionAttemptCount = 0
+                handlePermissionGranted()
+            } else {
+                android.util.Log.e("StreamCallPlugin", "handleRequestPermissionsResult: Permissions DENIED. Attempt: $permissionAttemptCount")
+                handlePermissionDenied(responseTime)
+            }
+        } else {
+            android.util.Log.w("StreamCallPlugin", "handleRequestPermissionsResult: Received unknown requestCode: $requestCode")
+        }
+    }
+
+    private fun logPermissionResults(permissions: Array<out String>, grantResults: IntArray) {
+        android.util.Log.d("StreamCallPlugin", "logPermissionResults: Logging permission results:")
+        for (i in permissions.indices) {
+            val permission = permissions[i]
+            val grantResult = if (grantResults.size > i) grantResults[i] else -999 // -999 for safety if arrays mismatch
+            val resultString = if (grantResult == PackageManager.PERMISSION_GRANTED) "GRANTED" else "DENIED ($grantResult)"
+            android.util.Log.d("StreamCallPlugin", "  Permission: $permission, Result: $resultString")
+        }
+    }
+
+    private fun handlePermissionGranted() {
+        android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Processing granted permissions")
+        
+        // Reset attempt count since permissions are now granted
+        permissionAttemptCount = 0
+        
+        // Determine what type of pending operation we have
+        val hasOutgoingCall = pendingCall != null && pendingCallUserIds != null
+        val hasActiveCallNeedingPermissions = pendingAcceptCall != null
+        
+        android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: hasOutgoingCall=$hasOutgoingCall, hasActiveCallNeedingPermissions=$hasActiveCallNeedingPermissions")
+        
+        when {
+            hasOutgoingCall -> {
+                // Outgoing call creation was waiting for permissions
+                android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Executing pending outgoing call with ${pendingCallUserIds?.size} users")
+                executePendingCall()
+            }
+            
+            hasActiveCallNeedingPermissions -> {
+                // Active call needing camera/microphone enabled 
+                val callToHandle = pendingAcceptCall!!
+                val activeCall = streamVideoClient?.state?.activeCall?.value
+                
+                android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Processing call ${callToHandle.id}")
+                android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Active call in state: ${activeCall?.id}")
+                
+                if (activeCall != null && activeCall.id == callToHandle.id) {
+                    // Call is already active - enable camera/microphone
+                    android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Enabling camera/microphone for active call ${callToHandle.id}")
+                    runOnMainThread {
+                        try {
+                            callToHandle.microphone?.setEnabled(true)
+                            callToHandle.camera?.setEnabled(true)
+                            android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Camera and microphone enabled for call ${callToHandle.id}")
+                            
+                            // Show success message
+                            android.widget.Toast.makeText(
+                                context,
+                                "Camera and microphone enabled",
+                                android.widget.Toast.LENGTH_SHORT
+                            ).show()
+                        } catch (e: Exception) {
+                            android.util.Log.e("StreamCallPlugin", "Error enabling camera/microphone", e)
+                        }
+                        clearPendingCall()
+                    }
+                } else if (pendingCall != null) {
+                    // Call not active yet - accept it (old flow, shouldn't happen with new flow)
+                    android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Accepting pending incoming call ${callToHandle.id}")
+                    kotlinx.coroutines.GlobalScope.launch {
+                        try {
+                            internalAcceptCall(callToHandle)
+                            pendingCall?.resolve(JSObject().apply {
+                                put("success", true)
+                            })
+                        } catch (e: Exception) {
+                            android.util.Log.e("StreamCallPlugin", "Error accepting call after permission grant", e)
+                            pendingCall?.reject("Failed to accept call: ${e.message}")
+                        } finally {
+                            clearPendingCall()
+                        }
+                    }
+                } else {
+                    // Just enable camera/mic for the stored call even if not currently active
+                    android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Enabling camera/microphone for stored call ${callToHandle.id}")
+                    runOnMainThread {
+                        try {
+                            callToHandle.microphone?.setEnabled(true)
+                            callToHandle.camera?.setEnabled(true)
+                            android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Camera and microphone enabled for stored call ${callToHandle.id}")
+                            
+                            android.widget.Toast.makeText(
+                                context,
+                                "Camera and microphone enabled",
+                                android.widget.Toast.LENGTH_SHORT
+                            ).show()
+                        } catch (e: Exception) {
+                            android.util.Log.e("StreamCallPlugin", "Error enabling camera/microphone for stored call", e)
+                        }
+                        clearPendingCall()
+                    }
+                }
+            }
+            
+            pendingCall != null -> {
+                // We have a pending call but unclear what type - fallback handling
+                android.util.Log.w("StreamCallPlugin", "handlePermissionGranted: Have pendingCall but unclear operation type")
+                android.util.Log.w("StreamCallPlugin", "  - pendingCallUserIds: ${pendingCallUserIds != null}")
+                android.util.Log.w("StreamCallPlugin", "  - pendingAcceptCall: ${pendingAcceptCall != null}")
+                
+                // Try fallback to current ringing call for acceptance
                 val ringingCall = streamVideoClient?.state?.ringingCall?.value
-                android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Ringing call object: ${ringingCall?.id}")
                 if (ringingCall != null) {
-                    android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Ringing call found (${ringingCall.id}). Re-attempting internalAcceptCall.")
+                    android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: Fallback - accepting current ringing call ${ringingCall.id}")
                     kotlinx.coroutines.GlobalScope.launch {
-                        internalAcceptCall(ringingCall)
+                        try {
+                            internalAcceptCall(ringingCall)
+                            pendingCall?.resolve(JSObject().apply {
+                                put("success", true)
+                            })
+                        } catch (e: Exception) {
+                            android.util.Log.e("StreamCallPlugin", "Error accepting fallback call after permission grant", e)
+                            pendingCall?.reject("Failed to accept call: ${e.message}")
+                        } finally {
+                            clearPendingCall()
+                        }
                     }
                 } else {
-                    android.util.Log.w("StreamCallPlugin", "handleRequestPermissionsResult: Permissions granted, but no ringing call found to accept.")
+                    android.util.Log.w("StreamCallPlugin", "handlePermissionGranted: No ringing call found for fallback")
+                    pendingCall?.reject("Unable to determine pending operation")
+                    clearPendingCall()
+                }
+            }
+            
+            else -> {
+                android.util.Log.d("StreamCallPlugin", "handlePermissionGranted: No pending operations to handle")
+            }
+        }
+    }
+
+    private fun handlePermissionDenied(responseTime: Long) {
+        android.util.Log.d("StreamCallPlugin", "handlePermissionDenied: Response time: ${responseTime}ms, Attempt: $permissionAttemptCount")
+        
+        // Check if the response was instant (< 500ms) indicating "don't ask again"
+        val instantDenial = responseTime < 500
+        android.util.Log.d("StreamCallPlugin", "handlePermissionDenied: Instant denial detected: $instantDenial")
+        
+        if (instantDenial) {
+            // If it's an instant denial (don't ask again), go straight to settings dialog
+            android.util.Log.d("StreamCallPlugin", "handlePermissionDenied: Instant denial, showing settings dialog")
+            showPermissionSettingsDialog()
+        } else if (permissionAttemptCount < 2) {
+            // Try asking again immediately if this is the first denial
+            android.util.Log.d("StreamCallPlugin", "handlePermissionDenied: First denial (attempt $permissionAttemptCount), asking again immediately")
+            requestPermissions() // This will increment the attempt count
+        } else {
+            // Second denial - show settings dialog (final ask)
+            android.util.Log.d("StreamCallPlugin", "handlePermissionDenied: Second denial (attempt $permissionAttemptCount), showing settings dialog (final ask)")
+            showPermissionSettingsDialog()
+        }
+    }
+
+    private fun executePendingCall() {
+        val call = pendingCall
+        val userIds = pendingCallUserIds
+        val callType = pendingCallType
+        val shouldRing = pendingCallShouldRing
+        val team = pendingCallTeam
+        
+        if (call != null && userIds != null && callType != null && shouldRing != null) {
+            android.util.Log.d("StreamCallPlugin", "executePendingCall: Executing call with ${userIds.size} users")
+            
+            // Clear pending call data
+            clearPendingCall()
+            
+            // Execute the call creation logic
+            createAndStartCall(call, userIds, callType, shouldRing, team)
+        } else {
+            android.util.Log.w("StreamCallPlugin", "executePendingCall: Missing pending call data")
+            call?.reject("Internal error: missing call parameters")
+            clearPendingCall()
+        }
+    }
+
+    private fun clearPendingCall() {
+        pendingCall = null
+        pendingCallUserIds = null
+        pendingCallType = null
+        pendingCallShouldRing = null
+        pendingCallTeam = null
+        pendingAcceptCall = null
+        permissionAttemptCount = 0 // Reset attempt count when clearing
+    }
+
+    @OptIn(DelicateCoroutinesApi::class, InternalStreamVideoApi::class)
+    private fun createAndStartCall(call: PluginCall, userIds: List<String>, callType: String, shouldRing: Boolean, team: String?) {
+        val selfUserId = streamVideoClient?.userId
+        if (selfUserId == null) {
+            call.reject("No self-user id found. Are you not logged in?")
+            return
+        }
+
+        val callId = java.util.UUID.randomUUID().toString()
+
+        // Create and join call in a coroutine
+        kotlinx.coroutines.GlobalScope.launch {
+            try {
+                // Create the call object
+                val streamCall = streamVideoClient?.call(type = callType, id = callId)
+
+                // Note: We no longer start tracking here - we'll wait for CallSessionStartedEvent
+                // instead, which contains the actual participant list
+
+                android.util.Log.d("StreamCallPlugin", "Creating call with members...")
+                // Create the call with all members
+                val createResult = streamCall?.create(
+                    memberIds = userIds + selfUserId,
+                    custom = emptyMap(),
+                    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)
+
+                    bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
+                    bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
+                    setOverlayContent(streamCall)
+                    overlayView?.isVisible = true
+                    // Ensure overlay is behind WebView by adjusting its position in the parent
+                    val parent = overlayView?.parent as? ViewGroup
+                    parent?.removeView(overlayView)
+                    parent?.addView(overlayView, 0) // Add at index 0 to ensure it's behind other views
+                }
+
+                // Resolve the call with success
+                call.resolve(JSObject().apply {
+                    put("success", true)
+                })
+            } catch (e: Exception) {
+                android.util.Log.e("StreamCallPlugin", "Error making call: ${e.message}")
+                call.reject("Failed to make call: ${e.message}")
+            }
+        }
+    }
+
+    // Function to request required permissions
+    private fun requestPermissions() {
+        permissionAttemptCount++
+        android.util.Log.d("StreamCallPlugin", "requestPermissions: Attempt #$permissionAttemptCount - Requesting RECORD_AUDIO and CAMERA permissions.")
+        
+        // Record timing for instant denial detection
+        permissionRequestStartTime = System.currentTimeMillis()
+        android.util.Log.d("StreamCallPlugin", "requestPermissions: Starting permission request at $permissionRequestStartTime")
+        
+        ActivityCompat.requestPermissions(
+            activity,
+            arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA),
+            9001 // Use high request code to avoid Capacitor conflicts
+        )
+        
+        android.util.Log.d("StreamCallPlugin", "requestPermissions: Permission request initiated with code 9001")
+    }
+
+    private fun showPermissionSettingsDialog() {
+        activity?.runOnUiThread {
+            val activeCall = streamVideoClient?.state?.activeCall?.value
+            val hasActiveCall = activeCall != null && pendingAcceptCall != null && activeCall.id == pendingAcceptCall?.id
+            
+            val builder = AlertDialog.Builder(activity)
+            builder.setTitle("Enable Permissions")
+            
+            if (hasActiveCall) {
+                builder.setMessage("Your call is active but camera and microphone are disabled.\n\nWould you like to open Settings to enable video and audio?")
+                builder.setNegativeButton("Continue without") { _, _ ->
+                    android.util.Log.d("StreamCallPlugin", "User chose to continue call without permissions")
+                    showPermissionRequiredMessage()
+                }
+            } else {
+                builder.setMessage("To make video calls, this app needs Camera and Microphone permissions.\n\nWould you like to open Settings to enable them?")
+                builder.setNegativeButton("Cancel") { _, _ ->
+                    android.util.Log.d("StreamCallPlugin", "User declined to grant permissions - final rejection")
+                    showPermissionRequiredMessage()
                 }
+            }
+            
+            builder.setPositiveButton("Open Settings") { _, _ ->
+                android.util.Log.d("StreamCallPlugin", "User chose to open app settings")
+                openAppSettings()
+                // Don't reject the call yet - let them go to settings and come back
+            }
+            
+            builder.setCancelable(false)
+            builder.show()
+        }
+    }
+
+    private fun showPermissionRequiredMessage() {
+        activity?.runOnUiThread {
+            val activeCall = streamVideoClient?.state?.activeCall?.value
+            val hasActiveCall = activeCall != null && pendingAcceptCall != null && activeCall.id == pendingAcceptCall?.id
+            
+            val builder = AlertDialog.Builder(activity)
+            builder.setTitle("Permissions Required")
+            
+            if (hasActiveCall) {
+                builder.setMessage("Camera and microphone permissions are required for video calling. Your call will continue without camera/microphone.")
             } else {
-                android.util.Log.e("StreamCallPlugin", "handleRequestPermissionsResult: One or more permissions DENIED.")
+                builder.setMessage("Camera/microphone permission is required for the calling functionality of this app")
+            }
+            
+            builder.setPositiveButton("OK") { dialog, _ ->
+                dialog.dismiss()
+                handleFinalPermissionDenial()
+            }
+            builder.setCancelable(false)
+            builder.show()
+        }
+    }
+
+    private fun handleFinalPermissionDenial() {
+        android.util.Log.d("StreamCallPlugin", "handleFinalPermissionDenial: Processing final permission denial")
+        
+        val hasOutgoingCall = pendingCall != null && pendingCallUserIds != null
+        val hasIncomingCall = pendingCall != null && pendingAcceptCall != null
+        val activeCall = streamVideoClient?.state?.activeCall?.value
+        
+        when {
+            hasOutgoingCall -> {
+                // Outgoing call that couldn't be created due to permissions
+                android.util.Log.d("StreamCallPlugin", "handleFinalPermissionDenial: Rejecting outgoing call creation")
+                pendingCall?.reject("Permissions required for call. Please grant them.")
+                clearPendingCall()
+            }
+            
+            hasIncomingCall && activeCall != null && activeCall.id == pendingAcceptCall?.id -> {
+                // Incoming call that's already active - DON'T end the call, just keep it without camera/mic
+                android.util.Log.d("StreamCallPlugin", "handleFinalPermissionDenial: Incoming call already active, keeping call without camera/mic")
+                
+                // Ensure camera and microphone are disabled since no permissions
+                try {
+                    activeCall.microphone?.setEnabled(false)
+                    activeCall.camera?.setEnabled(false)
+                    android.util.Log.d("StreamCallPlugin", "handleFinalPermissionDenial: Disabled camera/microphone for call ${activeCall.id}")
+                } catch (e: Exception) {
+                    android.util.Log.w("StreamCallPlugin", "handleFinalPermissionDenial: Error disabling camera/mic", e)
+                }
+                
+                android.widget.Toast.makeText(
+                    context,
+                    "Call continues without camera/microphone",
+                    android.widget.Toast.LENGTH_LONG
+                ).show()
+                
+                // Resolve the pending call since the call itself was successful (just no permissions)
+                pendingCall?.resolve(JSObject().apply {
+                    put("success", true)
+                    put("message", "Call accepted without camera/microphone permissions")
+                })
+                clearPendingCall()
+            }
+            
+            hasIncomingCall -> {
+                // Incoming call that wasn't accepted yet (old flow)
+                android.util.Log.d("StreamCallPlugin", "handleFinalPermissionDenial: Rejecting incoming call acceptance")
+                pendingCall?.reject("Permissions required for call. Please grant them.")
+                clearPendingCall()
+            }
+            
+            else -> {
+                android.util.Log.d("StreamCallPlugin", "handleFinalPermissionDenial: No pending operations to handle")
+                clearPendingCall()
+            }
+        }
+    }
+
+    private fun openAppSettings() {
+        try {
+            // Try to open app-specific permission settings directly (Android 11+)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                try {
+                    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+                        ("package:" + activity.packageName).toUri())
+                    intent.addCategory(Intent.CATEGORY_DEFAULT);
+                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                    context.startActivity(intent)
+                    android.util.Log.d("StreamCallPlugin", "Opened app details settings (Android 11+)")
+                    
+                    // Show toast with specific instructions
+                    runOnMainThread {
+                        android.widget.Toast.makeText(
+                            context,
+                            "Tap 'Permissions' → Enable Camera and Microphone",
+                            android.widget.Toast.LENGTH_LONG
+                        ).show()
+                    }
+                    return
+                } catch (e: Exception) {
+                    android.util.Log.w("StreamCallPlugin", "Failed to open app details, falling back", e)
+                }
+            }
+            
+            // Fallback for older Android versions or if the above fails
+            val intent = android.content.Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                data = Uri.fromParts("package", context.packageName, null)
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            context.startActivity(intent)
+            android.util.Log.d("StreamCallPlugin", "Opened app settings via fallback")
+            
+            // Show more specific instructions for older versions
+            runOnMainThread {
+                android.widget.Toast.makeText(
+                    context,
+                    "Find 'Permissions' and enable Camera + Microphone",
+                    android.widget.Toast.LENGTH_LONG
+                ).show()
+            }
+            
+        } catch (e: Exception) {
+            android.util.Log.e("StreamCallPlugin", "Error opening app settings", e)
+            
+            // Final fallback - open general settings
+            try {
+                val intent = android.content.Intent(android.provider.Settings.ACTION_SETTINGS).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                }
+                context.startActivity(intent)
+                android.util.Log.d("StreamCallPlugin", "Opened general settings as final fallback")
+                
                 runOnMainThread {
                     android.widget.Toast.makeText(
                         context,
-                        "Permissions not granted. Cannot join call.",
+                        "Go to Apps → ${context.applicationInfo.loadLabel(context.packageManager)} → Permissions",
+                        android.widget.Toast.LENGTH_LONG
+                    ).show()
+                }
+            } catch (finalException: Exception) {
+                android.util.Log.e("StreamCallPlugin", "All settings intents failed", finalException)
+                runOnMainThread {
+                    android.widget.Toast.makeText(
+                        context,
+                        "Please manually enable Camera and Microphone permissions",
                         android.widget.Toast.LENGTH_LONG
                     ).show()
                 }
             }
-        } else {
-            android.util.Log.w("StreamCallPlugin", "handleRequestPermissionsResult: Received unknown requestCode: $requestCode")
         }
     }
 
-    private fun logPermissionResults(permissions: Array<out String>, grantResults: IntArray) {
-        android.util.Log.d("StreamCallPlugin", "logPermissionResults: Logging permission results:")
-        for (i in permissions.indices) {
-            val permission = permissions[i]
-            val grantResult = if (grantResults.size > i) grantResults[i] else -999 // -999 for safety if arrays mismatch
-            val resultString = if (grantResult == PackageManager.PERMISSION_GRANTED) "GRANTED" else "DENIED ($grantResult)"
-            android.util.Log.d("StreamCallPlugin", "  Permission: $permission, Result: $resultString")
-        }
-    }
+
 
     @OptIn(DelicateCoroutinesApi::class)
     @PluginMethod
@@ -1459,58 +1949,21 @@ public class StreamCallPlugin : Plugin() {
 
             // Check permissions before creating the call
             if (!checkPermissions()) {
+                android.util.Log.d("StreamCallPlugin", "Permissions not granted, storing call parameters and requesting permissions")
+                // Store call parameters for later execution
+                pendingCall = call
+                pendingCallUserIds = userIds
+                pendingCallType = callType
+                pendingCallShouldRing = shouldRing
+                pendingCallTeam = team
+                // Reset attempt count for new permission flow
+                permissionAttemptCount = 0
                 requestPermissions()
-                call.reject("Permissions required for call. Please grant them.")
-                return
+                return // Don't reject immediately, wait for permission result
             }
 
-            // Create and join call in a coroutine
-            kotlinx.coroutines.GlobalScope.launch {
-                try {
-                    // Create the call object
-                    val streamCall = streamVideoClient?.call(type = callType, id = callId)
-
-                    // Note: We no longer start tracking here - we'll wait for CallSessionStartedEvent
-                    // instead, which contains the actual participant list
-
-                    android.util.Log.d("StreamCallPlugin", "Creating call with members...")
-                    // Create the call with all members
-                    val createResult = streamCall?.create(
-                        memberIds = userIds + selfUserId,
-                        custom = emptyMap(),
-                        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)
-
-                        bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
-                        bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
-                        setOverlayContent(streamCall)
-                        overlayView?.isVisible = true
-                        // Ensure overlay is behind WebView by adjusting its position in the parent
-                        val parent = overlayView?.parent as? ViewGroup
-                        parent?.removeView(overlayView)
-                        parent?.addView(overlayView, 0) // Add at index 0 to ensure it's behind other views
-                    }
-
-                    // Resolve the call with success
-                    call.resolve(JSObject().apply {
-                        put("success", true)
-                    })
-                } catch (e: Exception) {
-                    android.util.Log.e("StreamCallPlugin", "Error making call: ${e.message}")
-                    call.reject("Failed to make call: ${e.message}")
-                }
-            }
+            // Execute call creation immediately if permissions are granted
+            createAndStartCall(call, userIds, callType, shouldRing, team)
         } catch (e: Exception) {
             call.reject("Failed to make call: ${e.message}")
         }
@@ -1726,7 +2179,7 @@ public class StreamCallPlugin : Plugin() {
             call.reject("No active call")
         }
     }
-    
+
     // Helper method to update call status and notify listeners
     private fun updateCallStatusAndNotify(callId: String, state: String, userId: String? = null, reason: String? = null, members: List<Map<String, Any>>? = null, caller: Map<String, Any>? = null) {
         android.util.Log.d("StreamCallPlugin", "updateCallStatusAndNotify called: callId=$callId, state=$state, userId=$userId, reason=$reason")
@@ -1824,7 +2277,7 @@ public class StreamCallPlugin : Plugin() {
                     val call = streamVideoClient?.call(id = cid.id, type = cid.type)
                     if (call != null) {
                         kotlinx.coroutines.GlobalScope.launch {
-                            internalAcceptCall(call)
+                            internalAcceptCall(call, requestPermissionsAfter = !checkPermissions())
                         }
                         bringAppToForeground()
                     } else {

package/dist/docs.json

@@ -1565,6 +1565,22 @@
           "text": "'ended'",
           "complexTypes": []
         },
+        {
+          "text": "'camera_enabled'",
+          "complexTypes": []
+        },
+        {
+          "text": "'camera_disabled'",
+          "complexTypes": []
+        },
+        {
+          "text": "'microphone_enabled'",
+          "complexTypes": []
+        },
+        {
+          "text": "'microphone_disabled'",
+          "complexTypes": []
+        },
         {
           "text": "'unknown'",
           "complexTypes": []

package/dist/esm/definitions.d.ts

@@ -31,7 +31,7 @@ export interface PushNotificationsConfig {
  * @typedef CallState
  * @description Represents all possible call states from API and UI
  */
-export type CallState = 'idle' | 'ringing' | 'joining' | 'reconnecting' | 'joined' | 'leaving' | 'left' | 'created' | 'session_started' | 'rejected' | 'missed' | 'accepted' | 'ended' | 'unknown';
+export type CallState = 'idle' | 'ringing' | 'joining' | 'reconnecting' | 'joined' | 'leaving' | 'left' | 'created' | 'session_started' | 'rejected' | 'missed' | 'accepted' | 'ended' | 'camera_enabled' | 'camera_disabled' | 'microphone_enabled' | 'microphone_disabled' | 'unknown';
 /**
  * @typedef CallType
  * @description Represents the pre-defined types of a call.

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  pushNotificationsConfig?: PushNotificationsConfig;\n}\n\nexport interface PushNotificationsConfig {\n  pushProviderName: string;\n  voipProviderName: string;\n}\n\n/**\n * @typedef CallState\n * @description Represents all possible call states from API and UI\n */\nexport type CallState =\n  // User-facing states\n  | 'idle'\n  | 'ringing'\n  | 'joining'\n  | 'reconnecting'\n  | 'joined'\n  | 'leaving'\n  | 'left'\n  // Event-specific states\n  | 'created'\n  | 'session_started'\n  | 'rejected'\n  | 'missed'\n  | 'accepted'\n  | 'ended'\n  | 'unknown';\n\n/**\n * @typedef CallType\n * @description Represents the pre-defined types of a call.\n * - `default`: Simple 1-1 or group video calling with sensible defaults. Video/audio enabled, backstage disabled. Admins/hosts have elevated permissions.\n * - `audio_room`: For audio-only spaces (like Clubhouse). Backstage enabled (requires `goLive`), pre-configured permissions for requesting to speak.\n * - `livestream`: For one-to-many streaming. Backstage enabled (requires `goLive`), access granted to all authenticated users.\n * - `development`: For testing ONLY. All permissions enabled, backstage disabled. **Not recommended for production.**\n */\nexport type CallType = 'default' | 'audio_room' | 'livestream' | 'development';\n\n/**\n * @interface CallMember\n * @description Information about a call member/participant\n * @property {string} userId - User ID of the member\n * @property {string} [name] - Display name of the user\n * @property {string} [imageURL] - Profile image URL of the user\n * @property {string} [role] - Role of the user in the call\n */\nexport interface CallMember {\n  /** User ID of the member */\n  userId: string;\n  /** Display name of the user */\n  name?: string;\n  /** Profile image URL of the user */\n  imageURL?: string;\n  /** Role of the user in the call */\n  role?: string;\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 {CallState} state - Current state of the call\n * @property {string} [userId] - User ID of the participant who triggered the event\n * @property {string} [reason] - Reason for the call state change\n * @property {CallMember} [caller] - Information about the caller (for incoming calls)\n * @property {CallMember[]} [members] - List of call members\n */\nexport interface CallEvent {\n  /** ID of the call */\n  callId: string;\n  /** Current state of the call */\n  state: CallState;\n  /** User ID of the participant in the call who triggered the event */\n  userId?: string;\n  /** Reason for the call state change, if applicable */\n  reason?: string;\n  /** Information about the caller (for incoming calls) */\n  caller?: CallMember;\n  /** List of call members */\n  members?: CallMember[];\n}\n\nexport interface CameraEnabledResponse {\n  enabled: 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 CallOptions\n * @description Options for initiating a video call\n * @property {string[]} userIds - IDs of the users to call\n * @property {CallType} [type=default] - Type of call\n * @property {boolean} [ring=true] - Whether to send ring notification\n * @property {string} [team] - Team name to call\n */\nexport interface CallOptions {\n  /** User ID of the person to call */\n  userIds: string[];\n  /** Type of call, defaults to 'default' */\n  type?: CallType;\n  /** Whether to ring the other user, defaults to true */\n  ring?: boolean;\n  /** Team name to call */\n  team?: string;\n  /** Whether to start the call with video enabled, defaults to false */\n  video?: 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   * Listen for lock-screen incoming call (Android only).\n   * Fired when the app is shown by full-screen intent before user interaction.\n   */\n  addListener(\n    eventName: 'incomingCall',\n    listenerFunc: (event: IncomingCallPayload) => 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  /**\n   * Check if camera is enabled\n   * @returns {Promise<CameraEnabledResponse>} Camera enabled status\n   * @example\n   * const isCameraEnabled = await StreamCall.isCameraEnabled();\n   * console.log(isCameraEnabled);\n   */\n  isCameraEnabled(): Promise<CameraEnabledResponse>;\n\n  /**\n   * Get the current call status\n   * @returns {Promise<CallEvent>} Current call status as a CallEvent\n   * @example\n   * const callStatus = await StreamCall.getCallStatus();\n   * console.log(callStatus);\n   */\n  getCallStatus(): Promise<CallEvent>;\n\n  /**\n   * Set speakerphone on\n   * @param {{ name: string }} options - Speakerphone name\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.setSpeaker({ name: 'speaker' });\n   */\n  setSpeaker(options: { name: string }): Promise<SuccessResponse>;\n\n  /**\n   * Switch camera\n   * @param {{ camera: 'front' | 'back' }} options - Camera to switch to\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.switchCamera({ camera: 'back' });\n   */\n  switchCamera(options: { camera: 'front' | 'back' }): Promise<SuccessResponse>;\n\n  /**\n   * Get detailed information about an active call including caller details\n   * @param options - Options containing the call ID\n   */\n  getCallInfo(options: { callId: string }): Promise<CallEvent>;\n}\n\n/**\n * @interface IncomingCallPayload\n * @description Payload delivered with \"incomingCall\" event (Android lock-screen).\n * @property {string} cid - Call CID (type:id)\n * @property {string} type - Always \"incoming\" for this event\n * @property {CallMember} [caller] - Information about the caller\n */\nexport interface IncomingCallPayload {\n  /** Full call CID (e.g. default:123) */\n  cid: string;\n  /** Event type (currently always \"incoming\") */\n  type: 'incoming';\n  /** Information about the caller */\n  caller?: CallMember;\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  pushNotificationsConfig?: PushNotificationsConfig;\n}\n\nexport interface PushNotificationsConfig {\n  pushProviderName: string;\n  voipProviderName: string;\n}\n\n/**\n * @typedef CallState\n * @description Represents all possible call states from API and UI\n */\nexport type CallState =\n  // User-facing states\n  | 'idle'\n  | 'ringing'\n  | 'joining'\n  | 'reconnecting'\n  | 'joined'\n  | 'leaving'\n  | 'left'\n  // Event-specific states\n  | 'created'\n  | 'session_started'\n  | 'rejected'\n  | 'missed'\n  | 'accepted'\n  | 'ended'\n  | 'camera_enabled'\n  | 'camera_disabled'\n  | 'microphone_enabled'\n  | 'microphone_disabled'\n  | 'unknown';\n\n/**\n * @typedef CallType\n * @description Represents the pre-defined types of a call.\n * - `default`: Simple 1-1 or group video calling with sensible defaults. Video/audio enabled, backstage disabled. Admins/hosts have elevated permissions.\n * - `audio_room`: For audio-only spaces (like Clubhouse). Backstage enabled (requires `goLive`), pre-configured permissions for requesting to speak.\n * - `livestream`: For one-to-many streaming. Backstage enabled (requires `goLive`), access granted to all authenticated users.\n * - `development`: For testing ONLY. All permissions enabled, backstage disabled. **Not recommended for production.**\n */\nexport type CallType = 'default' | 'audio_room' | 'livestream' | 'development';\n\n/**\n * @interface CallMember\n * @description Information about a call member/participant\n * @property {string} userId - User ID of the member\n * @property {string} [name] - Display name of the user\n * @property {string} [imageURL] - Profile image URL of the user\n * @property {string} [role] - Role of the user in the call\n */\nexport interface CallMember {\n  /** User ID of the member */\n  userId: string;\n  /** Display name of the user */\n  name?: string;\n  /** Profile image URL of the user */\n  imageURL?: string;\n  /** Role of the user in the call */\n  role?: string;\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 {CallState} state - Current state of the call\n * @property {string} [userId] - User ID of the participant who triggered the event\n * @property {string} [reason] - Reason for the call state change\n * @property {CallMember} [caller] - Information about the caller (for incoming calls)\n * @property {CallMember[]} [members] - List of call members\n */\nexport interface CallEvent {\n  /** ID of the call */\n  callId: string;\n  /** Current state of the call */\n  state: CallState;\n  /** User ID of the participant in the call who triggered the event */\n  userId?: string;\n  /** Reason for the call state change, if applicable */\n  reason?: string;\n  /** Information about the caller (for incoming calls) */\n  caller?: CallMember;\n  /** List of call members */\n  members?: CallMember[];\n}\n\nexport interface CameraEnabledResponse {\n  enabled: 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 CallOptions\n * @description Options for initiating a video call\n * @property {string[]} userIds - IDs of the users to call\n * @property {CallType} [type=default] - Type of call\n * @property {boolean} [ring=true] - Whether to send ring notification\n * @property {string} [team] - Team name to call\n */\nexport interface CallOptions {\n  /** User ID of the person to call */\n  userIds: string[];\n  /** Type of call, defaults to 'default' */\n  type?: CallType;\n  /** Whether to ring the other user, defaults to true */\n  ring?: boolean;\n  /** Team name to call */\n  team?: string;\n  /** Whether to start the call with video enabled, defaults to false */\n  video?: 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   * Listen for lock-screen incoming call (Android only).\n   * Fired when the app is shown by full-screen intent before user interaction.\n   */\n  addListener(\n    eventName: 'incomingCall',\n    listenerFunc: (event: IncomingCallPayload) => 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  /**\n   * Check if camera is enabled\n   * @returns {Promise<CameraEnabledResponse>} Camera enabled status\n   * @example\n   * const isCameraEnabled = await StreamCall.isCameraEnabled();\n   * console.log(isCameraEnabled);\n   */\n  isCameraEnabled(): Promise<CameraEnabledResponse>;\n\n  /**\n   * Get the current call status\n   * @returns {Promise<CallEvent>} Current call status as a CallEvent\n   * @example\n   * const callStatus = await StreamCall.getCallStatus();\n   * console.log(callStatus);\n   */\n  getCallStatus(): Promise<CallEvent>;\n\n  /**\n   * Set speakerphone on\n   * @param {{ name: string }} options - Speakerphone name\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.setSpeaker({ name: 'speaker' });\n   */\n  setSpeaker(options: { name: string }): Promise<SuccessResponse>;\n\n  /**\n   * Switch camera\n   * @param {{ camera: 'front' | 'back' }} options - Camera to switch to\n   * @returns {Promise<SuccessResponse>} Success status\n   * @example\n   * await StreamCall.switchCamera({ camera: 'back' });\n   */\n  switchCamera(options: { camera: 'front' | 'back' }): Promise<SuccessResponse>;\n\n  /**\n   * Get detailed information about an active call including caller details\n   * @param options - Options containing the call ID\n   */\n  getCallInfo(options: { callId: string }): Promise<CallEvent>;\n}\n\n/**\n * @interface IncomingCallPayload\n * @description Payload delivered with \"incomingCall\" event (Android lock-screen).\n * @property {string} cid - Call CID (type:id)\n * @property {string} type - Always \"incoming\" for this event\n * @property {CallMember} [caller] - Information about the caller\n */\nexport interface IncomingCallPayload {\n  /** Full call CID (e.g. default:123) */\n  cid: string;\n  /** Event type (currently always \"incoming\") */\n  type: 'incoming';\n  /** Information about the caller */\n  caller?: CallMember;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-stream-call",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "description": "Uses the https://getstream.io/ SDK to implement calling in Capacitor",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",