Merge pull request #1124 from torlando-tech/feature/configurable-bottom-nav

User-configurable bottom navigation + NomadNet browsing polish

Author: torlando-tech

app/src/main/java/network/columba/app/MainActivity.kt

@@ -50,7 +50,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -91,6 +90,7 @@ import network.columba.app.navigation.navigateToAnsweredCall
 import network.columba.app.navigation.navigateToEntity
 import network.columba.app.navigation.navigateToIncomingCall
 import network.columba.app.navigation.shouldPresentIncomingCall
+import network.columba.app.navigation.NavTab
 import network.columba.app.notifications.CallNotificationHelper
 import network.columba.app.repository.InterfaceRepository
 import network.columba.app.repository.SettingsRepository
@@ -741,7 +741,6 @@ fun ColumbaNavigation(
     val context = LocalContext.current
     val lifecycleOwner = LocalLifecycleOwner.current
     val navController = rememberNavController()
-    var selectedTab by remember { mutableIntStateOf(0) }
 
     LaunchedEffect(detachedUsbDeviceEvents, navController) {
         detachedUsbDeviceEvents.collect { deviceId ->
@@ -926,7 +925,6 @@ fun ColumbaNavigation(
                     }
                     is PendingNavigation.AddContact -> {
                         // Navigate to contacts tab and trigger add contact dialog
-                        selectedTab = 1 // Contacts tab
                         navController.navigate(Screen.Contacts.route) {
                             popUpTo(navController.graph.startDestinationId) {
                                 saveState = true
@@ -950,7 +948,6 @@ fun ColumbaNavigation(
                     is PendingNavigation.SharedText -> {
                         sharedTextViewModel.setText(navigation.text)
 
-                        selectedTab = 0
                         val poppedToChats = navController.popBackStack(Screen.Chats.route, inclusive = false)
                         if (!poppedToChats) {
                             navController.navigate(Screen.Chats.route) {
@@ -966,7 +963,6 @@ fun ColumbaNavigation(
                     is PendingNavigation.SharedImage -> {
                         sharedImageViewModel.setImages(navigation.uris)
 
-                        selectedTab = 0
                         val poppedToChats = navController.popBackStack(Screen.Chats.route, inclusive = false)
                         if (!poppedToChats) {
                             navController.navigate(Screen.Chats.route) {
@@ -1170,19 +1166,6 @@ fun ColumbaNavigation(
     val navBackStackEntry by navController.currentBackStackEntryAsState()
     val currentRoute = navBackStackEntry?.destination?.route
 
-    // Synchronize selectedTab with current route when navigating back
-    LaunchedEffect(currentRoute) {
-        Log.d("ColumbaNavigation", "📍 currentRoute changed to: $currentRoute")
-        selectedTab =
-            when (currentRoute) {
-                Screen.Chats.route -> 0
-                Screen.Contacts.route -> 1
-                Screen.Map.route -> 2
-                Screen.Settings.route -> 3
-                else -> selectedTab // Keep current selection for nested screens
-            }
-    }
-
     // Observe call state for incoming calls and navigate to IncomingCallScreen.
     // Composable functions can't @Inject, so the RnsTelephony seam singleton is
     // reached through Hilt's RnsTelephonyEntryPoint. Replaces the A.9-era
@@ -1266,7 +1249,9 @@ fun ColumbaNavigation(
         listOf(
             "offline_map_download",
             "messaging/",
-            "announce_detail/",
+            // announce_detail (Node Details) intentionally keeps the nav bar:
+            // it sits one tap from the tabs, and hiding the bar made returning
+            // from NomadNet flows feel jarring.
             "message_detail/",
             "theme_editor",
             "rnode_wizard",
@@ -1277,20 +1262,15 @@ fun ColumbaNavigation(
             "voice_call/",
             "incoming_call/",
             "interface_stats/",
-            "nomadnet_browser/",
         )
     val shouldShowBottomNav =
         currentRoute != null &&
             currentRoute !in hideBottomNavScreens &&
             hideBottomNavPrefixes.none { currentRoute.startsWith(it) }
 
-    val screens =
-        listOf(
-            Screen.Chats,
-            Screen.Contacts,
-            Screen.Map,
-            Screen.Settings,
-        )
+    // User-configurable bottom bar tabs (Settings pinned last, max NavTab.MAX_TABS).
+    // The NomadNet tab is a normal tab: the bar stays visible while browsing pages.
+    val bottomNavTabs = settingsState.bottomNavTabs
 
     // Double-back-to-exit state: first back press on a root tab shows a toast,
     // second press within 2 seconds finishes the activity.
@@ -1345,14 +1325,32 @@ fun ColumbaNavigation(
                 bottomBar = {
                     if (shouldShowBottomNav) {
                         NavigationBar {
-                            screens.forEachIndexed { index, screen ->
+                            bottomNavTabs.forEach { tab ->
                                 NavigationBarItem(
-                                    icon = { Icon(screen.icon, contentDescription = null) },
-                                    label = { Text(screen.title) },
-                                    selected = selectedTab == index,
+                                    icon = { Icon(tab.icon, contentDescription = null) },
+                                    label = { Text(tab.label) },
+                                    selected = tab.matchesRoute(currentRoute),
                                     onClick = {
-                                        selectedTab = index
-                                        navController.navigate(screen.route) {
+                                        if (currentRoute?.startsWith("nomadnet") == true) {
+                                            if (tab == NavTab.NOMADNET) {
+                                                // Already browsing; the site session ends via
+                                                // Close Site or Back, not by re-tapping the tab.
+                                                return@NavigationBarItem
+                                            }
+                                            // Browsing is modal over the tab tree: collapse
+                                            // the NomadNet stack first, then switch tabs
+                                            // normally. Popping (rather than saving state)
+                                            // guarantees a single browser view, so tab taps
+                                            // can never stack duplicates or fight over
+                                            // scroll position.
+                                            while (
+                                                navController.currentDestination?.route
+                                                    ?.startsWith("nomadnet") == true
+                                            ) {
+                                                if (!navController.popBackStack()) break
+                                            }
+                                        }
+                                        navController.navigate(tab.tabRoute) {
                                             popUpTo(navController.graph.startDestinationId) {
                                                 saveState = true
                                             }
@@ -1741,7 +1739,6 @@ fun ColumbaNavigation(
                                         navController.navigate("apk_sharing")
                                     },
                                     onNavigateToAnnounces = { filterType ->
-                                        selectedTab = 1 // Announces tab
                                         val route =
                                             if (filterType != null) {
                                                 "${Screen.Announces.route}?filterType=$filterType"
@@ -2422,7 +2419,6 @@ fun ColumbaNavigation(
                                     },
                                     onStartChat = { destHash, peerName ->
                                         // Navigate back to chats tab
-                                        selectedTab = 0
                                         navController.navigate(Screen.Chats.route) {
                                             popUpTo(navController.graph.startDestinationId) {
                                                 saveState = true
@@ -2467,6 +2463,31 @@ fun ColumbaNavigation(
                                     destinationHash = destHash,
                                     initialPath = path,
                                     onBackClick = { navController.popBackStack() },
+                                    // Standalone browser: after closing the site,
+                                    // pop back the way Back does.
+                                    onCloseSite = { navController.popBackStack() },
+                                    onOpenConversation = { conversationHash ->
+                                        val encodedHash = Uri.encode(conversationHash)
+                                        val encodedName = Uri.encode(conversationHash.take(12))
+                                        navController.navigate("messaging/$encodedHash/$encodedName")
+                                    },
+                                )
+                            }
+
+                            // NomadNet tab home: reopens the last-browsed node,
+                            // or shows the address-entry prompt on a fresh install.
+                            appComposable(AppDestination.NOMADNET_HOME) {
+                                DoubleBackToExitHandler(AppDestination.NOMADNET_HOME.routePattern)
+                                val lastNodeHash = settingsState.nomadNetLastNodeHash
+                                NomadNetBrowserScreen(
+                                    destinationHash = lastNodeHash.orEmpty(),
+                                    showHomeEntry = lastNodeHash.isNullOrEmpty(),
+                                    onBackClick = { navController.popBackStack() },
+                                    // Close Site on the tab home: closeSite() drops the
+                                    // persisted last-node hash, the state flow flips
+                                    // showHomeEntry, and the screen swaps to the address
+                                    // prompt in place - no navigation needed.
+                                    onCloseSite = {},
                                     onOpenConversation = { conversationHash ->
                                         val encodedHash = Uri.encode(conversationHash)
                                         val encodedName = Uri.encode(conversationHash.take(12))

app/src/main/java/network/columba/app/navigation/AppDestination.kt

@@ -120,6 +120,10 @@ enum class AppDestination(
             ),
         externalNavigationPolicy = ExternalNavigationPolicy.REUSE_SAME_ENTITY,
     ),
+    NOMADNET_HOME(
+        "nomadnet_home",
+        backContract = BackContract.TOP_LEVEL,
+    ),
     OFFLINE_MAPS("offline_maps"),
     OFFLINE_MAP_DOWNLOAD(
         "offline_map_download?updateRegionId={updateRegionId}",

app/src/main/java/network/columba/app/navigation/NavTab.kt

@@ -0,0 +1,84 @@
+package network.columba.app.navigation
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Chat
+import androidx.compose.material.icons.filled.Language
+import androidx.compose.material.icons.filled.Map
+import androidx.compose.material.icons.filled.People
+import androidx.compose.material.icons.filled.Sensors
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.ui.graphics.vector.ImageVector
+
+/**
+ * Registry of destinations that may appear in the user-configurable bottom
+ * navigation bar.
+ *
+ * The user chooses which tabs appear and in what order; the persisted form is
+ * a comma-separated list of [id] values (see SettingsRepository). [SETTINGS]
+ * is pinned: it is always present and always rendered last, so Settings can
+ * never be removed from the bar. [sanitize] is the single authority for what
+ * the bar renders - it drops unknown ids (forward/backward compatible),
+ * dedupes, enforces the pin, and clamps the total to [MAX_TABS].
+ *
+ * [routePrefix] drives tab selection: a tab is selected while the current
+ * navigation route starts with its prefix, which keeps a tab highlighted
+ * across parameterized routes (e.g. `announce_stream?filterType=all`).
+ */
+enum class NavTab(
+    val id: String,
+    val routePrefix: String,
+    val tabRoute: String,
+    val label: String,
+    val icon: ImageVector,
+) {
+    CHATS("chats", "chats", "chats", "Chats", Icons.Default.Chat),
+    ANNOUNCES("announces", "announce_stream", "announce_stream", "Announces", Icons.Default.Sensors),
+    CONTACTS("contacts", "contacts", "contacts", "Contacts", Icons.Default.People),
+    MAP("map", "map", "map", "Map", Icons.Default.Map),
+
+    // The NomadNet tab lands on nomadnet_home (which resolves the last-browsed
+    // node); its selection prefix also covers nomadnet_browser/... so the tab
+    // stays highlighted while browsing pages with the bar visible.
+    NOMADNET("nomadnet", "nomadnet", "nomadnet_home", "NomadNet", Icons.Default.Language),
+    SETTINGS("settings", "settings", "settings", "Settings", Icons.Default.Settings),
+    ;
+
+    /** True when [currentRoute] belongs to this tab. */
+    fun matchesRoute(currentRoute: String?): Boolean =
+        currentRoute != null && currentRoute.startsWith(routePrefix)
+
+    companion object {
+        /** Maximum number of tabs in the bar, including the pinned Settings tab. */
+        const val MAX_TABS = 5
+
+        /** Bar layout shown before the user configures anything. */
+        val DEFAULT: List<NavTab> = listOf(CHATS, CONTACTS, MAP, SETTINGS)
+
+        /** All tabs the user may toggle in the settings card (Settings is pinned). */
+        val CONFIGURABLE: List<NavTab> = entries.filter { it != SETTINGS }
+
+        fun fromId(id: String): NavTab? = entries.firstOrNull { it.id == id }
+
+        /**
+         * Parse and normalize a persisted CSV of tab ids into the exact list of
+         * tabs the bottom bar should render. Malformed, unknown, or duplicate
+         * entries are dropped; Settings is appended if missing; the result is
+         * clamped to [MAX_TABS] entries. Falls back to [DEFAULT] when nothing
+         * valid remains, so the bar can never render empty.
+         */
+        fun sanitize(csv: String?): List<NavTab> {
+            val parsed =
+                csv
+                    ?.split(',')
+                    ?.map { it.trim() }
+                    ?.mapNotNull { fromId(it) }
+                    ?.distinct()
+                    .orEmpty()
+            if (parsed.isEmpty()) return DEFAULT
+            val withoutSettings = parsed.filter { it != SETTINGS }
+            val overflow = withoutSettings.size - (MAX_TABS - 1)
+            val kept = if (overflow > 0) withoutSettings.dropLast(overflow) else withoutSettings
+            return kept + SETTINGS
+        }
+    }
+}

app/src/main/java/network/columba/app/repository/SettingsRepository.kt

@@ -141,6 +141,8 @@ class SettingsRepository
             val MAP_MARKER_DECLUTTER_ENABLED = booleanPreferencesKey("map_marker_declutter_enabled")
             val MAP_STYLE_PREFERENCE = stringPreferencesKey("map_style_preference")
             val NOMADNET_RENDERING_MODE = stringPreferencesKey("nomadnet_rendering_mode")
+            val NOMADNET_LAST_NODE = stringPreferencesKey("nomadnet_last_node")
+            val BOTTOM_NAV_TABS = stringPreferencesKey("bottom_nav_tabs")
             val HTTP_ENABLED_FOR_DOWNLOAD = booleanPreferencesKey("http_enabled_for_download")
 
             // Privacy preferences
@@ -1479,6 +1481,68 @@ class SettingsRepository
             }
         }
 
+        /**
+         * Flow of the destination hash of the last NomadNet page the user loaded,
+         * or null when none. The bottom-nav NomadNet tab navigates here so the
+         * tab reopens where the user left off; a fresh install falls back to the
+         * caller-provided default entry node.
+         */
+        val nomadNetLastNodeHashFlow: Flow<String?> =
+            context.dataStore.data
+                .map { preferences -> preferences[PreferencesKeys.NOMADNET_LAST_NODE] }
+                .distinctUntilChanged()
+
+        /**
+         * Remember the destination hash of the most recently loaded NomadNet page.
+         * [whileActive] is evaluated inside the DataStore transaction (under the
+         * edit mutex), so callers can guard against a concurrent
+         * [clearNomadNetLastNodeHash] resurrecting a just-closed site: either the
+         * predicate fails and nothing is written, or the write lands before any
+         * later clear and is properly erased by it.
+         */
+        suspend fun saveNomadNetLastNodeHash(
+            nodeHash: String,
+            whileActive: () -> Boolean = { true },
+        ) {
+            if (nodeHash.isBlank()) return
+            context.dataStore.edit { preferences ->
+                if (whileActive()) {
+                    preferences[PreferencesKeys.NOMADNET_LAST_NODE] = nodeHash
+                }
+            }
+        }
+
+        /**
+         * Forget the last-browsed NomadNet page (Close Site). The bottom-nav
+         * NomadNet tab then reopens at the address-entry prompt instead of the
+         * closed site.
+         */
+        suspend fun clearNomadNetLastNodeHash() {
+            context.dataStore.edit { preferences ->
+                preferences.remove(PreferencesKeys.NOMADNET_LAST_NODE)
+            }
+        }
+
+        /**
+         * Flow of the user-configured bottom navigation tabs, stored as a
+         * comma-separated list of [network.columba.app.navigation.NavTab] ids.
+         * Emits null before first configuration; consumers map through
+         * [network.columba.app.navigation.NavTab.sanitize] for a normalized list.
+         */
+        val bottomNavTabsFlow: Flow<String?> =
+            context.dataStore.data
+                .map { preferences -> preferences[PreferencesKeys.BOTTOM_NAV_TABS] }
+                .distinctUntilChanged()
+
+        /**
+         * Persist the bottom navigation tab layout as a comma-separated id list.
+         */
+        suspend fun saveBottomNavTabs(csv: String) {
+            context.dataStore.edit { preferences ->
+                preferences[PreferencesKeys.BOTTOM_NAV_TABS] = csv
+            }
+        }
+
         /**
          * Flow of the map marker declutter enabled setting.
          * When enabled (default), overlapping markers are spread to improve readability.

app/src/main/java/network/columba/app/ui/screens/AnnounceDetailScreen.kt

@@ -201,7 +201,10 @@ fun AnnounceDetailScreen(
                         .fillMaxSize()
                         .padding(paddingValues)
                         .verticalScroll(rememberScrollState())
-                        .padding(16.dp),
+                        // The outer bottom nav bar is visible on this screen, so
+                        // clear its height (same 88.dp convention as other
+                        // nav-visible screens) for the last card.
+                        .padding(start = 16.dp, end = 16.dp, top = 16.dp, bottom = 88.dp),
                 verticalArrangement = Arrangement.spacedBy(16.dp),
             ) {
                 // Identicon header