mirror of
https://github.com/nextcloud/talk-android
synced 2025-07-20 03:05:01 +01:00
208 lines
8.6 KiB
Kotlin
208 lines
8.6 KiB
Kotlin
/*
|
|
* Nextcloud Talk application
|
|
*
|
|
* @author Mario Danic
|
|
* @author Andy Scherzinger
|
|
* Copyright (C) 2022 Andy Scherzinger (info@andy-scherzinger.de)
|
|
* Copyright (C) 2017 Mario Danic <mario@lovelyhq.com>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Parts related to account import were either copied from or inspired by the great work done by David Luhmer at:
|
|
* https://github.com/nextcloud/ownCloud-Account-Importer
|
|
*/
|
|
package com.nextcloud.talk.controllers
|
|
|
|
import android.accounts.Account
|
|
import android.os.Bundle
|
|
import android.view.MenuItem
|
|
import android.view.View
|
|
import androidx.preference.PreferenceManager
|
|
import androidx.recyclerview.widget.LinearLayoutManager
|
|
import autodagger.AutoInjector
|
|
import com.bluelinelabs.conductor.RouterTransaction
|
|
import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler
|
|
import com.nextcloud.talk.R
|
|
import com.nextcloud.talk.adapters.items.AdvancedUserItem
|
|
import com.nextcloud.talk.application.NextcloudTalkApplication
|
|
import com.nextcloud.talk.application.NextcloudTalkApplication.Companion.sharedApplication
|
|
import com.nextcloud.talk.controllers.base.NewBaseController
|
|
import com.nextcloud.talk.controllers.util.viewBinding
|
|
import com.nextcloud.talk.databinding.ControllerGenericRvBinding
|
|
import com.nextcloud.talk.models.ImportAccount
|
|
import com.nextcloud.talk.models.database.UserEntity
|
|
import com.nextcloud.talk.models.json.participants.Participant
|
|
import com.nextcloud.talk.utils.AccountUtils.findAccounts
|
|
import com.nextcloud.talk.utils.AccountUtils.getInformationFromAccount
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_BASE_URL
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_IS_ACCOUNT_IMPORT
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_TOKEN
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_USERNAME
|
|
import com.nextcloud.talk.utils.database.user.UserUtils
|
|
import eu.davidea.flexibleadapter.FlexibleAdapter
|
|
import eu.davidea.flexibleadapter.common.SmoothScrollLinearLayoutManager
|
|
import eu.davidea.flexibleadapter.items.AbstractFlexibleItem
|
|
import io.reactivex.Observer
|
|
import io.reactivex.disposables.Disposable
|
|
import org.osmdroid.config.Configuration
|
|
import java.net.CookieManager
|
|
import java.util.ArrayList
|
|
import javax.inject.Inject
|
|
|
|
@AutoInjector(NextcloudTalkApplication::class)
|
|
class SwitchAccountController(args: Bundle? = null) :
|
|
NewBaseController(
|
|
R.layout.controller_generic_rv,
|
|
args
|
|
) {
|
|
private val binding: ControllerGenericRvBinding by viewBinding(ControllerGenericRvBinding::bind)
|
|
|
|
@Inject
|
|
lateinit var userUtils: UserUtils
|
|
|
|
@Inject
|
|
lateinit var cookieManager: CookieManager
|
|
|
|
private var adapter: FlexibleAdapter<AbstractFlexibleItem<*>>? = null
|
|
private val userItems: MutableList<AbstractFlexibleItem<*>> = ArrayList()
|
|
private var isAccountImport = false
|
|
|
|
private val onImportItemClickListener = FlexibleAdapter.OnItemClickListener { _, position ->
|
|
if (userItems.size > position) {
|
|
val account = (userItems[position] as AdvancedUserItem).account
|
|
reauthorizeFromImport(account)
|
|
}
|
|
true
|
|
}
|
|
private val onSwitchItemClickListener = FlexibleAdapter.OnItemClickListener { _, position ->
|
|
if (userItems.size > position) {
|
|
val userEntity = (userItems[position] as AdvancedUserItem).entity
|
|
userUtils.createOrUpdateUser(
|
|
null,
|
|
null, null, null,
|
|
null, java.lang.Boolean.TRUE, null, userEntity.id, null, null, null
|
|
)
|
|
.subscribe(object : Observer<UserEntity> {
|
|
override fun onSubscribe(d: Disposable) {}
|
|
override fun onNext(userEntity: UserEntity) {
|
|
cookieManager.cookieStore.removeAll()
|
|
userUtils.disableAllUsersWithoutId(userEntity.id)
|
|
if (activity != null) {
|
|
activity!!.runOnUiThread { router.popCurrentController() }
|
|
}
|
|
}
|
|
|
|
override fun onError(e: Throwable) {}
|
|
override fun onComplete() {}
|
|
})
|
|
}
|
|
true
|
|
}
|
|
|
|
init {
|
|
setHasOptionsMenu(true)
|
|
sharedApplication!!.componentApplication.inject(this)
|
|
Configuration.getInstance().load(context, PreferenceManager.getDefaultSharedPreferences(context))
|
|
if (args?.containsKey(KEY_IS_ACCOUNT_IMPORT) == true) {
|
|
isAccountImport = true
|
|
}
|
|
}
|
|
|
|
override fun onOptionsItemSelected(item: MenuItem): Boolean {
|
|
return when (item.itemId) {
|
|
android.R.id.home -> {
|
|
router.popCurrentController()
|
|
true
|
|
}
|
|
else -> super.onOptionsItemSelected(item)
|
|
}
|
|
}
|
|
|
|
override fun onViewBound(view: View) {
|
|
super.onViewBound(view)
|
|
binding.swipeRefreshLayout.isEnabled = false
|
|
|
|
actionBar?.show()
|
|
|
|
if (adapter == null) {
|
|
adapter = FlexibleAdapter(userItems, activity, false)
|
|
var userEntity: UserEntity?
|
|
var participant: Participant
|
|
if (!isAccountImport) {
|
|
for (userEntityObject in userUtils.users) {
|
|
userEntity = userEntityObject as UserEntity?
|
|
if (!userEntity!!.current) {
|
|
var userId: String?
|
|
userId = if (userEntity.userId != null) {
|
|
userEntity.userId
|
|
} else {
|
|
userEntity.username
|
|
}
|
|
participant = Participant()
|
|
participant.setActorType(Participant.ActorType.USERS)
|
|
participant.setActorId(userId)
|
|
participant.setDisplayName(userEntity.displayName)
|
|
userItems.add(AdvancedUserItem(participant, userEntity, null))
|
|
}
|
|
}
|
|
adapter!!.addListener(onSwitchItemClickListener)
|
|
adapter!!.updateDataSet(userItems, false)
|
|
} else {
|
|
var account: Account
|
|
var importAccount: ImportAccount
|
|
for (accountObject in findAccounts(userUtils.users as List<UserEntity>)) {
|
|
account = accountObject
|
|
importAccount = getInformationFromAccount(account)
|
|
participant = Participant()
|
|
participant.setActorType(Participant.ActorType.USERS)
|
|
participant.setActorId(importAccount.getUsername())
|
|
participant.setDisplayName(importAccount.getUsername())
|
|
userEntity = UserEntity()
|
|
userEntity.baseUrl = importAccount.getBaseUrl()
|
|
userItems.add(AdvancedUserItem(participant, userEntity, account))
|
|
}
|
|
adapter!!.addListener(onImportItemClickListener)
|
|
adapter!!.updateDataSet(userItems, false)
|
|
}
|
|
}
|
|
prepareViews()
|
|
}
|
|
|
|
private fun prepareViews() {
|
|
val layoutManager: LinearLayoutManager = SmoothScrollLinearLayoutManager(activity)
|
|
binding.recyclerView.layoutManager = layoutManager
|
|
binding.recyclerView.setHasFixedSize(true)
|
|
binding.recyclerView.adapter = adapter
|
|
binding.swipeRefreshLayout.isEnabled = false
|
|
}
|
|
|
|
private fun reauthorizeFromImport(account: Account?) {
|
|
val importAccount = getInformationFromAccount(account!!)
|
|
val bundle = Bundle()
|
|
bundle.putString(KEY_BASE_URL, importAccount.getBaseUrl())
|
|
bundle.putString(KEY_USERNAME, importAccount.getUsername())
|
|
bundle.putString(KEY_TOKEN, importAccount.getToken())
|
|
bundle.putBoolean(KEY_IS_ACCOUNT_IMPORT, true)
|
|
router.pushController(
|
|
RouterTransaction.with(AccountVerificationController(bundle))
|
|
.pushChangeHandler(HorizontalChangeHandler())
|
|
.popChangeHandler(HorizontalChangeHandler())
|
|
)
|
|
}
|
|
|
|
override val title: String
|
|
get() =
|
|
resources!!.getString(R.string.nc_select_an_account)
|
|
}
|