Merge branch 'develop' into chore/merge-develop-into-develop-v2

Bring in the NC signal test hardening, join-after-relogin wait, and stopService null-check from develop, keeping the v2 StreamClient cleanup tests.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: PratimMallick

demo-app/src/main/kotlin/io/getstream/video/android/ui/join/CallJoinViewModel.kt

@@ -31,6 +31,7 @@ import io.getstream.video.android.model.User
 import io.getstream.video.android.model.mapper.isValidCallCid
 import io.getstream.video.android.model.mapper.toTypeAndId
 import io.getstream.video.android.tooling.util.StreamBuildFlavorUtil
+import io.getstream.video.android.util.InitializedState
 import io.getstream.video.android.util.NetworkMonitor
 import io.getstream.video.android.util.StreamVideoInitHelper
 import io.getstream.video.android.util.fcmToken
@@ -41,6 +42,7 @@ import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.shareIn
@@ -69,7 +71,11 @@ class CallJoinViewModel @Inject constructor(
                 }
                 is CallJoinEvent.JoinCall -> {
                     val call = joinCall(event.callId)
-                    flowOf(CallJoinUiState.JoinCompleted(callId = call.cid))
+                    if (call != null) {
+                        flowOf(CallJoinUiState.JoinCompleted(callId = call.cid))
+                    } else {
+                        flowOf(CallJoinUiState.GoBackToLogin)
+                    }
                 }
                 is CallJoinEvent.JoinCompleted -> flowOf(
                     CallJoinUiState.JoinCompleted(event.callId),
@@ -110,8 +116,18 @@ class CallJoinViewModel @Inject constructor(
         viewModelScope.launch { this@CallJoinViewModel.event.emit(event) }
     }
 
-    private fun joinCall(callId: String? = null): Call {
-        val streamVideo = StreamVideo.instance()
+    private suspend fun joinCall(callId: String? = null): Call? {
+        // A fast re-login lands on this screen while StreamVideoInitHelper.loadSdk, started in
+        // init, is still rebuilding the SDK, so the instance may not be installed yet at tap
+        // time. loadSdk returns early when another initialization is already in flight, so the
+        // helper's terminal state must be awaited before reading the instance.
+        if (!StreamVideo.isInstalled) {
+            StreamVideoInitHelper.loadSdk(dataStore = dataStore)
+            StreamVideoInitHelper.initializedState.first {
+                it == InitializedState.FINISHED || it == InitializedState.FAILED
+            }
+        }
+        val streamVideo = StreamVideo.instanceOrNull() ?: return null
         val newCallId = callId ?: "default:${UUID.randomUUID()}"
         val (type, id) = if (newCallId.isValidCallCid()) {
             newCallId.toTypeAndId()

stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/NoiseCancellationSignalTest.kt

@@ -32,13 +32,15 @@ import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 import stream.video.sfu.signal.StartNoiseCancellationResponse
 import stream.video.sfu.signal.StopNoiseCancellationResponse
+import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.test.assertEquals
 
 @RunWith(RobolectricTestRunner::class)
 class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = false) {
 
     private companion object {
         const val SIGNAL_TIMEOUT_MS = 5_000L
+        const val SIGNAL_POLL_MS = 10L
     }
 
     /**
@@ -80,8 +82,8 @@ class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = f
     }
 
     /** Records the state of every signal the SFU receives, in the order it receives them. */
-    private fun record(session: RtcSession): MutableList<Boolean> {
-        val signalled = mutableListOf<Boolean>()
+    private fun record(session: RtcSession): List<Boolean> {
+        val signalled = CopyOnWriteArrayList<Boolean>()
         coEvery { session.startNoiseCancellation() } coAnswers {
             signalled += true
             Result.Success(mockk<StartNoiseCancellationResponse>(relaxed = true))
@@ -93,6 +95,29 @@ class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = f
         return signalled
     }
 
+    /**
+     * MockK records the mocked call before the answer body runs, and the append to the list
+     * happens on the signal coroutine, so right after a passing coVerify the recorded signals
+     * may not be visible to the test thread yet. Polls until they match instead of asserting
+     * on a snapshot.
+     */
+    private fun awaitSignalled(signalled: List<Boolean>, expected: List<Boolean>) {
+        val deadline = System.currentTimeMillis() + SIGNAL_TIMEOUT_MS
+        while (signalled != expected && System.currentTimeMillis() < deadline) {
+            Thread.sleep(SIGNAL_POLL_MS)
+        }
+        assertEquals(expected, signalled.toList())
+    }
+
+    /** Same visibility caveat as [awaitSignalled], for a test where only the final state matters. */
+    private fun awaitFinalSignal(signalled: List<Boolean>, expected: Boolean) {
+        val deadline = System.currentTimeMillis() + SIGNAL_TIMEOUT_MS
+        while (signalled.lastOrNull() != expected && System.currentTimeMillis() < deadline) {
+            Thread.sleep(SIGNAL_POLL_MS)
+        }
+        assertEquals(expected, signalled.lastOrNull())
+    }
+
     @Test
     fun `enabling audio processing signals the SFU that noise cancellation started`() = runTest {
         val (call, session) = callWithProcessor()
@@ -158,7 +183,7 @@ class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = f
         call.injectSession(session)
 
         coVerify(timeout = SIGNAL_TIMEOUT_MS) { session.startNoiseCancellation() }
-        assertEquals(listOf(true), signalled)
+        awaitSignalled(signalled, listOf(true))
     }
 
     @Test
@@ -174,7 +199,7 @@ class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = f
         call.injectSession(replacement)
 
         coVerify(timeout = SIGNAL_TIMEOUT_MS) { replacement.startNoiseCancellation() }
-        assertEquals(listOf(true), signalled)
+        awaitSignalled(signalled, listOf(true))
     }
 
     @Test
@@ -190,7 +215,7 @@ class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = f
 
         // Waiting on the stop means every signal before it has already landed.
         coVerify(timeout = SIGNAL_TIMEOUT_MS) { session.stopNoiseCancellation() }
-        assertEquals(false, signalled.last())
+        awaitFinalSignal(signalled, expected = false)
     }
 
     @Test
@@ -212,6 +237,6 @@ class NoiseCancellationSignalTest : IntegrationTestBase(connectCoordinatorWS = f
         call.injectSession(session)
 
         coVerify(timeout = SIGNAL_TIMEOUT_MS) { session.startNoiseCancellation() }
-        assertEquals(listOf(true), signalled)
+        awaitSignalled(signalled, listOf(true))
     }
 }

stream-video-android-core/src/test/kotlin/io/getstream/video/android/core/StreamVideoClientCleanupTest.kt

@@ -16,19 +16,23 @@
 
 package io.getstream.video.android.core
 
+import android.app.ActivityManager
+import android.content.ComponentName
 import android.content.Context
 import androidx.lifecycle.Lifecycle
 import io.getstream.android.core.api.StreamClient
 import io.getstream.android.core.api.model.connection.StreamConnectionState
 import io.getstream.android.core.api.subscribe.StreamSubscription
 import io.getstream.video.android.core.internal.module.CoordinatorConnectionModule
+import io.getstream.video.android.core.notifications.internal.service.CallService
 import io.getstream.video.android.model.User
 import io.getstream.video.android.model.UserType
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.unmockkAll
+import io.mockk.verify
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.isActive
@@ -44,7 +48,8 @@ import kotlin.test.assertTrue
 /**
  * Runs under Robolectric so a real main looper exists and the test thread is the main thread,
  * which is exactly the situation an app is in when it calls StreamVideo.removeClient() from
- * a logout button handler.
+ * a logout button handler. The stop intent inside cleanup() is also a real Intent instead of
+ * a stubbed one that returns null from every builder call.
  */
 @RunWith(RobolectricTestRunner::class)
 class StreamVideoClientCleanupTest {
@@ -74,11 +79,20 @@ class StreamVideoClientCleanupTest {
         )
     }
 
+    private fun mockContext(runningServices: List<ActivityManager.RunningServiceInfo>): Context {
+        val context = mockk<Context>(relaxed = true)
+        val activityManager = mockk<ActivityManager>()
+        every { context.getSystemService(Context.ACTIVITY_SERVICE) } returns activityManager
+        every { activityManager.getRunningServices(any()) } returns runningServices
+        return context
+    }
+
     private fun buildClient(
         streamClient: StreamClient,
+        context: Context = mockk(relaxed = true),
         cleanupDisconnectTimeoutMs: Long = 10_000L,
     ): StreamVideoClient = StreamVideoClient(
-        context = mockk<Context>(relaxed = true),
+        context = context,
         initialUser = User(id = "user-1", type = UserType.Authenticated),
         apiKey = "apikey",
         token = "token",
@@ -205,4 +219,30 @@ class StreamVideoClientCleanupTest {
         // timeout branch ran instead of waiting for the disconnect.
         awaitScopeCancelled(client)
     }
+
+    // buildStopIntent returns null when the call service is not running. Passing the null
+    // through to stopService used to throw a NullPointerException, swallowed by safeCall,
+    // on every logout without a running call service. AND-1466 / #1794.
+    @Test
+    fun `cleanup does not call stopService when the call service is not running`() {
+        val context = mockContext(runningServices = emptyList())
+        val client = buildClient(mockStreamClient(), context)
+
+        client.cleanup()
+
+        verify(exactly = 0) { context.stopService(any()) }
+    }
+
+    @Test
+    fun `cleanup stops the call service when it is running`() {
+        val runningService = ActivityManager.RunningServiceInfo().apply {
+            service = ComponentName("io.getstream.video.android", CallService::class.java.name)
+        }
+        val context = mockContext(runningServices = listOf(runningService))
+        val client = buildClient(mockStreamClient(), context)
+
+        client.cleanup()
+
+        verify(exactly = 1) { context.stopService(any()) }
+    }
 }