swift/Beam
swift/Beam
1
0
Fork 0
mirror of https://github.com/element-hq/element-x-ios.git synced 2025-03-10 21:39:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Show recovery instead of verification if this is the last session and recovery is set up

Browse Source 
* Show recovery instead of verification if this is the last session and recovery is set up

* Rename `recoveryKeyState` to `recoveryState`

* Remove duplicates on session security state changes.

* Fix missing "Save recovery key" button

* Fix unit tests

* Rename `isLastDevice` to `isOnlyDeviceLeft`

* Address PR comments
This commit is contained in:
Stefan Ceriu 2024-02-16 11:38:49 +02:00 committed by GitHub
parent e0c9f43026
commit db05540cc5
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 255 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinator.swift
View File

@ -361,12 +361,12 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
private func runLogoutFlow() async {
let secureBackupController = userSession.clientProxy.secureBackupController
guard case let .success(isLastSession) = await secureBackupController.isLastSession() else {
guard case let .success(isLastDevice) = await userSession.clientProxy.isOnlyDeviceLeft() else {
ServiceLocator.shared.userIndicatorController.alertInfo = .init(id: .init())
return
}
guard isLastSession else {
guard isLastDevice else {
ServiceLocator.shared.userIndicatorController.alertInfo = .init(id: .init(),
title: L10n.screenSignoutConfirmationDialogTitle,
message: L10n.screenSignoutConfirmationDialogContent,
@ -376,7 +376,7 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
return
}
guard secureBackupController.recoveryKeyState.value == .enabled else {
guard secureBackupController.recoveryState.value == .enabled else {
ServiceLocator.shared.userIndicatorController.alertInfo = .init(id: .init(),
title: L10n.screenSignoutRecoveryDisabledTitle,
message: L10n.screenSignoutRecoveryDisabledSubtitle,

25
ElementX/Sources/Mocks/Generated/GeneratedMocks.swift
View File

@ -2363,11 +2363,11 @@ class RoomTimelineProviderMock: RoomTimelineProviderProtocol {
}
class SecureBackupControllerMock: SecureBackupControllerProtocol {
var recoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never> {
get { return underlyingRecoveryKeyState }
set(value) { underlyingRecoveryKeyState = value }
var recoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never> {
get { return underlyingRecoveryState }
set(value) { underlyingRecoveryState = value }
}
var underlyingRecoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never>!
var underlyingRecoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never>!
var keyBackupState: CurrentValuePublisher<SecureBackupKeyBackupState, Never> {
get { return underlyingKeyBackupState }
set(value) { underlyingKeyBackupState = value }
@ -2446,23 +2446,6 @@ class SecureBackupControllerMock: SecureBackupControllerProtocol {
return confirmRecoveryKeyReturnValue
}
}
//MARK: - isLastSession
var isLastSessionCallsCount = 0
var isLastSessionCalled: Bool {
return isLastSessionCallsCount > 0
}
var isLastSessionReturnValue: Result<Bool, SecureBackupControllerError>!
var isLastSessionClosure: (() async -> Result<Bool, SecureBackupControllerError>)?
func isLastSession() async -> Result<Bool, SecureBackupControllerError> {
isLastSessionCallsCount += 1
if let isLastSessionClosure = isLastSessionClosure {
return await isLastSessionClosure()
} else {
return isLastSessionReturnValue
}
}
//MARK: - waitForKeyBackupUpload
var waitForKeyBackupUploadCallsCount = 0

30
ElementX/Sources/Screens/HomeScreen/HomeScreenModels.swift
View File

@ -75,33 +75,21 @@ enum HomeScreenRoomListMode: CustomStringConvertible {
}
}
enum SecurityBannerMode {
case none
case dismissed
case sessionVerification
case recoveryKeyConfirmation
}
struct HomeScreenViewState: BindableState {
let userID: String
var userDisplayName: String?
var userAvatarURL: URL?
var isSessionVerified: Bool?
var hasSessionVerificationBannerBeenDismissed = false
var showSessionVerificationBanner: Bool {
guard let isSessionVerified else {
return false
}
var securityBannerMode = SecurityBannerMode.none
var requiresExtraAccountSetup = false
return !isSessionVerified && !hasSessionVerificationBannerBeenDismissed
}
var requiresSecureBackupSetup = false
var needsRecoveryKeyConfirmation = false
var hasRecoveryKeyConfirmationBannerBeenDismissed = false
var showRecoveryKeyConfirmationBanner: Bool {
guard let isSessionVerified else {
return false
}
return isSessionVerified && needsRecoveryKeyConfirmation && !hasRecoveryKeyConfirmationBannerBeenDismissed
}
var rooms: [HomeScreenRoom] = []
var roomListMode: HomeScreenRoomListMode = .skeletons

41
ElementX/Sources/Screens/HomeScreen/HomeScreenViewModel.swift
View File

@ -61,20 +61,35 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
.weakAssign(to: \.state.userDisplayName, on: self)
.store(in: &cancellables)
userSession.sessionVerificationState
userSession.sessionSecurityStatePublisher
.receive(on: DispatchQueue.main)
.weakAssign(to: \.state.isSessionVerified, on: self)
.store(in: &cancellables)
userSession.clientProxy.secureBackupController.recoveryKeyState
.receive(on: DispatchQueue.main)
.sink { [weak self] recoveryKeyState in
.sink { [weak self] securityState in
guard let self else { return }
let requiresSecureBackupSetup = recoveryKeyState == .disabled || recoveryKeyState == .incomplete
state.requiresSecureBackupSetup = requiresSecureBackupSetup
state.needsRecoveryKeyConfirmation = recoveryKeyState == .incomplete
switch (securityState.verificationState, securityState.recoveryState) {
case (.unverified, _):
state.requiresExtraAccountSetup = true
if state.securityBannerMode != .dismissed {
state.securityBannerMode = .sessionVerification
}
case (.unverifiedLastSession, .incomplete):
state.requiresExtraAccountSetup = true
if state.securityBannerMode != .dismissed {
state.securityBannerMode = .recoveryKeyConfirmation
}
case (.verified, .disabled):
state.requiresExtraAccountSetup = true
state.securityBannerMode = .none
case (.verified, .incomplete):
state.requiresExtraAccountSetup = true
if state.securityBannerMode != .dismissed {
state.securityBannerMode = .recoveryKeyConfirmation
}
default:
state.securityBannerMode = .none
state.requiresExtraAccountSetup = false
}
}
.store(in: &cancellables)
@ -149,9 +164,9 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
case .confirmRecoveryKey:
actionsSubject.send(.presentSecureBackupSettings)
case .skipSessionVerification:
state.hasSessionVerificationBannerBeenDismissed = true
state.securityBannerMode = .dismissed
case .skipRecoveryKeyConfirmation:
state.hasRecoveryKeyConfirmationBannerBeenDismissed = true
state.securityBannerMode = .dismissed
case .updateVisibleItemRange(let range, let isScrolling):
visibleItemRangePublisher.send((range, isScrolling))
case .startChat:

7
ElementX/Sources/Screens/HomeScreen/View/HomeScreenContent.swift
View File

@ -116,10 +116,13 @@ struct HomeScreenContent: View {
filters
}
if context.viewState.showSessionVerificationBanner {
switch context.viewState.securityBannerMode {
case .sessionVerification:
HomeScreenSessionVerificationBanner(context: context)
} else if context.viewState.showRecoveryKeyConfirmationBanner {
case .recoveryKeyConfirmation:
HomeScreenRecoveryKeyConfirmationBanner(context: context)
default:
EmptyView()
}
if context.viewState.hasPendingInvitations, !context.isSearchFieldFocused {

4
ElementX/Sources/Screens/HomeScreen/View/HomeScreenUserMenuButton.swift
View File

@ -29,7 +29,7 @@ struct HomeScreenUserMenuButton: View {
Label {
Text(L10n.commonSettings)
} icon: {
if context.viewState.requiresSecureBackupSetup, context.viewState.isSessionVerified == true {
if context.viewState.requiresExtraAccountSetup {
CompoundIcon(asset: Asset.Images.settingsIconWithBadge)
} else {
CompoundIcon(\.settings)
@ -50,7 +50,7 @@ struct HomeScreenUserMenuButton: View {
avatarSize: .user(on: .home),
imageProvider: context.imageProvider)
.accessibilityIdentifier(A11yIdentifiers.homeScreen.userAvatar)
.overlayBadge(10, isBadged: context.viewState.requiresSecureBackupSetup && context.viewState.isSessionVerified == true)
.overlayBadge(10, isBadged: context.viewState.requiresExtraAccountSetup)
.compositingGroup()
}
.accessibilityLabel(L10n.a11yUserMenu)

6
ElementX/Sources/Screens/SecureBackup/SecureBackupRecoveryKeyScreen/SecureBackupRecoveryKeyScreenViewModel.swift
View File

@ -32,9 +32,9 @@ class SecureBackupRecoveryKeyScreenViewModel: SecureBackupRecoveryKeyScreenViewM
self.secureBackupController = secureBackupController
self.userIndicatorController = userIndicatorController
super.init(initialViewState: .init(mode: secureBackupController.recoveryKeyState.value.viewMode, bindings: .init()))
super.init(initialViewState: .init(mode: secureBackupController.recoveryState.value.viewMode, bindings: .init()))
secureBackupController.recoveryKeyState
secureBackupController.recoveryState
.receive(on: DispatchQueue.main)
.sink(receiveValue: { [weak userIndicatorController] state in
let loadingIndicatorIdentifier = "SecureBackupRecoveryKeyScreenLoading"
@ -100,7 +100,7 @@ class SecureBackupRecoveryKeyScreenViewModel: SecureBackupRecoveryKeyScreenViewM
}
}
extension SecureBackupRecoveryKeyState {
extension SecureBackupRecoveryState {
var viewMode: SecureBackupRecoveryKeyScreenViewMode {
switch self {
case .disabled:

32
ElementX/Sources/Screens/SecureBackup/SecureBackupRecoveryKeyScreen/View/SecureBackupRecoveryKeyScreen.swift
View File

@ -65,6 +65,20 @@ struct SecureBackupRecoveryKeyScreen: View {
private var footer: some View {
switch context.viewState.mode {
case .setupRecovery, .changeRecovery:
recoveryCreatedActionButtons
case .fixRecovery:
Button {
context.send(viewAction: .confirmKey)
} label: {
Text(L10n.actionConfirm)
}
.buttonStyle(.compound(.primary))
.disabled(context.confirmationRecoveryKey.isEmpty)
}
}
private var recoveryCreatedActionButtons: some View {
VStack(spacing: 8.0) {
if let recoveryKey = context.viewState.recoveryKey {
ShareLink(item: recoveryKey) {
Label(L10n.screenRecoveryKeySaveAction, icon: \.download)
@ -82,14 +96,6 @@ struct SecureBackupRecoveryKeyScreen: View {
}
.buttonStyle(.compound(.primary))
.disabled(context.viewState.recoveryKey == nil || context.viewState.doneButtonEnabled == false)
case .fixRecovery:
Button {
context.send(viewAction: .confirmKey)
} label: {
Text(L10n.actionConfirm)
}
.buttonStyle(.compound(.primary))
.disabled(context.confirmationRecoveryKey.isEmpty)
}
}
@ -204,9 +210,9 @@ struct SecureBackupRecoveryKeyScreen: View {
// MARK: - Previews
struct SecureBackupRecoveryKeyScreen_Previews: PreviewProvider, TestablePreview {
static let setupViewModel = viewModel(recoveryKeyState: .enabled)
static let notSetUpViewModel = viewModel(recoveryKeyState: .disabled)
static let incompleteViewModel = viewModel(recoveryKeyState: .incomplete)
static let setupViewModel = viewModel(recoveryState: .enabled)
static let notSetUpViewModel = viewModel(recoveryState: .disabled)
static let incompleteViewModel = viewModel(recoveryState: .incomplete)
static var previews: some View {
NavigationStack {
@ -225,9 +231,9 @@ struct SecureBackupRecoveryKeyScreen_Previews: PreviewProvider, TestablePreview
.previewDisplayName("Incomplete")
}
static func viewModel(recoveryKeyState: SecureBackupRecoveryKeyState) -> SecureBackupRecoveryKeyScreenViewModelType {
static func viewModel(recoveryState: SecureBackupRecoveryState) -> SecureBackupRecoveryKeyScreenViewModelType {
let backupController = SecureBackupControllerMock()
backupController.underlyingRecoveryKeyState = CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(recoveryKeyState).asCurrentValuePublisher()
backupController.underlyingRecoveryState = CurrentValueSubject<SecureBackupRecoveryState, Never>(recoveryState).asCurrentValuePublisher()
return SecureBackupRecoveryKeyScreenViewModel(secureBackupController: backupController, userIndicatorController: UserIndicatorControllerMock())
}

2
ElementX/Sources/Screens/SecureBackup/SecureBackupScreen/SecureBackupScreenModels.swift
View File

@ -23,7 +23,7 @@ enum SecureBackupScreenViewModelAction {
struct SecureBackupScreenViewState: BindableState {
let chatBackupDetailsURL: URL
var recoveryKeyState = SecureBackupRecoveryKeyState.unknown
var recoveryState = SecureBackupRecoveryState.unknown
var keyBackupState = SecureBackupKeyBackupState.unknown
var bindings = SecureBackupScreenViewStateBindings()
}

4
ElementX/Sources/Screens/SecureBackup/SecureBackupScreen/SecureBackupScreenViewModel.swift
View File

@ -36,9 +36,9 @@ class SecureBackupScreenViewModel: SecureBackupScreenViewModelType, SecureBackup
super.init(initialViewState: .init(chatBackupDetailsURL: chatBackupDetailsURL))
secureBackupController.recoveryKeyState
secureBackupController.recoveryState
.receive(on: DispatchQueue.main)
.weakAssign(to: \.state.recoveryKeyState, on: self)
.weakAssign(to: \.state.recoveryState, on: self)
.store(in: &cancellables)
secureBackupController.keyBackupState

18
ElementX/Sources/Screens/SecureBackup/SecureBackupScreen/View/SecureBackupScreen.swift
View File

@ -25,7 +25,7 @@ struct SecureBackupScreen: View {
Form {
// Show recovery options for confirming the recovery key and
// getting access to secrets and implicitly the key backup
if context.viewState.recoveryKeyState == .incomplete {
if context.viewState.recoveryState == .incomplete {
recoveryKeySection
} else {
keyBackupSection
@ -93,7 +93,7 @@ struct SecureBackupScreen: View {
@ViewBuilder
private var recoveryKeySection: some View {
Section {
switch context.viewState.recoveryKeyState {
switch context.viewState.recoveryState {
case .enabled:
ListRow(label: .plain(title: L10n.screenChatBackupRecoveryActionChange),
kind: .navigationLink { context.send(viewAction: .recoveryKey) })
@ -116,7 +116,7 @@ struct SecureBackupScreen: View {
@ViewBuilder
private var recoveryKeySectionFooter: some View {
switch context.viewState.recoveryKeyState {
switch context.viewState.recoveryState {
case .disabled:
Text(L10n.screenChatBackupRecoveryActionSetupDescription(InfoPlistReader.main.bundleDisplayName))
case .incomplete:
@ -130,10 +130,10 @@ struct SecureBackupScreen: View {
// MARK: - Previews
struct SecureBackupScreen_Previews: PreviewProvider, TestablePreview {
static let bothSetupViewModel = viewModel(keyBackupState: .enabled, recoveryKeyState: .enabled)
static let onlyKeyBackupSetUpViewModel = viewModel(keyBackupState: .enabled, recoveryKeyState: .disabled)
static let keyBackupDisabledViewModel = viewModel(keyBackupState: .unknown, recoveryKeyState: .disabled)
static let recoveryIncompleteViewModel = viewModel(keyBackupState: .enabled, recoveryKeyState: .incomplete)
static let bothSetupViewModel = viewModel(keyBackupState: .enabled, recoveryState: .enabled)
static let onlyKeyBackupSetUpViewModel = viewModel(keyBackupState: .enabled, recoveryState: .disabled)
static let keyBackupDisabledViewModel = viewModel(keyBackupState: .unknown, recoveryState: .disabled)
static let recoveryIncompleteViewModel = viewModel(keyBackupState: .enabled, recoveryState: .incomplete)
static var previews: some View {
Group {
@ -161,10 +161,10 @@ struct SecureBackupScreen_Previews: PreviewProvider, TestablePreview {
}
static func viewModel(keyBackupState: SecureBackupKeyBackupState,
recoveryKeyState: SecureBackupRecoveryKeyState) -> SecureBackupScreenViewModelType {
recoveryState: SecureBackupRecoveryState) -> SecureBackupScreenViewModelType {
let backupController = SecureBackupControllerMock()
backupController.underlyingKeyBackupState = CurrentValueSubject<SecureBackupKeyBackupState, Never>(keyBackupState).asCurrentValuePublisher()
backupController.underlyingRecoveryKeyState = CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(recoveryKeyState).asCurrentValuePublisher()
backupController.underlyingRecoveryState = CurrentValueSubject<SecureBackupRecoveryState, Never>(recoveryState).asCurrentValuePublisher()
return SecureBackupScreenViewModel(secureBackupController: backupController,
userIndicatorController: UserIndicatorControllerMock(),

11
ElementX/Sources/Screens/Settings/SettingsScreen/SettingsScreenModels.swift
View File

@ -34,6 +34,12 @@ enum SettingsScreenViewModelAction {
case logout
}
enum SettingsScreenSecuritySectionMode {
case none
case sessionVerification
case secureBackup
}
struct SettingsScreenViewState: BindableState {
var deviceID: String?
var userID: String
@ -41,9 +47,10 @@ struct SettingsScreenViewState: BindableState {
var accountSessionsListURL: URL?
var userAvatarURL: URL?
var userDisplayName: String?
var isSessionVerified: Bool?
var showSecureBackupBadge = false
var showDeveloperOptions: Bool
var securitySectionMode = SettingsScreenSecuritySectionMode.none
var showSecuritySectionBadge = false
}
enum SettingsScreenViewAction {

30
ElementX/Sources/Screens/Settings/SettingsScreen/SettingsScreenViewModel.swift
View File

@ -44,17 +44,31 @@ class SettingsScreenViewModel: SettingsScreenViewModelType, SettingsScreenViewMo
.weakAssign(to: \.state.userDisplayName, on: self)
.store(in: &cancellables)
userSession.sessionVerificationState
userSession.sessionSecurityStatePublisher
.receive(on: DispatchQueue.main)
.weakAssign(to: \.state.isSessionVerified, on: self)
.store(in: &cancellables)
userSession.clientProxy.secureBackupController.recoveryKeyState
.receive(on: DispatchQueue.main)
.sink { [weak self] state in
.sink { [weak self] securityState in
guard let self else { return }
self.state.showSecureBackupBadge = (state == .incomplete || state == .disabled)
switch (securityState.verificationState, securityState.recoveryState) {
case (.unverified, _):
state.showSecuritySectionBadge = true
state.securitySectionMode = .sessionVerification
case (.unverifiedLastSession, .incomplete):
state.showSecuritySectionBadge = true
state.securitySectionMode = .secureBackup
case (.verified, .disabled):
state.showSecuritySectionBadge = true
state.securitySectionMode = .secureBackup
case (.verified, .incomplete):
state.showSecuritySectionBadge = true
state.securitySectionMode = .secureBackup
case (.unknown, _):
state.showSecuritySectionBadge = false
state.securitySectionMode = .none
default:
state.showSecuritySectionBadge = false
state.securitySectionMode = .secureBackup
}
}
.store(in: &cancellables)

30
ElementX/Sources/Screens/Settings/SettingsScreen/View/SettingsScreen.swift
View File

@ -80,18 +80,20 @@ struct SettingsScreen: View {
@ViewBuilder
private var accountSecuritySection: some View {
Section {
if let isSessionVerified = context.viewState.isSessionVerified {
if !isSessionVerified {
ListRow(label: .default(title: L10n.actionCompleteVerification,
icon: \.checkCircle),
kind: .button { context.send(viewAction: .sessionVerification) })
} else {
ListRow(label: .default(title: L10n.commonChatBackup,
icon: \.key),
details: context.viewState.showSecureBackupBadge ? .icon(secureBackupBadge) : nil,
kind: .navigationLink { context.send(viewAction: .secureBackup) })
.accessibilityIdentifier(A11yIdentifiers.settingsScreen.secureBackup)
}
switch context.viewState.securitySectionMode {
case .sessionVerification:
ListRow(label: .default(title: L10n.actionCompleteVerification,
icon: \.checkCircle),
details: context.viewState.showSecuritySectionBadge ? .icon(securitySectionBadge) : nil,
kind: .button { context.send(viewAction: .sessionVerification) })
case .secureBackup:
ListRow(label: .default(title: L10n.commonChatBackup,
icon: \.key),
details: context.viewState.showSecuritySectionBadge ? .icon(securitySectionBadge) : nil,
kind: .navigationLink { context.send(viewAction: .secureBackup) })
.accessibilityIdentifier(A11yIdentifiers.settingsScreen.secureBackup)
default:
EmptyView()
}
}
}
@ -210,8 +212,8 @@ struct SettingsScreen: View {
}
@ViewBuilder
private var secureBackupBadge: some View {
if context.viewState.showSecureBackupBadge {
private var securitySectionBadge: some View {
if context.viewState.showSecuritySectionBadge {
BadgeView(size: 10)
}
}

10
ElementX/Sources/Services/Client/ClientProxy.swift
View File

@ -166,6 +166,16 @@ class ClientProxy: ClientProxyProtocol {
let digest = SHA256.hash(data: data)
return digest.compactMap { String(format: "%02x", $0) }.joined()
}()
func isOnlyDeviceLeft() async -> Result<Bool, ClientProxyError> {
do {
let result = try await client.encryption().isLastDevice()
return .success(result)
} catch {
MXLog.error("Failed checking isLastDevice with error: \(error)")
return .failure(.failedCheckingIsLastDevice(error))
}
}
func startSync() {
guard !hasEncounteredAuthError else {

3
ElementX/Sources/Services/Client/ClientProxyProtocol.swift
View File

@ -49,6 +49,7 @@ enum ClientProxyError: Error {
case failedSearchingUsers
case failedGettingUserProfile
case failedSettingUserAvatar
case failedCheckingIsLastDevice(Error?)
}
enum SlidingSyncConstants {
@ -96,6 +97,8 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
var secureBackupController: SecureBackupControllerProtocol { get }
func isOnlyDeviceLeft() async -> Result<Bool, ClientProxyError>
func startSync()
func stopSync()

7
ElementX/Sources/Services/Client/MockClientProxy.swift
View File

@ -42,9 +42,8 @@ class MockClientProxy: ClientProxyProtocol {
lazy var secureBackupController: SecureBackupControllerProtocol = {
let secureBackupController = SecureBackupControllerMock()
secureBackupController.underlyingRecoveryKeyState = .init(CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(.enabled))
secureBackupController.underlyingRecoveryState = .init(CurrentValueSubject<SecureBackupRecoveryState, Never>(.enabled))
secureBackupController.underlyingKeyBackupState = .init(CurrentValueSubject<SecureBackupKeyBackupState, Never>(.enabled))
secureBackupController.isLastSessionReturnValue = .success(false)
return secureBackupController
}()
@ -54,6 +53,10 @@ class MockClientProxy: ClientProxyProtocol {
self.roomSummaryProvider = roomSummaryProvider
}
func isOnlyDeviceLeft() async -> Result<Bool, ClientProxyError> {
.success(false)
}
func startSync() { }
func stopSync() { }

34
ElementX/Sources/Services/SecureBackup/SecureBackupController.swift
View File

@ -21,7 +21,7 @@ import MatrixRustSDK
class SecureBackupController: SecureBackupControllerProtocol {
private let encryption: Encryption
private let recoveryKeyStateSubject = CurrentValueSubject<SecureBackupRecoveryKeyState, Never>(.unknown)
private let recoveryStateSubject = CurrentValueSubject<SecureBackupRecoveryState, Never>(.unknown)
private let keyBackupStateSubject = CurrentValueSubject<SecureBackupKeyBackupState, Never>(.unknown)
// periphery:ignore - retaining purpose
@ -33,8 +33,8 @@ class SecureBackupController: SecureBackupControllerProtocol {
/// Used to dedupe remote backup state requests
@CancellableTask private var remoteBackupStateTask: Task<Void, Error>?
var recoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never> {
recoveryKeyStateSubject.asCurrentValuePublisher()
var recoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never> {
recoveryStateSubject.asCurrentValuePublisher()
}
var keyBackupState: CurrentValuePublisher<SecureBackupKeyBackupState, Never> {
@ -76,16 +76,16 @@ class SecureBackupController: SecureBackupControllerProtocol {
switch state {
case .unknown:
recoveryKeyStateSubject.send(.unknown)
recoveryStateSubject.send(.unknown)
case .enabled:
recoveryKeyStateSubject.send(.enabled)
recoveryStateSubject.send(.enabled)
case .disabled:
recoveryKeyStateSubject.send(.disabled)
recoveryStateSubject.send(.disabled)
case .incomplete:
recoveryKeyStateSubject.send(.incomplete)
recoveryStateSubject.send(.incomplete)
}
MXLog.info("Recovery state changed to: \(state), setting local state to \(recoveryKeyStateSubject.value)")
MXLog.info("Recovery state changed to: \(state), setting local state to \(recoveryStateSubject.value)")
})
updateBackupStateFromRemote()
@ -120,7 +120,7 @@ class SecureBackupController: SecureBackupControllerProtocol {
func generateRecoveryKey() async -> Result<String, SecureBackupControllerError> {
do {
guard recoveryKeyState.value == .disabled else {
guard recoveryState.value == .disabled else {
MXLog.info("Resetting recovery key")
let key = try await encryption.resetRecoveryKey()
@ -135,9 +135,9 @@ class SecureBackupController: SecureBackupControllerProtocol {
switch state {
case .starting, .creatingBackup, .creatingRecoveryKey, .backingUp:
recoveryKeyStateSubject.send(.settingUp)
recoveryStateSubject.send(.settingUp)
case .done:
recoveryKeyStateSubject.send(.enabled)
recoveryStateSubject.send(.enabled)
case .roomKeyUploadError:
MXLog.error("Failed enabling recovery: room key upload error")
keyUploadErrored = true
@ -162,17 +162,7 @@ class SecureBackupController: SecureBackupControllerProtocol {
return .failure(.failedConfirmingRecoveryKey)
}
}
func isLastSession() async -> Result<Bool, SecureBackupControllerError> {
do {
MXLog.info("Checking if last session")
return try await .success(encryption.isLastDevice())
} catch {
MXLog.error("Failed checking if last session with error: \(error)")
return .failure(.failedFetchingSessionState)
}
}
func waitForKeyBackupUpload() async -> Result<Void, SecureBackupControllerError> {
do {
MXLog.info("Waiting for backup upload steady state")

6
ElementX/Sources/Services/SecureBackup/SecureBackupControllerProtocol.swift
View File

@ -17,7 +17,7 @@
import Combine
import Foundation
enum SecureBackupRecoveryKeyState {
enum SecureBackupRecoveryState {
case unknown
case disabled
case enabled
@ -50,7 +50,7 @@ enum SecureBackupControllerError: Error {
// sourcery: AutoMockable
protocol SecureBackupControllerProtocol {
var recoveryKeyState: CurrentValuePublisher<SecureBackupRecoveryKeyState, Never> { get }
var recoveryState: CurrentValuePublisher<SecureBackupRecoveryState, Never> { get }
var keyBackupState: CurrentValuePublisher<SecureBackupKeyBackupState, Never> { get }
@ -60,7 +60,5 @@ protocol SecureBackupControllerProtocol {
func generateRecoveryKey() async -> Result<String, SecureBackupControllerError>
func confirmRecoveryKey(_ key: String) async -> Result<Void, SecureBackupControllerError>
func isLastSession() async -> Result<Bool, SecureBackupControllerError>
func waitForKeyBackupUpload() async -> Result<Void, SecureBackupControllerError>
}

2
ElementX/Sources/Services/Session/MockUserSession.swift
View File

@ -25,5 +25,5 @@ struct MockUserSession: UserSessionProtocol {
let clientProxy: ClientProxyProtocol
let mediaProvider: MediaProviderProtocol
let voiceMessageMediaManager: VoiceMessageMediaManagerProtocol
var sessionVerificationState: CurrentValuePublisher<Bool?, Never> = .init(.init(true))
var sessionSecurityStatePublisher: AnyPublisher<SessionSecurityState, Never> = CurrentValueSubject<SessionSecurityState, Never>(.init(verificationState: .verified, recoveryState: .enabled)).eraseToAnyPublisher()
}

137
ElementX/Sources/Services/Session/UserSession.swift
View File

@ -18,10 +18,12 @@ import Combine
import Foundation
class UserSession: UserSessionProtocol {
private let sessionVerificationStateSubject: CurrentValueSubject<SessionVerificationState, Never> = .init(.unknown)
private var cancellables = Set<AnyCancellable>()
private var checkSessionVerificationStateCancellable: AnyCancellable?
private var checkSessionVerificationStateTask: Task<Void, Never>?
private var retrieveSessionVerificationControllerTask: Task<Void, Never>?
private var authErrorCancellable: AnyCancellable?
@ -40,7 +42,7 @@ class UserSession: UserSessionProtocol {
sessionVerificationController?.callbacks.sink { [weak self] callback in
switch callback {
case .finished:
self?.sessionVerificationStateSubject.send(true)
self?.sessionVerificationStateSubject.send(.verified)
default:
break
}
@ -49,74 +51,31 @@ class UserSession: UserSessionProtocol {
}
}
private var sessionVerificationStateSubject: CurrentValueSubject<Bool?, Never> = .init(nil)
var sessionVerificationState: CurrentValuePublisher<Bool?, Never> {
sessionVerificationStateSubject.asCurrentValuePublisher()
}
let sessionSecurityStatePublisher: AnyPublisher<SessionSecurityState, Never>
init(clientProxy: ClientProxyProtocol, mediaProvider: MediaProviderProtocol, voiceMessageMediaManager: VoiceMessageMediaManagerProtocol) {
self.clientProxy = clientProxy
self.mediaProvider = mediaProvider
self.voiceMessageMediaManager = voiceMessageMediaManager
setupSessionVerificationWatchdog()
setupAuthErrorWatchdog()
}
// MARK: - Private
private func setupSessionVerificationWatchdog() {
checkSessionVerificationStateCancellable = clientProxy.callbacks
sessionSecurityStatePublisher = Publishers.CombineLatest(sessionVerificationStateSubject, clientProxy.secureBackupController.recoveryState)
.map {
MXLog.info("Session security state changed, verificationState: \($0), recoveryState: \($1)")
return SessionSecurityState(verificationState: $0, recoveryState: $1)
}
.removeDuplicates()
.receive(on: DispatchQueue.main)
.eraseToAnyPublisher()
clientProxy.callbacks
.receive(on: DispatchQueue.main)
.sink { [weak self] callback in
if callback.isSyncUpdate {
self?.attemptSessionVerification()
self?.checkSessionVerificationState()
}
}
}
private func attemptSessionVerification() {
guard checkSessionVerificationStateTask == nil else {
MXLog.info("Session verification state check already in progress")
return
}
.store(in: &cancellables)
MXLog.info("Checking session verification state")
checkSessionVerificationStateTask = Task {
MXLog.info("Retrieving session verification controller")
switch await clientProxy.sessionVerificationControllerProxy() {
case .success(let sessionVerificationController):
MXLog.info("Retrieving session verification state")
guard case let .success(isVerified) = await sessionVerificationController.isVerified() else {
MXLog.error("Failed checking verification state. Will retry on the next sync update.")
return
}
tearDownSessionVerificationControllerWatchdog()
self.sessionVerificationController = sessionVerificationController
MXLog.info("Session verified: \(isVerified)")
sessionVerificationStateSubject.send(isVerified)
checkSessionVerificationStateTask = nil
case .failure(let error):
MXLog.info("Failed getting session verification controller with error: \(error). Will retry on the next sync update.")
}
}
}
private func tearDownSessionVerificationControllerWatchdog() {
checkSessionVerificationStateCancellable = nil
}
// MARK: Auth Error Watchdog
private func setupAuthErrorWatchdog() {
authErrorCancellable = clientProxy.callbacks
.receive(on: DispatchQueue.main)
.sink { [weak self] callback in
@ -124,14 +83,68 @@ class UserSession: UserSessionProtocol {
switch callback {
case .receivedAuthError(let isSoftLogout):
callbacks.send(.didReceiveAuthError(isSoftLogout: isSoftLogout))
tearDownAuthErrorWatchdog()
authErrorCancellable = nil
default:
break
}
}
}
private func tearDownAuthErrorWatchdog() {
authErrorCancellable = nil
// MARK: - Private
private func checkSessionVerificationState() {
guard retrieveSessionVerificationControllerTask == nil else {
MXLog.info("Session verification state check already in progress")
return
}
guard sessionVerificationController == nil else {
Task {
await updateSessionVerificationState()
}
return
}
MXLog.info("Retrieving session verification controller")
retrieveSessionVerificationControllerTask = Task {
switch await clientProxy.sessionVerificationControllerProxy() {
case .success(let sessionVerificationController):
self.sessionVerificationController = sessionVerificationController
await updateSessionVerificationState()
retrieveSessionVerificationControllerTask = nil
case .failure(let error):
MXLog.info("Failed getting session verification controller with error: \(error). Will retry on the next sync update.")
}
}
}
private func updateSessionVerificationState() async {
guard let sessionVerificationController else {
fatalError("This point should never be reached")
}
MXLog.info("Checking session verification state")
guard case let .success(isVerified) = await sessionVerificationController.isVerified() else {
MXLog.error("Failed checking verification state. Will retry on the next sync update.")
return
}
if isVerified {
sessionVerificationStateSubject.send(.verified)
} else {
guard case let .success(isLastDevice) = await clientProxy.isOnlyDeviceLeft() else {
MXLog.error("Failed checking isLastDevice. Will retry on the next sync update.")
return
}
if isLastDevice {
sessionVerificationStateSubject.send(.unverifiedLastSession)
} else {
sessionVerificationStateSubject.send(.unverified)
}
}
}
}

14
ElementX/Sources/Services/Session/UserSessionProtocol.swift
View File

@ -21,6 +21,18 @@ enum UserSessionCallback {
case didReceiveAuthError(isSoftLogout: Bool)
}
enum SessionVerificationState {
case unknown
case verified
case unverified
case unverifiedLastSession
}
struct SessionSecurityState: Equatable {
let verificationState: SessionVerificationState
let recoveryState: SecureBackupRecoveryState
}
protocol UserSessionProtocol {
var homeserver: String { get }
var userID: String { get }
@ -30,7 +42,7 @@ protocol UserSessionProtocol {
var mediaProvider: MediaProviderProtocol { get }
var voiceMessageMediaManager: VoiceMessageMediaManagerProtocol { get }
var sessionVerificationState: CurrentValuePublisher<Bool?, Never> { get }
var sessionSecurityStatePublisher: AnyPublisher<SessionSecurityState, Never> { get }
var sessionVerificationController: SessionVerificationControllerProxyProtocol? { get }
var callbacks: PassthroughSubject<UserSessionCallback, Never> { get }

4
UnitTests/Sources/UserSession/UserSessionTests.swift
View File

@ -32,8 +32,8 @@ final class UserSessionTests: XCTestCase {
func test_whenUserSessionReceivesSyncUpdateAndSessionControllerRetrievedAndSessionNotVerified_sessionVerificationNeededEventReceived() throws {
let expectation = expectation(description: "SessionVerificationNeeded expectation")
userSession.sessionVerificationState.sink { isVerified in
if let isVerified, isVerified == false {
userSession.sessionSecurityStatePublisher.sink { securityState in
if securityState.verificationState == .unverified {
expectation.fulfill()
}
}