Merge develop into develop-v2

README.md

@@ -14,8 +14,8 @@
 
 <div align="center">
 
-![stream-video-android-core](https://img.shields.io/badge/stream--video--android--core-12.30%20MB-lightgreen)
-![stream-video-android-ui-xml](https://img.shields.io/badge/stream--video--android--ui--xml-5.69%20MB-lightgreen)
+![stream-video-android-core](https://img.shields.io/badge/stream--video--android--core-12.36%20MB-lightgreen)
+![stream-video-android-ui-xml](https://img.shields.io/badge/stream--video--android--ui--xml-5.67%20MB-lightgreen)
 ![stream-video-android-ui-compose](https://img.shields.io/badge/stream--video--android--ui--compose-6.23%20MB-lightgreen)
 
 </div>

demo-app/src/androidTestE2etestingDebug/kotlin/io/getstream/video/android/pages/DirectCallPage.kt

@@ -22,6 +22,7 @@ class DirectCallPage {
 
     companion object {
         val participantName = By.res("Stream_DirectCallUserName")
+        val joinAndRingCheckbox = By.res("Stream_JoinAndRingCheckbox")
         val audioCallButton = By.res("Stream_AudioCallButton")
         val videoCallButton = By.res("Stream_VideoCallButton")
     }

demo-app/src/androidTestE2etestingDebug/kotlin/io/getstream/video/android/robots/UserRobot.kt

@@ -74,9 +74,14 @@ class UserRobot {
         return this
     }
 
-    fun directCall(audioOnly: Boolean): UserRobot {
+    fun directCall(audioOnly: Boolean, joinAndRing: Boolean = false): UserRobot {
         CallDetailsPage.wheelIcon.waitToAppearAndClick()
         CallDetailsPage.directCallButton.waitToAppearAndClick()
+        DirectCallPage.joinAndRingCheckbox.waitToAppear().let { checkbox ->
+            if (checkbox.isChecked != joinAndRing) {
+                checkbox.click()
+            }
+        }
         DirectCallPage.participantName.waitToAppearAndClick()
         val callButton = if (audioOnly) audioCallButton else videoCallButton
         callButton.waitToAppearAndClick()
@@ -103,7 +108,10 @@ class UserRobot {
         if (callId != null) {
             CallDetailsPage.callIdInputField.waitToAppear().typeText(callId)
         }
-        CallDetailsPage.joinCallButton.waitToAppearAndClick()
+        // The call details screen is the first screen after launch or login, so this wait
+        // overlaps app startup on an emulator that is still settling. The 5s default was the
+        // single most common nightly failure, so the window is deliberately wider.
+        CallDetailsPage.joinCallButton.waitToAppearAndClick(timeOutMillis = 15.seconds)
         waitForLobbyToOpen()
         return this
     }
@@ -122,7 +130,9 @@ class UserRobot {
     }
 
     private fun waitForLobbyToOpen(): UserRobot {
-        LobbyPage.closeButton.waitToAppear()
+        // Reached right after a login, so the lobby composes while the app is still starting
+        // up. At the 5s default this failed about half the time locally on the re-enter tests.
+        LobbyPage.closeButton.waitToAppear(timeOutMillis = 15.seconds)
         return this
     }
 
@@ -150,7 +160,9 @@ class UserRobot {
     }
 
     fun waitForIncomingCall(): UserRobot {
-        RingPage.acceptCallButton.waitToAppear(timeOutMillis = 15.seconds)
+        // Ring delivery goes through the coordinator and the push or socket path before the
+        // incoming screen renders, and 15s timed out on the nightlies.
+        RingPage.acceptCallButton.waitToAppear(timeOutMillis = 30.seconds)
         return this
     }
 
@@ -337,7 +349,8 @@ class UserRobot {
         CallPage.callViewButton.waitToAppearAndClick()
         // With many live video tiles the emulator UI is busy, and the opened menu can take
         // several seconds to land in the accessibility tree, so the items get a wide window.
-        val timeOutMillis = 15.seconds
+        // 15s still timed out on the six-participant test, so the window is wider again.
+        val timeOutMillis = 30.seconds
         when (mode) {
             VideoView.DYNAMIC -> CallPage.ViewMenu.dynamic.waitToAppearAndClick(timeOutMillis)
             VideoView.SPOTLIGHT -> CallPage.ViewMenu.spotlight.waitToAppearAndClick(timeOutMillis)
@@ -353,15 +366,18 @@ class UserRobot {
 
     fun acceptCallRecording(): UserRobot {
         // The recording-consent dialog only appears once the backend composite recorder
-        // emits call.recording_started, which can take 20-30s, so 10s is too short.
-        CallPage.RecordingButtons.accept.waitToAppearAndClick(timeOutMillis = 30.seconds)
+        // emits call.recording_started. The buddy starts the recording within seconds, so
+        // this wait is really the recorder's start-up latency: usually 10-20s, but 30s still
+        // timed out four times in the nightlies. Callers with a recording window have to
+        // outlive this wait, see testReconnectionDuringCallRecording.
+        CallPage.RecordingButtons.accept.waitToAppearAndClick(timeOutMillis = 60.seconds)
         return this
     }
 
     fun declineCallRecording(): UserRobot {
         // See acceptCallRecording: the consent dialog is gated on the backend recorder
-        // starting (call.recording_started), which can take 20-30s.
-        CallPage.RecordingButtons.leave.waitToAppearAndClick(timeOutMillis = 30.seconds)
+        // starting (call.recording_started).
+        CallPage.RecordingButtons.leave.waitToAppearAndClick(timeOutMillis = 60.seconds)
         return this
     }
 

demo-app/src/androidTestE2etestingDebug/kotlin/io/getstream/video/android/robots/UserRobotCallAsserts.kt

@@ -32,6 +32,7 @@ import io.getstream.video.android.uiautomator.findObjects
 import io.getstream.video.android.uiautomator.isDisplayed
 import io.getstream.video.android.uiautomator.retryOnStaleObjectException
 import io.getstream.video.android.uiautomator.seconds
+import io.getstream.video.android.uiautomator.wait
 import io.getstream.video.android.uiautomator.waitDisplayed
 import io.getstream.video.android.uiautomator.waitForCount
 import io.getstream.video.android.uiautomator.waitForText
@@ -130,8 +131,10 @@ fun UserRobot.assertBackground(background: Background, isEnabled: Boolean): User
         Background.IMAGE -> SettingsMenu.imageBackgroundEnabledToggle
         Background.BLUR -> SettingsMenu.blurBackgroundEnabledToggle
     }
-    val expectedCount = if (isEnabled) 1 else 0
-    assertEquals(expectedCount, locator.findObjects().size)
+    // The menu items land in the accessibility tree a moment after the sheet opens, so an
+    // instant count right after settings(ENABLE) can read 0 for a toggle that is there.
+    val toggles = if (isEnabled) locator.wait().findObjects() else locator.waitToDisappear().findObjects()
+    assertEquals(if (isEnabled) 1 else 0, toggles.size)
     return this
 }
 
@@ -270,7 +273,12 @@ fun UserRobot.assertSpotlightView(): UserRobot {
 
 fun UserRobot.assertIncomingCall(isDisplayed: Boolean): UserRobot {
     if (isDisplayed) {
-        assertTrue("Accept call button", RingPage.acceptCallButton.waitToAppear().isDisplayed())
+        // Often the first wait after the participant rings, so it carries the whole ring
+        // delivery latency. Same budget as waitForIncomingCall.
+        assertTrue(
+            "Accept call button",
+            RingPage.acceptCallButton.waitToAppear(timeOutMillis = 30.seconds).isDisplayed(),
+        )
         assertTrue("Decline call button", RingPage.declineCallButton.isDisplayed())
         assertTrue("Call label", RingPage.incomingCallLabel.isDisplayed())
         assertTrue("Avatar", RingPage.callParticipantAvatar.isDisplayed())
@@ -292,12 +300,20 @@ fun UserRobot.assertOutgoingCall(audioOnly: Boolean = true, isDisplayed: Boolean
         // muted state right after the screen renders), so poll instead of instant asserts.
         assertTrue("Call label", RingPage.outgoingCallLabel.waitDisplayed())
         assertTrue("Avatar", RingPage.callParticipantAvatar.waitDisplayed())
-        assertTrue("Microphone", RingPage.microphoneEnabledToggle.waitDisplayed())
+        assertTrue(
+            "Microphone",
+            RingPage.microphoneEnabledToggle.waitDisplayed() ||
+                RingPage.microphoneDisabledToggle.waitDisplayed(),
+        )
         if (audioOnly) {
             assertFalse("Camera enabled toggle", RingPage.cameraEnabledToggle.isDisplayed())
             assertFalse("Camera disabled toggle", RingPage.cameraDisabledToggle.isDisplayed())
         } else {
-            assertTrue("Camera", RingPage.cameraEnabledToggle.waitDisplayed())
+            assertTrue(
+                "Camera",
+                RingPage.cameraEnabledToggle.waitDisplayed() ||
+                    RingPage.cameraDisabledToggle.waitDisplayed(),
+            )
         }
     } else {
         assertFalse(

demo-app/src/androidTestE2etestingDebug/kotlin/io/getstream/video/android/tests/ReconnectionTests.kt

@@ -114,13 +114,14 @@ class ReconnectionTests : StreamTestCase() {
         }
         step("AND participant joins the call") {
             // The recording window counts from the participant's start request, and the
-            // composite recorder alone can take 20-30s to start. The window has to outlive
-            // the drop, the reconnect and the final polling assert on a slow CI emulator,
-            // otherwise the participant stops the recording on schedule before the assert
-            // and the test fails on a recording that legitimately ended.
+            // composite recorder alone can take up to the 60s acceptCallRecording waits for.
+            // The window has to outlive that, the drop, the reconnect and the final polling
+            // assert on a slow CI emulator, otherwise the participant stops the recording on
+            // schedule before the assert and the test fails on a recording that
+            // legitimately ended.
             participantRobot
                 .setUserCount(participants)
-                .setCallRecordingDuration(90)
+                .setCallRecordingDuration(120)
                 .joinCall(callId, actions = arrayOf(Actions.RECORD_CALL))
         }
         step("AND participant starts recording a call") {

demo-app/src/androidTestE2etestingDebug/kotlin/io/getstream/video/android/tests/RingingTests.kt

@@ -16,6 +16,10 @@
 
 package io.getstream.video.android.tests
 
+import io.getstream.video.android.core.Call
+import io.getstream.video.android.core.RealtimeConnection
+import io.getstream.video.android.core.RingingState
+import io.getstream.video.android.core.StreamVideo
 import io.getstream.video.android.robots.UserControls.DISABLE
 import io.getstream.video.android.robots.assertAudioCallControls
 import io.getstream.video.android.robots.assertConnectingView
@@ -24,12 +28,114 @@ import io.getstream.video.android.robots.assertOutgoingCall
 import io.getstream.video.android.robots.assertOutgoingCallNotification
 import io.getstream.video.android.robots.assertThatCallIsEnded
 import io.getstream.video.android.robots.assertVideoCallControls
+import io.getstream.video.android.uiautomator.seconds
 import io.qameta.allure.kotlin.Allure.step
 import io.qameta.allure.kotlin.AllureId
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.withTimeoutOrNull
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class RingingTests : StreamTestCase() {
 
+    @Test
+    fun testJoinAndRingRemainsOutgoingAfterFastReconnectBeforeCalleeAccepts() {
+        startUnansweredJoinAndRingCall()
+
+        step("WHEN the caller completes a fast reconnect before the callee accepts") {
+            reconnectOutgoingCall(expectSessionReplacement = false) {
+                fastReconnect("E2E: outgoing join-and-ring")
+            }
+        }
+        step("THEN the outgoing call screen is still displayed") {
+            userRobot.assertOutgoingCall(audioOnly = false, isDisplayed = true)
+        }
+
+        userRobot.declineOutgoingCall()
+    }
+
+    @Test
+    fun testJoinAndRingRemainsOutgoingAfterRejoinBeforeCalleeAccepts() {
+        startUnansweredJoinAndRingCall()
+
+        step("WHEN the caller completes a rejoin before the callee accepts") {
+            reconnectOutgoingCall(expectSessionReplacement = true) {
+                rejoin("E2E: outgoing join-and-ring")
+            }
+        }
+        step("THEN the outgoing call screen is still displayed") {
+            userRobot.assertOutgoingCall(audioOnly = false, isDisplayed = true)
+        }
+
+        userRobot.declineOutgoingCall()
+    }
+
+    private fun startUnansweredJoinAndRingCall() {
+        step("GIVEN the caller joins first and rings a callee who has not accepted") {
+            // Do not start the participant robot: the selected callee remains unanswered.
+            userRobot
+                .logout()
+                .loginAsRandomUser()
+                .directCall(audioOnly = false, joinAndRing = true)
+                .assertOutgoingCall(audioOnly = false, isDisplayed = true)
+        }
+    }
+
+    private fun reconnectOutgoingCall(
+        expectSessionReplacement: Boolean,
+        reconnect: suspend Call.() -> Unit,
+    ) {
+        val call = requireNotNull(StreamVideo.instance().state.ringingCall.value) {
+            "Expected the join-and-ring call to be registered as the ringing call"
+        }
+        assertTrue(call.state.ringingState.value is RingingState.Outgoing)
+        assertEquals(RealtimeConnection.Connected, call.state.connection.value)
+        val sessionIdBeforeReconnect = call.sessionId
+
+        runBlocking {
+            // Subscribe before triggering the reconnect so a fast Reconnecting transition
+            // cannot be missed by a polling assertion.
+            val enteredReconnecting = async(start = CoroutineStart.UNDISPATCHED) {
+                call.state.connection.first { it is RealtimeConnection.Reconnecting }
+            }
+            val reconnectCompleted = async {
+                reconnect(call)
+            }
+
+            val reconnectingState = withTimeoutOrNull(30.seconds) {
+                enteredReconnecting.await()
+            }
+            assertNotNull(
+                "Expected the connection to enter Reconnecting within 30 seconds, " +
+                    "but its current state is ${call.state.connection.value}",
+                reconnectingState,
+            )
+            withTimeout(60.seconds) { reconnectCompleted.await() }
+            val connectedState = withTimeoutOrNull(30.seconds) {
+                call.state.connection.first { it is RealtimeConnection.Connected }
+            }
+            assertNotNull(
+                "Expected the connection to recover to Connected within 30 seconds, " +
+                    "but its current state is ${call.state.connection.value}",
+                connectedState,
+            )
+        }
+
+        if (expectSessionReplacement) {
+            assertNotEquals(sessionIdBeforeReconnect, call.sessionId)
+        } else {
+            assertEquals(sessionIdBeforeReconnect, call.sessionId)
+        }
+        assertTrue(call.state.ringingState.value is RingingState.Outgoing)
+    }
+
     @AllureId("7774")
     @Test
     fun testParticipantRejectsTheOutgoingCall() {