"...app/src/main/res/layout/frag_location_sharing.xml" did not exist on "c17b06f80193db0ab2aa7334c13a46ffc2febc55"
-
Maxime Callet authored
Change-Id: Ibca1eb2f274bbcfba1134a99b8e05430b4e2b13c
Maxime Callet authoredChange-Id: Ibca1eb2f274bbcfba1134a99b8e05430b4e2b13c
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
HomeActivity.kt 34.18 KiB
/*
* Copyright (C) 2004-2021 Savoir-faire Linux Inc.
*
* Author: Adrien Beraud <adrien.beraud@savoirfairelinux.com>
* Alexandre Lision <alexandre.lision@savoirfairelinux.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/>.
*/
package cx.ring.client
import android.content.DialogInterface
import android.content.Intent
import android.content.res.Configuration
import android.graphics.Bitmap
import android.graphics.Typeface
import android.os.Build
import android.os.Bundle
import android.util.Log
import android.view.MenuItem
import android.view.View
import android.view.ViewOutlineProvider
import android.view.WindowManager
import android.widget.AdapterView
import android.widget.CompoundButton
import androidx.annotation.StringRes
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.Person
import androidx.core.content.pm.ShortcutInfoCompat
import androidx.core.content.pm.ShortcutManagerCompat
import androidx.core.graphics.drawable.IconCompat
import androidx.core.view.WindowCompat
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentTransaction
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.google.android.material.elevation.ElevationOverlayProvider
import com.google.android.material.navigation.NavigationBarView
import cx.ring.BuildConfig
import cx.ring.R
import cx.ring.about.AboutFragment
import cx.ring.account.AccountEditionFragment
import cx.ring.account.AccountWizardActivity
import cx.ring.application.JamiApplication
import cx.ring.contactrequests.ContactRequestsFragment
import cx.ring.databinding.ActivityHomeBinding
import cx.ring.fragments.ConversationFragment
import cx.ring.fragments.SmartListFragment
import cx.ring.interfaces.BackHandlerInterface
import cx.ring.interfaces.Colorable
import cx.ring.service.DRingService
import cx.ring.settings.SettingsFragment
import cx.ring.settings.VideoSettingsFragment
import cx.ring.settings.pluginssettings.PluginDetails
import cx.ring.settings.pluginssettings.PluginPathPreferenceFragment
import cx.ring.settings.pluginssettings.PluginSettingsFragment
import cx.ring.settings.pluginssettings.PluginsListSettingsFragment
import cx.ring.utils.BitmapUtils
import cx.ring.utils.ContentUriHandler
import cx.ring.utils.ConversationPath
import cx.ring.utils.DeviceUtils
import cx.ring.views.AvatarDrawable
import cx.ring.views.AvatarFactory
import cx.ring.views.SwitchButton
import dagger.hilt.android.AndroidEntryPoint
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.core.Single
import io.reactivex.rxjava3.disposables.CompositeDisposable
import io.reactivex.rxjava3.schedulers.Schedulers
import net.jami.model.Account
import net.jami.model.AccountConfig
import net.jami.model.Conversation
import net.jami.model.Uri
import net.jami.services.AccountService
import net.jami.services.ContactService
import net.jami.services.ConversationFacade
import net.jami.services.NotificationService
import net.jami.smartlist.ConversationItemViewModel
import java.util.concurrent.TimeUnit
import javax.inject.Inject
import kotlin.math.min
@AndroidEntryPoint
class HomeActivity : AppCompatActivity(), NavigationBarView.OnItemSelectedListener,
AdapterView.OnItemSelectedListener, Colorable {
private var fContent: Fragment? = null
private var fConversation: ConversationFragment? = null
private var mAccountAdapter: AccountSpinnerAdapter? = null
private var mAccountFragmentBackHandlerInterface: BackHandlerInterface? = null
private var mOutlineProvider: ViewOutlineProvider? = null
private var mOrientation = 0
@Inject
lateinit
var mContactService: ContactService
@Inject
lateinit
var mAccountService: AccountService
@Inject
lateinit
var mConversationFacade: ConversationFacade
@Inject
lateinit
var mNotificationService: NotificationService
private var mBinding: ActivityHomeBinding? = null
private var mMigrationDialog: AlertDialog? = null
private val mDisposable = CompositeDisposable()
/* called before activity is killed, e.g. rotation */
override fun onSaveInstanceState(bundle: Bundle) {
super.onSaveInstanceState(bundle)
bundle.putInt("orientation", mOrientation)
}
override fun onRestoreInstanceState(savedInstanceState: Bundle) {
super.onRestoreInstanceState(savedInstanceState)
mOrientation = savedInstanceState.getInt("orientation")
}
public override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
JamiApplication.instance?.startDaemon()
// Switch to TV if appropriate (could happen with buggy launcher)
if (DeviceUtils.isTv(this)) {
Log.d(TAG, "Switch to TV")
val intent = intent
intent.setClass(this, cx.ring.tv.main.HomeActivity::class.java)
finish()
startActivity(intent)
return
}
if (!DeviceUtils.isTablet(this)) {
if (resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
WindowCompat.setDecorFitsSystemWindows(window, true)
} else {
WindowCompat.setDecorFitsSystemWindows(window, false)
}
} else {
WindowCompat.setDecorFitsSystemWindows(window, true)
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
val attr = window.attributes
attr.layoutInDisplayCutoutMode =
WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
}
mBinding = ActivityHomeBinding.inflate(layoutInflater).also { binding ->
setContentView(binding.root)
setSupportActionBar(binding.mainToolbar)
supportActionBar?.title = ""
binding.navigationView.setOnItemSelectedListener(this)
binding.navigationView.menu.getItem(NAVIGATION_CONVERSATIONS).isChecked = true
mOutlineProvider = binding.appBar.outlineProvider
binding.spinnerToolbar.onItemSelectedListener = this
binding.accountSwitch.setOnCheckedChangeListener { _: CompoundButton, isChecked: Boolean ->
enableAccount(isChecked)
}
binding.contactImage?.setOnClickListener { fConversation?.openContact() }
if (!DeviceUtils.isTablet(this) && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
window.navigationBarColor =
ElevationOverlayProvider(this).compositeOverlayWithThemeSurfaceColorIfNeeded(
binding.navigationView.elevation
)
}
}
handleIntent(intent)
}
override fun onConfigurationChanged(newConfig: Configuration) {
if (!DeviceUtils.isTablet(this)) {
if (resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
WindowCompat.setDecorFitsSystemWindows(window, true)
} else {
WindowCompat.setDecorFitsSystemWindows(window, false)
}
}
super.onConfigurationChanged(newConfig)
}
override fun onDestroy() {
super.onDestroy()
mMigrationDialog?.apply {
if (isShowing) dismiss()
mMigrationDialog = null
}
fContent = null
mDisposable.dispose()
mBinding = null
}
override fun onNewIntent(intent: Intent) {
super.onNewIntent(intent)
handleIntent(intent)
}
private fun handleIntent(intent: Intent) {
Log.d(TAG, "handleIntent: $intent")
val extra = intent.extras
val action = intent.action
when (action) {
ACTION_PRESENT_TRUST_REQUEST_FRAGMENT -> {
presentTrustRequestFragment(
extra?.getString(AccountEditionFragment.ACCOUNT_ID_KEY) ?: return
)
}
Intent.ACTION_SEND,
Intent.ACTION_SEND_MULTIPLE -> {
val path = ConversationPath.fromBundle(extra)
if (path != null) {
startConversation(path)
} else {
intent.setClass(applicationContext, ShareActivity::class.java)
startActivity(intent)
}
}
Intent.ACTION_VIEW,
DRingService.ACTION_CONV_ACCEPT -> {
val path = ConversationPath.fromIntent(intent)
if (path != null)
startConversation(path)
}
}
val fragmentManager = supportFragmentManager
fContent = fragmentManager.findFragmentById(R.id.main_frame)
if (fContent == null || Intent.ACTION_SEARCH == action) {
if (fContent is SmartListFragment) {
(fContent as SmartListFragment).handleIntent(intent)
} else {
val content = SmartListFragment()
fContent = content
fragmentManager.beginTransaction()
.replace(R.id.main_frame, content, HOME_TAG)
.commitNow()
}
}
}
private fun showMigrationDialog() {
if (mMigrationDialog != null) {
return
}
mMigrationDialog = MaterialAlertDialogBuilder(this)
.setTitle(R.string.account_migration_title_dialog)
.setMessage(R.string.account_migration_message_dialog)
.setIcon(R.drawable.baseline_warning_24)
.setPositiveButton(android.R.string.ok) { _: DialogInterface?, _: Int ->
selectNavigationItem(R.id.navigation_settings)
}
.setNegativeButton(android.R.string.cancel, null)
.show()
}
private fun setToolbarState(@StringRes titleRes: Int) {
setToolbarState(getString(titleRes), null)
}
private fun setToolbarState(title: String?, subtitle: String?) {
mBinding?.mainToolbar?.let { toolbar ->
toolbar.logo = null
toolbar.title = title
toolbar.subtitle = subtitle
}
}
private fun showProfileInfo() {
mBinding?.apply {
spinnerToolbar.visibility = View.VISIBLE
mainToolbar.title = null
mainToolbar.subtitle = null
}
}
override fun onStart() {
super.onStart()
mDisposable.add(
mAccountService.observableAccountList
.observeOn(AndroidSchedulers.mainThread())
.subscribe { accounts: List<Account> ->
if (accounts.isEmpty()) {
startActivity(Intent(this, AccountWizardActivity::class.java))
}
for (account in accounts) {
if (account.needsMigration()) {
showMigrationDialog()
break
}
}
})
mDisposable.add(
mAccountService.observableAccountList
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ accounts ->
mAccountAdapter?.apply {
clear()
addAll(accounts)
notifyDataSetChanged()
if (accounts.isNotEmpty()) {
mBinding!!.spinnerToolbar.setSelection(0)
}
} ?: run {
AccountSpinnerAdapter(
this@HomeActivity,
ArrayList(accounts),
mDisposable,
mAccountService
).apply {
mAccountAdapter = this
setNotifyOnChange(false)
mBinding?.spinnerToolbar?.adapter = this
}
}
if (fContent is SmartListFragment) {
showProfileInfo()
}
}) { e -> Log.e(TAG, "Error loading account list !", e) })
mDisposable.add(mAccountService
.currentAccountSubject
.switchMap { obj -> obj.unreadPending }
.observeOn(AndroidSchedulers.mainThread())
.subscribe { count -> setBadge(R.id.navigation_requests, count) })
mDisposable.add(mAccountService
.currentAccountSubject
.switchMap { obj -> obj.unreadConversations }
.observeOn(AndroidSchedulers.mainThread())
.subscribe { count -> setBadge(R.id.navigation_home, count) })
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
val targetSize = (AvatarFactory.SIZE_NOTIF * resources.displayMetrics.density).toInt()
mDisposable.add(mAccountService
.currentAccountSubject
.switchMap { obj -> obj.getConversationsSubject() }
.debounce(10, TimeUnit.SECONDS)
.observeOn(Schedulers.computation())
.switchMapSingle { conversations ->
Single.zip(conversations.mapTo(ArrayList(conversations.size))
{ c ->
mContactService.getLoadedConversation(c)
.observeOn(Schedulers.computation())
.map { vm ->
Pair(
vm, BitmapUtils.drawableToBitmap(
AvatarDrawable.Builder()
.withViewModel(vm)
.withCircleCrop(true)
.build(this), targetSize
)
)
}
}) { obs -> obs }
}
.subscribe({ conversations -> setShareShortcuts(conversations) })
{ e -> Log.e(TAG, "Error generating conversation shortcuts", e) })
}
if (fConversation == null)
fConversation =
supportFragmentManager.findFragmentByTag(ConversationFragment::class.java.simpleName) as ConversationFragment?
val newOrientation = resources.configuration.orientation
if (mOrientation != newOrientation) {
mOrientation = newOrientation
hideTabletToolbar()
if (DeviceUtils.isTablet(this)) {
selectNavigationItem(R.id.navigation_home)
showTabletToolbar()
} else {
// Remove ConversationFragment that might have been restored after an orientation change
if (fConversation != null) {
supportFragmentManager
.beginTransaction()
.remove(fConversation!!)
.commitNow()
fConversation = null
}
}
}
// Select first conversation in tablet mode
if (DeviceUtils.isTablet(this)) {
val intent = intent
val uri = intent?.data
if ((intent == null || uri == null) && fConversation == null) {
var smartlist: Observable<List<Observable<ConversationItemViewModel>>>? = null
if (fContent is SmartListFragment) smartlist =
mConversationFacade.getSmartList(false) else if (fContent is ContactRequestsFragment) smartlist =
mConversationFacade.pendingList
if (smartlist != null) {
mDisposable.add(smartlist
.filter { list -> list.isNotEmpty() }
.map { list -> list[0].firstOrError() }
.firstElement()
.flatMapSingle { e -> e }
.subscribe { element ->
startConversation(
element.accountId,
element.uri
)
})
}
}
}
}
override fun onStop() {
super.onStop()
mDisposable.clear()
}
fun startConversation(conversationId: String) {
mDisposable.add(mAccountService.currentAccountSubject
.firstElement()
.observeOn(AndroidSchedulers.mainThread())
.subscribe { account ->
startConversation(
account.accountId,
Uri.fromString(conversationId)
)
})
}
fun startConversation(accountId: String, conversationId: Uri) {
startConversation(ConversationPath(accountId, conversationId))
}
private fun startConversation(path: ConversationPath) {
Log.w(TAG, "startConversation $path")
if (!DeviceUtils.isTablet(this)) {
startActivity(
Intent(
Intent.ACTION_VIEW,
path.toUri(),
this,
ConversationActivity::class.java
)
)
} else {
startConversationTablet(path.toBundle())
}
}
private fun startConversationTablet(bundle: Bundle?) {
fConversation = ConversationFragment()
fConversation!!.arguments = bundle
if (fContent !is ContactRequestsFragment) {
selectNavigationItem(R.id.navigation_home)
}
showTabletToolbar()
supportFragmentManager.beginTransaction()
.replace(
R.id.conversation_container,
fConversation!!,
ConversationFragment::class.java.simpleName
)
.commit()
}
private fun presentTrustRequestFragment(accountId: String) {
mNotificationService.cancelTrustRequestNotification(accountId)
if (fContent is ContactRequestsFragment) {
(fContent as ContactRequestsFragment).presentForAccount(accountId)
return
}
val content = ContactRequestsFragment().apply {
arguments =
Bundle().apply { putString(AccountEditionFragment.ACCOUNT_ID_KEY, accountId) }
}
fContent = content
mBinding!!.navigationView.menu.getItem(NAVIGATION_CONTACT_REQUESTS).isChecked = true
supportFragmentManager.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(R.id.main_frame, content, CONTACT_REQUESTS_TAG)
.addToBackStack(CONTACT_REQUESTS_TAG).commit()
}
override fun onBackPressed() {
if (mAccountFragmentBackHandlerInterface != null && mAccountFragmentBackHandlerInterface!!.onBackPressed()) {
return
}
super.onBackPressed()
fContent = supportFragmentManager.findFragmentById(R.id.main_frame)
if (fContent is SmartListFragment) {
mBinding!!.navigationView.menu.getItem(NAVIGATION_CONVERSATIONS).isChecked =
true
//showProfileInfo();
showToolbarSpinner()
hideTabletToolbar()
}
}
private fun popCustomBackStack() {
val fragmentManager = supportFragmentManager
val entryCount = fragmentManager.backStackEntryCount
for (i in 0 until entryCount) {
fragmentManager.popBackStackImmediate()
}
//fContent = fragmentManager.findFragmentById(R.id.main_frame);
hideTabletToolbar()
setToolbarElevation(false)
}
fun goToHome() {
val item = mBinding!!.navigationView.menu.getItem(NAVIGATION_CONVERSATIONS)
onNavigationItemSelected(item)
item.isChecked = true
}
fun goToSettings() {
if (fContent is SettingsFragment) {
return
}
popCustomBackStack()
hideToolbarSpinner()
val content = SettingsFragment()
fContent = content
supportFragmentManager
.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, SETTINGS_TAG)
.addToBackStack(SETTINGS_TAG).commit()
}
fun goToAbout() {
if (fContent is AboutFragment) {
return
}
popCustomBackStack()
hideToolbarSpinner()
val content = AboutFragment()
fContent = content
supportFragmentManager
.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, ABOUT_TAG)
.addToBackStack(ABOUT_TAG).commit()
}
fun goToVideoSettings() {
if (fContent is VideoSettingsFragment) {
return
}
val content = VideoSettingsFragment()
fContent = content
supportFragmentManager
.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, VIDEO_SETTINGS_TAG)
.addToBackStack(VIDEO_SETTINGS_TAG).commit()
}
override fun onNavigationItemSelected(item: MenuItem): Boolean {
val account = mAccountService.currentAccount ?: return false
val bundle = Bundle()
val itemId = item.itemId
if (itemId == R.id.navigation_requests) {
if (fContent is ContactRequestsFragment) {
(fContent as ContactRequestsFragment).presentForAccount(null)
return true
}
popCustomBackStack()
val content = ContactRequestsFragment()
fContent = content
supportFragmentManager.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(R.id.main_frame, content, CONTACT_REQUESTS_TAG)
.setReorderingAllowed(true)
.addToBackStack(CONTACT_REQUESTS_TAG)
.commit()
//showProfileInfo();
showToolbarSpinner()
} else if (itemId == R.id.navigation_home) {
if (fContent is SmartListFragment) {
return true
}
popCustomBackStack()
val fcontent = supportFragmentManager.findFragmentById(R.id.main_frame)
if (fcontent is SmartListFragment) {
fContent = fcontent
return true
}
val content = SmartListFragment()
fContent = content
supportFragmentManager.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(R.id.main_frame, content, HOME_TAG)
.setReorderingAllowed(true)
.commit()
//showProfileInfo();
showToolbarSpinner()
} else if (itemId == R.id.navigation_settings) {
if (account.needsMigration()) {
Log.d(TAG, "launchAccountMigrationActivity: Launch account migration activity")
val intent = Intent()
.setClass(this, AccountWizardActivity::class.java)
.setData(
android.net.Uri.withAppendedPath(
ContentUriHandler.ACCOUNTS_CONTENT_URI,
account.accountId
)
)
startActivityForResult(intent, 1)
} else {
Log.d(TAG, "launchAccountEditFragment: Launch account edit fragment")
bundle.putString(AccountEditionFragment.ACCOUNT_ID_KEY, account.accountId)
if (fContent is AccountEditionFragment) {
return true
}
popCustomBackStack()
val content = AccountEditionFragment()
content.arguments = bundle
fContent = content
supportFragmentManager.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, ACCOUNTS_TAG)
.addToBackStack(ACCOUNTS_TAG)
.commit()
showToolbarSpinner()
}
}
return true
}
override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
val adapter = mAccountAdapter ?: return
val type = adapter.getItemViewType(position)
if (type == AccountSpinnerAdapter.TYPE_ACCOUNT) {
adapter.getItem(position)?.let { account ->
mAccountService.currentAccount = account
showAccountStatus(fContent is AccountEditionFragment && !account.isSip)
}
} else {
val intent = Intent(this@HomeActivity, AccountWizardActivity::class.java)
if (type == AccountSpinnerAdapter.TYPE_CREATE_SIP) {
intent.action = AccountConfig.ACCOUNT_TYPE_SIP
}
startActivity(intent)
mBinding!!.spinnerToolbar.setSelection(mAccountService.currentAccountIndex)
}
}
override fun onNothingSelected(parent: AdapterView<*>?) {}
private fun setBadge(menuId: Int, number: Int) {
if (number == 0) mBinding!!.navigationView.removeBadge(menuId) else mBinding!!.navigationView.getOrCreateBadge(
menuId
).number = number
}
private fun hideTabletToolbar() {
mBinding?.let { binding ->
binding.tabletToolbar?.let { toolbar ->
binding.contactTitle?.text = null
binding.contactSubtitle?.text = null
binding.contactImage?.setImageDrawable(null)
toolbar.visibility = View.GONE
}
}
}
private fun showTabletToolbar() {
if (DeviceUtils.isTablet(this))
mBinding?.let { binding ->
binding.tabletToolbar?.let { toolbar ->
toolbar.visibility = View.VISIBLE
}
}
}
fun setTabletTitle(@StringRes titleRes: Int) {
mBinding?.let { binding ->
binding.tabletToolbar?.let { toolbar ->
binding.contactTitle?.setText(titleRes)
binding.contactTitle?.textSize = 19f
binding.contactTitle?.setTypeface(null, Typeface.BOLD)
binding.contactImage?.visibility = View.GONE
toolbar.visibility = View.VISIBLE
}
}
/*RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) binding.contactTitle.getLayoutParams();
params.removeRule(RelativeLayout.ALIGN_TOP);
params.addRule(RelativeLayout.CENTER_VERTICAL, RelativeLayout.TRUE);
binding.contactTitle.setLayoutParams(params);*/
}
fun setToolbarTitle(@StringRes titleRes: Int) {
if (DeviceUtils.isTablet(this)) {
setTabletTitle(titleRes)
} else {
setToolbarState(titleRes)
}
}
fun showAccountStatus(show: Boolean) {
mBinding!!.accountSwitch.visibility = if (show) View.VISIBLE else View.GONE
}
private fun showToolbarSpinner() {
mBinding!!.spinnerToolbar.visibility = View.VISIBLE
}
private fun hideToolbarSpinner() {
if (mBinding != null && !DeviceUtils.isTablet(this)) {
mBinding!!.spinnerToolbar.visibility = View.GONE
}
}
private val fragmentContainerId: Int
get() = if (DeviceUtils.isTablet(this@HomeActivity))
R.id.conversation_container else R.id.main_frame
fun setAccountFragmentOnBackPressedListener(backPressedListener: BackHandlerInterface?) {
mAccountFragmentBackHandlerInterface = backPressedListener
}
/**
* Changes the current main fragment to a plugins list settings fragment
*/
fun goToPluginsListSettings() {
if (fContent is PluginsListSettingsFragment) {
return
}
val content = PluginsListSettingsFragment()
fContent = content
supportFragmentManager
.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, PLUGINS_LIST_SETTINGS_TAG)
.addToBackStack(PLUGINS_LIST_SETTINGS_TAG).commit()
}
/**
* Changes the current main fragment to a plugin settings fragment
* @param pluginDetails
*/
fun gotToPluginSettings(pluginDetails: PluginDetails) {
if (fContent is PluginSettingsFragment) {
return
}
val content = PluginSettingsFragment.newInstance(pluginDetails)
fContent = content
supportFragmentManager
.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, PLUGIN_SETTINGS_TAG)
.addToBackStack(PLUGIN_SETTINGS_TAG).commit()
}
/**
* Changes the current main fragment to a plugin PATH preference fragment
*/
fun gotToPluginPathPreference(pluginDetails: PluginDetails, preferenceKey: String) {
if (fContent is PluginPathPreferenceFragment) {
return
}
val content = PluginPathPreferenceFragment.newInstance(pluginDetails, preferenceKey)
fContent = content
supportFragmentManager
.beginTransaction()
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.replace(fragmentContainerId, content, PLUGIN_PATH_PREFERENCE_TAG)
.addToBackStack(PLUGIN_PATH_PREFERENCE_TAG).commit()
}
override fun setColor(color: Int) {
//mToolbar.setBackground(new ColorDrawable(color));
}
fun setToolbarElevation(enable: Boolean) {
mBinding?.appBar?.isLifted = enable
}
fun popFragmentImmediate() {
val fm = supportFragmentManager
fm.popBackStackImmediate()
val entry = fm.getBackStackEntryAt(fm.backStackEntryCount - 1)
fContent = fm.findFragmentById(entry.id)
}
private fun selectNavigationItem(id: Int) {
val binding = mBinding ?: return
binding.navigationView.selectedItemId = id
}
private fun enableAccount(newValue: Boolean) {
val account = mAccountService.currentAccount
if (account == null) {
Log.w(TAG, "account not found!")
return
}
account.isEnabled = newValue
mAccountService.setAccountEnabled(account.accountId, newValue)
}
val switchButton: SwitchButton
get() = mBinding!!.accountSwitch
private fun setShareShortcuts(conversations: Array<*>) {
var maxCount = ShortcutManagerCompat.getMaxShortcutCountPerActivity(this)
if (maxCount == 0) maxCount = 4
val shortcutInfoList: MutableList<ShortcutInfoCompat> =
ArrayList(min(maxCount, conversations.size))
for (c in conversations) {
val conversation = c as Pair<ConversationItemViewModel, Bitmap>
val mode = conversation.first.mode
if (mode == Conversation.Mode.Syncing)
continue
var icon: IconCompat? = null
try {
icon = IconCompat.createWithBitmap(conversation.second)
} catch (e: Exception) {
Log.w(TAG, "Failed to load icon", e)
}
val title = conversation.first.contactName
if (title.isEmpty()) continue
val path = ConversationPath(conversation.first.accountId, conversation.first.uri)
val key = path.toKey()
val person = Person.Builder()
.setName(title)
.setKey(key)
.build()
val shortcutInfo = ShortcutInfoCompat.Builder(this, key)
.setShortLabel(title)
.setPerson(person)
.setLongLived(true)
.setIcon(icon)
.setCategories(setOf(CONVERSATIONS_CATEGORY))
.setIntent(
Intent(
Intent.ACTION_SEND,
android.net.Uri.EMPTY,
this,
HomeActivity::class.java
)
.putExtras(path.toBundle())
)
.build()
shortcutInfoList.add(shortcutInfo)
if (shortcutInfoList.size == maxCount) break
}
try {
Log.d(TAG, "Adding shortcuts: " + shortcutInfoList.size)
ShortcutManagerCompat.removeAllDynamicShortcuts(this)
ShortcutManagerCompat.addDynamicShortcuts(this, shortcutInfoList)
} catch (e: Exception) {
Log.w(TAG, "Error adding shortcuts", e)
}
}
companion object {
val TAG: String = HomeActivity::class.simpleName!!
const val REQUEST_CODE_CALL = 3
const val REQUEST_CODE_CONVERSATION = 4
const val REQUEST_CODE_PHOTO = 5
const val REQUEST_CODE_GALLERY = 6
const val REQUEST_CODE_QR_CONVERSATION = 7
const val REQUEST_PERMISSION_CAMERA = 113
const val REQUEST_PERMISSION_READ_STORAGE = 114
private const val NAVIGATION_CONTACT_REQUESTS = 0
private const val NAVIGATION_CONVERSATIONS = 1
private const val NAVIGATION_ACCOUNT = 2
const val HOME_TAG = "Home"
const val CONTACT_REQUESTS_TAG = "Trust request"
const val ACCOUNTS_TAG = "Accounts"
const val ABOUT_TAG = "About"
const val SETTINGS_TAG = "Prefs"
const val VIDEO_SETTINGS_TAG = "VideoPrefs"
const val ACTION_PRESENT_TRUST_REQUEST_FRAGMENT =
BuildConfig.APPLICATION_ID + "presentTrustRequestFragment"
const val PLUGINS_LIST_SETTINGS_TAG = "PluginsListSettings"
const val PLUGIN_SETTINGS_TAG = "PluginSettings"
const val PLUGIN_PATH_PREFERENCE_TAG = "PluginPathPreference"
private const val CONVERSATIONS_CATEGORY = "conversations"
}
}