jarno
/
element-android
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

renaming update homeserver to select homeserver 

- should better reflect this steps mvoes the onboarding process forwards
This commit is contained in:
Adam Brown 2022-04-01 16:13:33 +01:00
parent f34df3997d
commit 1e520121ce
7 changed files with 66 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vector/src/main/java/im/vector/app/features/onboarding/OnboardingAction.kt
View File

@ -29,7 +29,7 @@ sealed interface OnboardingAction : VectorViewModelAction {
data class OnIAlreadyHaveAnAccount(val resetLoginConfig: Boolean, val onboardingFlow: OnboardingFlow) : OnboardingAction
data class UpdateServerType(val serverType: ServerType) : OnboardingAction
data class UpdateHomeServer(val homeServerUrl: String) : OnboardingAction
data class SelectHomeServer(val homeServerUrl: String) : OnboardingAction
data class UpdateUseCase(val useCase: FtueUseCase) : OnboardingAction
object ResetUseCase : OnboardingAction
data class UpdateSignMode(val signMode: SignMode) : OnboardingAction

60
vector/src/main/java/im/vector/app/features/onboarding/OnboardingViewModel.kt
View File

@ -107,6 +107,7 @@ class OnboardingViewModel @AssistedInject constructor(
private var currentHomeServerConnectionConfig: HomeServerConnectionConfig? = null
private val matrixOrgUrl = stringProvider.getString(R.string.matrix_org_server_url).ensureTrailingSlash()
private val defaultHomeserverUrl = matrixOrgUrl
private val registrationWizard: RegistrationWizard
get() = authenticationService.getRegistrationWizard()
@ -139,7 +140,7 @@ class OnboardingViewModel @AssistedInject constructor(
is OnboardingAction.UpdateServerType -> handleUpdateServerType(action)
is OnboardingAction.UpdateSignMode -> handleUpdateSignMode(action)
is OnboardingAction.InitWith -> handleInitWith(action)
is OnboardingAction.UpdateHomeServer -> handleUpdateHomeserver(action).also { lastAction = action }
is OnboardingAction.SelectHomeServer -> handleSelectHomeserver(action).also { lastAction = action }
is OnboardingAction.LoginOrRegister -> handleLoginOrRegister(action).also { lastAction = action }
is OnboardingAction.Register -> handleRegisterWith(action).also { lastAction = action }
is OnboardingAction.LoginWithToken -> handleLoginWithToken(action)
@ -167,19 +168,19 @@ class OnboardingViewModel @AssistedInject constructor(
}
setState { copy(onboardingFlow = onboardingFlow) }
val configUrl = loginConfig?.homeServerUrl?.takeIf { it.isNotEmpty() }
if (configUrl != null) {
// Use config from uri
val homeServerConnectionConfig = homeServerConnectionConfigFactory.create(configUrl)
if (homeServerConnectionConfig == null) {
// Url is invalid, in this case, just use the regular flow
Timber.w("Url from config url was invalid: $configUrl")
continueToPageAfterSplash(onboardingFlow)
} else {
startAuthenticationFlow(homeServerConnectionConfig, ServerType.Other)
return when (val config = loginConfig.toHomeserverConfig()) {
null -> continueToPageAfterSplash(onboardingFlow)
else -> startAuthenticationFlow(config, ServerType.Other)
}
}
private fun LoginConfig?.toHomeserverConfig(): HomeServerConnectionConfig? {
return this?.homeServerUrl?.takeIf { it.isNotEmpty() }?.let { url ->
homeServerConnectionConfigFactory.create(url).also {
if (it == null) {
Timber.w("Url from config url was invalid: $url")
}
}
} else {
continueToPageAfterSplash(onboardingFlow)
}
}
@ -200,7 +201,7 @@ class OnboardingViewModel @AssistedInject constructor(
// It happens when we get the login flow, or during direct authentication.
// So alter the homeserver config and retrieve again the login flow
when (val finalLastAction = lastAction) {
is OnboardingAction.UpdateHomeServer -> {
is OnboardingAction.SelectHomeServer -> {
currentHomeServerConnectionConfig
?.let { it.copy(allowedFingerprints = it.allowedFingerprints + action.fingerprint) }
?.let { startAuthenticationFlow(it) }
@ -348,10 +349,7 @@ class OnboardingViewModel @AssistedInject constructor(
private fun handleUpdateUseCase(action: OnboardingAction.UpdateUseCase) {
setState { copy(useCase = action.useCase) }
when (vectorFeatures.isOnboardingCombinedRegisterEnabled()) {
true -> {
handle(OnboardingAction.UpdateHomeServer(matrixOrgUrl))
OnboardingViewEvents.OpenCombinedRegister
}
true -> handle(OnboardingAction.SelectHomeServer(defaultHomeserverUrl))
false -> _viewEvents.post(OnboardingViewEvents.OpenServerSelection)
}
}
@ -371,7 +369,7 @@ class OnboardingViewModel @AssistedInject constructor(
ServerType.Unknown -> Unit /* Should not happen */
ServerType.MatrixOrg ->
// Request login flow here
handle(OnboardingAction.UpdateHomeServer(matrixOrgUrl))
handle(OnboardingAction.SelectHomeServer(matrixOrgUrl))
ServerType.EMS,
ServerType.Other -> _viewEvents.post(OnboardingViewEvents.OnServerSelectionDone(action.serverType))
}
@ -578,7 +576,7 @@ class OnboardingViewModel @AssistedInject constructor(
}
}
private fun handleUpdateHomeserver(action: OnboardingAction.UpdateHomeServer) {
private fun handleSelectHomeserver(action: OnboardingAction.SelectHomeServer) {
val homeServerConnectionConfig = homeServerConnectionConfigFactory.create(action.homeServerUrl)
if (homeServerConnectionConfig == null) {
// This is invalid
@ -603,14 +601,8 @@ class OnboardingViewModel @AssistedInject constructor(
setState {
copy(
// If user has entered https://matrix.org, ensure that server type is ServerType.MatrixOrg
// It is also useful to set the value again in the case of a certificate error on matrix.org
serverType = if (homeServerConnectionConfig.homeServerUri.toString() == matrixOrgUrl) {
ServerType.MatrixOrg
} else {
serverTypeOverride ?: serverType
},
selectedHomeserver = it.serverSelectionState,
serverType = alignServerTypeAfterSubmission(homeServerConnectionConfig, serverTypeOverride),
selectedHomeserver = it.selectedHomeserverState,
isLoading = false,
)
}
@ -624,6 +616,18 @@ class OnboardingViewModel @AssistedInject constructor(
}
}
/**
* If user has entered https://matrix.org, ensure that server type is ServerType.MatrixOrg
* It is also useful to set the value again in the case of a certificate error on matrix.org
**/
private fun OnboardingViewState.alignServerTypeAfterSubmission(config: HomeServerConnectionConfig, serverTypeOverride: ServerType?): ServerType {
return if (config.homeServerUri.toString() == matrixOrgUrl) {
ServerType.MatrixOrg
} else {
serverTypeOverride ?: serverType
}
}
private fun onAuthenticationStartedSuccess() {
withState {
if (it.selectedHomeserver.preferredLoginMode.supportsSignModeScreen()) {

2
vector/src/main/java/im/vector/app/features/onboarding/OnboardingViewState.kt
View File

@ -68,7 +68,7 @@ data class SelectedHomeserverState(
val declaredUrl: String? = null,
val preferredLoginMode: LoginMode = LoginMode.Unknown,
// Supported types for the login. We cannot use a sealed class for LoginType because it is not serializable
val loginModeSupportedTypes: List<String> = emptyList(),
val supportedLoginTypes: List<String> = emptyList(),
) : Parcelable
@Parcelize

49
vector/src/main/java/im/vector/app/features/onboarding/StartAuthenticationFlowUseCase.kt
View File

@ -22,6 +22,7 @@ import im.vector.app.core.utils.ensureTrailingSlash
import im.vector.app.features.login.LoginMode
import org.matrix.android.sdk.api.auth.AuthenticationService
import org.matrix.android.sdk.api.auth.data.HomeServerConnectionConfig
import org.matrix.android.sdk.api.auth.data.LoginFlowResult
import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
import javax.inject.Inject
@ -30,38 +31,42 @@ class StartAuthenticationFlowUseCase @Inject constructor(
private val stringProvider: StringProvider
) {
data class Bar(
val isHomeserverOutdated: Boolean,
val serverSelectionState: SelectedHomeserverState,
val loginMode: LoginMode,
val supportedLoginTypes: List<String>,
)
suspend fun execute(config: HomeServerConnectionConfig): Bar {
suspend fun execute(config: HomeServerConnectionConfig): StartAuthenticationResult {
authenticationService.cancelPendingLoginOrRegistration()
val authFlow = authenticationService.getLoginFlow(config)
val preferredLoginMode = authFlow.findPreferredLoginMode()
val selection = createSelectedHomeserverState(authFlow, config, preferredLoginMode)
val isOutdated = (preferredLoginMode == LoginMode.Password && !authFlow.isLoginAndRegistrationSupported) || authFlow.isOutdatedHomeserver
return StartAuthenticationResult(isOutdated, selection, preferredLoginMode, authFlow.supportedLoginTypes.toList())
}
val loginMode = when {
// SSO login is taken first
authFlow.supportedLoginTypes.contains(LoginFlowTypes.SSO) &&
authFlow.supportedLoginTypes.contains(LoginFlowTypes.PASSWORD) -> LoginMode.SsoAndPassword(authFlow.ssoIdentityProviders)
authFlow.supportedLoginTypes.contains(LoginFlowTypes.SSO) -> LoginMode.Sso(authFlow.ssoIdentityProviders)
authFlow.supportedLoginTypes.contains(LoginFlowTypes.PASSWORD) -> LoginMode.Password
else -> LoginMode.Unsupported
}
private fun createSelectedHomeserverState(authFlow: LoginFlowResult, config: HomeServerConnectionConfig, preferredLoginMode: LoginMode): SelectedHomeserverState {
val matrixOrgUrl = stringProvider.getString(R.string.matrix_org_server_url).ensureTrailingSlash()
val selection = SelectedHomeserverState(
return SelectedHomeserverState(
description = when (authFlow.homeServerUrl) {
matrixOrgUrl -> stringProvider.getString(R.string.ftue_auth_create_account_matrix_dot_org_server_description)
else -> null
},
sourceUrl = config.homeServerUri.toString(),
declaredUrl = authFlow.homeServerUrl,
preferredLoginMode = loginMode,
loginModeSupportedTypes = authFlow.supportedLoginTypes
preferredLoginMode = preferredLoginMode,
supportedLoginTypes = authFlow.supportedLoginTypes
)
val isOutdated = (loginMode == LoginMode.Password && !authFlow.isLoginAndRegistrationSupported) || authFlow.isOutdatedHomeserver
return Bar(isOutdated, selection, loginMode, authFlow.supportedLoginTypes.toList())
}
private fun LoginFlowResult.findPreferredLoginMode() = when {
// SSO login is taken first
supportedLoginTypes.contains(LoginFlowTypes.SSO) &&
supportedLoginTypes.contains(LoginFlowTypes.PASSWORD) -> LoginMode.SsoAndPassword(ssoIdentityProviders)
supportedLoginTypes.contains(LoginFlowTypes.SSO) -> LoginMode.Sso(ssoIdentityProviders)
supportedLoginTypes.contains(LoginFlowTypes.PASSWORD) -> LoginMode.Password
else -> LoginMode.Unsupported
}
data class StartAuthenticationResult(
val isHomeserverOutdated: Boolean,
val selectedHomeserverState: SelectedHomeserverState,
val loginMode: LoginMode,
val supportedLoginTypes: List<String>,
)
}

2
vector/src/main/java/im/vector/app/features/onboarding/ftueauth/FtueAuthCombinedServerSelectionFragment.kt
View File

@ -45,7 +45,7 @@ class FtueAuthCombinedServerSelectionFragment @Inject constructor() : AbstractFt
}
views.chooseServerSubmit.debouncedClicks {
viewModel.handle(OnboardingAction.UpdateHomeServer(views.chooseServerInput.content()))
viewModel.handle(OnboardingAction.SelectHomeServer(views.chooseServerInput.content()))
}
}

2
vector/src/main/java/im/vector/app/features/onboarding/ftueauth/FtueAuthServerUrlFormFragment.kt
View File

@ -139,7 +139,7 @@ class FtueAuthServerUrlFormFragment @Inject constructor() : AbstractFtueAuthFrag
}
else -> {
views.loginServerUrlFormHomeServerUrl.setText(serverUrl, false /* to avoid completion dialog flicker*/)
viewModel.handle(OnboardingAction.UpdateHomeServer(serverUrl))
viewModel.handle(OnboardingAction.SelectHomeServer(serverUrl))
}
}
}

6
vector/src/main/java/im/vector/app/features/onboarding/ftueauth/FtueAuthVariant.kt
View File

@ -306,7 +306,7 @@ class FtueAuthVariant(
private fun handleSignInSelected(state: OnboardingViewState) {
if (isForceLoginFallbackEnabled) {
onLoginModeNotSupported(state.selectedHomeserver.loginModeSupportedTypes)
onLoginModeNotSupported(state.selectedHomeserver.supportedLoginTypes)
} else {
disambiguateLoginMode(state)
}
@ -317,7 +317,7 @@ class FtueAuthVariant(
is LoginMode.Sso -> error("Developer error")
is LoginMode.SsoAndPassword,
LoginMode.Password -> openAuthLoginFragmentWithTag(FRAGMENT_LOGIN_TAG)
LoginMode.Unsupported -> onLoginModeNotSupported(state.selectedHomeserver.loginModeSupportedTypes)
LoginMode.Unsupported -> onLoginModeNotSupported(state.selectedHomeserver.supportedLoginTypes)
}
private fun openAuthLoginFragmentWithTag(tag: String) {
@ -338,7 +338,7 @@ class FtueAuthVariant(
private fun handleSignInWithMatrixId(state: OnboardingViewState) {
if (isForceLoginFallbackEnabled) {
onLoginModeNotSupported(state.selectedHomeserver.loginModeSupportedTypes)
onLoginModeNotSupported(state.selectedHomeserver.supportedLoginTypes)
} else {
openAuthLoginFragmentWithTag(FRAGMENT_LOGIN_TAG)
}