[Fix]Accepting call on another device will sync state with CallViewModel

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### 🐞 Fixed
 - Fix an issue that was causing the video capturer to no be cleaned up when the call was ended, causing the camera access system indicator to remain on while the `CallEnded` screen is visible. [#636](https://github.com/GetStream/stream-video-swift/pull/636)
+- Fix an issue which was not dismissing incoming call screen if the call was accepted on another device. [#640](https://github.com/GetStream/stream-video-swift/pull/640)
 
 # [1.15.0](https://github.com/GetStream/stream-video-swift/releases/tag/1.15.0)
 _January 14, 2025_

Sources/StreamVideoSwiftUI/CallViewModel.swift

@@ -751,7 +751,7 @@ open class CallViewModel: ObservableObject {
 
         switch callingState {
         case .incoming where event.user?.id == streamVideo.user.id:
-            break
+            rejectCall(callType: event.type, callId: event.callId)
         case .outgoing where call?.cId == event.callCid:
             enterCall(
                 call: call,

StreamVideoSwiftUITests/CallViewModel_Tests.swift

@@ -297,7 +297,211 @@ final class CallViewModel_Tests: StreamVideoTestCase {
             callViewModel.callingState == .inCall
         }
     }
-
+
+    @MainActor
+    func test_incomingCall_acceptedFromSameUserElsewhere_callingStateChangesToIdle() async throws {
+        // Given
+        let callViewModel = CallViewModel()
+        await fulfillment { callViewModel.isSubscribedToCallEvents }
+
+        // When
+        let event = CallRingEvent(
+            call: mockResponseBuilder.makeCallResponse(cid: cId),
+            callCid: cId,
+            createdAt: Date(),
+            members: [],
+            sessionId: "123",
+            user: UserResponse(
+                blockedUserIds: [],
+                createdAt: Date(),
+                custom: [:],
+                id: secondUser.userId,
+                language: "",
+                role: "user",
+                teams: [],
+                updatedAt: Date()
+            ),
+            video: true
+        )
+
+        let wrapped = WrappedEvent.coordinatorEvent(.typeCallRingEvent(event))
+        let eventNotificationCenter = try XCTUnwrap(eventNotificationCenter)
+        eventNotificationCenter.process(wrapped)
+
+        await fulfillment {
+            if case .incoming = callViewModel.callingState {
+                return true
+            } else {
+                return false
+            }
+        }
+
+        // Then
+        guard case let .incoming(call) = callViewModel.callingState else {
+            XCTFail()
+            return
+        }
+        XCTAssert(call.id == callId)
+
+        // When we receive an accept even it means we accepted somewhere else
+        eventNotificationCenter.process(
+            .coordinatorEvent(
+                .typeCallAcceptedEvent(
+                    .dummy(
+                        callCid: cId,
+                        user: firstUser.user.toUserResponse()
+                    )
+                )
+            )
+        )
+
+        // Then
+        let callingState = callViewModel.callingState
+        await fulfillment("CallViewModel.callingState expected:.inCall actual: \(callingState)") {
+            callViewModel.callingState == .idle
+        }
+    }
+
+    @MainActor
+    func test_incomingCall_anotherUserAcceptedThisCall_callingStateShouldRemainIncoming() async throws {
+        // Given
+        let callViewModel = CallViewModel()
+        await fulfillment { callViewModel.isSubscribedToCallEvents }
+
+        // When
+        let event = CallRingEvent(
+            call: mockResponseBuilder.makeCallResponse(cid: cId),
+            callCid: cId,
+            createdAt: Date(),
+            members: [],
+            sessionId: "123",
+            user: UserResponse(
+                blockedUserIds: [],
+                createdAt: Date(),
+                custom: [:],
+                id: secondUser.userId,
+                language: "",
+                role: "user",
+                teams: [],
+                updatedAt: Date()
+            ),
+            video: true
+        )
+
+        let wrapped = WrappedEvent.coordinatorEvent(.typeCallRingEvent(event))
+        let eventNotificationCenter = try XCTUnwrap(eventNotificationCenter)
+        eventNotificationCenter.process(wrapped)
+
+        await fulfillment {
+            if case .incoming = callViewModel.callingState {
+                return true
+            } else {
+                return false
+            }
+        }
+
+        // Then
+        guard case let .incoming(call) = callViewModel.callingState else {
+            XCTFail()
+            return
+        }
+        XCTAssert(call.id == callId)
+
+        // When we receive an accept even it means we accepted somewhere else
+        eventNotificationCenter.process(
+            .coordinatorEvent(
+                .typeCallAcceptedEvent(
+                    .dummy(
+                        callCid: cId,
+                        user: secondUser.user.toUserResponse()
+                    )
+                )
+            )
+        )
+
+        // Then
+        try await XCTAssertWithDelay(
+            {
+                switch callViewModel.callingState {
+                case .incoming:
+                    return true
+                default:
+                    return false
+                }
+            }()
+        )
+    }
+
+    @MainActor
+    func test_incomingCall_acceptedAnotherCallElsewhere_callingStateShouldRemainInCall() async throws {
+        // Given
+        let callViewModel = CallViewModel()
+        await fulfillment { callViewModel.isSubscribedToCallEvents }
+
+        // When
+        let event = CallRingEvent(
+            call: mockResponseBuilder.makeCallResponse(cid: cId),
+            callCid: cId,
+            createdAt: Date(),
+            members: [],
+            sessionId: "123",
+            user: UserResponse(
+                blockedUserIds: [],
+                createdAt: Date(),
+                custom: [:],
+                id: secondUser.userId,
+                language: "",
+                role: "user",
+                teams: [],
+                updatedAt: Date()
+            ),
+            video: true
+        )
+
+        let wrapped = WrappedEvent.coordinatorEvent(.typeCallRingEvent(event))
+        let eventNotificationCenter = try XCTUnwrap(eventNotificationCenter)
+        eventNotificationCenter.process(wrapped)
+
+        await fulfillment {
+            if case .incoming = callViewModel.callingState {
+                return true
+            } else {
+                return false
+            }
+        }
+
+        // Then
+        guard case let .incoming(call) = callViewModel.callingState else {
+            XCTFail()
+            return
+        }
+        XCTAssert(call.id == callId)
+
+        // When we receive an accept even it means we accepted somewhere else
+        eventNotificationCenter.process(
+            .coordinatorEvent(
+                .typeCallAcceptedEvent(
+                    .dummy(
+                        callCid: "default:\(String.unique)",
+                        user: secondUser.user.toUserResponse()
+                    )
+                )
+            )
+        )
+
+        // Then
+        try await XCTAssertWithDelay(
+            {
+                switch callViewModel.callingState {
+                case .incoming:
+                    return true
+                default:
+                    return false
+                }
+            }()
+        )
+    }
+
     @MainActor
     func test_incomingCall_rejectCall() async throws {
         // Given