From e863559c12a48185528a1b7a4dd79aba9377ff91 Mon Sep 17 00:00:00 2001 From: Oleg Semenenko <146032743+oleg-livefront@users.noreply.github.com> Date: Mon, 8 Jan 2024 11:38:16 -0600 Subject: [PATCH] BIT-1114 Add code manual entry (#523) --- .../vaultunlocked/VaultUnlockedNavigation.kt | 22 +- .../feature/addedit/VaultAddEditNavigation.kt | 9 +- .../feature/addedit/VaultAddEditScreen.kt | 5 + .../feature/addedit/VaultAddEditViewModel.kt | 13 +- .../ManualCodeEntryNavigation.kt | 34 +++ .../manualcodeentry/ManualCodeEntryScreen.kt | 203 +++++++++++++++++ .../ManualCodeEntryViewModel.kt | 124 +++++++++++ .../qrcodescan/QrCodeScanNavigation.kt | 6 +- .../feature/qrcodescan/QrCodeScanScreen.kt | 5 + .../feature/qrcodescan/QrCodeScanViewModel.kt | 22 +- .../feature/addedit/VaultAddEditScreenTest.kt | 16 +- .../addedit/VaultAddEditViewModelTest.kt | 8 +- .../ManualCodeEntryScreenTests.kt | 204 ++++++++++++++++++ .../ManualCodeEntryViewModelTests.kt | 92 ++++++++ .../qrcodescan/QrCodeScanScreenTest.kt | 14 +- .../qrcodescan/QrCodeScanViewModelTest.kt | 7 +- 16 files changed, 747 insertions(+), 37 deletions(-) create mode 100644 app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryNavigation.kt create mode 100644 app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreen.kt create mode 100644 app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModel.kt create mode 100644 app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreenTests.kt create mode 100644 app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModelTests.kt diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/platform/feature/vaultunlocked/VaultUnlockedNavigation.kt b/app/src/main/java/com/x8bit/bitwarden/ui/platform/feature/vaultunlocked/VaultUnlockedNavigation.kt index a6f806d825..8fde16716c 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/platform/feature/vaultunlocked/VaultUnlockedNavigation.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/platform/feature/vaultunlocked/VaultUnlockedNavigation.kt @@ -18,6 +18,8 @@ import com.x8bit.bitwarden.ui.vault.feature.addedit.navigateToVaultAddEdit import com.x8bit.bitwarden.ui.vault.feature.addedit.vaultAddEditDestination import com.x8bit.bitwarden.ui.vault.feature.item.navigateToVaultItem import com.x8bit.bitwarden.ui.vault.feature.item.vaultItemDestination +import com.x8bit.bitwarden.ui.vault.feature.manualcodeentry.navigateToManualCodeEntryScreen +import com.x8bit.bitwarden.ui.vault.feature.manualcodeentry.vaultManualCodeEntryDestination import com.x8bit.bitwarden.ui.vault.feature.qrcodescan.navigateToQrCodeScanScreen import com.x8bit.bitwarden.ui.vault.feature.qrcodescan.vaultQrCodeScanDestination import com.x8bit.bitwarden.ui.vault.model.VaultAddEditType @@ -59,6 +61,9 @@ fun NavGraphBuilder.vaultUnlockedGraph( onNavigateToQrCodeScanScreen = { navController.navigateToQrCodeScanScreen() }, + onNavigateToManualCodeEntryScreen = { + navController.navigateToManualCodeEntryScreen() + }, onNavigateBack = { navController.popBackStack() }, ) vaultItemDestination( @@ -67,7 +72,22 @@ fun NavGraphBuilder.vaultUnlockedGraph( navController.navigateToVaultAddEdit(VaultAddEditType.EditItem(it)) }, ) - vaultQrCodeScanDestination(onNavigateBack = { navController.popBackStack() }) + vaultQrCodeScanDestination( + onNavigateToManualCodeEntryScreen = { + navController.popBackStack() + navController.navigateToManualCodeEntryScreen() + }, + onNavigateBack = { navController.popBackStack() }, + ) + + vaultManualCodeEntryDestination( + onNavigateToQrCodeScreen = { + navController.popBackStack() + navController.navigateToQrCodeScanScreen() + }, + onNavigateBack = { navController.popBackStack() }, + ) + addSendDestination(onNavigateBack = { navController.popBackStack() }) passwordHistoryDestination(onNavigateBack = { navController.popBackStack() }) foldersDestination(onNavigateBack = { navController.popBackStack() }) diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditNavigation.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditNavigation.kt index a8905bdca8..99b6e720f6 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditNavigation.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditNavigation.kt @@ -40,8 +40,9 @@ data class VaultAddEditArgs( * Add the vault add & edit screen to the nav graph. */ fun NavGraphBuilder.vaultAddEditDestination( - onNavigateToQrCodeScanScreen: () -> Unit, onNavigateBack: () -> Unit, + onNavigateToManualCodeEntryScreen: () -> Unit, + onNavigateToQrCodeScanScreen: () -> Unit, ) { composableWithSlideTransitions( route = ADD_EDIT_ITEM_ROUTE, @@ -49,7 +50,11 @@ fun NavGraphBuilder.vaultAddEditDestination( navArgument(ADD_EDIT_ITEM_TYPE) { type = NavType.StringType }, ), ) { - VaultAddEditScreen(onNavigateBack, onNavigateToQrCodeScanScreen) + VaultAddEditScreen( + onNavigateBack = onNavigateBack, + onNavigateToManualCodeEntryScreen = onNavigateToManualCodeEntryScreen, + onNavigateToQrCodeScanScreen = onNavigateToQrCodeScanScreen, + ) } } diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreen.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreen.kt index 1f56c4df67..c77e042010 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreen.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreen.kt @@ -49,6 +49,7 @@ fun VaultAddEditScreen( viewModel: VaultAddEditViewModel = hiltViewModel(), permissionsManager: PermissionsManager = PermissionsManagerImpl(LocalContext.current as Activity), + onNavigateToManualCodeEntryScreen: () -> Unit, ) { val state by viewModel.stateFlow.collectAsStateWithLifecycle() val context = LocalContext.current @@ -60,6 +61,10 @@ fun VaultAddEditScreen( onNavigateToQrCodeScanScreen() } + is VaultAddEditEvent.NavigateToManualCodeEntry -> { + onNavigateToManualCodeEntryScreen() + } + is VaultAddEditEvent.ShowToast -> { Toast.makeText(context, event.message(resources), Toast.LENGTH_SHORT).show() } diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModel.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModel.kt index 86e8e1f684..972127d07d 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModel.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModel.kt @@ -424,13 +424,7 @@ class VaultAddEditViewModel @Inject constructor( if (action.isGranted) { sendEvent(event = VaultAddEditEvent.NavigateToQrCodeScan) } else { - // TODO Add manual QR code entry (BIT-1114) - sendEvent( - event = VaultAddEditEvent.ShowToast( - message = - "Permission Not Granted, Manual QR Code Entry Not Implemented".asText(), - ), - ) + sendEvent(event = VaultAddEditEvent.NavigateToManualCodeEntry) } } @@ -1233,6 +1227,11 @@ sealed class VaultAddEditEvent { * Navigate to the QR code scan screen. */ data object NavigateToQrCodeScan : VaultAddEditEvent() + + /** + * Navigate to the manual code entry screen. + */ + data object NavigateToManualCodeEntry : VaultAddEditEvent() } /** diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryNavigation.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryNavigation.kt new file mode 100644 index 0000000000..15ca5f1cba --- /dev/null +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryNavigation.kt @@ -0,0 +1,34 @@ +package com.x8bit.bitwarden.ui.vault.feature.manualcodeentry + +import androidx.navigation.NavController +import androidx.navigation.NavGraphBuilder +import androidx.navigation.NavOptions +import com.x8bit.bitwarden.ui.platform.base.util.composableWithSlideTransitions + +private const val MANUAL_CODE_ENTRY_ROUTE: String = "manual_code_entry" + +/** + * Add the manual code entry screen to the nav graph. + */ +fun NavGraphBuilder.vaultManualCodeEntryDestination( + onNavigateBack: () -> Unit, + onNavigateToQrCodeScreen: () -> Unit, +) { + composableWithSlideTransitions( + route = MANUAL_CODE_ENTRY_ROUTE, + ) { + ManualCodeEntryScreen( + onNavigateBack = onNavigateBack, + onNavigateToQrCodeScreen = onNavigateToQrCodeScreen, + ) + } +} + +/** + * Navigate to the manual code entry screen. + */ +fun NavController.navigateToManualCodeEntryScreen( + navOptions: NavOptions? = null, +) { + this.navigate(MANUAL_CODE_ENTRY_ROUTE, navOptions) +} diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreen.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreen.kt new file mode 100644 index 0000000000..9a4983be98 --- /dev/null +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreen.kt @@ -0,0 +1,203 @@ +package com.x8bit.bitwarden.ui.vault.feature.manualcodeentry + +import android.Manifest +import android.app.Activity +import android.content.Intent +import android.net.Uri +import android.provider.Settings +import android.widget.Toast +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.text.ClickableText +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TopAppBarDefaults +import androidx.compose.material3.rememberTopAppBarState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.x8bit.bitwarden.R +import com.x8bit.bitwarden.ui.platform.base.util.EventsEffect +import com.x8bit.bitwarden.ui.platform.base.util.IntentHandler +import com.x8bit.bitwarden.ui.platform.base.util.PermissionsManager +import com.x8bit.bitwarden.ui.platform.base.util.PermissionsManagerImpl +import com.x8bit.bitwarden.ui.platform.base.util.toAnnotatedString +import com.x8bit.bitwarden.ui.platform.components.BitwardenFilledTonalButton +import com.x8bit.bitwarden.ui.platform.components.BitwardenScaffold +import com.x8bit.bitwarden.ui.platform.components.BitwardenTextField +import com.x8bit.bitwarden.ui.platform.components.BitwardenTopAppBar +import com.x8bit.bitwarden.ui.platform.components.BitwardenTwoButtonDialog + +/** + * The screen to manually add a totp code. + */ +@Suppress("LongMethod") +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun ManualCodeEntryScreen( + onNavigateBack: () -> Unit, + onNavigateToQrCodeScreen: () -> Unit, + viewModel: ManualCodeEntryViewModel = hiltViewModel(), + intentHandler: IntentHandler = IntentHandler(LocalContext.current), + permissionsManager: PermissionsManager = + PermissionsManagerImpl(LocalContext.current as Activity), +) { + var shouldShowPermissionDialog by rememberSaveable { mutableStateOf(false) } + val state by viewModel.stateFlow.collectAsStateWithLifecycle() + + val launcher = permissionsManager.getLauncher { isGranted -> + if (isGranted) { + viewModel.trySendAction(ManualCodeEntryAction.ScanQrCodeTextClick) + } else { + shouldShowPermissionDialog = true + } + } + + val context = LocalContext.current + + EventsEffect(viewModel = viewModel) { event -> + when (event) { + is ManualCodeEntryEvent.NavigateToAppSettings -> { + val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS) + intent.data = Uri.parse("package:" + context.packageName) + + intentHandler.startActivity(intent = intent) + } + + is ManualCodeEntryEvent.ShowToast -> { + Toast + .makeText(context, event.message.invoke(context.resources), Toast.LENGTH_SHORT) + .show() + } + + is ManualCodeEntryEvent.NavigateToQrCodeScreen -> { + onNavigateToQrCodeScreen.invoke() + } + + is ManualCodeEntryEvent.NavigateBack -> { + onNavigateBack.invoke() + } + } + } + + if (shouldShowPermissionDialog) { + BitwardenTwoButtonDialog( + message = stringResource(id = R.string.enable_camer_permission_to_use_the_scanner), + confirmButtonText = stringResource(id = R.string.settings), + dismissButtonText = stringResource(id = R.string.no_thanks), + onConfirmClick = remember(viewModel) { + { viewModel.trySendAction(ManualCodeEntryAction.SettingsClick) } + }, + onDismissClick = { shouldShowPermissionDialog = false }, + onDismissRequest = { shouldShowPermissionDialog = false }, + title = null, + ) + } + + BitwardenScaffold( + modifier = Modifier.fillMaxSize(), + topBar = { + BitwardenTopAppBar( + title = stringResource(id = R.string.authenticator_key_scanner), + navigationIcon = painterResource(id = R.drawable.ic_close), + navigationIconContentDescription = stringResource(id = R.string.close), + onNavigationIconClick = remember(viewModel) { + { viewModel.trySendAction(ManualCodeEntryAction.CloseClick) } + }, + scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState()), + ) + }, + ) { paddingValues -> + Column(modifier = Modifier.padding(paddingValues)) { + + Text( + text = stringResource(id = R.string.enter_key_manually), + style = MaterialTheme.typography.titleMedium, + modifier = Modifier.padding(horizontal = 16.dp), + ) + + Spacer(modifier = Modifier.height(8.dp)) + BitwardenTextField( + singleLine = false, + label = stringResource(id = R.string.authenticator_key_scanner), + value = state.code, + onValueChange = remember(viewModel) { + { + viewModel.trySendAction( + ManualCodeEntryAction.CodeTextChange(it), + ) + } + }, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 16.dp), + ) + + Spacer(modifier = Modifier.height(16.dp)) + BitwardenFilledTonalButton( + label = stringResource(id = R.string.add_totp), + onClick = remember(viewModel) { + { viewModel.trySendAction(ManualCodeEntryAction.CodeSubmit) } + }, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 16.dp), + ) + + Text( + text = stringResource(id = R.string.once_the_key_is_successfully_entered), + style = MaterialTheme.typography.bodyMedium, + modifier = Modifier + .fillMaxWidth() + .padding( + vertical = 16.dp, + horizontal = 16.dp, + ), + ) + + Text( + text = stringResource(id = R.string.cannot_add_authenticator_key), + style = MaterialTheme.typography.bodyMedium, + modifier = Modifier + .fillMaxWidth() + .padding( + vertical = 8.dp, + horizontal = 16.dp, + ), + ) + + ClickableText( + text = stringResource(id = R.string.scan_qr_code).toAnnotatedString(), + style = MaterialTheme.typography.bodyMedium.copy( + color = MaterialTheme.colorScheme.primary, + ), + modifier = Modifier + .padding(horizontal = 16.dp), + onClick = remember(viewModel) { + { + if (permissionsManager.checkPermission(Manifest.permission.CAMERA)) { + viewModel.trySendAction(ManualCodeEntryAction.ScanQrCodeTextClick) + } else { + launcher.launch(Manifest.permission.CAMERA) + } + } + }, + ) + } + } +} diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModel.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModel.kt new file mode 100644 index 0000000000..02f28261b6 --- /dev/null +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModel.kt @@ -0,0 +1,124 @@ +package com.x8bit.bitwarden.ui.vault.feature.manualcodeentry + +import android.os.Parcelable +import androidx.lifecycle.SavedStateHandle +import com.x8bit.bitwarden.data.vault.repository.VaultRepository +import com.x8bit.bitwarden.ui.platform.base.BaseViewModel +import com.x8bit.bitwarden.ui.platform.base.util.Text +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.flow.update +import kotlinx.parcelize.Parcelize +import javax.inject.Inject + +private const val KEY_STATE = "state" + +/** + * The ViewModel for handling user interactions in the manual code entry screen. + * + */ +@HiltViewModel +class ManualCodeEntryViewModel @Inject constructor( + savedStateHandle: SavedStateHandle, + private val vaultRepository: VaultRepository, +) : BaseViewModel( + initialState = savedStateHandle[KEY_STATE] + ?: ManualCodeEntryState(code = ""), +) { + override fun handleAction(action: ManualCodeEntryAction) { + when (action) { + is ManualCodeEntryAction.CloseClick -> handleCloseClick() + is ManualCodeEntryAction.CodeTextChange -> handleCodeTextChange(action) + is ManualCodeEntryAction.CodeSubmit -> handleCodeSubmit() + is ManualCodeEntryAction.ScanQrCodeTextClick -> handleScanQrCodeTextClick() + is ManualCodeEntryAction.SettingsClick -> handleSettingsClick() + } + } + + private fun handleCloseClick() { + sendEvent(ManualCodeEntryEvent.NavigateBack) + } + + private fun handleCodeTextChange(action: ManualCodeEntryAction.CodeTextChange) { + mutableStateFlow.update { + it.copy(code = action.code) + } + } + + private fun handleCodeSubmit() { + vaultRepository.emitTotpCode(state.code) + sendEvent(ManualCodeEntryEvent.NavigateBack) + } + + private fun handleScanQrCodeTextClick() { + sendEvent(ManualCodeEntryEvent.NavigateToQrCodeScreen) + } + + private fun handleSettingsClick() { + sendEvent(ManualCodeEntryEvent.NavigateToAppSettings) + } +} + +/** + * Models state of the manual entry screen. + */ +@Parcelize +data class ManualCodeEntryState( + val code: String, +) : Parcelable + +/** + * Models events for the [ManualCodeEntryScreen]. + */ +sealed class ManualCodeEntryEvent { + + /** + * Navigate back. + */ + data object NavigateBack : ManualCodeEntryEvent() + + /** + * Navigate to the Qr code screen. + */ + data object NavigateToQrCodeScreen : ManualCodeEntryEvent() + + /** + * Navigate to the app settings. + */ + data object NavigateToAppSettings : ManualCodeEntryEvent() + + /** + * Show a toast with the given [message]. + */ + data class ShowToast(val message: Text) : ManualCodeEntryEvent() +} + +/** + * Models actions for the [ManualCodeEntryScreen]. + */ +sealed class ManualCodeEntryAction { + + /** + * User clicked close. + */ + data object CloseClick : ManualCodeEntryAction() + + /** + * The user has submitted a code. + */ + data object CodeSubmit : ManualCodeEntryAction() + + /** + * The user has changed the code text. + */ + data class CodeTextChange(val code: String) : ManualCodeEntryAction() + + /** + * The text to switch to QR code scanning is clicked. + */ + data object ScanQrCodeTextClick : ManualCodeEntryAction() + + /** + * The action for the user clicking the settings button. + */ + data object SettingsClick : ManualCodeEntryAction() +} diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanNavigation.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanNavigation.kt index 3e7fa67b42..acc44e2c1d 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanNavigation.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanNavigation.kt @@ -12,11 +12,15 @@ private const val QR_CODE_SCAN_ROUTE: String = "qr_code_scan" */ fun NavGraphBuilder.vaultQrCodeScanDestination( onNavigateBack: () -> Unit, + onNavigateToManualCodeEntryScreen: () -> Unit, ) { composableWithSlideTransitions( route = QR_CODE_SCAN_ROUTE, ) { - QrCodeScanScreen(onNavigateBack) + QrCodeScanScreen( + onNavigateToManualCodeEntryScreen = onNavigateToManualCodeEntryScreen, + onNavigateBack = onNavigateBack, + ) } } diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreen.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreen.kt index 32b5c825fc..e485c01312 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreen.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreen.kt @@ -76,6 +76,7 @@ fun QrCodeScanScreen( onNavigateBack: () -> Unit, viewModel: QrCodeScanViewModel = hiltViewModel(), qrCodeAnalyzer: QrCodeAnalyzer = QrCodeAnalyzerImpl(), + onNavigateToManualCodeEntryScreen: () -> Unit, ) { qrCodeAnalyzer.onQrCodeScanned = remember(viewModel) { { viewModel.trySendAction(QrCodeScanAction.QrCodeScanReceive(it)) } @@ -100,6 +101,10 @@ fun QrCodeScanScreen( is QrCodeScanEvent.NavigateBack -> { onNavigateBack.invoke() } + + is QrCodeScanEvent.NavigateToManualCodeEntry -> { + onNavigateToManualCodeEntryScreen.invoke() + } } } diff --git a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModel.kt b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModel.kt index 7610878adf..b7c5bc156c 100644 --- a/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModel.kt +++ b/app/src/main/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModel.kt @@ -3,7 +3,6 @@ package com.x8bit.bitwarden.ui.vault.feature.qrcodescan import com.x8bit.bitwarden.data.vault.repository.VaultRepository import com.x8bit.bitwarden.ui.platform.base.BaseViewModel import com.x8bit.bitwarden.ui.platform.base.util.Text -import com.x8bit.bitwarden.ui.platform.base.util.asText import dagger.hilt.android.lifecycle.HiltViewModel import javax.inject.Inject @@ -21,8 +20,8 @@ class QrCodeScanViewModel @Inject constructor( when (action) { is QrCodeScanAction.CloseClick -> handleCloseClick() is QrCodeScanAction.ManualEntryTextClick -> handleManualEntryTextClick() + is QrCodeScanAction.CameraSetupErrorReceive -> handleCameraErrorReceive() is QrCodeScanAction.QrCodeScanReceive -> handleQrCodeScanReceive(action) - is QrCodeScanAction.CameraSetupErrorReceive -> handleCameraErrorReceive(action) } } @@ -33,11 +32,8 @@ class QrCodeScanViewModel @Inject constructor( } private fun handleManualEntryTextClick() { - // TODO: Implement Manual Entry Screen (BIT-1114) sendEvent( - QrCodeScanEvent.ShowToast( - message = "Not yet implemented.".asText(), - ), + QrCodeScanEvent.NavigateToManualCodeEntry, ) } @@ -46,14 +42,9 @@ class QrCodeScanViewModel @Inject constructor( sendEvent(QrCodeScanEvent.NavigateBack) } - private fun handleCameraErrorReceive( - action: QrCodeScanAction.CameraSetupErrorReceive, - ) { - // TODO: Implement Manual Entry Screen (BIT-1114) + private fun handleCameraErrorReceive() { sendEvent( - QrCodeScanEvent.ShowToast( - message = "Not yet implemented.".asText(), - ), + QrCodeScanEvent.NavigateToManualCodeEntry, ) } } @@ -68,6 +59,11 @@ sealed class QrCodeScanEvent { */ data object NavigateBack : QrCodeScanEvent() + /** + * Navigate to manual code entry screen. + */ + data object NavigateToManualCodeEntry : QrCodeScanEvent() + /** * Show a toast with the given [message]. */ diff --git a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreenTest.kt b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreenTest.kt index 1e4367e46d..3295544732 100644 --- a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreenTest.kt +++ b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditScreenTest.kt @@ -54,6 +54,7 @@ class VaultAddEditScreenTest : BaseComposeTest() { private var onNavigateBackCalled = false private var onNavigateQrCodeScanScreenCalled = false + private var onNavigateToManualCodeEntryScreenCalled = false private val mutableEventFlow = bufferedMutableSharedFlow() private val mutableStateFlow = MutableStateFlow(DEFAULT_STATE_LOGIN) @@ -69,12 +70,15 @@ class VaultAddEditScreenTest : BaseComposeTest() { fun setup() { composeTestRule.setContent { VaultAddEditScreen( - viewModel = viewModel, onNavigateBack = { onNavigateBackCalled = true }, - permissionsManager = fakePermissionManager, onNavigateToQrCodeScanScreen = { onNavigateQrCodeScanScreenCalled = true }, + onNavigateToManualCodeEntryScreen = { + onNavigateToManualCodeEntryScreenCalled = true + }, + viewModel = viewModel, + permissionsManager = fakePermissionManager, ) } } @@ -92,6 +96,13 @@ class VaultAddEditScreenTest : BaseComposeTest() { assertTrue(onNavigateQrCodeScanScreenCalled) } + @Suppress("MaxLineLength") + @Test + fun `on NavigateToManualCodeEntry event should invoke NavigateToManualCodeEntry`() { + mutableEventFlow.tryEmit(VaultAddEditEvent.NavigateToManualCodeEntry) + assertTrue(onNavigateToManualCodeEntryScreenCalled) + } + @Test fun `clicking close button should send CloseClick action`() { composeTestRule @@ -1429,6 +1440,7 @@ class VaultAddEditScreenTest : BaseComposeTest() { .onNodeWithTextAfterScroll(text = "Security code") .assertTextContains("123") } + @Test fun `clicking New Custom Field button should allow creation of Linked type`() { mutableStateFlow.value = DEFAULT_STATE_LOGIN diff --git a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModelTest.kt b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModelTest.kt index b66c3ccb18..7e76a4634e 100644 --- a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModelTest.kt +++ b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/addedit/VaultAddEditViewModelTest.kt @@ -558,7 +558,7 @@ class VaultAddEditViewModelTest : BaseViewModelTest() { @Suppress("MaxLineLength") @Test - fun `SetupTotpClick should emit ShowToast with permission not granted when isGranted is false`() = + fun `SetupTotpClick should emit NavigateToManualCodeEntry when isGranted is false`() = runTest { val viewModel = createAddVaultItemViewModel() @@ -568,10 +568,8 @@ class VaultAddEditViewModelTest : BaseViewModelTest() { isGranted = false, ), ) - assertEquals( - VaultAddEditEvent.ShowToast("Permission Not Granted, Manual QR Code Entry Not Implemented".asText()), - awaitItem(), - ) + + assertEquals(VaultAddEditEvent.NavigateToManualCodeEntry, awaitItem()) } } diff --git a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreenTests.kt b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreenTests.kt new file mode 100644 index 0000000000..acfdccdf2e --- /dev/null +++ b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryScreenTests.kt @@ -0,0 +1,204 @@ +package com.x8bit.bitwarden.ui.vault.feature.manualcodeentry + +import android.app.Application +import android.content.Intent +import android.net.Uri +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsNotDisplayed +import androidx.compose.ui.test.assertTextEquals +import androidx.compose.ui.test.filterToOne +import androidx.compose.ui.test.hasAnyAncestor +import androidx.compose.ui.test.isDialog +import androidx.compose.ui.test.onAllNodesWithText +import androidx.compose.ui.test.onFirst +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performTextInput +import androidx.test.core.app.ApplicationProvider +import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow +import com.x8bit.bitwarden.ui.platform.base.BaseComposeTest +import com.x8bit.bitwarden.ui.platform.base.util.FakePermissionManager +import com.x8bit.bitwarden.ui.platform.base.util.IntentHandler +import io.mockk.every +import io.mockk.mockk +import io.mockk.slot +import io.mockk.verify +import junit.framework.TestCase.assertEquals +import junit.framework.TestCase.assertTrue +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.update +import org.junit.Before +import org.junit.Test + +class ManualCodeEntryScreenTests : BaseComposeTest() { + + private var onNavigateBackCalled = false + private var onNavigateToScanQrCodeCalled = false + + private val mutableEventFlow = bufferedMutableSharedFlow() + private val mutableStateFlow = + MutableStateFlow(ManualCodeEntryState("")) + + private val fakePermissionManager: FakePermissionManager = FakePermissionManager() + private val intentHandler = mockk(relaxed = true) + + private val viewModel = mockk(relaxed = true) { + every { eventFlow } returns mutableEventFlow + every { stateFlow } returns mutableStateFlow + } + + @Before + fun setup() { + composeTestRule.setContent { + ManualCodeEntryScreen( + onNavigateBack = { onNavigateBackCalled = true }, + viewModel = viewModel, + onNavigateToQrCodeScreen = { + onNavigateToScanQrCodeCalled = true + }, + permissionsManager = fakePermissionManager, + intentHandler = intentHandler, + ) + } + } + + @Test + fun `on NavigateBack event should invoke onNavigateBack`() { + mutableEventFlow.tryEmit(ManualCodeEntryEvent.NavigateBack) + assertTrue(onNavigateBackCalled) + } + + @Test + fun `on NavigateToScanQrCode event should invoke NavigateToScanQrCode`() { + mutableEventFlow.tryEmit(ManualCodeEntryEvent.NavigateToQrCodeScreen) + assertTrue(onNavigateToScanQrCodeCalled) + } + + @Test + fun `on NavigateToAppSettings event should invoke intent handler`() { + mutableEventFlow.tryEmit(ManualCodeEntryEvent.NavigateToAppSettings) + + val uri = Uri.parse( + "package:" + + ApplicationProvider + .getApplicationContext() + .packageName, + ) + + val intentSlot = slot() + verify { intentHandler.startActivity(capture(intentSlot)) } + + assertEquals( + uri, + intentSlot.captured.data, + ) + } + + @Suppress("MaxLineLength") + @Test + fun `clicking on manual text should send ScanQrCodeTextClick if camera permission is granted`() { + fakePermissionManager.checkPermissionResult = true + + composeTestRule + .onNodeWithText("Scan QR Code") + .performClick() + + verify { + viewModel.trySendAction(ManualCodeEntryAction.ScanQrCodeTextClick) + } + } + + @Test + fun `dialog should be dismissed on dismiss click in settings dialog`() { + fakePermissionManager.checkPermissionResult = false + + composeTestRule + .onNodeWithText("Scan QR Code") + .performClick() + + composeTestRule + .onAllNodesWithText("Enable camera permission to use the scanner") + .filterToOne(hasAnyAncestor(isDialog())) + .assertIsDisplayed() + + composeTestRule + .onNodeWithText("No thanks") + .performClick() + + composeTestRule + .onAllNodesWithText("Enable camera permission to use the scanner") + .filterToOne(hasAnyAncestor(isDialog())) + .assertIsNotDisplayed() + } + + @Test + fun `settings dialog should call SettingsClick action on confirm click`() { + fakePermissionManager.checkPermissionResult = false + + composeTestRule + .onNodeWithText("Scan QR Code") + .performClick() + + composeTestRule + .onAllNodesWithText("Enable camera permission to use the scanner") + .filterToOne(hasAnyAncestor(isDialog())) + .assertIsDisplayed() + + composeTestRule + .onNodeWithText("Settings") + .performClick() + + verify { + viewModel.trySendAction(ManualCodeEntryAction.SettingsClick) + } + } + + @Test + fun `CodeTextChanged will be sent when text for code is updated`() { + composeTestRule + .onAllNodesWithText(text = "Authenticator key") + .onFirst() + .assertTextEquals("Authenticator key", "") + + composeTestRule + .onAllNodesWithText(text = "Authenticator key") + .onFirst() + .performTextInput(text = "TestCode") + + verify { + viewModel.trySendAction( + ManualCodeEntryAction.CodeTextChange("TestCode"), + ) + } + } + + @Test + fun `Authenticator key text should display the text provided by the state`() { + composeTestRule + .onAllNodesWithText(text = "Authenticator key") + .onFirst() + .assertTextEquals("Authenticator key", "") + + mutableStateFlow.update { + it.copy(code = "TestCode") + } + + composeTestRule + .onAllNodesWithText(text = "Authenticator key") + .onFirst() + .assertTextEquals("Authenticator key", "TestCode") + } + + @Test + fun `clicking Add TOTP button should send CodeSubmit action`() { + composeTestRule + .onNodeWithText(text = "Add TOTP") + .performClick() + + verify { + viewModel.trySendAction( + ManualCodeEntryAction.CodeSubmit, + ) + } + } +} diff --git a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModelTests.kt b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModelTests.kt new file mode 100644 index 0000000000..9a44e4c200 --- /dev/null +++ b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/manualcodeentry/ManualCodeEntryViewModelTests.kt @@ -0,0 +1,92 @@ +package com.x8bit.bitwarden.ui.vault.feature.manualcodeentry + +import androidx.lifecycle.SavedStateHandle +import app.cash.turbine.test +import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow +import com.x8bit.bitwarden.data.vault.repository.VaultRepository +import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest +import io.mockk.every +import io.mockk.just +import io.mockk.mockk +import io.mockk.runs +import io.mockk.verify +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.test.runTest +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Test + +class ManualCodeEntryViewModelTests : BaseViewModelTest() { + + private val totpTestCodeFlow: Flow = bufferedMutableSharedFlow() + private val vaultRepository: VaultRepository = mockk { + every { totpCodeFlow } returns totpTestCodeFlow + every { emitTotpCode(any()) } just runs + } + + @Test + fun `CloseClick should emit NavigateBack`() = runTest { + val viewModel = createViewModel(initialState = ManualCodeEntryState("")) + + viewModel.eventFlow.test { + viewModel.actionChannel.trySend(ManualCodeEntryAction.CloseClick) + assertEquals(ManualCodeEntryEvent.NavigateBack, awaitItem()) + } + } + + @Test + fun `CodeSubmit should emit new code and NavigateBack`() = runTest { + val viewModel = + createViewModel(initialState = ManualCodeEntryState("TestCode")) + + viewModel.eventFlow.test { + viewModel.actionChannel.trySend(ManualCodeEntryAction.CodeSubmit) + + verify(exactly = 1) { vaultRepository.emitTotpCode("TestCode") } + assertEquals(ManualCodeEntryEvent.NavigateBack, awaitItem()) + } + } + + @Test + fun `CodeTextChange should update state with new value`() = runTest { + val viewModel = + createViewModel(initialState = ManualCodeEntryState("TestCode")) + + val expectedState = ManualCodeEntryState("NewCode") + + viewModel.actionChannel.trySend(ManualCodeEntryAction.CodeTextChange("NewCode")) + assertEquals(expectedState, viewModel.stateFlow.value) + } + + @Test + fun `SettingsClick should emit NavigateToAppSettings and update state`() = runTest { + val viewModel = createViewModel(initialState = ManualCodeEntryState("")) + + val expectedState = ManualCodeEntryState("") + + viewModel.eventFlow.test { + viewModel.actionChannel.trySend(ManualCodeEntryAction.SettingsClick) + + assertEquals(ManualCodeEntryEvent.NavigateToAppSettings, awaitItem()) + assertEquals(expectedState, viewModel.stateFlow.value) + } + } + + @Test + fun `ScanQrTextCodeClick should emit NavigateToQrCodeScreen`() = runTest { + val viewModel = createViewModel(initialState = ManualCodeEntryState("")) + + viewModel.eventFlow.test { + viewModel.actionChannel.trySend(ManualCodeEntryAction.ScanQrCodeTextClick) + + assertEquals(ManualCodeEntryEvent.NavigateToQrCodeScreen, awaitItem()) + } + } + + private fun createViewModel(initialState: ManualCodeEntryState): ManualCodeEntryViewModel = + ManualCodeEntryViewModel( + vaultRepository = vaultRepository, + savedStateHandle = SavedStateHandle( + initialState = mapOf("state" to initialState), + ), + ) +} diff --git a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreenTest.kt b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreenTest.kt index d3ead40faf..707d58f0c2 100644 --- a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreenTest.kt +++ b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanScreenTest.kt @@ -17,6 +17,7 @@ import org.robolectric.annotation.Config class QrCodeScanScreenTest : BaseComposeTest() { private var onNavigateBackCalled = false + private var onNavigateToManualCodeEntryScreenCalled = false private val imageProxy: ImageProxy = mockk() private val qrCodeAnalyzer = FakeQrCodeAnalyzer() @@ -31,9 +32,12 @@ class QrCodeScanScreenTest : BaseComposeTest() { fun setup() { composeTestRule.setContent { QrCodeScanScreen( - qrCodeAnalyzer = qrCodeAnalyzer, - viewModel = viewModel, onNavigateBack = { onNavigateBackCalled = true }, + viewModel = viewModel, + qrCodeAnalyzer = qrCodeAnalyzer, + onNavigateToManualCodeEntryScreen = { + onNavigateToManualCodeEntryScreenCalled = true + }, ) } } @@ -44,6 +48,12 @@ class QrCodeScanScreenTest : BaseComposeTest() { assertTrue(onNavigateBackCalled) } + @Test + fun `on NavigateToManualCodeEntry event should invoke onNavigateToManualCodeEntryScreen`() { + mutableEventFlow.tryEmit(QrCodeScanEvent.NavigateToManualCodeEntry) + assertTrue(onNavigateToManualCodeEntryScreenCalled) + } + @Test fun `when unable to setup camera CameraErrorReceive will be sent`() = runTest { // Because the camera is not set up in the tests, this will always be triggered diff --git a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModelTest.kt b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModelTest.kt index 0e2c7a6f6b..c6566b7c81 100644 --- a/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModelTest.kt +++ b/app/src/test/java/com/x8bit/bitwarden/ui/vault/feature/qrcodescan/QrCodeScanViewModelTest.kt @@ -4,7 +4,6 @@ import app.cash.turbine.test import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow import com.x8bit.bitwarden.data.vault.repository.VaultRepository import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest -import com.x8bit.bitwarden.ui.platform.base.util.asText import io.mockk.every import io.mockk.just import io.mockk.mockk @@ -34,13 +33,13 @@ class QrCodeScanViewModelTest : BaseViewModelTest() { } @Test - fun `CameraErrorReceive should emit ShowToast`() = runTest { + fun `CameraErrorReceive should emit NavigateToManualCodeEntry`() = runTest { val viewModel = createViewModel() viewModel.eventFlow.test { viewModel.actionChannel.trySend(QrCodeScanAction.CameraSetupErrorReceive) assertEquals( - QrCodeScanEvent.ShowToast("Not yet implemented.".asText()), + QrCodeScanEvent.NavigateToManualCodeEntry, awaitItem(), ) } @@ -53,7 +52,7 @@ class QrCodeScanViewModelTest : BaseViewModelTest() { viewModel.eventFlow.test { viewModel.actionChannel.trySend(QrCodeScanAction.ManualEntryTextClick) assertEquals( - QrCodeScanEvent.ShowToast("Not yet implemented.".asText()), + QrCodeScanEvent.NavigateToManualCodeEntry, awaitItem(), ) }