tabbed settings with Display split, icon-on-top layout, gauge slider polish

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: eried

app/src/main/java/com/eried/eucplanet/data/db/AppDatabase.kt

@@ -8,7 +8,7 @@ import com.eried.eucplanet.data.model.TripRecord
 
 @Database(
     entities = [AppSettings::class, TripRecord::class, AlarmRule::class],
-    version = 18,
+    version = 20,
     exportSchema = false
 )
 abstract class AppDatabase : RoomDatabase() {

app/src/main/java/com/eried/eucplanet/data/model/AppSettings.kt

@@ -112,6 +112,20 @@ data class AppSettings(
     val themeMode: String = "black",
     // accentColor: key into the accent palette
     val accentColor: String = "default",
+    // Colored danger-zone band behind the speed arc (yellow/orange/red thresholds).
+    @ColumnInfo(defaultValue = "0")
+    val showGaugeColorBand: Boolean = false,
+    // Percentages of the full speed sweep where orange and red zones begin (yellow fills below orange).
+    @ColumnInfo(defaultValue = "65")
+    val gaugeOrangeThresholdPct: Int = 65,
+    @ColumnInfo(defaultValue = "85")
+    val gaugeRedThresholdPct: Int = 85,
+    // Haptic feedback on dashboard action button taps.
+    @ColumnInfo(defaultValue = "1")
+    val hapticFeedback: Boolean = true,
+    // "AMPS" or "WATTS" — long-press the amps card to switch.
+    @ColumnInfo(defaultValue = "AMPS")
+    val currentDisplayMode: String = "AMPS",
 
     // Backup folder (SAF tree URI on local storage; companion sync app handles cloud upload)
     val syncFolderUri: String? = null,

app/src/main/java/com/eried/eucplanet/flic/FlicManager.kt

@@ -48,6 +48,10 @@ class FlicManager @Inject constructor(
     private val _scanning = MutableStateFlow(false)
     val scanning: StateFlow<Boolean> = _scanning.asStateFlow()
 
+    // Timestamp of last dispatched Flic action. UI uses this to flash a Flic indicator briefly.
+    private val _lastActionAt = MutableStateFlow(0L)
+    val lastActionAt: StateFlow<Long> = _lastActionAt.asStateFlow()
+
     private val _scanStatus = MutableStateFlow("")
     val scanStatus: StateFlow<String> = _scanStatus.asStateFlow()
 
@@ -205,6 +209,7 @@ class FlicManager @Inject constructor(
     }
 
     private suspend fun executeAction(action: FlicAction, settings: AppSettings) {
+        if (action != FlicAction.NONE) _lastActionAt.value = System.currentTimeMillis()
         when (action) {
             FlicAction.NONE -> {}
             FlicAction.HORN -> wheelRepository.sendHorn()

app/src/main/java/com/eried/eucplanet/ui/dashboard/DashboardScreen.kt

@@ -10,16 +10,19 @@ import com.eried.eucplanet.data.repository.MetricSample
 import com.eried.eucplanet.data.repository.SettingsRepository
 import com.eried.eucplanet.data.repository.TripRepository
 import com.eried.eucplanet.data.repository.WheelRepository
+import com.eried.eucplanet.flic.FlicManager
 import com.eried.eucplanet.service.AutomationManager
 import com.eried.eucplanet.service.VoiceService
 import com.eried.eucplanet.service.WheelService
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import javax.inject.Inject
 
 data class MetricHistory(
@@ -38,13 +41,19 @@ class DashboardViewModel @Inject constructor(
     private val tripRepository: TripRepository,
     private val voiceService: VoiceService,
     private val automationManager: AutomationManager,
+    private val flicManager: FlicManager,
     @ApplicationContext private val context: Context
 ) : ViewModel() {
 
     companion object {
         private const val SPARKLINE_SIZE = 300  // 5 minutes at 1 sample/sec
     }
 
+    // Synchronous initial settings read so StateFlows start with the user's persisted values
+    // instead of hardcoded defaults (prevents a visible flash on app open).
+    private val initialSettings: com.eried.eucplanet.data.model.AppSettings =
+        runBlocking(Dispatchers.IO) { settingsRepository.get() }
+
     val wheelData: StateFlow<com.eried.eucplanet.data.model.WheelData> = wheelRepository.wheelData
 
     val connectionState: StateFlow<ConnectionState> = wheelRepository.connectionState
@@ -58,21 +67,67 @@ class DashboardViewModel @Inject constructor(
     val tripCount: StateFlow<Int> = tripRepository.tripCount
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), 0)
 
+    // Newest trip id (first row of trips sorted by startTime DESC), or null if none.
+    val latestTripId: StateFlow<Long?> = tripRepository.allTrips
+        .map { it.firstOrNull()?.id }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
+
+    val currentTripId: StateFlow<Long?> = tripRepository.currentTripId
+
     val tiltbackSpeed: StateFlow<Float> = settingsRepository.settings
         .map { it.tiltbackSpeedKmh }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), 50f)
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.tiltbackSpeedKmh)
 
     val safetyTiltbackSpeed: StateFlow<Float> = settingsRepository.settings
         .map { it.safetyTiltbackKmh }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), 25f)
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.safetyTiltbackKmh)
 
     val imperialUnits: StateFlow<Boolean> = settingsRepository.settings
         .map { it.imperialUnits }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.imperialUnits)
 
     val accentKey: StateFlow<String> = settingsRepository.settings
         .map { it.accentColor }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), com.eried.eucplanet.ui.theme.AccentKeyDefault)
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.accentColor)
+
+    val showGaugeColorBand: StateFlow<Boolean> = settingsRepository.settings
+        .map { it.showGaugeColorBand }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.showGaugeColorBand)
+
+    // Orange/red threshold percentages for the gauge color band (both 0-100).
+    val gaugeOrangePct: StateFlow<Int> = settingsRepository.settings
+        .map { it.gaugeOrangeThresholdPct }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.gaugeOrangeThresholdPct)
+
+    val gaugeRedPct: StateFlow<Int> = settingsRepository.settings
+        .map { it.gaugeRedThresholdPct }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.gaugeRedThresholdPct)
+
+    val currentDisplayMode: StateFlow<String> = settingsRepository.settings
+        .map { it.currentDisplayMode }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.currentDisplayMode)
+
+    val hasFlicConfigured: StateFlow<Boolean> = settingsRepository.settings
+        .map { it.flic1Address != null || it.flic2Address != null }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, initialSettings.flic1Address != null || initialSettings.flic2Address != null)
+
+    val flicFlashAt: StateFlow<Long> = flicManager.lastActionAt
+
+    fun toggleCurrentDisplayMode() {
+        viewModelScope.launch {
+            val current = settingsRepository.get()
+            val next = if (current.currentDisplayMode == "WATTS") "AMPS" else "WATTS"
+            settingsRepository.update(current.copy(currentDisplayMode = next))
+        }
+    }
+
+    fun startRecording() {
+        viewModelScope.launch { tripRepository.startRecording() }
+    }
+
+    fun stopRecording() {
+        viewModelScope.launch { tripRepository.stopRecording() }
+    }
 
     val modelName: StateFlow<String?> = wheelRepository.modelName
 

