Offer a floating ball in place of the navigation bar

An option in the appearance sheet, off by default. With it on there is no bar
and no rail: the suite type becomes NavigationSuiteType.None, which is the part
that makes this worth having at all -- the container is not merely hidden but
never laid out, so the strip it costs every screen comes back as content. On a
small phone reading a log, that strip is the expensive part.

Long-pressing the ball fans the visible panels into an arc around it; keep
dragging to highlight one and release to go there. A plain tap opens the same
arc latched, so each panel is then an ordinary tappable target -- that is the
accessible path, and it is not decoration: a drag-to-select gesture is
invisible to TalkBack, so without it the whole style would be unreachable for
anyone using a screen reader.

It is an ordinary composable drawn over the destination, inside the app window.
Never a system overlay: parasitically this app *is* com.android.shell, and
asking for SYSTEM_ALERT_WINDOW from there is not something we should ever do.
It follows the rule the container already follows -- present at the root of a
panel, gone on a detail screen, which has its own back affordance.

The arc opens inward from whichever edge the ball is parked on and stays inside
the window, including at the corners. Only the side and a fractional height are
persisted, not a coordinate: the ball always snaps to an edge, so an x position
would be a lie the moment the window is a different width, which unfolded and
in landscape it routinely is.

Edit mode overrules the setting for as long as it lasts, since there is nothing
to rearrange otherwise, and the sheet's rearrange row stops being merely a
discoverability aid and becomes the only way in -- there is no bar left to
long-press.

Author: JingMatrix

manager/src/main/kotlin/org/matrix/vector/manager/data/repository/SettingsRepository.kt

@@ -297,6 +297,49 @@ class SettingsRepository(context: Context) {
         _navPanels.value = encoded
     }
 
