feat: Observe cells flags use cases (WPB-25214) (#4204)

* feat: use case to check viewer access for self user on a conversation

* feat: cleanup

* feat: cleanup

* chore: address comment

* feat: add use cases to observe cells flags

Author: ohassine

data/persistence/src/commonMain/kotlin/com/wire/kalium/persistence/dao/UserConfigDAO.kt

@@ -73,6 +73,7 @@ interface UserConfigDAO {
     suspend fun getAsyncNotificationsEnabled(): Boolean
     suspend fun setCellsEnabled(enabled: Boolean)
     suspend fun isCellsEnabled(): Boolean
+    suspend fun observeIsCellsEnabled(): Flow<Boolean>
     suspend fun setAppsEnabled(isAppsEnabled: Boolean)
     suspend fun getAppsEnabled(): Boolean
     fun observeAppsEnabled(): Flow<Boolean>
@@ -266,6 +267,9 @@ internal class UserConfigDAOImpl internal constructor(
     override suspend fun isCellsEnabled(): Boolean =
         metadataDAO.valueByKey(CELLS_ENABLED)?.toBoolean() ?: false
 
+    override suspend fun observeIsCellsEnabled(): Flow<Boolean> =
+        metadataDAO.valueByKeyFlow(CELLS_ENABLED).map { it.toBoolean() }
+
     override suspend fun setProfileQRCodeEnabled(enabled: Boolean) {
         metadataDAO.insertValue(enabled.toString(), PROFILE_QR_CODE_ENABLED)
     }

data/persistence/src/commonMain/kotlin/com/wire/kalium/persistence/dao/conversation/ConversationDAO.kt

@@ -183,6 +183,7 @@ interface ConversationDAO {
 
     suspend fun getCellName(conversationId: QualifiedIDEntity): String?
     suspend fun hasConversationWithCell(): Boolean
+    suspend fun observeHasConversationWithCell(): Flow<Boolean>
     suspend fun updateReadDateAndGetHasUnreadEvents(conversationID: QualifiedIDEntity, date: Instant): Boolean
     suspend fun updateReadDatesAndGetHasUnreadEvents(conversationDates: Map<QualifiedIDEntity, Instant>): Map<QualifiedIDEntity, Boolean>
     suspend fun getMLSConversationsByDomain(domain: String): List<ConversationEntity>

data/persistence/src/commonMain/kotlin/com/wire/kalium/persistence/dao/conversation/ConversationDAOImpl.kt

@@ -21,8 +21,6 @@ package com.wire.kalium.persistence.dao.conversation
 import app.cash.sqldelight.async.coroutines.awaitAsList
 import app.cash.sqldelight.async.coroutines.awaitAsOne
 import app.cash.sqldelight.async.coroutines.awaitAsOneOrNull
-import app.cash.sqldelight.async.coroutines.await
-
 import app.cash.sqldelight.coroutines.asFlow
 import com.wire.kalium.persistence.ConversationDetailsQueries
 import com.wire.kalium.persistence.ConversationDetailsWithEventsQueries
@@ -748,6 +746,11 @@ internal class ConversationDAOImpl internal constructor(
         conversationQueries.hasConversationWithCell().awaitAsOne()
     }
 
+    override suspend fun observeHasConversationWithCell(): Flow<Boolean> =
+        conversationQueries.hasConversationWithCell().asFlow()
+            .mapToOneOrDefault(false)
+            .flowOn(readDispatcher.value)
+
     override suspend fun updateReadDateAndGetHasUnreadEvents(
         conversationID: QualifiedIDEntity,
         date: Instant

domain/cells/src/commonMain/kotlin/com/wire/kalium/cells/CellsScope.kt

@@ -131,6 +131,8 @@ import com.wire.kalium.cells.domain.usecase.GetConversationNameUseCase
 import com.wire.kalium.cells.domain.usecase.GetConversationNameUseCaseImpl
 import com.wire.kalium.cells.domain.usecase.GetUserNameUseCase
 import com.wire.kalium.cells.domain.usecase.GetUserNameUseCaseImpl
+import com.wire.kalium.cells.domain.usecase.ObserveIsAtLeastOneCellAvailableUseCase
+import com.wire.kalium.cells.domain.usecase.ObserveIsAtLeastOneCellAvailableUseCaseImpl
 import com.wire.kalium.cells.domain.usecase.offline.GetOfflineFileUseCase
 import com.wire.kalium.cells.domain.usecase.offline.GetOfflineFileUseCaseImpl
 import com.wire.kalium.cells.domain.usecase.offline.ObserveOfflineFilesUseCase
@@ -366,6 +368,9 @@ public class CellsScope(
     public val isCellAvailable: IsAtLeastOneCellAvailableUseCase by lazy {
         IsAtLeastOneCellAvailableUseCaseImpl(cellsConversationRepository)
     }
+    public val observeIsCellAvailable: ObserveIsAtLeastOneCellAvailableUseCase by lazy {
+        ObserveIsAtLeastOneCellAvailableUseCaseImpl(cellsConversationRepository)
+    }
 
     public val getMessageAttachmentUseCase: GetMessageAttachmentUseCase by lazy {
         GetMessageAttachmentUseCaseImpl(cellAttachmentsRepository)

domain/cells/src/commonMain/kotlin/com/wire/kalium/cells/data/CellConversationDataSource.kt

@@ -30,6 +30,7 @@ import com.wire.kalium.persistence.dao.conversation.ConversationDAO
 import com.wire.kalium.persistence.dao.conversation.ConversationEntity
 import com.wire.kalium.util.KaliumDispatcher
 import com.wire.kalium.util.KaliumDispatcherImpl
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.withContext
 
@@ -72,6 +73,13 @@ internal class CellConversationDataSource(
             }
         }
 
+    override suspend fun observeHasConversationWithCell(): Either<StorageFailure, Flow<Boolean>> =
+        withContext(dispatchers.io) {
+            wrapStorageRequest {
+                conversationDao.observeHasConversationWithCell()
+            }
+        }
+
     override suspend fun getCellGroupConversations(): Either<StorageFailure, List<CellConversation>> =
         withContext(dispatchers.io) {
             wrapStorageRequest {

domain/cells/src/commonMain/kotlin/com/wire/kalium/cells/domain/CellConversationRepository.kt

@@ -21,12 +21,14 @@ import com.wire.kalium.cells.domain.model.CellConversation
 import com.wire.kalium.common.error.StorageFailure
 import com.wire.kalium.common.functional.Either
 import com.wire.kalium.persistence.dao.QualifiedIDEntity
+import kotlinx.coroutines.flow.Flow
 
 internal interface CellConversationRepository {
     suspend fun getCellName(conversationId: QualifiedIDEntity): Either<StorageFailure, String?>
     suspend fun getConversationNames(): Either<StorageFailure, List<Pair<String, String>>>
     suspend fun getConversationNameById(conversationId: String): Either<StorageFailure, String?>
     suspend fun hasConversationWithCell(): Either<StorageFailure, Boolean>
+    suspend fun observeHasConversationWithCell(): Either<StorageFailure, Flow<Boolean>>
     suspend fun getCellGroupConversations(): Either<StorageFailure, List<CellConversation>>
     suspend fun getPaginatedCellGroupConversations(
         limit: Int,

domain/cells/src/commonMain/kotlin/com/wire/kalium/cells/domain/usecase/ObserveIsAtLeastOneCellAvailableUseCase.kt

@@ -0,0 +1,38 @@
+/*
+ * Wire
+ * Copyright (C) 2026 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+package com.wire.kalium.cells.domain.usecase
+
+import com.wire.kalium.cells.domain.CellConversationRepository
+import com.wire.kalium.common.error.StorageFailure
+import com.wire.kalium.common.functional.Either
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Use case to observe if there is at least one conversation available with cell feature enabled.
+ * This is required to determine if we can call Cell API methods without getting a Not Authenticated error.
+ */
+public interface ObserveIsAtLeastOneCellAvailableUseCase {
+    public suspend operator fun invoke(): Either<StorageFailure, Flow<Boolean>>
+}
+
+internal class ObserveIsAtLeastOneCellAvailableUseCaseImpl(
+    private val conversationRepository: CellConversationRepository
+) : ObserveIsAtLeastOneCellAvailableUseCase {
+
+    override suspend fun invoke(): Either<StorageFailure, Flow<Boolean>> = conversationRepository.observeHasConversationWithCell()
+}

logic/src/commonMain/kotlin/com/wire/kalium/logic/configuration/UserConfigRepository.kt

@@ -156,6 +156,7 @@ internal interface UserConfigRepository {
     suspend fun isAsyncNotificationsEnabled(): Boolean
     suspend fun setCellsEnabled(enabled: Boolean): Either<StorageFailure, Unit>
     suspend fun isCellsEnabled(): Boolean
+    suspend fun observeIsCellsEnabled(): Flow<Boolean>
     suspend fun setAppsEnabled(isAppsEnabled: Boolean): Either<StorageFailure, Unit>
     suspend fun isAppsEnabled(): Boolean
     fun observeAppsEnabled(): Flow<Either<StorageFailure, Boolean>>
@@ -584,6 +585,8 @@ internal class UserConfigDataSource internal constructor(
 
     override suspend fun isCellsEnabled(): Boolean = userConfigDAO.isCellsEnabled()
 
+    override suspend fun observeIsCellsEnabled(): Flow<Boolean> = userConfigDAO.observeIsCellsEnabled()
+
     override suspend fun setAppsEnabled(isAppsEnabled: Boolean): Either<StorageFailure, Unit> =
         wrapStorageRequest {
             userConfigDAO.setAppsEnabled(isAppsEnabled)

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/client/ObserveIsWireCellsEnabledUseCase.kt

@@ -0,0 +1,34 @@
+/*
+ * Wire
+ * Copyright (C) 2026 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+package com.wire.kalium.logic.feature.client
+
+import com.wire.kalium.logic.configuration.UserConfigRepository
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Use case to observe if Wire Cells feature is enabled.
+ */
+public interface ObserveIsWireCellsEnabledUseCase {
+    public suspend operator fun invoke(): Flow<Boolean>
+}
+
+internal class ObserveIsWireCellsEnabledUseCaseImpl(
+    private val userConfigRepository: UserConfigRepository,
+) : ObserveIsWireCellsEnabledUseCase {
+    override suspend fun invoke(): Flow<Boolean> = userConfigRepository.observeIsCellsEnabled()
+}

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/user/UserScope.kt

@@ -62,6 +62,8 @@ import com.wire.kalium.logic.feature.client.IsWireCellsEnabledForConversationUse
 import com.wire.kalium.logic.feature.client.IsWireCellsEnabledUseCase
 import com.wire.kalium.logic.feature.client.IsWireCellsEnabledUseCaseImpl
 import com.wire.kalium.logic.feature.client.MLSClientManager
+import com.wire.kalium.logic.feature.client.ObserveIsWireCellsEnabledUseCase
+import com.wire.kalium.logic.feature.client.ObserveIsWireCellsEnabledUseCaseImpl
 import com.wire.kalium.logic.feature.client.RegisterMLSClientUseCase
 import com.wire.kalium.logic.feature.conversation.GetAllContactsNotInConversationUseCase
 import com.wire.kalium.logic.feature.conversation.keyingmaterials.KeyingMaterialsManager
@@ -301,6 +303,12 @@ public class UserScope internal constructor(
         get() = IsWireCellsEnabledUseCaseImpl(
             userConfigRepository = userConfigRepository,
         )
+
+    public val observeIsWireCellsEnabled: ObserveIsWireCellsEnabledUseCase
+        get() = ObserveIsWireCellsEnabledUseCaseImpl(
+            userConfigRepository = userConfigRepository,
+        )
+
     public val isWireCellsEnabledForConversation: IsWireCellsEnabledForConversationUseCase
         get() = IsWireCellsEnabledForConversationUseCaseImpl(
             conversationRepository = conversationRepository