Added basic convention plugins setup for modularization

feature/settings/.gitignore

@@ -0,0 +1 @@
+/build

feature/settings/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    alias(libs.plugins.convention.composeFeaturePlugin)
+}
+
+android {
+    namespace = "com.rtbishop.look4sat.feature.settings"
+}

feature/settings/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest>
+
+</manifest>

feature/settings/src/main/java/com/rtbishop/look4sat/feature/settings/SettingsDialog.kt

@@ -0,0 +1,484 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.settings
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.presentation.CardButton
+import com.rtbishop.look4sat.core.presentation.LocalSpacing
+import com.rtbishop.look4sat.core.presentation.MainTheme
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+
+@Preview(showBackground = true)
+@Composable
+private fun PositionDialogPreview() {
+    MainTheme { PositionDialog(0.0, 0.0, {}) { _, _ -> } }
+}
+
+@Composable
+fun PositionDialog(lat: Double, lon: Double, dismiss: () -> Unit, save: (Double, Double) -> Unit) {
+    val latValue = rememberSaveable { mutableStateOf(lat.toString()) }
+    val lonValue = rememberSaveable { mutableStateOf(lon.toString()) }
+    val titleText = stringResource(id = R.string.prefs_station_title)
+    val onAccept = { saveValues(latValue.value, lonValue.value, save).also { dismiss() } }
+    SharedDialog(title = titleText, onCancel = dismiss, onAccept = onAccept) {
+        OutlinedTextField(
+            value = latValue.value,
+            onValueChange = { latValue.value = it },
+            label = { Text(text = stringResource(id = R.string.prefs_station_lat_text)) }
+        )
+        OutlinedTextField(
+            value = lonValue.value,
+            onValueChange = { lonValue.value = it },
+            label = { Text(text = stringResource(id = R.string.prefs_station_lon_text)) }
+        )
+    }
+}
+
+private fun saveValues(latValue: String, lonValue: String, save: (Double, Double) -> Unit) {
+    val latitude = latValue.toDoubleOrNull() ?: 0.0
+    val longitude = lonValue.toDoubleOrNull() ?: 0.0
+    val newLatitude = if (latitude > 90) 90.0 else if (latitude < -90) -90.0 else latitude
+    val newLongitude = if (longitude > 180) 180.0 else if (longitude < -180) -180.0 else longitude
+    save(newLatitude, newLongitude)
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun LocatorDialogPreview() {
+    MainTheme { LocatorDialog("IO91vl", {}) { } }
+}
+
+@Composable
+fun LocatorDialog(qthLocator: String, dismiss: () -> Unit, save: (String) -> Unit) {
+    val locator = rememberSaveable { mutableStateOf(qthLocator) }
+    val onAccept = { save(locator.value).also { dismiss() } }
+    SharedDialog(title = stringResource(R.string.prefs_locator_title), onCancel = dismiss, onAccept = onAccept) {
+        OutlinedTextField(
+            value = locator.value,
+            onValueChange = { locator.value = it },
+            label = { Text(text = stringResource(id = R.string.prefs_locator_text)) }
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun TransceiversDialogPreview() {
+    MainTheme {
+        DataSourcesDialog(
+            useCustomTle = true,
+            useCustomTransceivers = true,
+            tleUrl = "https://example.com/tle.txt",
+            transceiversUrl = "https://example.com/tx.json",
+            onImportTle = {},
+            onImportTransceivers = {},
+            onDismiss = {},
+            onSave = { _, _, _, _ -> }
+        )
+    }
+}
+
+@Composable
+fun DataSourcesDialog(
+    useCustomTle: Boolean,
+    useCustomTransceivers: Boolean,
+    tleUrl: String,
+    transceiversUrl: String,
+    onImportTle: () -> Unit,
+    onImportTransceivers: () -> Unit,
+    onDismiss: () -> Unit,
+    onSave: (Boolean, Boolean, String, String) -> Unit
+) {
+    val padding = LocalSpacing.current.large
+    val isEnabledCustomTle = rememberSaveable { mutableStateOf(useCustomTle) }
+    val isEnabledCustomTransceivers = rememberSaveable { mutableStateOf(useCustomTransceivers) }
+    val urlTle = rememberSaveable { mutableStateOf(tleUrl) }
+    val urlTransceivers = rememberSaveable { mutableStateOf(transceiversUrl) }
+    val onAccept = {
+        onSave(isEnabledCustomTle.value, isEnabledCustomTransceivers.value, urlTle.value, urlTransceivers.value)
+        onDismiss()
+    }
+    val onCancel = { onDismiss() }
+    SharedDialog(
+        title = stringResource(id = R.string.prefs_data_sources_title),
+        onCancel = onCancel,
+        onAccept = onAccept,
+    ) {
+        Column(modifier = Modifier.padding(horizontal = padding)) {
+            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                CardButton(
+                    onClick = {
+                        onImportTle()
+                        onDismiss()
+                    },
+                    text = "TLE (3LE)\nR4UAB (.txt)",
+                    modifier = Modifier.weight(1f)
+                )
+                CardButton(
+                    onClick = {
+                        onImportTransceivers()
+                        onDismiss()
+                    },
+                    text = "Transceivers\nSatNOGS (.json)",
+                    modifier = Modifier.weight(1f)
+                )
+            }
+            Spacer(modifier = Modifier.height(6.dp))
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(text = stringResource(id = R.string.prefs_data_sources_tle_switch))
+                Switch(
+                    checked = isEnabledCustomTle.value,
+                    onCheckedChange = { isEnabledCustomTle.value = it }
+                )
+            }
+            OutlinedTextField(
+                value = urlTle.value,
+                onValueChange = { urlTle.value = it },
+                label = { Text(text = stringResource(id = R.string.prefs_data_sources_url_title)) },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth(),
+                enabled = isEnabledCustomTle.value,
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(text = stringResource(id = R.string.prefs_data_sources_transceivers_switch))
+                Switch(
+                    checked = isEnabledCustomTransceivers.value,
+                    onCheckedChange = { isEnabledCustomTransceivers.value = it }
+                )
+            }
+            OutlinedTextField(
+                value = urlTransceivers.value,
+                onValueChange = { urlTransceivers.value = it },
+                label = { Text(text = stringResource(id = R.string.prefs_data_sources_url_title)) },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth(),
+                enabled = isEnabledCustomTransceivers.value,
+            )
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreviewNetworkOutputDialog() {
+    MainTheme {
+        NetworkOutputDialog(
+            initialSettings = RCSettings(
+                rotatorState = false,
+                rotatorAddress = "127.0.0.1",
+                rotatorPort = "4533",
+                rotatorFormat = $$"P $AZ $EL",
+                frequencyState = false,
+                frequencyAddress = "127.0.0.1",
+                frequencyPort = "4532",
+                frequencyFormat = $$"set_freq $FREQ",
+                bluetoothRotatorState = false,
+                bluetoothRotatorFormat = $$"W$AZ $EL",
+                bluetoothRotatorName = "Default",
+                bluetoothRotatorAddress = "00:0C:BF:13:80:5D",
+                bluetoothFrequencyState = false,
+                bluetoothFrequencyAddress = "00:0C:BF:13:80:5D",
+                bluetoothFrequencyFormat = $$"FA$FREQ"
+            ),
+            onDismiss = {},
+            onSave = { _, _, _, _, _, _, _, _ -> }
+        )
+    }
+}
+
+@Composable
+fun NetworkOutputDialog(
+    initialSettings: RCSettings,
+    onDismiss: () -> Unit,
+    onSave: (
+        Boolean, String, String, String,
+        Boolean, String, String, String
+    ) -> Unit
+) {
+    val padding = LocalSpacing.current.large
+    val rotatorState = rememberSaveable { mutableStateOf(initialSettings.rotatorState) }
+    val rotatorAddress = rememberSaveable { mutableStateOf(initialSettings.rotatorAddress) }
+    val rotatorPort = rememberSaveable { mutableStateOf(initialSettings.rotatorPort) }
+    val rotatorFormat = rememberSaveable { mutableStateOf(initialSettings.rotatorFormat) }
+    val frequencyState = rememberSaveable { mutableStateOf(initialSettings.frequencyState) }
+    val frequencyAddress = rememberSaveable { mutableStateOf(initialSettings.frequencyAddress) }
+    val frequencyPort = rememberSaveable { mutableStateOf(initialSettings.frequencyPort) }
+    val frequencyFormat = rememberSaveable { mutableStateOf(initialSettings.frequencyFormat) }
+    val onAccept = {
+        onSave(
+            rotatorState.value,
+            rotatorAddress.value,
+            rotatorPort.value,
+            rotatorFormat.value,
+            frequencyState.value,
+            frequencyAddress.value,
+            frequencyPort.value,
+            frequencyFormat.value
+        )
+        onDismiss()
+    }
+    SharedDialog(
+        title = stringResource(R.string.prefs_net_title),
+        onCancel = onDismiss,
+        onAccept = onAccept
+    ) {
+        Column(modifier = Modifier.padding(horizontal = padding)) {
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(stringResource(R.string.prefs_net_rotator_switch))
+                Switch(
+                    checked = rotatorState.value,
+                    onCheckedChange = { rotatorState.value = it }
+                )
+            }
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(6.dp),
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                OutlinedTextField(
+                    value = rotatorAddress.value,
+                    onValueChange = { rotatorAddress.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_net_rotator_ip_hint)) },
+                    modifier = Modifier.weight(1.5f),
+                    enabled = rotatorState.value
+                )
+                OutlinedTextField(
+                    value = rotatorPort.value,
+                    onValueChange = { rotatorPort.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_net_rotator_port_hint)) },
+                    modifier = Modifier.weight(1f),
+                    enabled = rotatorState.value
+                )
+            }
+            Spacer(modifier = Modifier.height(6.dp))
+            OutlinedTextField(
+                value = rotatorFormat.value,
+                onValueChange = { rotatorFormat.value = it },
+                singleLine = true,
+                label = { Text(stringResource(R.string.prefs_net_rotator_format_hint)) },
+                modifier = Modifier.fillMaxWidth(),
+                enabled = rotatorState.value
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(stringResource(R.string.prefs_net_frequency_switch))
+                Switch(
+                    checked = frequencyState.value,
+                    onCheckedChange = { frequencyState.value = it }
+                )
+            }
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(6.dp),
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                OutlinedTextField(
+                    value = frequencyAddress.value,
+                    onValueChange = { frequencyAddress.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_net_frequency_ip_hint)) },
+                    modifier = Modifier.weight(1.5f),
+                    enabled = frequencyState.value
+                )
+                OutlinedTextField(
+                    value = frequencyPort.value,
+                    onValueChange = { frequencyPort.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_net_frequency_port_hint)) },
+                    modifier = Modifier.weight(1f),
+                    enabled = frequencyState.value
+                )
+            }
+            Spacer(modifier = Modifier.height(6.dp))
+            OutlinedTextField(
+                value = frequencyFormat.value,
+                onValueChange = { frequencyFormat.value = it },
+                maxLines = 2,
+                label = { Text(stringResource(R.string.prefs_net_frequency_format_hint)) },
+                modifier = Modifier.fillMaxWidth(),
+                enabled = frequencyState.value
+            )
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreviewBluetoothOutputDialog() {
+    MainTheme {
+        BluetoothOutputDialog(
+            initialSettings = RCSettings(
+                rotatorState = false,
+                rotatorAddress = "127.0.0.1",
+                rotatorPort = "4533",
+                rotatorFormat = $$"P $AZ $EL",
+                frequencyState = false,
+                frequencyAddress = "127.0.0.1",
+                frequencyPort = "4532",
+                frequencyFormat = $$"set_freq $FREQ",
+                bluetoothRotatorState = false,
+                bluetoothRotatorFormat = $$"W$AZ $EL",
+                bluetoothRotatorName = "Default",
+                bluetoothRotatorAddress = "00:0C:BF:13:80:5D",
+                bluetoothFrequencyState = false,
+                bluetoothFrequencyAddress = "00:0C:BF:13:80:5D",
+                bluetoothFrequencyFormat = $$"FA$FREQ"
+            ),
+            onDismiss = {},
+            onSave = { _, _, _, _, _, _ -> }
+        )
+    }
+}
+
+@Composable
+fun BluetoothOutputDialog(
+    initialSettings: RCSettings,
+    onDismiss: () -> Unit,
+    onSave: (
+        Boolean, String, String,
+        Boolean, String, String
+    ) -> Unit
+) {
+    val padding = LocalSpacing.current.large
+    val rotatorState = rememberSaveable { mutableStateOf(initialSettings.bluetoothRotatorState) }
+    val rotatorAddress = rememberSaveable { mutableStateOf(initialSettings.bluetoothRotatorAddress) }
+    val rotatorFormat = rememberSaveable { mutableStateOf(initialSettings.bluetoothRotatorFormat) }
+    val frequencyState = rememberSaveable { mutableStateOf(initialSettings.bluetoothFrequencyState) }
+    val frequencyAddress = rememberSaveable { mutableStateOf(initialSettings.bluetoothFrequencyAddress) }
+    val frequencyFormat = rememberSaveable { mutableStateOf(initialSettings.bluetoothFrequencyFormat) }
+    val onAccept = {
+        onSave(
+            rotatorState.value,
+            rotatorAddress.value,
+            rotatorFormat.value,
+            frequencyState.value,
+            frequencyAddress.value,
+            frequencyFormat.value
+        )
+        onDismiss()
+    }
+    SharedDialog(
+        title = stringResource(R.string.prefs_bt_title),
+        onCancel = onDismiss,
+        onAccept = onAccept
+    ) {
+        Column(modifier = Modifier.padding(horizontal = padding)) {
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(stringResource(R.string.prefs_bt_rotator_switch))
+                Switch(
+                    checked = rotatorState.value,
+                    onCheckedChange = { rotatorState.value = it }
+                )
+            }
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(6.dp),
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                OutlinedTextField(
+                    value = rotatorAddress.value,
+                    onValueChange = { rotatorAddress.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_bt_rotator_device_hint)) },
+                    modifier = Modifier.weight(1.5f),
+                    enabled = rotatorState.value
+                )
+                OutlinedTextField(
+                    value = rotatorFormat.value,
+                    onValueChange = { rotatorFormat.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_bt_rotator_output_hint)) },
+                    modifier = Modifier.weight(1f),
+                    enabled = rotatorState.value
+                )
+            }
+            Spacer(modifier = Modifier.height(6.dp))
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(stringResource(R.string.prefs_bt_frequency_switch))
+                Switch(
+                    checked = frequencyState.value,
+                    onCheckedChange = { frequencyState.value = it }
+                )
+            }
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(6.dp),
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                OutlinedTextField(
+                    value = frequencyAddress.value,
+                    onValueChange = { frequencyAddress.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_bt_frequency_device_hint)) },
+                    modifier = Modifier.weight(1.5f),
+                    enabled = frequencyState.value
+                )
+                OutlinedTextField(
+                    value = frequencyFormat.value,
+                    onValueChange = { frequencyFormat.value = it },
+                    singleLine = true,
+                    label = { Text(stringResource(R.string.prefs_bt_frequency_output_hint)) },
+                    modifier = Modifier.weight(1f),
+                    enabled = frequencyState.value
+                )
+            }
+        }
+    }
+}

