mirror of
https://github.com/nextcloud/talk-android
synced 2025-06-19 03:29:28 +01:00
416 lines
16 KiB
Kotlin
416 lines
16 KiB
Kotlin
/*
|
|
* Nextcloud Talk - Android Client
|
|
*
|
|
* SPDX-FileCopyrightText: 2023 Marcel Hibbe <dev@mhibbe.de>
|
|
* SPDX-FileCopyrightText: 2021 Andy Scherzinger <info@andy-scherzinger.de>
|
|
* SPDX-FileCopyrightText: 2017 Mario Danic <mario@lovelyhq.com>
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*/
|
|
package com.nextcloud.talk.account
|
|
|
|
import android.accounts.Account
|
|
import android.annotation.SuppressLint
|
|
import android.content.Intent
|
|
import android.content.pm.ActivityInfo
|
|
import android.os.Bundle
|
|
import android.security.KeyChain
|
|
import android.text.TextUtils
|
|
import android.util.Log
|
|
import android.view.KeyEvent
|
|
import android.view.View
|
|
import android.view.inputmethod.EditorInfo
|
|
import android.widget.TextView
|
|
import androidx.activity.OnBackPressedCallback
|
|
import androidx.core.net.toUri
|
|
import autodagger.AutoInjector
|
|
import com.nextcloud.talk.R
|
|
import com.nextcloud.talk.activities.BaseActivity
|
|
import com.nextcloud.talk.api.NcApi
|
|
import com.nextcloud.talk.application.NextcloudTalkApplication
|
|
import com.nextcloud.talk.application.NextcloudTalkApplication.Companion.sharedApplication
|
|
import com.nextcloud.talk.databinding.ActivityServerSelectionBinding
|
|
import com.nextcloud.talk.models.json.capabilities.CapabilitiesOverall
|
|
import com.nextcloud.talk.models.json.generic.Status
|
|
import com.nextcloud.talk.users.UserManager
|
|
import com.nextcloud.talk.utils.AccountUtils
|
|
import com.nextcloud.talk.utils.ApiUtils
|
|
import com.nextcloud.talk.utils.CapabilitiesUtil
|
|
import com.nextcloud.talk.utils.UriUtils
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.ADD_ADDITIONAL_ACCOUNT
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_IS_ACCOUNT_IMPORT
|
|
import com.nextcloud.talk.utils.singletons.ApplicationWideMessageHolder
|
|
import io.reactivex.Observer
|
|
import io.reactivex.android.schedulers.AndroidSchedulers
|
|
import io.reactivex.disposables.Disposable
|
|
import io.reactivex.schedulers.Schedulers
|
|
import java.security.cert.CertificateException
|
|
import javax.inject.Inject
|
|
|
|
@AutoInjector(NextcloudTalkApplication::class)
|
|
class ServerSelectionActivity : BaseActivity() {
|
|
|
|
private lateinit var binding: ActivityServerSelectionBinding
|
|
|
|
@Inject
|
|
lateinit var ncApi: NcApi
|
|
|
|
@Inject
|
|
lateinit var userManager: UserManager
|
|
|
|
private var statusQueryDisposable: Disposable? = null
|
|
|
|
private val onBackPressedCallback = object : OnBackPressedCallback(true) {
|
|
override fun handleOnBackPressed() {
|
|
if (intent.hasExtra(ADD_ADDITIONAL_ACCOUNT) && intent.getBooleanExtra(ADD_ADDITIONAL_ACCOUNT, false)) {
|
|
finish()
|
|
} else {
|
|
finishAffinity()
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressLint("SourceLockedOrientationActivity")
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
sharedApplication!!.componentApplication.inject(this)
|
|
binding = ActivityServerSelectionBinding.inflate(layoutInflater)
|
|
requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
|
|
setContentView(binding.root)
|
|
actionBar?.hide()
|
|
initSystemBars()
|
|
|
|
onBackPressedDispatcher.addCallback(this, onBackPressedCallback)
|
|
}
|
|
|
|
override fun onResume() {
|
|
super.onResume()
|
|
|
|
binding.hostUrlInputHelperText.text = String.format(
|
|
resources!!.getString(R.string.nc_server_helper_text),
|
|
resources!!.getString(R.string.nc_server_product_name)
|
|
)
|
|
binding.serverEntryTextInputLayout.setEndIconOnClickListener { checkServerAndProceed() }
|
|
|
|
if (resources!!.getBoolean(R.bool.hide_auth_cert)) {
|
|
binding.certTextView.visibility = View.GONE
|
|
}
|
|
|
|
val loggedInUsers = userManager.users.blockingGet()
|
|
val availableAccounts = AccountUtils.findAvailableAccountsOnDevice(loggedInUsers)
|
|
|
|
if (isImportAccountNameSet() && availableAccounts.isNotEmpty()) {
|
|
showImportAccountsInfo(availableAccounts)
|
|
} else if (isAbleToShowProviderLink() && loggedInUsers.isEmpty()) {
|
|
showVisitProvidersInfo()
|
|
} else {
|
|
binding.importOrChooseProviderText.visibility = View.INVISIBLE
|
|
}
|
|
|
|
binding.serverEntryTextInputEditText.requestFocus()
|
|
if (!TextUtils.isEmpty(resources!!.getString(R.string.weblogin_url))) {
|
|
binding.serverEntryTextInputEditText.setText(resources!!.getString(R.string.weblogin_url))
|
|
checkServerAndProceed()
|
|
}
|
|
binding.serverEntryTextInputEditText.setOnEditorActionListener { _: TextView?, i: Int, _: KeyEvent? ->
|
|
if (i == EditorInfo.IME_ACTION_DONE) {
|
|
checkServerAndProceed()
|
|
}
|
|
false
|
|
}
|
|
binding.certTextView.setOnClickListener { onCertClick() }
|
|
|
|
if (ApplicationWideMessageHolder.getInstance().messageType != null) {
|
|
if (ApplicationWideMessageHolder.getInstance().messageType
|
|
== ApplicationWideMessageHolder.MessageType.SERVER_WITHOUT_TALK
|
|
) {
|
|
setErrorText(resources!!.getString(R.string.nc_settings_no_talk_installed))
|
|
} else if (ApplicationWideMessageHolder.getInstance().messageType
|
|
== ApplicationWideMessageHolder.MessageType.FAILED_TO_IMPORT_ACCOUNT
|
|
) {
|
|
setErrorText(resources!!.getString(R.string.nc_server_failed_to_import_account))
|
|
}
|
|
ApplicationWideMessageHolder.getInstance().messageType = null
|
|
}
|
|
setCertTextView()
|
|
}
|
|
|
|
fun onCertClick() {
|
|
KeyChain.choosePrivateKeyAlias(
|
|
this,
|
|
{ alias: String? ->
|
|
if (alias != null) {
|
|
appPreferences.temporaryClientCertAlias = alias
|
|
} else {
|
|
appPreferences.removeTemporaryClientCertAlias()
|
|
}
|
|
setCertTextView()
|
|
},
|
|
arrayOf("RSA", "EC"),
|
|
null,
|
|
null,
|
|
-1,
|
|
null
|
|
)
|
|
}
|
|
|
|
private fun isAbleToShowProviderLink(): Boolean {
|
|
return !resources!!.getBoolean(R.bool.hide_provider) &&
|
|
!TextUtils.isEmpty(resources!!.getString(R.string.nc_providers_url))
|
|
}
|
|
|
|
private fun showImportAccountsInfo(availableAccounts: List<Account>) {
|
|
if (!TextUtils.isEmpty(
|
|
AccountUtils.getAppNameBasedOnPackage(resources!!.getString(R.string.nc_import_accounts_from))
|
|
)
|
|
) {
|
|
if (availableAccounts.size > 1) {
|
|
binding.importOrChooseProviderText.text = String.format(
|
|
resources!!.getString(R.string.nc_server_import_accounts),
|
|
AccountUtils.getAppNameBasedOnPackage(resources!!.getString(R.string.nc_import_accounts_from))
|
|
)
|
|
} else {
|
|
binding.importOrChooseProviderText.text = String.format(
|
|
resources!!.getString(R.string.nc_server_import_account),
|
|
AccountUtils.getAppNameBasedOnPackage(resources!!.getString(R.string.nc_import_accounts_from))
|
|
)
|
|
}
|
|
} else {
|
|
if (availableAccounts.size > 1) {
|
|
binding.importOrChooseProviderText.text =
|
|
resources!!.getString(R.string.nc_server_import_accounts_plain)
|
|
} else {
|
|
binding.importOrChooseProviderText.text =
|
|
resources!!.getString(R.string.nc_server_import_account_plain)
|
|
}
|
|
}
|
|
binding.importOrChooseProviderText.setOnClickListener {
|
|
val bundle = Bundle()
|
|
bundle.putBoolean(KEY_IS_ACCOUNT_IMPORT, true)
|
|
val intent = Intent(context, SwitchAccountActivity::class.java)
|
|
intent.putExtras(bundle)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
|
|
private fun showVisitProvidersInfo() {
|
|
binding.importOrChooseProviderText.setText(R.string.nc_get_from_provider)
|
|
binding.importOrChooseProviderText.setOnClickListener {
|
|
val browserIntent = Intent(
|
|
Intent.ACTION_VIEW,
|
|
resources!!.getString(R.string.nc_providers_url).toUri()
|
|
)
|
|
startActivity(browserIntent)
|
|
}
|
|
}
|
|
|
|
private fun isImportAccountNameSet(): Boolean {
|
|
return !TextUtils.isEmpty(resources!!.getString(R.string.nc_import_account_type))
|
|
}
|
|
|
|
@SuppressLint("LongLogTag")
|
|
@Suppress("Detekt.TooGenericExceptionCaught")
|
|
private fun checkServerAndProceed() {
|
|
dispose()
|
|
var url: String = binding.serverEntryTextInputEditText.text.toString().trim()
|
|
showserverEntryProgressBar()
|
|
if (binding.importOrChooseProviderText.visibility != View.INVISIBLE) {
|
|
binding.importOrChooseProviderText.visibility = View.INVISIBLE
|
|
binding.certTextView.visibility = View.INVISIBLE
|
|
}
|
|
if (url.endsWith("/")) {
|
|
url = url.substring(0, url.length - 1)
|
|
}
|
|
|
|
if (UriUtils.hasHttpProtocolPrefixed(url)) {
|
|
checkServer(url, false)
|
|
} else {
|
|
checkServer("https://$url", true)
|
|
}
|
|
}
|
|
|
|
private fun checkServer(url: String, checkForcedHttps: Boolean) {
|
|
val queryStatusUrl = url + ApiUtils.getUrlPostfixForStatus()
|
|
|
|
statusQueryDisposable = ncApi.getServerStatus(queryStatusUrl)
|
|
.subscribeOn(Schedulers.io())
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
.subscribe({ status: Status ->
|
|
val versionString: String = status.version!!.substring(0, status.version!!.indexOf("."))
|
|
val version: Int = versionString.toInt()
|
|
|
|
if (isServerStatusQueryable(status) && version >= MIN_SERVER_MAJOR_VERSION) {
|
|
findServerTalkApp(url)
|
|
} else {
|
|
showErrorTextForStatus(status)
|
|
}
|
|
}, { throwable: Throwable ->
|
|
if (checkForcedHttps) {
|
|
checkServer(queryStatusUrl.replace("https://", "http://"), false)
|
|
} else {
|
|
if (throwable.localizedMessage != null) {
|
|
setErrorText(throwable.localizedMessage)
|
|
} else if (throwable.cause is CertificateException) {
|
|
setErrorText(resources!!.getString(R.string.nc_certificate_error))
|
|
} else {
|
|
hideserverEntryProgressBar()
|
|
}
|
|
|
|
if (binding.importOrChooseProviderText.visibility != View.INVISIBLE) {
|
|
binding.importOrChooseProviderText.visibility = View.VISIBLE
|
|
binding.certTextView.visibility = View.VISIBLE
|
|
}
|
|
dispose()
|
|
}
|
|
}) {
|
|
hideserverEntryProgressBar()
|
|
if (binding.importOrChooseProviderText.visibility != View.INVISIBLE) {
|
|
binding.importOrChooseProviderText.visibility = View.VISIBLE
|
|
binding.certTextView.visibility = View.VISIBLE
|
|
}
|
|
dispose()
|
|
}
|
|
}
|
|
|
|
private fun showErrorTextForStatus(status: Status) {
|
|
if (!status.installed) {
|
|
setErrorText(
|
|
String.format(
|
|
resources!!.getString(R.string.nc_server_not_installed),
|
|
resources!!.getString(R.string.nc_server_product_name)
|
|
)
|
|
)
|
|
} else if (status.needsUpgrade) {
|
|
setErrorText(
|
|
String.format(
|
|
resources!!.getString(R.string.nc_server_db_upgrade_needed),
|
|
resources!!.getString(R.string.nc_server_product_name)
|
|
)
|
|
)
|
|
} else if (status.maintenance) {
|
|
setErrorText(
|
|
String.format(
|
|
resources!!.getString(R.string.nc_server_maintenance),
|
|
resources!!.getString(R.string.nc_server_product_name)
|
|
)
|
|
)
|
|
} else if (!status.version!!.startsWith("13.")) {
|
|
setErrorText(
|
|
String.format(
|
|
resources!!.getString(R.string.nc_server_version),
|
|
resources!!.getString(R.string.nc_app_product_name),
|
|
resources!!.getString(R.string.nc_server_product_name)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
private fun findServerTalkApp(queryUrl: String) {
|
|
ncApi.getCapabilities(ApiUtils.getUrlForCapabilities(queryUrl))
|
|
.subscribeOn(Schedulers.io())
|
|
.subscribe(object : Observer<CapabilitiesOverall> {
|
|
override fun onSubscribe(d: Disposable) {
|
|
// unused atm
|
|
}
|
|
|
|
override fun onNext(capabilitiesOverall: CapabilitiesOverall) {
|
|
val capabilities = capabilitiesOverall.ocs?.data?.capabilities
|
|
|
|
val hasTalk =
|
|
capabilities?.spreedCapability != null &&
|
|
capabilities.spreedCapability?.features != null &&
|
|
capabilities.spreedCapability?.features?.isNotEmpty() == true
|
|
|
|
if (hasTalk) {
|
|
runOnUiThread {
|
|
if (CapabilitiesUtil.isServerEOL(capabilitiesOverall.ocs?.data?.serverVersion?.major)) {
|
|
if (resources != null) {
|
|
runOnUiThread {
|
|
setErrorText(resources!!.getString(R.string.nc_settings_server_eol))
|
|
}
|
|
}
|
|
} else {
|
|
val bundle = Bundle()
|
|
bundle.putString(BundleKeys.KEY_BASE_URL, queryUrl.replace("/status.php", ""))
|
|
|
|
val intent = Intent(context, WebViewLoginActivity::class.java)
|
|
intent.putExtras(bundle)
|
|
startActivity(intent)
|
|
}
|
|
}
|
|
} else {
|
|
if (resources != null) {
|
|
runOnUiThread {
|
|
setErrorText(resources!!.getString(R.string.nc_server_unsupported))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onError(e: Throwable) {
|
|
Log.e(TAG, "Error while checking capabilities", e)
|
|
if (resources != null) {
|
|
runOnUiThread {
|
|
setErrorText(resources!!.getString(R.string.nc_common_error_sorry))
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onComplete() {
|
|
// unused atm
|
|
}
|
|
})
|
|
}
|
|
|
|
private fun isServerStatusQueryable(status: Status): Boolean {
|
|
return status.installed && !status.maintenance && !status.needsUpgrade
|
|
}
|
|
|
|
private fun setErrorText(text: String?) {
|
|
binding.errorWrapper.visibility = View.VISIBLE
|
|
binding.errorText.text = text
|
|
hideserverEntryProgressBar()
|
|
}
|
|
|
|
private fun showserverEntryProgressBar() {
|
|
binding.errorWrapper.visibility = View.INVISIBLE
|
|
binding.serverEntryProgressBar.visibility = View.VISIBLE
|
|
}
|
|
|
|
private fun hideserverEntryProgressBar() {
|
|
binding.serverEntryProgressBar.visibility = View.INVISIBLE
|
|
}
|
|
|
|
@SuppressLint("LongLogTag")
|
|
private fun setCertTextView() {
|
|
runOnUiThread {
|
|
if (!TextUtils.isEmpty(appPreferences.temporaryClientCertAlias)) {
|
|
binding.certTextView.setText(R.string.nc_change_cert_auth)
|
|
} else {
|
|
binding.certTextView.setText(R.string.nc_configure_cert_auth)
|
|
}
|
|
hideserverEntryProgressBar()
|
|
}
|
|
}
|
|
|
|
public override fun onDestroy() {
|
|
super.onDestroy()
|
|
dispose()
|
|
}
|
|
|
|
private fun dispose() {
|
|
if (statusQueryDisposable != null && !statusQueryDisposable!!.isDisposed) {
|
|
statusQueryDisposable!!.dispose()
|
|
}
|
|
statusQueryDisposable = null
|
|
}
|
|
|
|
override val appBarLayoutType: AppBarLayoutType
|
|
get() = AppBarLayoutType.EMPTY
|
|
|
|
companion object {
|
|
private val TAG = ServerSelectionActivity::class.java.simpleName
|
|
const val MIN_SERVER_MAJOR_VERSION = 13
|
|
}
|
|
}
|