@capgo/capacitor-stream-call 0.0.43 → 0.0.50

package/README.md

@@ -140,123 +140,96 @@ Add string resources for different languages:
 </resources>
 ```
 
-## Usage
+## Displaying Caller Information
 
-### Handling Incoming Calls (Android)
-On Android, to handle incoming calls when the device is locked, you need to listen for the `incomingCall` event and manage the call state properly:
+When receiving incoming calls, you can access caller information including name, user ID, and profile image. This information is automatically extracted from the call data and passed through the event system.
 
-```typescript
-import { StreamCall } from '@capgo/capacitor-stream-call';
+### Getting Caller Information
 
-export class CallService {
-  private incomingCallId: string | null = null;
-  private isLockscreenIncoming = false;
+The caller information is available in two ways:
 
-  constructor() {
-    this.setupIncomingCallListener();
-  }
+**1. Through Call Events**
 
-  private setupIncomingCallListener() {
-    StreamCall.addListener('incomingCall', async (payload) => {
-      console.log('Incoming call from lockscreen:', payload);
-      
-      // Store the call ID and show incoming call UI
-      this.incomingCallId = payload.cid;
-      this.isLockscreenIncoming = true;
-      
-      // Show your custom incoming call screen
-      this.showIncomingCallScreen(payload);
-    });
-  }
+The `callEvent` listener provides caller information for incoming calls:
 
-  // Accept the incoming call
-  async acceptCall() {
-    if (!this.incomingCallId) {
-      console.warn('No incoming call to accept');
-      return;
-    }
-    
-    try {
-      await StreamCall.acceptCall();
-      this.clearIncomingCall();
-      console.log('Call accepted successfully');
-    } catch (error) {
-      console.error('Failed to accept call:', error);
-    }
-  }
-
-  // Reject the incoming call
-  async rejectCall() {
-    if (!this.incomingCallId) {
-      console.warn('No incoming call to reject');
-      return;
-    }
-    
-    try {
-      await StreamCall.rejectCall();
-      this.clearIncomingCall();
-      console.log('Call rejected successfully');
-    } catch (error) {
-      console.error('Failed to reject call:', error);
-    }
+```typescript
+StreamCall.addListener('callEvent', (event) => {
+  if (event.state === 'ringing' && event.caller) {
+    console.log('Incoming call from:', event.caller.name || event.caller.userId);
+    console.log('Caller image:', event.caller.imageURL);
+    // Update your UI to show caller information
+    showIncomingCallUI(event.caller);
   }
+});
+```
 
-  private clearIncomingCall() {
-    this.incomingCallId = null;
-    this.isLockscreenIncoming = false;
-    // Hide your incoming call UI
-    this.hideIncomingCallScreen();
-  }
+**2. Through Incoming Call Events (Android lock-screen)**
 
-  private showIncomingCallScreen(payload: any) {
-    // Implement your custom incoming call UI
-    // This should show accept/reject buttons and caller information
-    // Example: navigate to incoming call page or show modal
-  }
+The `incomingCall` listener also includes caller information:
 
-  private hideIncomingCallScreen() {
-    // Hide the incoming call UI
-    // Example: navigate away from incoming call page or close modal
+```typescript
+StreamCall.addListener('incomingCall', (payload) => {
+  if (payload.caller) {
+    console.log('Lock-screen call from:', payload.caller.name || payload.caller.userId);
+    // Update your lock-screen UI
+    updateLockScreenUI(payload.caller);
   }
-}
+});
 ```
 
-> **Important:** This lock-screen handling is only required on Android. On iOS, the system handles incoming call UI automatically.
+### Caller Information Structure
 
-### Basic Call Operations
 ```typescript
-import { StreamCall } from '@capgo/capacitor-stream-call';
-
-// Login to Stream Video
-await StreamCall.login({
-  token: 'your_user_token',
-  userId: 'user_id', 
-  name: 'User Name',
-  apiKey: 'your_api_key',
-  magicDivId: 'video-container'
-});
+interface CallMember {
+  userId: string;      // User ID (always present)
+  name?: string;       // Display name (optional)
+  imageURL?: string;   // Profile image URL (optional)
+  role?: string;       // User role (optional)
+}
+```
 
-// Make a call
-await StreamCall.call({
-  userIds: ['user_to_call'],
-  type: 'default',
-  ring: true
-});
+### Example Implementation
 
-// End call
-await StreamCall.endCall();
+Here's how to implement a proper incoming call screen with caller information:
 
-// Toggle microphone
-await StreamCall.setMicrophoneEnabled({ enabled: false });
+```typescript
+export class CallService {
+  private callerInfo: CallMember | null = null;
 
-// Toggle camera  
-await StreamCall.setCameraEnabled({ enabled: false });
+  constructor() {
+    this.setupCallListeners();
+  }
 
-// Switch camera
-await StreamCall.switchCamera({ camera: 'front' });
+  private setupCallListeners() {
+    StreamCall.addListener('callEvent', (event) => {
+      if (event.state === 'ringing') {
+        this.callerInfo = event.caller || null;
+        this.showIncomingCallScreen();
+      } else if (event.state === 'joined' || event.state === 'left') {
+        this.callerInfo = null;
+        this.hideIncomingCallScreen();
+      }
+    });
 
-// Logout
-await StreamCall.logout();
+    // Android lock-screen support
+    if (Capacitor.getPlatform() === 'android') {
+      StreamCall.addListener('incomingCall', (payload) => {
+        this.callerInfo = payload.caller || null;
+        this.showLockScreenIncomingCall();
+      });
+    }
+  }
+
+  private showIncomingCallScreen() {
+    const callerName = this.callerInfo?.name || 'Unknown Caller';
+    const callerImage = this.callerInfo?.imageURL || 'default-avatar.png';
+    
+    // Update your UI components
+    document.getElementById('caller-name').textContent = callerName;
+    document.getElementById('caller-image').src = callerImage;
+    document.getElementById('incoming-call-screen').style.display = 'block';
+  }
+}
 ```
 
 ## API
@@ -278,6 +251,7 @@ await StreamCall.logout();
 * [`getCallStatus()`](#getcallstatus)
 * [`setSpeaker(...)`](#setspeaker)
 * [`switchCamera(...)`](#switchcamera)
+* [`getCallInfo(...)`](#getcallinfo)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
 * [Enums](#enums)
@@ -515,6 +489,23 @@ Switch camera
 --------------------
 
 
+### getCallInfo(...)
+
+```typescript
+getCallInfo(options: { callId: string; }) => Promise<CallEvent>
+```
+
+Get detailed information about an active call including caller details
+
+| Param         | Type                             | Description                      |
+| ------------- | -------------------------------- | -------------------------------- |
+| **`options`** | <code>{ callId: string; }</code> | - Options containing the call ID |
+
+**Returns:** <code>Promise&lt;<a href="#callevent">CallEvent</a>&gt;</code>
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -549,12 +540,14 @@ Switch camera
 
 #### CallEvent
 
-| Prop         | Type                                            | Description                                                    |
-| ------------ | ----------------------------------------------- | -------------------------------------------------------------- |
-| **`callId`** | <code>string</code>                             | ID of the call                                                 |
-| **`state`**  | <code><a href="#callstate">CallState</a></code> | Current state of the call                                      |
-| **`userId`** | <code>string</code>                             | User ID of the participant in the call who triggered the event |
-| **`reason`** | <code>string</code>                             | Reason for the call state change, if applicable                |
+| Prop          | Type                                              | Description                                                    |
+| ------------- | ------------------------------------------------- | -------------------------------------------------------------- |
+| **`callId`**  | <code>string</code>                               | ID of the call                                                 |
+| **`state`**   | <code><a href="#callstate">CallState</a></code>   | Current state of the call                                      |
+| **`userId`**  | <code>string</code>                               | User ID of the participant in the call who triggered the event |
+| **`reason`**  | <code>string</code>                               | Reason for the call state change, if applicable                |
+| **`caller`**  | <code><a href="#callmember">CallMember</a></code> | Information about the caller (for incoming calls)              |
+| **`members`** | <code>CallMember[]</code>                         | List of call members                                           |
 
 
 #### CallState
@@ -748,12 +741,23 @@ The JSON representation for <a href="#listvalue">`ListValue`</a> is JSON array.
 | **`sessionId`** | <code>string</code> | the user sesion_id to pin, if not provided, applies to all sessions |
 
 
+#### CallMember
+
+| Prop           | Type                | Description                   |
+| -------------- | ------------------- | ----------------------------- |
+| **`userId`**   | <code>string</code> | User ID of the member         |
+| **`name`**     | <code>string</code> | Display name of the user      |
+| **`imageURL`** | <code>string</code> | Profile image URL of the user |
+| **`role`**     | <code>string</code> | Role of the user in the call  |
+
+
 #### IncomingCallPayload
 
-| Prop       | Type                    | Description                              |
-| ---------- | ----------------------- | ---------------------------------------- |
-| **`cid`**  | <code>string</code>     | Full call CID (e.g. default:123)         |
-| **`type`** | <code>'incoming'</code> | Event type (currently always "incoming") |
+| Prop         | Type                                              | Description                              |
+| ------------ | ------------------------------------------------- | ---------------------------------------- |
+| **`cid`**    | <code>string</code>                               | Full call CID (e.g. default:123)         |
+| **`type`**   | <code>'incoming'</code>                           | Event type (currently always "incoming") |
+| **`caller`** | <code><a href="#callmember">CallMember</a></code> | Information about the caller             |
 
 
 #### CameraEnabledResponse

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

@@ -63,6 +63,7 @@ import io.getstream.video.android.core.CameraDirection
 import android.content.BroadcastReceiver
 import android.content.Intent
 import android.content.IntentFilter
+import com.getcapacitor.JSArray
 import io.getstream.android.video.generated.models.CallSessionParticipantLeftEvent
 import io.getstream.video.android.core.RealtimeConnection
 import io.getstream.video.android.core.events.ParticipantLeftEvent
@@ -215,15 +216,37 @@ public class StreamCallPlugin : Plugin() {
                     // Start ringtone only; UI handled in web layer
                     ringtonePlayer?.startRinging()
 
-                    // Notify WebView/JS about incoming call so it can render its own UI
-                    try {
-                        val payload = com.getcapacitor.JSObject().apply {
-                            put("cid", cid.cid)
-                            put("type", "incoming")
+                    // Try to get caller information from the call
+                    kotlinx.coroutines.GlobalScope.launch {
+                        try {
+                            val callInfo = call?.get()
+                            val callerInfo = callInfo?.getOrNull()?.call?.createdBy
+                            
+                            val payload = com.getcapacitor.JSObject().apply {
+                                put("cid", cid.cid)
+                                put("type", "incoming")
+                                if (callerInfo != null) {
+                                    val caller = com.getcapacitor.JSObject().apply {
+                                        put("userId", callerInfo.id)
+                                        put("name", callerInfo.name ?: "")
+                                        put("imageURL", callerInfo.image ?: "")
+                                        put("role", callerInfo.role ?: "")
+                                    }
+                                    put("caller", caller)
+                                }
+                            }
+                            
+                            // Notify WebView/JS about incoming call so it can render its own UI
+                            notifyListeners("incomingCall", payload, true)
+                        } catch (e: Exception) {
+                            android.util.Log.e("StreamCallPlugin", "Error getting call info for incoming call", e)
+                            // Fallback to basic payload without caller info
+                            val payload = com.getcapacitor.JSObject().apply {
+                                put("cid", cid.cid)
+                                put("type", "incoming")
+                            }
+                            notifyListeners("incomingCall", payload, true)
                         }
-                        notifyListeners("incomingCall", payload, true)
-                    } catch (e: Exception) {
-                        android.util.Log.e("StreamCallPlugin", "Error notifying JS about incoming call", e)
                     }
 
                     bringAppToForeground()
@@ -602,7 +625,38 @@ public class StreamCallPlugin : Plugin() {
                 android.util.Log.v("StreamCallPlugin", "Received an event ${event.getEventType()} $event")
                 when (event) {
                     is CallRingEvent -> {
-                        updateCallStatusAndNotify(event.callCid, "ringing")
+                        // Extract caller information from the ringing call
+                        kotlinx.coroutines.GlobalScope.launch {
+                            try {
+                                val callCid = event.callCid
+                                val callIdParts = callCid.split(":")
+                                if (callIdParts.size >= 2) {
+                                    val callType = callIdParts[0]
+                                    val callId = callIdParts[1]
+                                    val call = streamVideoClient?.call(type = callType, id = callId)
+                                    val callInfo = call?.get()
+                                    val callerInfo = callInfo?.getOrNull()?.call?.createdBy
+                                    
+                                    // Pass caller information to the ringing event
+                                    if (callerInfo != null) {
+                                        val caller = mapOf(
+                                            "userId" to callerInfo.id,
+                                            "name" to (callerInfo.name ?: ""),
+                                            "imageURL" to (callerInfo.image ?: ""),
+                                            "role" to (callerInfo.role ?: "")
+                                        )
+                                        updateCallStatusAndNotify(event.callCid, "ringing", null, null, null, caller)
+                                    } else {
+                                        updateCallStatusAndNotify(event.callCid, "ringing")
+                                    }
+                                } else {
+                                    updateCallStatusAndNotify(event.callCid, "ringing")
+                                }
+                            } catch (e: Exception) {
+                                android.util.Log.e("StreamCallPlugin", "Error getting caller info for ringing event", e)
+                                updateCallStatusAndNotify(event.callCid, "ringing")
+                            }
+                        }
                     }
                     // Handle CallCreatedEvent differently - only log it but don't try to access members yet
                     is CallCreatedEvent -> {
@@ -611,22 +665,59 @@ public class StreamCallPlugin : Plugin() {
                         android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: All members from event: ${event.members.joinToString { it.user.id + " (role: " + it.user.role + ")" }}")
                         android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Self user ID from SDK: ${this@StreamCallPlugin.streamVideoClient?.userId}")
 
-                        val callParticipants = event.members.filter {
-                            val selfId = this@StreamCallPlugin.streamVideoClient?.userId
-                            val memberId = it.user.id
-                            val isSelf = memberId == selfId
-                            android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Filtering member $memberId. Self ID: $selfId. Is self: $isSelf")
-                            !isSelf
-                        }.map { it.user.id }
-
-                        android.util.Log.d("StreamCallPlugin", "Call created for $callCid with ${callParticipants.size} remote participants: ${callParticipants.joinToString()}.")
-
-                        // Start tracking this call now that we have the member list
-                        startCallTimeoutMonitor(callCid, callParticipants)
-
-                        // Use direction from event if available
-                        val callType = callCid.split(":").firstOrNull() ?: "default"
-                        updateCallStatusAndNotify(callCid, "created")
+                        // Only send "created" event for outgoing calls (calls created by current user)
+                        // For incoming calls, we'll only send "ringing" event in CallRingEvent handler
+                        kotlinx.coroutines.GlobalScope.launch {
+                            try {
+                                val callIdParts = callCid.split(":")
+                                if (callIdParts.size >= 2) {
+                                    val callType = callIdParts[0]
+                                    val callId = callIdParts[1]
+                                    val call = streamVideoClient?.call(type = callType, id = callId)
+                                    val callInfo = call?.get()
+                                    val createdBy = callInfo?.getOrNull()?.call?.createdBy
+                                    val currentUserId = streamVideoClient?.userId
+                                    
+                                    android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Call created by: ${createdBy?.id}, Current user: $currentUserId")
+                                    
+                                    // Only notify for outgoing calls (where current user is the creator)
+                                    if (createdBy?.id == currentUserId) {
+                                        android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: This is an outgoing call, sending created event")
+                                        
+                                        val callParticipants = event.members.filter {
+                                            val selfId = this@StreamCallPlugin.streamVideoClient?.userId
+                                            val memberId = it.user.id
+                                            val isSelf = memberId == selfId
+                                            android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Filtering member $memberId. Self ID: $selfId. Is self: $isSelf")
+                                            !isSelf
+                                        }.map { it.user.id }
+
+                                        android.util.Log.d("StreamCallPlugin", "Call created for $callCid with ${callParticipants.size} remote participants: ${callParticipants.joinToString()}.")
+
+                                        // Start tracking this call now that we have the member list
+                                        startCallTimeoutMonitor(callCid, callParticipants)
+
+                                        // Extract all members information (including self) for UI display
+                                        val allMembers = event.members.map { member ->
+                                            mapOf(
+                                                "userId" to member.user.id,
+                                                "name" to (member.user.name ?: ""),
+                                                "imageURL" to (member.user.image ?: ""),
+                                                "role" to (member.user.role ?: "")
+                                            )
+                                        }
+
+                                        updateCallStatusAndNotify(callCid, "created", null, null, allMembers)
+                                    } else {
+                                        android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: This is an incoming call (created by ${createdBy?.id}), not sending created event")
+                                    }
+                                } else {
+                                    android.util.Log.w("StreamCallPlugin", "CallCreatedEvent: Invalid call CID format: $callCid")
+                                }
+                            } catch (e: Exception) {
+                                android.util.Log.e("StreamCallPlugin", "Error processing CallCreatedEvent", e)
+                            }
+                        }
                     }
                     // Add handler for CallSessionStartedEvent which contains participant information
                     is CallSessionStartedEvent -> {
@@ -1153,7 +1244,35 @@ public class StreamCallPlugin : Plugin() {
     private suspend fun endCallRaw(call: Call) {
         val callId = call.id
         android.util.Log.d("StreamCallPlugin", "Attempting to end call $callId")
-        call.leave()
+        
+        try {
+            // Get call information to make the decision
+            val callInfo = call.get()
+            val callData = callInfo?.getOrNull()?.call
+            val currentUserId = streamVideoClient?.userId
+            val createdBy = callData?.createdBy?.id
+            val isCreator = createdBy == currentUserId
+            
+            // Use call.state.totalParticipants to get participant count (as per StreamVideo Android SDK docs)
+            val totalParticipants = call.state.totalParticipants.value ?: 0
+            val shouldEndCall = isCreator || totalParticipants <= 2
+            
+            android.util.Log.d("StreamCallPlugin", "Call $callId - Creator: $createdBy, CurrentUser: $currentUserId, IsCreator: $isCreator, TotalParticipants: $totalParticipants, ShouldEnd: $shouldEndCall")
+            
+            if (shouldEndCall) {
+                // End the call for everyone if I'm the creator or only 2 people
+                android.util.Log.d("StreamCallPlugin", "Ending call $callId for all participants (creator: $isCreator, participants: $totalParticipants)")
+                call.end()
+            } else {
+                // Just leave the call if there are more than 2 people and I'm not the creator
+                android.util.Log.d("StreamCallPlugin", "Leaving call $callId (not creator, >2 participants)")
+                call.leave()
+            }
+        } catch (e: Exception) {
+            android.util.Log.e("StreamCallPlugin", "Error getting call info for $callId, defaulting to leave()", e)
+            // Fallback to leave if we can't determine the call info
+            call.leave()
+        }
 
         // Capture context from the overlayView
         val currentContext = overlayView?.context ?: this.savedContext
@@ -1250,16 +1369,22 @@ public class StreamCallPlugin : Plugin() {
     @PluginMethod
     fun endCall(call: PluginCall) {
         try {
-            val activeCall = streamVideoClient?.state?.activeCall
-            if (activeCall == null) {
-                android.util.Log.w("StreamCallPlugin", "Attempted to end call but no active call found")
+            val activeCall = streamVideoClient?.state?.activeCall?.value
+            val ringingCall = streamVideoClient?.state?.ringingCall?.value
+            
+            val callToEnd = activeCall ?: ringingCall
+            
+            if (callToEnd == null) {
+                android.util.Log.w("StreamCallPlugin", "Attempted to end call but no active or ringing call found")
                 call.reject("No active call to end")
                 return
             }
 
+            android.util.Log.d("StreamCallPlugin", "Ending call: activeCall=${activeCall?.id}, ringingCall=${ringingCall?.id}, callToEnd=${callToEnd.id}")
+
             kotlinx.coroutines.GlobalScope.launch {
                 try {
-                    activeCall.value?.let { endCallRaw(it) }
+                    endCallRaw(callToEnd)
                     call.resolve(JSObject().apply {
                         put("success", true)
                     })
@@ -1587,7 +1712,7 @@ public class StreamCallPlugin : Plugin() {
     }
     
     // Helper method to update call status and notify listeners
-    private fun updateCallStatusAndNotify(callId: String, state: String, userId: String? = null, reason: String? = null) {
+    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")
         // Update stored call info
         currentCallId = callId
@@ -1608,6 +1733,26 @@ public class StreamCallPlugin : Plugin() {
             reason?.let {
                 put("reason", it)
             }
+            members?.let { membersList ->
+                val membersArray = JSArray()
+                membersList.forEach { member ->
+                    val memberObj = JSObject().apply {
+                        member.forEach { (key, value) ->
+                            put(key, value)
+                        }
+                    }
+                    membersArray.put(memberObj)
+                }
+                put("members", membersArray)
+            }
+            caller?.let { callerInfo ->
+                val callerObj = JSObject().apply {
+                    callerInfo.forEach { (key, value) ->
+                        put(key, value)
+                    }
+                }
+                put("caller", callerObj)
+            }
         }
 
         // Notify listeners