ruby_everywhere 0.3.0 → 0.4.0

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/MainTabs.kt

@@ -0,0 +1,201 @@
+package com.rubyeverywhere.shell
+
+import dev.hotwire.core.config.Hotwire
+import dev.hotwire.navigation.navigator.NavigatorConfiguration
+import dev.hotwire.navigation.tabs.HotwireBottomTab
+
+/**
+ * Maps the server's `settings.tabs` onto the fixed pool of NavigatorHosts in
+ * activity_main.xml.
+ *
+ * iOS builds its tab bar from the path configuration at runtime, so tabs can be
+ * auth-gated server-side and change without a release. Android can't do that
+ * directly — a tab needs a real FragmentContainerView id and NavigatorHost
+ * resolves its configuration once, in onCreate — so the shell declares five
+ * hosts up front and maps whatever the server sends onto them.
+ *
+ * The list this produces is ALWAYS five long. That is not tidiness, it is a
+ * hard requirement of the framework, twice over:
+ *
+ *   * [NavigatorHost] throws `IllegalStateException("No configuration found for
+ *     NavigatorHost")` in onCreate for any host in the layout that
+ *     `navigatorConfigurations()` doesn't cover. Three tabs and five hosts
+ *     would be two crashes at launch.
+ *   * `HotwireBottomNavigationController.switchTab` only hides hosts present in
+ *     the *new* tabs list, so a host dropped from a shortened list is never
+ *     hidden and stays on screen, overlapping the tab that replaced it.
+ *
+ * "Not a tab right now" is therefore always `isVisible = false`, never a
+ * shorter list.
+ */
+object MainTabs {
+
+    /**
+     * The pool, in layout order. Slot 0 is special:
+     * `HotwireActivityDelegate` initialises `currentNavigatorHostId` to the
+     * first configuration's host and loads it eagerly regardless of laziness,
+     * so slot 0 must always be a real tab (it is — the first resolved tab fills
+     * it, and with no tabs at all it holds the app's start URL).
+     */
+    val hostIds = listOf(
+        R.id.navigator_host_1,
+        R.id.navigator_host_2,
+        R.id.navigator_host_3,
+        R.id.navigator_host_4,
+        R.id.navigator_host_5
+    )
+
+    val size = hostIds.size
+
+    /** The Material icon the More slot wears. Verified present in both fonts. */
+    const val MORE_ICON = "more_horiz"
+
+    /** One tab as the server described it. `icon` is a Material icon name. */
+    data class Entry(val title: String, val path: String, val icon: String)
+
+    /**
+     * One occupied slot in the bar. [entry] is the tab it stands for, or `null`
+     * for the synthesised More slot, which stands for all of [Arrangement.overflow]
+     * at once and therefore for no single tab.
+     */
+    data class Slot(val title: String, val icon: String, val startPath: String, val entry: Entry?)
+
+    /**
+     * How the resolved tabs were laid out across the five hosts.
+     *
+     * Android's BottomNavigationView caps at five destinations and, unlike
+     * UITabBarController, synthesises nothing past that — a sixth tab simply
+     * has no bar item to live in. So the shell hand-builds iOS's answer: with
+     * six or more tabs the last slot becomes "More", a container that holds
+     * every tab from the fifth on and presents them in a bottom sheet.
+     *
+     * Five or fewer tabs arrange exactly as they always did. There is no More
+     * slot, no sheet, and nothing about the bar changes.
+     */
+    data class Arrangement(
+        val entries: List<Entry>,
+        val slots: List<Slot>,
+        val overflow: List<Entry>
+    ) {
+        val hasMore: Boolean get() = overflow.isNotEmpty()
+
+        /** The More slot's index, or -1 when there is no More slot. */
+        val moreIndex: Int get() = if (hasMore) slots.lastIndex else -1
+
+        fun isMoreIndex(index: Int): Boolean = hasMore && index == slots.lastIndex
+
+        /** The tab a slot stands for; `null` for More, and for empty slots. */
+        fun entryAt(index: Int): Entry? = slots.getOrNull(index)?.entry
+    }
+
+    /**
+     * `settings.tabs` from the merged path configuration. Parsed defensively:
+     * the settings map comes from Gson as plain collections, and the document
+     * is fetched from a server that can deploy independently of the app.
+     *
+     * Deliberately NOT truncated to the host pool. Everything past the fourth
+     * tab is still a tab — [arrange] puts it behind More rather than on the
+     * floor.
+     */
+    fun entries(): List<Entry> {
+        val tabs = Hotwire.config.pathConfiguration.settings["tabs"] as? List<*> ?: return emptyList()
+
+        return tabs.mapNotNull { entry ->
+            val map = entry as? Map<*, *> ?: return@mapNotNull null
+            val title = map["title"] as? String ?: return@mapNotNull null
+            val path = map["path"] as? String ?: return@mapNotNull null
+            Entry(title = title, path = path, icon = map["icon"] as? String ?: "circle")
+        }
+    }
+
+    /**
+     * Lay the resolved tabs out across the pool.
+     *
+     * Up to five tabs each take a slot of their own. From six, slots 1–4 are the
+     * first four tabs and slot 5 becomes More, holding the rest.
+     *
+     * The More slot's host still needs a start location — every host in the
+     * pool does — and it gets the FIRST overflow tab's path. That is load
+     * bearing rather than arbitrary: it makes the fifth host's start location
+     * identical whether there are exactly five tabs or six, so gaining or
+     * losing a More slot never moves a host's start URL and never, by itself,
+     * trips the `recreate()` that a path change costs (see [pathsFingerprint]).
+     *
+     * Nothing fetches it until the user picks a row: More is a menu, not a
+     * destination, so tapping it never selects the host (MainActivity's
+     * item-selected listener refuses the selection) and `lazyLoadTabs = true`
+     * means an unselected host loads nothing.
+     */
+    fun arrange(entries: List<Entry>, moreTitle: String): Arrangement {
+        if (entries.size <= size) {
+            return Arrangement(
+                entries = entries,
+                slots = entries.map { Slot(it.title, it.icon, it.path, it) },
+                overflow = emptyList()
+            )
+        }
+
+        val kept = entries.take(size - 1)
+        val overflow = entries.drop(size - 1)
+
+        return Arrangement(
+            entries = entries,
+            slots = kept.map { Slot(it.title, it.icon, it.path, it) } +
+                Slot(moreTitle, MORE_ICON, overflow.first().path, null),
+            overflow = overflow
+        )
+    }
+
+    /**
+     * The five tabs, padded with hidden slots. Hidden slots still need a valid
+     * start location — it is what [dev.hotwire.navigation.routing.AppNavigationRouteDecisionHandler]
+     * compares hosts against — so they get the app's own start URL. They never
+     * fetch it: `lazyLoadTabs = true` means an unselected host loads nothing,
+     * and a hidden tab cannot be selected.
+     */
+    fun tabs(config: EverywhereConfig, arrangement: Arrangement): List<HotwireBottomTab> =
+        hostIds.mapIndexed { index, hostId ->
+            val slot = arrangement.slots.getOrNull(index)
+            HotwireBottomTab(
+                title = slot?.title.orEmpty(),
+                // A placeholder, always. `iconResId` is an @DrawableRes Int, so
+                // the font-rendered bitmap cannot be passed here; MainActivity
+                // overwrites the menu item's icon after every load().
+                iconResId = R.drawable.ic_tab_placeholder,
+                isVisible = slot != null,
+                configuration = NavigatorConfiguration(
+                    // Stable per slot, not per path: the name keys the tab's
+                    // Session and SessionViewModel, and a tab that merely
+                    // changed title must not lose them.
+                    name = "tab-${index + 1}",
+                    navigatorHostId = hostId,
+                    startLocation = slot?.let { config.url(forPath = it.startPath) } ?: config.startUrl
+                )
+            )
+        }
+
+    /**
+     * Identifies a tab set for the cheap-vs-expensive decision.
+     *
+     * A change in title, icon or visibility is grade one: a second
+     * `load()` on the live controller, no fragment teardown, ~96 ms. A change
+     * in *paths* is grade two: `NavigatorHost` cached its configuration in
+     * onCreate, so nothing short of `Activity.recreate()` re-reads it. Hence
+     * two fingerprints — the paths one decides whether the Activity has to go.
+     *
+     * [fingerprint] covers every entry, overflow included: an overflow tab that
+     * changed its title or icon changes nothing in the bar, but the sheet has
+     * to be rebuilt from the new entries the next time it opens.
+     */
+    fun fingerprint(entries: List<Entry>): String =
+        entries.joinToString("\n") { "${it.title}|${it.path}|${it.icon}" }
+
+    /**
+     * The paths the five hosts were actually built against — the slots', not the
+     * entries'. An overflow tab's path is deliberately absent: it is not any
+     * host's start location, so changing it costs nothing and must not buy a
+     * `recreate()`.
+     */
+    fun pathsFingerprint(arrangement: Arrangement): String =
+        arrangement.slots.joinToString("\n") { it.startPath }
+}

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/WebBottomSheetFragment.kt

