fix(apps): consider protocol instead of feature flag for enabling apps interaction - cherry pick (WPB-21835) (#4430)

Author: yamilmedina

app/src/main/kotlin/com/wire/android/ui/home/conversations/details/GroupConversationDetailsViewModel.kt

@@ -30,6 +30,7 @@ import com.wire.android.ui.home.newconversation.channelaccess.ChannelAccessType
 import com.wire.android.ui.home.newconversation.channelaccess.ChannelAddPermissionType
 import com.wire.android.ui.home.newconversation.channelaccess.toUiEnum
 import com.wire.android.ui.navArgs
+import com.wire.android.util.debug.FeatureVisibilityFlags
 import com.wire.android.util.dispatchers.DispatcherProvider
 import com.wire.android.util.ui.UIText
 import com.wire.kalium.common.functional.getOrNull
@@ -126,6 +127,12 @@ class GroupConversationDetailsViewModel @Inject constructor(
                 val channelPermissionType = groupDetails.getChannelPermissionType()
                 val channelAccessType = groupDetails.getChannelAccessType()
 
+                // WPB-21835: Apps availability logic controlled by feature flag
+                val isMLSConversation = groupDetails.conversation.protocol is Conversation.ProtocolInfo.MLS
+                val isAppsAllowedForConversation = computeAppsEnabledStatus(groupDetails, isMLSConversation)
+                val isUpdatingAppsAllowedForConversation =
+                    computeAppsAllowedStatus(canSelfPerformAdminTasks, isSelfInTeamThatOwnsConversation, isMLSConversation)
+
                 _isFetchingInitialData.value = false
 
                 updateState(
@@ -140,8 +147,8 @@ class GroupConversationDetailsViewModel @Inject constructor(
                         isUpdatingNameAllowed = canSelfPerformAdminTasks && !isSelfExternalMember,
                         isUpdatingGuestAllowed = canSelfPerformAdminTasks && isSelfInTeamThatOwnsConversation,
                         isUpdatingChannelAccessAllowed = canSelfPerformAdminTasks && isSelfInTeamThatOwnsConversation,
-                        isAppsAllowed = groupDetails.conversation.isServicesAllowed(),
-                        isUpdatingAppsAllowed = canSelfPerformAdminTasks && isSelfInTeamThatOwnsConversation,
+                        isAppsAllowed = isAppsAllowedForConversation,
+                        isUpdatingAppsAllowed = isUpdatingAppsAllowedForConversation,
                         isUpdatingReadReceiptAllowed = canSelfPerformAdminTasks && groupDetails.conversation.isTeamGroup(),
                         isUpdatingSelfDeletingAllowed = canSelfPerformAdminTasks,
                         mlsEnabled = isMLSEnabled(),
@@ -161,6 +168,37 @@ class GroupConversationDetailsViewModel @Inject constructor(
         }
     }
 
+    /**
+     * Determine apps visibility based on feature flag and team settings
+     * Or just should be protocol based in case of current logic
+     */
+    private fun computeAppsAllowedStatus(
+        canSelfPerformAdminTasks: Boolean,
+        isSelfInTeamThatOwnsConversation: Boolean,
+        isMLSConversation: Boolean
+    ) = if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+        // current logic: based on protocol
+        canSelfPerformAdminTasks && isSelfInTeamThatOwnsConversation && !isMLSConversation
+    } else {
+        // new logic: based on permissions
+        canSelfPerformAdminTasks && isSelfInTeamThatOwnsConversation
+    }
+
+    /**
+     * Determine apps visibility based on feature flag and team settings
+     * Or just should be protocol based in case of current logic
+     */
+    private fun computeAppsEnabledStatus(
+        groupDetails: ConversationDetails.Group,
+        isMLSConversation: Boolean
+    ) = if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+        // current logic: based on protocol (apps disabled for MLS)
+        groupDetails.conversation.isServicesAllowed() && !isMLSConversation
+    } else {
+        // new logic: based on feature flags
+        groupDetails.conversation.isServicesAllowed()
+    }
+
     fun shouldShowAddParticipantButton(): Boolean {
         val isSelfAdmin = groupParticipantsState.data.isSelfAnAdmin
         val isSelfGuest = groupParticipantsState.data.isSelfGuest

app/src/main/kotlin/com/wire/android/ui/home/conversations/details/updateappsaccess/UpdateAppsAccessViewModel.kt

@@ -25,6 +25,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wire.android.ui.home.conversations.details.participants.usecase.ObserveParticipantsForConversationUseCase
 import com.wire.android.ui.navArgs
+import com.wire.android.util.debug.FeatureVisibilityFlags
 import com.wire.android.util.dispatchers.DispatcherProvider
 import com.wire.kalium.logic.data.conversation.Conversation
 import com.wire.kalium.logic.data.conversation.ConversationDetails
@@ -106,16 +107,54 @@ class UpdateAppsAccessViewModel @Inject constructor(
                     (conversationDetails is ConversationDetails.Group.Channel && isTeamAdmin && isSelfInConversationTeam)
                 val canSelfPerformAdminActions = isSelfAnAdmin || isSelfChannelTeamAdmin
 
+                // WPB-21835: Apps availability logic controlled by feature flag
+                val isMLSConversation = conversationDetails.conversation.protocol is Conversation.ProtocolInfo.MLS
+                val isAppAccessAllowed = computeAppsEnabledStatus(conversationDetails, isMLSConversation, isTeamAllowedToUseApps)
+                val isUpdatingAppAccessAllowed =
+                    computeAppsAllowedStatus(canSelfPerformAdminActions, isMLSConversation, isTeamAllowedToUseApps)
+
                 updateAppsAccessState = updateAppsAccessState.copy(
-                    isAppAccessAllowed = conversationDetails.conversation.isServicesAllowed() && isTeamAllowedToUseApps,
-                    isUpdatingAppAccessAllowed = canSelfPerformAdminActions && isTeamAllowedToUseApps,
+                    isAppAccessAllowed = isAppAccessAllowed,
+                    isUpdatingAppAccessAllowed = isUpdatingAppAccessAllowed,
                     isLoadingAppsOption = false,
                     shouldShowDisableAppsConfirmationDialog = false
                 )
             }
         }
     }
 