app/src/main/java/com/eried/eucplanet/ui/dashboard/DashboardViewModel.kt

@@ -30,7 +30,9 @@ import com.eried.eucplanet.util.MultipleEventsCutter
 sealed class Screen(val route: String) {
     data object Dashboard : Screen("dashboard")
     data object Scan : Screen("scan")
-    data object Settings : Screen("settings")
+    data object Settings : Screen("settings?tab={tab}") {
+        fun createRoute(tab: Int?) = if (tab == null) "settings" else "settings?tab=$tab"
+    }
     data object Recording : Screen("recording")
     data object Flic : Screen("flic")
     data object TripDetail : Screen("trip_detail/{tripId}") {
@@ -68,8 +70,14 @@ fun NavGraph(navController: NavHostController) {
         composable(Screen.Dashboard.route) {
             DashboardScreen(
                 onNavigateToScan = { navController.navigateSingle(Screen.Scan.route) },
-                onNavigateToSettings = { navController.navigateSingle(Screen.Settings.route) },
+                onNavigateToSettings = { tab ->
+                    navController.navigateSingle(Screen.Settings.createRoute(tab))
+                },
                 onNavigateToRecording = { navController.navigateSingle(Screen.Recording.route) },
+                onNavigateToFlic = { navController.navigateSingle(Screen.Settings.createRoute(7)) },
+                onNavigateToTripDetail = { tripId ->
+                    navController.navigateSingle(Screen.TripDetail.createRoute(tripId))
+                },
                 onNavigateToMetric = { metric ->
                     navController.navigateSingle(Screen.MetricDetail.createRoute(metric))
                 }
@@ -81,10 +89,18 @@ fun NavGraph(navController: NavHostController) {
                 onBack = { navController.popSingle() }
             )
         }
-        composable(Screen.Settings.route) {
+        composable(
+            Screen.Settings.route,
+            arguments = listOf(navArgument("tab") {
+                type = NavType.IntType
+                defaultValue = 0
+            })
+        ) { backStackEntry ->
+            val tab = backStackEntry.arguments?.getInt("tab") ?: 0
             SettingsScreen(
                 onBack = { navController.popSingle() },
-                onNavigateToFlic = { navController.navigateSingle(Screen.Flic.route) }
+                onNavigateToFlic = { navController.navigateSingle(Screen.Flic.route) },
+                initialTab = tab
             )
         }
         composable(Screen.Flic.route) {
@@ -106,9 +122,10 @@ fun NavGraph(navController: NavHostController) {
         ) { backStackEntry ->
             val tripId = backStackEntry.arguments?.getLong("tripId")
             val recordingEntry = remember(backStackEntry) {
-                navController.getBackStackEntry(Screen.Recording.route)
+                runCatching { navController.getBackStackEntry(Screen.Recording.route) }.getOrNull()
             }
-            val viewModel: RecordingViewModel = hiltViewModel(recordingEntry)
+            val viewModel: RecordingViewModel =
+                if (recordingEntry != null) hiltViewModel(recordingEntry) else hiltViewModel()
             val trips by viewModel.trips.collectAsState()
             val trip = tripId?.let { id -> trips.find { it.id == id } }
             var notFound by remember { mutableStateOf(false) }