feature/settings/src/main/java/com/rtbishop/look4sat/feature/settings/SettingsScreen.kt

@@ -0,0 +1,638 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.settings
+
+import android.Manifest
+import android.os.Build
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.compose.composable
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.presentation.CardButton
+import com.rtbishop.look4sat.core.presentation.IconCard
+import com.rtbishop.look4sat.core.presentation.MainTheme
+import com.rtbishop.look4sat.core.presentation.PrimaryIconCard
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.Screen
+import com.rtbishop.look4sat.core.presentation.ScreenColumn
+import com.rtbishop.look4sat.core.presentation.TopBar
+import com.rtbishop.look4sat.core.presentation.infiniteMarquee
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+fun NavGraphBuilder.settingsDestination() {
+    composable(Screen.Settings.route) {
+        val viewModel = viewModel(
+            modelClass = SettingsViewModel::class.java,
+            factory = SettingsViewModel.Factory
+        )
+        val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
+        SettingsScreen(uiState)
+    }
+}
+
+@Composable
+private fun SettingsScreen(uiState: SettingsState) {
+    val locationContract = ActivityResultContracts.RequestMultiplePermissions()
+    val locationError = stringResource(R.string.prefs_loc_gps_error)
+    val locationPermCoarse = Manifest.permission.ACCESS_COARSE_LOCATION
+    val locationPermFine = Manifest.permission.ACCESS_FINE_LOCATION
+    val locationRequest = rememberLauncherForActivityResult(locationContract) { permissions ->
+        when {
+            permissions[locationPermFine] == true -> uiState.sendAction(SettingsAction.SetGpsPosition)
+            permissions[locationPermCoarse] == true -> uiState.sendAction(SettingsAction.SetGpsPosition)
+            else -> uiState.sendSystemAction(SystemAction.ShowToast(locationError))
+        }
+    }
+    val contentContract = ActivityResultContracts.GetContent()
+    val contentRequestForTle = rememberLauncherForActivityResult(contentContract) { uri ->
+        uri?.let { uiState.sendAction(SettingsAction.UpdateTLEFromFile(uri.toString())) }
+    }
+    val contentRequestForTransceivers = rememberLauncherForActivityResult(contentContract) { uri ->
+        uri?.let { uiState.sendAction(SettingsAction.UpdateTransceiversFromFile(uri.toString())) }
+    }
+
+    // Position settings
+    val posSettings = uiState.positionSettings
+    val setGpsPos = { locationRequest.launch(arrayOf(locationPermCoarse, locationPermFine)) }
+    val setGeoPos = { lat: Double, lon: Double ->
+        uiState.sendAction(SettingsAction.SetGeoPosition(lat, lon))
+    }
+    val setQthPos = { locator: String ->
+        uiState.sendAction(SettingsAction.SetQthPosition(locator))
+    }
+    val dismissPos = { uiState.sendAction(SettingsAction.DismissPosMessages) }
+    val posDialogState = rememberSaveable { mutableStateOf(false) }
+    val showPosDialog = { posDialogState.value = posDialogState.value.not() }
+    if (posDialogState.value) {
+        PositionDialog(posSettings.stationPos.latitude, posSettings.stationPos.longitude, showPosDialog, setGeoPos)
+    }
+    val locDialogState = rememberSaveable { mutableStateOf(false) }
+    val showLocDialog = { locDialogState.value = locDialogState.value.not() }
+    if (locDialogState.value) {
+        LocatorDialog(posSettings.stationPos.qthLocator, showLocDialog, setQthPos)
+    }
+
+    // Data sources dialog
+    val dataSourcesDialogState = rememberSaveable { mutableStateOf(false) }
+    val showDataSourcesDialog = { dataSourcesDialogState.value = true }
+    val dismissDataSourcesDialog = { dataSourcesDialogState.value = false }
+    if (dataSourcesDialogState.value) {
+        DataSourcesDialog(
+            useCustomTle = uiState.dataSourcesSettings.useCustomTLE,
+            useCustomTransceivers = uiState.dataSourcesSettings.useCustomTransceivers,
+            tleUrl = uiState.dataSourcesSettings.tleUrl,
+            transceiversUrl = uiState.dataSourcesSettings.transceiversUrl,
+            onImportTle = { contentRequestForTle.launch("*/*") },
+            onImportTransceivers = { contentRequestForTransceivers.launch("*/*") },
+            onDismiss = dismissDataSourcesDialog,
+            onSave = {
+                useCustomTle, useCustomTransceivers, tleUrl, transceiversUrl  ->
+                if (!useCustomTle || tleUrl.isNotBlank()) {
+                    uiState.sendDataSourcesAction(DataSourcesAction.SetUseCustomTle(useCustomTle))
+                    uiState.sendDataSourcesAction(DataSourcesAction.SetTleUrl(tleUrl))
+                }
+                if (!useCustomTransceivers || transceiversUrl.isNotBlank()) {
+                    uiState.sendDataSourcesAction(DataSourcesAction.SetUseCustomTransceivers(useCustomTransceivers))
+                    uiState.sendDataSourcesAction(DataSourcesAction.SetTransceiversUrl(transceiversUrl))
+                }
+                if (useCustomTle || useCustomTransceivers) {
+                    uiState.sendAction(SettingsAction.UpdateFromWeb)
+                }
+            }
+        )
+    }
+
+    // Data settings
+    val dataSettings = uiState.dataSettings
+    val updateFromWeb: () -> Unit = { uiState.sendAction(SettingsAction.UpdateFromWeb) }
+    val clearAllData: () -> Unit = { uiState.sendAction(SettingsAction.ClearAllData) }
+
+    // RC settings
+    val rcSettings = uiState.rcSettings
+    val setRotatorState = { value: Boolean -> uiState.sendRCAction(RCAction.SetRotatorState(value)) }
+    val setRotatorAddress = { value: String -> uiState.sendRCAction(RCAction.SetRotatorAddress(value)) }
+    val setRotatorPort = { value: String -> uiState.sendRCAction(RCAction.SetRotatorPort(value)) }
+    val setRotatorFormat = { value: String -> uiState.sendRCAction(RCAction.SetRotatorFormat(value)) }
+    val setFrequencyState = { value: Boolean -> uiState.sendRCAction(RCAction.SetFrequencyState(value)) }
+    val setFrequencyAddress = { value: String -> uiState.sendRCAction(RCAction.SetFrequencyAddress(value)) }
+    val setFrequencyPort = { value: String -> uiState.sendRCAction(RCAction.SetFrequencyPort(value)) }
+    val setFrequencyFormat = { value: String -> uiState.sendRCAction(RCAction.SetFrequencyFormat(value)) }
+    val setBluetoothRotatorState = { value: Boolean -> uiState.sendRCAction(RCAction.SetBluetoothRotatorState(value)) }
+    val setBluetoothRotatorAddress = { value: String -> uiState.sendRCAction(RCAction.SetBluetoothRotatorAddress(value)) }
+    val setBluetoothRotatorFormat = { value: String -> uiState.sendRCAction(RCAction.SetBluetoothRotatorFormat(value)) }
+    val setBluetoothFrequencyState = { value: Boolean -> uiState.sendRCAction(RCAction.SetBluetoothFrequencyState(value)) }
+    val setBluetoothFrequencyAddress = { value: String -> uiState.sendRCAction(RCAction.SetBluetoothFrequencyAddress(value)) }
+    val setBluetoothFrequencyFormat = { value: String -> uiState.sendRCAction(RCAction.SetBluetoothFrequencyFormat(value)) }
+
+    // Network data output
+    val networkDialogState = rememberSaveable { mutableStateOf(false) }
+    val showNetworkDialog = { networkDialogState.value = true }
+    val dismissNetworkDialog = { networkDialogState.value = false }
+    if (networkDialogState.value) {
+        NetworkOutputDialog(
+            initialSettings = rcSettings,
+            onDismiss = dismissNetworkDialog,
+            onSave = { rotatorState,
+                       rotatorAddress,
+                       rotatorPort,
+                       rotatorFormat,
+                       frequencyState,
+                       frequencyAddress,
+                       frequencyPort,
+                       frequencyFormat ->
+                setRotatorState(rotatorState)
+                setRotatorAddress(rotatorAddress)
+                setRotatorPort(rotatorPort)
+                setRotatorFormat(rotatorFormat)
+                setFrequencyState(frequencyState)
+                setFrequencyAddress(frequencyAddress)
+                setFrequencyPort(frequencyPort)
+                setFrequencyFormat(frequencyFormat)
+            }
+        )
+    }
+
+    // Bluetooth data output
+    val bluetoothDialogState = rememberSaveable { mutableStateOf(false) }
+    val bluetoothContract = ActivityResultContracts.RequestPermission()
+    val bluetoothError = stringResource(R.string.prefs_bt_perm_error)
+    val bluetoothPerm = when {
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.S -> Manifest.permission.BLUETOOTH
+        else -> Manifest.permission.BLUETOOTH_CONNECT
+    }
+    val bluetoothRequest = rememberLauncherForActivityResult(bluetoothContract) { isGranted ->
+        if (!isGranted)
+        {
+            uiState.sendRCAction(RCAction.SetBluetoothRotatorState(false))
+            uiState.sendRCAction(RCAction.SetBluetoothFrequencyState(false))
+            uiState.sendSystemAction(SystemAction.ShowToast(bluetoothError))
+        }
+        else { bluetoothDialogState.value = true }
+    }
+    val showBluetoothDialog = { bluetoothRequest.launch(bluetoothPerm) }
+    val dismissBluetoothDialog = { bluetoothDialogState.value = false }
+    if (bluetoothDialogState.value) {
+        BluetoothOutputDialog(
+            initialSettings = rcSettings,
+            onDismiss = dismissBluetoothDialog,
+            onSave = { rotatorState,
+                       rotatorAddress,
+                       rotatorFormat,
+                       frequencyState,
+                       frequencyAddress,
+                       frequencyFormat ->
+                setBluetoothRotatorState(rotatorState)
+                setBluetoothRotatorAddress(rotatorAddress)
+                setBluetoothRotatorFormat(rotatorFormat)
+                setBluetoothFrequencyState(frequencyState)
+                setBluetoothFrequencyAddress(frequencyAddress)
+                setBluetoothFrequencyFormat(frequencyFormat)
+            }
+        )
+    }
+
+    // Other settings
+    val otherSettings = uiState.otherSettings
+    val toggleUtc = { value: Boolean -> uiState.sendAction(SettingsAction.ToggleUtc(value)) }
+    val toggleUpdate = { value: Boolean -> uiState.sendAction(SettingsAction.ToggleUpdate(value)) }
+    val toggleSweep = { value: Boolean -> uiState.sendAction(SettingsAction.ToggleSweep(value)) }
+    val toggleSensor = { value: Boolean -> uiState.sendAction(SettingsAction.ToggleSensor(value)) }
+    val uriHandler = LocalUriHandler.current
+    val appUrl = stringResource(R.string.prefs_app_url)
+    val donateUrl = stringResource(R.string.prefs_donate_url)
+    val fdroidTitle = stringResource(R.string.prefs_fdroid_title)
+    val fdroidUrl = stringResource(R.string.prefs_fdroid_url)
+    val gitHubTitle = stringResource(R.string.prefs_github_title)
+    val gitHubUrl = stringResource(R.string.prefs_github_url)
+    val licenseUrl = stringResource(R.string.prefs_license_url)
+    val privacyUrl = stringResource(R.string.prefs_privacy_url)
+
+    ScreenColumn(
+        topBar = { isVerticalLayout ->
+            if (isVerticalLayout) {
+                TopBar {
+                    TopCard(onClick = { uriHandler.openUri(appUrl) }, version = uiState.appVersionName, modifier = Modifier.weight(1f))
+                    PrimaryIconCard(onClick = { uriHandler.openUri(donateUrl) }, resId = R.drawable.ic_pound)
+                }
+                TopBar {
+                    Row(modifier = Modifier.weight(1f), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                        BotCard(onClick = { uriHandler.openUri(fdroidUrl) }, R.drawable.ic_fdroid, fdroidTitle, modifier = Modifier.weight(1f))
+                        BotCard(onClick = { uriHandler.openUri(gitHubUrl) }, R.drawable.ic_github, gitHubTitle, modifier = Modifier.weight(1f))
+                    }
+                    IconCard(action = { uriHandler.openUri(licenseUrl) }, resId = R.drawable.ic_license)
+                    IconCard(action = { uriHandler.openUri(privacyUrl) }, resId = R.drawable.ic_policy)
+                }
+            } else {
+                TopBar {
+                    PrimaryIconCard(onClick = { uriHandler.openUri(donateUrl) }, resId = R.drawable.ic_pound)
+                    TopCard(onClick = { uriHandler.openUri(appUrl) }, version = uiState.appVersionName, modifier = Modifier.weight(1f))
+                    Row(modifier = Modifier.weight(1f), horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                        BotCard(onClick = { uriHandler.openUri(fdroidUrl) }, R.drawable.ic_fdroid, fdroidTitle, modifier = Modifier.weight(1f))
+                        BotCard(onClick = { uriHandler.openUri(gitHubUrl) }, R.drawable.ic_github, gitHubTitle, modifier = Modifier.weight(1f))
+                    }
+                    IconCard(action = { uriHandler.openUri(licenseUrl) }, resId = R.drawable.ic_license)
+                    IconCard(action = { uriHandler.openUri(privacyUrl) }, resId = R.drawable.ic_policy)
+                }
+            }
+        }
+    ) { _ ->
+        LazyVerticalGrid(
+            columns = GridCells.Adaptive(320.dp),
+            horizontalArrangement = Arrangement.spacedBy(6.dp),
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+            modifier = Modifier.clip(MaterialTheme.shapes.medium)
+        ) {
+            item {
+                LocationCard(posSettings, setGpsPos, showPosDialog, showLocDialog, dismissPos, uiState.sendSystemAction)
+            }
+            item { DataCard(dataSettings, updateFromWeb, clearAllData, showDataSourcesDialog) }
+            item(span = { GridItemSpan(maxLineSpan) }) { OutputCard({ showNetworkDialog() }, { showBluetoothDialog() }) }
+            item { OtherCard(otherSettings, toggleUtc, toggleUpdate, toggleSweep, toggleSensor) }
+            item { CardCredits() }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun LocationCardPreview() = MainTheme {
+    val stationPos = GeoPos(0.0, 0.0, 0.0, "IO91vl", 0L)
+    val settings = PositionSettings(true, stationPos, 0)
+    LocationCard(settings = settings, setGpsPos = {}, showPosDialog = {}, {}, {}) {}
+}
+
+@Composable
+private fun LocationCard(
+    settings: PositionSettings,
+    setGpsPos: () -> Unit,
+    showPosDialog: () -> Unit,
+    showLocDialog: () -> Unit,
+    dismissPosMessage: () -> Unit,
+    sendSystemAction: (SystemAction) -> Unit
+) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
+        ) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    text = stringResource(id = R.string.prefs_loc_title),
+                    color = MaterialTheme.colorScheme.primary
+                )
+                UpdateIndicator(isUpdating = settings.isUpdating, Modifier.weight(1f))
+            }
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(text = setUpdateTime(updateTime = settings.stationPos.timestamp))
+            Spacer(modifier = Modifier.height(2.dp))
+            Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
+                Text(text = "Lat: ${settings.stationPos.latitude}°")
+                Text(text = "Lon: ${settings.stationPos.longitude}°")
+                Text(text = "Qth: ${settings.stationPos.qthLocator}")
+            }
+            Spacer(modifier = Modifier.height(1.dp))
+            Row(horizontalArrangement = Arrangement.SpaceEvenly) {
+                CardButton(
+                    onClick = setGpsPos,
+                    text = stringResource(id = R.string.prefs_loc_gps_title),
+                    modifier = Modifier.weight(1f)
+                )
+                Spacer(modifier = Modifier.width(6.dp))
+                CardButton(
+                    onClick = showPosDialog,
+                    text = stringResource(id = R.string.prefs_loc_input_title),
+                    modifier = Modifier.weight(1f)
+                )
+                Spacer(modifier = Modifier.width(6.dp))
+                CardButton(
+                    onClick = showLocDialog,
+                    text = stringResource(id = R.string.prefs_loc_qth_title),
+                    modifier = Modifier.weight(1f)
+                )
+            }
+        }
+    }
+    if (settings.messageResId != 0) {
+        val errorString = stringResource(id = settings.messageResId)
+        LaunchedEffect(key1 = settings.messageResId) {
+            sendSystemAction(SystemAction.ShowToast(errorString))
+            dismissPosMessage()
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun DataCardPreview() = MainTheme {
+    val settings = DataSettings(true, 5000, 2500, 0L)
+    DataCard(settings = settings, {}, {}, {})
+}
+
+@Composable
+private fun DataCard(
+    settings: DataSettings,
+    updateFromWeb: () -> Unit,
+    clearAllData: () -> Unit,
+    showDataSourcesDialog: () -> Unit
+) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
+        ) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    text = stringResource(id = R.string.prefs_data_title),
+                    color = MaterialTheme.colorScheme.primary
+                )
+                UpdateIndicator(isUpdating = settings.isUpdating, Modifier.weight(1f))
+            }
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(text = setUpdateTime(updateTime = settings.timestamp))
+            Spacer(modifier = Modifier.height(2.dp))
+            Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
+                Text(text = stringResource(R.string.prefs_data_entries, settings.entriesTotal))
+                Text(text = stringResource(R.string.prefs_data_radios, settings.radiosTotal))
+            }
+            Spacer(modifier = Modifier.height(1.dp))
+            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                CardButton(
+                    onClick = updateFromWeb,
+                    text = stringResource(id = R.string.prefs_data_update),
+                    modifier = Modifier.weight(1f)
+                )
+                CardButton(
+                    onClick = showDataSourcesDialog,
+                    text = stringResource(id = R.string.prefs_data_import),
+                    modifier = Modifier.weight(1f)
+                )
+                CardButton(
+                    onClick = clearAllData,
+                    text = stringResource(id = R.string.prefs_data_clear),
+                    modifier = Modifier.weight(1f)
+                )
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun OutputCardPreview() = MainTheme { OutputCard({}, {}) }
+
+@Composable
+private fun OutputCard(
+    onNetworkClick: () -> Unit,
+    onBluetoothClick: () -> Unit
+) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
+            Text(
+                text = stringResource(id = R.string.prefs_data_output_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                CardButton(
+                    onClick = onNetworkClick,
+                    text = stringResource(id = R.string.prefs_net_output),
+                    modifier = Modifier.weight(1f)
+                )
+                CardButton(
+                    onClick = onBluetoothClick,
+                    text = stringResource(id = R.string.prefs_bt_output),
+                    modifier = Modifier.weight(1f)
+                )
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun OtherCardPreview() = MainTheme {
+    val values = OtherSettings(
+        stateOfAutoUpdate = true,
+        stateOfSensors = true,
+        stateOfSweep = true,
+        stateOfUtc = false,
+        stateOfLightTheme = false,
+        shouldSeeWarning = false,
+        shouldSeeWhatsNew = false
+    )
+    OtherCard(settings = values, {}, {}, {}, {})
+}
+
+@Composable
+private fun OtherCard(
+    settings: OtherSettings,
+    toggleUtc: (Boolean) -> Unit,
+    toggleUpdate: (Boolean) -> Unit,
+    toggleSweep: (Boolean) -> Unit,
+    toggleSensor: (Boolean) -> Unit
+) {
+    ElevatedCard(
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(220.dp)
+    ) {
+        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
+            Text(
+                text = stringResource(id = R.string.prefs_other_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(text = stringResource(id = R.string.prefs_other_switch_utc))
+                Switch(checked = settings.stateOfUtc, onCheckedChange = { toggleUtc(it) })
+            }
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(text = stringResource(id = R.string.prefs_other_switch_update))
+                Switch(checked = settings.stateOfAutoUpdate, onCheckedChange = { toggleUpdate(it) })
+            }
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(text = stringResource(id = R.string.prefs_other_switch_sweep))
+                Switch(checked = settings.stateOfSweep, onCheckedChange = { toggleSweep(it) })
+            }
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(text = stringResource(id = R.string.prefs_other_switch_sensors))
+                Switch(checked = settings.stateOfSensors, onCheckedChange = { toggleSensor(it) })
+            }
+        }
+    }
+}
+
+@Composable
+private fun setUpdateTime(updateTime: Long): String {
+    val updateDate = if (updateTime != 0L) {
+        val timePattern = stringResource(id = R.string.prefs_updated_time)
+        SimpleDateFormat(timePattern, Locale.getDefault()).format(Date(updateTime))
+    } else {
+        stringResource(id = R.string.pass_time_placeholder)
+    }
+    return stringResource(id = R.string.prefs_updated_title, updateDate)
+}
+
+@Composable
+private fun UpdateIndicator(isUpdating: Boolean, modifier: Modifier = Modifier) = if (isUpdating) {
+    LinearProgressIndicator(modifier = modifier.padding(start = 6.dp))
+} else {
+    LinearProgressIndicator(
+        progress = { 0f },
+        drawStopIndicator = {},
+        modifier = modifier.padding(start = 6.dp)
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun CardCreditsPreview() = MainTheme { CardCredits() }
+
+@Composable
+private fun CardCredits(modifier: Modifier = Modifier) {
+    ElevatedCard(
+        modifier = modifier
+            .fillMaxWidth()
+            .height(220.dp)
+    ) {
+        Column(
+            verticalArrangement = Arrangement.SpaceBetween,
+            modifier = Modifier
+                .padding(horizontal = 8.dp, vertical = 4.dp)
+                .fillMaxHeight()
+        ) {
+            Text(
+                text = stringResource(id = R.string.prefs_outro_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Text(
+                text = stringResource(id = R.string.prefs_outro_thanks)
+            )
+            Text(
+                text = stringResource(id = R.string.prefs_outro_license),
+                color = MaterialTheme.colorScheme.primary
+            )
+        }
+    }
+}
+
+@Composable
+private fun TopCard(onClick: () -> Unit, modifier: Modifier = Modifier, version: String) {
+    ElevatedCard(modifier = modifier) {
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .height(48.dp)
+                .clickable { onClick() }) {
+            Spacer(Modifier)
+            Icon(
+                painter = painterResource(id = R.drawable.ic_satellites),
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.primary
+            )
+            Text(
+                text = stringResource(R.string.prefs_app_title, version),
+                fontSize = 24.sp,
+                fontWeight = FontWeight.Medium,
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(end = 6.dp)
+                    .infiniteMarquee()
+            )
+        }
+    }
+}
+
+@Composable
+private fun BotCard(onClick: () -> Unit, resId: Int, text: String, modifier: Modifier = Modifier) {
+    ElevatedCard(modifier = modifier) {
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .height(48.dp)
+                .clickable { onClick() }) {
+            Spacer(Modifier)
+            Icon(painter = painterResource(id = resId), contentDescription = null)
+            Text(
+                text = text,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Medium,
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(end = 6.dp)
+                    .infiniteMarquee()
+            )
+        }
+    }
+}

feature/settings/src/main/java/com/rtbishop/look4sat/feature/settings/SettingsState.kt

@@ -0,0 +1,93 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.settings
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+
+data class PositionSettings(
+    val isUpdating: Boolean, val stationPos: GeoPos, val messageResId: Int
+)
+
+data class DataSettings(
+    val isUpdating: Boolean, val entriesTotal: Int, val radiosTotal: Int, val timestamp: Long
+)
+
+data class SettingsState(
+    val nextPass: OrbitalPass,
+    val nextTime: String,
+    val isNextTimeAos: Boolean,
+    val appVersionName: String,
+    val positionSettings: PositionSettings,
+    val dataSettings: DataSettings,
+    val otherSettings: OtherSettings,
+    val rcSettings: RCSettings,
+    val dataSourcesSettings: DataSourcesSettings,
+    val sendAction: (SettingsAction) -> Unit,
+    val sendRCAction: (RCAction) -> Unit,
+    val sendSystemAction: (SystemAction) -> Unit,
+    val sendDataSourcesAction: (DataSourcesAction) -> Unit
+)
+
+sealed class SettingsAction {
+    data object SetGpsPosition : SettingsAction()
+    data class SetGeoPosition(val latitude: Double, val longitude: Double) : SettingsAction()
+    data class SetQthPosition(val locator: String) : SettingsAction()
+    data object DismissPosMessages : SettingsAction()
+    data object UpdateFromWeb : SettingsAction()
+    data class UpdateTLEFromFile(val uri: String) : SettingsAction()
+    data class UpdateTransceiversFromFile(val uri: String) : SettingsAction()
+    data object ClearAllData : SettingsAction()
+    data class ToggleUtc(val value: Boolean) : SettingsAction()
+    data class ToggleUpdate(val value: Boolean) : SettingsAction()
+    data class ToggleSweep(val value: Boolean) : SettingsAction()
+    data class ToggleSensor(val value: Boolean) : SettingsAction()
+    data class ToggleLightTheme(val value: Boolean) : SettingsAction()
+}
+
+sealed class SystemAction {
+    data class ShowToast(val message: String) : SystemAction()
+}
+
+sealed class RCAction {
+    data class SetRotatorState(val value: Boolean) : RCAction()
+    data class SetRotatorAddress(val value: String) : RCAction()
+    data class SetRotatorPort(val value: String) : RCAction()
+    data class SetRotatorFormat(val value: String) : RCAction()
+    data class SetFrequencyState(val value: Boolean) : RCAction()
+    data class SetFrequencyAddress(val value: String) : RCAction()
+    data class SetFrequencyPort(val value: String) : RCAction()
+    data class SetFrequencyFormat(val value: String) : RCAction()
+    data class SetBluetoothRotatorState(val value: Boolean) : RCAction()
+    data class SetBluetoothRotatorFormat(val value: String) : RCAction()
+    data class SetBluetoothRotatorName(val value: String) : RCAction()
+    data class SetBluetoothRotatorAddress(val value: String) : RCAction()
+    data class SetBluetoothFrequencyState(val value: Boolean) : RCAction()
+    data class SetBluetoothFrequencyFormat(val value: String) : RCAction()
+    data class SetBluetoothFrequencyAddress(val value: String) : RCAction()
+}
+
+sealed class DataSourcesAction {
+    data class SetUseCustomTle(val value: Boolean) : DataSourcesAction()
+    data class SetUseCustomTransceivers(val value: Boolean) : DataSourcesAction()
+    data class SetTleUrl(val value: String) : DataSourcesAction()
+    data class SetTransceiversUrl(val value: String) : DataSourcesAction()
+}

feature/settings/src/main/java/com/rtbishop/look4sat/feature/settings/SettingsViewModel.kt

@@ -0,0 +1,304 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.settings
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.usecase.IShowToast
+import com.rtbishop.look4sat.core.domain.utility.toTimerString
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.getDefaultPass
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+class SettingsViewModel(
+    private val databaseRepo: IDatabaseRepo,
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo,
+    private val showToast: IShowToast
+) : ViewModel() {
+
+    private val defaultPosSettings = PositionSettings(false, settingsRepo.stationPosition.value, 0)
+    private val defaultDataSettings = DataSettings(false, 0, 0, 0L)
+    private val defaultDataSourcesSettings = DataSourcesSettings(
+        useCustomTLE = false,
+        useCustomTransceivers = false,
+        tleUrl = settingsRepo.dataSourcesSettings.value.tleUrl,
+        transceiversUrl = settingsRepo.dataSourcesSettings.value.transceiversUrl
+    )
+    private val _uiState = MutableStateFlow(
+        SettingsState(
+            nextTime = "00:00:00",
+            isNextTimeAos = true,
+            nextPass = getDefaultPass(),
+            appVersionName = settingsRepo.appVersionName,
+            positionSettings = defaultPosSettings,
+            dataSettings = defaultDataSettings,
+            otherSettings = settingsRepo.otherSettings.value,
+            rcSettings = settingsRepo.rcSettings.value,
+            dataSourcesSettings = defaultDataSourcesSettings,
+            sendAction = ::handleAction,
+            sendRCAction = ::handleAction,
+            sendSystemAction = ::handleAction,
+            sendDataSourcesAction = ::handleAction
+        )
+    )
+    private var processing: Job? = null
+
+    val uiState: StateFlow<SettingsState> = _uiState
+
+    init {
+        viewModelScope.launch {
+            satelliteRepo.passes.collectLatest { passes ->
+                processing?.cancelAndJoin()
+                processing = viewModelScope.launch {
+                    while (isActive) {
+                        val timeNow = System.currentTimeMillis()
+                        val newPasses = satelliteRepo.processPasses(passes, timeNow)
+                        setPassInfo(newPasses, timeNow)
+                        delay(1000)
+                    }
+                }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.stationPosition.collect { geoPos ->
+                val newPosSettings = _uiState.value.positionSettings.copy(
+                    isUpdating = false, stationPos = geoPos
+                )
+                _uiState.update { it.copy(positionSettings = newPosSettings) }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.databaseState.collect { state ->
+                val newDataSettings = _uiState.value.dataSettings.copy(
+                    isUpdating = false,
+                    entriesTotal = state.numberOfSatellites,
+                    radiosTotal = state.numberOfRadios,
+                    timestamp = state.updateTimestamp
+                )
+                _uiState.update { it.copy(dataSettings = newDataSettings) }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.rcSettings.collect { settings ->
+                _uiState.update { it.copy(rcSettings = settings) }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.otherSettings.collect { settings ->
+                _uiState.update { it.copy(otherSettings = settings) }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.dataSourcesSettings.collect { settings ->
+                _uiState.update { it.copy(dataSourcesSettings = settings) }
+            }
+        }
+    }
+
+    private fun handleAction(action: SettingsAction) {
+        when (action) {
+            SettingsAction.SetGpsPosition -> setGpsPosition()
+            is SettingsAction.SetGeoPosition -> setGeoPosition(action.latitude, action.longitude)
+            is SettingsAction.SetQthPosition -> setQthPosition(action.locator)
+            SettingsAction.DismissPosMessages -> dismissPosMessage()
+            SettingsAction.UpdateFromWeb -> updateFromWeb()
+            is SettingsAction.UpdateTLEFromFile -> updateTLEFromFile(action.uri)
+            is SettingsAction.UpdateTransceiversFromFile -> updateTransceiversFromFile(action.uri)
+            SettingsAction.ClearAllData -> clearAllData()
+            is SettingsAction.ToggleUtc -> settingsRepo.setStateOfUtc(action.value)
+            is SettingsAction.ToggleUpdate -> settingsRepo.setStateOfAutoUpdate(action.value)
+            is SettingsAction.ToggleSweep -> settingsRepo.setStateOfSweep(action.value)
+            is SettingsAction.ToggleSensor -> settingsRepo.setStateOfSensors(action.value)
+            is SettingsAction.ToggleLightTheme -> settingsRepo.setStateOfLightTheme(action.value)
+        }
+    }
+
+    private fun handleAction(action: RCAction) {
+        when (action) {
+            is RCAction.SetRotatorState -> settingsRepo.setRotatorState(action.value)
+            is RCAction.SetRotatorAddress -> settingsRepo.setRotatorAddress(action.value)
+            is RCAction.SetRotatorPort -> settingsRepo.setRotatorPort(action.value)
+            is RCAction.SetRotatorFormat -> settingsRepo.setRotatorFormat(action.value)
+            is RCAction.SetFrequencyState -> settingsRepo.setFrequencyState(action.value)
+            is RCAction.SetFrequencyAddress -> settingsRepo.setFrequencyAddress(action.value)
+            is RCAction.SetFrequencyPort -> settingsRepo.setFrequencyPort(action.value)
+            is RCAction.SetFrequencyFormat -> settingsRepo.setFrequencyFormat(action.value)
+            is RCAction.SetBluetoothRotatorState -> settingsRepo.setBluetoothRotatorState(action.value)
+            is RCAction.SetBluetoothRotatorAddress -> settingsRepo.setBluetoothRotatorAddress(action.value)
+            is RCAction.SetBluetoothRotatorFormat -> settingsRepo.setBluetoothRotatorFormat(action.value)
+            is RCAction.SetBluetoothRotatorName -> settingsRepo.setBluetoothRotatorName(action.value)
+            is RCAction.SetBluetoothFrequencyState -> settingsRepo.setBluetoothFrequencyState(action.value)
+            is RCAction.SetBluetoothFrequencyFormat -> settingsRepo.setBluetoothFrequencyFormat(action.value)
+            is RCAction.SetBluetoothFrequencyAddress -> settingsRepo.setBluetoothFrequencyAddress(action.value)
+        }
+    }
+
+    private fun handleAction(action: SystemAction) {
+        when (action) {
+            is SystemAction.ShowToast -> showToast(action.message)
+        }
+    }
+
+    private fun handleAction(action: DataSourcesAction) {
+        when (action) {
+            is DataSourcesAction.SetUseCustomTle ->  settingsRepo.setUseCustomTle(action.value)
+            is DataSourcesAction.SetUseCustomTransceivers ->  settingsRepo.setUseCustomTransceivers(action.value)
+            is DataSourcesAction.SetTleUrl -> settingsRepo.setTleUrl(action.value)
+            is DataSourcesAction.SetTransceiversUrl -> settingsRepo.setTransceiversUrl(action.value)
+        }
+    }
+
+    private fun setGpsPosition() {
+        if (settingsRepo.setStationPosition()) {
+            val messageResId = R.string.prefs_loc_success
+            val newPosSettings = _uiState.value.positionSettings.copy(
+                isUpdating = true, messageResId = messageResId
+            )
+            _uiState.update { it.copy(positionSettings = newPosSettings) }
+        } else {
+            val errorResId = R.string.prefs_loc_gps_error
+            val newPosSettings = _uiState.value.positionSettings.copy(
+                isUpdating = false, messageResId = errorResId
+            )
+            _uiState.update { it.copy(positionSettings = newPosSettings) }
+        }
+    }
+
+    private fun setGeoPosition(latitude: Double, longitude: Double) {
+        if (settingsRepo.setStationPosition(latitude, longitude, 0.0)) {
+            val messageResId = R.string.prefs_loc_success
+            val newPosSettings = _uiState.value.positionSettings.copy(
+                isUpdating = false, messageResId = messageResId
+            )
+            _uiState.update { it.copy(positionSettings = newPosSettings) }
+        } else {
+            val errorResId = R.string.prefs_loc_input_error
+            val newPosSettings = _uiState.value.positionSettings.copy(
+                isUpdating = false, messageResId = errorResId
+            )
+            _uiState.update { it.copy(positionSettings = newPosSettings) }
+        }
+    }
+
+    private fun setQthPosition(locator: String) {
+        if (settingsRepo.setStationPosition(locator)) {
+            val messageResId = R.string.prefs_loc_success
+            val newPosSettings = _uiState.value.positionSettings.copy(
+                isUpdating = false, messageResId = messageResId
+            )
+            _uiState.update { it.copy(positionSettings = newPosSettings) }
+        } else {
+            val errorResId = R.string.prefs_loc_qth_error
+            val newPosSettings = _uiState.value.positionSettings.copy(
+                isUpdating = false, messageResId = errorResId
+            )
+            _uiState.update { it.copy(positionSettings = newPosSettings) }
+        }
+    }
+
+    private fun dismissPosMessage() {
+        val newPosSettings = _uiState.value.positionSettings.copy(
+            isUpdating = false, messageResId = 0
+        )
+        _uiState.update { it.copy(positionSettings = newPosSettings) }
+    }
+
+    private fun updateFromWeb() = viewModelScope.launch {
+        try {
+            val newDataSettings = _uiState.value.dataSettings.copy(isUpdating = true)
+            _uiState.update { it.copy(dataSettings = newDataSettings) }
+            databaseRepo.updateFromRemote()
+        } catch (exception: Exception) {
+            val newDataSettings = _uiState.value.dataSettings.copy(isUpdating = false)
+            _uiState.update { it.copy(dataSettings = newDataSettings) }
+            println(exception)
+        }
+    }
+
+    private fun updateTLEFromFile(uri: String) = viewModelScope.launch {
+        try {
+            val newDataSettings = _uiState.value.dataSettings.copy(isUpdating = true)
+            _uiState.update { it.copy(dataSettings = newDataSettings) }
+            databaseRepo.updateTLEFromFile(uri)
+        } catch (exception: Exception) {
+            val newDataSettings = _uiState.value.dataSettings.copy(isUpdating = false)
+            _uiState.update { it.copy(dataSettings = newDataSettings) }
+            println(exception)
+        }
+    }
+
+    private fun updateTransceiversFromFile(uri: String) = viewModelScope.launch {
+        try {
+            val newDataSettings = _uiState.value.dataSettings.copy(isUpdating = true)
+            _uiState.update { it.copy(dataSettings = newDataSettings) }
+            databaseRepo.updateTransceiversFromFile(uri)
+        } catch (exception: Exception) {
+            val newDataSettings = _uiState.value.dataSettings.copy(isUpdating = false)
+            _uiState.update { it.copy(dataSettings = newDataSettings) }
+            println(exception)
+        }
+    }
+
+    private fun setPassInfo(passes: List<OrbitalPass>, timeNow: Long) {
+        if (passes.isEmpty()) return
+        try {
+            val nextPass = passes.first { it.aosTime.minus(timeNow) > 0 }
+            val time = nextPass.aosTime.minus(timeNow).toTimerString()
+            _uiState.update { it.copy(nextPass = nextPass, nextTime = time, isNextTimeAos = true) }
+        } catch (_: NoSuchElementException) {
+            val lastPass = passes.last()
+            val time = lastPass.losTime.minus(timeNow).toTimerString()
+            _uiState.update { it.copy(nextPass = lastPass, nextTime = time, isNextTimeAos = false) }
+        }
+    }
+
+    private fun clearAllData() = viewModelScope.launch { databaseRepo.clearAllData() }
+
+    companion object {
+        val Factory: ViewModelProvider.Factory = viewModelFactory {
+            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
+            initializer {
+                val container = (this[applicationKey] as IContainerProvider).getMainContainer()
+                SettingsViewModel(
+                    container.databaseRepo,
+                    container.satelliteRepo,
+                    container.settingsRepo,
+                    container.provideShowToast()
+                )
+            }
+        }
+    }
+}