+    /**
+     * Determine apps visibility based on feature flag and team settings
+     * Or just should be protocol based in case of current logic
+     */
+    private fun computeAppsEnabledStatus(
+        conversationDetails: ConversationDetails,
+        isMLSConversation: Boolean,
+        isTeamAllowedToUseApps: Boolean
+    ) = if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+        // New logic: based on protocol (apps disabled for MLS)o
+        conversationDetails.conversation.isServicesAllowed() && !isMLSConversation
+    } else {
+        // Old logic: based on team settings and feature flags
+        conversationDetails.conversation.isServicesAllowed() && isTeamAllowedToUseApps
+    }
+
+    /**
+     * Determine apps visibility based on feature flag and team settings
+     * Or just should be protocol based in case of current logic
+     */
+    private fun computeAppsAllowedStatus(
+        canSelfPerformAdminActions: Boolean,
+        isMLSConversation: Boolean,
+        isTeamAllowedToUseApps: Boolean
+    ) = if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+        // New logic: based on protocol
+        canSelfPerformAdminActions && !isMLSConversation
+    } else {
+        // Old logic: based on permissions and team settings
+        canSelfPerformAdminActions && isTeamAllowedToUseApps
+    }
+
     private data class CombineFour(
         val isAppsUsageAllowed: Boolean,
         val conversationDetails: ConversationDetails,

app/src/main/kotlin/com/wire/android/ui/home/conversations/search/adddembertoconversation/AddMembersSearchScreen.kt

@@ -30,6 +30,7 @@ import com.wire.android.ui.home.conversations.search.AddMembersSearchNavArgs
 import com.wire.android.ui.home.conversations.search.SearchPeopleScreenType
 import com.wire.android.ui.home.conversations.search.SearchUsersAndAppsScreen
 import com.wire.android.ui.home.newconversation.model.Contact
+import com.wire.android.util.debug.FeatureVisibilityFlags
 import com.wire.kalium.logic.data.id.QualifiedID
 import com.wire.kalium.logic.data.user.BotService
 
@@ -45,6 +46,10 @@ fun AddMembersSearchScreen(
     if (addMembersToConversationViewModel.newGroupState.isCompleted) {
         navigator.navigateBack()
     }
+
+    // WPB-21835: Apps tab visibility controlled by feature flag
+    val isAppsTabVisible = computeAppsVisible(navArgs)
+
     SearchUsersAndAppsScreen(
         searchTitle = stringResource(id = R.string.label_add_participants),
         onOpenUserProfile = { contact: Contact ->
@@ -61,9 +66,19 @@ fun AddMembersSearchScreen(
         },
         screenType = SearchPeopleScreenType.CONVERSATION_DETAILS,
         selectedContacts = addMembersToConversationViewModel.newGroupState.selectedContacts,
-        isAppsTabVisible = navArgs.isSelfPartOfATeam,
+        isAppsTabVisible = isAppsTabVisible,
         isUserAllowedToCreateChannels = false,
         shouldShowChannelPromotion = false,
         isConversationAppsEnabled = navArgs.isConversationAppsEnabled,
     )
 }
+
+@Composable
+private fun computeAppsVisible(navArgs: AddMembersSearchNavArgs) =
+    if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+        // current logic: based on protocol (isConversationAppsEnabled represents non-MLS)
+        navArgs.isConversationAppsEnabled
+    } else {
+        // new logic: based on team membership
+        navArgs.isSelfPartOfATeam
+    }

app/src/main/kotlin/com/wire/android/ui/home/conversations/search/apps/SearchAppsScreen.kt

@@ -47,6 +47,7 @@ import com.wire.android.ui.common.rowitem.RowItemTemplate
 import com.wire.android.ui.common.upgradetoapps.UpgradeToGetAppsBanner
 import com.wire.android.ui.home.conversations.search.HighlightName
 import com.wire.android.ui.home.conversations.search.widget.SearchFailureBox
+import com.wire.android.util.debug.FeatureVisibilityFlags
 import com.wire.android.ui.home.conversationslist.model.Membership
 import com.wire.android.ui.home.newconversation.model.Contact
 import com.wire.android.ui.theme.WireTheme
@@ -158,11 +159,17 @@ private fun rememberAppsContentState(
     result: ImmutableList<Contact>
 ): State<AppsContentState> = remember(isConversationAppsEnabled, isLoading, isTeamAllowedToUseApps, searchQuery, result) {
     derivedStateOf {
+        // WPB-21835: Apps availability checks controlled by feature flag
+        if (!FeatureVisibilityFlags.AppsBasedOnProtocol) {
+            // new logic: check team and conversation settings first
+            if (!isTeamAllowedToUseApps) return@derivedStateOf AppsContentState.TEAM_NOT_ALLOWED
+            if (!isConversationAppsEnabled) return@derivedStateOf AppsContentState.APPS_NOT_ENABLED_FOR_CONVERSATION
+        }
+        // current logic: protocol-based, skip the above checks (screen shouldn't be accessible if apps disabled)
+
         when {
             isLoading -> AppsContentState.LOADING
-            !isTeamAllowedToUseApps -> AppsContentState.TEAM_NOT_ALLOWED
-            !isConversationAppsEnabled -> AppsContentState.APPS_NOT_ENABLED_FOR_CONVERSATION
-            searchQuery.isBlank() && result.isEmpty() -> AppsContentState.EMPTY_INITIAL
+            searchQuery.isBlank() && result.isEmpty() -> AppsContentState.EMPTY_SEARCH
             searchQuery.isNotBlank() && result.isEmpty() -> AppsContentState.EMPTY_SEARCH
             else -> AppsContentState.SHOW_RESULTS
         }

app/src/main/kotlin/com/wire/android/ui/home/conversations/search/apps/SearchAppsViewModel.kt

@@ -26,6 +26,7 @@ import com.wire.android.mapper.ContactMapper
 import com.wire.android.ui.common.DEFAULT_SEARCH_QUERY_DEBOUNCE
 import com.wire.android.ui.home.newconversation.model.Contact
 import com.wire.android.util.EMPTY
+import com.wire.android.util.debug.FeatureVisibilityFlags
 import com.wire.kalium.logic.data.user.type.isTeamAdmin
 import com.wire.kalium.logic.feature.featureConfig.ObserveIsAppsAllowedForUsageUseCase
 import com.wire.kalium.logic.feature.service.ObserveAllServicesUseCase
@@ -63,7 +64,8 @@ class SearchAppsViewModel @Inject constructor(
                 isAppsAllowedForUsage(),
                 searchQueryTextFlow.onStart { emit(String.EMPTY) }
             ) { selfUser, isEnabled, query ->
-                Triple(selfUser, isEnabled, query)
+                val effectiveIsEnabled = computeAppsEnabledStatus(isEnabled)
+                Triple(selfUser, effectiveIsEnabled, query)
             }.debounce(DEFAULT_SEARCH_QUERY_DEBOUNCE).collectLatest { (selfUser, isEnabled, query) ->
                 state = state.copy(isTeamAllowedToUseApps = isEnabled, isSelfATeamAdmin = selfUser.userType.isTeamAdmin())
                 if (isEnabled) {
@@ -75,6 +77,21 @@ class SearchAppsViewModel @Inject constructor(
         }
     }
 
+    /**
+     * Determine apps visibility based on feature flag and team settings
+     * Or just should be protocol based in case of current logic
+     */
+    private fun computeAppsEnabledStatus(isEnabled: Boolean): Boolean {
+        val effectiveIsEnabled = if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+            // current logic: always enabled here (protocol check happens elsewhere)
+            true
+        } else {
+            // new logic: use team feature flag
+            isEnabled
+        }
+        return effectiveIsEnabled
+    }
+
     fun searchQueryChanged(searchQuery: String) {
         viewModelScope.launch {
             searchQueryTextFlow.emit(searchQuery)

app/src/main/kotlin/com/wire/android/ui/home/newconversation/NewConversationViewModel.kt

@@ -37,6 +37,7 @@ import com.wire.android.ui.home.newconversation.channelhistory.ChannelHistoryTyp
 import com.wire.android.ui.home.newconversation.common.CreateGroupState
 import com.wire.android.ui.home.newconversation.groupOptions.GroupOptionState
 import com.wire.android.ui.home.newconversation.model.Contact
+import com.wire.android.util.debug.FeatureVisibilityFlags
 import com.wire.kalium.logic.data.conversation.Conversation
 import com.wire.kalium.logic.data.conversation.CreateConversationParam
 import com.wire.kalium.logic.data.user.UserId
@@ -82,7 +83,6 @@ class NewConversationViewModel @Inject constructor(
     var groupOptionsState: GroupOptionState by mutableStateOf(GroupOptionState())
     var isChannelCreationPossible: Boolean by mutableStateOf(true)
     var isFreemiumAccount: Boolean by mutableStateOf(false) // TODO: implement logic to determine if the account is freemium
-
     var createGroupState: CreateGroupState by mutableStateOf(CreateGroupState.Default)
 
     init {
@@ -96,14 +96,28 @@ class NewConversationViewModel @Inject constructor(
         viewModelScope.launch {
             observeIsAppsAllowedForUsage()
                 .collectLatest { appsAllowed ->
+                    val isMLS = newGroupState.groupProtocol == CreateConversationParam.Protocol.MLS
+                    val isAppsAllowed = computeAppsAllowedStatus(isMLS, appsAllowed)
                     groupOptionsState = groupOptionsState.copy(
-                        isTeamAllowedToUseApps = appsAllowed,
-                        isAllowAppsEnabled = appsAllowed
+                        isTeamAllowedToUseApps = isAppsAllowed,
+                        isAllowAppsEnabled = isAppsAllowed
                     )
                 }
         }
     }
 
+    /**
+     * Determine apps visibility based on feature flag and team settings
+     * Or just should be protocol based in case of current logic
+     */
+    private fun computeAppsAllowedStatus(isMLS: Boolean, appsAllowed: Boolean) = if (FeatureVisibilityFlags.AppsBasedOnProtocol) {
+        // current logic: based on protocol (apps disabled for MLS)
+        !isMLS
+    } else {
+        // new logic: based on feature flags
+        appsAllowed
+    }
+
     fun resetState() {
         newGroupNameTextState.clearText()
         newGroupState = GroupMetadataState().let {
@@ -178,9 +192,9 @@ class NewConversationViewModel @Inject constructor(
         } else {
             newGroupState = newGroupState.copy(
                 selectedUsers = newGroupState.selectedUsers.filterNot {
-                it.id == contact.id &&
-                        it.domain == contact.domain
-            }.toImmutableSet()
+                    it.id == contact.id &&
+                            it.domain == contact.domain
+                }.toImmutableSet()
             )
         }
     }

app/src/main/kotlin/com/wire/android/ui/home/newconversation/groupOptions/GroupOptionsScreen.kt

@@ -220,7 +220,9 @@ private fun GroupOptionState.GroupOptionsScreenMainContent(
                 }
             }
             AllowGuestsOptions(groupMetadataState.isChannel, onAllowGuestChanged)
-            AllowAppsOptions(onAllowServicesChanged)
+            if (isTeamAllowedToUseApps) {
+                AllowAppsOptions(onAllowServicesChanged)
+            }
             if (groupMetadataState.groupProtocol != CreateConversationParam.Protocol.MLS || mlsReadReceiptsEnabled) {
                 ReadReceiptsOptions(groupMetadataState.isChannel, onReadReceiptChanged)
             }

app/src/main/kotlin/com/wire/android/ui/home/newconversation/search/NewConversationSearchPeopleScreen.kt

@@ -33,6 +33,7 @@ import com.wire.android.ui.home.conversations.search.SearchPeopleScreenType
 import com.wire.android.ui.home.conversations.search.SearchUsersAndAppsScreen
 import com.wire.android.ui.home.newconversation.NewConversationViewModel
 import com.wire.android.ui.home.newconversation.common.NewConversationNavGraph
+import com.wire.kalium.logic.data.conversation.CreateConversationParam
 import com.wire.kalium.logic.data.id.QualifiedID
 
 @NewConversationNavGraph(start = true)
@@ -72,7 +73,7 @@ fun NewConversationSearchPeopleScreen(
         onClose = navigator::navigateBack,
         screenType = SearchPeopleScreenType.NEW_CONVERSATION,
         selectedContacts = newConversationViewModel.newGroupState.selectedUsers,
-        isAppsTabVisible = false,
+        isAppsTabVisible = newConversationViewModel.newGroupState.groupProtocol != CreateConversationParam.Protocol.MLS,
         onAppClicked = { }
     )
 

app/src/main/kotlin/com/wire/android/util/debug/FeatureVisibilityFlags.kt

@@ -56,6 +56,13 @@ object FeatureVisibilityFlags {
     const val MessageEditIcon = true
     const val SearchConversationMessages = true
     const val DrawingIcon = true
+
+    /**
+     * WPB-21835: Controls how apps availability is determined.
+     * When true: Apps are allowed based on protocol (disabled for MLS conversations)
+     * When false: Apps are allowed based on feature flags (original logic with team settings)
+     */
+    const val AppsBasedOnProtocol = true
 }
 
 val LocalFeatureVisibilityFlags = staticCompositionLocalOf { FeatureVisibilityFlags }

app/src/test/kotlin/com/wire/android/ui/home/conversations/details/updateappsaccess/UpdateAppsAccessViewModelTest.kt

@@ -253,8 +253,9 @@ class UpdateAppsAccessViewModelTest {
         advanceUntilIdle()
 
         // Then
-        assertEquals(false, viewModel.updateAppsAccessState.isUpdatingAppAccessAllowed)
-        assertEquals(false, viewModel.updateAppsAccessState.isAppAccessAllowed)
+        // WPB-21835: even if team does not allow apps, we still allow enabling/disabling apps based on protocol, later this will change
+        assertEquals(true, viewModel.updateAppsAccessState.isUpdatingAppAccessAllowed)
+        assertEquals(true, viewModel.updateAppsAccessState.isAppAccessAllowed)
     }
 
     @Test