Improve auto-scroll to current tab item

Slion · Slion · commit 64cfb0778e0e · 2025-03-04T14:18:13.000+01:00
It should center on target item. We gave up on the speed tweaks for now. Close #668.
diff --git a/app/src/main/java/fulguris/activity/WebBrowserActivity.kt b/app/src/main/java/fulguris/activity/WebBrowserActivity.kt
@@ -131,6 +131,7 @@ import java.util.*
 import javax.inject.Inject
 import kotlin.math.abs
 import kotlin.system.exitProcess
+import kotlin.time.TimeSource
 
 
 /**
@@ -463,7 +464,6 @@ abstract class WebBrowserActivity : ThemedBrowserActivity(),
 
         // Hook in buttons with onClick handler
         iBindingToolbarContent.buttonReload.setOnClickListener(this)
-
     }
 
     /**
@@ -510,9 +510,6 @@ abstract class WebBrowserActivity : ThemedBrowserActivity(),
         mainHandler.postDelayed({
             setupToolBar()
             setupPullToRefresh(aConfig)
-            // For embedded tab bars modes
-            tryScrollToCurrentTab()
-
             iBinding.drawerLayout.requestLayout()
         },500);
 
@@ -610,7 +607,9 @@ abstract class WebBrowserActivity : ThemedBrowserActivity(),
         // See: https://github.com/material-components/material-components-android/issues/2168
         tabsDialog = createBottomSheetDialog(tabsView as View)
         // Once our bottom sheet is open we want it to scroll to current tab
-        tabsDialog.setOnShowListener { tryScrollToCurrentTab() }
+        tabsDialog.setOnShowListener {
+            tryScrollToCurrentTab()
+        }
         /*
         tabsDialog.behavior.addBottomSheetCallback(object : BottomSheetBehavior.BottomSheetCallback() {
             override fun onStateChanged(bottomSheet: View, newState: Int) {
@@ -2901,7 +2900,7 @@ abstract class WebBrowserActivity : ThemedBrowserActivity(),
         showActionBar()
         // Make sure current tab is visible in tab list
         tryScrollToCurrentTab()
-        //mainHandler.postDelayed({ scrollToCurrentTab() }, 0)
+        //mainHandler.postDelayed({ tryScrollToCurrentTab() }, 0)
 
         // Current tab was already set by the time we get here
         tabsManager.currentTab?.let {
@@ -4092,32 +4091,36 @@ abstract class WebBrowserActivity : ThemedBrowserActivity(),
     }
 
     /**
-     * Never call that function direction.
+     * Never call that function directly.
      * Just call [tryScrollToCurrentTab] instead.
      */
     private fun scrollToCurrentTab() {
         /*if (userPreferences.useBottomSheets && tabsView is TabsDrawerView && !(tabsDialog.isShowing && tabsDialog.behavior.state == BottomSheetBehavior.STATE_EXPANDED)) {
-       return
-   }*/
+            return
+        }*/
+        //Thread.dumpStack()
 
-        val tabListView = (tabsView as ViewGroup).findViewById<RecyclerView>(R.id.tabs_list)
-        // Set focus
         // Find our recycler list view
+        val tabListView = (tabsView as ViewGroup).findViewById<RecyclerView>(R.id.tabs_list)
+
         tabListView?.apply {
-            // Get current tab index and layout manager
-            val index = tabsManager.indexOfCurrentTab()
-            val lm = layoutManager as LinearLayoutManager
-            // Check if current item is currently visible
-            if (lm.findFirstCompletelyVisibleItemPosition() <= index && index <= lm.findLastCompletelyVisibleItemPosition()) {
+            if (smoothScrollToPositionEx(tabsManager.indexOfCurrentTab())) {
+                // Our current item is not completely visible, we need to scroll then
+                // Once scroll is complete we will focus our current item
+                val timeSource = TimeSource.Monotonic
+                val mark = timeSource.markNow();
+                onceOnScrollStateIdle {
+                    // For some reason we need to try again to scroll to current tab as sometimes it fails on first or even second try,
+                    // and lands somewhere else when we have over 600 tabs in our bottom sheet. Hopefully it won't get stuck in endless tries.
+                    val elapsed = timeSource.markNow() - mark;
+                    Timber.d("Scroll time: ${elapsed.inWholeMilliseconds} ms")
+                    tryScrollToCurrentTab()
+                    findViewHolderForAdapterPosition(tabsManager.indexOfCurrentTab())?.itemView?.requestFocus()
+                }
+            } else {
                 // We don't need to scroll as current item is already visible
                 // Just focus our current item then for best keyboard navigation experience
                 findViewHolderForAdapterPosition(tabsManager.indexOfCurrentTab())?.itemView?.requestFocus()
-            } else {
-                // Our current item is not completely visible, we need to scroll then
-                // Once scroll is complete we will focus our current item
-                onceOnScrollStateIdle { findViewHolderForAdapterPosition(tabsManager.indexOfCurrentTab())?.itemView?.requestFocus() }
-                // Trigger scroll
-                smoothScrollToPosition(index)
             }
         }
     }
