fix: consume direct flow to preserve behvior or app lifecycle observer (WPB-22609)

app/src/main/kotlin/com/wire/android/util/lifecycle/SyncLifecycleManager.kt

@@ -28,13 +28,13 @@ import com.wire.kalium.logger.obfuscateDomain
 import com.wire.kalium.logger.obfuscateId
 import com.wire.kalium.logic.CoreLogic
 import com.wire.kalium.logic.data.user.UserId
+import com.wire.kalium.logic.feature.session.GetAllSessionsResult
 import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -58,32 +58,32 @@ class SyncLifecycleManager @Inject constructor(
      * Should be called only once on a global level
      */
     suspend fun observeAppLifecycle() {
-        coreLogic.getGlobalScope().observeValidAccounts()
-            .filter { pairs -> pairs.isNotEmpty() }
-            .map { pairs ->
-                pairs.map { (selfUser, _) ->
-                    selfUser.id
+        coreLogic.getGlobalScope().observeAllValidSessionsFlow()
+            .map { result ->
+                when (result) {
+                    is GetAllSessionsResult.Success -> result.sessions
+                    is GetAllSessionsResult.Failure -> emptyList()
                 }
-            }.combine(currentScreenManager.isAppVisibleFlow(), ::Pair)
+            }
+            .combine(currentScreenManager.isAppVisibleFlow()) { accounts, isAppVisible ->
+                accounts to isAppVisible
+            }
             .distinctUntilChanged()
-            .collectLatest { (userIds, isAppVisible) ->
-                if (isAppVisible) {
-                    logger.i(
-                        "App moved to foreground, " +
-                                "starting sync requests for users: ${userIds.joinToString { it.value.obfuscateId() }}"
-                    )
-                    coroutineScope {
-                        userIds.forEach { userId ->
-                            launch {
-                                logger.i("!!!!! Starting foreground sync request for user ${userId.value.obfuscateId()}.")
-                                coreLogic.getSessionScope(userId).syncExecutor.request {
-                                    awaitCancellation()
-                                }
+            .collectLatest { (accounts, isAppVisible) ->
+                if (!isAppVisible) {
+                    logger.i("Not running foreground sync request for users, as App is not visible.")
+                    return@collectLatest
+                }
+                coroutineScope {
+                    accounts.forEach { accountInfo ->
+                        val userId = accountInfo.userId
+                        launch {
+                            logger.i("!!!!! Starting foreground sync request for user ${userId.value.obfuscateId()}.")
+                            coreLogic.getSessionScope(userId).syncExecutor.request {
+                                awaitCancellation()
                             }
                         }
                     }
-                } else {
-                    logger.i("App moved to background, no longer running foreground sync requests for users.")
                 }
             }
     }

app/src/test/kotlin/com/wire/android/util/lifecycle/SyncLifecycleManagerTest.kt

@@ -22,8 +22,10 @@ import com.wire.android.framework.TestUser
 import com.wire.android.framework.fake.FakeSyncExecutor
 import com.wire.android.util.CurrentScreenManager
 import com.wire.kalium.logic.CoreLogic
+import com.wire.kalium.logic.data.auth.AccountInfo
 import com.wire.kalium.logic.feature.UserSessionScope
-import com.wire.kalium.logic.feature.user.ObserveValidAccountsUseCase
+import com.wire.kalium.logic.feature.session.GetAllSessionsResult
+import com.wire.kalium.logic.feature.session.ObserveSessionsUseCase
 import io.mockk.MockKAnnotations
 import io.mockk.coEvery
 import io.mockk.every
@@ -108,7 +110,7 @@ class SyncLifecycleManagerTest {
         lateinit var userSessionScope: UserSessionScope
 
         @MockK
-        lateinit var observeValidAccountsUseCase: ObserveValidAccountsUseCase
+        lateinit var observeValidAccountsUseCase: ObserveSessionsUseCase
 
         var syncExecutor = FakeSyncExecutor()
 
@@ -118,11 +120,13 @@ class SyncLifecycleManagerTest {
 
         init {
             MockKAnnotations.init(this, relaxUnitFun = true)
-            every { coreLogic.getGlobalScope().observeValidAccounts } returns observeValidAccountsUseCase
+            every { coreLogic.getGlobalScope().observeAllValidSessionsFlow } returns observeValidAccountsUseCase
             every { coreLogic.getSessionScope(TestUser.SELF_USER_ID) } returns userSessionScope
             coEvery { observeValidAccountsUseCase.invoke() } returns flowOf(
-                listOf(
-                    TestUser.SELF_USER to null
+                GetAllSessionsResult.Success(
+                    listOf(
+                        AccountInfo.Valid(TestUser.SELF_USER_ID)
+                    )
                 )
             )
         }