feat: Show team applock change dialog (WPB-4476)

app/src/main/kotlin/com/wire/android/datastore/GlobalDataStore.kt

@@ -36,12 +36,13 @@
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runBlocking
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Suppress("TooManyFunctions")
 @Singleton
-class GlobalDataStore @Inject constructor(@ApplicationContext private val context: Context) {
+class GlobalDataStore @Inject constructor(@ApplicationContext val context: Context) {
 
     companion object {
         private const val PREFERENCES_NAME = "global_data"
@@ -52,8 +53,10 @@
         private val WELCOME_SCREEN_PRESENTED = booleanPreferencesKey("welcome_screen_presented")
         private val IS_LOGGING_ENABLED = booleanPreferencesKey("is_logging_enabled")
         private val IS_ENCRYPTED_PROTEUS_STORAGE_ENABLED = booleanPreferencesKey("is_encrypted_proteus_storage_enabled")
+        private val IS_APP_LOCKED_BY_USER = booleanPreferencesKey("is_app_locked_by_user")
         private val APP_LOCK_PASSCODE = stringPreferencesKey("app_lock_passcode")
-        private val APP_THEME_OPTION = stringPreferencesKey("app_theme_option")
+        private val TEAM_APP_LOCK_PASSCODE = stringPreferencesKey("team_app_lock_passcode")
+        val APP_THEME_OPTION = stringPreferencesKey("app_theme_option")
         private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = PREFERENCES_NAME)
         private fun userMigrationStatusKey(userId: String): Preferences.Key<Int> = intPreferencesKey("user_migration_status_$userId")
         private fun userDoubleTapToastStatusKey(userId: String): Preferences.Key<Boolean> =
@@ -67,7 +70,7 @@
         context.dataStore.edit { it.clear() }
     }
 
-    private fun getBooleanPreference(key: Preferences.Key<Boolean>, defaultValue: Boolean): Flow<Boolean> =
+    fun getBooleanPreference(key: Preferences.Key<Boolean>, defaultValue: Boolean): Flow<Boolean> =
         context.dataStore.data.map { it[key] ?: defaultValue }
 
     private fun getStringPreference(key: Preferences.Key<String>, defaultValue: String): Flow<String> =
@@ -141,43 +144,90 @@
     suspend fun getShouldShowDoubleTapToast(userId: String): Boolean =
         getBooleanPreference(userDoubleTapToastStatusKey(userId), true).first()
 
-    // returns a flow with decoded passcode
+    /**
+     * returns a flow with decoded passcode
+     */
     @Suppress("TooGenericExceptionCaught")
     fun getAppLockPasscodeFlow(): Flow<String?> =
         context.dataStore.data.map {
-            it[APP_LOCK_PASSCODE]?.let {
+            it[APP_LOCK_PASSCODE]?.let { passcode ->
                 try {
-                    EncryptionManager.decrypt(APP_LOCK_PASSCODE.name, it)
+                    EncryptionManager.decrypt(APP_LOCK_PASSCODE.name, passcode)
                 } catch (e: Exception) {
                     null
                 }
             }
         }
 
-    // returns a flow only informing whether the passcode is set, without the need to decode it
+    /**
+     * returns a flow only informing whether the passcode is set, without the need to decode it
+     */
     fun isAppLockPasscodeSetFlow(): Flow<Boolean> =
         context.dataStore.data.map {
             it.contains(APP_LOCK_PASSCODE)
         }
 
+    fun isAppLockPasscodeSet(): Boolean = runBlocking {
+        context.dataStore.data.map {
+            it.contains(APP_LOCK_PASSCODE)
+        }.first()
+    }
+
+    fun isAppTeamPasscodeSetFlow(): Flow<Boolean> =
+        context.dataStore.data.map {
+            it.contains(TEAM_APP_LOCK_PASSCODE)
+        }
+
+    fun isAppTeamPasscodeSet(): Boolean = runBlocking {
+        context.dataStore.data.map {
+            it.contains(TEAM_APP_LOCK_PASSCODE)
+        }.first()
+    }
+
     suspend fun clearAppLockPasscode() {
         context.dataStore.edit {
             it.remove(APP_LOCK_PASSCODE)
         }
     }
+    suspend fun clearTeamAppLockPasscode() {
+        context.dataStore.edit {
+            it.remove(TEAM_APP_LOCK_PASSCODE)
+        }
+    }
 
     @Suppress("TooGenericExceptionCaught")
-    suspend fun setAppLockPasscode(passcode: String) {
+    private suspend fun setAppLockPasscode(
+        passcode: String,
+        key: Preferences.Key<String>
+    ) {
         context.dataStore.edit {
             try {
-                val encrypted = EncryptionManager.encrypt(APP_LOCK_PASSCODE.name, passcode)
-                it[APP_LOCK_PASSCODE] = encrypted
+                val encrypted =
+                    EncryptionManager.encrypt(key.name, passcode)
+                it[key] = encrypted
             } catch (e: Exception) {
-                it.remove(APP_LOCK_PASSCODE)
+                it.remove(key)
             }
         }
     }
 
+    suspend fun setTeamAppLock(
+        passcode: String,
+        key: Preferences.Key<String> = TEAM_APP_LOCK_PASSCODE
+    ) {
+        setAppLockPasscode(passcode, key)
+    }
+
+    suspend fun setUserAppLock(
+        passcode: String,
+        key: Preferences.Key<String> = APP_LOCK_PASSCODE
+    ) {
+        setAppLockPasscode(passcode, key)
+    }
+
+    fun isAppLockedByUserFlow(): Flow<Boolean> =
+        getBooleanPreference(IS_APP_LOCKED_BY_USER, false)
+
     suspend fun setThemeOption(option: ThemeOption) {
         context.dataStore.edit { it[APP_THEME_OPTION] = option.toString() }
     }

app/src/main/kotlin/com/wire/android/di/CoreLogicModule.kt

@@ -391,6 +391,11 @@ class UseCaseModule {
     fun provideMarkGuestLinkFeatureFlagAsNotChangedUseCase(@KaliumCoreLogic coreLogic: CoreLogic, @CurrentAccount currentAccount: UserId) =
         coreLogic.getSessionScope(currentAccount).markGuestLinkFeatureFlagAsNotChanged
 
+    @ViewModelScoped
+    @Provides
+    fun provideMarkTeamAppLockStatusAsNotifiedUseCase(@KaliumCoreLogic coreLogic: CoreLogic, @CurrentAccount currentAccount: UserId) =
+        coreLogic.getSessionScope(currentAccount).markTeamAppLockStatusAsNotified
+
     @ViewModelScoped
     @Provides
     fun provideGetOtherUserSecurityClassificationLabelUseCase(

app/src/main/kotlin/com/wire/android/di/KaliumConfigsModule.kt

@@ -64,7 +64,9 @@ class KaliumConfigsModule {
             wipeOnDeviceRemoval = BuildConfig.WIPE_ON_DEVICE_REMOVAL,
             wipeOnRootedDevice = BuildConfig.WIPE_ON_ROOTED_DEVICE,
             isWebSocketEnabledByDefault = isWebsocketEnabledByDefault(context),
-            certPinningConfig = BuildConfig.CERTIFICATE_PINNING_CONFIG
+            certPinningConfig = BuildConfig.CERTIFICATE_PINNING_CONFIG,
+            teamAppLock = BuildConfig.TEAM_APP_LOCK,
+            teamAppLockTimeout = BuildConfig.TEAM_APP_LOCK_TIMEOUT
         )
     }
 }

app/src/main/kotlin/com/wire/android/feature/ObserveAppLockConfigUseCase.kt

@@ -18,33 +18,59 @@
 package com.wire.android.feature
 
 import com.wire.android.datastore.GlobalDataStore
+import com.wire.android.di.KaliumCoreLogic
+import com.wire.kalium.logic.CoreLogic
+import com.wire.kalium.logic.feature.applock.AppLockTeamFeatureConfigObserverImpl.Companion.DEFAULT_TIMEOUT
+import com.wire.kalium.logic.feature.session.CurrentSessionResult
+import com.wire.kalium.logic.feature.session.CurrentSessionUseCase
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combineTransform
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.seconds
 
 @Singleton
 class ObserveAppLockConfigUseCase @Inject constructor(
     private val globalDataStore: GlobalDataStore,
+    @KaliumCoreLogic private val coreLogic: CoreLogic,
+    private val currentSession: CurrentSessionUseCase
 ) {
 
-    operator fun invoke(): Flow<AppLockConfig> =
-        globalDataStore.isAppLockPasscodeSetFlow().map { // TODO: include checking if any logged account does not enforce app-lock
-            when {
-                it -> AppLockConfig.Enabled
-                else -> AppLockConfig.Disabled
+    operator fun invoke(): Flow<AppLockConfig> = channelFlow {
+        when (val currentSession = currentSession()) {
+            is CurrentSessionResult.Failure -> {
+                send(AppLockConfig.Disabled(DEFAULT_TIMEOUT))
+            }
+
+            is CurrentSessionResult.Success -> {
+                val userId = currentSession.accountInfo.userId
+                val appLockTeamFeatureConfigFlow =
+                    coreLogic.getSessionScope(userId).appLockTeamFeatureConfigObserver
+
+                appLockTeamFeatureConfigFlow().combineTransform(
+                    globalDataStore.isAppLockPasscodeSetFlow()
+                ) { isAppLockedByTeam, isAppLocked ->
+                    if (isAppLockedByTeam.isEnabled) {
+                        emit(AppLockConfig.EnforcedByTeam(isAppLockedByTeam.timeout))
+                    } else {
+                        if (isAppLocked) {
+                            emit(AppLockConfig.Enabled(isAppLockedByTeam.timeout))
+                        } else {
+                            emit(AppLockConfig.Disabled(isAppLockedByTeam.timeout))
+                        }
+                    }
+                }.collectLatest {
+                    send(it)
+                }
             }
         }
+    }
 }
 
 sealed class AppLockConfig(open val timeout: Duration = DEFAULT_TIMEOUT) {
-    data object Disabled : AppLockConfig()
-    data object Enabled : AppLockConfig()
+    data class Disabled(override val timeout: Duration) : AppLockConfig(timeout)
+    data class Enabled(override val timeout: Duration) : AppLockConfig(timeout)
     data class EnforcedByTeam(override val timeout: Duration) : AppLockConfig(timeout)
-
-    companion object {
-        val DEFAULT_TIMEOUT = 60.seconds
-    }
 }

app/src/main/kotlin/com/wire/android/ui/AppLockActivity.kt

@@ -27,6 +27,7 @@
 import com.wire.android.navigation.rememberNavigator
 import com.wire.android.ui.destinations.AppUnlockWithBiometricsScreenDestination
 import com.wire.android.ui.destinations.EnterLockCodeScreenDestination
+import com.wire.android.ui.destinations.SetLockCodeScreenDestination
 import com.wire.android.ui.theme.WireTheme
 import dagger.hilt.android.AndroidEntryPoint
 
@@ -37,19 +38,23 @@
         WindowCompat.setDecorFitsSystemWindows(window, false)
         setContent {
             WireTheme {
-                val canAuthenticateWithBiometrics = BiometricManager
-                    .from(this)
-                    .canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_STRONG)
-
                 val navigator = rememberNavigator(this@AppLockActivity::finish)
 
                 val startDestination =
-                    if (canAuthenticateWithBiometrics == BiometricManager.BIOMETRIC_SUCCESS) {
-                        appLogger.i("appLock: requesting app Unlock with biometrics")
-                        AppUnlockWithBiometricsScreenDestination
+                    if (intent.getBooleanExtra(SET_TEAM_APP_LOCK, false)) {
+                        appLogger.i("appLock: requesting set team app lock")
+                        SetLockCodeScreenDestination
                     } else {
-                        appLogger.i("appLock: requesting app Unlock with passcode")
-                        EnterLockCodeScreenDestination
+                        val canAuthenticateWithBiometrics = BiometricManager
+                            .from(this)
+                            .canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_STRONG)
+                        if (canAuthenticateWithBiometrics == BiometricManager.BIOMETRIC_SUCCESS) {
+                            appLogger.i("appLock: requesting app Unlock with biometrics")
+                            AppUnlockWithBiometricsScreenDestination
+                        } else {
+                            appLogger.i("appLock: requesting app Unlock with passcode")
+                            EnterLockCodeScreenDestination
+                        }
                     }
 
                 NavigationGraph(
@@ -59,4 +64,8 @@
             }
         }
     }
+
+    companion object {
+        const val SET_TEAM_APP_LOCK = "set_team_app_lock"
+    }
 }

app/src/main/kotlin/com/wire/android/ui/WireActivity.kt

@@ -263,6 +263,35 @@
                 )
             }
 
+            if (shouldShowTeamAppLockDialog) {
+                TeamAppLockFeatureFlagDialog(
+                    isTeamAppLockEnabled = isTeamAppLockEnabled,
+                    onConfirm = {
+                        featureFlagNotificationViewModel.dismissTeamAppLockDialog()
+                        if (isTeamAppLockEnabled) {
+                            val isUserAppLockSet =
+                                featureFlagNotificationViewModel.isUserAppLockSet()
+                            // No need to setup another app lock if the user already has one
+                            if (!isUserAppLockSet) {
+                                Intent(this@WireActivity, AppLockActivity::class.java)
+                                    .apply {
+                                        putExtra(AppLockActivity.SET_TEAM_APP_LOCK, true)
+                                    }.also {
+                                        startActivity(it)
+                                    }
+                            } else {
+                                featureFlagNotificationViewModel.markTeamAppLockStatusAsNot()
+                            }
+                        } else {
+                            with(featureFlagNotificationViewModel) {
+                                markTeamAppLockStatusAsNot()
+                                clearTeamAppLockPasscode()
+                            }
+                        }
+                    }
+                )
+            }
+
             if (shouldShowSelfDeletingMessagesDialog) {
                 SelfDeletingMessagesDialog(
                     areSelfDeletingMessagesEnabled = areSelfDeletedMessagesEnabled,

app/src/main/kotlin/com/wire/android/ui/WireActivityDialogs.kt

@@ -127,6 +127,27 @@ fun GuestRoomLinkFeatureFlagDialog(
     )
 }
 
+@Composable
+fun TeamAppLockFeatureFlagDialog(
+    isTeamAppLockEnabled: Boolean,
+    onConfirm: () -> Unit,
+) {
+    val text: String =
+        stringResource(id = if (isTeamAppLockEnabled) R.string.team_app_lock_enabled
+        else R.string.team_app_lock_disabled)
+
+    WireDialog(
+        title = stringResource(id = R.string.team_settings_changed),
+        text = text,
+        onDismiss = {},
+        optionButton1Properties = WireDialogButtonProperties(
+            onClick = onConfirm,
+            text = stringResource(id = R.string.label_ok),
+            type = WireDialogButtonType.Primary,
+        )
+    )
+}
+
 @Composable
 fun UpdateAppDialog(shouldShow: Boolean, onUpdateClick: () -> Unit) {
     if (shouldShow) {

app/src/main/kotlin/com/wire/android/ui/common/WireDialog.kt

@@ -116,7 +116,6 @@ fun WireDialog(
     )
 }
 
-@OptIn(ExperimentalComposeUiApi::class)
 @Composable
 fun WireDialog(
     title: String,

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

@@ -28,6 +28,8 @@ data class FeatureFlagState(
     val isFileSharingEnabledState: Boolean = true,
     val fileSharingRestrictedState: SharingRestrictedState? = null,
     val shouldShowGuestRoomLinkDialog: Boolean = false,
+    val shouldShowTeamAppLockDialog: Boolean = false,
+    val isTeamAppLockEnabled: Boolean = false,
     val isGuestRoomLinkEnabled: Boolean = true,
     val shouldShowSelfDeletingMessagesDialog: Boolean = false,
     val enforcedTimeoutDuration: SelfDeletionDuration = SelfDeletionDuration.None,