diff --git a/app/src/main/java/fulguris/browser/tabs/TabsDrawerView.kt b/app/src/main/java/fulguris/browser/tabs/TabsDrawerView.kt
@@ -17,6 +17,7 @@ import androidx.recyclerview.widget.DefaultItemAnimator
 import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import timber.log.Timber
 
 
 /**
@@ -110,9 +111,10 @@ class TabsDrawerView @JvmOverloads constructor(
     }
 
     /**
-     * TODO: this is called way to often for my taste and should be optimized somehow.
+     * TODO: this is called way too often for my taste and should be optimized somehow.
      */
     private fun displayTabs() {
+        Timber.d("displayTabs");
         tabsAdapter.showTabs(webBrowser.getTabModel().allTabs.map(WebPageTab::asTabViewState))
 
         if (fixScrollBug(iBinding.tabsList)) {
diff --git a/app/src/main/java/fulguris/extensions/ViewExtensions.kt b/app/src/main/java/fulguris/extensions/ViewExtensions.kt
@@ -1,12 +1,11 @@
 package fulguris.extensions
 
-import fulguris.R
-import fulguris.utils.getFilteredColor
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.res.Configuration
 import android.graphics.*
 import android.os.SystemClock
+import android.util.DisplayMetrics
 import android.view.*
 import android.view.inputmethod.InputMethodManager
 import android.widget.ImageView
@@ -19,10 +18,14 @@ import androidx.core.view.isVisible
 import androidx.databinding.BindingAdapter
 import androidx.drawerlayout.widget.DrawerLayout
 import androidx.palette.graphics.Palette
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.LinearSmoothScroller
 import androidx.recyclerview.widget.RecyclerView
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import fulguris.R
+import fulguris.utils.getFilteredColor
+import timber.log.Timber
 import java.lang.reflect.Method
-import java.util.ArrayList
 
 
 /**
@@ -214,6 +217,96 @@ inline fun RecyclerView?.onceOnScrollStateIdle(crossinline runnable: () -> Unit)
     })
 }
 
+/**
+ * If needed it triggers a scroll animation to show the specified item in this [RecyclerView].
+ * Unfortunately [LinearSmoothScroller] won't let us define the exact duration of the animation.
+ *
+ * [aPosition] The index of the item you want to scroll to.
+ * [aDurationInMs] The rough duration of the scroll animation in milliseconds.
+ * [aOvershot] Specify if you want your scroll animation to overshot in order to put the target item roughly in the middle of this view, as opposed than on the edge.
+ * [aSnapMode] See [LinearSmoothScroller].
+ *
+ * Returns true if a scroll was triggered, false otherwise.
+ * Improved from: https://stackoverflow.com/a/65489113/3969362
+ */
+fun RecyclerView.smoothScrollToPositionEx(aPosition: Int, aDurationInMs: Int = 1000) : Boolean {
+
+    // First of all, check if we should be scrolling at all
+    if (scrollState != RecyclerView.SCROLL_STATE_IDLE) {
+        Timber.d("Already scrolling, skip it for now")
+        return false
+    }
+
+    // Can't do it without adapter
+    adapter?.let { adaptor ->
+
+        val count = adaptor.itemCount
+        var index = aPosition
+
+
+        //adaptor.getItemViewType()
+
+        val lm = layoutManager as LinearLayoutManager
+        // Check if current item is currently visible
+        val minIndex = lm.findFirstCompletelyVisibleItemPosition()
+        val maxIndex = lm.findLastCompletelyVisibleItemPosition()
+
+        // Check if our item is already visible
+        if ( minIndex <= index && index <= maxIndex) {
+            Timber.d("No need to scroll")
+            return false
+        }
+
+        val scrollDown = (index<minIndex) // && !configPrefs.toolbarsBottom
+        val scrollFrom = if (scrollDown) minIndex else maxIndex
+
+        val scrollRange = if (scrollFrom>index) scrollFrom - index else index - scrollFrom
+        Timber.d("Scroll range: $scrollRange")
+
+        // Trigger our scroll animation
+        val smoothScroller = object : LinearSmoothScroller(this.context) {
+
+            // Center on our target item
+            // See: https://stackoverflow.com/a/53756296/3969362
+            override fun calculateDtToFit(viewStart: Int, viewEnd: Int, boxStart: Int, boxEnd: Int, snapPreference: Int): Int {
+                return (boxStart + (boxEnd - boxStart) / 2) - (viewStart + (viewEnd - viewStart) / 2)
+            }
+
+            // We disabled our speed tweak as it is really tricky to get it right for various use cases
+            // Various tabs list variant, number of tabs or screen DPI...
+            // The default implementation appears to be a good compromise after all.
+            /*
+            override fun calculateSpeedPerPixel(displayMetrics: DisplayMetrics?): Float {
+                // Compute our speed as function of the distance we need to scroll
+                var speed = if ((layoutManager as? LinearLayoutManager)?.orientation == LinearLayoutManager.VERTICAL) {
+                    aDurationInMs.toFloat() / ((computeVerticalScrollRange().toFloat() / count) * scrollRange)
+                } else {
+                    aDurationInMs.toFloat() / ((computeHorizontalScrollRange().toFloat() / count) * scrollRange)
+                }
+
+                Timber.d("Scroll speed: $speed ms/pixel")
+
+                // Speed is expressed in ms/pixel so in fact min speed is the fastest one and max speed is the slowest one
+                val minSpeed = 0.001f    // Fastest
+                val maxSpeed = 0.05f     // Slowest
+                // Make sure we don't go too fast or too slow, going too fast can break the LinearSmoothScroller and cause endless animation jitter
+                if (speed<minSpeed) speed = minSpeed
+                if (speed>maxSpeed) speed = maxSpeed
+
+                return speed
+            }
+            */
+
+        }
+        smoothScroller.targetPosition = index
+        layoutManager?.startSmoothScroll(smoothScroller)
+
+        return true
+    }
+
+    return false
+}
+
 /**
  * Reset Swipe Refresh Layout target.
  * This is needed if you are changing the child scrollable view during the lifetime of your layout.
@@ -441,4 +534,5 @@ fun View.onConfigurationChange(aRunnable: () -> Unit) {
         // Could be useful to help understand what's going on when inspecting our views
         id = R.id.onConfigurationChange
     }) }
-}
+}
+
