@capgo/capacitor-stream-call 0.0.43 → 0.0.51

package/ios/Sources/StreamCallPlugin/StreamCallPlugin.swift

@@ -26,7 +26,8 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "isCameraEnabled", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getCallStatus", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setSpeaker", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "switchCamera", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "switchCamera", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getCallInfo", returnType: CAPPluginReturnPromise)
     ]
 
     private enum State {
@@ -60,7 +61,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     private var callViewModel: CallViewModel?
 
     // Helper method to update call status and notify listeners
-    private func updateCallStatusAndNotify(callId: String, state: String, userId: String? = nil, reason: String? = nil) {
+    private func updateCallStatusAndNotify(callId: String, state: String, userId: String? = nil, reason: String? = nil, caller: [String: Any]? = nil, members: [[String: Any]]? = nil) {
         // Update stored call info
         currentCallId = callId
         currentCallState = state
@@ -78,6 +79,14 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         if let reason = reason {
             data["reason"] = reason
         }
+        
+        if let caller = caller {
+            data["caller"] = caller
+        }
+        
+        if let members = members {
+            data["members"] = members
+        }
 
         // Notify listeners
         notifyListeners("callEvent", data: data)
@@ -231,20 +240,69 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                                 self.hasNotifiedCallJoined = true
                             }
                         } else if case .incoming(let incomingCall) = newState {
-                            self.updateCallStatusAndNotify(callId: incomingCall.id, state: "ringing")
-                        } else if newState == .idle && self.streamVideo?.state.activeCall == nil {
+                            // Extract caller information
+                            Task {
+                                var caller: [String: Any]? = nil
+                                var members: [[String: Any]]? = nil
+                                
+                                do {
+                                    // Get the call from StreamVideo to access detailed information
+                                    if let streamVideo = self.streamVideo {
+                                        let call = streamVideo.call(callType: incomingCall.type, callId: incomingCall.id)
+                                        let callInfo = try await call.get()
+                                        
+                                        // Extract caller information
+                                        let createdBy = callInfo.call.createdBy
+                                        var callerData: [String: Any] = [:]
+                                        callerData["userId"] = createdBy.id
+                                        callerData["name"] = createdBy.name
+                                        callerData["imageURL"] = createdBy.image
+                                        callerData["role"] = createdBy.role
+                                        caller = callerData
+                                        
+                                        // Extract members information from current participants if available
+                                        var membersArray: [[String: Any]] = []
+                                        if let activeCall = streamVideo.state.activeCall {
+                                            let participants = activeCall.state.participants
+                                            for participant in participants {
+                                                var memberData: [String: Any] = [:]
+                                                memberData["userId"] = participant.userId
+                                                memberData["name"] = participant.name
+                                                memberData["imageURL"] = participant.profileImageURL?.absoluteString ?? ""
+                                                memberData["role"] = participant.roles.first ?? ""
+                                                membersArray.append(memberData)
+                                            }
+                                        }
+                                        members = membersArray.isEmpty ? nil : membersArray
+                                    }
+                                } catch {
+                                    print("Failed to get call info for caller details: \(error)")
+                                }
+                                
+                                // Notify with caller information
+                                self.updateCallStatusAndNotify(callId: incomingCall.id, state: "ringing", caller: caller, members: members)
+                            }
+                        } else if newState == .idle {
                             // Get the call ID that was active before the state changed
                             let endingCallId = viewModel.call?.cId
-                            print("Call ending: \(String(describing: endingCallId))")
-                            
-                            // Notify that call has ended - use the properly tracked call ID
-                            self.updateCallStatusAndNotify(callId: endingCallId ?? "", state: "left")
+                            print("Call state changed to idle. EndingCallId: \(String(describing: endingCallId)), ActiveCall: \(String(describing: self.streamVideo?.state.activeCall?.cId))")
                             
-                            // Reset notification flag when call ends
-                            self.hasNotifiedCallJoined = false
-                            
-                            // Remove the call overlay view when not in a call
-                            self.ensureViewRemoved()
+                            // Only notify about call ending if we have a valid call ID and there's truly no active call
+                            // This prevents false "left" events during normal state transitions
+                            if let callId = endingCallId, !callId.isEmpty, self.streamVideo?.state.activeCall == nil {
+                                print("Call actually ending: \(callId)")
+                                
+                                // Notify that call has ended - use the properly tracked call ID
+                                self.updateCallStatusAndNotify(callId: callId, state: "left")
+                                
+                                // Reset notification flag when call ends
+                                self.hasNotifiedCallJoined = false
+                                
+                                // Remove the call overlay view when not in a call
+                                self.ensureViewRemoved()
+                            } else {
+                                print("Not sending left event - CallId: \(String(describing: endingCallId)), ActiveCall exists: \(self.streamVideo?.state.activeCall != nil)")
+                            }
                         }
                     } catch {
                         log.error("Error handling call state update: \(String(describing: error))")
@@ -409,9 +467,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     print("- Should Ring: \(shouldRing)")
                     print("- Team: \(team)")
 
-
-
-                    // Update the CallOverlayView with the active call
                     // Create the call object
                     await self.callViewModel?.startCall(
                         callType: callType,
@@ -420,6 +475,46 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                         ring: shouldRing
                     )
                     
+                    // Wait for call state to be populated by WebSocket events
+                    let callStream = streamVideo!.call(callType: callType, callId: callId)
+                    
+                    // Wait until we have member data - with timeout to prevent infinite loop
+                    var allMembers: [[String: Any]] = []
+                    var attempts = 0
+                    let maxAttempts = 50 // 5 seconds max
+                    
+                    while allMembers.isEmpty && attempts < maxAttempts {
+                        let membersList = await callStream.state.members
+                        if !membersList.isEmpty {
+                            allMembers = membersList.map { member in
+                                [
+                                    "userId": member.user.id,
+                                    "name": member.user.name,
+                                    "imageURL": member.user.imageURL?.absoluteString ?? "",
+                                    "role": member.user.role
+                                ]
+                            }
+                        } else {
+                            attempts += 1
+                            // Wait a bit and try again
+                            try? await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
+                        }
+                    }
+                    
+                    // If we still don't have members after timeout, use basic data
+                    if allMembers.isEmpty {
+                        allMembers = members.map { userId in
+                            [
+                                "userId": userId,
+                                "name": "",
+                                "imageURL": "",
+                                "role": ""
+                            ]
+                        }
+                    }
+                    
+                    // Now send the created event with complete member data
+                    self.updateCallStatusAndNotify(callId: callId, state: "created", members: allMembers)
                     
                     // Update UI on main thread
                     await MainActor.run {
@@ -430,7 +525,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                     call.resolve([
                         "success": true
-                    ])  
+                    ])
 
                 } catch {
                     log.error("Error making call: \(String(describing: error))")
@@ -447,16 +542,81 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             try requireInitialized()
 
             Task {
-                if let activeCall = streamVideo?.state.activeCall {
-                    activeCall.leave()
-
-                    // Update view state instead of cleaning up
+                // Check both active call and callViewModel's call state to handle outgoing calls
+                let activeCall = streamVideo?.state.activeCall
+                let viewModelCall = await callViewModel?.call
+                
+                // Helper function to determine if we should end or leave the call
+                func shouldEndCall(for streamCall: Call) async throws -> Bool {
+                    do {
+                        let callInfo = try await streamCall.get()
+                        let currentUserId = streamVideo?.user.id
+                        let createdBy = callInfo.call.createdBy.id
+                        let isCreator = createdBy == currentUserId
+                        
+                        // Use call.state.participants.count to get participant count (as per StreamVideo iOS SDK docs)
+                        let totalParticipants = await streamCall.state.participants.count
+                        let shouldEnd = isCreator || totalParticipants <= 2
+                        
+                        print("Call \(streamCall.cId) - Creator: \(createdBy), CurrentUser: \(currentUserId ?? "nil"), IsCreator: \(isCreator), TotalParticipants: \(totalParticipants), ShouldEnd: \(shouldEnd)")
+                        
+                        return shouldEnd
+                    } catch {
+                        print("Error getting call info for \(streamCall.cId), defaulting to leave: \(error)")
+                        return false // Fallback to leave if we can't determine
+                    }
+                }
+                
+                if let activeCall = activeCall {
+                    // There's an active call, check if we should end or leave
+                    do {
+                        let shouldEnd = try await shouldEndCall(for: activeCall)
+                        
+                        if shouldEnd {
+                            print("Ending active call \(activeCall.cId) for all participants")
+                            try await activeCall.end()
+                        } else {
+                            print("Leaving active call \(activeCall.cId)")
+                            try await activeCall.leave()
+                        }
+                    } catch {
+                        print("Error ending/leaving active call: \(error)")
+                        try await activeCall.leave() // Fallback to leave
+                    }
+                    
                     await MainActor.run {
-                        // self.overlayViewModel?.updateCall(nil)
                         self.overlayView?.isHidden = true
                         self.webView?.isOpaque = true
                     }
-
+                    
+                    call.resolve([
+                        "success": true
+                    ])
+                } else if let viewModelCall = viewModelCall {
+                    // There's a call in the viewModel (likely outgoing/ringing), check if we should end or leave
+                    do {
+                        let shouldEnd = try await shouldEndCall(for: viewModelCall)
+                        
+                        if shouldEnd {
+                            print("Ending viewModel call \(viewModelCall.cId) for all participants")
+                            try await viewModelCall.end()
+                        } else {
+                            print("Leaving viewModel call \(viewModelCall.cId)")
+                            try await viewModelCall.leave()
+                        }
+                    } catch {
+                        print("Error ending/leaving viewModel call: \(error)")
+                        try await viewModelCall.leave() // Fallback to leave
+                    }
+                    
+                    // Also hang up to reset the calling state
+                    await callViewModel?.hangUp()
+                    
+                    await MainActor.run {
+                        self.overlayView?.isHidden = true
+                        self.webView?.isOpaque = true
+                    }
+                    
                     call.resolve([
                         "success": true
                     ])
@@ -783,7 +943,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     @objc func getCallStatus(_ call: CAPPluginCall) {
-        // Use stored state rather than accessing SDK state directly
+        // If not in a call, reject
         if currentCallId.isEmpty || currentCallState == "left" {
             call.reject("Not in a call")
             return
@@ -794,6 +954,90 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             "state": currentCallState
         ])
     }
+    
+    @objc func getCallInfo(_ call: CAPPluginCall) {
+        guard let callId = call.getString("callId") else {
+            call.reject("Missing required parameter: callId")
+            return
+        }
+        
+        do {
+            try requireInitialized()
+            
+            guard let activeCall = streamVideo?.state.activeCall, activeCall.cId == callId else {
+                call.reject("Call ID does not match active call")
+                return
+            }
+            
+            Task {
+                do {
+                    // Get detailed call information
+                    let callInfo = try await activeCall.get()
+                    
+                    // Extract caller information
+                    var caller: [String: Any]? = nil
+                    let createdBy = callInfo.call.createdBy
+                    var callerData: [String: Any] = [:]
+                    callerData["userId"] = createdBy.id
+                    callerData["name"] = createdBy.name
+                    callerData["imageURL"] = createdBy.image
+                    callerData["role"] = createdBy.role
+                    caller = callerData
+                    
+                    // Extract members information
+                    var membersArray: [[String: Any]] = []
+                    let participants = await activeCall.state.participants
+                    for participant in participants {
+                        var memberData: [String: Any] = [:]
+                        memberData["userId"] = participant.userId
+                        memberData["name"] = participant.name
+                        memberData["imageURL"] = participant.profileImageURL
+                        memberData["role"] = participant.roles.first ?? ""
+                        membersArray.append(memberData)
+                    }
+                    let members = membersArray
+                    
+                    // Determine call state based on current calling state
+                    let state: String
+                    let callingState = await self.callViewModel?.callingState
+                    switch callingState {
+                    case .idle:
+                        state = "idle"
+                    case .incoming:
+                        state = "ringing"
+                    case .outgoing:
+                        state = "ringing"
+                    case .inCall:
+                        state = "joined"
+                    case .lobby:
+                        state = "lobby"
+                    case .joining:
+                        state = "joining"
+                    case .reconnecting:
+                        state = "reconnecting"
+                    case .none:
+                        state = "unknown"
+                    }
+                    
+                    var result: [String: Any] = [:]
+                    result["callId"] = callId
+                    result["state"] = state
+                    
+                    if let caller = caller {
+                        result["caller"] = caller
+                    }
+                    
+                    result["members"] = members
+                    
+                    call.resolve(result)
+                } catch {
+                    call.reject("Failed to get call info: \(error.localizedDescription)")
+                }
+            }
+        } catch {
+            call.reject("StreamVideo not initialized")
+        }
+    }
 
     @objc func setSpeaker(_ call: CAPPluginCall) {
         guard let name = call.getString("name") else {

package/package.json

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