+    /**
+     * Whether the panels live on a draggable ball over the content instead of in a bar or a rail.
+     *
+     * Off by default: the bar is what every other app on the device puts there, and a reader who
+     * has not asked for anything else should not have to work out where their panels went. It is
+     * offered at all because the bar costs a strip of every screen for four items that are rarely
+     * touched, and on a small phone reading a log that strip is the expensive part.
+     */
+    private val _floatingNav = MutableStateFlow(prefs.getBoolean("floating_nav", false))
+    val floatingNav: StateFlow<Boolean> = _floatingNav.asStateFlow()
+
+    fun setFloatingNav(enabled: Boolean) {
+        prefs.edit().putBoolean("floating_nav", enabled).apply()
+        _floatingNav.value = enabled
+    }
+
+    /**
+     * Where the floating ball was left: which side it snapped to, and how far down it sits as a
+     * fraction of the window height.
+     *
+     * No flow, for the same reason the ambience adjustments have none: written straight through
+     * from a gesture and read once when the ball is composed, so a StateFlow would recompose the
+     * very thing being dragged on every frame of the drag. Persisted rather than remembered because
+     * somebody who moved the ball out of the way of what they were reading has made a decision
+     * about their thumb, and the host process is killed often enough that anything held in memory
+     * would put the ball back over the content within the hour.
+     *
+     * The side is stored, not the x position: the ball always snaps to an edge, so a coordinate
+     * would be a lie the moment the window is a different width — which, unfoldable and in
+     * landscape, it routinely is.
+     */
+    fun floatingNavAtEnd(): Boolean = prefs.getBoolean("floating_nav_at_end", true)
+
+    fun setFloatingNavAtEnd(atEnd: Boolean) {
+        prefs.edit().putBoolean("floating_nav_at_end", atEnd).apply()
+    }
+
+    fun floatingNavY(): Float = prefs.getFloat("floating_nav_y", 0.72f)
+
+    fun setFloatingNavY(fraction: Float) {
+        prefs.edit().putFloat("floating_nav_y", fraction).apply()
+    }
+
     fun setThemeMode(mode: String) {
         prefs.edit().putString("theme_mode", mode).apply()
         _themeMode.value = mode

manager/src/main/kotlin/org/matrix/vector/manager/ui/VectorApp.kt

@@ -1,25 +1,33 @@
 package org.matrix.vector.manager.ui
 
 import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffoldDefaults
+import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteType
 import androidx.compose.material3.adaptive.navigationsuite.rememberNavigationSuiteScaffoldState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
 import androidx.navigation3.runtime.EntryProviderScope
 import androidx.navigation3.runtime.NavKey
 import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
 import androidx.navigation3.ui.NavDisplay
+import org.matrix.vector.manager.di.ServiceLocator
 import org.matrix.vector.manager.ui.navigation.FrameworkUpdate
 import org.matrix.vector.manager.ui.screens.update.FrameworkUpdateScreen
 import org.matrix.vector.manager.ui.navigation.Canary
 import org.matrix.vector.manager.ui.screens.canary.CanaryScreen
 import org.matrix.vector.manager.ui.navigation.Troubleshoot
 import org.matrix.vector.manager.ui.screens.report.TroubleshootScreen
+import org.matrix.vector.manager.ui.navigation.FloatingPanelNav
 import org.matrix.vector.manager.ui.navigation.LocalNavigator
 import org.matrix.vector.manager.ui.navigation.Navigator
 import org.matrix.vector.manager.ui.navigation.PanelBar
@@ -48,13 +56,18 @@ import org.matrix.vector.manager.ui.screens.web.WebScreen
  * has to work unfolded and in landscape regardless. The scaffold also owns where that container
  * sits, so the destinations below it are laid out beside or above it rather than under it.
  *
- * Which panels that container holds, in which order, is the reader's — see NavPanels.
+ * Which panels that container holds, in which order, is the reader's — see NavPanels — and there is
+ * a third arrangement it can take, a ball floating over the content with no container at all. The
+ * two are not independent: rearranging the panels needs something to rearrange, so edit mode always
+ * puts the container back for as long as it lasts.
  */
 @Composable
 fun VectorApp() {
     val navigator = rememberNavigator()
 
     CompositionLocalProvider(LocalNavigator provides navigator) {
+        val settings = ServiceLocator.settings
+        val floating by settings.floatingNav.collectAsStateWithLifecycle()
         val editing = navigator.editingPanels
         // The container shows only at the root of a panel. On a detail screen none of the items is
         // the current destination, and a navigation bar highlighting nothing is worse than none.
@@ -66,46 +79,69 @@ fun VectorApp() {
         val suiteState = rememberNavigationSuiteScaffoldState()
         LaunchedEffect(atRoot) { if (atRoot) suiteState.show() else suiteState.hide() }
 
-        // Computed rather than left to the scaffold's default because PanelBar has to be told which
-        // axis it is laying items along, and the scaffold keeps that decision to itself otherwise.
+        // Computed rather than left to the scaffold's default, for two reasons: the floating style
+        // forces None, which is what actually removes the container instead of hiding it, and
+        // PanelBar has to be told which axis it is laying items along. Entering edit mode overrules
+        // the floating setting for as long as it lasts — there is nothing to rearrange otherwise.
         val suiteType =
-            NavigationSuiteScaffoldDefaults.navigationSuiteType(currentWindowAdaptiveInfo())
+            if (floating && !editing) NavigationSuiteType.None
+            else NavigationSuiteScaffoldDefaults.navigationSuiteType(currentWindowAdaptiveInfo())
 
         NavigationSuiteScaffold(
             navigationItems = {
-                PanelBar(
-                    panels = navigator.panels,
-                    current = navigator.currentTopLevel,
-                    editing = editing,
-                    suiteType = suiteType,
-                    onSelect = { route -> navigator.switchTo(route) },
-                    onEdit = { navigator.editingPanels = true },
-                    onToggleHidden = { key, hidden -> navigator.setPanelHidden(key, hidden) },
-                    onMove = { from, to -> navigator.movePanel(from, to) },
-                )
+                // NavigationSuite's `when` over the type has no None branch and no else, so under
+                // None this slot is silently dropped along with the container. Skipping it here
+                // says so out loud rather than leaving a composable that never runs.
+                if (suiteType != NavigationSuiteType.None) {
+                    PanelBar(
+                        panels = navigator.panels,
+                        current = navigator.currentTopLevel,
+                        editing = editing,
+                        suiteType = suiteType,
+                        onSelect = { route -> navigator.switchTo(route) },
+                        onEdit = { navigator.editingPanels = true },
+                        onToggleHidden = { key, hidden -> navigator.setPanelHidden(key, hidden) },
+                        onMove = { from, to -> navigator.movePanel(from, to) },
+                    )
+                }
             },
             navigationSuiteType = suiteType,
             state = suiteState,
             primaryActionContent = {
                 if (editing) PanelEditDone(onDone = { navigator.editingPanels = false })
             },
         ) {
-            NavDisplay(
-                backStack = navigator.backStack,
-                onBack = { navigator.back() },
-                // Naming any decorator replaces NavDisplay's default, which is the saveable-state
-                // one alone, so it is repeated here; the scene-setup decorator NavDisplay applies
-                // internally is untouched. The ViewModel one is what this list is for: it scopes a
-                // ViewModelStore per entry, so opening the scope editor for a second module builds
-                // a second ViewModel instead of reusing the first (they would otherwise share one
-                // default key under the activity's store).
-                entryDecorators =
-                    listOf(
-                        rememberSaveableStateHolderNavEntryDecorator(),
-                        rememberViewModelStoreNavEntryDecorator(),
-                    ),
-                entryProvider = entryProvider { registerRoutes(navigator) },
-            )
+            Box(Modifier.fillMaxSize()) {
+                NavDisplay(
+                    backStack = navigator.backStack,
+                    onBack = { navigator.back() },
+                    // Naming any decorator replaces NavDisplay's default, which is the
+                    // saveable-state one alone, so it is repeated here; the scene-setup decorator
+                    // NavDisplay applies internally is untouched. The ViewModel one is what this
+                    // list is for: it scopes a ViewModelStore per entry, so opening the scope
+                    // editor for a second module builds a second ViewModel instead of reusing the
+                    // first (they would otherwise share one default key under the activity's
+                    // store).
+                    entryDecorators =
+                        listOf(
+                            rememberSaveableStateHolderNavEntryDecorator(),
+                            rememberViewModelStoreNavEntryDecorator(),
+                        ),
+                    entryProvider = entryProvider { registerRoutes(navigator) },
+                )
+                // Last child of the Box so it draws over the destination, and inside the app window
+                // rather than in one of its own: parasitically this app is com.android.shell, which
+                // must never ask for SYSTEM_ALERT_WINDOW. It follows the same rule the container
+                // does — present at the root of a panel, gone on a detail screen that has its own
+                // back affordance.
+                if (floating && !editing && atRoot) {
+                    FloatingPanelNav(
+                        panels = navigator.panels,
+                        current = navigator.currentTopLevel,
+                        onSelect = { route -> navigator.switchTo(route) },
+                    )
+                }
+            }
         }
 
         // After the scaffold on purpose. Back callbacks are dispatched last-registered-first and