@@ -0,0 +1,13 @@
+package com.rubyeverywhere.shell
+
+import dev.hotwire.navigation.destinations.HotwireDestinationDeepLink
+import dev.hotwire.navigation.fragments.HotwireWebBottomSheetFragment
+
+/**
+ * The destination for path rules with `context: modal` and a bottom-sheet
+ * presentation. Registered so the path configuration can name it; it needs no
+ * behaviour of its own — a sheet is never the first content, so it has no part
+ * in dismissing the splash.
+ */
+@HotwireDestinationDeepLink(uri = "hotwire://fragment/web/modal/sheet")
+class WebBottomSheetFragment : HotwireWebBottomSheetFragment()

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/WebFragment.kt

@@ -0,0 +1,36 @@
+package com.rubyeverywhere.shell
+
+import dev.hotwire.core.turbo.errors.VisitError
+import dev.hotwire.navigation.destinations.HotwireDestinationDeepLink
+import dev.hotwire.navigation.fragments.HotwireWebFragment
+
+/**
+ * The default destination for every web visit.
+ *
+ * Deliberately thin — the framework's own fragment already does the work. Its
+ * one job is telling [MainActivity] when there is content on screen, which is
+ * how the splash comes down. Android has no `NavigatorDelegate.requestDidFinish`
+ * the way iOS does; the visit callbacks on the fragment are where that
+ * information surfaces.
+ */
+@HotwireDestinationDeepLink(uri = "hotwire://fragment/web")
+open class WebFragment : HotwireWebFragment() {
+
+    override fun onVisitRequestFinished(location: String) {
+        super.onVisitRequestFinished(location)
+        settled()
+    }
+
+    /**
+     * An error is still an answer: the framework has swapped in its error view,
+     * so leaving the splash up would hide it behind a spinner that never stops.
+     */
+    override fun onVisitErrorReceived(location: String, error: VisitError) {
+        super.onVisitErrorReceived(location, error)
+        settled()
+    }
+
+    private fun settled() {
+        (activity as? MainActivity)?.onWebContentSettled()
+    }
+}