You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
798 lines
31 KiB
Kotlin
798 lines
31 KiB
Kotlin
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
package org.mozilla.fenix.tabtray
|
|
|
|
import android.content.Context
|
|
import android.view.LayoutInflater
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.view.accessibility.AccessibilityEvent
|
|
import android.view.accessibility.AccessibilityNodeInfo
|
|
import android.view.accessibility.AccessibilityNodeInfo.CollectionInfo
|
|
import androidx.annotation.IdRes
|
|
import androidx.cardview.widget.CardView
|
|
import androidx.constraintlayout.widget.ConstraintLayout
|
|
import androidx.constraintlayout.widget.ConstraintSet
|
|
import androidx.core.content.ContextCompat
|
|
import androidx.core.view.isVisible
|
|
import androidx.core.view.updateLayoutParams
|
|
import androidx.core.view.updatePadding
|
|
import androidx.lifecycle.LifecycleOwner
|
|
import androidx.lifecycle.lifecycleScope
|
|
import androidx.recyclerview.widget.ConcatAdapter
|
|
import androidx.recyclerview.widget.GridLayoutManager
|
|
import androidx.recyclerview.widget.LinearLayoutManager
|
|
import com.google.android.material.bottomsheet.BottomSheetBehavior
|
|
import com.google.android.material.tabs.TabLayout
|
|
import kotlinx.android.extensions.LayoutContainer
|
|
import kotlinx.android.synthetic.main.component_tabs_screen_top.view.*
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.collect_multi_select
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.exit_multi_select
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.handle
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.multiselect_title
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.tab_layout
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.tab_tray_empty_view
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.tab_tray_new_tab
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.tab_tray_overflow
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.tab_wrapper
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.tabsTray
|
|
import kotlinx.android.synthetic.main.component_tabstray_bottom.view.topBar
|
|
import kotlinx.android.synthetic.main.component_tabstray_fab_bottom.view.*
|
|
import kotlinx.android.synthetic.main.tabs_tray_tab_counter.*
|
|
import kotlinx.coroutines.Dispatchers.Main
|
|
import kotlinx.coroutines.delay
|
|
import kotlinx.coroutines.launch
|
|
import mozilla.components.browser.menu.BrowserMenu
|
|
import mozilla.components.browser.menu.BrowserMenuBuilder
|
|
import mozilla.components.browser.menu.item.SimpleBrowserMenuItem
|
|
import mozilla.components.browser.state.selector.getNormalOrPrivateTabs
|
|
import mozilla.components.browser.state.selector.normalTabs
|
|
import mozilla.components.browser.state.selector.privateTabs
|
|
import mozilla.components.browser.state.state.BrowserState
|
|
import mozilla.components.browser.tabstray.TabViewHolder
|
|
import mozilla.components.feature.syncedtabs.SyncedTabsFeature
|
|
import mozilla.components.support.base.feature.ViewBoundFeatureWrapper
|
|
import mozilla.components.support.ktx.android.util.dpToPx
|
|
import org.mozilla.fenix.R
|
|
import org.mozilla.fenix.components.metrics.Event
|
|
import org.mozilla.fenix.components.toolbar.TabCounter.Companion.INFINITE_CHAR_PADDING_BOTTOM
|
|
import org.mozilla.fenix.components.toolbar.TabCounter.Companion.MAX_VISIBLE_TABS
|
|
import org.mozilla.fenix.components.toolbar.TabCounter.Companion.SO_MANY_TABS_OPEN
|
|
import org.mozilla.fenix.components.topsheet.TopSheetBehavior
|
|
import org.mozilla.fenix.ext.components
|
|
import org.mozilla.fenix.ext.settings
|
|
import org.mozilla.fenix.tabtray.SaveToCollectionsButtonAdapter.MultiselectModeChange
|
|
import org.mozilla.fenix.tabtray.TabTrayDialogFragmentState.Mode
|
|
import java.text.NumberFormat
|
|
import kotlin.math.max
|
|
import kotlin.math.min
|
|
import mozilla.components.browser.storage.sync.Tab as SyncTab
|
|
|
|
/**
|
|
* View that contains and configures the BrowserAwesomeBar
|
|
*/
|
|
@Suppress("LongParameterList", "TooManyFunctions", "LargeClass")
|
|
class TabTrayView(
|
|
private val container: ViewGroup,
|
|
private val tabsAdapter: FenixTabsAdapter,
|
|
private val interactor: TabTrayInteractor,
|
|
store: TabTrayDialogFragmentStore,
|
|
isPrivate: Boolean,
|
|
startingInLandscape: Boolean,
|
|
lifecycleOwner: LifecycleOwner,
|
|
private val filterTabs: (Boolean) -> Unit
|
|
) : LayoutContainer, TabLayout.OnTabSelectedListener {
|
|
val lifecycleScope = lifecycleOwner.lifecycleScope
|
|
|
|
private val useFab = container.context.settings().useNewTabFloatingActionButton
|
|
val fabView: View = when (container.context.settings().placeNewTabFloatingActionButtonAtTop) {
|
|
true -> LayoutInflater.from(container.context).inflate(R.layout.component_tabstray_fab_top, container, true)
|
|
false -> LayoutInflater.from(container.context).inflate(R.layout.component_tabstray_fab_bottom, container, true)
|
|
}
|
|
|
|
private val enableCompactTabs = container.context.settings().enableCompactTabs
|
|
private val reverseTabOrderInTabsTray = container.context.settings().reverseTabOrderInTabsTray
|
|
private val isTabsTrayFullScreenMode = container.context.settings().useFullScreenTabScreen
|
|
private val hasAccessibilityEnabled = container.context.settings().accessibilityServicesEnabled
|
|
private val useTopTabsTray = container.context.settings().useTopTabsTray
|
|
|
|
val view: View = if (isTabsTrayFullScreenMode) {
|
|
when (useTopTabsTray) {
|
|
true -> LayoutInflater.from(container.context)
|
|
.inflate(R.layout.component_tabs_screen_bottom, container, true)
|
|
false -> LayoutInflater.from(container.context)
|
|
.inflate(R.layout.component_tabs_screen_top, container, true)
|
|
}
|
|
} else {
|
|
when (useTopTabsTray) {
|
|
true -> LayoutInflater.from(container.context)
|
|
.inflate(R.layout.component_tabstray_top, container, true)
|
|
false -> LayoutInflater.from(container.context)
|
|
.inflate(R.layout.component_tabstray_bottom, container, true)
|
|
}
|
|
}
|
|
|
|
private val isPrivateModeSelected: Boolean get() = view.tab_layout.selectedTabPosition == PRIVATE_TAB_ID
|
|
|
|
private val behavior = if (isTabsTrayFullScreenMode) null else {
|
|
when (useTopTabsTray) {
|
|
true -> TopSheetBehavior.from(view.tab_wrapper)
|
|
false -> BottomSheetBehavior.from(view.tab_wrapper)
|
|
}
|
|
}
|
|
|
|
private val concatAdapter = ConcatAdapter(tabsAdapter)
|
|
private val tabTrayItemMenu: TabTrayItemMenu
|
|
private var menu: BrowserMenu? = null
|
|
|
|
private var tabsTouchHelper: TabsTouchHelper
|
|
private val collectionsButtonAdapter = SaveToCollectionsButtonAdapter(interactor, isPrivate)
|
|
|
|
private val syncedTabsController = SyncedTabsController(lifecycleOwner, view, store, concatAdapter)
|
|
private val syncedTabsFeature = ViewBoundFeatureWrapper<SyncedTabsFeature>()
|
|
|
|
private var hasLoaded = false
|
|
|
|
override val containerView: View?
|
|
get() = container
|
|
|
|
private val components = container.context.components
|
|
|
|
init {
|
|
components.analytics.metrics.track(Event.TabsTrayOpened)
|
|
|
|
toggleFabText(isPrivate)
|
|
|
|
if (!isTabsTrayFullScreenMode) {
|
|
if (useTopTabsTray) {
|
|
(behavior as TopSheetBehavior).setTopSheetCallback(object :
|
|
TopSheetBehavior.TopSheetCallback() {
|
|
override fun onSlide(topSheet: View, slideOffset: Float, isOpening: Boolean?) {
|
|
if (interactor.onModeRequested() is Mode.Normal && useFab) {
|
|
if (slideOffset >= SLIDE_OFFSET) {
|
|
fabView.new_tab_button.show()
|
|
} else {
|
|
fabView.new_tab_button.hide()
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onStateChanged(topSheet: View, newState: Int) {
|
|
if (newState == TopSheetBehavior.STATE_HIDDEN) {
|
|
components.analytics.metrics.track(Event.TabsTrayClosed)
|
|
interactor.onTabTrayDismissed()
|
|
}
|
|
}
|
|
})
|
|
} else {
|
|
(behavior as BottomSheetBehavior).addBottomSheetCallback(object :
|
|
BottomSheetBehavior.BottomSheetCallback() {
|
|
override fun onSlide(bottomSheet: View, slideOffset: Float) {
|
|
if (interactor.onModeRequested() is Mode.Normal && useFab) {
|
|
if (slideOffset >= SLIDE_OFFSET) {
|
|
fabView.new_tab_button.show()
|
|
} else {
|
|
fabView.new_tab_button.hide()
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onStateChanged(bottomSheet: View, newState: Int) {
|
|
if (newState == BottomSheetBehavior.STATE_HIDDEN) {
|
|
components.analytics.metrics.track(Event.TabsTrayClosed)
|
|
interactor.onTabTrayDismissed()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
if (isTabsTrayFullScreenMode) {
|
|
view.exit_tabs_screen.setOnClickListener {
|
|
interactor.onTabTrayDismissed()
|
|
}
|
|
}
|
|
|
|
val selectedTabIndex = if (!isPrivate) {
|
|
DEFAULT_TAB_ID
|
|
} else {
|
|
PRIVATE_TAB_ID
|
|
}
|
|
|
|
view.tab_layout.getTabAt(selectedTabIndex)?.also {
|
|
view.tab_layout.selectTab(it, true)
|
|
}
|
|
|
|
view.tab_layout.addOnTabSelectedListener(this)
|
|
|
|
val tabs = if (isPrivate) {
|
|
view.context.components.core.store.state.privateTabs
|
|
} else {
|
|
view.context.components.core.store.state.normalTabs
|
|
}
|
|
|
|
val selectedBrowserTabIndex = tabs
|
|
.indexOfFirst { it.id == view.context.components.core.store.state.selectedTabId }
|
|
|
|
if (tabs.size > EXPAND_AT_SIZE || startingInLandscape) {
|
|
expand()
|
|
}
|
|
|
|
setTopOffset(startingInLandscape)
|
|
|
|
if (view.context.settings().syncedTabsInTabsTray) {
|
|
syncedTabsFeature.set(
|
|
feature = SyncedTabsFeature(
|
|
context = container.context,
|
|
storage = components.backgroundServices.syncedTabsStorage,
|
|
accountManager = components.backgroundServices.accountManager,
|
|
view = syncedTabsController,
|
|
lifecycleOwner = lifecycleOwner,
|
|
onTabClicked = ::handleTabClicked
|
|
),
|
|
owner = lifecycleOwner,
|
|
view = view
|
|
)
|
|
}
|
|
|
|
updateTabsTrayLayout()
|
|
view.tabsTray.apply {
|
|
adapter = concatAdapter
|
|
|
|
tabsTouchHelper = TabsTouchHelper(
|
|
observable = tabsAdapter,
|
|
onViewHolderTouched = { it is TabViewHolder }
|
|
)
|
|
|
|
tabsTouchHelper.attachToRecyclerView(this)
|
|
|
|
tabsAdapter.tabTrayInteractor = interactor
|
|
tabsAdapter.onTabsUpdated = {
|
|
// Put the 'Add to collections' button after the tabs have loaded.
|
|
// And, put the Synced Tabs adapter at the end.
|
|
if (reverseTabOrderInTabsTray) {
|
|
// Put these at the start when reverse tab order is enabled. Also, we disallow
|
|
// reverse tab order for compact tabs in settings.
|
|
concatAdapter.addAdapter(0, collectionsButtonAdapter)
|
|
concatAdapter.addAdapter(0, syncedTabsController.adapter)
|
|
} else {
|
|
concatAdapter.addAdapter(collectionsButtonAdapter)
|
|
concatAdapter.addAdapter(syncedTabsController.adapter)
|
|
}
|
|
|
|
// Disabling the following block of code because it causes a crash when
|
|
// accessibility services are enabled! `notifyDataSetChanged()` is incompatible
|
|
// with concatAdapter. See: https://github.com/mozilla-mobile/fenix/issues/14540
|
|
// WARNING: Merging the upstream fix for this will cause lot of conflicts!
|
|
//
|
|
// if (hasAccessibilityEnabled) {
|
|
// tabsAdapter.notifyItemRangeChanged(0, tabs.size)
|
|
// }
|
|
|
|
if (!hasLoaded) {
|
|
hasLoaded = true
|
|
scrollToTab(view.context.components.core.store.state.selectedTabId)
|
|
if (hasAccessibilityEnabled) {
|
|
lifecycleScope.launch {
|
|
delay(SELECTION_DELAY.toLong())
|
|
lifecycleScope.launch(Main) {
|
|
layoutManager?.findViewByPosition(selectedBrowserTabIndex)
|
|
?.requestFocus()
|
|
layoutManager?.findViewByPosition(selectedBrowserTabIndex)
|
|
?.sendAccessibilityEvent(
|
|
AccessibilityEvent.TYPE_VIEW_FOCUSED
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tabTrayItemMenu =
|
|
TabTrayItemMenu(view.context, { view.tab_layout.selectedTabPosition == 0 }) {
|
|
when (it) {
|
|
is TabTrayItemMenu.Item.ShareAllTabs -> interactor.onShareTabsClicked(
|
|
isPrivateModeSelected
|
|
)
|
|
is TabTrayItemMenu.Item.OpenTabSettings -> interactor.onTabSettingsClicked()
|
|
is TabTrayItemMenu.Item.SaveToCollection -> interactor.onEnterMultiselect()
|
|
is TabTrayItemMenu.Item.CloseAllTabs -> interactor.onCloseAllTabsClicked(
|
|
isPrivateModeSelected
|
|
)
|
|
is TabTrayItemMenu.Item.OpenRecentlyClosed -> interactor.onOpenRecentlyClosedClicked()
|
|
}
|
|
}
|
|
|
|
view.tab_tray_overflow.setOnClickListener {
|
|
components.analytics.metrics.track(Event.TabsTrayMenuOpened)
|
|
menu = tabTrayItemMenu.menuBuilder.build(container.context)
|
|
menu?.show(it)
|
|
?.also { pu ->
|
|
(pu.contentView as? CardView)?.setCardBackgroundColor(
|
|
ContextCompat.getColor(
|
|
view.context,
|
|
R.color.foundation_normal_theme
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
adjustNewTabButtonForNormalMode()
|
|
}
|
|
|
|
private fun gridViewNumberOfCols(context: Context): Int {
|
|
val displayMetrics = context.resources.displayMetrics
|
|
val dpWidth = displayMetrics.widthPixels / displayMetrics.density
|
|
val columnWidthDp = 190
|
|
val columnCount = (dpWidth / columnWidthDp).toInt()
|
|
return if (columnCount >= 2) columnCount else 2
|
|
}
|
|
|
|
private fun handleTabClicked(tab: SyncTab) {
|
|
interactor.onSyncedTabClicked(tab)
|
|
}
|
|
|
|
private fun adjustNewTabButtonForNormalMode() {
|
|
view.tab_tray_new_tab.apply {
|
|
visibility = if (useFab) View.GONE else View.VISIBLE
|
|
setOnClickListener {
|
|
sendNewTabEvent(isPrivateModeSelected)
|
|
interactor.onNewTabTapped(isPrivateModeSelected)
|
|
}
|
|
}
|
|
|
|
fabView.new_tab_button.apply {
|
|
isVisible = useFab
|
|
setOnClickListener {
|
|
sendNewTabEvent(isPrivateModeSelected)
|
|
interactor.onNewTabTapped(isPrivateModeSelected)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun sendNewTabEvent(isPrivateModeSelected: Boolean) {
|
|
val eventToSend = if (isPrivateModeSelected) {
|
|
Event.NewPrivateTabTapped
|
|
} else {
|
|
Event.NewTabTapped
|
|
}
|
|
|
|
components.analytics.metrics.track(eventToSend)
|
|
}
|
|
|
|
fun updateTabsTrayLayout() {
|
|
view.tabsTray.apply {
|
|
if (enableCompactTabs) {
|
|
val gridLayoutManager = GridLayoutManager(container.context, gridViewNumberOfCols(container.context))
|
|
if (useTopTabsTray) {
|
|
gridLayoutManager.reverseLayout = true
|
|
}
|
|
gridLayoutManager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
|
|
override fun getSpanSize(position: Int): Int {
|
|
val numTabs = tabsAdapter.itemCount
|
|
return if (position < numTabs) {
|
|
1
|
|
} else {
|
|
gridViewNumberOfCols(container.context)
|
|
}
|
|
}
|
|
}
|
|
|
|
layoutManager = gridLayoutManager
|
|
} else {
|
|
val linearLayoutManager = LinearLayoutManager(container.context)
|
|
if (useTopTabsTray) {
|
|
if (!reverseTabOrderInTabsTray) {
|
|
linearLayoutManager.reverseLayout = true
|
|
} else {
|
|
linearLayoutManager.stackFromEnd = true
|
|
}
|
|
} else {
|
|
if (reverseTabOrderInTabsTray) {
|
|
linearLayoutManager.reverseLayout = true
|
|
linearLayoutManager.stackFromEnd = true
|
|
}
|
|
}
|
|
|
|
layoutManager = linearLayoutManager
|
|
}
|
|
}
|
|
}
|
|
|
|
fun expand() {
|
|
if (!isTabsTrayFullScreenMode) {
|
|
if (useTopTabsTray) {
|
|
(behavior as TopSheetBehavior).state = TopSheetBehavior.STATE_EXPANDED
|
|
} else {
|
|
(behavior as BottomSheetBehavior).state = BottomSheetBehavior.STATE_EXPANDED
|
|
}
|
|
}
|
|
}
|
|
|
|
enum class TabChange {
|
|
PRIVATE, NORMAL
|
|
}
|
|
|
|
private fun toggleSaveToCollectionButton(isPrivate: Boolean) {
|
|
collectionsButtonAdapter.notifyItemChanged(
|
|
0,
|
|
if (isPrivate) TabChange.PRIVATE else TabChange.NORMAL
|
|
)
|
|
}
|
|
|
|
override fun onTabSelected(tab: TabLayout.Tab?) {
|
|
toggleFabText(isPrivateModeSelected)
|
|
filterTabs.invoke(isPrivateModeSelected)
|
|
toggleSaveToCollectionButton(isPrivateModeSelected)
|
|
|
|
updateUINormalMode(view.context.components.core.store.state)
|
|
scrollToTab(view.context.components.core.store.state.selectedTabId)
|
|
|
|
if (isPrivateModeSelected) {
|
|
components.analytics.metrics.track(Event.TabsTrayPrivateModeTapped)
|
|
} else {
|
|
components.analytics.metrics.track(Event.TabsTrayNormalModeTapped)
|
|
}
|
|
}
|
|
|
|
override fun onTabReselected(tab: TabLayout.Tab?) = Unit
|
|
override fun onTabUnselected(tab: TabLayout.Tab?) = Unit
|
|
|
|
var mode: Mode = Mode.Normal
|
|
private set
|
|
|
|
fun updateState(state: TabTrayDialogFragmentState) {
|
|
val oldMode = mode
|
|
|
|
if (oldMode::class != state.mode::class) {
|
|
updateTabsForMultiselectModeChanged(state.mode is Mode.MultiSelect)
|
|
if (hasAccessibilityEnabled) {
|
|
view.announceForAccessibility(
|
|
if (state.mode == Mode.Normal) view.context.getString(
|
|
R.string.tab_tray_exit_multiselect_content_description
|
|
) else view.context.getString(R.string.tab_tray_enter_multiselect_content_description)
|
|
)
|
|
}
|
|
}
|
|
|
|
mode = state.mode
|
|
when (state.mode) {
|
|
Mode.Normal -> {
|
|
view.tabsTray.apply {
|
|
tabsTouchHelper.attachToRecyclerView(this)
|
|
}
|
|
|
|
toggleUIMultiselect(multiselect = false)
|
|
|
|
updateUINormalMode(state.browserState)
|
|
}
|
|
is Mode.MultiSelect -> {
|
|
// Disable swipe to delete while in multiselect
|
|
tabsTouchHelper.attachToRecyclerView(null)
|
|
|
|
toggleUIMultiselect(multiselect = true)
|
|
|
|
fabView.new_tab_button.isVisible = false
|
|
view.tab_tray_new_tab.isVisible = false
|
|
view.collect_multi_select.isVisible = state.mode.selectedItems.isNotEmpty()
|
|
|
|
view.multiselect_title.text = view.context.getString(
|
|
R.string.tab_tray_multi_select_title,
|
|
state.mode.selectedItems.size
|
|
)
|
|
view.collect_multi_select.setOnClickListener {
|
|
interactor.onSaveToCollectionClicked(state.mode.selectedItems)
|
|
}
|
|
view.exit_multi_select.setOnClickListener {
|
|
interactor.onBackPressed()
|
|
}
|
|
}
|
|
}
|
|
|
|
if (oldMode.selectedItems != state.mode.selectedItems) {
|
|
val unselectedItems = oldMode.selectedItems - state.mode.selectedItems
|
|
|
|
state.mode.selectedItems.union(unselectedItems).forEach { item ->
|
|
if (hasAccessibilityEnabled) {
|
|
view.announceForAccessibility(
|
|
if (unselectedItems.contains(item)) view.context.getString(
|
|
R.string.tab_tray_item_unselected_multiselect_content_description,
|
|
item.title
|
|
) else view.context.getString(
|
|
R.string.tab_tray_item_selected_multiselect_content_description,
|
|
item.title
|
|
)
|
|
)
|
|
}
|
|
updateTabsForSelectionChanged(item.id)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun ConstraintLayout.setChildWPercent(percentage: Float, @IdRes childId: Int) {
|
|
this.findViewById<View>(childId)?.let {
|
|
val constraintSet = ConstraintSet()
|
|
constraintSet.clone(this)
|
|
constraintSet.constrainPercentWidth(it.id, percentage)
|
|
constraintSet.applyTo(this)
|
|
it.requestLayout()
|
|
}
|
|
}
|
|
|
|
private fun updateUINormalMode(browserState: BrowserState) {
|
|
val hasNoTabs = if (isPrivateModeSelected) {
|
|
browserState.privateTabs.isEmpty()
|
|
} else {
|
|
browserState.normalTabs.isEmpty()
|
|
}
|
|
|
|
view.tab_tray_empty_view.isVisible = hasNoTabs
|
|
if (hasNoTabs) {
|
|
view.tab_tray_empty_view.text = if (isPrivateModeSelected) {
|
|
view.context.getString(R.string.no_private_tabs_description)
|
|
} else {
|
|
view.context?.getString(R.string.no_open_tabs_description)
|
|
}
|
|
}
|
|
|
|
view.tabsTray.visibility = if (hasNoTabs) {
|
|
View.INVISIBLE
|
|
} else {
|
|
View.VISIBLE
|
|
}
|
|
view.tab_tray_overflow.isVisible = !hasNoTabs
|
|
|
|
counter_text.text = updateTabCounter(browserState.normalTabs.size)
|
|
updateTabCounterContentDescription(browserState.normalTabs.size)
|
|
|
|
adjustNewTabButtonForNormalMode()
|
|
}
|
|
|
|
private fun toggleUIMultiselect(multiselect: Boolean) {
|
|
view.multiselect_title.isVisible = multiselect
|
|
view.collect_multi_select.isVisible = multiselect
|
|
view.exit_multi_select.isVisible = multiselect
|
|
|
|
view.topBar.setBackgroundColor(
|
|
ContextCompat.getColor(
|
|
view.context,
|
|
if (multiselect) R.color.accent_normal_theme else R.color.foundation_normal_theme
|
|
)
|
|
)
|
|
|
|
val displayMetrics = view.context.resources.displayMetrics
|
|
|
|
view.handle.updateLayoutParams<ViewGroup.MarginLayoutParams> {
|
|
height =
|
|
if (multiselect) MULTISELECT_HANDLE_HEIGHT.dpToPx(displayMetrics) else NORMAL_HANDLE_HEIGHT.dpToPx(
|
|
displayMetrics
|
|
)
|
|
if (useTopTabsTray) {
|
|
bottomMargin = if (multiselect) 0.dpToPx(displayMetrics) else NORMAL_BOTTOM_MARGIN.dpToPx(
|
|
displayMetrics
|
|
)
|
|
} else {
|
|
topMargin = if (multiselect) 0.dpToPx(displayMetrics) else NORMAL_TOP_MARGIN.dpToPx(
|
|
displayMetrics
|
|
)
|
|
}
|
|
}
|
|
|
|
view.tab_wrapper.setChildWPercent(
|
|
if (multiselect) 1F else NORMAL_HANDLE_PERCENT_WIDTH,
|
|
view.handle.id
|
|
)
|
|
|
|
view.handle.setBackgroundColor(
|
|
ContextCompat.getColor(
|
|
view.context,
|
|
if (multiselect) R.color.accent_normal_theme else R.color.secondary_text_normal_theme
|
|
)
|
|
)
|
|
|
|
if (isTabsTrayFullScreenMode) {
|
|
view.exit_tabs_screen.isVisible = !multiselect
|
|
}
|
|
view.tab_layout.isVisible = !multiselect
|
|
view.tab_tray_empty_view.isVisible = !multiselect
|
|
view.tab_tray_overflow.isVisible = !multiselect
|
|
}
|
|
|
|
private fun updateTabsForMultiselectModeChanged(inMultiselectMode: Boolean) {
|
|
view.tabsTray.apply {
|
|
val tabs = view.context.components.core.store.state.getNormalOrPrivateTabs(
|
|
isPrivateModeSelected
|
|
)
|
|
|
|
collectionsButtonAdapter.notifyItemChanged(
|
|
0,
|
|
if (inMultiselectMode) MultiselectModeChange.MULTISELECT else MultiselectModeChange.NORMAL
|
|
)
|
|
|
|
tabsAdapter.notifyItemRangeChanged(0, tabs.size, true)
|
|
}
|
|
}
|
|
|
|
private fun updateTabsForSelectionChanged(itemId: String) {
|
|
view.tabsTray.apply {
|
|
val tabs = view.context.components.core.store.state.getNormalOrPrivateTabs(
|
|
isPrivateModeSelected
|
|
)
|
|
|
|
val selectedBrowserTabIndex = tabs.indexOfFirst { it.id == itemId }
|
|
|
|
tabsAdapter.notifyItemChanged(
|
|
selectedBrowserTabIndex, true
|
|
)
|
|
}
|
|
}
|
|
|
|
private fun updateTabCounterContentDescription(count: Int) {
|
|
view.tab_layout.getTabAt(0)?.contentDescription = if (count == 1) {
|
|
view.context?.getString(R.string.open_tab_tray_single)
|
|
} else {
|
|
view.context?.getString(R.string.open_tab_tray_plural, count.toString())
|
|
}
|
|
|
|
view.tabsTray.accessibilityDelegate = object : View.AccessibilityDelegate() {
|
|
override fun onInitializeAccessibilityNodeInfo(
|
|
host: View?,
|
|
info: AccessibilityNodeInfo?
|
|
) {
|
|
super.onInitializeAccessibilityNodeInfo(host, info)
|
|
info?.let {
|
|
info.collectionInfo = CollectionInfo.obtain(
|
|
tabsAdapter.tabCount,
|
|
1,
|
|
false
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun updateTabCounter(count: Int): String {
|
|
if (count > MAX_VISIBLE_TABS) {
|
|
counter_text.updatePadding(bottom = INFINITE_CHAR_PADDING_BOTTOM)
|
|
return SO_MANY_TABS_OPEN
|
|
}
|
|
return NumberFormat.getInstance().format(count.toLong())
|
|
}
|
|
|
|
fun setTopOffset(landscape: Boolean) {
|
|
if (!isTabsTrayFullScreenMode) {
|
|
val topOffset = if (landscape) {
|
|
0
|
|
} else {
|
|
view.context.resources.getDimension(R.dimen.tab_tray_top_offset).toInt()
|
|
}
|
|
|
|
if (!useTopTabsTray) {
|
|
(behavior as BottomSheetBehavior).setExpandedOffset(topOffset)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun dismissMenu() {
|
|
menu?.dismiss()
|
|
}
|
|
|
|
private fun toggleFabText(private: Boolean) {
|
|
if (private) {
|
|
fabView.new_tab_button.extend()
|
|
fabView.new_tab_button.contentDescription =
|
|
view.context.resources.getString(R.string.add_private_tab)
|
|
} else {
|
|
fabView.new_tab_button.shrink()
|
|
fabView.new_tab_button.contentDescription =
|
|
view.context.resources.getString(R.string.add_tab)
|
|
}
|
|
}
|
|
|
|
fun onBackPressed(): Boolean {
|
|
return interactor.onBackPressed()
|
|
}
|
|
|
|
fun scrollToTab(sessionId: String?) {
|
|
view.tabsTray.apply {
|
|
val tabs = if (isPrivateModeSelected) {
|
|
view.context.components.core.store.state.privateTabs
|
|
} else {
|
|
view.context.components.core.store.state.normalTabs
|
|
}
|
|
|
|
val selectedBrowserTabIndex = tabs
|
|
.indexOfFirst { it.id == sessionId }
|
|
|
|
val recyclerViewIndex = if (reverseTabOrderInTabsTray) {
|
|
// For reverse tab order and non-compact tabs, we add the items in collections button
|
|
// adapter and synced tabs adapter, and offset by 1 to show the tab above the
|
|
// current tab, unless current tab is first in reverse order.
|
|
min(selectedBrowserTabIndex + 1, tabsAdapter.itemCount - 1) +
|
|
collectionsButtonAdapter.itemCount + syncedTabsController.adapter.itemCount
|
|
} else {
|
|
// We offset index by -1 to show the tab above the current tab, unless current tab
|
|
// is the first.
|
|
max(0, selectedBrowserTabIndex - 1)
|
|
}
|
|
|
|
layoutManager?.scrollToPosition(recyclerViewIndex)
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
private const val DEFAULT_TAB_ID = 0
|
|
private const val PRIVATE_TAB_ID = 1
|
|
private const val EXPAND_AT_SIZE = 3
|
|
private const val SLIDE_OFFSET = 0
|
|
private const val SELECTION_DELAY = 500
|
|
private const val MULTISELECT_HANDLE_HEIGHT = 11
|
|
private const val NORMAL_HANDLE_HEIGHT = 3
|
|
private const val NORMAL_TOP_MARGIN = 8
|
|
private const val NORMAL_BOTTOM_MARGIN = 8
|
|
private const val NORMAL_HANDLE_PERCENT_WIDTH = 0.1F
|
|
}
|
|
}
|
|
|
|
class TabTrayItemMenu(
|
|
private val context: Context,
|
|
private val shouldShowSaveToCollection: () -> Boolean,
|
|
private val onItemTapped: (Item) -> Unit = {}
|
|
) {
|
|
|
|
sealed class Item {
|
|
object ShareAllTabs : Item()
|
|
object OpenTabSettings : Item()
|
|
object SaveToCollection : Item()
|
|
object CloseAllTabs : Item()
|
|
object OpenRecentlyClosed : Item()
|
|
}
|
|
|
|
val menuBuilder by lazy { BrowserMenuBuilder(menuItems) }
|
|
|
|
private val menuItems by lazy {
|
|
listOf(
|
|
SimpleBrowserMenuItem(
|
|
context.getString(R.string.tab_tray_menu_item_save),
|
|
textColorResource = R.color.primary_text_normal_theme
|
|
) {
|
|
context.components.analytics.metrics.track(Event.TabsTraySaveToCollectionPressed)
|
|
onItemTapped.invoke(Item.SaveToCollection)
|
|
}.apply { visible = shouldShowSaveToCollection },
|
|
|
|
SimpleBrowserMenuItem(
|
|
context.getString(R.string.tab_tray_menu_item_share),
|
|
textColorResource = R.color.primary_text_normal_theme
|
|
) {
|
|
context.components.analytics.metrics.track(Event.TabsTrayShareAllTabsPressed)
|
|
onItemTapped.invoke(Item.ShareAllTabs)
|
|
},
|
|
|
|
SimpleBrowserMenuItem(
|
|
context.getString(R.string.tab_tray_menu_tab_settings),
|
|
textColorResource = R.color.primary_text_normal_theme
|
|
) {
|
|
onItemTapped.invoke(Item.OpenTabSettings)
|
|
},
|
|
|
|
SimpleBrowserMenuItem(
|
|
context.getString(R.string.tab_tray_menu_recently_closed),
|
|
textColorResource = R.color.primary_text_normal_theme
|
|
) {
|
|
onItemTapped.invoke(Item.OpenRecentlyClosed)
|
|
},
|
|
|
|
SimpleBrowserMenuItem(
|
|
context.getString(R.string.tab_tray_menu_item_close),
|
|
textColorResource = R.color.primary_text_normal_theme
|
|
) {
|
|
context.components.analytics.metrics.track(Event.TabsTrayCloseAllTabsPressed)
|
|
onItemTapped.invoke(Item.CloseAllTabs)
|
|
}
|
|
)
|
|
}
|
|
}
|