v4.1.1 - Fixes for landscape/split screen issues, by londre7

app/build.gradle.kts

@@ -1,50 +1,3 @@
 plugins {
-    alias(libs.plugins.android.application)
-    alias(libs.plugins.compose.compiler)
-}
-
-kotlin {
-    jvmToolchain(17)
-}
-
-android {
-    namespace = "com.rtbishop.look4sat"
-    compileSdk = 36
-    defaultConfig {
-        applicationId = "com.rtbishop.look4sat"
-        minSdk = 24
-        versionCode = 410
-        versionName = "4.1.0"
-    }
-    buildFeatures {
-        compose = true
-    }
-    buildTypes {
-        debug {
-            applicationIdSuffix = ".debug"
-        }
-        release {
-            isMinifyEnabled = true
-            isShrinkResources = true
-            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
-        }
-    }
-    androidResources {
-        generateLocaleConfig = true
-        localeFilters.addAll(listOf("en", "es", "ru", "si", "uk", "zh"))
-    }
-}
-
-dependencies {
-    implementation(project(":data"))
-    implementation(project(":domain"))
-
-    implementation(libs.androidx.core.splashscreen)
-    implementation(platform(libs.compose.bom))
-    implementation(libs.bundles.composeAll)
-    implementation(libs.other.osmdroid)
-
-    debugImplementation(libs.bundles.composeDebug)
-    testImplementation(libs.bundles.unitTest)
-    androidTestImplementation(libs.bundles.androidTest)
+    alias(libs.plugins.convention.androidAppPlugin)
 }

app/src/main/java/com/rtbishop/look4sat/MainActivity.kt

@@ -24,8 +24,7 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
-import com.rtbishop.look4sat.presentation.MainScreen
-import com.rtbishop.look4sat.presentation.MainTheme
+import com.rtbishop.look4sat.core.presentation.MainTheme
 
 class MainActivity : ComponentActivity() {
 

app/src/main/java/com/rtbishop/look4sat/MainApplication.kt

@@ -18,15 +18,19 @@
 package com.rtbishop.look4sat
 
 import android.app.Application
-import com.rtbishop.look4sat.data.injection.MainContainer
+import com.rtbishop.look4sat.core.data.injection.MainContainer
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+import kotlinx.coroutines.launch
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
-import kotlinx.coroutines.launch
 
-class MainApplication : Application() {
+class MainApplication : Application(), IContainerProvider {
 
-    lateinit var container: MainContainer
+    private lateinit var container: IMainContainer
+
+    override fun getMainContainer(): IMainContainer = container
 
     override fun onCreate() {
         super.onCreate()

app/src/main/java/com/rtbishop/look4sat/MainScreen.kt

@@ -0,0 +1,90 @@
+/*
+ * 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
+
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteDefaults
+import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold
+import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteType
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.currentBackStackEntryAsState
+import androidx.navigation.compose.rememberNavController
+import com.rtbishop.look4sat.core.presentation.Screen
+import com.rtbishop.look4sat.core.presentation.hasEnoughHeight
+import com.rtbishop.look4sat.core.presentation.hasEnoughWidth
+import com.rtbishop.look4sat.feature.map.mapDestination
+import com.rtbishop.look4sat.feature.passes.passesDestination
+import com.rtbishop.look4sat.feature.radar.radarDestination
+import com.rtbishop.look4sat.feature.satellites.satellitesDestination
+import com.rtbishop.look4sat.feature.settings.settingsDestination
+
+@Composable
+fun MainScreen(navController: NavHostController = rememberNavController()) {
+    val items = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Map, Screen.Settings)
+    val currentDestination = navController.currentBackStackEntryAsState().value?.destination?.route
+    val startDestination = Screen.Passes.route
+    NavigationSuiteScaffold(
+        navigationSuiteItems = {
+            items.forEach {
+                item(
+                    icon = { Icon(painterResource(it.iconResId), stringResource(it.titleResId)) },
+                    label = { Text(stringResource(it.titleResId)) },
+                    selected = currentDestination?.contains(it.route) ?: false,
+                    onClick = {
+                        if (currentDestination?.contains(it.route) ?: false) return@item
+                        navController.navigate(it.route) {
+                            popUpTo(startDestination) { saveState = false }
+                            launchSingleTop = true
+                            restoreState = false
+                        }
+                    })
+            }
+        }, navigationSuiteColors = NavigationSuiteDefaults.colors(
+            navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
+        ), layoutType = when {
+            !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
+            !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
+            else -> NavigationSuiteType.ShortNavigationBarMedium
+        }
+    ) {
+        NavHost(
+            navController = navController,
+            startDestination = startDestination,
+            enterTransition =  { fadeIn(animationSpec = tween(350)) },
+            exitTransition = { fadeOut(animationSpec = tween(350)) }
+        ) {
+            satellitesDestination { navController.navigateUp() }
+            passesDestination { catNum: Int, aosTime: Long ->
+                val radarRoute = "${Screen.Radar.route}?catNum=${catNum}&aosTime=${aosTime}"
+                navController.navigate(radarRoute)
+            }
+            radarDestination { navController.navigateUp() }
+            mapDestination()
+            settingsDestination()
+        }
+    }
+}

app/src/main/java/com/rtbishop/look4sat/presentation/MainScreen.kt

@@ -1,98 +0,0 @@
-/*
- * 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.presentation
-
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteDefaults
-import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold
-import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteType
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavHostController
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.currentBackStackEntryAsState
-import androidx.navigation.compose.rememberNavController
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.presentation.common.hasEnoughHeight
-import com.rtbishop.look4sat.presentation.common.hasEnoughWidth
-import com.rtbishop.look4sat.presentation.map.mapDestination
-import com.rtbishop.look4sat.presentation.passes.passesDestination
-import com.rtbishop.look4sat.presentation.radar.radarDestination
-import com.rtbishop.look4sat.presentation.satellites.satellitesDestination
-import com.rtbishop.look4sat.presentation.settings.settingsDestination
-
-sealed class Screen(val route: String, val iconResId: Int, val titleResId: Int) {
-    data object Satellites : Screen("satellites", R.drawable.ic_satellites, R.string.nav_sat)
-    data object Passes : Screen("passes", R.drawable.ic_passes, R.string.nav_pass)
-    data object Radar : Screen("radar", R.drawable.ic_radar, R.string.nav_radar)
-    data object Map : Screen("map", R.drawable.ic_map, R.string.nav_map)
-    data object Settings : Screen("settings", R.drawable.ic_settings, R.string.nav_prefs)
-}
-
-@Composable
-fun MainScreen(navController: NavHostController = rememberNavController()) {
-    val items = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Map, Screen.Settings)
-    val currentDestination = navController.currentBackStackEntryAsState().value?.destination?.route
-    val startDestination = Screen.Passes.route
-    NavigationSuiteScaffold(
-        navigationSuiteItems = {
-            items.forEach {
-                item(
-                    icon = { Icon(painterResource(it.iconResId), stringResource(it.titleResId)) },
-                    label = { Text(stringResource(it.titleResId)) },
-                    selected = currentDestination?.contains(it.route) ?: false,
-                    onClick = {
-                        if (currentDestination?.contains(it.route) ?: false) return@item
-                        navController.navigate(it.route) {
-                            popUpTo(startDestination) { saveState = false }
-                            launchSingleTop = true
-                            restoreState = false
-                        }
-                    })
-            }
-        }, navigationSuiteColors = NavigationSuiteDefaults.colors(
-            navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
-        ), layoutType = when {
-            !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
-            !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
-            else -> NavigationSuiteType.ShortNavigationBarMedium
-        }
-    ) {
-        NavHost(
-            navController = navController,
-            startDestination = startDestination,
-            enterTransition =  { fadeIn(animationSpec = tween(350)) },
-            exitTransition = { fadeOut(animationSpec = tween(350)) }
-        ) {
-            satellitesDestination { navController.navigateUp() }
-            passesDestination { catNum: Int, aosTime: Long ->
-                val radarRoute = "${Screen.Radar.route}?catNum=${catNum}&aosTime=${aosTime}"
-                navController.navigate(radarRoute)
-            }
-            radarDestination { navController.navigateUp() }
-            mapDestination()
-            settingsDestination()
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/MainTheme.kt

@@ -1,161 +0,0 @@
-/*
- * 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.presentation
-
-import android.os.Build
-import androidx.activity.ComponentActivity
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Shapes
-import androidx.compose.material3.Typography
-import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.lightColorScheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalView
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.core.view.WindowCompat
-
-val LocalSpacing = compositionLocalOf { Spacing }
-
-data object Spacing {
-    val extraExtraSmall = 4.dp
-    val extraSmall = 6.dp
-    val small = 8.dp
-    val medium = 12.dp
-    val large = 16.dp
-    val extraLarge = 24.dp
-}
-
-@Composable
-fun MainTheme(isDarkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
-    val view = LocalView.current
-    if (view.isInEditMode) {
-        MaterialTheme(darkScheme, shapes, typography, content)
-    } else {
-        CompositionLocalProvider(LocalSpacing provides Spacing) {
-            val colorScheme = if (isDarkTheme) darkScheme else lightScheme
-            SideEffect {
-                val window = (view.context as ComponentActivity).window
-                val insetsController = WindowCompat.getInsetsController(window, view)
-                insetsController.isAppearanceLightStatusBars = false
-                insetsController.isAppearanceLightNavigationBars = false
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                    window.isNavigationBarContrastEnforced = false
-                }
-            }
-            MaterialTheme(colorScheme, shapes, typography, content)
-        }
-    }
-}
-
-private val lightScheme = lightColorScheme(
-    primary = Color(0xFF715C0C),
-    onPrimary = Color(0xFFFFFFFF),
-    secondary = Color(0xFF685E40),
-    onSecondary = Color(0xFFFFFFFF),
-    secondaryContainer = Color(0xFFF1E1BB),
-    onSecondaryContainer = Color(0xFF221B04),
-    background = Color(0xFFFFF8F0),
-    onBackground = Color(0xFF1E1B13),
-    surface = Color(0xFFFFF8F0),
-    onSurface = Color(0xFF1E1B13),
-    surfaceTint = Color(0x00000000),
-    surfaceVariant = Color(0xFFEBE2CF),
-    onSurfaceVariant = Color(0xFF4C4639),
-    error = Color(0xFFDC0000),
-    outline = Color(0xFF7D7667),
-    scrim = Color(0xFF000000)
-)
-
-private val darkScheme = darkColorScheme(
-    primary = Color(0xFFFFE082), // main accent, switch background, active progress
-    onPrimary = Color(0xFF000000), // on main accent, switch knob
-//    primaryContainer = Color(0xFF121212),
-//    onPrimaryContainer = Color(0xFF121212),
-//    inversePrimary = Color(0xFF121212),
-    secondary = Color(0xFFE0E0E0),
-    onSecondary = Color(0xFF000000),
-    secondaryContainer = Color(0xFF404040), // navBar indicator,
-    onSecondaryContainer = Color(0xFFE0E0E0), // navBar active icon
-//    tertiary = Color(0xFF121212),
-//    onTertiary = Color(0xFF121212),
-//    tertiaryContainer = Color(0xFF121212),
-//    onTertiaryContainer = Color(0xFF121212),
-    background = Color(0xFF121212),
-    onBackground = Color(0xFFE0E0E0),
-    surface = Color(0xFF202020), // card background
-    onSurface = Color(0xFFE0E0E0), // on card background
-    surfaceVariant = Color(0xFF404040), // buttons background
-    onSurfaceVariant = Color(0xFFE0E0E0), // navBar inactive icon
-    surfaceTint = Color(0x00000000),
-//    inverseSurface = Color(0xFF121212),
-//    inverseOnSurface = Color(0xFF121212),
-    error = Color(0xFFDC0000),
-//    onError = Color(0xFFFFFFFF),
-//    errorContainer = Color(0xFF121212),
-//    onErrorContainer = Color(0xFF121212),
-    outline = Color(0xA3E0E0E0),
-//    outlineVariant = Color(0xFF121212),
-    scrim = Color(0xFF000000),
-//    surfaceBright = Color(0xFF121212),
-    surfaceContainer = Color(0xFF121212), // navBar background
-//    surfaceContainerHigh = Color(0xFF121212),
-    surfaceContainerHighest = Color(0xFF242424), // filled card background
-    surfaceContainerLow = Color(0xFF202020), // elevated card background
-    surfaceContainerLowest = Color(0xCC121212),
-//    surfaceDim = Color(0xFF121212),
-)
-
-private val shapes = Shapes(
-    extraSmall = RoundedCornerShape(4.dp), // menus, snackbars, text fields
-    small = RoundedCornerShape(8.dp), // buttons, chips
-    medium = RoundedCornerShape(12.dp), // cards, small FABs
-    large = RoundedCornerShape(24.dp), // extended FABs, FABs, nav drawers
-    extraLarge = RoundedCornerShape(32.dp) // large FABs
-)
-
-private val typography = Typography(
-    bodyLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 16.sp,
-        lineHeight = 24.sp,
-        letterSpacing = 0.5.sp
-    ), titleLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 22.sp,
-        lineHeight = 28.sp,
-        letterSpacing = 0.sp
-    ), labelSmall = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Medium,
-        fontSize = 11.sp,
-        lineHeight = 16.sp,
-        letterSpacing = 0.5.sp
-    )
-)

app/src/main/java/com/rtbishop/look4sat/presentation/common/Components.kt

@@ -1,402 +0,0 @@
-/*
- * 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.presentation.common
-
-import androidx.compose.foundation.MarqueeSpacing
-import androidx.compose.foundation.basicMarquee
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.RowScope
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.statusBarsPadding
-import androidx.compose.foundation.layout.width
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.ElevatedButton
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.window.Dialog
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.domain.predict.NearEarthObject
-import com.rtbishop.look4sat.domain.predict.OrbitalData
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.presentation.LocalSpacing
-import com.rtbishop.look4sat.presentation.MainTheme
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-
-private val sdfTime = SimpleDateFormat("HH:mm:ss", Locale.ENGLISH)
-
-@Composable
-@Preview(showBackground = true)
-private fun TopBarPreview() = MainTheme {
-    TopBar {
-        IconCard(action = {}, resId = R.drawable.ic_filter)
-        TimerRow(timeString = "88:88:88", isTimeAos = true)
-        IconCard(action = {}, resId = R.drawable.ic_radios)
-    }
-}
-
-@Composable
-fun TopBar(content: @Composable (RowScope.() -> Unit)) {
-    Row(
-        modifier = Modifier.height(48.dp),
-        horizontalArrangement = Arrangement.spacedBy(6.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) { content() }
-}
-
-@Composable
-fun RowScope.TimerRow(timeString: String, isTimeAos: Boolean) {
-    val colorScheme = MaterialTheme.colorScheme
-    val aosColor = if (isTimeAos) colorScheme.primary else colorScheme.onSurface
-    val losColor = if (!isTimeAos) colorScheme.primary else colorScheme.onSurface
-    ElevatedCard(modifier = Modifier.weight(1f)) {
-        Row(
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceEvenly,
-            modifier = Modifier.fillMaxSize()
-        ) {
-            Text(text = "AOS", fontSize = 16.sp, fontWeight = FontWeight.Medium, color = aosColor)
-            Text(
-                text = timeString,
-                fontSize = 32.sp,
-                fontWeight = FontWeight.Bold,
-                color = MaterialTheme.colorScheme.primary
-            )
-            Text(text = "LOS", fontSize = 16.sp, fontWeight = FontWeight.Medium, color = losColor)
-        }
-    }
-}
-
-@Composable
-@Preview(showBackground = true)
-private fun NextPassRowPreview() = MainTheme {
-    TopBar { NextPassRow(pass = getDefaultPass()) }
-}
-
-@Composable
-fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
-    ElevatedCard(modifier = modifier.height(48.dp).weight(1f)) {
-        Column(
-            verticalArrangement = Arrangement.spacedBy((-2).dp),
-            modifier = Modifier
-                .fillMaxSize()
-//                .background(color = MaterialTheme.colorScheme.background)
-                .padding(start = 6.dp, top = 1.dp, end = 6.dp, bottom = 0.dp)
-        ) {
-            val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "$passSatId - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
-                Text(
-                    text = pass.name,
-                    modifier = Modifier
-                        .weight(1f)
-                        .padding(end = 6.dp)
-                        .infiniteMarquee(),
-                    fontWeight = FontWeight.Medium,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis
-                )
-                Icon(
-                    painter = painterResource(id = R.drawable.ic_elevation),
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.size(16.dp)
-                )
-                Spacer(modifier = Modifier.width(4.dp))
-                Text(
-                    text = "${pass.maxElevation}°",
-                    color = MaterialTheme.colorScheme.primary
-                )
-            }
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween,
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Row(
-                    modifier = Modifier.weight(1f),
-                    horizontalArrangement = Arrangement.Start,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(
-                        text = sdfTime.format(Date(pass.aosTime)),
-                        fontSize = 15.sp,
-                        modifier = Modifier.weight(1f)
-                    )
-                }
-                Row(
-                    modifier = Modifier.weight(1f),
-                    horizontalArrangement = Arrangement.Center,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Icon(
-                        painter = painterResource(id = R.drawable.ic_altitude),
-                        contentDescription = null,
-                        modifier = Modifier.size(16.dp)
-                    )
-                    Spacer(modifier = Modifier.width(4.dp))
-                    Text(
-                        text = "${pass.altitude} km",
-                        fontSize = 15.sp
-                    )
-                }
-                Row(
-                    modifier = Modifier.weight(1f),
-                    horizontalArrangement = Arrangement.End,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(
-                        text = stringResource(
-                            id = R.string.pass_aosLos,
-                            pass.aosAzimuth.toInt(),
-                            pass.losAzimuth.toInt()
-                        ),
-                        fontSize = 15.sp
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier) {
-    ElevatedButton(
-        onClick = { onClick() }, colors = ButtonDefaults.buttonColors(
-            containerColor = MaterialTheme.colorScheme.surfaceVariant,
-            contentColor = MaterialTheme.colorScheme.onSurfaceVariant
-        ), shape = MaterialTheme.shapes.small, modifier = modifier,
-        contentPadding = PaddingValues(horizontal = 8.dp, vertical = 8.dp)
-    ) { Text(text = text, fontSize = 16.sp, textAlign = TextAlign.Center) }
-}
-
-@Composable
-fun IconCard(action: () -> Unit, resId: Int, modifier: Modifier = Modifier) {
-    val clickableMod = Modifier.clickable { action() }
-    ElevatedCard(modifier = Modifier.size(48.dp)) {
-        Box(modifier = clickableMod.fillMaxSize(), contentAlignment = Alignment.Center) {
-            Icon(painter = painterResource(resId), contentDescription = null, modifier = modifier)
-        }
-    }
-}
-
-@Composable
-fun PrimaryIconCard(modifier: Modifier = Modifier, resId: Int, onClick: () -> Unit) {
-    val clickableMod = modifier.clickable { onClick() }
-    ElevatedCard(
-        modifier = Modifier.size(102.dp, 48.dp),
-        colors = CardDefaults.elevatedCardColors(containerColor = MaterialTheme.colorScheme.primary)
-    ) {
-        Box(modifier = clickableMod.fillMaxSize(), contentAlignment = Alignment.Center) {
-            Icon(painter = painterResource(id = resId), contentDescription = null)
-        }
-    }
-}
-
-@Composable
-fun CardLoadingIndicator() {
-    Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
-        CircularProgressIndicator(modifier = Modifier.size(80.dp))
-    }
-}
-
-@Composable
-fun EmptyListCard(message: String) {
-    Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(24.dp),
-            modifier = Modifier.padding(32.dp)
-        ) {
-            Text(text = """¯\_(ツ)_/¯""", fontSize = 32.sp)
-            Text(text = stringResource(R.string.empty_list_message), fontSize = 21.sp, textAlign = TextAlign.Center)
-            Text(text = message, fontSize = 18.sp, textAlign = TextAlign.Center)
-        }
-    }
-}
-
-fun getDefaultPass(): OrbitalPass {
-    val orbitalData = OrbitalData(""" ¯\_(ツ)_/¯ ⚠️""", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0, 0.0)
-    val satellite = NearEarthObject(orbitalData)
-    return OrbitalPass(0L, 0.0, Long.MAX_VALUE, 0.0, 0, 0.0, satellite, 0f)
-}
-
-@Composable
-fun SharedDialog(
-    title: String, onCancel: () -> Unit, onAccept: () -> Unit, content: @Composable () -> Unit
-) {
-    val padding = LocalSpacing.current.large
-    Dialog(onDismissRequest = { onCancel() }) {
-        ElevatedCard {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.spacedBy(padding)
-            ) {
-                Text(
-                    text = title,
-                    fontSize = 16.sp,
-                    fontWeight = FontWeight.Medium,
-                    color = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.padding(start = padding, top = padding, end = padding)
-                )
-                content()
-                Row(modifier = Modifier.padding(start = padding, bottom = padding, end = padding)) {
-                    CardButton(onClick = onCancel, text = stringResource(id = R.string.btn_cancel))
-                    Spacer(modifier = Modifier.weight(1f))
-                    CardButton(onClick = onAccept, text = stringResource(id = R.string.btn_accept))
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun InfoDialog(title: String, text: String, onDismiss: () -> Unit) {
-    val padding = LocalSpacing.current.large
-    Dialog(onDismissRequest = {}) {
-        ElevatedCard {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.spacedBy(padding)
-            ) {
-                Text(
-                    text = title,
-                    fontSize = 18.sp,
-                    fontWeight = FontWeight.Medium,
-                    color = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.padding(start = padding, top = padding, end = padding)
-                )
-                Text(
-                    text = text,
-                    fontSize = 16.sp,
-                    color = MaterialTheme.colorScheme.onSurface,
-                    modifier = Modifier.padding(horizontal = padding)
-                )
-                Row(modifier = Modifier.padding(start = padding, bottom = padding, end = padding)) {
-                    Spacer(modifier = Modifier.weight(1f))
-                    CardButton(
-                        onClick = onDismiss,
-                        text = stringResource(id = R.string.btn_accept)
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun hasEnoughHeight(): Boolean {
-    return currentWindowAdaptiveInfo().windowSizeClass.isHeightAtLeastBreakpoint(480)
-}
-
-@Composable
-fun hasEnoughWidth(): Boolean {
-    return currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600)
-}
-
-@Composable
-fun isVerticalLayout(): Boolean {
-    return currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600).not()
-}
-
-@Composable
-fun Modifier.infiniteMarquee(): Modifier {
-    return basicMarquee(iterations = Int.MAX_VALUE, spacing = MarqueeSpacing(16.dp))
-}
-
-@Composable
-fun Modifier.layoutPadding(): Modifier {
-    val statusBarMod = this.statusBarsPadding()
-    val spacing = LocalSpacing.current.extraSmall
-    return statusBarMod.padding(start = spacing, top = 0.dp, end = spacing, bottom = spacing)
-}
-
-@Composable
-fun ScreenColumn(
-    topBar: @Composable (Boolean) -> Unit = {},
-    floatingBar: @Composable () -> Unit = {},
-    content: @Composable (Boolean) -> Unit = {}
-) {
-    val isVerticalLayout = isVerticalLayout()
-    Surface(color = MaterialTheme.colorScheme.background) {
-        Box(modifier = Modifier.layoutPadding(), contentAlignment = Alignment.BottomCenter) {
-            Column(verticalArrangement = Arrangement.spacedBy(LocalSpacing.current.extraSmall)) {
-                topBar(isVerticalLayout)
-                Surface(
-                    modifier = Modifier.fillMaxSize(),
-                    color = MaterialTheme.colorScheme.surfaceContainer
-                ) { content(isVerticalLayout) }
-            }
-            floatingBar()
-        }
-    }
-}
-
-@Composable
-fun TopBar(
-    isVerticalLayout: Boolean,
-    startAction: @Composable () -> Unit,
-    topInfo: @Composable (RowScope.() -> Unit),
-    bottomInfo: @Composable (RowScope.() -> Unit),
-    endAction: @Composable () -> Unit
-) {
-    val topBarRow = @Composable { content: @Composable RowScope.() -> Unit ->
-        Row(
-            modifier = Modifier.height(48.dp),
-            horizontalArrangement = Arrangement.spacedBy(6.dp),
-            verticalAlignment = Alignment.CenterVertically
-        ) { content() }
-    }
-    if (isVerticalLayout) {
-        topBarRow { startAction().also { topInfo() }.also { endAction() } }
-        topBarRow { bottomInfo() }
-    } else {
-        topBarRow { startAction().also { topInfo() }.also { bottomInfo() }.also { endAction() } }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/map/MapScreen.kt

@@ -1,367 +0,0 @@
-/*
- * 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.presentation.map
-
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.ColorMatrix
-import android.graphics.ColorMatrixColorFilter
-import android.graphics.Paint
-import android.graphics.Rect
-import android.graphics.drawable.Drawable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.State
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.rotate
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.viewinterop.AndroidView
-import androidx.core.content.ContextCompat
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleEventObserver
-import androidx.lifecycle.compose.LocalLifecycleOwner
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.viewmodel.compose.viewModel
-import androidx.navigation.NavGraphBuilder
-import androidx.navigation.compose.composable
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.domain.predict.GeoPos
-import com.rtbishop.look4sat.domain.predict.OrbitalObject
-import com.rtbishop.look4sat.domain.predict.OrbitalPos
-import com.rtbishop.look4sat.presentation.Screen
-import com.rtbishop.look4sat.presentation.common.IconCard
-import com.rtbishop.look4sat.presentation.common.NextPassRow
-import com.rtbishop.look4sat.presentation.common.TimerRow
-import com.rtbishop.look4sat.presentation.common.TopBar
-import org.osmdroid.tileprovider.tilesource.XYTileSource
-import org.osmdroid.util.GeoPoint
-import org.osmdroid.views.CustomZoomButtonsController
-import org.osmdroid.views.MapView
-import org.osmdroid.views.overlay.FolderOverlay
-import org.osmdroid.views.overlay.Marker
-import org.osmdroid.views.overlay.Polyline
-import androidx.core.graphics.toColorInt
-import androidx.core.graphics.createBitmap
-import androidx.core.graphics.drawable.toDrawable
-import com.rtbishop.look4sat.presentation.common.isVerticalLayout
-import com.rtbishop.look4sat.presentation.common.layoutPadding
-
-private val minLat = MapView.getTileSystem().minLatitude
-private val maxLat = MapView.getTileSystem().maxLatitude
-private val trackPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-    strokeWidth = 3f
-    style = Paint.Style.STROKE
-    color = Color.RED
-    strokeCap = Paint.Cap.ROUND
-    strokeJoin = Paint.Join.ROUND
-}
-private val footprintPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-    strokeWidth = 3f
-    style = Paint.Style.FILL_AND_STROKE
-    color = "#FFE082".toColorInt()
-}
-private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-    textSize = 36f
-    style = Paint.Style.FILL
-    color = "#FFE082".toColorInt()
-    setShadowLayer(3f, 3f, 3f, Color.BLACK)
-}
-private val labelRect = Rect()
-
-fun NavGraphBuilder.mapDestination() {
-    composable(Screen.Map.route) {
-        val viewModel = viewModel(MapViewModel::class.java, factory = MapViewModel.Factory)
-        val uiState = viewModel.uiState.collectAsStateWithLifecycle()
-        val mapView = rememberMapViewWithLifecycle()
-        MapScreen(uiState, mapView)
-    }
-}
-
-@Composable
-private fun MapScreen(uiState: State<MapState>, mapView: MapView) {
-    val onItemClick = { item: OrbitalObject -> uiState.value.sendAction(MapAction.SelectItem(item)) }
-    val selectPrev = { uiState.value.sendAction(MapAction.SelectPrev) }
-    val selectNext = { uiState.value.sendAction(MapAction.SelectNext) }
-    val rotateMod = Modifier.rotate(180f)
-    val timeString = uiState.value.mapData?.aosTime ?: "00:00:00"
-    val isTimeAos = uiState.value.mapData?.isTimeAos ?: true
-    LaunchedEffect(uiState.value.track) {
-        val latitude = uiState.value.track?.get(0)?.get(0)?.latitude ?: 0.0
-        val longitude = uiState.value.track?.get(0)?.get(0)?.longitude ?: 0.0
-        mapView.controller.animateTo(GeoPoint(latitude, longitude))
-    }
-    Column(modifier = Modifier.layoutPadding(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
-        if (isVerticalLayout()) {
-            TopBar {
-                IconCard(action = selectPrev, resId = R.drawable.ic_arrow, modifier = rotateMod)
-                TimerRow(timeString = timeString, isTimeAos = isTimeAos)
-                IconCard(action = selectNext, resId = R.drawable.ic_arrow)
-            }
-            TopBar { NextPassRow(pass = uiState.value.orbitalPass) }
-        } else {
-            TopBar {
-                IconCard(action = selectPrev, resId = R.drawable.ic_arrow, modifier = rotateMod)
-                TimerRow(timeString = timeString, isTimeAos = isTimeAos)
-                NextPassRow(pass = uiState.value.orbitalPass, modifier = Modifier.weight(1f))
-                IconCard(action = selectNext, resId = R.drawable.ic_arrow)
-            }
-        }
-        ElevatedCard(modifier = Modifier.weight(1f)) {
-            Box(contentAlignment = Alignment.BottomCenter) {
-                AndroidView({ mapView }) { mapView ->
-                    uiState.value.stationPosition?.let { setStationPosition(it, mapView) }
-                    uiState.value.positions?.let { setPositions(it, mapView, onItemClick) }
-                    uiState.value.track?.let { setSatelliteTrack(it, mapView) }
-                    uiState.value.footprint?.let { setFootprint(it, mapView) }
-                }
-                uiState.value.mapData?.let { mapData ->
-                    if (isVerticalLayout()) MapDataCard(mapData) else MapDataCards(mapData)
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun MapDataCard(data: MapData) {
-    val textColor = MaterialTheme.colorScheme.primary
-    val cardColors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLowest)
-    Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.SpaceBetween) {
-        Text(text = stringResource(R.string.map_copyright), fontSize = 14.sp)
-        Card(colors = cardColors) {
-            Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
-                Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
-                    Text(text = stringResource(R.string.map_azimuth, data.azimuth), color = textColor)
-                    Text(text = stringResource(R.string.map_elevation, data.elevation), color = textColor)
-                }
-                Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
-                    Text(text = stringResource(R.string.map_altitude, data.altitude))
-                    Text(text = stringResource(R.string.map_distance, data.range))
-                }
-                Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
-                    Text(text = stringResource(R.string.map_latitude, data.osmPos.latitude), color = textColor)
-                    Text(text = stringResource(R.string.map_longitude, data.osmPos.longitude), color = textColor)
-                }
-                Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
-                    Text(text = stringResource(R.string.map_qth, data.qthLoc))
-                    Text(text = stringResource(R.string.map_phase, data.phase))
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun MapDataCards(data: MapData) {
-    val cardColors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLowest)
-    val paddingMod = Modifier.padding(horizontal = 8.dp, vertical = 4.dp).width(160.dp)
-    val osmText = stringResource(R.string.map_copyright)
-    val textColor = MaterialTheme.colorScheme.primary
-    Box(modifier = Modifier.fillMaxSize()) {
-        Card(colors = cardColors, modifier = Modifier.align(Alignment.TopStart)) {
-            Column(horizontalAlignment = Alignment.Start, modifier = paddingMod) {
-                Text(text = stringResource(R.string.map_azimuth, data.azimuth), color = textColor)
-                Text(text = stringResource(R.string.map_elevation, data.elevation))
-            }
-        }
-        Card(colors = cardColors, modifier = Modifier.align(Alignment.TopEnd)) {
-            Column(horizontalAlignment = Alignment.End, modifier = paddingMod) {
-                Text(text = stringResource(R.string.map_altitude, data.altitude), color = textColor)
-                Text(text = stringResource(R.string.map_distance, data.range))
-            }
-        }
-        Card(colors = cardColors, modifier = Modifier.align(Alignment.BottomStart)) {
-            Column(horizontalAlignment = Alignment.Start, modifier = paddingMod) {
-                Text(text = stringResource(R.string.map_phase, data.phase), color = textColor)
-                Text(text = stringResource(R.string.map_qth, data.qthLoc))
-            }
-        }
-        Text(text = osmText, fontSize = 14.sp, modifier = Modifier.align(Alignment.BottomCenter))
-        Card(colors = cardColors, modifier = Modifier.align(Alignment.BottomEnd)) {
-            Column(horizontalAlignment = Alignment.End, modifier = paddingMod) {
-                Text(text = stringResource(R.string.map_latitude, data.osmPos.latitude), color = textColor)
-                Text(text = stringResource(R.string.map_longitude, data.osmPos.longitude))
-            }
-        }
-    }
-}
-
-private fun setStationPosition(stationPos: GeoPos, mapView: MapView) {
-    try {
-        Marker(mapView).apply {
-            setInfoWindow(null)
-            setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
-            icon = ContextCompat.getDrawable(mapView.context, R.drawable.ic_position)
-            position = GeoPoint(stationPos.latitude, stationPos.longitude)
-            mapView.overlays[0] = this
-            mapView.invalidate()
-        }
-    } catch (exception: Exception) {
-        println(exception)
-    }
-}
-
-private fun setPositions(
-    posMap: Map<OrbitalObject, GeoPos>,
-    mapView: MapView,
-    action: (OrbitalObject) -> Unit
-) {
-    val markers = FolderOverlay()
-    try {
-        posMap.entries.forEach {
-            Marker(mapView).apply {
-                setInfoWindow(null)
-                setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
-                icon = getCustomTextIcon(it.key.data.name, mapView)
-                try {
-                    position = GeoPoint(it.value.latitude, it.value.longitude)
-                } catch (exception: IllegalArgumentException) {
-                    println(exception.stackTraceToString())
-                }
-                setOnMarkerClickListener { _, _ ->
-                    action(it.key)
-                    return@setOnMarkerClickListener true
-                }
-                markers.add(this)
-            }
-        }
-        mapView.overlays[3] = markers
-        mapView.invalidate()
-    } catch (exception: Exception) {
-        println(exception)
-    }
-}
-
-private fun getCustomTextIcon(textLabel: String, mapView: MapView): Drawable {
-    textPaint.getTextBounds(textLabel, 0, textLabel.length, labelRect)
-    val iconSize = 10f
-    val width = labelRect.width() + iconSize * 2f
-    val height = textPaint.textSize * 3f + iconSize * 2f
-    val bitmap = createBitmap(width.toInt(), height.toInt())
-    Canvas(bitmap).run {
-        drawCircle(width / 2f, height / 2f, iconSize, textPaint)
-        drawText(textLabel, iconSize / 2f, height - iconSize, textPaint)
-    }
-    return bitmap.toDrawable(mapView.context.resources)
-}
-
-private fun setSatelliteTrack(satTrack: List<List<GeoPos>>, mapView: MapView) {
-    val trackOverlay = FolderOverlay()
-    try {
-        satTrack.forEach { track ->
-            val trackPoints = track.map { GeoPoint(it.latitude, it.longitude) }
-            Polyline().apply {
-                setPoints(trackPoints)
-                outlinePaint.set(trackPaint)
-                trackOverlay.add(this)
-            }
-        }
-        mapView.overlays[1] = trackOverlay
-    } catch (exception: Exception) {
-        println(exception)
-    }
-}
-
-private fun setFootprint(orbitalPos: OrbitalPos, mapView: MapView) {
-    val footprintPoints = orbitalPos.getRangeCircle().map { GeoPoint(it.latitude, it.longitude) }
-    try {
-        val footprintOverlay = Polyline().apply {
-            outlinePaint.set(footprintPaint)
-            setPoints(footprintPoints)
-        }
-        mapView.overlays[2] = footprintOverlay
-    } catch (exception: Exception) {
-        println(exception)
-    }
-}
-
-@Composable
-private fun rememberMapViewWithLifecycle(): MapView {
-    val tileSource = XYTileSource("tiles", 0, 6, 256, ".webp", emptyArray<String>())
-    val context = LocalContext.current
-    val mapView = remember { MapView(context) }.apply {
-        setMultiTouchControls(true)
-        setUseDataConnection(false)
-        setTileSource(tileSource)
-        minZoomLevel = getMinZoom(resources.displayMetrics.heightPixels)
-        maxZoomLevel = 7.0
-        controller.setCenter(GeoPoint(48.8575, 6.3514))
-        controller.setZoom(minZoomLevel + 2)
-        zoomController.setVisibility(CustomZoomButtonsController.Visibility.NEVER)
-        overlayManager.tilesOverlay.loadingBackgroundColor = Color.TRANSPARENT
-        overlayManager.tilesOverlay.loadingLineColor = Color.TRANSPARENT
-        overlayManager.tilesOverlay.setColorFilter(getColorFilter())
-        setScrollableAreaLimitLatitude(maxLat, minLat, 0)
-        // add overlays: 0 - GSP, 1 - SatTrack, 2 - SatFootprint, 3 - SatIcons
-        overlays.addAll(Array(4) { FolderOverlay() })
-    }
-    // Makes MapView follow the lifecycle of this composable
-    val lifecycleObserver = rememberMapViewLifecycleObserver(mapView)
-    val lifecycle = LocalLifecycleOwner.current.lifecycle
-    DisposableEffect(lifecycle) {
-        lifecycle.addObserver(lifecycleObserver)
-        onDispose { lifecycle.removeObserver(lifecycleObserver) }
-    }
-    return mapView
-}
-
-@Composable
-private fun rememberMapViewLifecycleObserver(mapView: MapView) = remember(mapView) {
-    LifecycleEventObserver { _, event ->
-        when (event) {
-            Lifecycle.Event.ON_RESUME -> mapView.onResume()
-            Lifecycle.Event.ON_PAUSE -> mapView.onPause()
-            else -> {}
-        }
-    }
-}
-
-@Composable
-private fun getColorFilter(): ColorMatrixColorFilter {
-    val grayScale = ColorMatrix().apply { setSaturation(0f) }
-    val negative = ColorMatrix(
-        floatArrayOf(-1f, 0f, 0f, 0f, 260f, 0f, -1f, 0f, 0f, 260f, 0f, 0f, -1f, 0f, 260f, 0f, 0f, 0f, 1f, 0f)
-    )
-    negative.preConcat(grayScale)
-    return ColorMatrixColorFilter(negative)
-}
-
-@Composable
-private fun getMinZoom(screenHeight: Int): Double {
-    if (!isVerticalLayout()) return 3.5
-    return MapView.getTileSystem().getLatitudeZoom(maxLat, minLat, screenHeight)
-}

app/src/main/java/com/rtbishop/look4sat/presentation/map/MapState.kt

@@ -1,58 +0,0 @@
-/*
- * 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.presentation.map
-
-import com.rtbishop.look4sat.domain.predict.GeoPos
-import com.rtbishop.look4sat.domain.predict.OrbitalObject
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.domain.predict.OrbitalPos
-
-data class MapState(
-    val mapData: MapData?,
-    val isLightUi: Boolean,
-    val stationPosition: GeoPos?,
-    val orbitalPass: OrbitalPass,
-    val track: List<List<GeoPos>>?,
-    val footprint: OrbitalPos?,
-    val positions: Map<OrbitalObject, GeoPos>?,
-    val sendAction: (MapAction) -> Unit
-)
-
-sealed class MapAction {
-    data object SelectPrev: MapAction()
-    data object SelectNext: MapAction()
-    data class SelectItem(val item: OrbitalObject): MapAction()
-    data class SelectDefaultItem(val catnum: Int): MapAction()
-}
-
-data class MapData(
-    val catNum: Int,
-    val name: String,
-    val aosTime: String,
-    val isTimeAos: Boolean,
-    val azimuth: Double,
-    val elevation: Double,
-    val range: Double,
-    val altitude: Double,
-    val velocity: Double,
-    val qthLoc: String,
-    val osmPos: GeoPos,
-    val period: Double,
-    val phase: Double,
-    val eclipsed: Boolean
-)

app/src/main/java/com/rtbishop/look4sat/presentation/map/MapViewModel.kt

@@ -1,235 +0,0 @@
-/*
- * 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.presentation.map
-
-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.MainApplication
-import com.rtbishop.look4sat.domain.predict.GeoPos
-import com.rtbishop.look4sat.domain.predict.OrbitalObject
-import com.rtbishop.look4sat.domain.repository.ISatelliteRepo
-import com.rtbishop.look4sat.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.domain.utility.clipLat
-import com.rtbishop.look4sat.domain.utility.clipLon
-import com.rtbishop.look4sat.domain.utility.positionToQth
-import com.rtbishop.look4sat.domain.utility.toDegrees
-import com.rtbishop.look4sat.domain.utility.toTimerString
-import com.rtbishop.look4sat.presentation.common.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.update
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import java.util.Date
-import kotlin.collections.set
-
-class MapViewModel(private val satelliteRepo: ISatelliteRepo, settingsRepo: ISettingsRepo) :
-    ViewModel() {
-
-    private val stationPos = settingsRepo.stationPosition.value
-    private val defaultPass = getDefaultPass()
-    private val _uiState = MutableStateFlow(
-        MapState(
-            mapData = null,
-            isLightUi = settingsRepo.otherSettings.value.stateOfLightTheme,
-            stationPosition = null,
-            orbitalPass = defaultPass,
-            track = null,
-            footprint = null,
-            positions = null,
-            sendAction = ::handleAction
-        )
-    )
-    private var allPasses = satelliteRepo.passes.value
-    private var allSatellites = satelliteRepo.satellites.value
-    private var dataUpdateJob: Job? = null
-    private var dataUpdateRate = 1000L
-    private var selectedOrbitalObject: OrbitalObject? = null
-    val uiState: StateFlow<MapState> = _uiState
-
-    init {
-        selectDefaultSatellite(-1)
-    }
-
-    private fun handleAction(action: MapAction) {
-        when (action) {
-            MapAction.SelectPrev -> scrollSelection(true)
-            MapAction.SelectNext -> scrollSelection(false)
-            is MapAction.SelectItem -> selectSatellite(action.item)
-            is MapAction.SelectDefaultItem -> selectDefaultSatellite(action.catnum)
-        }
-    }
-
-    private fun getStationPosition() {
-        val osmLat = clipLat(stationPos.latitude)
-        val osmLon = clipLon(stationPos.longitude)
-        _uiState.update { it.copy(stationPosition = GeoPos(osmLat, osmLon)) }
-    }
-
-    private fun selectDefaultSatellite(catnum: Int) {
-        if (allSatellites.isNotEmpty()) {
-            if (catnum == -1) {
-                allPasses.find { pass -> pass.progress < 100 && !pass.isDeepSpace }
-                    ?.let { pass -> selectSatellite(pass.orbitalObject) }
-            } else {
-                allSatellites.find { it.data.catnum == catnum }?.let { selectSatellite(it) }
-            }
-        }
-    }
-
-    private fun scrollSelection(decrement: Boolean) {
-        if (allSatellites.isNotEmpty()) {
-            val index = allSatellites.indexOf(selectedOrbitalObject)
-            if (decrement) {
-                if (index > 0) selectSatellite(allSatellites[index - 1])
-                else selectSatellite(allSatellites[allSatellites.size - 1])
-            } else {
-                if (index < allSatellites.size - 1) selectSatellite(allSatellites[index + 1])
-                else selectSatellite(allSatellites[0])
-            }
-        }
-    }
-
-    private fun selectSatellite(orbitalObject: OrbitalObject, updateFreq: Long = dataUpdateRate) {
-        selectedOrbitalObject = orbitalObject
-        viewModelScope.launch {
-            dataUpdateJob?.cancelAndJoin()
-            dataUpdateJob = launch {
-                val dateNow = Date()
-                getStationPosition()
-                getSatTrack(orbitalObject, stationPos, dateNow)
-                while (isActive) {
-                    dateNow.time = System.currentTimeMillis()
-                    getPositions(allSatellites, stationPos, dateNow)
-                    getSatFootprint(orbitalObject, stationPos, dateNow)
-                    getSatData(orbitalObject, stationPos, dateNow)
-                    delay(updateFreq)
-                }
-            }
-        }
-    }
-
-    private suspend fun getSatTrack(orbitalObject: OrbitalObject, pos: GeoPos, date: Date) {
-        val satTracks = mutableListOf<List<GeoPos>>()
-        val currentTrack = mutableListOf<GeoPos>()
-        val endDate = Date(date.time + (orbitalObject.data.orbitalPeriod * 2.4 * 60000L).toLong())
-        var oldLongitude = 0.0
-        satelliteRepo.getTrack(orbitalObject, pos, date.time, endDate.time).forEach { satPos ->
-            val osmLat = clipLat(satPos.latitude.toDegrees())
-            val osmLon = clipLon(satPos.longitude.toDegrees())
-            val currentPosition = GeoPos(osmLat, osmLon)
-            if (oldLongitude < -170.0 && currentPosition.longitude > 170.0) {
-                // adding left terminal position
-                currentTrack.add(GeoPos(osmLat, -180.0))
-                val finishedTrack = mutableListOf<GeoPos>().apply { addAll(currentTrack) }
-                satTracks.add(finishedTrack)
-                currentTrack.clear()
-            } else if (oldLongitude > 170.0 && currentPosition.longitude < -170.0) {
-                // adding right terminal position
-                currentTrack.add(GeoPos(osmLat, 180.0))
-                val finishedTrack = mutableListOf<GeoPos>().apply { addAll(currentTrack) }
-                satTracks.add(finishedTrack)
-                currentTrack.clear()
-            }
-            oldLongitude = currentPosition.longitude
-            currentTrack.add(currentPosition)
-        }
-        satTracks.add(currentTrack)
-        _uiState.update { it.copy(track = satTracks) }
-    }
-
-    private suspend fun getPositions(orbitalObjects: List<OrbitalObject>, pos: GeoPos, date: Date) {
-        val positions = mutableMapOf<OrbitalObject, GeoPos>()
-        orbitalObjects.forEach { satellite ->
-            val satPos = satelliteRepo.getPosition(satellite, pos, date.time)
-            val osmLat = clipLat(satPos.latitude.toDegrees())
-            val osmLon = clipLon(satPos.longitude.toDegrees())
-            positions[satellite] = GeoPos(osmLat, osmLon)
-        }
-        _uiState.update { it.copy(positions = positions) }
-    }
-
-    private suspend fun getSatFootprint(orbitalObject: OrbitalObject, pos: GeoPos, date: Date) {
-        val satPos = satelliteRepo.getPosition(orbitalObject, pos, date.time)
-        _uiState.update { it.copy(footprint = satPos) }
-    }
-
-    private suspend fun getSatData(sat: OrbitalObject, pos: GeoPos, date: Date) {
-        var orbitalPass = defaultPass
-        var aosTime = 0L.toTimerString()
-        var isTimeAos = true
-        allPasses.find { pass -> pass.catNum == sat.data.catnum && pass.progress < 1 }
-            ?.let { satPass ->
-                orbitalPass = satPass
-                if (!satPass.isDeepSpace) {
-                    aosTime = if (date.time < satPass.aosTime) {
-                        val millisBeforeStart = satPass.aosTime.minus(date.time)
-                        isTimeAos = true
-                        millisBeforeStart.toTimerString()
-                    } else {
-                        val millisBeforeEnd = satPass.losTime.minus(date.time)
-                        isTimeAos = false
-                        millisBeforeEnd.toTimerString()
-                    }
-                }
-            }
-        val satPos = satelliteRepo.getPosition(sat, pos, date.time)
-        val azimuth = satPos.azimuth.toDegrees()
-        val elevation = satPos.elevation.toDegrees()
-        val osmLat = clipLat(satPos.latitude.toDegrees())
-        val osmLon = clipLon(satPos.longitude.toDegrees())
-        val osmPos = GeoPos(osmLat, osmLon)
-        val qthLoc = positionToQth(osmPos.latitude, osmPos.longitude) ?: "-- --"
-        val velocity = satPos.getOrbitalVelocity()
-        val phase = satPos.phase.toDegrees()
-        val visibility = satPos.eclipsed
-        val satData = MapData(
-            sat.data.catnum,
-            sat.data.name,
-            aosTime,
-            isTimeAos,
-            azimuth,
-            elevation,
-            satPos.distance,
-            satPos.altitude,
-            velocity,
-            qthLoc,
-            osmPos,
-            sat.data.orbitalPeriod,
-            phase,
-            visibility
-        )
-        _uiState.update { it.copy(mapData = satData, orbitalPass = orbitalPass) }
-    }
-
-    companion object {
-        val Factory: ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
-            initializer {
-                val container = (this[applicationKey] as MainApplication).container
-                MapViewModel(container.satelliteRepo, container.settingsRepo)
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/passes/PassesDialog.kt

@@ -1,189 +0,0 @@
-/*
- * 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.presentation.passes
-
-import androidx.compose.foundation.background
-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.fillMaxHeight
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.itemsIndexed
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Slider
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableDoubleStateOf
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.presentation.LocalSpacing
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.common.SharedDialog
-
-private val allModes = listOf(
-    "AFSK", "AFSK S-Net", "AFSK SALSAT", "AHRPT", "AM", "APT", "BPSK", "BPSK PMT-A3",
-    "CERTO", "CW", "DQPSK", "DSTAR", "DUV", "FFSK", "FM", "FMN", "FSK", "FSK AX.100 Mode 5",
-    "FSK AX.100 Mode 6", "FSK AX.25 G3RUH", "GFSK", "GFSK Rktr", "GMSK", "HRPT", "LoRa",
-    "LRPT", "LSB", "MFSK", "MSK", "MSK AX.100 Mode 5", "MSK AX.100 Mode 6", "OFDM", "OQPSK",
-    "PSK", "PSK31", "PSK63", "QPSK", "QPSK31", "QPSK63", "SSTV", "USB", "WSJT"
-)
-
-@Preview
-@Composable
-private fun PassesDialogPreview() {
-    MainTheme { PassesDialog(24, 16.0, {}) { _, _ -> } }
-}
-
-@Composable
-fun PassesDialog(hours: Int, elevation: Double, cancel: () -> Unit, accept: (Int, Double) -> Unit) {
-    val hoursValue = remember { mutableIntStateOf(hours) }
-    val elevationValueNew = remember { mutableDoubleStateOf(elevation) }
-    val onAccept = {
-        accept(hoursValue.intValue, elevationValueNew.doubleValue).also { cancel() }
-    }
-    SharedDialog(title = stringResource(R.string.pass_filter_title), onCancel = cancel, onAccept = onAccept) {
-        SliderRow(
-            title = stringResource(R.string.pass_filter_elev),
-            value = elevationValueNew.doubleValue,
-            valuePostfix = "°",
-            valueResId = R.drawable.ic_elevation,
-            valueRange = 0f..60f
-        ) { elevationValueNew.doubleValue = it.toDouble() }
-        SliderRow(
-            title = stringResource(R.string.pass_filter_hours),
-            value = hoursValue.intValue.toDouble(),
-            valuePostfix = "h",
-            valueResId = R.drawable.ic_clock,
-            valueRange = 1f..240f
-        ) { hoursValue.intValue = it.toInt() }
-    }
-}
-
-@Composable
-private fun SliderRow(
-    title: String,
-    value: Double,
-    valuePostfix: String,
-    valueResId: Int,
-    valueRange: ClosedFloatingPointRange<Float>,
-    onChange: (Float) -> Unit
-) {
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.spacedBy(LocalSpacing.current.small),
-        modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
-    ) {
-        Row(
-            horizontalArrangement = Arrangement.spacedBy(LocalSpacing.current.small),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Text(
-                text = title,
-                fontSize = 16.sp,
-                modifier = Modifier.weight(1f),
-                color = MaterialTheme.colorScheme.onSurface
-            )
-            Icon(
-                painter = painterResource(id = valueResId),
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.primary,
-                modifier = Modifier.size(20.dp)
-            )
-            Text(
-                text = "${value.toInt()}$valuePostfix",
-                fontSize = 18.sp,
-                fontWeight = FontWeight.Medium,
-                color = MaterialTheme.colorScheme.primary
-            )
-        }
-        Slider(value = value.toFloat(), onValueChange = onChange, valueRange = valueRange)
-    }
-}
-
-@Preview(showBackground = true)
-@Composable
-private fun RadiosDialogPreview() {
-    MainTheme { RadiosDialog(emptyList(), {}) { _ -> } }
-}
-
-@Composable
-fun RadiosDialog(modes: List<String>, cancel: () -> Unit, accept: (List<String>) -> Unit) {
-    val selected = remember { mutableStateListOf<String>().apply { addAll(modes) } }
-    val select = { mode: String ->
-        if (selected.contains(mode)) selected.remove(mode) else selected.add(mode)
-    }
-    val onAccept = { accept(selected.toList()).also { cancel() } }
-    SharedDialog(title = stringResource(R.string.pass_modes_title), onCancel = cancel, onAccept = onAccept) {
-        LazyVerticalGrid(
-            columns = GridCells.Adaptive(240.dp),
-            modifier = Modifier
-                .fillMaxHeight(0.69f)
-                .background(MaterialTheme.colorScheme.background),
-            horizontalArrangement = Arrangement.spacedBy(1.dp),
-            verticalArrangement = Arrangement.spacedBy(1.dp)
-        ) {
-            itemsIndexed(allModes) { index, item ->
-                Surface {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier
-                            .background(MaterialTheme.colorScheme.surface)
-                            .clickable { select(item) }
-                    ) {
-                        Text(
-                            text = "${index + 1}).",
-                            modifier = Modifier.padding(start = 16.dp, end = 8.dp),
-                            fontWeight = FontWeight.Normal,
-                            color = MaterialTheme.colorScheme.primary
-                        )
-                        Text(
-                            text = item,
-                            modifier = Modifier.weight(1f),
-                            fontWeight = FontWeight.Medium,
-                            maxLines = 1,
-                            overflow = TextOverflow.Ellipsis
-                        )
-                        Checkbox(
-                            checked = selected.contains(item),
-                            onCheckedChange = null,
-                            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
-                        )
-                    }
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/passes/PassesScreen.kt

@@ -1,336 +0,0 @@
-/*
- * 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.presentation.passes
-
-import androidx.compose.foundation.background
-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.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyGridState
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.items
-import androidx.compose.foundation.lazy.grid.rememberLazyGridState
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.LinearProgressIndicator
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.material3.pulltorefresh.PullToRefreshBox
-import androidx.compose.material3.pulltorefresh.PullToRefreshDefaults
-import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-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.R
-import com.rtbishop.look4sat.domain.predict.DeepSpaceObject
-import com.rtbishop.look4sat.domain.predict.NearEarthObject
-import com.rtbishop.look4sat.domain.predict.OrbitalData
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.Screen
-import com.rtbishop.look4sat.presentation.common.EmptyListCard
-import com.rtbishop.look4sat.presentation.common.IconCard
-import com.rtbishop.look4sat.presentation.common.InfoDialog
-import com.rtbishop.look4sat.presentation.common.NextPassRow
-import com.rtbishop.look4sat.presentation.common.ScreenColumn
-import com.rtbishop.look4sat.presentation.common.TimerRow
-import com.rtbishop.look4sat.presentation.common.TopBar
-import com.rtbishop.look4sat.presentation.common.infiniteMarquee
-import com.rtbishop.look4sat.presentation.common.isVerticalLayout
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-
-private val sdfDate = SimpleDateFormat("EEE dd MMM", Locale.ENGLISH)
-private val sdfTime = SimpleDateFormat("HH:mm:ss", Locale.ENGLISH)
-
-fun NavGraphBuilder.passesDestination(navigateToRadar: (Int, Long) -> Unit) {
-    composable(Screen.Passes.route) {
-        val viewModel = viewModel(
-            modelClass = PassesViewModel::class.java,
-            factory = PassesViewModel.Factory
-        )
-        val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
-        PassesScreen(uiState, navigateToRadar)
-    }
-}
-
-@Composable
-private fun PassesScreen(uiState: PassesState, navigateToRadar: (Int, Long) -> Unit) {
-    val refreshList = { uiState.takeAction(PassesAction.RefreshPasses) }
-    val showPassesDialog = { uiState.takeAction(PassesAction.TogglePassesDialog) }
-    val showRadiosDialog = { uiState.takeAction(PassesAction.ToggleRadiosDialog) }
-    if (uiState.isPassesDialogShown) {
-        PassesDialog(
-            hours = uiState.hours,
-            elevation = uiState.elevation,
-            cancel = showPassesDialog
-        ) { hours, elevation ->
-            uiState.takeAction(PassesAction.FilterPasses(hours, elevation))
-        }
-    }
-    if (uiState.isRadiosDialogShown) {
-        RadiosDialog(modes = uiState.modes, cancel = showRadiosDialog) { modes ->
-            uiState.takeAction(PassesAction.FilterRadios(modes))
-        }
-    }
-    if (uiState.shouldSeeWhatsNew) {
-        InfoDialog(
-            title = stringResource(R.string.pass_whatsnew_title),
-            text = stringResource(R.string.pass_whatsnew_message)
-        ) {
-            uiState.takeAction(PassesAction.DismissWhatsNew)
-        }
-    }
-    val gridState = rememberLazyGridState()
-    ScreenColumn(
-        topBar = { isVerticalLayout ->
-            TopBar(
-                isVerticalLayout = isVerticalLayout,
-                startAction = {
-                    IconCard(action = showPassesDialog, resId = R.drawable.ic_filter)
-                },
-                topInfo = {
-                    TimerRow(timeString = uiState.nextTime, isTimeAos = uiState.isNextTimeAos)
-                },
-                bottomInfo = {
-                    NextPassRow(pass = uiState.nextPass)
-                },
-                endAction = {
-                    IconCard(action = showRadiosDialog, resId = R.drawable.ic_radios)
-                }
-            )
-        }
-    ) { _ ->
-        PassesList(
-            isRefreshing = uiState.isRefreshing,
-            passes = uiState.itemsList,
-            navigateToRadar = navigateToRadar,
-            refreshPasses = refreshList,
-            gridState = gridState
-        )
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun PassesList(
-    isRefreshing: Boolean,
-    passes: List<OrbitalPass>,
-    navigateToRadar: (Int, Long) -> Unit,
-    refreshPasses: () -> Unit,
-    gridState: LazyGridState
-) {
-    val isVerticalLayout = isVerticalLayout()
-    val refreshState = rememberPullToRefreshState()
-    ElevatedCard(modifier = Modifier.fillMaxSize()) {
-        PullToRefreshBox(
-            isRefreshing = isRefreshing,
-            state = refreshState,
-            onRefresh = refreshPasses,
-            indicator = {
-                PullToRefreshDefaults.Indicator(
-                    state = refreshState,
-                    isRefreshing = isRefreshing,
-                    color = MaterialTheme.colorScheme.background,
-                    containerColor = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.align(Alignment.TopCenter),
-                )
-            }
-        ) {
-            if (passes.isEmpty()) {
-                EmptyListCard(message = stringResource(R.string.pass_empty_list_message))
-            } else {
-                LazyVerticalGrid(
-                    state = gridState,
-                    columns = GridCells.Adaptive(320.dp),
-                    modifier = Modifier.fillMaxSize()
-                ) {
-                    items(items = passes, key = { item -> item.catNum + item.aosTime }) { pass ->
-                        NearEarthPass(
-                            pass = pass,
-                            navigateToRadar = navigateToRadar,
-                            modifier = Modifier.animateItem(),
-                            isVerticalLayout = isVerticalLayout
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Preview(showBackground = true)
-@Composable
-private fun DeepSpacePassPreview() {
-    val data = OrbitalData("Satellite", 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 45000, 0.0)
-    val satellite = DeepSpaceObject(data)
-    val pass = OrbitalPass(1L, 180.0, 10L, 360.0, 36650, 45.0, satellite, 0.5f)
-    MainTheme { NearEarthPass(pass = pass, { _, _ -> }) }
-}
-
-@Preview(showBackground = true)
-@Composable
-private fun NearEarthPassPreview() {
-    val data = OrbitalData("Satellite", 0.0, 15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 45000, 0.0)
-    val satellite = NearEarthObject(data)
-    val pass = OrbitalPass(1L, 180.0, 10L, 360.0, 36650, 45.0, satellite, 0.5f)
-    MainTheme { NearEarthPass(pass = pass, { _, _ -> }) }
-}
-
-@Composable
-private fun NearEarthPass(
-    pass: OrbitalPass,
-    navigateToRadar: (Int, Long) -> Unit,
-    modifier: Modifier = Modifier,
-    isVerticalLayout: Boolean = true
-) {
-    val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
-    val horizontalPadding = if (isVerticalLayout) 6.dp else 10.dp
-    Surface(color = MaterialTheme.colorScheme.background, modifier = modifier) {
-        Surface(modifier = Modifier
-            .padding(bottom = 2.dp)
-            .clickable { navigateToRadar(pass.catNum, pass.aosTime) }) {
-            Column(
-                verticalArrangement = Arrangement.spacedBy(1.dp),
-                modifier = Modifier
-                    .background(color = MaterialTheme.colorScheme.surface)
-                    .padding(horizontal = horizontalPadding, vertical = 4.dp)
-            ) {
-                Row(verticalAlignment = Alignment.CenterVertically) {
-                    Text(
-                        text = "$passSatId - ",
-                        color = MaterialTheme.colorScheme.primary
-                    )
-                    Text(
-                        text = pass.name,
-                        modifier = Modifier
-                            .weight(1f)
-                            .padding(end = 6.dp)
-                            .infiniteMarquee(),
-                        fontWeight = FontWeight.Medium,
-                        maxLines = 1,
-                        overflow = TextOverflow.Ellipsis
-                    )
-                    Icon(
-                        painter = painterResource(id = R.drawable.ic_elevation),
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.primary,
-                        modifier = Modifier.size(16.dp)
-                    )
-                    Spacer(modifier = Modifier.width(4.dp))
-                    Text(
-                        text = "${pass.maxElevation}°",
-                        color = MaterialTheme.colorScheme.primary
-                    )
-                }
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    Row(
-                        modifier = Modifier.weight(1f),
-                        horizontalArrangement = Arrangement.Start,
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        if (pass.isDeepSpace) {
-                            Text(text = stringResource(R.string.pass_deep_space), fontSize = 15.sp)
-                        } else {
-                            Text(
-                                text = sdfDate.format(Date(pass.aosTime)),
-                                fontSize = 15.sp
-                            )
-                        }
-                    }
-                    Row(
-                        modifier = Modifier.weight(1f),
-                        horizontalArrangement = Arrangement.Center,
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Icon(
-                            painter = painterResource(id = R.drawable.ic_altitude),
-                            contentDescription = null,
-                            modifier = Modifier.size(16.dp)
-                        )
-                        Spacer(modifier = Modifier.width(4.dp))
-                        Text(
-                            text = "${pass.altitude} km",
-                            fontSize = 15.sp
-                        )
-                    }
-                    Row(
-                        modifier = Modifier.weight(1f),
-                        horizontalArrangement = Arrangement.End,
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Text(
-                            text = stringResource(
-                                id = R.string.pass_aosLos,
-                                pass.aosAzimuth.toInt(),
-                                pass.losAzimuth.toInt()
-                            ),
-                            fontSize = 15.sp
-                        )
-                    }
-                }
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    val defaultTime = "   - - : - -   "
-                    Text(
-                        text = if (pass.isDeepSpace) defaultTime else sdfTime.format(Date(pass.aosTime)),
-                        fontSize = 15.sp
-                    )
-                    LinearProgressIndicator(
-                        progress = { if (pass.isDeepSpace) 100f else pass.progress },
-                        drawStopIndicator = {},
-                        modifier = modifier.fillMaxWidth(0.75f)
-                    )
-                    Text(
-                        text = if (pass.isDeepSpace) defaultTime else sdfTime.format(Date(pass.losTime)),
-                        fontSize = 15.sp
-                    )
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/passes/PassesState.kt

@@ -1,45 +0,0 @@
-/*
- * 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.presentation.passes
-
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-
-data class PassesState(
-    val isPassesDialogShown: Boolean,
-    val isRadiosDialogShown: Boolean,
-    val isRefreshing: Boolean,
-    val isUtc: Boolean,
-    val nextPass: OrbitalPass,
-    val nextTime: String,
-    val isNextTimeAos: Boolean,
-    val hours: Int,
-    val elevation: Double,
-    val modes: List<String>,
-    val itemsList: List<OrbitalPass>,
-    val shouldSeeWhatsNew: Boolean,
-    val takeAction: (PassesAction) -> Unit
-)
-
-sealed class PassesAction {
-    data object DismissWhatsNew : PassesAction()
-    data class FilterPasses(val hoursAhead: Int, val minElevation: Double) : PassesAction()
-    data class FilterRadios(val modes: List<String>) : PassesAction()
-    data object RefreshPasses : PassesAction()
-    data object TogglePassesDialog : PassesAction()
-    data object ToggleRadiosDialog : PassesAction()
-}

app/src/main/java/com/rtbishop/look4sat/presentation/passes/PassesViewModel.kt

@@ -1,148 +0,0 @@
-/*
- * 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.presentation.passes
-
-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.MainApplication
-import com.rtbishop.look4sat.domain.model.PassesSettings
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.domain.repository.ISatelliteRepo
-import com.rtbishop.look4sat.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.domain.utility.toTimerString
-import com.rtbishop.look4sat.presentation.common.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 PassesViewModel(
-    private val satelliteRepo: ISatelliteRepo,
-    private val settingsRepo: ISettingsRepo
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow(
-        PassesState(
-            isPassesDialogShown = false,
-            isRadiosDialogShown = false,
-            isRefreshing = true,
-            isUtc = settingsRepo.otherSettings.value.stateOfUtc,
-            nextTime = "00:00:00",
-            isNextTimeAos = true,
-            nextPass = getDefaultPass(),
-            hours = settingsRepo.passesSettings.value.hoursAhead,
-            elevation = settingsRepo.passesSettings.value.minElevation,
-            modes = settingsRepo.passesSettings.value.selectedModes,
-            itemsList = emptyList(),
-            shouldSeeWhatsNew = settingsRepo.otherSettings.value.shouldSeeWhatsNew,
-            takeAction = ::handleAction
-        )
-    )
-    private var processing: Job? = null
-    val uiState: StateFlow<PassesState> = _uiState
-
-    init {
-        viewModelScope.launch {
-            delay(1000)
-            satelliteRepo.passes.collectLatest { passes ->
-                processing?.cancelAndJoin()
-                processing = viewModelScope.launch {
-                    while (isActive) {
-                        val timeNow = System.currentTimeMillis()
-                        val newPasses = satelliteRepo.processPasses(passes, timeNow)
-                        setPassInfo(newPasses, timeNow)
-                        _uiState.update { it.copy(isRefreshing = false, itemsList = newPasses) }
-                        delay(1000)
-                    }
-                }
-            }
-        }
-        viewModelScope.launch {
-            settingsRepo.otherSettings.collectLatest { settings ->
-                _uiState.update { it.copy(shouldSeeWhatsNew = settings.shouldSeeWhatsNew) }
-            }
-        }
-    }
-
-    private fun handleAction(action: PassesAction) {
-        when (action) {
-            PassesAction.DismissWhatsNew -> settingsRepo.setWhatsNewDismissed()
-            is PassesAction.FilterPasses -> applyFilter(action.hoursAhead, action.minElevation, uiState.value.modes)
-            is PassesAction.FilterRadios -> applyFilter(uiState.value.hours, uiState.value.elevation, action.modes)
-            PassesAction.RefreshPasses -> refreshPasses()
-            PassesAction.TogglePassesDialog -> toggleFilterDialog()
-            PassesAction.ToggleRadiosDialog -> toggleRadiosDialog()
-        }
-    }
-
-    private fun applyFilter(hoursAhead: Int, minElevation: Double, modes: List<String>) = viewModelScope.launch {
-        _uiState.update { it.copy(isRefreshing = true) }
-        processing?.cancelAndJoin()
-        settingsRepo.setPassesSettings(PassesSettings(hoursAhead, minElevation, modes))
-        _uiState.update { it.copy(hours = hoursAhead, elevation = minElevation, modes = modes) }
-        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
-    }
-
-    private fun refreshPasses() = viewModelScope.launch {
-        _uiState.update { it.copy(isRefreshing = true) }
-        processing?.cancelAndJoin()
-        val (hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
-        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
-    }
-
-    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 toggleFilterDialog() {
-        val currentDialogState = _uiState.value.isPassesDialogShown
-        _uiState.update { it.copy(isPassesDialogShown = currentDialogState.not()) }
-    }
-
-    private fun toggleRadiosDialog() {
-        val currentDialogState = _uiState.value.isRadiosDialogShown
-        _uiState.update { it.copy(isRadiosDialogShown = currentDialogState.not()) }
-    }
-
-    companion object {
-        val Factory: ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
-            initializer {
-                val container = (this[applicationKey] as MainApplication).container
-                PassesViewModel(container.satelliteRepo, container.settingsRepo)
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/radar/RadarScreen.kt

@@ -1,489 +0,0 @@
-/*
- * 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.presentation.radar
-
-import androidx.compose.animation.core.LinearEasing
-import androidx.compose.animation.core.RepeatMode
-import androidx.compose.animation.core.animateFloat
-import androidx.compose.animation.core.infiniteRepeatable
-import androidx.compose.animation.core.rememberInfiniteTransition
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.draw.rotate
-import androidx.compose.ui.keepScreenOn
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-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 androidx.navigation.navArgument
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.domain.model.SatRadio
-import com.rtbishop.look4sat.domain.utility.toDegrees
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.Screen
-import com.rtbishop.look4sat.presentation.common.EmptyListCard
-import com.rtbishop.look4sat.presentation.common.IconCard
-import com.rtbishop.look4sat.presentation.common.NextPassRow
-import com.rtbishop.look4sat.presentation.common.TimerRow
-import com.rtbishop.look4sat.presentation.common.TopBar
-import com.rtbishop.look4sat.presentation.common.getDefaultPass
-import com.rtbishop.look4sat.presentation.common.infiniteMarquee
-import com.rtbishop.look4sat.presentation.common.isVerticalLayout
-import com.rtbishop.look4sat.presentation.common.layoutPadding
-
-fun NavGraphBuilder.radarDestination(navigateUp: () -> Unit) {
-    val radarRoute = "${Screen.Radar.route}?catNum={catNum}&aosTime={aosTime}"
-    val radarArgs = listOf(
-        navArgument("catNum") { defaultValue = 0 },
-        navArgument("aosTime") { defaultValue = 0L }
-    )
-    composable(radarRoute, radarArgs) {
-        val viewModel = viewModel(RadarViewModel::class.java, factory = RadarViewModel.Factory)
-        val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
-        RadarScreen(uiState, navigateUp)
-    }
-}
-
-@Composable
-private fun RadarScreen(uiState: RadarState, navigateUp: () -> Unit) {
-//    BluetoothCIV.init(LocalContext.current)
-    val addToCalendar: () -> Unit = {
-        uiState.currentPass?.let { pass ->
-            uiState.sendAction(RadarAction.AddToCalendar(pass.name, pass.aosTime, pass.losTime))
-        }
-    }
-    val upcomingPass = uiState.currentPass ?: getDefaultPass()
-    if (upcomingPass.losTime < System.currentTimeMillis()) navigateUp()
-    Column(modifier = Modifier.layoutPadding().keepScreenOn(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
-        if (isVerticalLayout()) {
-            TopBar {
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isCurrentTimeAos)
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
-            }
-            TopBar { NextPassRow(pass = upcomingPass) }
-        } else {
-            TopBar {
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isCurrentTimeAos)
-                NextPassRow(pass = upcomingPass, modifier = Modifier.weight(1f))
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
-            }
-        }
-        if(isVerticalLayout()) {
-            ElevatedCard(modifier = Modifier.weight(1f)) {
-                Box(contentAlignment = Alignment.Center) {
-                    if (uiState.orbitalPos == null) {
-                        ElevatedCard(modifier = Modifier.fillMaxSize()) {
-                            EmptyListCard(message = "")
-                        }
-                    }
-                    uiState.orbitalPos?.let { position ->
-                        RadarViewCompose(
-                            item = position,
-                            items = uiState.satTrack,
-                            azimElev = uiState.orientationValues,
-                            shouldShowSweep = uiState.shouldShowSweep,
-                            shouldUseCompass = uiState.shouldUseCompass,
-                            modifier = Modifier.align(Alignment.Center)
-                        )
-                        Column(
-                            verticalArrangement = Arrangement.SpaceBetween,
-                            modifier = Modifier
-                                .fillMaxSize()
-                                .padding(horizontal = 6.dp, vertical = 4.dp)
-                        ) {
-                            Row(
-                                horizontalArrangement = Arrangement.SpaceBetween,
-                                modifier = Modifier.fillMaxWidth()
-                            ) {
-                                RadarTextTop(
-                                    position.azimuth,
-                                    stringResource(R.string.radar_az_text),
-                                    true
-                                )
-                                RadarTextTop(
-                                    position.elevation,
-                                    stringResource(R.string.radar_el_text),
-                                    false
-                                )
-                            }
-                            Row(
-                                horizontalArrangement = Arrangement.SpaceBetween,
-                                modifier = Modifier.fillMaxWidth()
-                            ) {
-                                RadarTextBottom(
-                                    position.altitude,
-                                    stringResource(R.string.radar_alt_text),
-                                    true
-                                )
-                                RadarTextBottom(
-                                    position.distance,
-                                    stringResource(R.string.radar_dist_text),
-                                    false
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-            ElevatedCard(modifier = Modifier.weight(1f)) {
-                if (uiState.transmitters.isEmpty()) {
-                    Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
-                        Column(
-                            horizontalAlignment = Alignment.CenterHorizontally,
-                            verticalArrangement = Arrangement.spacedBy(24.dp),
-                            modifier = Modifier.padding(32.dp)
-                        ) {
-                            Text(text = """¯\_(ツ)_/¯""", fontSize = 32.sp)
-                            Text(
-                                text = stringResource(R.string.empty_list_message),
-                                fontSize = 21.sp,
-                                textAlign = TextAlign.Center
-                            )
-                            Text(
-                                text = stringResource(R.string.radar_no_data),
-                                fontSize = 18.sp,
-                                textAlign = TextAlign.Center
-                            )
-                        }
-                    }
-                } else {
-                    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-                        TransmittersList(
-                            transmitters = uiState.transmitters,
-                            selectedUuid = uiState.selectedTransmitterUuid,
-                            onSelect = { uuid ->
-                                if (uiState.selectedTransmitterUuid != null) {
-                                    uiState.sendAction(RadarAction.SelectTransmitter(uuid))
-                                }
-                            }
-                        )
-                        if (uiState.orbitalPos?.eclipsed == true) {
-                            EclipsedIndicator()
-                        }
-                    }
-                }
-            }
-        } else {
-            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                ElevatedCard(modifier = Modifier.weight(1f)) {
-                    Box(contentAlignment = Alignment.Center) {
-                        if (uiState.orbitalPos == null) {
-                            ElevatedCard(modifier = Modifier.fillMaxSize()) {
-                                EmptyListCard(message = "")
-                            }
-                        }
-                        uiState.orbitalPos?.let { position ->
-                            RadarViewCompose(
-                                item = position,
-                                items = uiState.satTrack,
-                                azimElev = uiState.orientationValues,
-                                shouldShowSweep = uiState.shouldShowSweep,
-                                shouldUseCompass = false,
-                                modifier = Modifier.align(Alignment.Center)
-                            )
-                            Column(
-                                verticalArrangement = Arrangement.SpaceBetween,
-                                modifier = Modifier
-                                    .fillMaxSize()
-                                    .padding(horizontal = 6.dp, vertical = 4.dp)
-                            ) {
-                                Row(
-                                    horizontalArrangement = Arrangement.SpaceBetween,
-                                    modifier = Modifier.fillMaxWidth()
-                                ) {
-                                    RadarTextTop(
-                                        position.azimuth,
-                                        stringResource(R.string.radar_az_text),
-                                        true
-                                    )
-                                    RadarTextTop(
-                                        position.elevation,
-                                        stringResource(R.string.radar_el_text),
-                                        false
-                                    )
-                                }
-                                Row(
-                                    horizontalArrangement = Arrangement.SpaceBetween,
-                                    modifier = Modifier.fillMaxWidth()
-                                ) {
-                                    RadarTextBottom(
-                                        position.altitude,
-                                        stringResource(R.string.radar_alt_text),
-                                        true
-                                    )
-                                    RadarTextBottom(
-                                        position.distance,
-                                        stringResource(R.string.radar_dist_text),
-                                        false
-                                    )
-                                }
-                            }
-                        }
-                    }
-                }
-                ElevatedCard(modifier = Modifier.weight(1f)) {
-                    if (uiState.transmitters.isEmpty()) {
-                        Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
-                            Column(
-                                horizontalAlignment = Alignment.CenterHorizontally,
-                                verticalArrangement = Arrangement.spacedBy(24.dp),
-                                modifier = Modifier.padding(32.dp)
-                            ) {
-                                Text(text = """¯\_(ツ)_/¯""", fontSize = 32.sp)
-                                Text(
-                                    text = stringResource(R.string.empty_list_message),
-                                    fontSize = 21.sp,
-                                    textAlign = TextAlign.Center
-                                )
-                                Text(
-                                    text = stringResource(R.string.radar_no_data),
-                                    fontSize = 18.sp,
-                                    textAlign = TextAlign.Center
-                                )
-                            }
-                        }
-                    } else {
-                        Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-                            TransmittersList(
-                                transmitters = uiState.transmitters,
-                                selectedUuid = uiState.selectedTransmitterUuid,
-                                onSelect = { uuid ->
-                                    if (uiState.selectedTransmitterUuid != null) {
-                                        uiState.sendAction(RadarAction.SelectTransmitter(uuid))
-                                    }
-                                }
-                            )
-                            if (uiState.orbitalPos?.eclipsed == true) {
-                                EclipsedIndicator()
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun RadarTextTop(value: Double, text: String, isLeft: Boolean) {
-    val alignment = if (isLeft) Alignment.Start else Alignment.End
-    val degValue = stringResource(R.string.radar_az_value, value.toDegrees())
-    Column(horizontalAlignment = alignment) {
-        Text(text = degValue, fontSize = 18.sp)
-        Text(text = text, fontSize = 15.sp)
-    }
-}
-
-@Composable
-private fun RadarTextBottom(value: Double, text: String, isLeft: Boolean) {
-    val alignment = if (isLeft) Alignment.Start else Alignment.End
-    val degValue = stringResource(R.string.radar_alt_value, value)
-    Column(horizontalAlignment = alignment) {
-        Text(text = text, fontSize = 15.sp)
-        Text(text = degValue, fontSize = 18.sp)
-    }
-}
-
-@Composable
-private fun TransmittersList(
-    transmitters: List<SatRadio>,
-    selectedUuid: String?,
-    onSelect: (String) -> Unit
-) {
-    LazyColumn(modifier = Modifier.fillMaxSize()) {
-        items(items = transmitters, key = { item -> item.uuid }) { radio ->
-            TransmitterItem(
-                radio,
-                (selectedUuid != null),
-                (radio.uuid == selectedUuid)
-            ) { onSelect(radio.uuid) }
-        }
-    }
-}
-
-@Preview
-@Composable
-private fun TransmitterItemPreview() {
-    val transmitter = SatRadio(
-        "", "Extremely powerful transmitter", true, 10000000000L, 10000000000L,
-        null, 10000000000L, 10000000000L, "FSK AX.100 Mode 5", true, 0
-    )
-    MainTheme { TransmitterItem(transmitter, isClickable = true, isSelected = true, onClick = {}) }
-}
-
-@Composable
-private fun EclipsedIndicator() {
-    val bgColor = MaterialTheme.colorScheme.primary
-    val bgShape = MaterialTheme.shapes.medium
-    val infiniteTransition = rememberInfiniteTransition()
-    val textAlpha = infiniteTransition.animateFloat(
-        initialValue = 1.0f,
-        targetValue = 0.0f,
-        animationSpec = infiniteRepeatable(
-            animation = tween(
-                durationMillis = 1000,
-                delayMillis = 25,
-                easing = LinearEasing
-            ),
-            repeatMode = RepeatMode.Reverse
-        )
-    )
-    Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .alpha(textAlpha.value)
-            .border(width = 2.dp, color = bgColor, shape = bgShape),
-        contentAlignment = Alignment.Center
-    ) {
-        Text(
-            text = stringResource(R.string.radar_eclipsed),
-            fontSize = 18.sp,
-            fontWeight = FontWeight.Medium,
-            color = MaterialTheme.colorScheme.background,
-            modifier = Modifier
-                .background(color = bgColor, shape = bgShape)
-                .padding(12.dp)
-        )
-    }
-}
-
-@Composable
-private fun TransmitterItem(
-    radio: SatRadio,
-    isClickable: Boolean,
-    isSelected: Boolean,
-    onClick: () -> Unit
-) {
-    val title = if (radio.isInverted) "INVERTED: ${radio.info}" else radio.info
-    val fullTitle = "$title - (${radio.downlinkMode ?: "--"}/${radio.uplinkMode ?: "--"})"
-    Surface(
-        color = MaterialTheme.colorScheme.background,
-        modifier = Modifier
-            .fillMaxWidth()
-            .then(if (isClickable) Modifier.clickable { onClick() } else Modifier)
-    ) {
-        Surface(modifier = Modifier.padding(bottom = 2.dp)) {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.spacedBy(6.dp),
-                modifier = Modifier
-                    .background(MaterialTheme.colorScheme.surface)
-                    .padding(horizontal = 8.dp, vertical = 6.dp)
-            ) {
-                Box {
-                    Text(
-                        text = fullTitle,
-                        textAlign = TextAlign.Center,
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 6.dp)
-                            .infiniteMarquee()
-                    )
-                    if (isSelected) {
-                        Icon(
-                            painter = painterResource(id = R.drawable.ic_radios),
-                            contentDescription = null,
-                            tint = MaterialTheme.colorScheme.primary,
-                            modifier = Modifier.background(color = MaterialTheme.colorScheme.surface)
-                        )
-                    }
-                }
-                FrequencyRow(radio = radio, isDownlink = true)
-                FrequencyRow(radio = radio, isDownlink = false)
-            }
-        }
-    }
-}
-
-@Composable
-private fun FrequencyRow(radio: SatRadio, isDownlink: Boolean, modifier: Modifier = Modifier) {
-    Row(verticalAlignment = Alignment.CenterVertically, modifier = modifier.fillMaxWidth()) {
-        val rotateMod = Modifier.rotate(if (isDownlink) 90f else -90f)
-        val weightMod = Modifier.weight(1f)
-        val desc = if (isDownlink) stringResource(R.string.radar_downlink) else stringResource(R.string.radar_uplink)
-        Text(
-            text = if (isDownlink) "D:" else "U:",
-            textAlign = TextAlign.Center,
-            fontSize = 18.sp,
-            color = MaterialTheme.colorScheme.onSurface,
-            modifier = modifier.size(width = 24.dp, height = 24.dp).semantics { contentDescription = desc }
-        )
-        FrequencyText(if (isDownlink) radio.downlinkLow else radio.uplinkLow, weightMod)
-        Text(
-            text = "-",
-            textAlign = TextAlign.Center,
-            fontSize = 21.sp,
-            fontWeight = FontWeight.Bold,
-            color = MaterialTheme.colorScheme.primary,
-            modifier = modifier
-        )
-        FrequencyText(if (isDownlink) radio.downlinkHigh else radio.uplinkHigh, weightMod)
-        Icon(
-            painter = painterResource(id = R.drawable.ic_arrow),
-            tint = MaterialTheme.colorScheme.onSurface,
-            contentDescription = null,
-            modifier = rotateMod.size(width = 24.dp, height = 24.dp)
-        )
-    }
-}
-
-@Composable
-private fun FrequencyText(frequency: Long?, modifier: Modifier = Modifier) {
-    val noLinkText = stringResource(R.string.radar_no_link)
-    val freqValue = frequency?.let { it / 1000000f }
-    Text(
-        text = freqValue?.let { stringResource(id = R.string.radar_link_low, it) } ?: noLinkText,
-        textAlign = TextAlign.Center,
-        fontSize = 21.sp,
-        fontWeight = FontWeight.Bold,
-        color = MaterialTheme.colorScheme.primary,
-        modifier = modifier
-    )
-}

app/src/main/java/com/rtbishop/look4sat/presentation/radar/RadarState.kt

@@ -1,42 +0,0 @@
-/*
- * 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.presentation.radar
-
-import com.rtbishop.look4sat.domain.model.SatRadio
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.domain.predict.OrbitalPos
-
-data class RadarState(
-    val currentPass: OrbitalPass?,
-    val currentTime: String,
-    val isCurrentTimeAos: Boolean,
-    val orientationValues: Pair<Float, Float>,
-    val orbitalPos: OrbitalPos?,
-    val satTrack: List<OrbitalPos>,
-    val shouldShowSweep: Boolean,
-    val shouldUseCompass: Boolean,
-    val transmitters: List<SatRadio>,
-    val selectedTransmitterUuid: String?,
-    val selectedFrequency: Long?,
-    val sendAction: (RadarAction) -> Unit
-)
-
-sealed class RadarAction {
-    data class AddToCalendar(val name: String, val aosTime: Long, val losTime: Long) : RadarAction()
-    data class SelectTransmitter(val uuid: String) : RadarAction()
-}

app/src/main/java/com/rtbishop/look4sat/presentation/radar/RadarView.kt

@@ -1,252 +0,0 @@
-/*
- * 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.presentation.radar
-
-import androidx.compose.animation.core.animateFloat
-import androidx.compose.animation.core.infiniteRepeatable
-import androidx.compose.animation.core.rememberInfiniteTransition
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.Path
-import androidx.compose.ui.graphics.PathEffect
-import androidx.compose.ui.graphics.PathMeasure
-import androidx.compose.ui.graphics.ShaderBrush
-import androidx.compose.ui.graphics.StampedPathEffectStyle
-import androidx.compose.ui.graphics.SweepGradientShader
-import androidx.compose.ui.graphics.drawscope.DrawScope
-import androidx.compose.ui.graphics.drawscope.Fill
-import androidx.compose.ui.graphics.drawscope.Stroke
-import androidx.compose.ui.graphics.drawscope.rotate
-import androidx.compose.ui.graphics.drawscope.translate
-import androidx.compose.ui.text.TextMeasurer
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.drawText
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.unit.sp
-import com.rtbishop.look4sat.domain.predict.OrbitalPos
-import com.rtbishop.look4sat.domain.predict.PI_2
-import com.rtbishop.look4sat.domain.utility.toRadians
-import kotlin.math.cos
-import kotlin.math.sin
-
-@Composable
-fun RadarViewCompose(
-    item: OrbitalPos,
-    items: List<OrbitalPos>,
-    azimElev: Pair<Float, Float>,
-    shouldShowSweep: Boolean,
-    shouldUseCompass: Boolean,
-    modifier: Modifier = Modifier
-) {
-//    val context = LocalContext.current
-//    val view = LocalView.current
-    val radarColor = MaterialTheme.colorScheme.secondary
-    val trackColor = MaterialTheme.colorScheme.primary
-    val aimColor = MaterialTheme.colorScheme.error
-    val strokeWidth = 6f
-    val animTransition = rememberInfiniteTransition(label = "animScale")
-    val animSpec = infiniteRepeatable<Float>(tween(1000))
-    val animScale = animTransition.animateFloat(16f, 64f, animSpec, label = "animScale")
-//    val aimThreshold = 0.05f
-    val measurer = rememberTextMeasurer()
-    val sweepDegrees = remember { mutableFloatStateOf(0f) }
-    val trackCreated = remember { mutableStateOf(false) }
-    val trackPath = remember { mutableStateOf(Path()) }
-    val trackEffect = remember { mutableStateOf(PathEffect.cornerPathEffect(0f)) }
-//    val soundPool = remember { mutableStateOf<SoundPool?>(null) }
-//    val beepSoundId = remember { mutableIntStateOf(0) }
-//    val aimTargetDifference = remember { mutableFloatStateOf(0f) }
-
-//    LaunchedEffect(item.azimuth, item.elevation, azimElev.first, azimElev.second) {
-//        val aimAzimuthRadians = azimElev.first.toDouble().toRadians()
-//        val aimElevationRadians = abs(min(azimElev.second, 0f)).toDouble().toRadians()
-//        // radius of 0.5 makes the aimTargetDifference range 0.0 to 1.0
-//        val radius = 0.5
-//        val aimX = sph2CartX(aimAzimuthRadians, aimElevationRadians, radius)
-//        val aimY = sph2CartY(aimAzimuthRadians, aimElevationRadians, radius)
-//        val satX = sph2CartX(item.azimuth, item.elevation, radius)
-//        val satY = sph2CartY(item.azimuth, item.elevation, radius)
-//        aimTargetDifference.floatValue = sqrt((satX - aimX).pow(2) + (satY - aimY).pow(2))
-//        val minPlaybackRate = 0.5f
-//        val maxPlaybackRate = 2.0f
-//        val playbackRate =
-//            maxPlaybackRate - (aimTargetDifference.floatValue / (maxPlaybackRate - minPlaybackRate))
-//        soundPool.value?.setRate(beepSoundId.intValue, playbackRate)
-//    }
-//
-//    LaunchedEffect(aimTargetDifference.floatValue < aimThreshold) {
-//        if (aimTargetDifference.floatValue < aimThreshold) {
-//            view.performHapticFeedback(HapticFeedbackConstantsCompat.VIRTUAL_KEY)
-//            soundPool.value?.pause(beepSoundId.intValue)
-//        } else {
-//            soundPool.value?.resume(beepSoundId.intValue)
-//        }
-//    }
-//
-//    LaunchedEffect(item.elevation > 0) {
-//        if(item.elevation > 0) {
-//            soundPool.value?.resume(beepSoundId.intValue)
-//        } else {
-//            soundPool.value?.pause(beepSoundId.intValue)
-//        }
-//    }
-//
-//    DisposableEffect(Unit) {
-//        val audioAttributes = AudioAttributes.Builder()
-//            .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION)
-//            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-//            .build()
-//        soundPool.value = SoundPool.Builder()
-//            .setMaxStreams(1)
-//            .setAudioAttributes(audioAttributes)
-//            .build()
-//        beepSoundId.intValue = soundPool.value?.load(context, R.raw.beep, 1) ?: 0
-//        soundPool.value?.setOnLoadCompleteListener { soundPool, _, status ->
-//            if (status == 0) {
-//                soundPool.play(beepSoundId.intValue, 0.5f, 0.5f, 0, -1, 1f)
-//            }
-//        }
-//        onDispose {
-//            soundPool.value?.release()
-//        }
-//    }
-
-    Canvas(modifier = modifier.aspectRatio(1f)) {
-        val radius = (size.minDimension / 2f) * 0.95f
-        if (!trackCreated.value) {
-            trackPath.value = createTrackPath(items, radius)
-            trackEffect.value = createTrackEffect(trackPath.value)
-            trackCreated.value = true
-        }
-        rotate(if (shouldUseCompass) -azimElev.first else 0f) {
-            if (shouldShowSweep) {
-                drawSweep(center, sweepDegrees.floatValue, radius, trackColor)
-            }
-            drawRadar(radius, radarColor, strokeWidth, 3)
-            drawInfo(radius, trackColor, measurer, 3)
-            translate(center.x, center.y) {
-                drawTrack(trackPath.value, trackEffect.value, aimColor, trackColor)
-                if (item.elevation > 0) {
-                    drawPosition(item, radius, animScale.value, trackColor)
-                }
-                if (shouldUseCompass) {
-                    drawAim(azimElev.first, azimElev.second, radius, strokeWidth, aimColor)
-                }
-            }
-            sweepDegrees.floatValue = (sweepDegrees.floatValue + 360 / 12.0f / 60) % 360
-        }
-    }
-}
-
-private fun DrawScope.drawRadar(radius: Float, color: Color, width: Float, circles: Int) {
-    for (i in 0 until circles) {
-        val circleRadius = radius - radius / circles.toFloat() * i.toFloat()
-        drawCircle(color, circleRadius, style = Stroke(width))
-    }
-    drawLine(color, center.copy(x = center.x - radius), center.copy(x = center.x + radius), width)
-    drawLine(color, center.copy(y = center.y - radius), center.copy(y = center.y + radius), width)
-}
-
-private fun DrawScope.drawInfo(radius: Float, color: Color, measurer: TextMeasurer, circles: Int) {
-    for (i in 0 until circles) {
-        val textY = (radius - radius / circles * i) - 32f
-        val textDeg = " ${(90 / circles) * (circles - i)}°"
-        drawText(measurer, textDeg, center.copy(y = textY), style = TextStyle(color, 15.sp))
-    }
-}
-
-private fun DrawScope.drawTrack(path: Path, effect: PathEffect, color: Color, effectColor: Color) {
-    drawPath(path, color, style = Stroke(6f))
-    drawPath(path, effectColor, style = Stroke(pathEffect = effect))
-}
-
-private fun DrawScope.drawPosition(item: OrbitalPos, radius: Float, posRadius: Float, color: Color) {
-    val satX = sph2CartX(item.azimuth, item.elevation, radius.toDouble())
-    val satY = sph2CartY(item.azimuth, item.elevation, radius.toDouble())
-    drawCircle(color, 16f, center.copy(satX, -satY))
-    drawCircle(color.copy(alpha = 1 - (posRadius / 64f)), posRadius, center.copy(satX, -satY))
-}
-
-private fun DrawScope.drawAim(azim: Float, elev: Float, radius: Float, width: Float, color: Color) {
-    val size = 36f
-    val azimRadians = azim.toDouble().toRadians()
-    val tempElevRadians = elev.toDouble().toRadians()
-    val elevRadians = if (tempElevRadians > 0.0) 0.0 else tempElevRadians
-    val aimX = sph2CartX(azimRadians, -elevRadians, radius.toDouble())
-    val aimY = sph2CartY(azimRadians, -elevRadians, radius.toDouble())
-    try {
-        drawLine(color, center.copy(aimX - size, -aimY), center.copy(aimX + size, -aimY), width)
-        drawLine(color, center.copy(aimX, -aimY - size), center.copy(aimX, -aimY + size), width)
-        drawCircle(color, size / 2, center.copy(aimX, -aimY), style = Stroke(width))
-    } catch (exception: Exception) {
-        println(exception)
-    }
-}
-
-private fun DrawScope.drawSweep(center: Offset, degrees: Float, radius: Float, color: Color) {
-    val colors = listOf(Color.Transparent, color.copy(alpha = 0.5f), color)
-    val colorStops = listOf(0.64f, 0.995f, 1f)
-    val brush = ShaderBrush(SweepGradientShader(center, colors, colorStops))
-    rotate(-90 + degrees, center) { drawCircle(brush, radius, style = Fill) }
-}
-
-private fun createTrackPath(positions: List<OrbitalPos>, radius: Float): Path {
-    val trackPath = Path()
-    positions.forEachIndexed { index, satPos ->
-        val passX = sph2CartX(satPos.azimuth, satPos.elevation, radius.toDouble())
-        val passY = sph2CartY(satPos.azimuth, satPos.elevation, radius.toDouble())
-        if (index == 0) trackPath.moveTo(passX, -passY) else trackPath.lineTo(passX, -passY)
-    }
-    return trackPath
-}
-
-private fun createTrackEffect(trackPath: Path): PathEffect {
-    val shape = Path()
-    val shapeRadius = 24f
-    val angle = 120.0.toRadians()
-    shape.moveTo((shapeRadius * cos(angle)).toFloat(), (shapeRadius * sin(angle)).toFloat())
-    for (i in 1 until 3) {
-        val x = (shapeRadius * cos(angle - angle * i)).toFloat()
-        val y = (shapeRadius * sin(angle - angle * i)).toFloat()
-        shape.lineTo(x, y)
-    }
-    shape.close()
-    val trackLength = PathMeasure().apply { setPath(trackPath, false) }.length
-    val advance = trackLength / 2f
-    val phase = trackLength / 4f
-    return PathEffect.stampedPathEffect(shape, advance, phase, StampedPathEffectStyle.Rotate)
-}
-
-private fun sph2CartX(azim: Double, elev: Double, r: Double): Float {
-    val radius = r * (PI_2 - elev) / PI_2
-    return (radius * cos(PI_2 - azim)).toFloat()
-}
-
-private fun sph2CartY(azim: Double, elev: Double, r: Double): Float {
-    val radius = r * (PI_2 - elev) / PI_2
-    return (radius * sin(PI_2 - azim)).toFloat()
-}

app/src/main/java/com/rtbishop/look4sat/presentation/radar/RadarViewModel.kt

@@ -1,244 +0,0 @@
-/*
- * 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.presentation.radar
-
-import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.ViewModelProvider
-import androidx.lifecycle.createSavedStateHandle
-import androidx.lifecycle.viewModelScope
-import androidx.lifecycle.viewmodel.initializer
-import androidx.lifecycle.viewmodel.viewModelFactory
-import com.rtbishop.look4sat.MainApplication
-import com.rtbishop.look4sat.data.framework.WithoutExtParams
-import com.rtbishop.look4sat.data.framework.BluetoothReporter
-import com.rtbishop.look4sat.data.framework.BtService
-import com.rtbishop.look4sat.data.framework.ExtendedParams
-import com.rtbishop.look4sat.data.framework.NetworkReporter
-import com.rtbishop.look4sat.domain.model.SatRadio
-import com.rtbishop.look4sat.domain.predict.OrbitalObject
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.domain.predict.OrbitalPos
-import com.rtbishop.look4sat.domain.repository.ISatelliteRepo
-import com.rtbishop.look4sat.domain.repository.ISensorsRepo
-import com.rtbishop.look4sat.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.domain.usecase.IAddToCalendar
-import com.rtbishop.look4sat.domain.utility.round
-import com.rtbishop.look4sat.domain.utility.toDegrees
-import com.rtbishop.look4sat.domain.utility.toTimerString
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-
-class RadarViewModel(
-    private val savedStateHandle: SavedStateHandle,
-    private val bluetoothReporter: BluetoothReporter,
-    private val networkReporter: NetworkReporter,
-    private val satelliteRepo: ISatelliteRepo,
-    private val settingsRepo: ISettingsRepo,
-    private val sensorsRepo: ISensorsRepo,
-    private val addToCalendar: IAddToCalendar
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow(
-        RadarState(
-            currentPass = null,
-            currentTime = "00:00:00",
-            isCurrentTimeAos = true,
-            orientationValues = sensorsRepo.orientation.value,
-            orbitalPos = null,
-            satTrack = emptyList(),
-            shouldShowSweep = settingsRepo.otherSettings.value.stateOfSweep,
-            shouldUseCompass = settingsRepo.otherSettings.value.stateOfSensors,
-            selectedTransmitterUuid = null,
-            selectedFrequency = null,
-            transmitters = emptyList(),
-            sendAction = ::handleAction,
-        )
-    )
-    private val stationPos = settingsRepo.stationPosition.value
-    private val magDeclination = sensorsRepo.getMagDeclination(stationPos)
-    val uiState: StateFlow<RadarState> = _uiState
-
-    init {
-        if (settingsRepo.otherSettings.value.stateOfSensors) {
-            viewModelScope.launch {
-                sensorsRepo.enableSensor()
-                sensorsRepo.orientation.collect { data ->
-                    val orientationValues = Pair(data.first + magDeclination, data.second)
-                    _uiState.update { it.copy(orientationValues = orientationValues) }
-                }
-            }
-        }
-        viewModelScope.launch {
-            val catNum = savedStateHandle.get<Int>("catNum") ?: 0
-            val aosTime = savedStateHandle.get<Long>("aosTime") ?: 0L
-            val passes = satelliteRepo.passes.value
-            val pass = passes.find { pass -> pass.catNum == catNum && pass.aosTime == aosTime }
-            val currentPass = pass ?: passes.firstOrNull()
-            currentPass?.let { satPass ->
-                _uiState.update { it.copy(currentPass = satPass) }
-                val transmitters = satelliteRepo.getRadiosWithId(satPass.catNum)
-                while (isActive) {
-                    val timeNow = System.currentTimeMillis()
-                    val pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, timeNow)
-                    when {
-                        satPass.isDeepSpace -> {
-                            val time = 0L.toTimerString()
-                            _uiState.update { it.copy(currentTime = time, isCurrentTimeAos = false) }
-                        }
-                        satPass.aosTime > timeNow -> {
-                            val time = satPass.aosTime.minus(timeNow).toTimerString()
-                            _uiState.update { it.copy(currentTime = time, isCurrentTimeAos = true) }
-                        }
-                        else -> {
-                            val time = satPass.losTime.minus(timeNow).toTimerString()
-                            _uiState.update { it.copy(currentTime = time, isCurrentTimeAos = false) }
-                        }
-                    }
-                    processRadios(transmitters, satPass.orbitalObject, timeNow)
-                    sendPassData(satPass, pos, satPass.orbitalObject)
-                    sendPassDataBT(pos)
-                    delay(1000)
-                }
-            }
-        }
-    }
-
-    override fun onCleared() {
-        sensorsRepo.disableSensor()
-        super.onCleared()
-    }
-
-    private fun handleAction(action: RadarAction) {
-        when (action) {
-            is RadarAction.AddToCalendar -> addToCalendar(action.name, action.aosTime, action.losTime)
-            is RadarAction.SelectTransmitter -> { _uiState.update { it.copy(selectedTransmitterUuid = action.uuid) } }
-        }
-    }
-
-    private suspend fun sendPassData(orbitalPass: OrbitalPass, orbitalPos: OrbitalPos, orbitalObject: OrbitalObject) {
-        var track: List<OrbitalPos> = emptyList()
-        if (!orbitalPass.isDeepSpace) {
-            track = satelliteRepo.getTrack(
-                orbitalObject, stationPos, orbitalPass.aosTime, orbitalPass.losTime
-            )
-        }
-        _uiState.update { it.copy(orbitalPos = orbitalPos, satTrack = track) }
-        viewModelScope.launch {
-            if (settingsRepo.rcSettings.value.rotatorState) {
-                val server = settingsRepo.rcSettings.value.rotatorAddress
-                val port = settingsRepo.rcSettings.value.rotatorPort.toInt()
-                val format = settingsRepo.rcSettings.value.rotatorFormat
-                val azimuth = orbitalPos.azimuth.toDegrees().round(2)
-                val elevation = orbitalPos.elevation.toDegrees().round(2)
-                networkReporter.reportRotation(format, azimuth, elevation, ExtendedParams(server, port))
-            }
-            if (settingsRepo.rcSettings.value.frequencyState) {
-                _uiState.value.selectedFrequency?.let { freq ->
-                    val server = settingsRepo.rcSettings.value.frequencyAddress
-                    val port = settingsRepo.rcSettings.value.frequencyPort.toInt()
-                    val format = settingsRepo.rcSettings.value.frequencyFormat
-                    networkReporter.reportFrequency(format,freq, ExtendedParams(server, port))
-                }
-            }
-        }
-    }
-
-    private fun sendPassDataBT(orbitalPos: OrbitalPos) {
-        viewModelScope.launch {
-            if (settingsRepo.rcSettings.value.bluetoothRotatorState) {
-                val btRotatorDevice = settingsRepo.rcSettings.value.bluetoothRotatorAddress
-                if (bluetoothReporter.isConnected(BtService.ROTATOR)) {
-                    val format = settingsRepo.rcSettings.value.bluetoothRotatorFormat
-                    val azimuth = orbitalPos.azimuth.toDegrees().round(0)
-                    val elevation = orbitalPos.elevation.toDegrees().round(0)
-                    bluetoothReporter.reportRotation(format, azimuth, elevation, WithoutExtParams(0))
-                } else if (!bluetoothReporter.isConnecting(BtService.ROTATOR)) {
-//                    Log.i("BTReporter", "BTReporter (rotator): Attempting to connect...")
-                    bluetoothReporter.connect(BtService.ROTATOR,btRotatorDevice)
-                }
-            }
-            if (settingsRepo.rcSettings.value.bluetoothFrequencyState) {
-                val btFrequencyDevice = settingsRepo.rcSettings.value.bluetoothFrequencyAddress
-                if (bluetoothReporter.isConnected(BtService.FREQUENCY)) {
-                    val format = settingsRepo.rcSettings.value.bluetoothFrequencyFormat
-                    val frequency = _uiState.value.selectedFrequency
-                    frequency?.let { freq ->
-                        bluetoothReporter.reportFrequency(format, freq, WithoutExtParams(0))
-                    }
-                } else if (!bluetoothReporter.isConnecting(BtService.FREQUENCY)) {
-//                    Log.i("BTReporter", "BTReporter (frequency): Attempting to connect...")
-                    bluetoothReporter.connect(BtService.FREQUENCY, btFrequencyDevice)
-                }
-            }
-        }
-    }
-
-    private suspend fun processRadios(radios: List<SatRadio>, orbitalObject: OrbitalObject, time: Long) {
-        val transmitters = satelliteRepo.getRadios(orbitalObject, stationPos, radios, time)
-        _uiState.update { state ->
-            if (!settingsRepo.rcSettings.value.frequencyState && !settingsRepo.rcSettings.value.bluetoothFrequencyState) {
-                return@update state.copy(
-                    transmitters = transmitters,
-                    selectedTransmitterUuid = null,
-                    selectedFrequency = null
-                )
-            }
-            val selectedUuid = state.selectedTransmitterUuid ?: transmitters.firstOrNull()?.uuid
-            val selectedRadio = transmitters.firstOrNull { it.uuid == selectedUuid }
-            val freq = selectedRadio?.let { radio ->
-                val low = radio.downlinkLow
-                val high = radio.downlinkHigh
-                when {
-                    low != null && high != null ->
-                        (low + high) / 2
-                    low != null ->
-                        low
-                    else -> null
-                }
-            }
-            state.copy(
-                transmitters = transmitters,
-                selectedTransmitterUuid = selectedUuid,
-                selectedFrequency = freq
-            )
-        }
-    }
-
-    companion object {
-        val Factory: ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
-            initializer {
-                val container = (this[applicationKey] as MainApplication).container
-                RadarViewModel(
-                    createSavedStateHandle(),
-                    container.provideBluetoothReporter(),
-                    container.provideNetworkReporter(),
-                    container.satelliteRepo,
-                    container.settingsRepo,
-                    container.provideSensorsRepo(),
-                    container.provideAddToCalendar()
-                )
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/satellites/SatellitesDialog.kt

@@ -1,100 +0,0 @@
-/*
- * 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.presentation.satellites
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.itemsIndexed
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.common.SharedDialog
-
-@Preview(showBackground = true)
-@Composable
-private fun MultiTypesDialogPreview() {
-    val types = listOf("Amateur", "Geostationary", "Military", "Weather")
-    MainTheme { MultiTypesDialog(types, emptyList(), {}) {} }
-}
-
-@Composable
-fun MultiTypesDialog(
-    allTypes: List<String>, types: List<String>, cancel: () -> Unit, accept: (List<String>) -> Unit
-) {
-    val selected = remember { mutableStateListOf<String>().apply { addAll(types) } }
-    val select = { type: String ->
-        if (selected.contains(type)) selected.remove(type) else selected.add(type)
-    }
-    val onAccept = { accept(selected.toList()) }
-    SharedDialog(title = stringResource(R.string.sat_type_title), onCancel = cancel, onAccept = onAccept) {
-        LazyVerticalGrid(
-            columns = GridCells.Adaptive(240.dp),
-            modifier = Modifier
-                .fillMaxHeight(0.69f)
-                .background(MaterialTheme.colorScheme.background),
-            horizontalArrangement = Arrangement.spacedBy(1.dp),
-            verticalArrangement = Arrangement.spacedBy(1.dp)
-        ) {
-            itemsIndexed(allTypes) { index, item ->
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
-                        .background(MaterialTheme.colorScheme.surface)
-                        .clickable { select(item) }
-                ) {
-                    Text(
-                        text = "${index + 1}).",
-                        modifier = Modifier.padding(start = 16.dp, end = 8.dp),
-                        fontWeight = FontWeight.Normal,
-                        color = MaterialTheme.colorScheme.primary
-                    )
-                    Text(
-                        text = item,
-                        modifier = Modifier.weight(1f),
-                        fontWeight = FontWeight.Medium,
-                        maxLines = 1,
-                        overflow = TextOverflow.Ellipsis
-                    )
-                    Checkbox(
-                        checked = selected.contains(item),
-                        onCheckedChange = null,
-                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
-                    )
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/satellites/SatellitesScreen.kt

@@ -1,277 +0,0 @@
-/*
- * 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.presentation.satellites
-
-import androidx.compose.foundation.background
-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.fillMaxSize
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.items
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-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.graphics.SolidColor
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-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.R
-import com.rtbishop.look4sat.domain.model.SatItem
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.Screen
-import com.rtbishop.look4sat.presentation.common.CardLoadingIndicator
-import com.rtbishop.look4sat.presentation.common.EmptyListCard
-import com.rtbishop.look4sat.presentation.common.IconCard
-import com.rtbishop.look4sat.presentation.common.InfoDialog
-import com.rtbishop.look4sat.presentation.common.PrimaryIconCard
-import com.rtbishop.look4sat.presentation.common.TopBar
-import com.rtbishop.look4sat.presentation.common.infiniteMarquee
-import com.rtbishop.look4sat.presentation.common.isVerticalLayout
-import com.rtbishop.look4sat.presentation.common.layoutPadding
-
-fun NavGraphBuilder.satellitesDestination(navigateUp: () -> Unit) {
-    composable(Screen.Satellites.route) {
-        val viewModel = viewModel(
-            modelClass = SatellitesViewModel::class.java, factory = SatellitesViewModel.Factory
-        )
-        val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
-        SatellitesScreen(uiState, navigateUp)
-    }
-}
-
-@Composable
-private fun SatellitesScreen(uiState: SatellitesState, navigateUp: () -> Unit) {
-    val toggleDialog = { uiState.takeAction(SatellitesAction.ToggleTypesDialog) }
-    if (uiState.isDialogShown) {
-        MultiTypesDialog(allTypes = uiState.typesList, types = uiState.currentTypes, toggleDialog) {
-            uiState.takeAction(SatellitesAction.SelectTypes(it))
-        }
-    }
-    if (uiState.shouldSeeWarning) {
-        InfoDialog(
-            stringResource(R.string.sat_warning_title),
-            stringResource(R.string.sat_warning_message)
-        ) {
-            uiState.takeAction(SatellitesAction.DismissWarning)
-        }
-    }
-    val unselectAll = { uiState.takeAction(SatellitesAction.UnselectAll) }
-    val selectAll = { uiState.takeAction(SatellitesAction.SelectAll) }
-    val setQuery = { newQuery: String -> uiState.takeAction(SatellitesAction.SearchFor(newQuery)) }
-    val saveSelection = { uiState.takeAction(SatellitesAction.SaveSelection).also { navigateUp() } }
-    val primCardCd = stringResource(R.string.btn_accept)
-    val primCardMod = Modifier.semantics { contentDescription = primCardCd }
-    val clearAllCd = stringResource(R.string.sat_clear_all)
-    val clearAllMod = Modifier.semantics { contentDescription = clearAllCd }
-    val selectAllCd = stringResource(R.string.sat_select_all)
-    val selectAllMod = Modifier.semantics { contentDescription = selectAllCd }
-    Column(modifier = Modifier.layoutPadding(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
-        if (isVerticalLayout()) {
-            TopBar {
-                TypeCard(types = uiState.currentTypes, toggleDialog, modifier = Modifier.weight(1f))
-                PrimaryIconCard(onClick = saveSelection, resId = R.drawable.ic_done, modifier = primCardMod)
-            }
-            TopBar {
-                SearchBar(setQuery = { setQuery(it) }, modifier = Modifier.weight(1f))
-                IconCard(action = unselectAll, resId = R.drawable.ic_check_off, modifier = clearAllMod)
-                IconCard(action = selectAll, resId = R.drawable.ic_check_on, modifier = selectAllMod)
-            }
-        } else {
-            TopBar {
-                PrimaryIconCard(onClick = saveSelection, resId = R.drawable.ic_done, modifier = primCardMod)
-                TypeCard(types = uiState.currentTypes, toggleDialog, modifier = Modifier.weight(1f))
-                SearchBar(setQuery = { setQuery(it) }, modifier = Modifier.weight(1f))
-                IconCard(action = unselectAll, resId = R.drawable.ic_check_off, modifier = clearAllMod)
-                IconCard(action = selectAll, resId = R.drawable.ic_check_on, modifier = selectAllMod)
-            }
-        }
-        ElevatedCard(modifier = Modifier.fillMaxSize()) {
-            val emptyMessage = stringResource(R.string.sat_empty_list_message)
-            when {
-                uiState.isLoading -> CardLoadingIndicator()
-                uiState.itemsList.isEmpty() -> EmptyListCard(message = emptyMessage)
-                else -> SatellitesCard(uiState.itemsList) { id, isTicked ->
-                    uiState.takeAction(SatellitesAction.SelectSingle(id, isTicked))
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun SearchBar(setQuery: (String) -> Unit, modifier: Modifier = Modifier) {
-    val currentQuery = rememberSaveable { mutableStateOf("") }
-    val setNewQuery = { newValue: String ->
-        currentQuery.value = newValue
-        setQuery(newValue)
-    }
-    ElevatedCard(modifier = modifier.height(48.dp)) {
-        Row(
-            horizontalArrangement = Arrangement.Start,
-            verticalAlignment = Alignment.CenterVertically,
-            modifier = Modifier.padding(start = 12.dp)
-        ) {
-            Icon(painter = painterResource(id = R.drawable.ic_search), contentDescription = null)
-            BasicTextField(
-                value = currentQuery.value,
-                onValueChange = { setNewQuery(it) },
-                singleLine = true,
-                modifier = modifier.padding(start = 12.dp),
-                textStyle = TextStyle(
-                    fontSize = 16.sp,
-                    lineHeight = 20.sp,
-                    fontWeight = FontWeight.Medium,
-                    color = MaterialTheme.colorScheme.onSurface
-                ),
-                decorationBox = { innerTextField ->
-                    if (currentQuery.value.isEmpty()) {
-                        Text(
-                            text = stringResource(id = R.string.sat_search_hint),
-                            fontSize = 16.sp,
-                            lineHeight = 20.sp,
-                            fontWeight = FontWeight.Medium,
-                            color = MaterialTheme.colorScheme.onSurface
-                        )
-                    }
-                    innerTextField()
-                },
-                cursorBrush = SolidColor(MaterialTheme.colorScheme.onSurface)
-            )
-            IconButton(onClick = { setNewQuery("") }) {
-                val clearCd = stringResource(R.string.sat_search_clear)
-                Icon(painter = painterResource(id = R.drawable.ic_close), contentDescription = clearCd)
-            }
-        }
-    }
-}
-
-@Composable
-private fun TypeCard(types: List<String>, onClick: () -> Unit, modifier: Modifier = Modifier) {
-    val typesText = if (types.isEmpty()) "All" else types.joinToString(", ")
-    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_tags),
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.primary
-            )
-            Text(
-                text = stringResource(R.string.sat_type_hint, typesText),
-                fontSize = 16.sp,
-                fontWeight = FontWeight.Medium,
-                modifier = Modifier
-                    .weight(1f)
-                    .padding(end = 6.dp)
-                    .infiniteMarquee()
-            )
-        }
-    }
-}
-
-@Preview(showBackground = true)
-@Composable
-private fun SatellitePreview() {
-    val satItem = SatItem(44444, "Ultra Super Mega long satellite name", true)
-    MainTheme { Satellite(item = satItem, onSelected = { _, _ -> run {} }, modifier = Modifier) }
-}
-
-@Composable
-private fun Satellite(item: SatItem, onSelected: (Int, Boolean) -> Unit, modifier: Modifier) {
-    val passSatId = stringResource(id = R.string.pass_satId, item.catnum)
-    Surface(
-        color = MaterialTheme.colorScheme.background,
-        modifier = modifier.clickable { onSelected(item.catnum, item.isSelected) }) {
-        Surface(modifier = Modifier.padding(bottom = 1.dp)) {
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier
-                    .background(MaterialTheme.colorScheme.surface)
-                    .padding(start = 14.dp, top = 8.dp, end = 12.dp, bottom = 8.dp)
-            ) {
-                Text(
-                    text = "$passSatId - ", color = MaterialTheme.colorScheme.primary
-                )
-                Text(
-                    text = item.name,
-                    modifier = Modifier.weight(1f),
-                    fontWeight = FontWeight.Medium,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis
-                )
-                Checkbox(
-                    checked = item.isSelected,
-                    onCheckedChange = null,
-                    modifier = Modifier.padding(start = 6.dp)
-                )
-            }
-        }
-    }
-}
-
-@Preview(showBackground = true)
-@Composable
-private fun SatellitesPreview() {
-    val entries = listOf(
-        SatItem(8888, "Meteor", false),
-        SatItem(44444, "ISS", true),
-        SatItem(88888, "Starlink", false)
-    )
-    MainTheme { SatellitesCard(entries) { _, _ -> run {} } }
-}
-
-@Composable
-fun SatellitesCard(items: List<SatItem>, onSelected: (Int, Boolean) -> Unit) {
-    LazyVerticalGrid(columns = GridCells.Adaptive(320.dp)) {
-        items(items = items, key = { item -> item.catnum }) { entry ->
-            Satellite(entry, onSelected, Modifier.animateItem())
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/satellites/SatellitesState.kt

@@ -1,41 +0,0 @@
-/*
- * 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.presentation.satellites
-
-import com.rtbishop.look4sat.domain.model.SatItem
-
-data class SatellitesState(
-    val isDialogShown: Boolean,
-    val isLoading: Boolean,
-    val shouldSeeWarning: Boolean,
-    val itemsList: List<SatItem>,
-    val currentTypes: List<String>,
-    val typesList: List<String>,
-    val takeAction: (SatellitesAction) -> Unit
-)
-
-sealed class SatellitesAction {
-    data object DismissWarning : SatellitesAction()
-    data object SaveSelection : SatellitesAction()
-    data class SearchFor(val query: String) : SatellitesAction()
-    data object SelectAll : SatellitesAction()
-    data class SelectSingle(val id: Int, val isTicked: Boolean) : SatellitesAction()
-    data class SelectTypes(val types: List<String>) : SatellitesAction()
-    data object ToggleTypesDialog : SatellitesAction()
-    data object UnselectAll : SatellitesAction()
-}

app/src/main/java/com/rtbishop/look4sat/presentation/satellites/SatellitesViewModel.kt

@@ -1,114 +0,0 @@
-/*
- * 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.presentation.satellites
-
-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.MainApplication
-import com.rtbishop.look4sat.domain.repository.ISelectionRepo
-import com.rtbishop.look4sat.domain.repository.ISettingsRepo
-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.launch
-
-class SatellitesViewModel(
-    private val selectionRepo: ISelectionRepo,
-    private val settingsRepo: ISettingsRepo
-) : ViewModel() {
-
-    private val defaultTypes = selectionRepo.getCurrentTypes()
-    private val _uiState = MutableStateFlow(
-        SatellitesState(
-            isDialogShown = false,
-            isLoading = true,
-            shouldSeeWarning = settingsRepo.otherSettings.value.shouldSeeWarning,
-            itemsList = emptyList(),
-            currentTypes = defaultTypes,
-            typesList = selectionRepo.getTypesList(),
-            takeAction = ::handleAction
-        )
-    )
-    val uiState: StateFlow<SatellitesState> = _uiState
-
-    init {
-        viewModelScope.launch {
-            delay(1000)
-            selectionRepo.setQuery(String())
-            selectionRepo.setTypes(defaultTypes)
-            selectionRepo.getEntriesFlow().collectLatest { items ->
-                _uiState.update { it.copy(isLoading = false, itemsList = items) }
-            }
-        }
-        viewModelScope.launch {
-            settingsRepo.otherSettings.collectLatest { settings ->
-                _uiState.update { it.copy(shouldSeeWarning = settings.shouldSeeWarning) }
-            }
-        }
-    }
-
-    private fun handleAction(action: SatellitesAction) {
-        when (action) {
-            SatellitesAction.DismissWarning -> settingsRepo.setWarningDismissed()
-            SatellitesAction.SaveSelection -> saveSelection()
-            is SatellitesAction.SearchFor -> searchFor(action.query)
-            SatellitesAction.SelectAll -> selectAll(true)
-            is SatellitesAction.SelectSingle -> selectSingle(action.id, action.isTicked)
-            is SatellitesAction.SelectTypes -> selectTypes(action.types)
-            SatellitesAction.ToggleTypesDialog -> toggleTypesDialog()
-            SatellitesAction.UnselectAll -> selectAll(false)
-        }
-    }
-
-    private fun saveSelection() = viewModelScope.launch { selectionRepo.saveSelection() }
-
-    private fun searchFor(query: String) = viewModelScope.launch { selectionRepo.setQuery(query) }
-
-    private fun selectAll(selectAll: Boolean) = viewModelScope.launch {
-        selectionRepo.setSelection(selectAll)
-    }
-
-    private fun selectSingle(id: Int, isTicked: Boolean) = viewModelScope.launch {
-        selectionRepo.setSelection(listOf(id), isTicked.not())
-    }
-
-    private fun selectTypes(types: List<String>) = viewModelScope.launch {
-        selectionRepo.setTypes(types)
-        _uiState.value = _uiState.value.copy(currentTypes = types, isDialogShown = false)
-    }
-
-    private fun toggleTypesDialog() {
-        val currentDialogState = _uiState.value.isDialogShown
-        _uiState.value = _uiState.value.copy(isDialogShown = currentDialogState.not())
-    }
-
-    companion object {
-        val Factory: ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
-            initializer {
-                val container = (this[applicationKey] as MainApplication).container
-                SatellitesViewModel(container.selectionRepo, container.settingsRepo)
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/settings/SettingsDialog.kt

@@ -1,484 +0,0 @@
-/*
- * 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.presentation.settings
-
-import androidx.compose.material3.OutlinedTextField
-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.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.common.SharedDialog
-import com.rtbishop.look4sat.presentation.common.CardButton
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Switch
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import com.rtbishop.look4sat.presentation.LocalSpacing
-import com.rtbishop.look4sat.domain.model.RCSettings
-
-@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
-                )
-            }
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/settings/SettingsScreen.kt

@@ -1,628 +0,0 @@
-/*
- * 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.presentation.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.R
-import com.rtbishop.look4sat.domain.model.OtherSettings
-import com.rtbishop.look4sat.domain.predict.GeoPos
-import com.rtbishop.look4sat.presentation.MainTheme
-import com.rtbishop.look4sat.presentation.Screen
-import com.rtbishop.look4sat.presentation.common.CardButton
-import com.rtbishop.look4sat.presentation.common.IconCard
-import com.rtbishop.look4sat.presentation.common.PrimaryIconCard
-import com.rtbishop.look4sat.presentation.common.ScreenColumn
-import com.rtbishop.look4sat.presentation.common.TopBar
-import com.rtbishop.look4sat.presentation.common.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()
-            )
-        }
-    }
-}

app/src/main/java/com/rtbishop/look4sat/presentation/settings/SettingsState.kt

@@ -1,93 +0,0 @@
-/*
- * 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.presentation.settings
-
-import com.rtbishop.look4sat.domain.model.OtherSettings
-import com.rtbishop.look4sat.domain.model.RCSettings
-import com.rtbishop.look4sat.domain.model.DataSourcesSettings
-import com.rtbishop.look4sat.domain.predict.GeoPos
-import com.rtbishop.look4sat.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()
-}

app/src/main/java/com/rtbishop/look4sat/presentation/settings/SettingsViewModel.kt

@@ -1,304 +0,0 @@
-/*
- * 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.presentation.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.MainApplication
-import com.rtbishop.look4sat.R
-import com.rtbishop.look4sat.domain.model.DataSourcesSettings
-import com.rtbishop.look4sat.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.domain.repository.IDatabaseRepo
-import com.rtbishop.look4sat.domain.repository.ISatelliteRepo
-import com.rtbishop.look4sat.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.domain.usecase.IShowToast
-import com.rtbishop.look4sat.domain.utility.toTimerString
-import com.rtbishop.look4sat.presentation.common.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 MainApplication).container
-                SettingsViewModel(
-                    container.databaseRepo,
-                    container.satelliteRepo,
-                    container.settingsRepo,
-                    container.provideShowToast()
-                )
-            }
-        }
-    }
-}

app/src/main/res/values/strings.xml

@@ -1,183 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <!-- Commmon -->
-    <string name="app_name" translatable="false">Look4Sat</string>
-    <string name="btn_accept">Accept</string>
-    <string name="btn_cancel">Cancel</string>
-    <string name="empty_list_message">No data to show</string>
-
-    <!-- Navigation -->
-    <string name="nav_sat">Satellites</string>
-    <string name="nav_pass">Passes</string>
-    <string name="nav_radar">Radar</string>
-    <string name="nav_map">Map</string>
-    <string name="nav_prefs">Settings</string>
-
-    <!-- Satellites screen -->
-    <string name="sat_type_hint">Type: %s</string>
-    <string name="sat_type_title">Select satellite type</string>
-    <string name="sat_search_hint">Id - Name</string>
-    <string name="sat_search_clear">Clear</string>
-    <string name="sat_clear_all">Clear all</string>
-    <string name="sat_select_all">Select all</string>
-    <string name="sat_empty_list_message">"Make sure your search query is correct and the DB is updated"</string>
-    <string name="sat_warning_title">Warning\!</string>
-    <string name="sat_warning_message">
-        There are over 9000 satellites listed in this app.
-        It makes no sense to track them all at the same time.
-        \n\nAlways try to narrow down the list to only the ones
-        you\'re interested in via search and types selector.</string>
-
-    <!-- Passes screen -->
-    <string name="pass_filter_title">Filter passes</string>
-    <string name="pass_filter_elev">Minimal elevation</string>
-    <string name="pass_filter_hours">Hours ahead</string>
-    <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
-    <string name="pass_modes_title">Select modulation type</string>
-    <string name="pass_satId" translatable="false">%05d</string>
-    <string name="pass_elevation">Elevation: %.1f°</string>
-    <string name="pass_deep_space" translatable="false">DeepSpace</string>
-    <string name="pass_altitude">Altitude: %d km</string>
-    <string name="pass_aosLos" translatable="false">%03d° - %03d°</string>
-    <string name="pass_empty_list_message">
-        Make sure your filters are correct and you have selected satellites</string>
-    <string name="pass_error_message">There are no upcoming satellite passes to display</string>
-    <string name="pass_welcome_title">Welcome to Look4Sat\!</string>
-    <string name="pass_welcome_message">
-        Make sure to set your position via GPS, Lat/Lon or QTH in Settings.
-        \n\nPlease update the database at least weekly to get accurate predictions.</string>
-    <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat</string>
-    <string name="pass_whatsnew_message" translatable="false">
-        • Londre7 added a remote frequency control feature (Hamlib/SDR++) by sending compatible messages via Network/BT.
-        Enable it in Settings and tap the transceiver (Radar Screen).
-    </string>
-
-    <!-- Radar screen -->
-    <string name="radar_back">Back</string>
-    <string name="radar_notify">Notify</string>
-    <string name="radar_az_text">Azimuth</string>
-    <string name="radar_az_value" translatable="false">%.1f°</string>
-    <string name="radar_el_text">Elevation</string>
-    <string name="radar_el_value" translatable="false">%.1f°</string>
-    <string name="radar_alt_text">Altitude</string>
-    <string name="radar_alt_value" translatable="false">%.0f km</string>
-    <string name="radar_dist_text">Distance</string>
-    <string name="radar_dist_value" translatable="false">%.0f km</string>
-    <string name="radar_eclipsed">Eclipsed</string>
-    <string name="radar_downlink">Downlink</string>
-    <string name="radar_uplink">Uplink</string>
-    <string name="radar_link_low" translatable="false">%.4f</string>
-    <string name="radar_link_lowHigh" translatable="false">%.4f - %.4f</string>
-    <string name="radar_no_link" translatable="false">- - . - -</string>
-    <string name="radar_no_data">This satellite has no transceivers</string>
-    <string name="radar_add">Add</string>
-    <string name="radar_data">Satellite transceivers:</string>
-    <string name="radar_inverted">Inverted: %s</string>
-    <string name="radar_mode">Mode: %s</string>
-    <string name="radar_string_no">No</string>
-    <string name="radar_string_yes">Yes</string>
-    <string name="radar_visible">Visible</string>
-
-    <!-- Map screen -->
-    <string name="map_prev">Prev</string>
-    <string name="map_next">Next</string>
-    <string name="map_copyright" translatable="false">© OpenStreetMap contributors</string>
-    <string name="map_azimuth">Azimuth: %.1f°</string>
-    <string name="map_elevation">Elevation: %.1f°</string>
-    <string name="map_altitude">Altitude: %.0f km</string>
-    <string name="map_distance">Distance: %.0f km</string>
-    <string name="map_latitude">Latitude: %.1f°</string>
-    <string name="map_longitude">Longitude: %.1f°</string>
-    <string name="map_qth" translatable="false">QTH: %s</string>
-    <string name="map_phase">Phase: %.1f°</string>
-    <string name="map_eclipsed">Eclipsed</string>
-    <string name="map_period">Period: %.0f min</string>
-    <string name="map_velocity">Velocity: %.2f km/s</string>
-    <string name="map_visibility">Visibility: %s</string>
-    <string name="map_visible">Visible</string>
-
-    <!-- Settings screen -->
-    <string name="prefs_app_title" translatable="false">Look4Sat v%s</string>
-    <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=com.rtbishop.look4sat</string>
-    <string name="prefs_donate_title">Donate</string>
-    <string name="prefs_donate_url" translatable="false">https://ko-fi.com/rt_bishop</string>
-    <string name="prefs_fdroid_title" translatable="false">F-Droid</string>
-    <string name="prefs_fdroid_url" translatable="false">https://f-droid.org/en/packages/com.rtbishop.look4sat/</string>
-    <string name="prefs_github_title" translatable="false">GitHub</string>
-    <string name="prefs_github_url" translatable="false">https://github.com/rt-bishop/Look4Sat/</string>
-    <string name="prefs_license_title" translatable="false">GPLv3</string>
-    <string name="prefs_license_url" translatable="false">https://www.gnu.org/licenses/gpl-3.0.html</string>
-    <string name="prefs_privacy_title">Privacy Policy</string>
-    <string name="prefs_privacy_url" translatable="false">https://sites.google.com/view/look4sat-privacy-policy/home</string>
-
-    <string name="prefs_updated_title">Updated: %s</string>
-    <string name="prefs_updated_time">d MMM yyyy - HH:mm:ss</string>
-
-    <string name="prefs_loc_title">Station position</string>
-    <string name="prefs_loc_gps_title">GPS</string>
-    <string name="prefs_loc_gps_error">Check your location permissions</string>
-    <string name="prefs_loc_input_title">Input</string>
-    <string name="prefs_loc_input_error">Invalid location entered</string>
-    <string name="prefs_loc_qth_title">QTH</string>
-    <string name="prefs_loc_qth_error">Invalid QTH locator</string>
-    <string name="prefs_loc_success">Position updated successfully</string>
-    <string name="prefs_station_title">Station position settings</string>
-    <string name="prefs_station_lat_text">Set your ground station\'s latitude</string>
-    <string name="prefs_station_lon_text">Set your ground station\'s longitude</string>
-    <string name="prefs_locator_title">QTH locator settings</string>
-    <string name="prefs_locator_text">Set station\'s position using locator</string>
-
-    <string name="prefs_data_title">Satellite data</string>
-    <string name="prefs_data_entries">Satellites: %s</string>
-    <string name="prefs_data_radios">Transceivers: %s</string>
-    <string name="prefs_data_update">Update</string>
-    <string name="prefs_data_import">Import</string>
-    <string name="prefs_data_clear">Clear</string>
-    <string name="prefs_data_clear_success">Data was cleared successfully</string>
-    <string name="prefs_data_update_success">Update completed successfully</string>
-
-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
-    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
-
-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
-    <string name="prefs_bt_output">Bluetooth</string>
-
-    <string name="prefs_net_title">Network data output</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
-    <string name="prefs_net_rotator_ip_hint">IP address</string>
-    <string name="prefs_net_rotator_port_hint">Port</string>
-    <string name="prefs_net_rotator_format_hint">Format</string>
-    <string name="prefs_net_frequency_switch">Enable frequency output</string>
-    <string name="prefs_net_frequency_ip_hint">IP address</string>
-    <string name="prefs_net_frequency_port_hint">Port</string>
-    <string name="prefs_net_frequency_format_hint">Format</string>
-
-    <string name="prefs_bt_title">Bluetooth data output</string>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Device id</string>
-    <string name="prefs_bt_rotator_output_hint">Data format</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">Device id</string>
-    <string name="prefs_bt_frequency_output_hint">Data format</string>
-    <string name="prefs_bt_perm_error">Check your bluetooth permission</string>
-
-    <string name="prefs_other_title">Other settings</string>
-    <string name="prefs_other_switch_utc">Show pass time in UTC</string>
-    <string name="prefs_other_switch_update">Enable automatic data update</string>
-    <string name="prefs_other_switch_sweep">Enable radar sweep animation</string>
-    <string name="prefs_other_switch_sensors">Use sensors to rotate radar view</string>
-
-    <string name="prefs_outro_title">I would like to say thanks to</string>
-    <string name="prefs_outro_thanks" translatable="false">
-        • Look4Sat users and contributors!
-        \n• David A. B. Johnson (predict4java)
-        \n• Dave Moten (predict4java)
-        \n• Alexandru Csete (Gpredict)
-        \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)</string>
-    <string name="prefs_outro_license">The app comes with no warranty</string>
-
-</resources>

build-logic/convention/build.gradle.kts

@@ -0,0 +1,48 @@
+import org.gradle.initialization.DependenciesAccessors
+import org.gradle.kotlin.dsl.support.serviceOf
+
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    compileOnly(libs.android.gradlePlugin)
+    compileOnly(libs.kotlin.gradlePlugin)
+    gradle.serviceOf<DependenciesAccessors>().classes.asFiles.forEach {
+        compileOnly(files(it.absolutePath))
+    }
+}
+
+tasks {
+    validatePlugins {
+        enableStricterValidation = true
+        failOnWarning = true
+    }
+}
+
+group = "com.rtbishop.look4sat.build_logic.convention"
+
+gradlePlugin {
+    plugins {
+        register("androidAppPlugin") {
+            id = libs.plugins.convention.androidAppPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.AndroidAppPlugin"
+        }
+        register("androidLibraryPlugin") {
+            id = libs.plugins.convention.androidLibraryPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.AndroidLibraryPlugin"
+        }
+        register("composeFeaturePlugin") {
+            id = libs.plugins.convention.composeFeaturePlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.ComposeFeaturePlugin"
+        }
+        register("composeLibraryPlugin") {
+            id = libs.plugins.convention.composeLibraryPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.ComposeLibraryPlugin"
+        }
+        register("kotlinLibraryPlugin") {
+            id = libs.plugins.convention.kotlinLibraryPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.KotlinLibraryPlugin"
+        }
+    }
+}

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/AndroidAppPlugin.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+@Suppress("Unused")
+internal class AndroidAppPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            setupAndroidApplication()
+            setupComposeFeature()
+            setupKotlinToolchain()
+            setupAndroidTestDependencies()
+            setupTestDependencies()
+            dependencies {
+                IMPLEMENTATION(project(":core:data"))
+                IMPLEMENTATION(project(":core:domain"))
+                IMPLEMENTATION(project(":core:presentation"))
+                IMPLEMENTATION(project(":feature:map"))
+                IMPLEMENTATION(project(":feature:passes"))
+                IMPLEMENTATION(project(":feature:radar"))
+                IMPLEMENTATION(project(":feature:satellites"))
+                IMPLEMENTATION(project(":feature:settings"))
+                IMPLEMENTATION(libs.androidx.core.splashscreen)
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/AndroidLibraryPlugin.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+@Suppress("Unused")
+internal class AndroidLibraryPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                alias(libs.plugins.google.ksp)
+            }
+            setupCommonLibrary()
+            setupKotlinToolchain()
+            setupAndroidTestDependencies()
+            setupTestDependencies()
+            dependencies {
+                IMPLEMENTATION(project(":core:domain"))
+                IMPLEMENTATION(libs.androidx.core.ktx)
+                IMPLEMENTATION(libs.androidx.room.asProvider())
+                IMPLEMENTATION(libs.androidx.room.runtime)
+                KSP(libs.androidx.room.compiler)
+                IMPLEMENTATION(libs.other.coroutines)
+                IMPLEMENTATION(libs.other.okhttp)
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/ComposeFeaturePlugin.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+@Suppress("Unused")
+internal class ComposeFeaturePlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            setupCommonLibrary()
+            setupComposeFeature()
+            setupKotlinToolchain()
+            setupAndroidTestDependencies()
+            setupTestDependencies()
+            dependencies {
+                IMPLEMENTATION(project(":core:domain"))
+                IMPLEMENTATION(project(":core:presentation"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/ComposeLibraryPlugin.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+@Suppress("Unused")
+internal class ComposeLibraryPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            setupCommonLibrary()
+            setupComposeFeature()
+            setupKotlinToolchain()
+            setupAndroidTestDependencies()
+            setupTestDependencies()
+            dependencies {
+                IMPLEMENTATION(project(":core:domain"))
+                IMPLEMENTATION(libs.androidx.core.splashscreen)
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/KotlinLibraryPlugin.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+@Suppress("Unused")
+internal class KotlinLibraryPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                alias(libs.plugins.kotlin.jvm)
+            }
+            setupKotlinToolchain()
+            setupTestDependencies()
+            dependencies {
+                IMPLEMENTATION(libs.other.coroutines)
+                IMPLEMENTATION(libs.other.json)
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/PluginSetupUtils.kt

@@ -0,0 +1,118 @@
+/*
+ * 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.convention
+
+import com.android.build.api.dsl.ApplicationExtension
+import com.android.build.api.dsl.CommonExtension
+import org.gradle.accessors.dm.LibrariesForLibs
+import org.gradle.api.Project
+import org.gradle.api.plugins.PluginManager
+import org.gradle.api.provider.Provider
+import org.gradle.kotlin.dsl.accessors.runtime.extensionOf
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.plugin.use.PluginDependency
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+
+internal const val ANDROID_TEST_IMPLEMENTATION = "androidTestImplementation"
+internal const val DEBUG_IMPLEMENTATION = "debugImplementation"
+internal const val IMPLEMENTATION = "implementation"
+internal const val KSP = "ksp"
+internal const val TEST_IMPLEMENTATION = "testImplementation"
+
+internal val Project.libs
+    get(): LibrariesForLibs = extensionOf(this, "libs") as LibrariesForLibs
+
+internal fun PluginManager.alias(notation: Provider<PluginDependency>) {
+    apply(notation.get().pluginId)
+}
+
+internal fun Project.setupAndroidApplication() {
+    with(pluginManager) {
+        alias(libs.plugins.android.application)
+    }
+    extensions.configure<ApplicationExtension> {
+        namespace = libs.versions.packageName.get()
+        compileSdk = libs.versions.compileSdk.get().toInt()
+        defaultConfig {
+            applicationId = libs.versions.packageName.get()
+            minSdk = libs.versions.minSdk.get().toInt()
+            versionCode = libs.versions.appVersionCode.get().toInt()
+            versionName = libs.versions.appVersionName.get()
+        }
+        buildFeatures {
+            compose = true
+        }
+        buildTypes {
+            debug {
+                applicationIdSuffix = ".debug"
+            }
+            release {
+                isMinifyEnabled = true
+                isShrinkResources = true
+                proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+            }
+        }
+        androidResources {
+            generateLocaleConfig = true
+            localeFilters.addAll(listOf("en", "es", "ru", "si", "uk", "zh"))
+        }
+        packaging { resources { excludes += listOf("META-INF/*") } }
+    }
+}
+
+internal fun Project.setupCommonLibrary() {
+    with(pluginManager) {
+        alias(libs.plugins.android.library)
+    }
+    extensions.configure<CommonExtension> {
+        compileSdk = libs.versions.compileSdk.get().toInt()
+        defaultConfig.minSdk = libs.versions.minSdk.get().toInt()
+    }
+}
+
+internal fun Project.setupComposeFeature() {
+    with(pluginManager) {
+        alias(libs.plugins.compose.compiler)
+    }
+    extensions.configure<CommonExtension> {
+        buildFeatures.compose = true
+    }
+    dependencies {
+        IMPLEMENTATION(platform(libs.compose.bom))
+        IMPLEMENTATION(libs.bundles.composeAll)
+        DEBUG_IMPLEMENTATION(libs.bundles.composeDebug)
+    }
+}
+
+internal fun Project.setupKotlinToolchain() {
+    kotlinExtension.jvmToolchain(libs.versions.jdkVersion.get().toInt())
+}
+
+internal fun Project.setupAndroidTestDependencies() {
+    dependencies {
+        ANDROID_TEST_IMPLEMENTATION(libs.bundles.androidTest)
+    }
+}
+
+internal fun Project.setupTestDependencies() {
+    dependencies {
+        TEST_IMPLEMENTATION(libs.test.coroutines)
+        TEST_IMPLEMENTATION(libs.test.junit4)
+    }
+}

build-logic/gradle.properties

@@ -0,0 +1,6 @@
+# Configure your build environment: http://www.gradle.org/docs/current/userguide/build_environment.html
+android.disallowKotlinSourceSets=false
+org.gradle.caching=true
+org.gradle.jvmargs=-Xmx6g -XX:MaxMetaspaceSize=1g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+org.gradle.workers.max=4

build-logic/settings.gradle.kts

@@ -0,0 +1,13 @@
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+rootProject.name = "build-logic"
+include(":convention")

core/data/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    alias(libs.plugins.convention.androidLibraryPlugin)
+}
+
+android {
+    namespace = "com.rtbishop.look4sat.core.data"
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/Look4SatDao.kt

@@ -0,0 +1,63 @@
+/*
+ * 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.core.data.database
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Transaction
+import com.rtbishop.look4sat.core.data.database.entity.SatEntry
+import com.rtbishop.look4sat.core.data.database.entity.SatRadio
+import com.rtbishop.look4sat.core.domain.model.SatItem
+
+@Dao
+interface Look4SatDao {
+
+    @Query("SELECT COUNT(*) FROM entries")
+    suspend fun getEntriesTotal(): Int
+
+    @Query("SELECT catnum, name, 0 as isSelected FROM entries ORDER BY name ASC")
+    suspend fun getEntriesList(): List<SatItem>
+
+    @Transaction
+    @Query("SELECT * FROM entries WHERE catnum IN (:selectedIds)")
+    suspend fun getEntriesWithIds(selectedIds: List<Int>): List<SatEntry>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertEntries(entries: List<SatEntry>)
+
+    @Query("DELETE FROM entries")
+    suspend fun deleteEntries()
+
+    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes)")
+    suspend fun getIdsWithModes(modes: List<String>): List<Int>
+
+    @Query("SELECT COUNT(*) FROM radios")
+    suspend fun getRadiosTotal(): Int
+
+    @Transaction
+    @Query("SELECT * FROM radios WHERE catnum = :id AND isAlive = 1")
+    suspend fun getRadiosWithId(id: Int): List<SatRadio>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertRadios(radios: List<SatRadio>)
+
+    @Query("DELETE FROM radios")
+    suspend fun deleteRadios()
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/Look4SatDb.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.core.data.database
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import com.rtbishop.look4sat.core.data.database.entity.SatEntry
+import com.rtbishop.look4sat.core.data.database.entity.SatRadio
+
+@Database(entities = [SatEntry::class, SatRadio::class], version = 1, exportSchema = false)
+abstract class Look4SatDb : RoomDatabase() {
+    abstract fun look4SatDao(): Look4SatDao
+}
+
+//val MIGRATION_1_2 = object : Migration(1, 2) {
+//    override fun migrate(database: SupportSQLiteDatabase) {
+//        database.execSQL("CREATE TABLE entries_backup (name TEXT NOT NULL, epoch REAL NOT NULL, meanmo REAL NOT NULL, eccn REAL NOT NULL, incl REAL NOT NULL, raan REAL NOT NULL, argper REAL NOT NULL, meanan REAL NOT NULL, catnum INTEGER NOT NULL, bstar REAL NOT NULL, xincl REAL NOT NULL, xnodeo REAL NOT NULL, omegao REAL NOT NULL, xmo REAL NOT NULL, xno REAL NOT NULL, orbitalPeriod REAL NOT NULL, isDeepSpace INTEGER NOT NULL, comment TEXT, PRIMARY KEY(catnum))")
+//        database.execSQL("INSERT INTO entries_backup (name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar, xincl, xnodeo, omegao, xmo, xno, orbitalPeriod, isDeepSpace, comment) SELECT name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar, xincl, xnodeo, omegao, xmo, xno, 1440 / meanmo, 1440 / meanmo >= 225.0, comment FROM entries")
+//        database.execSQL("DROP TABLE entries")
+//        database.execSQL("ALTER TABLE entries_backup RENAME TO entries")
+//    }
+//}

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/entity/SatEntry.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.core.data.database.entity
+
+import androidx.room.Entity
+
+@Entity(tableName = "entries", primaryKeys = ["catnum"])
+data class SatEntry(
+    val name: String,
+    val epoch: Double,
+    val meanmo: Double,
+    val eccn: Double,
+    val incl: Double,
+    val raan: Double,
+    val argper: Double,
+    val meanan: Double,
+    val catnum: Int,
+    val bstar: Double
+)

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/entity/SatRadio.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.core.data.database.entity
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "radios")
+data class SatRadio(
+    @PrimaryKey val uuid: String,
+    val info: String,
+    val isAlive: Boolean,
+    var downlinkLow: Long?,
+    var downlinkHigh: Long?,
+    val downlinkMode: String?,
+    var uplinkLow: Long?,
+    var uplinkHigh: Long?,
+    val uplinkMode: String?,
+    val isInverted: Boolean,
+    val catnum: Int?
+)

core/data/src/main/java/com/rtbishop/look4sat/core/data/framework/BluetoothReporter.kt

@@ -0,0 +1,140 @@
+/*
+ * 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.core.data.framework
+
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothSocket
+import android.util.Log
+import com.rtbishop.look4sat.core.domain.repository.BtService
+import com.rtbishop.look4sat.core.domain.repository.IReporterRepo
+import com.rtbishop.look4sat.core.domain.repository.WithoutExtParams
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.io.OutputStream
+import java.util.UUID
+import kotlin.math.abs
+
+data class DeviceConnection(
+    var socket: BluetoothSocket? = null,
+    var outputStream: OutputStream? = null,
+    var connected: Boolean = false,
+    var connecting: Boolean = false,
+    var connectionJob: Job? = null
+)
+
+class BluetoothReporter(
+    private val bluetoothManager: BluetoothManager,
+    private val reporterScope: CoroutineScope
+) : IReporterRepo<WithoutExtParams> {
+
+    private val tag = "BTReporter"
+    private val sppid: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
+
+    private val serviceToDevice = mutableMapOf<BtService, String>()
+    private val deviceConnections = mutableMapOf<String, DeviceConnection>()
+    private val writeMutex = Mutex()
+
+    override fun isConnected(service: BtService): Boolean {
+        val deviceId = serviceToDevice[service] ?: return false
+        return deviceConnections[deviceId]?.connected == true
+    }
+
+    override fun isConnecting(service: BtService): Boolean {
+        val deviceId = serviceToDevice[service] ?: return false
+        return deviceConnections[deviceId]?.connecting == true
+    }
+
+    override fun connect(service: BtService, deviceId: String) {
+        serviceToDevice[service] = deviceId
+        val connection = deviceConnections.getOrPut(deviceId) {
+            DeviceConnection()
+        }
+        if (connection.connected || connection.connecting) return
+        connection.connectionJob = reporterScope.launch {
+            try {
+                connection.connecting = true
+                val device = bluetoothManager.adapter.getRemoteDevice(deviceId)
+                val socket = device.createInsecureRfcommSocketToServiceRecord(sppid)
+                socket.connect()
+                connection.socket = socket
+                connection.outputStream = socket.outputStream
+                connection.connected = true
+                Log.i(tag, "$tag: Connected to $deviceId")
+            } catch (e: Exception) {
+                Log.e(tag, "$tag: ${e.message}")
+                connection.connected = false
+            } finally {
+                connection.connecting = false
+            }
+        }
+    }
+
+    private suspend fun write(service: BtService, buffer: String) {
+        val deviceId = serviceToDevice[service] ?: return
+        val connection = deviceConnections[deviceId] ?: return
+        if (!connection.connected) return
+        try {
+            writeMutex.withLock {
+                connection.outputStream?.write(buffer.toByteArray())
+            }
+        } catch (e: Exception) {
+            Log.e(tag, "$tag: Write failed ${e.message}")
+            connection.connected = false
+        }
+    }
+
+    override fun reportRotation(format: String, azimuth: Double, elevation: Double, params: WithoutExtParams) {
+        reporterScope.launch {
+            if (!isConnected(BtService.ROTATOR)) return@launch
+            val newElevation = if (elevation > 0.0) elevation else 0.0
+            val azimuthString = intToStringWithLeadingZeroes(azimuth.toInt())
+            val elevationString = intToStringWithLeadingZeroes(newElevation.toInt())
+            val buffer = format
+                .replace($$"$AZ", azimuthString)
+                .replace($$"$EL", elevationString)
+                .replace("\\r", "\r")
+                .replace("\\n", "\n")
+                .replace("\\t", "\t")
+            write(BtService.ROTATOR, buffer)
+        }
+    }
+
+    override fun reportFrequency(format: String, frequency: Long, params: WithoutExtParams) {
+        reporterScope.launch {
+            if (!isConnected(BtService.FREQUENCY)) return@launch
+            val buffer = format
+                .replace($$"$FREQ", frequency.toString())
+                .replace("\\r", "\r")
+                .replace("\\n", "\n")
+                .replace("\\t", "\t")
+            write(BtService.FREQUENCY, buffer)
+        }
+    }
+
+    private fun intToStringWithLeadingZeroes(value: Int): String {
+        return if (value > 0) {
+            if (value < 10) "00$value" else if (value < 100) "0$value" else "$value"
+        } else {
+            val absValue = abs(value)
+            if (value > -10) "-00$absValue" else if (value > -100) "-0$absValue" else "-$absValue"
+        }
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/framework/NetworkReporter.kt

@@ -0,0 +1,117 @@
+/*
+ * 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.core.data.framework
+
+import com.rtbishop.look4sat.core.domain.repository.BtService
+import com.rtbishop.look4sat.core.domain.repository.ExtendedParams
+import com.rtbishop.look4sat.core.domain.repository.IReporterRepo
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.net.InetSocketAddress
+import java.nio.ByteBuffer
+import java.nio.channels.SocketChannel
+
+enum class NetworkService { ROTATOR, FREQUENCY }
+
+data class SocketConnection(
+    var socket: SocketChannel? = null,
+    var connected: Boolean = false,
+    var connecting: Boolean = false,
+    var connectionJob: Job? = null
+)
+
+class NetworkReporter(private val reporterScope: CoroutineScope) : IReporterRepo<ExtendedParams> {
+    private val serviceToAddress = mutableMapOf<NetworkService, String>()
+    private val connections = mutableMapOf<String, SocketConnection>()
+    private val writeMutex = Mutex()
+
+    fun isConnected(service: NetworkService): Boolean {
+        val addr = serviceToAddress[service] ?: return false
+        return connections[addr]?.connected == true
+    }
+
+    private fun getOrCreateConnection(addr: String): SocketConnection {
+        return connections.getOrPut(addr) { SocketConnection() }
+    }
+
+    fun connect(service: NetworkService, server: String, port: Int) {
+        val addr = "$server:$port"
+        serviceToAddress[service] = addr
+        val connection = getOrCreateConnection(addr)
+        if (connection.connected || connection.connecting) return
+        connection.connectionJob = reporterScope.launch {
+            try {
+                connection.connecting = true
+                val socket = SocketChannel.open(InetSocketAddress(server, port))
+                connection.socket = socket
+                connection.connected = true
+                println("NetworkReporter: $service connected to $addr")
+            } catch (e: Exception) {
+                println("NetworkReporter connect error: ${e.message}")
+                connection.connected = false
+            } finally {
+                connection.connecting = false
+            }
+        }
+    }
+
+    private suspend fun write(service: NetworkService, command: String) {
+        val addr = serviceToAddress[service] ?: return
+        val connection = connections[addr] ?: return
+        if (!connection.connected) return
+        try {
+            writeMutex.withLock {
+                val buffer = ByteBuffer.wrap("\\$command\n".toByteArray())
+                connection.socket?.write(buffer)
+            }
+        } catch (e: Exception) {
+            println("NetworkReporter write error: ${e.message}")
+            connection.connected = false
+        }
+    }
+
+    override fun isConnected(service: BtService): Boolean = false
+
+    override fun isConnecting(service: BtService): Boolean = false
+
+    override fun connect(service: BtService, deviceId: String) {}
+
+    override fun reportRotation(format: String, azimuth: Double, elevation: Double, params: ExtendedParams) {
+        reporterScope.launch {
+            connect(NetworkService.ROTATOR, params.server, params.port)
+            if (!isConnected(NetworkService.ROTATOR)) return@launch
+            val el = if (elevation > 0.0) elevation else 0.0
+            val command = format
+                .replace("\$AZ", azimuth.toString())
+                .replace("\$EL", el.toString())
+            write(NetworkService.ROTATOR, command)
+        }
+    }
+
+    override fun reportFrequency(format: String, frequency: Long, params: ExtendedParams) {
+        reporterScope.launch {
+            connect(NetworkService.FREQUENCY, params.server, params.port)
+            if (!isConnected(NetworkService.FREQUENCY)) return@launch
+            val command = format.replace("\$FREQ", frequency.toString())
+            write(NetworkService.FREQUENCY, command)
+        }
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/injection/MainContainer.kt

@@ -0,0 +1,104 @@
+package com.rtbishop.look4sat.core.data.injection
+
+import android.bluetooth.BluetoothManager
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorManager
+import android.location.LocationManager
+import android.view.WindowManager
+import androidx.room.Room
+import com.rtbishop.look4sat.core.data.database.Look4SatDb
+import com.rtbishop.look4sat.core.data.framework.BluetoothReporter
+import com.rtbishop.look4sat.core.data.framework.NetworkReporter
+import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
+import com.rtbishop.look4sat.core.data.repository.SatelliteRepo
+import com.rtbishop.look4sat.core.data.repository.SelectionRepo
+import com.rtbishop.look4sat.core.data.repository.SensorsRepo
+import com.rtbishop.look4sat.core.data.repository.SettingsRepo
+import com.rtbishop.look4sat.core.data.source.LocalSource
+import com.rtbishop.look4sat.core.data.source.RemoteSource
+import com.rtbishop.look4sat.core.data.usecase.AddToCalendar
+import com.rtbishop.look4sat.core.data.usecase.ShowToast
+import com.rtbishop.look4sat.core.domain.repository.ExtendedParams
+import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+import com.rtbishop.look4sat.core.domain.repository.IReporterRepo
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
+import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.WithoutExtParams
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+import com.rtbishop.look4sat.core.domain.usecase.IShowToast
+import com.rtbishop.look4sat.core.domain.utility.DataParser
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import okhttp3.OkHttpClient
+
+class MainContainer(private val context: Context) : IMainContainer {
+
+    private val localSource = provideLocalSource()
+    private val mainHandler = CoroutineExceptionHandler { _, error -> println("MainHandler: $error") }
+    override val appScope = CoroutineScope(SupervisorJob() + Dispatchers.Default + mainHandler)
+    override val settingsRepo = provideSettingsRepo()
+    override val selectionRepo = provideSelectionRepo()
+    override val satelliteRepo = provideSatelliteRepo()
+    override val databaseRepo = provideDatabaseRepo()
+
+    override fun provideAddToCalendar(): IAddToCalendar = AddToCalendar(context)
+
+    override fun provideShowToast(): IShowToast = ShowToast(context)
+
+    override fun provideBluetoothReporter(): IReporterRepo<WithoutExtParams> {
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        return BluetoothReporter(manager, CoroutineScope(Dispatchers.IO))
+    }
+
+    override fun provideNetworkReporter(): IReporterRepo<ExtendedParams> {
+        return NetworkReporter(CoroutineScope(Dispatchers.IO))
+    }
+
+    override fun provideSensorsRepo(): ISensorsRepo {
+        val manager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+        val sensor = manager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
+        val window = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+        return SensorsRepo(manager,sensor,window)
+    }
+
+    private fun provideDatabaseRepo(): IDatabaseRepo {
+        val dbDispatcher = Dispatchers.Default
+        val dataParser = DataParser(dbDispatcher)
+        val remoteSource = provideRemoteSource()
+        return DatabaseRepo(dbDispatcher, dataParser, localSource, remoteSource, settingsRepo)
+    }
+
+    private fun provideLocalSource(): ILocalSource {
+        val builder = Room.databaseBuilder(context, Look4SatDb::class.java, "Look4SatDBv400")
+        val database = builder.fallbackToDestructiveMigration(false).build()
+        return LocalSource(database.look4SatDao())
+    }
+
+    private fun provideRemoteSource(): IRemoteSource {
+        return RemoteSource(Dispatchers.IO, context.contentResolver, OkHttpClient.Builder().build())
+    }
+
+    private fun provideSatelliteRepo(): ISatelliteRepo {
+        return SatelliteRepo(Dispatchers.Default, localSource, settingsRepo)
+    }
+
+    private fun provideSelectionRepo(): ISelectionRepo {
+        return SelectionRepo(Dispatchers.Default, localSource, settingsRepo)
+    }
+
+    private fun provideSettingsRepo(): ISettingsRepo {
+        val manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+        val appPrefsFileName = "${context.packageName}_preferences"
+        val appPreferences = context.getSharedPreferences(appPrefsFileName, Context.MODE_PRIVATE)
+        val appVersionName = context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "4.0.4"
+        return SettingsRepo(manager, appPreferences, appVersionName)
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/DatabaseRepo.kt

@@ -0,0 +1,130 @@
+/*
+ * 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.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.source.Sources
+import com.rtbishop.look4sat.core.domain.utility.DataParser
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.async
+import kotlinx.coroutines.withContext
+import java.util.zip.ZipInputStream
+
+class DatabaseRepo(
+    private val dispatcher: CoroutineDispatcher,
+    private val dataParser: DataParser,
+    private val localSource: ILocalSource,
+    private val remoteSource: IRemoteSource,
+    private val settingsRepo: ISettingsRepo
+) : IDatabaseRepo {
+
+    override suspend fun updateTLEFromFile(uri: String) = withContext(dispatcher) {
+        val importedSatellites = remoteSource.getFileStream(uri)?.let { dataParser.parseTLEStream(it) }
+        importedSatellites?.let { localSource.insertEntries(it) }
+        setUpdateSuccessful(System.currentTimeMillis())
+    }
+
+    override suspend fun updateTransceiversFromFile(uri: String) = withContext(dispatcher) {
+        val radios = remoteSource.getFileStream(uri)?.let { dataParser.parseJSONStream(it) }
+        radios?.let {
+            if(it.isNotEmpty()) {
+                localSource.deleteRadios()
+                localSource.insertRadios(it)
+            }
+        }
+        setUpdateSuccessful(System.currentTimeMillis())
+    }
+
+    override suspend fun updateFromRemote() = withContext(dispatcher) {
+        val importedEntries = mutableListOf<OrbitalData>()
+        val importedRadios = mutableListOf<SatRadio>()
+        val tleUrls = Sources.satelliteDataUrls.toMutableMap().apply {
+            if (settingsRepo.dataSourcesSettings.value.useCustomTLE) {
+                this["Other"] = settingsRepo.dataSourcesSettings.value.tleUrl
+            }
+        }
+        val jobsMap = tleUrls
+            .filter { (_, url) -> url.isNotEmpty() }
+            .mapValues { (_, url) -> async { remoteSource.getNetworkStream(url) } }
+        val radioUrls = buildList {
+            add(Sources.RADIO_DATA_URL)
+            if (settingsRepo.dataSourcesSettings.value.useCustomTransceivers) {
+                add(settingsRepo.dataSourcesSettings.value.transceiversUrl)
+            }
+        }
+        val jobRadios = radioUrls.associateWith { url -> async { remoteSource.getNetworkStream(url) } }
+        // parse
+        jobsMap.mapValues { job -> job.value.await() }.forEach { entry ->
+            entry.value?.let { stream ->
+                when (val type = entry.key) {
+                    "Amsat", "R4UAB", "Other" -> {
+                        // parse tle stream
+                        val satellites = dataParser.parseTLEStream(stream)
+                        val catnums = satellites.map { it.catnum }
+                        settingsRepo.setSatelliteTypeIds(type, catnums)
+                        importedEntries.addAll(satellites)
+                    }
+
+                    "McCants", "Classified" -> {
+                        // unzip and parse tle stream
+                        val unzipped = ZipInputStream(stream).apply { nextEntry }
+                        val satellites = dataParser.parseTLEStream(unzipped)
+                        val catnums = satellites.map { it.catnum }
+                        settingsRepo.setSatelliteTypeIds(type, catnums)
+                        importedEntries.addAll(satellites)
+                    }
+
+                    else -> {
+                        // parse csv stream
+                        val satellites = dataParser.parseCSVStream(stream)
+                        val catnums = satellites.map { it.catnum }
+                        settingsRepo.setSatelliteTypeIds(type, catnums)
+                        importedEntries.addAll(satellites)
+                    }
+                }
+            }
+        }
+        jobRadios.values.forEach { job ->
+            job.await()?.let {
+                importedRadios.addAll(dataParser.parseJSONStream(it))
+            }
+        }
+        // insert
+        localSource.insertEntries(importedEntries)
+        localSource.insertRadios(importedRadios)
+        setUpdateSuccessful(System.currentTimeMillis())
+    }
+
+    override suspend fun clearAllData() = withContext(dispatcher) {
+        localSource.deleteEntries()
+        localSource.deleteRadios()
+        setUpdateSuccessful(0L)
+    }
+
+    private suspend fun setUpdateSuccessful(timestamp: Long) = withContext(dispatcher) {
+        val numberOfRadios = localSource.getRadiosTotal()
+        val numberOfSatellites = localSource.getEntriesTotal()
+        settingsRepo.updateDatabaseState(DatabaseState(numberOfRadios, numberOfSatellites, timestamp))
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SatelliteRepo.kt

@@ -0,0 +1,242 @@
+/*
+ * 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.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.domain.utility.round
+import com.rtbishop.look4sat.core.domain.utility.toDegrees
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.withContext
+
+class SatelliteRepo(
+    private val dispatcher: CoroutineDispatcher,
+    private val localStorage: ILocalSource,
+    private val settingsRepo: ISettingsRepo
+) : ISatelliteRepo {
+
+    private val _passes = MutableStateFlow<List<OrbitalPass>>(emptyList())
+    override val passes: StateFlow<List<OrbitalPass>> = _passes
+
+    private val _satellites = MutableStateFlow<List<OrbitalObject>>(emptyList())
+    override val satellites: StateFlow<List<OrbitalObject>> = _satellites
+
+    override suspend fun getRadiosWithId(id: Int) = localStorage.getRadiosWithId(id)
+
+    override suspend fun initRepository() = withContext(dispatcher) {
+        settingsRepo.selectedIds.collect { selectedIds ->
+            _satellites.update { localStorage.getEntriesWithIds(selectedIds) }
+            val (hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
+            val timeNow = 1000 * ((System.currentTimeMillis() + 500) / 1000)
+            calculatePasses(timeNow, hoursAhead, minElevation, modes)
+        }
+    }
+
+    override suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos {
+        return withContext(dispatcher) { sat.getPosition(pos, time) }
+    }
+
+    override suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos> {
+        return withContext(dispatcher) {
+            val positions = mutableListOf<OrbitalPos>()
+            var currentTime = start
+            while (currentTime < end) {
+                positions.add(sat.getPosition(pos, currentTime))
+                currentTime += 15000
+            }
+            positions
+        }
+    }
+
+    override suspend fun getRadios(
+        sat: OrbitalObject,
+        pos: GeoPos,
+        radios: List<SatRadio>,
+        time: Long
+    ): List<SatRadio> {
+        return withContext(dispatcher) {
+            val satPos = sat.getPosition(pos, time)
+            val copiedList = radios.map { it.copy() }
+            copiedList.forEach { transmitter ->
+                transmitter.downlinkLow?.let { transmitter.downlinkLow = satPos.getDownlinkFreq(it) }
+                transmitter.downlinkHigh?.let { transmitter.downlinkHigh = satPos.getDownlinkFreq(it) }
+                transmitter.uplinkLow?.let { transmitter.uplinkLow = satPos.getUplinkFreq(it) }
+                transmitter.uplinkHigh?.let { transmitter.uplinkHigh = satPos.getUplinkFreq(it) }
+            }
+            copiedList.map { it.copy() }
+        }
+    }
+
+    override suspend fun processPasses(passList: List<OrbitalPass>, time: Long): List<OrbitalPass> {
+        return withContext(dispatcher) {
+            passList.forEach { pass ->
+                if (!pass.isDeepSpace) {
+                    val timeStart = pass.aosTime
+                    if (time > timeStart) {
+                        val deltaNow = time.minus(timeStart).toFloat()
+                        val deltaTotal = pass.losTime.minus(timeStart).toFloat()
+                        pass.progress = (deltaNow / deltaTotal).round(2)
+                    }
+                }
+            }
+            passList.filter { pass -> pass.progress < 1.0 }.map { it.copy() }
+        }
+    }
+
+    override suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>) {
+        if (_satellites.value.isNotEmpty()) {
+            withContext(dispatcher) {
+                val newPasses = mutableListOf<OrbitalPass>()
+                val idsWithModes = localStorage.getIdsWithModes(modes)
+                _satellites.value.forEach { satellite ->
+                    if (idsWithModes.isEmpty() || satellite.data.catnum in idsWithModes) {
+                        newPasses.addAll(satellite.getPasses(settingsRepo.stationPosition.value, time, hoursAhead))
+                    }
+                }
+                _passes.update { newPasses.filter(time, hoursAhead, minElevation) }
+            }
+        } else {
+            _passes.update { emptyList() }
+        }
+    }
+
+    private fun OrbitalObject.getPasses(pos: GeoPos, time: Long, hours: Int): List<OrbitalPass> {
+        val passes = mutableListOf<OrbitalPass>()
+        val endDate = time + hours * 60L * 60L * 1000L
+        val quarterOrbitMin = (this.data.orbitalPeriod / 4.0).toInt()
+        var startDate = time
+        var shouldRewind = true
+        var lastAosDate: Long
+        var count = 0
+        if (this.willBeSeen(pos)) {
+            if (this.data.isDeepSpace) {
+                passes.add(getGeoPass(this, pos, time))
+            } else {
+                do {
+                    if (count > 0) shouldRewind = false
+                    val pass = getLeoPass(this, pos, startDate, shouldRewind)
+                    lastAosDate = pass.aosTime
+                    passes.add(pass)
+                    startDate = pass.losTime + (quarterOrbitMin * 3) * 60L * 1000L
+                    count++
+                } while (lastAosDate < endDate)
+            }
+        }
+        return passes
+    }
+
+    private fun List<OrbitalPass>.filter(time: Long, hoursAhead: Int, minElev: Double): List<OrbitalPass> {
+        val timeFuture = time + (hoursAhead * 60L * 60L * 1000L)
+        return this.filter { it.losTime > time }.filter { it.aosTime < timeFuture }
+            .filter { it.maxElevation > minElev }.sortedBy { it.aosTime }
+    }
+
+    private fun getGeoPass(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPass {
+        val satPos = sat.getPosition(pos, time)
+        val aos = time - 24 * 60L * 60L * 1000L
+        val los = time + 24 * 60L * 60L * 1000L // val tca = (aos + los) / 2
+        val az = satPos.azimuth.toDegrees().round(1)
+        val elev = satPos.elevation.toDegrees().round(1)
+        val alt = satPos.altitude
+        return OrbitalPass(aos, az, los, az, alt.toInt(), elev, sat)
+    }
+
+    private fun getLeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, rewind: Boolean): OrbitalPass {
+        val quarterOrbitMin = (sat.data.orbitalPeriod / 4.0).toInt()
+        var calendarTimeMillis = time
+        var elevation: Double
+        var maxElevation = 0.0
+        var alt = 0.0 // var tcaAz = 0.0
+        // rewind 1/4 of an orbit
+        if (rewind) calendarTimeMillis += -quarterOrbitMin * 60L * 1000L
+
+        var satPos = sat.getPosition(pos, calendarTimeMillis)
+        if (satPos.elevation > 0.0) {
+            // move forward in 30 second intervals until the sat goes below the horizon
+            do {
+                calendarTimeMillis += 30 * 1000L
+                satPos = sat.getPosition(pos, calendarTimeMillis)
+            } while (satPos.elevation > 0.0)
+            // move forward 3/4 of an orbit
+            calendarTimeMillis += quarterOrbitMin * 3 * 60L * 1000L
+        }
+
+        // find the next time sat comes above the horizon
+        do {
+            calendarTimeMillis += 60L * 1000L
+            satPos = sat.getPosition(pos, calendarTimeMillis)
+            elevation = satPos.elevation
+            if (elevation > maxElevation) {
+                maxElevation = elevation
+                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
+            }
+        } while (satPos.elevation < 0.0)
+
+        // refine to 1 second
+        calendarTimeMillis += -60L * 1000L
+        do {
+            calendarTimeMillis += 1L * 500L
+            satPos = sat.getPosition(pos, calendarTimeMillis)
+            elevation = satPos.elevation
+            if (elevation > maxElevation) {
+                maxElevation = elevation
+                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
+            }
+        } while (satPos.elevation < 0.0)
+
+        val aos = 1000 * ((satPos.time + 500) / 1000)
+        val aosAz = satPos.azimuth.toDegrees().round(1)
+
+        // find when sat goes below
+        do {
+            calendarTimeMillis += 30L * 1000L
+            satPos = sat.getPosition(pos, calendarTimeMillis)
+            elevation = satPos.elevation
+            if (elevation > maxElevation) {
+                maxElevation = elevation
+                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
+            }
+        } while (satPos.elevation > 0.0)
+
+        // refine to 1 second
+        calendarTimeMillis += -30L * 1000L
+        do {
+            calendarTimeMillis += 1L * 500L
+            satPos = sat.getPosition(pos, calendarTimeMillis)
+            elevation = satPos.elevation
+            if (elevation > maxElevation) {
+                maxElevation = elevation
+                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
+            }
+        } while (satPos.elevation > 0.0)
+
+        val los = 1000 * ((satPos.time + 500) / 1000) // val tca = (aos + los) / 2
+        val losAz = satPos.azimuth.toDegrees().round(1)
+        val elev = maxElevation.toDegrees().round(1)
+        return OrbitalPass(aos, aosAz, los, losAz, alt.toInt(), elev, sat)
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SelectionRepo.kt

@@ -0,0 +1,103 @@
+/*
+ * 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.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.domain.source.Sources
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SelectionRepo(
+    private val dispatcher: CoroutineDispatcher,
+    private val localSource: ILocalSource,
+    private val settingsRepo: ISettingsRepo
+) : ISelectionRepo {
+
+    private val currentItems = MutableStateFlow<List<SatItem>>(emptyList())
+    private val currentTypes = MutableStateFlow(settingsRepo.selectedTypes.value)
+    private val currentQuery = MutableStateFlow("")
+    private val itemsWithTypes = currentTypes.flatMapLatest { types: List<String> ->
+        currentItems.map { items -> items.filterByTypes(types) }
+    }
+    private val itemsWithQuery = currentQuery.flatMapLatest { query ->
+        itemsWithTypes.map { items -> items.filterByQuery(query) }
+    }
+
+    override fun getCurrentTypes() = currentTypes.value
+
+    override fun getTypesList() = Sources.satelliteDataUrls.keys.sorted().toMutableList().apply {
+        removeAt(0)
+    }
+
+    override suspend fun getEntriesFlow() = withContext(dispatcher) {
+        val selectedIds = settingsRepo.selectedIds.value
+        currentItems.value = localSource.getEntriesList().map { item ->
+            item.copy(isSelected = item.catnum in selectedIds)
+        }
+        return@withContext itemsWithQuery
+    }
+
+    override suspend fun setTypes(types: List<String>) {
+        currentTypes.value = types
+        settingsRepo.setSelectedTypes(types)
+    }
+
+    override suspend fun setQuery(query: String) = withContext(dispatcher) {
+        currentQuery.value = query
+    }
+
+    override suspend fun setSelection(selectAll: Boolean) = withContext(dispatcher) {
+        setSelection(itemsWithQuery.first().map { item -> item.catnum }, selectAll)
+    }
+
+    override suspend fun setSelection(ids: List<Int>, isTicked: Boolean) = withContext(dispatcher) {
+        currentItems.value = currentItems.value.map { item ->
+            if (item.catnum in ids) item.copy(isSelected = isTicked) else item
+        }
+    }
+
+    override suspend fun saveSelection() = withContext(dispatcher) {
+        val currentSelection = currentItems.value.filter { it.isSelected }.map { it.catnum }
+        settingsRepo.setSelectedIds(currentSelection)
+    }
+
+    private suspend fun List<SatItem>.filterByTypes(types: List<String>) = withContext(dispatcher) {
+        if (types.isEmpty()) return@withContext this@filterByTypes
+        val catnums = settingsRepo.getSatelliteTypesIds(types)
+        if (catnums.isEmpty()) return@withContext this@filterByTypes
+        return@withContext this@filterByTypes.filter { item -> item.catnum in catnums }
+    }
+
+    private suspend fun List<SatItem>.filterByQuery(query: String) = withContext(dispatcher) {
+        if (query.isBlank()) return@withContext this@filterByQuery
+        return@withContext try {
+            this@filterByQuery.filter { it.catnum == query.toInt() }
+        } catch (_: Exception) {
+            this@filterByQuery.filter { item -> item.name.lowercase().contains(query.lowercase()) }
+        }
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SensorsRepo.kt

@@ -0,0 +1,112 @@
+/*
+ * 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.core.data.repository
+
+import android.hardware.GeomagneticField
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.view.Surface
+import android.view.WindowManager
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.RAD2DEG
+import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlin.math.round
+
+class SensorsRepo(
+    private val sensorManager: SensorManager,
+    private val sensor: Sensor?,
+    private val windowManager: WindowManager
+) :
+    SensorEventListener, ISensorsRepo {
+
+    private val _orientation = MutableStateFlow(Pair(0f, 0f))
+    private val rotationMatrix = FloatArray(9)
+    private val orientationValues = FloatArray(3)
+    private var sensorAccuracy = SensorManager.SENSOR_STATUS_UNRELIABLE
+
+    override val orientation: StateFlow<Pair<Float, Float>> = _orientation
+
+    override fun getMagDeclination(geoPos: GeoPos, time: Long): Float {
+        val latitude = geoPos.latitude.toFloat()
+        val longitude = geoPos.longitude.toFloat()
+        return GeomagneticField(latitude, longitude, geoPos.altitude.toFloat(), time).declination
+    }
+
+    override fun enableSensor() {
+        sensor?.let { sensorManager.registerListener(this, it, 8000) }
+    }
+
+    override fun disableSensor() = sensorManager.unregisterListener(this)
+
+    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
+        sensorAccuracy = accuracy
+    }
+
+    override fun onSensorChanged(event: SensorEvent) = when {
+        sensorAccuracy == SensorManager.SENSOR_STATUS_UNRELIABLE -> {}
+        event.sensor == sensor -> updateOrientation(event.values)
+        else -> {}
+    }
+
+    private fun getDisplayRotation(): Int {
+        return try {
+            @Suppress("DEPRECATION")
+            windowManager.defaultDisplay.rotation
+        } catch (e: Exception) {
+            Surface.ROTATION_0
+        }
+    }
+
+    private fun transformRotationMatrix(rotationMatrix: FloatArray, rotation: Int) {
+        val tempMatrix = FloatArray(9)
+        when (rotation) {
+            Surface.ROTATION_0 -> {
+                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_X, SensorManager.AXIS_Y, tempMatrix)
+                System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
+            }
+            Surface.ROTATION_90 -> {
+                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, tempMatrix)
+                SensorManager.remapCoordinateSystem(tempMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_Y, rotationMatrix)
+            }
+            Surface.ROTATION_180 -> {
+                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_MINUS_Y, tempMatrix)
+                System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
+            }
+            Surface.ROTATION_270 -> {
+                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_X, tempMatrix)
+                SensorManager.remapCoordinateSystem(tempMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_Y, rotationMatrix)
+            }
+        }
+    }
+
+    private fun updateOrientation(rotationVector: FloatArray) {
+        SensorManager.getRotationMatrixFromVector(rotationMatrix, rotationVector)
+        transformRotationMatrix(rotationMatrix, getDisplayRotation())
+        SensorManager.getOrientation(rotationMatrix, orientationValues)
+        val azimuth = (orientationValues[0] * RAD2DEG).toFloat()
+        val pitch = (orientationValues[1] * RAD2DEG).toFloat() // roll [2]
+        val magneticAzimuth = (azimuth + 360f) % 360f
+        val roundedAzimuth = round(magneticAzimuth * 10) / 10
+        val roundedPitch = round(pitch * 10) / 10
+        _orientation.value = Pair(roundedAzimuth, roundedPitch)
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SettingsRepo.kt

@@ -0,0 +1,427 @@
+/*
+ * 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.core.data.repository
+
+import android.content.SharedPreferences
+import android.location.Location
+import android.location.LocationManager
+import androidx.core.content.edit
+import androidx.core.location.LocationListenerCompat
+import androidx.core.location.LocationManagerCompat
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.utility.positionToQth
+import com.rtbishop.look4sat.core.domain.utility.qthToPosition
+import com.rtbishop.look4sat.core.domain.utility.round
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+
+class SettingsRepo(
+    private val locationManager: LocationManager,
+    private val preferences: SharedPreferences,
+    override val appVersionName: String
+) : ISettingsRepo, LocationListenerCompat {
+
+    private val keyBluetoothRotatorAddress = "bluetoothAddress"
+    private val keyBluetoothRotatorName = "bluetoothName"
+    private val keyBluetoothRotatorFormat = "bluetoothFormat"
+    private val keyBluetoothRotatorState = "bluetoothState"
+    private val keyBluetoothFrequencyState = "bluetoothFrequencyState"
+    private val keyBluetoothFrequencyAddress = "bluetoothFrequencyAddress"
+    private val keyBluetoothFrequencyFormat = "bluetoothFrequencyFormat"
+    private val keyFilterHoursAhead = "filterHoursAhead"
+    private val keyFilterMinElevation = "filterMinElevation"
+    private val keyNumberOfRadios = "numberOfRadios"
+    private val keyNumberOfSatellites = "numberOfSatellites"
+    private val keyRotatorAddress = "rotatorAddress"
+    private val keyRotatorPort = "rotatorPort"
+    private val keyRotatorState = "rotatorState"
+    private val keyRotatorFormat = "rotatorFormat"
+    private val keyFrequencyState = "frequencyState"
+    private val keyFrequencyAddress = "frequencyAddress"
+    private val keyFrequencyPort = "frequencyPort"
+    private val keyFrequencyFormat = "frequencyFormat"
+    private val keySelectedIds = "selectedIds"
+    private val keySelectedTypes = "selectedTypes"
+    private val keySelectedModes = "selectedModes"
+    private val keyStateOfAutoUpdate = "stateOfAutoUpdate"
+    private val keyStateOfSensors = "stateOfSensors"
+    private val keyStateOfSweep = "stateOfSweep"
+    private val keyStateOfUtc = "stateOfUtc"
+    private val keyStateOfLightTheme = "stateOfLightTheme"
+    private val keyStationAltitude = "stationAltitude"
+    private val keyStationLatitude = "stationLatitude"
+    private val keyStationLongitude = "stationLongitude"
+    private val keyStationQth = "stationQth"
+    private val keyStationTimestamp = "stationTimestamp"
+    private val keyUpdateTimestamp = "updateTimestamp"
+    private val keyShouldSeeWarning = "shouldSeeWarning"
+    private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew_v$appVersionName"
+    private val keyUseCustomTle = "useCustomTle"
+    private val keyUseCustomTransceivers = "useCustomTransceivers"
+    private val keyTleUrl = "tleUrl"
+    private val keyTransceiversUrl = "transceiversUrl"
+    private val separatorComma = ","
+
+    //region # Satellites selection settings
+    private val _satelliteSelection = MutableStateFlow(getSelectedIds())
+    private val _typesSelection = MutableStateFlow(getSelectedTypes())
+    override val selectedIds: StateFlow<List<Int>> = _satelliteSelection
+    override val selectedTypes: StateFlow<List<String>> = _typesSelection
+
+    override fun setSelectedIds(ids: List<Int>) {
+        val selectionString = ids.joinToString(separatorComma)
+        preferences.edit { putString(keySelectedIds, selectionString) }
+        _satelliteSelection.value = ids
+    }
+
+    override fun setSelectedTypes(types: List<String>) {
+        val typesString = types.joinToString(separatorComma)
+        preferences.edit { putString(keySelectedTypes, typesString) }
+        _typesSelection.value = types
+    }
+
+    private fun getSelectedIds(): List<Int> {
+        val selectionString = preferences.getString(keySelectedIds, null)
+        if (selectionString.isNullOrEmpty()) return emptyList()
+        return selectionString.split(separatorComma).map { it.toInt() }
+    }
+
+    private fun getSelectedTypes(): List<String> {
+        val typesString = preferences.getString(keySelectedTypes, null)
+        if (typesString.isNullOrEmpty()) return listOf("Amateur")
+        return typesString.split(separatorComma)
+    }
+    //endregion
+
+    //region # Passes filter settings
+    private val _passesSettings = MutableStateFlow(getPassesSettings())
+    override val passesSettings: StateFlow<PassesSettings> = _passesSettings
+
+    override fun setPassesSettings(settings: PassesSettings) = preferences.edit {
+        putInt(keyFilterHoursAhead, settings.hoursAhead)
+        putLong(keyFilterMinElevation, settings.minElevation.toRawBits())
+        putString(keySelectedModes, settings.selectedModes.joinToString(separatorComma))
+        _passesSettings.value = settings
+    }
+
+    private fun getPassesSettings(): PassesSettings {
+        val hoursAhead = preferences.getInt(keyFilterHoursAhead, 24)
+        val minElevation = Double.fromBits(preferences.getLong(keyFilterMinElevation, 16.0.toRawBits()))
+        val selectedModesString = preferences.getString(keySelectedModes, null)
+        val selectedModes = selectedModesString?.split(separatorComma)?.sorted() ?: emptyList()
+        return PassesSettings(hoursAhead, minElevation, selectedModes)
+    }
+    //endregion
+
+    //region # Station position settings
+    private val _stationPosition = MutableStateFlow(getStationPosition())
+    private val providerDef = LocationManager.PASSIVE_PROVIDER
+    private val providerGps = LocationManager.GPS_PROVIDER
+    private val providerNet = LocationManager.NETWORK_PROVIDER
+    override val stationPosition: StateFlow<GeoPos> = _stationPosition
+
+    override fun onLocationChanged(location: Location) {
+        setStationPosition(location.latitude, location.longitude, location.altitude)
+    }
+
+    override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean {
+        val newLongitude = if (longitude > 180.0) longitude - 180 else longitude
+        val locator = positionToQth(latitude, newLongitude) ?: return false
+        setStationPosition(latitude, newLongitude, altitude, locator)
+        return true
+    }
+
+    override fun setStationPosition(): Boolean {
+        if (!LocationManagerCompat.isLocationEnabled(locationManager)) return false
+        try {
+            val hasGps = LocationManagerCompat.hasProvider(locationManager, providerGps)
+            val hasNet = LocationManagerCompat.hasProvider(locationManager, providerNet)
+            val provider = if (hasGps) providerGps else if (hasNet) providerNet else providerDef
+            val location = locationManager.getLastKnownLocation(providerDef)
+            if (location == null || System.currentTimeMillis() - location.time > 600_000L) {
+                println("Requesting location for $provider provider")
+                locationManager.requestLocationUpdates(provider, 0L, 0f, this)
+            } else {
+                setStationPosition(location.latitude, location.longitude, location.altitude)
+            }
+        } catch (exception: SecurityException) {
+            println("No permissions were given - $exception")
+        }
+        return true
+    }
+
+    override fun setStationPosition(locator: String): Boolean {
+        val position = qthToPosition(locator) ?: return false
+        setStationPosition(position.latitude, position.longitude, 0.0, locator)
+        return true
+    }
+
+    private fun getStationPosition(): GeoPos {
+        val latitude = (preferences.getString(keyStationLatitude, null) ?: "0.0").toDouble()
+        val longitude = (preferences.getString(keyStationLongitude, null) ?: "0.0").toDouble()
+        val altitude = (preferences.getString(keyStationAltitude, null) ?: "0.0").toDouble()
+        val qthLocator = preferences.getString(keyStationQth, null) ?: "JJ00aa"
+        val timestamp = preferences.getLong(keyStationTimestamp, 0L)
+        return GeoPos(latitude, longitude, altitude, qthLocator, timestamp)
+    }
+
+    private fun setStationPosition(latitude: Double, longitude: Double, altitude: Double, locator: String) {
+        val newLat = latitude.round(4)
+        val newLon = longitude.round(4)
+        val newAlt = altitude.round(1)
+        val timestamp = System.currentTimeMillis()
+        println("Received new Position($newLat, $newLon, $newAlt) & Locator $locator")
+        setStationPosition(GeoPos(newLat, newLon, newAlt, locator, timestamp))
+    }
+
+    private fun setStationPosition(stationPos: GeoPos) = preferences.edit {
+        putString(keyStationLatitude, stationPos.latitude.toString())
+        putString(keyStationLongitude, stationPos.longitude.toString())
+        putString(keyStationAltitude, stationPos.altitude.toString())
+        putString(keyStationQth, stationPos.qthLocator)
+        putLong(keyStationTimestamp, stationPos.timestamp)
+        _stationPosition.value = stationPos
+    }
+    //endregion
+
+    //region # Database update settings
+    private val _databaseState = MutableStateFlow(getDatabaseState())
+    override val databaseState: StateFlow<DatabaseState> = _databaseState
+
+    override fun getSatelliteTypesIds(types: List<String>): List<Int> {
+        val idsSet = mutableSetOf<Int>()
+        types.forEach { type ->
+            val typeString = preferences.getString("type$type", null)
+            val typeIds = if (typeString.isNullOrBlank()) {
+                emptyList()
+            } else {
+                typeString.split(separatorComma).map { it.toInt() }
+            }
+            idsSet.addAll(typeIds)
+        }
+        return idsSet.toList()
+    }
+
+    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
+        if (type == "All") return
+        val typesString = ids.joinToString(separatorComma)
+        preferences.edit { putString("type$type", typesString) }
+    }
+
+    override fun updateDatabaseState(state: DatabaseState) = preferences.edit {
+        putInt(keyNumberOfSatellites, state.numberOfSatellites)
+        putInt(keyNumberOfRadios, state.numberOfRadios)
+        putLong(keyUpdateTimestamp, state.updateTimestamp)
+        _databaseState.value = state
+    }
+
+    private fun getDatabaseState(): DatabaseState {
+        val numberOfRadios = preferences.getInt(keyNumberOfRadios, 0)
+        val numberOfSatellites = preferences.getInt(keyNumberOfSatellites, 0)
+        val updateTimestamp = preferences.getLong(keyUpdateTimestamp, 0L)
+        return DatabaseState(numberOfRadios, numberOfSatellites, updateTimestamp)
+    }
+    //endregion
+
+    //region # RC settings
+    private val _rcSettings = MutableStateFlow(getRCSettings())
+    override val rcSettings: StateFlow<RCSettings> = _rcSettings
+
+    override fun setBluetoothRotatorAddress(value: String) {
+        preferences.edit { putString(keyBluetoothRotatorAddress, value) }
+        _rcSettings.update { it.copy(bluetoothRotatorAddress = value) }
+    }
+
+    override fun setBluetoothRotatorFormat(value: String) {
+        preferences.edit { putString(keyBluetoothRotatorFormat, value) }
+        _rcSettings.update { it.copy(bluetoothRotatorFormat = value) }
+    }
+
+    override fun setBluetoothRotatorName(value: String) {
+        preferences.edit { putString(keyBluetoothRotatorName, value) }
+        _rcSettings.update { it.copy(bluetoothRotatorName = value) }
+    }
+
+    override fun setBluetoothRotatorState(value: Boolean) {
+        preferences.edit { putBoolean(keyBluetoothRotatorState, value) }
+        _rcSettings.update { it.copy(bluetoothRotatorState = value) }
+    }
+
+    override fun setBluetoothFrequencyState(value: Boolean) {
+        preferences.edit { putBoolean(keyBluetoothFrequencyState, value) }
+        _rcSettings.update { it.copy(bluetoothFrequencyState = value) }
+    }
+
+    override fun setBluetoothFrequencyAddress(value: String) {
+        preferences.edit { putString(keyBluetoothFrequencyAddress, value) }
+        _rcSettings.update { it.copy(bluetoothFrequencyAddress = value) }
+    }
+
+    override fun setBluetoothFrequencyFormat(value: String) {
+        preferences.edit { putString(keyBluetoothFrequencyFormat, value) }
+        _rcSettings.update { it.copy(bluetoothFrequencyFormat = value) }
+    }
+
+    override fun setRotatorAddress(value: String) {
+        preferences.edit { putString(keyRotatorAddress, value) }
+        _rcSettings.update { it.copy(rotatorAddress = value) }
+    }
+
+    override fun setRotatorPort(value: String) {
+        preferences.edit { putString(keyRotatorPort, value) }
+        _rcSettings.update { it.copy(rotatorPort = value) }
+    }
+
+    override fun setRotatorState(value: Boolean) {
+        preferences.edit { putBoolean(keyRotatorState, value) }
+        _rcSettings.update { it.copy(rotatorState = value) }
+    }
+
+    override fun setRotatorFormat(value: String) {
+        preferences.edit { putString(keyRotatorFormat, value) }
+        _rcSettings.update { it.copy(rotatorFormat = value) }
+    }
+
+    override fun setFrequencyState(value: Boolean) {
+        preferences.edit { putBoolean(keyFrequencyState, value) }
+        _rcSettings.update { it.copy(frequencyState = value) }
+    }
+
+    override fun setFrequencyAddress(value: String) {
+        preferences.edit { putString(keyFrequencyAddress, value) }
+        _rcSettings.update { it.copy(frequencyAddress = value) }
+    }
+
+    override fun setFrequencyPort(value: String) {
+        preferences.edit { putString(keyFrequencyPort, value) }
+        _rcSettings.update { it.copy(frequencyPort = value) }
+    }
+
+    override fun setFrequencyFormat(value: String) {
+        preferences.edit { putString(keyFrequencyFormat, value) }
+        _rcSettings.update { it.copy(frequencyFormat = value) }
+    }
+
+    private fun getRCSettings(): RCSettings = RCSettings(
+        rotatorState = preferences.getBoolean(keyRotatorState, false),
+        rotatorAddress = preferences.getString(keyRotatorAddress, null) ?: "127.0.0.1",
+        rotatorPort = preferences.getString(keyRotatorPort, null) ?: "4533",
+        rotatorFormat = preferences.getString(keyRotatorFormat, null) ?: $$"P $AZ $EL",
+        frequencyState = preferences.getBoolean(keyFrequencyState, false),
+        frequencyAddress = preferences.getString(keyFrequencyAddress, null) ?: "127.0.0.1",
+        frequencyPort = preferences.getString(keyFrequencyPort, null) ?: "4532",
+        frequencyFormat = preferences.getString(keyFrequencyFormat, null) ?: $$"set_freq $FREQ",
+        bluetoothRotatorState = preferences.getBoolean(keyBluetoothRotatorState, false),
+        bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"W$AZ $EL",
+        bluetoothRotatorName = preferences.getString(keyBluetoothRotatorName, null) ?: "Default",
+        bluetoothRotatorAddress = preferences.getString(keyBluetoothRotatorAddress, null) ?: "00:0C:BF:13:80:5D",
+        bluetoothFrequencyState = preferences.getBoolean(keyBluetoothFrequencyState, false),
+        bluetoothFrequencyAddress = preferences.getString(keyBluetoothFrequencyAddress, null) ?: "00:0C:BF:13:80:5D",
+        bluetoothFrequencyFormat = preferences.getString(keyBluetoothFrequencyFormat, null) ?: $$"FA$FREQ"
+    )
+    //endregion
+
+    //region # Other settings
+    private val _otherSettings = MutableStateFlow(getOtherSettings())
+    override val otherSettings: StateFlow<OtherSettings> = _otherSettings
+
+    override fun setStateOfAutoUpdate(value: Boolean) {
+        preferences.edit { putBoolean(keyStateOfAutoUpdate, value) }
+        _otherSettings.update { it.copy(stateOfAutoUpdate = value) }
+    }
+
+    override fun setStateOfSensors(value: Boolean) {
+        preferences.edit { putBoolean(keyStateOfSensors, value) }
+        _otherSettings.update { it.copy(stateOfSensors = value) }
+    }
+
+    override fun setStateOfSweep(value: Boolean) {
+        preferences.edit { putBoolean(keyStateOfSweep, value) }
+        _otherSettings.update { it.copy(stateOfSweep = value) }
+    }
+
+    override fun setStateOfUtc(value: Boolean) {
+        preferences.edit { putBoolean(keyStateOfUtc, value) }
+        _otherSettings.update { it.copy(stateOfUtc = value) }
+    }
+
+    override fun setStateOfLightTheme(value: Boolean){
+        preferences.edit { putBoolean(keyStateOfLightTheme, value) }
+        _otherSettings.update { it.copy(stateOfLightTheme = value) }
+    }
+
+    override fun setWarningDismissed() {
+        preferences.edit { putBoolean(keyShouldSeeWarning, false) }
+        _otherSettings.update { it.copy(shouldSeeWarning = false) }
+    }
+
+    override fun setWhatsNewDismissed() {
+        preferences.edit { putBoolean(keyShouldSeeWhatsNew, false) }
+        _otherSettings.update { it.copy(shouldSeeWhatsNew = false) }
+    }
+
+    private fun getOtherSettings(): OtherSettings = OtherSettings(
+        stateOfAutoUpdate = preferences.getBoolean(keyStateOfAutoUpdate, true),
+        stateOfSensors = preferences.getBoolean(keyStateOfSensors, true),
+        stateOfSweep = preferences.getBoolean(keyStateOfSweep, true),
+        stateOfUtc = preferences.getBoolean(keyStateOfUtc, false),
+        stateOfLightTheme = preferences.getBoolean(keyStateOfLightTheme, false),
+        shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
+        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true)
+    )
+    //endregion
+
+    //region # Data sources settings
+    private val _dataSourcesSettings = MutableStateFlow(getDataSourcesSettings())
+    override val dataSourcesSettings: StateFlow<DataSourcesSettings> = _dataSourcesSettings
+
+    override fun setUseCustomTle(value: Boolean) {
+        preferences.edit { putBoolean(keyUseCustomTle, value) }
+        _dataSourcesSettings.update { it.copy(useCustomTLE = value) }
+    }
+
+    override fun setUseCustomTransceivers(value: Boolean) {
+        preferences.edit { putBoolean(keyUseCustomTransceivers, value) }
+        _dataSourcesSettings.update { it.copy(useCustomTransceivers = value) }
+    }
+
+    override fun setTleUrl(value: String) {
+        preferences.edit { putString(keyTleUrl, value) }
+        _dataSourcesSettings.update { it.copy(tleUrl = value) }
+    }
+
+    override fun setTransceiversUrl(value: String) {
+        preferences.edit { putString(keyTransceiversUrl, value) }
+        _dataSourcesSettings.update { it.copy(transceiversUrl = value) }
+    }
+
+    private fun getDataSourcesSettings(): DataSourcesSettings = DataSourcesSettings(
+        useCustomTLE = preferences.getBoolean(keyUseCustomTle, false),
+        useCustomTransceivers = preferences.getBoolean(keyUseCustomTransceivers, false),
+        tleUrl = preferences.getString(keyTleUrl, "https://example.com/tle.txt") ?: "",
+        transceiversUrl = preferences.getString(keyTransceiversUrl, "https://example.com/radio.json") ?: ""
+    )
+    //endregion
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/source/LocalSource.kt

@@ -0,0 +1,98 @@
+/*
+ * 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.core.data.source
+
+import com.rtbishop.look4sat.core.data.database.Look4SatDao
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.data.database.entity.SatEntry as FrameworkEntry
+import com.rtbishop.look4sat.core.data.database.entity.SatRadio as FrameworkRadio
+import com.rtbishop.look4sat.core.domain.model.SatRadio as DomainRadio
+
+class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
+
+    //region # Entries region
+
+    override suspend fun getEntriesTotal() = look4SatDao.getEntriesTotal()
+
+    override suspend fun getEntriesList() = look4SatDao.getEntriesList()
+
+    override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> {
+        val selectedOrbitalObjects = mutableListOf<OrbitalObject>()
+        ids.chunked(999).forEach { idsPart ->
+            val entries = look4SatDao.getEntriesWithIds(idsPart)
+            selectedOrbitalObjects.addAll(entries.toDomain().map { entry -> entry.getObject() })
+        }
+        return selectedOrbitalObjects
+    }
+
+    override suspend fun insertEntries(entries: List<OrbitalData>) = look4SatDao.insertEntries(entries.toEntity())
+
+    override suspend fun deleteEntries() = look4SatDao.deleteEntries()
+
+    override suspend fun getIdsWithModes(modes: List<String>) = look4SatDao.getIdsWithModes(modes)
+
+    private fun FrameworkEntry.toDomain() = OrbitalData(
+        this.name, this.epoch, this.meanmo, this.eccn, this.incl,
+        this.raan, this.argper, this.meanan, this.catnum, this.bstar
+    )
+
+    private fun OrbitalData.toEntity() = FrameworkEntry(
+        this.name, this.epoch, this.meanmo, this.eccn, this.incl,
+        this.raan, this.argper, this.meanan, this.catnum, this.bstar
+    )
+
+    private fun List<OrbitalData>.toEntity() = this.map { item -> item.toEntity() }
+
+    private fun List<FrameworkEntry>.toDomain() = this.map { item -> item.toDomain() }
+
+    //endregion
+
+    //region # Radios region
+
+    override suspend fun getRadiosTotal() = look4SatDao.getRadiosTotal()
+
+    override suspend fun getRadiosWithId(id: Int): List<SatRadio> {
+        return look4SatDao.getRadiosWithId(id).toDomainRadios()
+    }
+
+    override suspend fun insertRadios(radios: List<SatRadio>) {
+        look4SatDao.deleteRadios()
+        look4SatDao.insertRadios(radios.toFrameworkRadios())
+    }
+
+    override suspend fun deleteRadios() = look4SatDao.deleteRadios()
+
+    private fun DomainRadio.toFramework() = FrameworkRadio(
+        this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum
+    )
+
+    private fun FrameworkRadio.toDomain() = DomainRadio(
+        this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum
+    )
+
+    private fun List<DomainRadio>.toFrameworkRadios() = this.map { radio -> radio.toFramework() }
+
+    private fun List<FrameworkRadio>.toDomainRadios() = this.map { radio -> radio.toDomain() }
+
+    //endregion
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/source/RemoteSource.kt

@@ -0,0 +1,54 @@
+/*
+ * 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.core.data.source
+
+import android.content.ContentResolver
+import androidx.core.net.toUri
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.InputStream
+
+class RemoteSource(
+    private val dispatcher: CoroutineDispatcher,
+    private val contentResolver: ContentResolver,
+    private val httpClient: OkHttpClient
+) : IRemoteSource {
+
+    override suspend fun getFileStream(uri: String): InputStream? = withContext(dispatcher) {
+        try {
+            val fileUri = uri.toUri()
+            contentResolver.openInputStream(fileUri)?.buffered()
+        } catch (exception: Exception) {
+            println("RemoteSource file stream exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun getNetworkStream(url: String): InputStream? = withContext(dispatcher) {
+        try {
+            val networkRequest = Request.Builder().url(url).build()
+            httpClient.newCall(networkRequest).execute().body.byteStream()
+        } catch (exception: Exception) {
+            println("RemoteSource network stream exception: $exception")
+            null
+        }
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/usecase/AddToCalendar.kt

@@ -0,0 +1,41 @@
+/*
+ * 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.core.data.usecase
+
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.provider.CalendarContract
+import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+
+class AddToCalendar(private val context: Context) : IAddToCalendar {
+    override fun invoke(name: String, aosTime: Long, losTime: Long) {
+        val intent = Intent(Intent.ACTION_INSERT).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            setData(CalendarContract.Events.CONTENT_URI)
+            putExtra(CalendarContract.Events.TITLE, name)
+            putExtra(CalendarContract.Events.DESCRIPTION, "Look4Sat Pass")
+            putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, aosTime)
+            putExtra(CalendarContract.EXTRA_EVENT_END_TIME, losTime)
+        }
+        try {
+            context.startActivity(intent)
+        } catch (_: ActivityNotFoundException) {
+        }
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/usecase/ShowToast.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.core.data.usecase
+
+import android.content.Context
+import android.widget.Toast
+import com.rtbishop.look4sat.core.domain.usecase.IShowToast
+
+class ShowToast(private val context: Context) : IShowToast {
+    override fun invoke(message: String) {
+        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
+    }
+}

core/domain/.gitignore

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

core/domain/build.gradle.kts

@@ -0,0 +1,3 @@
+plugins {
+    alias(libs.plugins.convention.kotlinLibraryPlugin)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/model/SatItem.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.core.domain.model
+
+data class SatItem(val catnum: Int, val name: String, val isSelected: Boolean = false)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/model/SatRadio.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.core.domain.model
+
+data class SatRadio(
+    val uuid: String,
+    val info: String,
+    val isAlive: Boolean,
+    var downlinkLow: Long?,
+    var downlinkHigh: Long?,
+    val downlinkMode: String?,
+    var uplinkLow: Long?,
+    var uplinkHigh: Long?,
+    val uplinkMode: String?,
+    val isInverted: Boolean,
+    val catnum: Int?
+)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/model/Settings.kt

@@ -0,0 +1,65 @@
+/*
+ * 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.core.domain.model
+
+data class DatabaseState(
+    val numberOfRadios: Int,
+    val numberOfSatellites: Int,
+    val updateTimestamp: Long
+)
+
+data class PassesSettings(
+    val hoursAhead: Int,
+    val minElevation: Double,
+    val selectedModes: List<String>
+)
+
+data class RCSettings(
+    val rotatorState: Boolean,
+    val rotatorAddress: String,
+    val rotatorPort: String,
+    val rotatorFormat: String,
+    val frequencyState: Boolean,
+    val frequencyAddress: String,
+    val frequencyPort: String,
+    val frequencyFormat: String,
+    val bluetoothRotatorState: Boolean,
+    val bluetoothRotatorFormat: String,
+    val bluetoothRotatorName: String,
+    val bluetoothRotatorAddress: String,
+    val bluetoothFrequencyState: Boolean,
+    val bluetoothFrequencyFormat: String,
+    val bluetoothFrequencyAddress: String
+)
+
+data class OtherSettings(
+    val stateOfAutoUpdate: Boolean,
+    val stateOfSensors: Boolean,
+    val stateOfSweep: Boolean,
+    val stateOfUtc: Boolean,
+    val stateOfLightTheme: Boolean,
+    val shouldSeeWarning: Boolean,
+    val shouldSeeWhatsNew: Boolean
+)
+
+data class DataSourcesSettings(
+    val useCustomTLE: Boolean,
+    val useCustomTransceivers: Boolean,
+    val tleUrl: String,
+    val transceiversUrl: String
+)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/Constants.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.core.domain.predict
+
+const val ASTRONOMICAL_UNIT = 1.49597870691E8
+const val DEG2RAD = 0.017453292519943295
+const val RAD2DEG = 57.29577951308232
+const val EARTH_RADIUS = 6378.137
+const val EPSILON = 1.0E-12
+const val FLAT_FACT = 3.35281066474748E-3
+const val J3_HARMONIC = -2.53881E-6
+const val MIN_PER_DAY = 1.44E3
+const val SEC_PER_DAY = 8.6400E4
+const val SOLAR_RADIUS = 6.96000E5
+const val SPEED_OF_LIGHT = 2.99792458E8
+const val PI = 3.141592653589793
+const val PI_2 = PI / 2.0
+const val TWO_PI = PI * 2.0
+const val TWO_THIRDS = 2.0 / 3.0
+const val CK2 = 5.413079E-4
+const val CK4 = 6.209887E-7
+const val XKE = 7.43669161E-2

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/DeepSpaceObject.kt

@@ -0,0 +1,853 @@
+/*
+ * 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.core.domain.predict
+
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.floor
+import kotlin.math.pow
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+class DeepSpaceObject(data: OrbitalData) : OrbitalObject(data) {
+
+    private val c1: Double
+    private val c4: Double
+    private val x1mth2: Double
+    private val x3thm1: Double
+    private val xlcof: Double
+    private val xnodcf: Double
+    private val t2cof: Double
+    private val aycof: Double
+    private val x7thm1: Double
+    private val deep: DeepSpaceCalculator
+    private val dsv = DeepSpaceValueObject()
+
+    init {
+        // Recover original mean motion (xnodp) and semimajor axis (aodp) from input elements
+        val a1 = (XKE / data.xno).pow(TWO_THIRDS)
+        dsv.cosio = cos(data.xincl)
+        dsv.theta2 = dsv.cosio * dsv.cosio
+        x3thm1 = 3.0 * dsv.theta2 - 1
+        dsv.eosq = data.eccn * data.eccn
+        dsv.betao2 = 1.0 - dsv.eosq
+        dsv.betao = sqrt(dsv.betao2)
+        val del1 = 1.5 * CK2 * x3thm1 / (a1 * a1 * dsv.betao * dsv.betao2)
+        val ao = a1 * (1.0 - del1 * (0.5 * TWO_THIRDS + del1 * (1.0 + 134.0 / 81.0 * del1)))
+        val delo = 1.5 * CK2 * x3thm1 / (ao * ao * dsv.betao * dsv.betao2)
+        dsv.xnodp = data.xno / (1.0 + delo)
+        dsv.aodp = ao / (1.0 - delo)
+        // For perigee below 156 km, the values of S and QOMS2T are altered
+        setPerigee((dsv.aodp * (1.0 - data.eccn) - 1.0) * EARTH_RADIUS)
+        val pinvsq = invert(dsv.aodp * dsv.aodp * dsv.betao2 * dsv.betao2)
+        dsv.sing = sin(data.omegao)
+        dsv.cosg = cos(data.omegao)
+        val tsi = invert(dsv.aodp - s4)
+        val eta = dsv.aodp * data.eccn * tsi
+        val etasq = eta * eta
+        val eeta = data.eccn * eta
+        val psisq = abs(1.0 - etasq)
+        val coef = qoms24 * tsi.pow(4.0)
+        val coef1 = coef / psisq.pow(3.5)
+        val c2 = coef1 * dsv.xnodp * (dsv.aodp * (1.0 + 1.5 * etasq + eeta * (4.0 + etasq))
+            + 0.75 * CK2 * tsi / psisq * x3thm1 * (8.0 + 3.0 * etasq * (8.0 + etasq)))
+        c1 = data.bstar * c2
+        dsv.sinio = sin(data.xincl)
+        val a3ovk2 = -J3_HARMONIC / CK2
+        x1mth2 = 1.0 - dsv.theta2
+        c4 =
+            2 * dsv.xnodp * coef1 * dsv.aodp * dsv.betao2 * (eta * (2.0 + 0.5 * etasq) + data.eccn
+                * (0.5 + 2 * etasq) - 2 * CK2 * tsi / (dsv.aodp * psisq)
+                * (-3 * x3thm1 * (1.0 - 2 * eeta + etasq * (1.5 - 0.5 * eeta)) + (0.75 * x1mth2
+                * (2.0 * etasq - eeta * (1.0 + etasq)) * cos(2.0 * data.omegao))))
+        val theta4 = dsv.theta2 * dsv.theta2
+        val temp1 = 3.0 * CK2 * pinvsq * dsv.xnodp
+        val temp2 = temp1 * CK2 * pinvsq
+        val temp3 = 1.25 * CK4 * pinvsq * pinvsq * dsv.xnodp
+        dsv.xmdot =
+            dsv.xnodp + 0.5 * temp1 * dsv.betao * x3thm1 + 0.0625 * temp2 * dsv.betao * (13 - 78 * dsv.theta2 + 137 * theta4)
+        val x1m5th = 1.0 - 5 * dsv.theta2
+        dsv.omgdot =
+            -0.5 * temp1 * x1m5th + 0.0625 * temp2 * (7.0 - 114 * dsv.theta2 + 395 * theta4) + temp3 * (3.0 - 36 * dsv.theta2 + 49 * theta4)
+        val xhdot1 = -temp1 * dsv.cosio
+        dsv.xnodot =
+            xhdot1 + (0.5 * temp2 * (4.0 - 19 * dsv.theta2) + 2 * temp3 * (3.0 - 7 * dsv.theta2)) * dsv.cosio
+        xnodcf = 3.5 * dsv.betao2 * xhdot1 * c1
+        t2cof = 1.5 * c1
+        xlcof = 0.125 * a3ovk2 * dsv.sinio * (3.0 + 5 * dsv.cosio) / (1.0 + dsv.cosio)
+        aycof = 0.25 * a3ovk2 * dsv.sinio
+        x7thm1 = 7.0 * dsv.theta2 - 1
+        deep = DeepSpaceCalculator(dsv)
+    }
+
+    internal fun calculateSDP4(tSince: Double) {
+        synchronized(this) {
+            val temp = DoubleArray(12)
+            val xmdf = data.xmo + dsv.xmdot * tSince
+            val tsq = tSince * tSince
+            val templ = t2cof * tsq
+            dsv.xll = xmdf + dsv.xnodp * templ
+            dsv.omgadf = data.omegao + dsv.omgdot * tSince
+            val xnoddf = data.xnodeo + dsv.xnodot * tSince
+            dsv.xnode = xnoddf + xnodcf * tsq
+            val tempa = 1.0 - c1 * tSince
+            val tempe = data.bstar * c4 * tSince
+            dsv.xn = dsv.xnodp
+            dsv.t = tSince
+            deep.dpsec(data)
+            val a = (XKE / dsv.xn).pow(TWO_THIRDS) * tempa * tempa
+            dsv.em -= tempe
+            deep.dpper()
+            val xl = dsv.xll + dsv.omgadf + dsv.xnode
+            val beta = sqrt(1.0 - dsv.em * dsv.em)
+            dsv.xn = XKE / a.pow(1.5)
+            // Long period periodics
+            val axn = dsv.em * cos(dsv.omgadf)
+            temp[0] = invert(a * beta * beta)
+            val xll = temp[0] * xlcof * axn
+            val aynl = temp[0] * aycof
+            val xlt = xl + xll
+            val ayn = dsv.em * sin(dsv.omgadf) + aynl
+            // Solve Kepler's equation
+            val capu = mod2PI(xlt - dsv.xnode)
+            temp[2] = capu
+            converge(temp, axn, ayn, capu)
+            calculatePosAndVel(temp, a, axn, ayn)
+            calculatePhase(xlt, dsv.xnode, dsv.omgadf)
+        }
+    }
+
+    private fun calculatePosAndVel(temp: DoubleArray, a: Double, axn: Double, ayn: Double) {
+        val ecose = temp[5] + temp[6]
+        val esine = temp[3] - temp[4]
+        val elsq = axn * axn + ayn * ayn
+        temp[0] = 1.0 - elsq
+        val pl = a * temp[0]
+        temp[9] = a * (1.0 - ecose)
+        temp[1] = invert(temp[9])
+        temp[10] = XKE * sqrt(a) * esine * temp[1]
+        temp[11] = XKE * sqrt(pl) * temp[1]
+        temp[2] = a * temp[1]
+        val betal = sqrt(temp[0])
+        temp[3] = invert(1.0 + betal)
+        val cosu = temp[2] * (temp[8] - axn + ayn * esine * temp[3])
+        val sinu = temp[2] * (temp[7] - ayn - axn * esine * temp[3])
+        val u = atan2(sinu, cosu)
+        val sin2u = 2.0 * sinu * cosu
+        val cos2u = 2.0 * cosu * cosu - 1
+        temp[0] = invert(pl)
+        temp[1] = CK2 * temp[0]
+        temp[2] = temp[1] * temp[0]
+        // Update for short periodics
+        val rk = temp[9] * (1.0 - 1.5 * temp[2] * betal * x3thm1) + 0.5 * temp[1] * x1mth2 * cos2u
+        val uk = u - 0.25 * temp[2] * x7thm1 * sin2u
+        val xnodek = dsv.xnode + 1.5 * temp[2] * dsv.cosio * sin2u
+        val xinck = dsv.xinc + 1.5 * temp[2] * dsv.cosio * dsv.sinio * cos2u
+        val rdotk = temp[10] - dsv.xn * temp[1] * x1mth2 * sin2u
+        val rfdotk = temp[11] + dsv.xn * temp[1] * (x1mth2 * cos2u + 1.5 * x3thm1)
+        super.calculatePosAndVel(rk, uk, xnodek, xinck, rdotk, rfdotk)
+    }
+
+    class DeepSpaceValueObject {
+
+        var eosq = 0.0
+        var sinio = 0.0
+        var cosio = 0.0
+        var betao = 0.0
+        var aodp = 0.0
+        var theta2 = 0.0
+        var sing = 0.0
+        var cosg = 0.0
+        var betao2 = 0.0
+        var xmdot = 0.0
+        var omgdot = 0.0
+        var xnodot = 0.0
+        var xnodp = 0.0
+
+        // Used by dpsec and dpper parts of Deep()
+        var xll = 0.0
+        var omgadf = 0.0
+        var xnode = 0.0
+        var em = 0.0
+        var xinc = 0.0
+        var xn = 0.0
+        var t = 0.0
+
+        // Used by thetg and Deep()
+        var ds50 = 0.0
+    }
+
+    inner class DeepSpaceCalculator(private val dsv: DeepSpaceValueObject) {
+
+        private val zSinis = 3.9785416E-1
+        private val zSings = -9.8088458E-1
+        private val zNs = 1.19459E-5
+        private val c1ss = 2.9864797E-6
+        private val zEs = 1.675E-2
+        private val zNl = 1.5835218E-4
+        private val c1l = 4.7968065E-7
+        private val zEl = 5.490E-2
+        private val root22 = 1.7891679E-6
+        private val root32 = 3.7393792E-7
+        private val root44 = 7.3636953E-9
+        private val root52 = 1.1428639E-7
+        private val root54 = 2.1765803E-9
+        private val tHdt = 4.3752691E-3
+        private val q22 = 1.7891679E-6
+        private val q31 = 2.1460748E-6
+        private val q33 = 2.2123015E-7
+        private val g22 = 5.7686396
+        private val g32 = 9.5240898E-1
+        private val g44 = 1.8014998
+        private val g52 = 1.0508330
+        private val g54 = 4.4108898
+        private val thgr: Double
+        private val xnq: Double
+        private val xqncl: Double
+        private val omegaq: Double
+        private var zmol = 0.0
+        private var zmos = 0.0
+
+        // Many fields below cannot be final because they are iteratively refined
+        private var savtsn = 0.0
+        private var ee2 = 0.0
+        private var e3 = 0.0
+        private var xi2 = 0.0
+        private var xl2 = 0.0
+        private var xl3 = 0.0
+        private var xl4 = 0.0
+        private var xgh2 = 0.0
+        private var xgh3 = 0.0
+        private var xgh4 = 0.0
+        private var xh2 = 0.0
+        private var xh3 = 0.0
+        private var sse = 0.0
+        private var ssi = 0.0
+        private var ssg = 0.0
+        private var xi3 = 0.0
+        private var se2 = 0.0
+        private var si2 = 0.0
+        private var sl2 = 0.0
+        private var sgh2 = 0.0
+        private var sh2 = 0.0
+        private var se3 = 0.0
+        private var si3 = 0.0
+        private var sl3 = 0.0
+        private var sgh3 = 0.0
+        private var sh3 = 0.0
+        private var sl4 = 0.0
+        private var sgh4 = 0.0
+        private var ssl = 0.0
+        private var ssh = 0.0
+        private var d3210 = 0.0
+        private var d3222 = 0.0
+        private var d4410 = 0.0
+        private var d4422 = 0.0
+        private var d5220 = 0.0
+        private var d5232 = 0.0
+        private var d5421 = 0.0
+        private var d5433 = 0.0
+        private var del1 = 0.0
+        private var del2 = 0.0
+        private var del3 = 0.0
+        private var fasx2 = 0.0
+        private var fasx4 = 0.0
+        private var fasx6 = 0.0
+        private var xlamo = 0.0
+        private val xfact: Double
+        private var xni: Double
+        private var atime: Double
+        private val stepp: Double
+        private val stepn: Double
+        private val step2: Double
+        private var preep = 0.0
+        private var pl = 0.0
+        private var sghs = 0.0
+        private var xli: Double
+        private var d2201 = 0.0
+        private var d2211 = 0.0
+        private var sghl = 0.0
+        private var sh1 = 0.0
+        private var pinc = 0.0
+        private var pe = 0.0
+        private var shs = 0.0
+        private var zsingl = 0.0
+        private var zcosgl = 0.0
+        private var zsinhl = 0.0
+        private var zcoshl = 0.0
+        private var zsinil = 0.0
+        private var zcosil = 0.0
+        private var a1 = 0.0
+        private var a2 = 0.0
+        private var a3 = 0.0
+        private var a4 = 0.0
+        private var a5 = 0.0
+        private var a6 = 0.0
+        private var a7 = 0.0
+        private var a8 = 0.0
+        private var a9 = 0.0
+        private var a10 = 0.0
+        private var ainv2 = 0.0
+        private var alfdp = 0.0
+        private val aqnv: Double
+        private var sgh = 0.0
+        private var sini2 = 0.0
+        private var sinis = 0.0
+        private var sinok = 0.0
+        private var sh = 0.0
+        private var si = 0.0
+        private var sil = 0.0
+        private val day: Double
+        private var betdp = 0.0
+        private var dalf = 0.0
+        private var bfact = 0.0
+        private var c = 0.0
+        private var cc = 0.0
+        private var cosis = 0.0
+        private var cosok = 0.0
+        private val cosq: Double
+        private var ctem = 0.0
+        private var f322 = 0.0
+        private var zx = 0.0
+        private var zy = 0.0
+        private var dbet = 0.0
+        private var dls = 0.0
+        private var eoc = 0.0
+        private val eq: Double
+        private var f2 = 0.0
+        private var f220 = 0.0
+        private var f221 = 0.0
+        private var f3 = 0.0
+        private var f311 = 0.0
+        private var f321 = 0.0
+        private var xnoh = 0.0
+        private var f330 = 0.0
+        private var f441 = 0.0
+        private var f442 = 0.0
+        private var f522 = 0.0
+        private var f523 = 0.0
+        private var f542 = 0.0
+        private var f543 = 0.0
+        private var g200 = 0.0
+        private var g201 = 0.0
+        private var g211 = 0.0
+        private var pgh = 0.0
+        private var ph = 0.0
+        private var s1 = 0.0
+        private var s2 = 0.0
+        private var s3 = 0.0
+        private var s4 = 0.0
+        private var s5 = 0.0
+        private var s6 = 0.0
+        private var s7 = 0.0
+        private var se = 0.0
+        private var sel = 0.0
+        private var ses = 0.0
+        private var xls = 0.0
+        private var g300 = 0.0
+        private var g310 = 0.0
+        private var g322 = 0.0
+        private var g410 = 0.0
+        private var g422 = 0.0
+        private var g520 = 0.0
+        private var g521 = 0.0
+        private var g532 = 0.0
+        private var g533 = 0.0
+        private var gam = 0.0
+        private val sinq: Double
+        private var sinzf = 0.0
+        private var sis = 0.0
+        private var sl = 0.0
+        private var sll = 0.0
+        private var sls = 0.0
+        private var stem = 0.0
+        private var temp = 0.0
+        private var temp1 = 0.0
+        private var x1 = 0.0
+        private var x2 = 0.0
+        private var x2li = 0.0
+        private var x2omi = 0.0
+        private var x3 = 0.0
+        private var x4 = 0.0
+        private var x5 = 0.0
+        private var x6 = 0.0
+        private var x7 = 0.0
+        private var x8 = 0.0
+        private var xl = 0.0
+        private var xldot = 0.0
+        private val xmao: Double
+        private var xnddt = 0.0
+        private var xndot = 0.0
+        private var xno2 = 0.0
+        private var xnodce = 0.0
+        private var xnoi = 0.0
+        private var xomi = 0.0
+        private val xpidot: Double
+        private var z1 = 0.0
+        private var z11 = 0.0
+        private var z12 = 0.0
+        private var z13 = 0.0
+        private var z2 = 0.0
+        private var z21 = 0.0
+        private var z22 = 0.0
+        private var z23 = 0.0
+        private var z3 = 0.0
+        private var z31 = 0.0
+        private var z32 = 0.0
+        private var z33 = 0.0
+        private var ze = 0.0
+        private var zf = 0.0
+        private var zm = 0.0
+        private var zn = 0.0
+        private var zsing = 0.0
+        private var zsinh = 0.0
+        private var zsini = 0.0
+        private var zcosg = 0.0
+        private var zcosh = 0.0
+        private var zcosi = 0.0
+        private var delt = 0.0
+        private var ft = 0.0
+        private var resonance: Boolean
+        private var synchronous: Boolean
+        private var doLoop = false
+        private var epochRestart = false
+
+        init {
+            thgr = thetaG(data.epoch)
+            eq = data.eccn
+            xnq = dsv.xnodp
+            aqnv = invert(dsv.aodp)
+            xqncl = data.xincl
+            xmao = data.xmo
+            xpidot = dsv.omgdot + dsv.xnodot
+            sinq = sin(data.xnodeo)
+            cosq = cos(data.xnodeo)
+            omegaq = data.omegao
+            // Initialize lunar solar terms, days since 1900 Jan 0.5
+            day = dsv.ds50 + 18261.5
+            if (abs(day - preep) > 1.0E-6) {
+                preep = day
+                xnodce = 4.5236020 - 9.2422029E-4 * day
+                stem = sin(xnodce)
+                ctem = cos(xnodce)
+                zcosil = 0.91375164 - 0.03568096 * ctem
+                zsinil = sqrt(1.0 - zcosil * zcosil)
+                zsinhl = 0.089683511 * stem / zsinil
+                zcoshl = sqrt(1.0 - zsinhl * zsinhl)
+                c = 4.7199672 + 0.22997150 * day
+                gam = 5.8351514 + 0.0019443680 * day
+                zmol = mod2PI(c - gam)
+                zx = 0.39785416 * stem / zsinil
+                zy = zcoshl * ctem + 0.91744867 * zsinhl * stem
+                zx = atan2(zx, zy)
+                zx = gam + zx - xnodce
+                zcosgl = cos(zx)
+                zsingl = sin(zx)
+                zmos = mod2PI(6.2565837 + 0.017201977 * day)
+            } else {
+                zmol = 0.0
+                zmos = 0.0
+            }
+            doSolarTerms()
+
+            // Geopotential resonance initialization for 12 hour orbits
+            resonance = false
+            synchronous = false
+            if (!(xnq < 0.0052359877 && xnq > 0.0034906585)) {
+                if (xnq !in 0.00826..0.00924)
+                    if (eq < 0.5)
+                    // calculateResonance
+                        resonance = true
+                eoc = eq * dsv.eosq
+                g201 = -0.306 - (eq - 0.64) * 0.440
+                if (eq <= 0.65) {
+                    g211 = 3.616 - 13.247 * eq + 16.290 * dsv.eosq
+                    g310 = -19.302 + 117.390 * eq - 228.419 * dsv.eosq + 156.591 * eoc
+                    g322 = -18.9068 + 109.7927 * eq - 214.6334 * dsv.eosq + 146.5816 * eoc
+                    g410 = -41.122 + 242.694 * eq - 471.094 * dsv.eosq + 313.953 * eoc
+                    g422 = -146.407 + 841.880 * eq - 1629.014 * dsv.eosq + 1083.435 * eoc
+                    g520 = -532.114 + 3017.977 * eq - 5740 * dsv.eosq + 3708.276 * eoc
+                } else {
+                    g211 = -72.099 + 331.819 * eq - 508.738 * dsv.eosq + 266.724 * eoc
+                    g310 = -346.844 + 1582.851 * eq - 2415.925 * dsv.eosq + 1246.113 * eoc
+                    g322 = -342.585 + 1554.908 * eq - 2366.899 * dsv.eosq + 1215.972 * eoc
+                    g410 = -1052.797 + 4758.686 * eq - 7193.992 * dsv.eosq + 3651.957 * eoc
+                    g422 = -3581.69 + 16178.11 * eq - 24462.77 * dsv.eosq + 12422.52 * eoc
+                    g520 =
+                        if (eq <= 0.715) 1464.74 - 4664.75 * eq + 3763.64 * dsv.eosq
+                        else -5149.66 + 29936.92 * eq - 54087.36 * dsv.eosq + 31324.56 * eoc
+                }
+                if (eq < 0.7) {
+                    g533 = -919.2277 + 4988.61 * eq - 9064.77 * dsv.eosq + 5542.21 * eoc
+                    g521 = -822.71072 + 4568.6173 * eq - 8491.4146 * dsv.eosq + 5337.524 * eoc
+                    g532 = -853.666 + 4690.25 * eq - 8624.77 * dsv.eosq + 5341.4 * eoc
+                } else {
+                    g533 = -37995.78 + 161616.52 * eq - 229838.2 * dsv.eosq + 109377.94 * eoc
+                    g521 = -51752.104 + 218913.95 * eq - 309468.16 * dsv.eosq + 146349.42 * eoc
+                    g532 = -40023.88 + 170470.89 * eq - 242699.48 * dsv.eosq + 115605.82 * eoc
+                }
+                sini2 = dsv.sinio * dsv.sinio
+                f220 = 0.75 * (1.0 + 2 * dsv.cosio + dsv.theta2)
+                f221 = 1.5 * sini2
+                f321 = 1.875 * dsv.sinio * (1.0 - 2 * dsv.cosio - 3.0 * dsv.theta2)
+                f322 = -1.875 * dsv.sinio * (1.0 + 2 * dsv.cosio - 3.0 * dsv.theta2)
+                f441 = 35 * sini2 * f220
+                f442 = 39.3750 * sini2 * sini2
+                f522 =
+                    9.84375 * dsv.sinio * (sini2 * (1.0 - 2 * dsv.cosio - 5 * dsv.theta2) + 0.33333333 * (-2 + 4 * dsv.cosio + 6 * dsv.theta2))
+                f523 =
+                    dsv.sinio * (4.92187512 * sini2 * (-2 - 4 * dsv.cosio + 10 * dsv.theta2) + 6.56250012 * (1.0 + 2 * dsv.cosio - 3.0 * dsv.theta2))
+                f542 =
+                    29.53125 * dsv.sinio * (2.0 - 8 * dsv.cosio + dsv.theta2 * (-12 + 8 * dsv.cosio + 10 * dsv.theta2))
+                f543 =
+                    29.53125 * dsv.sinio * (-2 - 8 * dsv.cosio + dsv.theta2 * (12 + 8 * dsv.cosio - 10 * dsv.theta2))
+                xno2 = xnq * xnq
+                ainv2 = aqnv * aqnv
+                temp1 = 3.0 * xno2 * ainv2
+                temp = temp1 * root22
+                d2201 = temp * f220 * g201
+                d2211 = temp * f221 * g211
+                temp1 *= aqnv
+                temp = temp1 * root32
+                d3210 = temp * f321 * g310
+                d3222 = temp * f322 * g322
+                temp1 *= aqnv
+                temp = 2.0 * temp1 * root44
+                d4410 = temp * f441 * g410
+                d4422 = temp * f442 * g422
+                temp1 *= aqnv
+                temp = temp1 * root52
+                d5220 = temp * f522 * g520
+                d5232 = temp * f523 * g532
+                temp = 2.0 * temp1 * root54
+                d5421 = temp * f542 * g521
+                d5433 = temp * f543 * g533
+                xlamo = xmao + data.xnodeo + data.xnodeo - thgr - thgr
+                bfact = dsv.xmdot + dsv.xnodot + dsv.xnodot - tHdt - tHdt
+                bfact += ssl + ssh + ssh
+            } else {
+                // Init synchronous resonance terms
+                resonance = true
+                synchronous = true
+                g200 = 1.0 + dsv.eosq * (-2.5 + 0.8125 * dsv.eosq)
+                g310 = 1.0 + 2 * dsv.eosq
+                g300 = 1.0 + dsv.eosq * (-6 + 6.60937 * dsv.eosq)
+                f220 = 0.75 * (1.0 + dsv.cosio) * (1.0 + dsv.cosio)
+                f311 =
+                    0.9375 * dsv.sinio * dsv.sinio * (1.0 + 3.0 * dsv.cosio) - 0.75 * (1.0 + dsv.cosio)
+                f330 = 1.0 + dsv.cosio
+                f330 *= 1.875 * f330 * f330
+                del1 = 3.0 * xnq * xnq * aqnv * aqnv
+                del2 = 2.0 * del1 * f220 * g200 * q22
+                del3 = 3.0 * del1 * f330 * g300 * q33 * aqnv
+                del1 *= f311 * g310 * q31 * aqnv
+                fasx2 = 0.13130908
+                fasx4 = 2.8843198
+                fasx6 = 0.37448087
+                xlamo = xmao + data.xnodeo + data.omegao - thgr
+                bfact = dsv.xmdot + xpidot - tHdt
+                bfact += ssl + ssg + ssh
+            }
+            xfact = bfact - xnq
+            // Init integrator
+            xli = xlamo
+            xni = xnq
+            atime = 0.0
+            stepp = 720.0
+            stepn = -720.0
+            step2 = 259200.0
+        }
+
+        // Entrance for lunar-solar periodics
+        fun dpper() {
+            sinis = sin(dsv.xinc)
+            cosis = cos(dsv.xinc)
+            if (abs(savtsn - dsv.t) >= 30) {
+                savtsn = dsv.t
+                zm = zmos + zNs * dsv.t
+                zf = zm + 2 * zEs * sin(zm)
+                sinzf = sin(zf)
+                f2 = 0.5 * sinzf * sinzf - 0.25
+                f3 = -0.5 * sinzf * cos(zf)
+                ses = se2 * f2 + se3 * f3
+                sis = si2 * f2 + si3 * f3
+                sls = sl2 * f2 + sl3 * f3 + sl4 * sinzf
+                sghs = sgh2 * f2 + sgh3 * f3 + sgh4 * sinzf
+                shs = sh2 * f2 + sh3 * f3
+                zm = zmol + zNl * dsv.t
+                zf = zm + 2 * zEl * sin(zm)
+                sinzf = sin(zf)
+                f2 = 0.5 * sinzf * sinzf - 0.25
+                f3 = -0.5 * sinzf * cos(zf)
+                sel = ee2 * f2 + e3 * f3
+                sil = xi2 * f2 + xi3 * f3
+                sll = xl2 * f2 + xl3 * f3 + xl4 * sinzf
+                sghl = xgh2 * f2 + xgh3 * f3 + xgh4 * sinzf
+                sh1 = xh2 * f2 + xh3 * f3
+                pe = ses + sel
+                pinc = sis + sil
+                pl = sls + sll
+            }
+            pgh = sghs + sghl
+            ph = shs + sh1
+            dsv.xinc += pinc
+            dsv.em += pe
+            if (xqncl >= 0.2) {
+                /* Apply periodics directly */
+                ph /= dsv.sinio
+                pgh -= dsv.cosio * ph
+                dsv.omgadf += pgh
+                dsv.xnode += ph
+                dsv.xll += pl
+            } else {
+                applyPeriodics()
+                // This is a patch to Lyddane modification suggested by Rob Matson
+                if (abs(xnoh - dsv.xnode) > PI) {
+                    if (dsv.xnode < xnoh) dsv.xnode += TWO_PI else dsv.xnode -= TWO_PI
+                }
+                dsv.xll += pl
+                dsv.omgadf = xls - dsv.xll - cos(dsv.xinc) * dsv.xnode
+            }
+        }
+
+        // Entrance for deep space secular effects
+        fun dpsec(params: OrbitalData) {
+            dsv.xll += ssl * dsv.t
+            dsv.omgadf += ssg * dsv.t
+            dsv.xnode += ssh * dsv.t
+            dsv.em = params.eccn + sse * dsv.t
+            dsv.xinc = params.xincl + ssi * dsv.t
+            if (dsv.xinc < 0) {
+                dsv.xinc = -dsv.xinc
+                dsv.xnode += PI
+                dsv.omgadf -= PI
+            }
+            if (!resonance) return
+            do processEpochRestartLoop() while (doLoop && epochRestart)
+            dsv.xn = xni + xndot * ft + xnddt * ft * ft * 0.5
+            xl = xli + xldot * ft + xndot * ft * ft * 0.5
+            temp = -dsv.xnode + thgr + dsv.t * tHdt
+            if (synchronous) dsv.xll = xl - dsv.omgadf + temp else dsv.xll = xl + temp + temp
+        }
+
+        private fun doSolarTerms() {
+            savtsn = 1E20
+            zcosg = 1.945905E-1
+            zsing = zSings
+            zcosi = 9.1744867E-1
+            zsini = zSinis
+            zcosh = cosq
+            zsinh = sinq
+            cc = c1ss
+            zn = zNs
+            ze = zEs
+            xnoi = invert(xnq)
+            calculateSolarTerms()
+            calculateLunarTerms()
+            calculateSolarTerms() // Solar terms done again after Lunar terms are done
+            sse += se
+            ssi += si
+            ssl += sl
+            ssg = ssg + sgh - dsv.cosio / dsv.sinio * sh
+            ssh += sh / dsv.sinio
+        }
+
+        private fun calculateLunarTerms() {
+            sse = se
+            ssi = si
+            ssl = sl
+            ssh = sh / dsv.sinio
+            ssg = sgh - dsv.cosio * ssh
+            se2 = ee2
+            si2 = xi2
+            sl2 = xl2
+            sgh2 = xgh2
+            sh2 = xh2
+            se3 = e3
+            si3 = xi3
+            sl3 = xl3
+            sgh3 = xgh3
+            sh3 = xh3
+            sl4 = xl4
+            sgh4 = xgh4
+            zcosg = zcosgl
+            zsing = zsingl
+            zcosi = zcosil
+            zsini = zsinil
+            zcosh = zcoshl * cosq + zsinhl * sinq
+            zsinh = sinq * zcoshl - cosq * zsinhl
+            zn = zNl
+            cc = c1l
+            ze = zEl
+        }
+
+        private fun calculateSolarTerms() {
+            a1 = zcosg * zcosh + zsing * zcosi * zsinh
+            a3 = -zsing * zcosh + zcosg * zcosi * zsinh
+            a7 = -zcosg * zsinh + zsing * zcosi * zcosh
+            a8 = zsing * zsini
+            a9 = zsing * zsinh + zcosg * zcosi * zcosh
+            a10 = zcosg * zsini
+            a2 = dsv.cosio * a7 + dsv.sinio * a8
+            a4 = dsv.cosio * a9 + dsv.sinio * a10
+            a5 = -dsv.sinio * a7 + dsv.cosio * a8
+            a6 = -dsv.sinio * a9 + dsv.cosio * a10
+            x1 = a1 * dsv.cosg + a2 * dsv.sing
+            x2 = a3 * dsv.cosg + a4 * dsv.sing
+            x3 = -a1 * dsv.sing + a2 * dsv.cosg
+            x4 = -a3 * dsv.sing + a4 * dsv.cosg
+            x5 = a5 * dsv.sing
+            x6 = a6 * dsv.sing
+            x7 = a5 * dsv.cosg
+            x8 = a6 * dsv.cosg
+            z31 = 12 * x1 * x1 - 3.0 * x3 * x3
+            z32 = 24 * x1 * x2 - 6 * x3 * x4
+            z33 = 12 * x2 * x2 - 3.0 * x4 * x4
+            z1 = 3.0 * (a1 * a1 + a2 * a2) + z31 * dsv.eosq
+            z2 = 6.0 * (a1 * a3 + a2 * a4) + z32 * dsv.eosq
+            z3 = 3.0 * (a3 * a3 + a4 * a4) + z33 * dsv.eosq
+            z11 = -6 * a1 * a5 + dsv.eosq * (-24 * x1 * x7 - 6 * x3 * x5)
+            z12 =
+                -6 * (a1 * a6 + a3 * a5) + dsv.eosq * (-24 * (x2 * x7 + x1 * x8) - 6 * (x3 * x6 + x4 * x5))
+            z13 = -6 * a3 * a6 + dsv.eosq * (-24 * x2 * x8 - 6 * x4 * x6)
+            z21 = 6.0 * a2 * a5 + dsv.eosq * (24 * x1 * x5 - 6 * x3 * x7)
+            z22 =
+                6.0 * (a4 * a5 + a2 * a6) + dsv.eosq * (24 * (x2 * x5 + x1 * x6) - 6 * (x4 * x7 + x3 * x8))
+            z23 = 6.0 * a4 * a6 + dsv.eosq * (24 * x2 * x6 - 6 * x4 * x8)
+            z1 += z1 + dsv.betao2 * z31
+            z2 += z2 + dsv.betao2 * z32
+            z3 += z3 + dsv.betao2 * z33
+            s3 = cc * xnoi
+            s2 = -0.5 * s3 / dsv.betao
+            s4 = s3 * dsv.betao
+            s1 = -15 * eq * s4
+            s5 = x1 * x3 + x2 * x4
+            s6 = x2 * x3 + x1 * x4
+            s7 = x2 * x4 - x1 * x3
+            se = s1 * zn * s5
+            si = s2 * zn * (z11 + z13)
+            sl = -zn * s3 * (z1 + z3 - 14 - 6 * dsv.eosq)
+            sgh = s4 * zn * (z31 + z33 - 6)
+            sh = -zn * s2 * (z21 + z23)
+            if (xqncl < 5.2359877E-2) sh = 0.0
+            ee2 = 2.0 * s1 * s6
+            e3 = 2.0 * s1 * s7
+            xi2 = 2.0 * s2 * z12
+            xi3 = 2.0 * s2 * (z13 - z11)
+            xl2 = -2 * s3 * z2
+            xl3 = -2 * s3 * (z3 - z1)
+            xl4 = -2 * s3 * (-21 - 9 * dsv.eosq) * ze
+            xgh2 = 2.0 * s4 * z32
+            xgh3 = 2.0 * s4 * (z33 - z31)
+            xgh4 = -18 * s4 * ze
+            xh2 = -2 * s2 * z22
+            xh3 = -2 * s2 * (z23 - z21)
+        }
+
+        private fun processEpochRestartLoop() {
+            if (atime == 0.0 || dsv.t >= 0 && atime < 0 || dsv.t < 0 && atime >= 0) {
+                calculateDelta()
+                atime = 0.0
+                xni = xnq
+                xli = xlamo
+            } else if (abs(dsv.t) >= abs(atime)) calculateDelta()
+            processNotEpochRestartLoop()
+        }
+
+        private fun calculateDelta() {
+            delt = if (dsv.t < 0) stepn else stepp
+        }
+
+        private fun processNotEpochRestartLoop() {
+            do {
+                if (abs(dsv.t - atime) >= stepp) {
+                    doLoop = true
+                    epochRestart = false
+                } else {
+                    ft = dsv.t - atime
+                    doLoop = false
+                }
+                if (abs(dsv.t) < abs(atime)) {
+                    delt = if (dsv.t >= 0) stepn else stepp
+                    doLoop = doLoop or epochRestart
+                }
+                if (synchronous) {
+                    xndot = del1 * sin(xli - fasx2) + del2 * sin(2.0 * (xli - fasx4)) +
+                        del3 * sin(3.0 * (xli - fasx6))
+                    xnddt = del1 * cos(xli - fasx2) + 2 * del2 * cos(2.0 * (xli - fasx4)) +
+                        3.0 * del3 * cos(3.0 * (xli - fasx6))
+                } else {
+                    xomi = omegaq + dsv.omgdot * atime
+                    x2omi = xomi + xomi
+                    x2li = xli + xli
+                    xndot =
+                        d2201 * sin(x2omi + xli - g22) + d2211 * sin(xli - g22) + (d3210
+                            * sin(xomi + xli - g32)) + d3222 * sin(-xomi + xli - g32) + (d4410
+                            * sin(x2omi + x2li - g44)) + d4422 * sin(x2li - g44) + (d5220
+                            * sin(xomi + xli - g52)) + d5232 * sin(-xomi + xli - g52) + (d5421
+                            * sin(xomi + x2li - g54)) + d5433 * sin(-xomi + x2li - g54)
+                    xnddt =
+                        d2201 * cos(x2omi + xli - g22) + d2211 * cos(xli - g22) + (d3210
+                            * cos(xomi + xli - g32)) + d3222 * cos(-xomi + xli - g32) + (d5220
+                            * cos(xomi + xli - g52)) + d5232 * cos(-xomi + xli - g52) + (2
+                            * (d4410 * cos(x2omi + x2li - g44) + d4422 * cos(x2li - g44) + (d5421
+                            * cos(xomi + x2li - g54)) + d5433 * cos(-xomi + x2li - g54)))
+                }
+                xldot = xni + xfact
+                xnddt *= xldot
+                if (doLoop) {
+                    xli += xldot * delt + xndot * step2
+                    xni += xndot * delt + xnddt * step2
+                    atime += delt
+                }
+            } while (doLoop && !epochRestart)
+        }
+
+        // Apply periodics with Lyddane modification
+        private fun applyPeriodics() {
+            sinok = sin(dsv.xnode)
+            cosok = cos(dsv.xnode)
+            alfdp = sinis * sinok
+            betdp = sinis * cosok
+            dalf = ph * cosok + pinc * cosis * sinok
+            dbet = -ph * sinok + pinc * cosis * cosok
+            alfdp += dalf
+            betdp += dbet
+            dsv.xnode = mod2PI(dsv.xnode)
+            xls = dsv.xll + dsv.omgadf + cosis * dsv.xnode
+            dls = pl + pgh - pinc * dsv.xnode * sinis
+            xls += dls
+            xnoh = dsv.xnode
+            dsv.xnode = atan2(alfdp, betdp)
+        }
+
+        // Calculates the Greenwich Mean Sidereal Time for an epoch, valid 1957 through 2056
+        private fun thetaG(epoch: Double): Double {
+            var year = floor(epoch * 1E-3)
+            var dayOfYear = (epoch * 1E-3 - year) * 1000.0
+            year = if (year < 57) year + 2000 else year + 1900
+            val dayFloor = floor(dayOfYear)
+            val dayFraction = dayOfYear - dayFloor
+            dayOfYear = dayFloor
+            val jd = julianDateOfYear(year) + dayOfYear
+            dsv.ds50 = jd - 2433281.5 + dayFraction
+            return mod2PI(6.3003880987 * dsv.ds50 + 1.72944494)
+        }
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/GeoPos.kt

@@ -0,0 +1,26 @@
+/*
+ * 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.core.domain.predict
+
+data class GeoPos(
+    val latitude: Double,
+    val longitude: Double,
+    val altitude: Double = 0.0,
+    val qthLocator: String = "null",
+    val timestamp: Long = 0L
+)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/NearEarthObject.kt

@@ -0,0 +1,226 @@
+/*
+ * 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.core.domain.predict
+
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.pow
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+class NearEarthObject(data: OrbitalData) : OrbitalObject(data) {
+
+    private val aodp: Double
+    private val aycof: Double
+    private val c1: Double
+    private val c4: Double
+    private val c5: Double
+    private val cosio: Double
+    private var d2 = 0.0
+    private var d3 = 0.0
+    private var d4 = 0.0
+    private val delmo: Double
+    private val omgcof: Double
+    private val eta: Double
+    private val omgdot: Double
+    private val sinio: Double
+    private val xnodp: Double
+    private val sinmo: Double
+    private val t2cof: Double
+    private var t3cof = 0.0
+    private var t4cof = 0.0
+    private var t5cof = 0.0
+    private val x1mth2: Double
+    private val x3thm1: Double
+    private val x7thm1: Double
+    private val xmcof: Double
+    private val xmdot: Double
+    private val xnodcf: Double
+    private val xnodot: Double
+    private val xlcof: Double
+    private val sgp4Simple: Boolean
+
+    init {
+        // Recover original mean motion (xnodp) and semimajor axis (aodp) from input elements
+        val a1 = (XKE / data.xno).pow(TWO_THIRDS)
+        cosio = cos(data.xincl)
+        val theta2 = sqr(cosio)
+        x3thm1 = 3.0 * theta2 - 1.0
+        val eo = data.eccn
+        val eosq = sqr(eo)
+        val betao2 = 1.0 - eosq
+        val betao = sqrt(betao2)
+        val del1 = 1.5 * CK2 * x3thm1 / (sqr(a1) * betao * betao2)
+        val ao = a1 * (1.0 - del1 * (0.5 * TWO_THIRDS + del1 * (1.0 + 134.0 / 81.0 * del1)))
+        val delo = 1.5 * CK2 * x3thm1 / (sqr(ao) * betao * betao2)
+        xnodp = data.xno / (1.0 + delo)
+        aodp = ao / (1.0 - delo)
+
+        // For perigee less than 220 kilometers, the "simple" flag is set
+        sgp4Simple = aodp * (1.0 - eo) < 220 / EARTH_RADIUS + 1.0
+
+        // For perigees below 156 km, the values of S and QOMS2T are altered
+        setPerigee((aodp * (1.0 - eo) - 1.0) * EARTH_RADIUS)
+        val pinvsq = invert(sqr(aodp) * sqr(betao2))
+        val tsi = invert(aodp - s4)
+        eta = aodp * eo * tsi
+        val etasq = eta * eta
+        val eeta = eo * eta
+        val psisq = abs(1.0 - etasq)
+        val coef = qoms24 * tsi.pow(4.0)
+        val coef1 = coef / psisq.pow(3.5)
+        val bstar = data.bstar
+        val c2 = coef1 * xnodp * (aodp * (1.0 + 1.5 * etasq + eeta * (4.0 + etasq)) + 0.75
+            * CK2 * tsi / psisq * x3thm1 * (8.0 + 3.0 * etasq * (8.0 + etasq)))
+        c1 = bstar * c2
+        sinio = sin(data.xincl)
+        val a3ovk2 = -J3_HARMONIC / CK2
+        val c3 = coef * tsi * a3ovk2 * xnodp * sinio / eo
+        x1mth2 = 1.0 - theta2
+        val omegao = data.omegao
+        c4 = 2 * xnodp * coef1 * aodp * betao2 * (eta * (2.0 + 0.5 * etasq) + eo * (0.5 + 2 * etasq)
+            - 2 * CK2 * tsi / (aodp * psisq) * (-3 * x3thm1 * (1.0 - 2 * eeta + etasq
+            * (1.5 - 0.5 * eeta)) + 0.75 * x1mth2 * (2.0 * etasq - eeta * (1.0 + etasq))
+            * cos(2.0 * omegao)))
+        c5 = 2.0 * coef1 * aodp * betao2 * (1.0 + 2.75 * (etasq + eeta) + eeta * etasq)
+        val theta4 = sqr(theta2)
+        val temp1 = 3.0 * CK2 * pinvsq * xnodp
+        val temp2 = temp1 * CK2 * pinvsq
+        val temp3 = 1.25 * CK4 * pinvsq * pinvsq * xnodp
+        xmdot =
+            xnodp + 0.5 * temp1 * betao * x3thm1 + (0.0625 * temp2 * betao * (13.0 - 78.0 * theta2 + 137.0 * theta4))
+        val x1m5th = 1.0 - 5.0 * theta2
+        omgdot =
+            -0.5 * temp1 * x1m5th + 0.0625 * temp2 * (7.0 - 114.0 * theta2 + 395.0 * theta4) + temp3 * (3.0 - 36.0 * theta2 + 49.0 * theta4)
+        val xhdot1 = -temp1 * cosio
+        xnodot =
+            xhdot1 + (0.5 * temp2 * (4.0 - 19.0 * theta2) + 2.0 * temp3 * (3.0 - 7.0 * theta2)) * cosio
+        omgcof = bstar * c3 * cos(omegao)
+        xmcof = -TWO_THIRDS * coef * bstar / eeta
+        xnodcf = 3.5 * betao2 * xhdot1 * c1
+        t2cof = 1.5 * c1
+        xlcof = 0.125 * a3ovk2 * sinio * (3.0 + 5 * cosio) / (1.0 + cosio)
+        aycof = 0.25 * a3ovk2 * sinio
+        val xmo = data.xmo
+        delmo = (1.0 + eta * cos(xmo)).pow(3.0)
+        sinmo = sin(xmo)
+        x7thm1 = 7.0 * theta2 - 1
+        if (!sgp4Simple) {
+            val c1sq = sqr(c1)
+            d2 = 4.0 * aodp * tsi * c1sq
+            val temp = d2 * tsi * c1 / 3.0
+            d3 = (17 * aodp + s4) * temp
+            d4 = 0.5 * temp * aodp * tsi * (221 * aodp + 31 * s4) * c1
+            t3cof = d2 + 2 * c1sq
+            t4cof = 0.25 * (3.0 * d3 + c1 * (12 * d2 + 10 * c1sq))
+            t5cof = 0.2 * (3.0 * d4 + 12 * c1 * d3 + 6 * d2 * d2 + 15 * c1sq * (2.0 * d2 + c1sq))
+        } else {
+            d2 = 0.0
+            d3 = 0.0
+            d4 = 0.0
+            t3cof = 0.0
+            t4cof = 0.0
+            t5cof = 0.0
+        }
+    }
+
+    internal fun calculateSGP4(tSince: Double) {
+        synchronized(this) {
+            val temp = DoubleArray(9)
+            val xmdf = data.xmo + xmdot * tSince
+            val omgadf = data.omegao + omgdot * tSince
+            val xnoddf = data.xnodeo + xnodot * tSince
+            var omega = omgadf
+            var xmp = xmdf
+            val tsq = sqr(tSince)
+            val xnode = xnoddf + xnodcf * tsq
+            val bstar = data.bstar
+            var tempa = 1.0 - c1 * tSince
+            var tempe = bstar * c4 * tSince
+            var templ = t2cof * tsq
+            if (!sgp4Simple) {
+                val delomg = omgcof * tSince
+                val delm = xmcof * ((1.0 + eta * cos(xmdf)).pow(3.0) - delmo)
+                temp[0] = delomg + delm
+                xmp = xmdf + temp[0]
+                omega = omgadf - temp[0]
+                val tcube = tsq * tSince
+                val tfour = tSince * tcube
+                tempa = tempa - d2 * tsq - d3 * tcube - d4 * tfour
+                tempe += bstar * c5 * (sin(xmp) - sinmo)
+                templ += t3cof * tcube + tfour * (t4cof + tSince * t5cof)
+            }
+            val a = aodp * tempa.pow(2.0)
+            val eo = data.eccn
+            val e = eo - tempe
+            val xl = xmp + omega + xnode + xnodp * templ
+            val beta = sqrt(1.0 - e * e)
+            val xn = XKE / a.pow(1.5)
+
+            // Long period periodics
+            val axn = e * cos(omega)
+            temp[0] = invert(a * sqr(beta))
+            val xll = temp[0] * xlcof * axn
+            val aynl = temp[0] * aycof
+            val xlt = xl + xll
+            val ayn = e * sin(omega) + aynl
+
+            // Solve Kepler's equation
+            val capu = mod2PI(xlt - xnode)
+            temp[2] = capu
+            converge(temp, axn, ayn, capu)
+            calculatePosAndVel(temp, xnode, a, xn, axn, ayn)
+            calculatePhase(xlt, xnode, omgadf)
+        }
+    }
+
+    private fun calculatePosAndVel(
+        temp: DoubleArray, xnode: Double, a: Double,
+        xn: Double, axn: Double, ayn: Double
+    ) {
+        val ecose = temp[5] + temp[6]
+        val esine = temp[3] - temp[4]
+        val elsq = sqr(axn) + sqr(ayn)
+        temp[0] = 1.0 - elsq
+        val pl = a * temp[0]
+        val r = a * (1.0 - ecose)
+        temp[1] = invert(r)
+        val rdot = XKE * sqrt(a) * esine * temp[1]
+        val rfdot = XKE * sqrt(pl) * temp[1]
+        temp[2] = a * temp[1]
+        val betal = sqrt(temp[0])
+        temp[3] = invert(1.0 + betal)
+        val cosu = temp[2] * (temp[8] - axn + ayn * esine * temp[3])
+        val sinu = temp[2] * (temp[7] - ayn - axn * esine * temp[3])
+        val u = atan2(sinu, cosu)
+        val sin2u = 2.0 * sinu * cosu
+        val cos2u = 2.0 * cosu * cosu - 1
+        temp[0] = invert(pl)
+        temp[1] = CK2 * temp[0]
+        temp[2] = temp[1] * temp[0]
+        // Update for short periodics
+        val rk = r * (1.0 - 1.5 * temp[2] * betal * x3thm1) + 0.5 * temp[1] * x1mth2 * cos2u
+        val uk = u - 0.25 * temp[2] * x7thm1 * sin2u
+        val xnodek = xnode + 1.5 * temp[2] * cosio * sin2u
+        val xinck = data.xincl + 1.5 * temp[2] * cosio * sinio * cos2u
+        val rdotk = rdot - xn * temp[1] * x1mth2 * sin2u
+        val rfdotk = rfdot + xn * temp[1] * (x1mth2 * cos2u + 1.5 * x3thm1)
+        super.calculatePosAndVel(rk, uk, xnodek, xinck, rdotk, rfdotk)
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/OrbitalData.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.core.domain.predict
+
+data class OrbitalData(
+    val name: String,
+    val epoch: Double,
+    val meanmo: Double,
+    val eccn: Double,
+    val incl: Double,
+    val raan: Double,
+    val argper: Double,
+    val meanan: Double,
+    val catnum: Int,
+    val bstar: Double
+) {
+    val xincl: Double = incl * DEG2RAD
+    val xnodeo: Double = raan * DEG2RAD
+    val omegao: Double = argper * DEG2RAD
+    val xmo: Double = meanan * DEG2RAD
+    val xno: Double = meanmo * TWO_PI / MIN_PER_DAY
+    val orbitalPeriod: Double = MIN_PER_DAY / meanmo
+    val isDeepSpace: Boolean = orbitalPeriod >= 225.0 // NearEarth (period < 225 min) or DeepSpace (period >= 225 min)
+    fun getObject(): OrbitalObject = if (isDeepSpace) DeepSpaceObject(this) else NearEarthObject(this)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/OrbitalObject.kt

@@ -0,0 +1,423 @@
+/*
+ * 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.core.domain.predict
+
+import kotlin.math.abs
+import kotlin.math.acos
+import kotlin.math.asin
+import kotlin.math.atan
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.exp
+import kotlin.math.floor
+import kotlin.math.ln
+import kotlin.math.pow
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+abstract class OrbitalObject(val data: OrbitalData) {
+
+    private val position = Vector4()
+    private val velocity = Vector4()
+    private var orbitalPos = OrbitalPos()
+    private var eclipseDepth = 0.0
+    private var gsPosTheta = 0.0
+    private var julUTC = 0.0
+    private var perigee = 0.0
+    var qoms24 = 0.0
+    var s4 = 0.0
+
+    fun willBeSeen(pos: GeoPos): Boolean {
+        return if (data.meanmo < 1e-8) false
+        else {
+            val sma = 331.25 * exp(ln(MIN_PER_DAY / data.meanmo) * (2.0 / 3.0))
+            val apogee = sma * (1.0 + data.eccn) - EARTH_RADIUS
+            var lin = data.incl
+            if (lin >= 90.0) lin = 180.0 - lin
+            acos(EARTH_RADIUS / (apogee + EARTH_RADIUS)) + lin * DEG2RAD > abs(pos.latitude * DEG2RAD)
+        }
+    }
+
+    fun getPosition(pos: GeoPos, time: Long): OrbitalPos {
+        orbitalPos = OrbitalPos()
+        // Date/time at which the position and velocity were calculated
+        julUTC = calcCurrentDaynum(time) + 2444238.5
+        // Convert satellite's epoch time to Julian and calculate time since epoch in minutes
+        val julEpoch = juliandDateOfEpoch(data.epoch)
+        val tsince = (julUTC - julEpoch) * MIN_PER_DAY
+        calculateSDP4orSGP4(tsince)
+        // Scale position and velocity vectors to km and km/sec
+        convertSatState(position, velocity)
+        // Calculate velocity of satellite
+        magnitude(velocity)
+        val squintVector = Vector4()
+        // Angles in rads, dist in km, vel in km/S. Calculate sat Az, El, Range and Range-rate.
+        calculateObs(julUTC, position, velocity, pos, squintVector)
+        calculateLatLonAlt(julUTC)
+        orbitalPos.time = time
+        orbitalPos.eclipsed = isEclipsed()
+        orbitalPos.eclipseDepth = eclipseDepth
+        return orbitalPos
+    }
+
+    private fun calcCurrentDaynum(now: Long): Double {
+        val then = 315446400000 // time in millis on 31Dec79 00:00:00 UTC (daynum 0)
+        return (now - then) / 1000.0 / 60.0 / 60.0 / 24.0
+    }
+
+    private fun juliandDateOfEpoch(epoch: Double): Double {
+        var year = floor(epoch * 1E-3)
+        val day = (epoch * 1E-3 - year) * 1000.0
+        year = if (year < 57) year + 2000 else year + 1900
+        return julianDateOfYear(year) + day
+    }
+
+    internal fun julianDateOfYear(theYear: Double): Double {
+        val aYear = theYear - 1
+        var i = floor(aYear / 100).toLong()
+        val a = i
+        i = a / 4
+        val b = 2 - a + i
+        i = floor(365.25 * aYear).toLong()
+        i += (30.6001 * 14).toLong()
+        return i + 1720994.5 + b
+    }
+
+    private fun calculateSDP4orSGP4(tsince: Double) {
+        if (data.isDeepSpace) (this as DeepSpaceObject).calculateSDP4(tsince)
+        else (this as NearEarthObject).calculateSGP4(tsince)
+    }
+
+    // Converts the sat position and velocity vectors to km and km/sec
+    private fun convertSatState(pos: Vector4, vel: Vector4) {
+        scaleVector(EARTH_RADIUS, pos)
+        scaleVector(EARTH_RADIUS * MIN_PER_DAY / SEC_PER_DAY, vel)
+    }
+
+    // Calculates the topocentric coordinates of the object with ECI pos and vel at time
+    private fun calculateObs(
+        julianUTC: Double,
+        positionVector: Vector4,
+        velocityVector: Vector4,
+        gsPos: GeoPos,
+        squintVector: Vector4
+    ) {
+        val obsPos = Vector4()
+        val obsVel = Vector4()
+        val range = Vector4()
+        val rgvel = Vector4()
+        calculateUserPosVel(julianUTC, gsPos, obsPos, obsVel)
+        range.setXYZ(
+            positionVector.x - obsPos.x,
+            positionVector.y - obsPos.y,
+            positionVector.z - obsPos.z
+        )
+        // Save these values globally for calculating squint angles later
+        squintVector.setXYZ(range.x, range.y, range.z)
+        rgvel.setXYZ(
+            velocityVector.x - obsVel.x,
+            velocityVector.y - obsVel.y,
+            velocityVector.z - obsVel.z
+        )
+        magnitude(range)
+        val sinLat = sin(DEG2RAD * gsPos.latitude)
+        val cosLat = cos(DEG2RAD * gsPos.latitude)
+        val sinTheta = sin(gsPosTheta)
+        val cosTheta = cos(gsPosTheta)
+        val topS = sinLat * cosTheta * range.x + sinLat * sinTheta * range.y - cosLat * range.z
+        val topE = -sinTheta * range.x + cosTheta * range.y
+        val topZ = cosLat * cosTheta * range.x + cosLat * sinTheta * range.y + sinLat * range.z
+        var azim = atan(-topE / topS)
+        if (topS > 0.0) azim += PI
+        if (azim < 0.0) azim += TWO_PI
+        orbitalPos.azimuth = azim
+        orbitalPos.elevation = asin(topZ / range.w)
+        orbitalPos.distance = range.w
+        orbitalPos.distanceRate = dot(range, rgvel) / range.w
+        var elevation = orbitalPos.elevation / TWO_PI * 360.0
+        if (elevation > 90) elevation = 180 - elevation
+        orbitalPos.aboveHorizon = elevation - 0 > EPSILON
+    }
+
+    // Returns the ECI position and velocity of the observer
+    private fun calculateUserPosVel(
+        time: Double,
+        gsPos: GeoPos,
+        obsPos: Vector4,
+        obsVel: Vector4
+    ) {
+        val mFactor = 7.292115E-5
+        gsPosTheta = mod2PI(thetaGJD(time) + DEG2RAD * gsPos.longitude)
+        val c = invert(sqrt(1.0 + FLAT_FACT * (FLAT_FACT - 2) * sqr(sin(DEG2RAD * gsPos.latitude))))
+        val sq = sqr(1.0 - FLAT_FACT) * c
+        val achcp = (EARTH_RADIUS * c + gsPos.altitude / 1000.0) * cos(DEG2RAD * gsPos.latitude)
+        obsPos.setXYZ(
+            achcp * cos(gsPosTheta), achcp * sin(gsPosTheta),
+            (EARTH_RADIUS * sq + gsPos.altitude / 1000.0) * sin(DEG2RAD * gsPos.latitude)
+        )
+        obsVel.setXYZ(-mFactor * obsPos.y, mFactor * obsPos.x, 0.0)
+        magnitude(obsPos)
+        magnitude(obsVel)
+    }
+
+    // Calculate the geodetic position of an object given its ECI pos and time
+    private fun calculateLatLonAlt(time: Double) {
+        orbitalPos.theta = atan2(position.y, position.x)
+        orbitalPos.longitude = mod2PI(orbitalPos.theta - thetaGJD(time))
+        val r = sqrt(sqr(position.x) + sqr(position.y))
+        val e2 = FLAT_FACT * (2.0 - FLAT_FACT)
+        orbitalPos.latitude = atan2(position.z, r)
+        var phi: Double
+        var c: Double
+        var i = 0
+        var converged: Boolean
+        do {
+            phi = orbitalPos.latitude
+            c = invert(sqrt(1.0 - e2 * sqr(sin(phi))))
+            orbitalPos.latitude = atan2(position.z + EARTH_RADIUS * c * e2 * sin(phi), r)
+            converged = abs(orbitalPos.latitude - phi) < EPSILON
+        } while (i++ < 10 && !converged)
+        orbitalPos.altitude = r / cos(orbitalPos.latitude) - EARTH_RADIUS * c
+        var temp = orbitalPos.latitude
+        if (temp > PI_2) {
+            temp -= TWO_PI
+            orbitalPos.latitude = temp
+        }
+    }
+
+    internal fun calculatePosAndVel(
+        rk: Double, uk: Double, xnodek: Double,
+        xinck: Double, rdotk: Double, rfdotk: Double
+    ) {
+        // Orientation vectors
+        val sinuk = sin(uk)
+        val cosuk = cos(uk)
+        val sinik = sin(xinck)
+        val cosik = cos(xinck)
+        val sinnok = sin(xnodek)
+        val cosnok = cos(xnodek)
+        val xmx = -sinnok * cosik
+        val xmy = cosnok * cosik
+        val ux = xmx * sinuk + cosnok * cosuk
+        val uy = xmy * sinuk + sinnok * cosuk
+        val uz = sinik * sinuk
+        val vx = xmx * cosuk - cosnok * sinuk
+        val vy = xmy * cosuk - sinnok * sinuk
+        val vz = sinik * cosuk
+        // Position and velocity
+        position.setXYZ(ux, uy, uz)
+        position.multiply(rk)
+        velocity.x = rdotk * ux + rfdotk * vx
+        velocity.y = rdotk * uy + rfdotk * vy
+        velocity.z = rdotk * uz + rfdotk * vz
+    }
+
+    internal class Vector4(
+        var w: Double = 0.0,
+        var x: Double = 0.0,
+        var y: Double = 0.0,
+        var z: Double = 0.0
+    ) {
+
+        fun multiply(multiplier: Double) {
+            x *= multiplier
+            y *= multiplier
+            z *= multiplier
+        }
+
+        fun setXYZ(xValue: Double, yValue: Double, zValue: Double) {
+            x = xValue
+            y = yValue
+            z = zValue
+        }
+    }
+
+    internal fun sqr(arg: Double): Double {
+        return arg * arg
+    }
+
+    internal fun invert(value: Double): Double {
+        return 1.0 / value
+    }
+
+    // Calculates the modulus of 2 * PI
+    internal fun mod2PI(value: Double): Double {
+        var retVal = value
+        val i = (retVal / TWO_PI).toInt()
+        retVal -= i * TWO_PI
+        if (retVal < 0.0) retVal += TWO_PI
+        return retVal
+    }
+
+    // Solves Keplers' Equation
+    internal fun converge(temp: DoubleArray, axn: Double, ayn: Double, capu: Double) {
+        var converged = false
+        var i = 0
+        do {
+            temp[7] = sin(temp[2])
+            temp[8] = cos(temp[2])
+            temp[3] = axn * temp[7]
+            temp[4] = ayn * temp[8]
+            temp[5] = axn * temp[8]
+            temp[6] = ayn * temp[7]
+            val epw = (capu - temp[4] + temp[3] - temp[2]) / (1.0 - temp[5] - temp[6]) + temp[2]
+            if (abs(epw - temp[2]) <= EPSILON) converged = true else temp[2] = epw
+        } while (i++ < 10 && !converged)
+    }
+
+    internal fun calculatePhase(xlt: Double, xnode: Double, omgadf: Double) {
+        var phaseValue = xlt - xnode - omgadf + TWO_PI
+        if (phaseValue < 0.0) phaseValue += TWO_PI
+        orbitalPos.phase = mod2PI(phaseValue)
+    }
+
+    // Sets perigee and checks and adjusts the calculation if the perigee is less tan 156KM
+    internal fun setPerigee(perigee: Double) {
+        this.perigee = perigee
+        checkPerigee()
+    }
+
+    // Checks and adjusts the calculation if the perigee is less tan 156KM
+    private fun checkPerigee() {
+        s4 = 1.012229
+        qoms24 = 1.880279E-09
+        if (perigee < 156.0) {
+            s4 = if (perigee <= 98.0) 20.0 else perigee - 78.0
+            qoms24 = ((120 - s4) / EARTH_RADIUS).pow(4.0)
+            s4 = s4 / EARTH_RADIUS + 1.0
+        }
+    }
+
+    // Checks if the satellite is in sunlight
+    private fun isEclipsed(): Boolean {
+        val sunVector = calculateSunVector()
+        val sdEarth = asin(EARTH_RADIUS / position.w)
+        val rho = subtract(sunVector, position)
+        val sdSun = asin(SOLAR_RADIUS / rho.w)
+        val earth = scalarNegMultiply(position)
+        val delta = angle(sunVector, earth)
+        eclipseDepth = sdEarth - sdSun - delta
+        return if (sdEarth < sdSun) false else eclipseDepth >= 0
+    }
+
+    private fun calculateSunVector(): Vector4 {
+        val mjd = julUTC - 2415020.0
+        val year = 1900 + mjd / 365.25
+        val solTime = (mjd + deltaEt(year) / SEC_PER_DAY) / 36525.0
+        val mTemp = modulus(35999.04975 * solTime, 360.0)
+        val m = radians(
+            modulus(358.47583 + mTemp - (0.000150 + 0.0000033 * solTime) * sqr(solTime), 360.0)
+        )
+        val lTemp = modulus(36000.76892 * solTime, 360.0)
+        val l = radians(
+            modulus(279.69668 + lTemp + 0.0003025 * sqr(solTime), 360.0)
+        )
+        val e = 0.01675104 - (0.0000418 + 0.000000126 * solTime) * solTime
+        val c = radians(
+            ((1.919460 - (0.004789 + 0.000014 * solTime) * solTime) * sin(m))
+                + ((0.020094 - 0.000100 * solTime) * sin(2 * m)) + 0.000293 * sin(3 * m)
+        )
+        val o = radians(modulus(259.18 - 1934.142 * solTime, 360.0))
+        val lsa = modulus(l + c - radians(0.00569 - 0.00479 * sin(o)), TWO_PI)
+        val nu = modulus(m + c, TWO_PI)
+        var r = (1.0000002 * (1.0 - sqr(e)) / (1.0 + e * cos(nu)))
+        val eps = radians(
+            23.452294 - (0.0130125 + (0.00000164 - 0.000000503 * solTime) * solTime)
+                * solTime + 0.00256 * cos(o)
+        )
+        r *= ASTRONOMICAL_UNIT
+        return Vector4(r, r * cos(lsa), r * sin(lsa) * cos(eps), r * sin(lsa) * sin(eps))
+    }
+
+    private fun subtract(v1: Vector4, v2: Vector4): Vector4 {
+        val v3 = Vector4()
+        v3.x = v1.x - v2.x
+        v3.y = v1.y - v2.y
+        v3.z = v1.z - v2.z
+        magnitude(v3)
+        return v3
+    }
+
+    private fun scalarNegMultiply(vector: Vector4): Vector4 {
+        val neg = -1.0
+        return Vector4(vector.w * abs(neg), vector.x * neg, vector.y * neg, vector.z * neg)
+    }
+
+    private fun angle(v1: Vector4, v2: Vector4): Double {
+        magnitude(v1)
+        magnitude(v2)
+        return acos(dot(v1, v2) / (v1.w * v2.w))
+    }
+
+    /**
+     * The function Delta_ET has been added to allow calculations on the
+     * position of the sun. It provides the difference between UT (approximately
+     * the same as UTC) and ET (now referred to as TDT) This function is based
+     * on a least squares fit of data from 1950 to 1991 and will need to be
+     * updated periodically.
+     *
+     * Values determined using data from 1950-1991 in the 1990 Astronomical
+     * Almanac. See DELTA_ET.WQ1 for details.
+     */
+    private fun deltaEt(year: Double): Double {
+        return 26.465 + 0.747622 * (year - 1950) + (1.886913 * sin(TWO_PI * (year - 1975) / 33))
+    }
+
+    private fun radians(degrees: Double): Double {
+        return degrees * DEG2RAD
+    }
+
+    // Calculates the dot product of two vectors
+    private fun dot(v1: Vector4, v2: Vector4): Double {
+        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
+    }
+
+    // Returns fractional part of double argument
+    private fun fraction(arg: Double): Double {
+        return arg - floor(arg)
+    }
+
+    // Calculates scalar magnitude of a vector4 argument
+    private fun magnitude(v: Vector4) {
+        v.w = sqrt(sqr(v.x) + sqr(v.y) + sqr(v.z))
+    }
+
+    private fun modulus(arg1: Double, arg2: Double = SEC_PER_DAY): Double {
+        var returnValue = arg1
+        val i = floor(returnValue / arg2).toInt()
+        returnValue -= i * arg2
+        if (returnValue < 0.0) returnValue += arg2
+        return returnValue
+    }
+
+    // Multiplies the vector v1 by the scalar k
+    private fun scaleVector(k: Double, v: Vector4) {
+        v.multiply(k)
+        magnitude(v)
+    }
+
+    private fun thetaGJD(theJD: Double): Double {
+        val earthRotPerSidDay = 1.00273790934
+        val ut = fraction(theJD + 0.5)
+        val aJD = theJD - ut
+        val tu = (aJD - 2451545.0) / 36525.0
+        var gmst = 24110.54841 + tu * (8640184.812866 + tu * (0.093104 - tu * 6.2E-6))
+        gmst = modulus(gmst + SEC_PER_DAY * earthRotPerSidDay * ut)
+        return TWO_PI * gmst / SEC_PER_DAY
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/OrbitalPass.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.core.domain.predict
+
+data class OrbitalPass(
+    val aosTime: Long = 0L,
+    val aosAzimuth: Double = 90.0,
+    val losTime: Long = 0L,
+    val losAzimuth: Double = 270.0,
+    val altitude: Int = 1000,
+    val maxElevation: Double = 75.0,
+    val orbitalObject: OrbitalObject,
+    var progress: Float = 0.0f
+) {
+    val catNum: Int = orbitalObject.data.catnum
+    val name: String = orbitalObject.data.name
+    val isDeepSpace: Boolean = orbitalObject.data.isDeepSpace
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/predict/OrbitalPos.kt

@@ -0,0 +1,72 @@
+/*
+ * 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.core.domain.predict
+
+import kotlin.math.acos
+import kotlin.math.asin
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.pow
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+data class OrbitalPos(
+    var azimuth: Double = 0.0,
+    var elevation: Double = 0.0,
+    var latitude: Double = 0.0,
+    var longitude: Double = 0.0,
+    var altitude: Double = 0.0,
+    var distance: Double = 0.0,
+    var distanceRate: Double = 0.0,
+    var theta: Double = 0.0,
+    var time: Long = 0L,
+    var phase: Double = 0.0,
+    var eclipseDepth: Double = 0.0,
+    var eclipsed: Boolean = false,
+    var aboveHorizon: Boolean = false
+) {
+
+    fun getDownlinkFreq(freq: Long): Long {
+        return (freq.toDouble() * (SPEED_OF_LIGHT - distanceRate * 1000.0) / SPEED_OF_LIGHT).toLong()
+    }
+
+    fun getUplinkFreq(freq: Long): Long {
+        return (freq.toDouble() * (SPEED_OF_LIGHT + distanceRate * 1000.0) / SPEED_OF_LIGHT).toLong()
+    }
+
+    fun getOrbitalVelocity(): Double {
+        val earthG = 6.674 * 10.0.pow(-11)
+        val earthM = 5.98 * 10.0.pow(24)
+        val radius = 6.37 * 10.0.pow(6) + altitude * 10.0.pow(3)
+        return sqrt(earthG * earthM / radius) / 1000
+    }
+
+    fun getRangeCircle(): List<GeoPos> {
+        val rangeCirclePoints = mutableListOf<GeoPos>()
+        val beta = acos(EARTH_RADIUS / (EARTH_RADIUS + altitude)) // * EARTH_RADIUS = radiusKm
+        for (azimuth in 0..720) {
+            val rads = azimuth * DEG2RAD
+            val lat = asin(sin(latitude) * cos(beta) + (cos(latitude) * sin(beta) * cos(rads)))
+            val lon = (longitude + atan2(
+                sin(rads) * sin(beta) * cos(latitude), cos(beta) - sin(latitude) * sin(lat)
+            ))
+            rangeCirclePoints.add(GeoPos(lat * RAD2DEG, lon * RAD2DEG))
+        }
+        return rangeCirclePoints
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/IDatabaseRepo.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.core.domain.repository
+
+interface IDatabaseRepo {
+    suspend fun updateTLEFromFile(uri: String)
+    suspend fun updateTransceiversFromFile(uri: String)
+    suspend fun updateFromRemote()
+    suspend fun clearAllData()
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/IMainContainer.kt

@@ -0,0 +1,22 @@
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+import com.rtbishop.look4sat.core.domain.usecase.IShowToast
+import kotlinx.coroutines.CoroutineScope
+
+interface IMainContainer {
+    val appScope: CoroutineScope
+    val settingsRepo: ISettingsRepo
+    val selectionRepo: ISelectionRepo
+    val satelliteRepo: ISatelliteRepo
+    val databaseRepo: IDatabaseRepo
+    fun provideAddToCalendar(): IAddToCalendar
+    fun provideShowToast(): IShowToast
+    fun provideBluetoothReporter(): IReporterRepo<WithoutExtParams>
+    fun provideNetworkReporter(): IReporterRepo<ExtendedParams>
+    fun provideSensorsRepo(): ISensorsRepo
+}
+
+interface IContainerProvider {
+    fun getMainContainer(): IMainContainer
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/IReporterRepo.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.core.domain.repository
+
+interface IReporterParams
+
+interface IReporterRepo<T : IReporterParams> {
+    fun isConnected(service: BtService): Boolean
+    fun isConnecting(service: BtService): Boolean
+    fun connect(service: BtService, deviceId: String)
+    fun reportRotation(format: String, azimuth: Double, elevation: Double, params: T)
+    fun reportFrequency(format: String, frequency: Long, params: T)
+}
+
+data class ExtendedParams(val server: String, val port: Int) : IReporterParams
+
+data class WithoutExtParams(val dummy: Int) : IReporterParams
+
+enum class BtService { ROTATOR, FREQUENCY }

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/ISatelliteRepo.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import kotlinx.coroutines.flow.StateFlow
+
+interface ISatelliteRepo {
+    val passes: StateFlow<List<OrbitalPass>>
+    val satellites: StateFlow<List<OrbitalObject>>
+    suspend fun getRadiosWithId(id: Int): List<SatRadio>
+    suspend fun initRepository()
+    suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos
+    suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos>
+    suspend fun getRadios(sat: OrbitalObject, pos: GeoPos, radios: List<SatRadio>, time: Long): List<SatRadio>
+    suspend fun processPasses(passList: List<OrbitalPass>, time: Long): List<OrbitalPass>
+    suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/ISelectionRepo.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import kotlinx.coroutines.flow.Flow
+
+interface ISelectionRepo {
+    fun getCurrentTypes(): List<String>
+    fun getTypesList(): List<String>
+    suspend fun getEntriesFlow(): Flow<List<SatItem>>
+    suspend fun setTypes(types: List<String>)
+    suspend fun setQuery(query: String)
+    suspend fun setSelection(selectAll: Boolean)
+    suspend fun setSelection(ids: List<Int>, isTicked: Boolean)
+    suspend fun saveSelection()
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/ISensorsRepo.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import kotlinx.coroutines.flow.StateFlow
+
+interface ISensorsRepo {
+    val orientation: StateFlow<Pair<Float, Float>>
+    fun getMagDeclination(geoPos: GeoPos, time: Long = System.currentTimeMillis()): Float
+    fun enableSensor()
+    fun disableSensor()
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/ISettingsRepo.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import kotlinx.coroutines.flow.StateFlow
+
+interface ISettingsRepo {
+
+    val appVersionName: String
+
+    //region # Satellites selection settings
+    val selectedIds: StateFlow<List<Int>>
+    val selectedTypes: StateFlow<List<String>>
+    fun setSelectedIds(ids: List<Int>)
+    fun setSelectedTypes(types: List<String>)
+    //endregion
+
+    //region # Passes filter settings
+    val passesSettings: StateFlow<PassesSettings>
+    fun setPassesSettings(settings: PassesSettings)
+    //endregion
+
+    //region # Station position settings
+    val stationPosition: StateFlow<GeoPos>
+    fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean
+    fun setStationPosition(): Boolean
+    fun setStationPosition(locator: String): Boolean
+    //endregion
+
+    //region # Database update settings
+    val databaseState: StateFlow<DatabaseState>
+    fun getSatelliteTypesIds(types: List<String>): List<Int>
+    fun setSatelliteTypeIds(type: String, ids: List<Int>)
+    fun updateDatabaseState(state: DatabaseState)
+    //endregion
+
+    //region # RC settings
+    val rcSettings: StateFlow<RCSettings>
+    fun setBluetoothRotatorAddress(value: String)
+    fun setBluetoothRotatorFormat(value: String)
+    fun setBluetoothRotatorName(value: String)
+    fun setBluetoothRotatorState(value: Boolean)
+    fun setBluetoothFrequencyAddress(value: String)
+    fun setBluetoothFrequencyFormat(value: String)
+    fun setBluetoothFrequencyState(value: Boolean)
+    fun setRotatorAddress(value: String)
+    fun setRotatorPort(value: String)
+    fun setRotatorState(value: Boolean)
+    fun setRotatorFormat(value: String)
+    fun setFrequencyAddress(value: String)
+    fun setFrequencyPort(value: String)
+    fun setFrequencyState(value: Boolean)
+    fun setFrequencyFormat(value: String)
+    //endregion
+
+    //region # Other settings
+    val otherSettings: StateFlow<OtherSettings>
+    fun setStateOfAutoUpdate(value: Boolean)
+    fun setStateOfSensors(value: Boolean)
+    fun setStateOfSweep(value: Boolean)
+    fun setStateOfUtc(value: Boolean)
+    fun setStateOfLightTheme(value: Boolean)
+    fun setWarningDismissed()
+    fun setWhatsNewDismissed()
+    //endregion
+
+    //region # Transceivers settings
+    val dataSourcesSettings: StateFlow<DataSourcesSettings>
+    fun setUseCustomTle(value: Boolean)
+    fun setUseCustomTransceivers(value: Boolean)
+    fun setTleUrl(value: String)
+    fun setTransceiversUrl(value: String)
+    //endregion
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/source/ILocalSource.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.core.domain.source
+
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+
+interface ILocalSource {
+    suspend fun getEntriesTotal(): Int
+    suspend fun getEntriesList(): List<SatItem>
+    suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject>
+    suspend fun insertEntries(entries: List<OrbitalData>)
+    suspend fun deleteEntries()
+    suspend fun getIdsWithModes(modes: List<String>): List<Int>
+    suspend fun getRadiosTotal(): Int
+    suspend fun getRadiosWithId(id: Int): List<SatRadio>
+    suspend fun insertRadios(radios: List<SatRadio>)
+    suspend fun deleteRadios()
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/source/IRemoteSource.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.core.domain.source
+
+import java.io.InputStream
+
+interface IRemoteSource {
+    suspend fun getFileStream(uri: String): InputStream?
+    suspend fun getNetworkStream(url: String): InputStream?
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/source/Sources.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.core.domain.source
+
+object Sources {
+    const val RADIO_DATA_URL = "https://db.satnogs.org/api/transmitters/?format=json&status=active"
+    val satelliteDataUrls = mapOf(
+        "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
+        "Amateur" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=csv",
+        "Brightest" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=visual&FORMAT=csv",
+        "Cubesat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=cubesat&FORMAT=csv",
+        "Education" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=education&FORMAT=csv",
+        "Engineer" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=engineering&FORMAT=csv",
+        "Geostationary" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=geo&FORMAT=csv",
+        "Globalstar" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=globalstar&FORMAT=csv",
+        "GNSS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=gnss&FORMAT=csv",
+        "Intelsat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=intelsat&FORMAT=csv",
+        "Iridium" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=iridium-NEXT&FORMAT=csv",
+        "Military" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=military&FORMAT=csv",
+        "New" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=last-30-days&FORMAT=csv",
+        "OneWeb" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=oneweb&FORMAT=csv",
+        "Orbcomm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=orbcomm&FORMAT=csv",
+        "Resource" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=resource&FORMAT=csv",
+        "SatNOGS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv",
+        "Science" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=science&FORMAT=csv",
+        "Spire" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=spire&FORMAT=csv",
+        "Starlink" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=starlink&FORMAT=csv",
+        "Swarm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=swarm&FORMAT=csv",
+        "Weather" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=weather&FORMAT=csv",
+        "X-Comm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=x-comm&FORMAT=csv",
+        "Amsat" to "https://amsat.org/tle/current/nasabare.txt",
+        "Classified" to "https://www.mmccants.org/tles/classfd.zip",
+        "McCants" to "https://www.mmccants.org/tles/inttles.zip",
+        "R4UAB" to "https://r4uab.ru/satonline.txt",
+        "Other" to "" // key for sats filter
+    )
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/usecase/IAddToCalendar.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.core.domain.usecase
+
+interface IAddToCalendar {
+    operator fun invoke(name: String, aosTime: Long, losTime: Long)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/usecase/IShowToast.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.core.domain.usecase
+
+interface IShowToast {
+    operator fun invoke(message: String)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/DataParser.kt

@@ -0,0 +1,154 @@
+/*
+ * 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.core.domain.utility
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.InputStream
+import kotlin.math.pow
+
+class DataParser(private val dispatcher: CoroutineDispatcher) {
+
+    suspend fun parseCSVStream(stream: InputStream): List<OrbitalData> = withContext(dispatcher) {
+        val parsedItems = mutableListOf<OrbitalData>()
+        stream.bufferedReader().useLines { lines ->
+            lines.forEachIndexed { index, line ->
+                if (index != 0) {
+                    val values = line.split(",")
+                    parseCSV(values)?.let { tle -> parsedItems.add(tle) }
+                }
+            }
+        }
+        return@withContext parsedItems
+    }
+
+    suspend fun parseTLEStream(stream: InputStream): List<OrbitalData> = withContext(dispatcher) {
+        val tleStrings = mutableListOf(String(), String(), String())
+        val parsedItems = mutableListOf<OrbitalData>()
+        var lineIndex = 0
+        stream.bufferedReader().forEachLine { line ->
+            tleStrings[lineIndex] = line
+            if (lineIndex < 2) {
+                lineIndex++
+            } else {
+                val isLineOneValid = tleStrings[1].substring(0, 1) == "1"
+                val isLineTwoValid = tleStrings[2].substring(0, 1) == "2"
+                if (!isLineOneValid && !isLineTwoValid) return@forEachLine
+                parseTLE(tleStrings)?.let { tle -> parsedItems.add(tle) }
+                lineIndex = 0
+            }
+        }
+        return@withContext parsedItems
+    }
+
+    suspend fun parseJSONStream(stream: InputStream): List<SatRadio> = withContext(dispatcher) {
+        val parsedItems = mutableListOf<SatRadio>()
+        try {
+            val jsonArray = JSONArray(stream.bufferedReader().readText())
+            for (index in 0 until jsonArray.length()) {
+                val jsonObject = jsonArray.getJSONObject(index)
+                parseJSON(jsonObject)?.let { parsedItems.add(it) }
+            }
+            return@withContext parsedItems
+        } catch (_: Exception) {
+            return@withContext parsedItems
+        }
+    }
+
+    fun isLeapYear(year: Int): Boolean {
+        return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)
+    }
+
+    private fun parseCSV(values: List<String>): OrbitalData? = try {
+        val name = values[0]
+        val year = values[2].substring(0, 4)
+        val month = values[2].substring(5, 7)
+        val dayOfMonth = values[2].substring(8, 10)
+        val dayInt = getDayOfYear(year.toInt(), month.toInt(), dayOfMonth.toInt())
+        val day = if (dayInt < 10) "00$dayInt" else if (dayInt < 100) "0$dayInt" else "$dayInt"
+        val hour = values[2].substring(11, 13).toInt() * 3600000 // ms in one hour
+        val min = values[2].substring(14, 16).toInt() * 60000 // ms in one minute
+        val sec = values[2].substring(17, 19).toInt() * 1000 // ms in one second
+        val ms = values[2].substring(20, 26).toInt() / 1000.0 // microseconds to ms
+        val frac = ((hour + min + sec + ms) / 86400000.0).toString()
+        val epoch = "${year.substring(2)}$day${frac.substring(1)}".toDouble()
+        val meanmo = values[3].toDouble()
+        val eccn = values[4].toDouble()
+        val incl = values[5].toDouble()
+        val raan = values[6].toDouble()
+        val argper = values[7].toDouble()
+        val meanan = values[8].toDouble()
+        val catnum = values[11].toInt()
+        val bstar = values[14].toDouble()
+        OrbitalData(name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar)
+    } catch (exception: Exception) {
+        println("CSV parsing exception: $exception")
+        null
+    }
+
+    private fun parseTLE(tle: List<String>): OrbitalData? = try {
+        val name: String = tle[0].trim()
+        val epoch: Double = tle[1].substring(18, 32).toDouble()
+        val meanmo: Double = tle[2].substring(52, 63).toDouble()
+        val eccn: Double = tle[2].substring(26, 33).toDouble() / 10000000.0
+        val incl: Double = tle[2].substring(8, 16).toDouble()
+        val raan: Double = tle[2].substring(17, 25).toDouble()
+        val argper: Double = tle[2].substring(34, 42).toDouble()
+        val meanan: Double = tle[2].substring(43, 51).toDouble()
+        val catnum: Int = tle[1].substring(2, 7).trim().toInt()
+        val bstar: Double = 1.0e-5 * tle[1].substring(53, 59).toDouble() / 10.0.pow(tle[1].substring(60, 61).toDouble())
+        OrbitalData(name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar)
+    } catch (exception: Exception) {
+        println("TLE parsing exception: $exception")
+        null
+    }
+
+    private fun parseJSON(json: JSONObject): SatRadio? = try {
+        val uuid = json.getString("uuid")
+        val info = json.getString("description")
+        val alive = json.getBoolean("alive")
+        val dlinkLow = if (json.isNull("downlink_low")) null else json.getLong("downlink_low")
+        val dlinkHigh = if (json.isNull("downlink_high")) null else json.getLong("downlink_high")
+        val dlinkMode = if (json.isNull("mode")) null else json.getString("mode")
+        val ulinkLow = if (json.isNull("uplink_low")) null else json.getLong("uplink_low")
+        val ulinkHigh = if (json.isNull("uplink_high")) null else json.getLong("uplink_high")
+        val ulinkMode = if (json.isNull("uplink_mode")) null else json.getString("uplink_mode")
+        val inverted = json.getBoolean("invert")
+        val catnum = if (json.isNull("norad_cat_id")) null else json.getInt("norad_cat_id")
+        SatRadio(uuid, info, alive, dlinkLow, dlinkHigh, dlinkMode, ulinkLow, ulinkHigh, ulinkMode, inverted, catnum)
+    } catch (exception: Exception) {
+        println("JSON parsing exception: $exception")
+        null
+    }
+
+    private fun getDayOfYear(year: Int, month: Int, dayOfMonth: Int): Int {
+        if (month == 1) return dayOfMonth
+        val daysArray = arrayOf(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+        var dayOfYear = dayOfMonth
+        // If leap year increment Feb days
+        if (isLeapYear(year)) daysArray[1]++
+        for (i in 0 until month - 1) {
+            dayOfYear += daysArray[i]
+        }
+        return dayOfYear
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/Extensions.kt

@@ -0,0 +1,69 @@
+/*
+ * 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.core.domain.utility
+
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+
+fun Long.toTimerString(): String {
+    val format = "%02d:%02d:%02d"
+    val hours = TimeUnit.MILLISECONDS.toHours(this)
+    val minutes = TimeUnit.MILLISECONDS.toMinutes(this) % 60
+    val seconds = TimeUnit.MILLISECONDS.toSeconds(this) % 60
+    return String.format(Locale.ENGLISH, format, hours, minutes, seconds)
+}
+
+fun Float.round(decimals: Int): Float {
+    var multiplier = 1.0f
+    repeat(decimals) { multiplier *= 10 }
+    return kotlin.math.round(this * multiplier) / multiplier
+}
+
+fun Double.round(decimals: Int): Double {
+    var multiplier = 1.0
+    repeat(decimals) { multiplier *= 10 }
+    return kotlin.math.round(this * multiplier) / multiplier
+}
+
+//fun String.getHash(type: String = "SHA-256"): String {
+//    val hexChars = "0123456789ABCDEF"
+//    val bytes = MessageDigest.getInstance(type).digest(this.toByteArray())
+//    val result = StringBuilder(bytes.size * 2)
+//    bytes.forEach {
+//        val i = it.toInt()
+//        result.append(hexChars[i shr 4 and 0x0f])
+//        result.append(hexChars[i and 0x0f])
+//    }
+//    return result.toString()
+//}
+
+//fun String.isValidEmail(): Boolean {
+//    val expression = "^[\\w.-]+@([\\w\\-]+\\.)+[A-Z]{2,8}$"
+//    val pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE)
+//    return pattern.matcher(this).matches()
+//}
+
+//fun String.isValidIPv4(): Boolean {
+//    val ip4 = "^((\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])(\\.(?!\$)|\$)){4}\$"
+//    return this.matches(ip4.toRegex())
+//}
+
+//fun String.isValidPort(): Boolean {
+//    val port = "([1-9]|[1-9]\\d{1,3}|[1-5]\\d{4}|6[0-4]\\d{3}|65[0-4]\\d{2}|655[0-2]\\d|6553[0-5])"
+//    return this.matches(port.toRegex()) && this.toInt() in 1024..65535
+//}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/GeoConverter.kt

@@ -0,0 +1,64 @@
+/*
+ * 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.core.domain.utility
+
+import com.rtbishop.look4sat.core.domain.predict.DEG2RAD
+import com.rtbishop.look4sat.core.domain.predict.RAD2DEG
+import kotlin.math.max
+import kotlin.math.min
+
+private const val MIN_LATITUDE = -85.05112877980658
+private const val MAX_LATITUDE = 85.05112877980658
+private const val MIN_LONGITUDE = -180.0
+private const val MAX_LONGITUDE = 180.0
+
+fun Double.toDegrees(): Double = this * RAD2DEG
+
+fun Double.toRadians(): Double = this * DEG2RAD
+
+//fun Double.latToY01(): Double {
+//    val sinus = sin(clipLat(this) * PI / MAX_LONGITUDE)
+//    return 0.5 - ln((1 + sinus) / (1 - sinus)) / (4 * PI)
+//}
+
+//fun Double.lonToX01(): Double {
+//    return (clipLon(this) - MIN_LONGITUDE) / (MAX_LONGITUDE - MIN_LONGITUDE)
+//}
+
+//fun Double.y01ToLat(): Double {
+//    return 90 - 360 * atan(exp((this - 0.5) * 2 * PI)) / PI
+//}
+
+//fun Double.x01ToLon(): Double {
+//    return MIN_LONGITUDE + (MAX_LONGITUDE - MIN_LONGITUDE) * this
+//}
+
+fun clipLat(latitude: Double): Double {
+    return clip(latitude, MIN_LATITUDE, MAX_LATITUDE)
+}
+
+fun clipLon(longitude: Double): Double {
+    var result = longitude
+    while (result < MIN_LONGITUDE) result += 360.0
+    while (result > MAX_LONGITUDE) result -= 360.0
+    return clip(result, MIN_LONGITUDE, MAX_LONGITUDE)
+}
+
+private fun clip(currentValue: Double, minValue: Double, maxValue: Double): Double {
+    return min(max(currentValue, minValue), maxValue)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/QthConverter.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.core.domain.utility
+
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+
+fun qthToPosition(locator: String): GeoPos? {
+    val trimmedQth = locator.take(6)
+    if (!isValidLocator(trimmedQth)) return null
+    val lonFirst = (trimmedQth[0].uppercaseChar().code - 65) * 20
+    val latFirst = (trimmedQth[1].uppercaseChar().code - 65) * 10
+    val lonSecond = trimmedQth[2].toString().toInt() * 2
+    val latSecond = trimmedQth[3].toString().toInt()
+    val lonThird = (((trimmedQth[4].lowercaseChar().code - 97) / 12.0) + (1.0 / 24.0)) - 180
+    val latThird = (((trimmedQth[5].lowercaseChar().code - 97) / 24.0) + (1.0 / 48.0)) - 90
+    val longitude = (lonFirst + lonSecond + lonThird).round(4)
+    val latitude = (latFirst + latSecond + latThird).round(4)
+    return GeoPos(latitude, longitude)
+}
+
+fun positionToQth(latitude: Double, longitude: Double): String? {
+    if (!isValidPosition(latitude, longitude)) return null
+    val newLongitude = if (longitude > 180.0) longitude else longitude + 180
+    val newLatitude = latitude + 90
+    val lonFirst = (65 + (newLongitude / 20)).toInt().toChar()
+    val latFirst = (65 + (newLatitude / 10)).toInt().toChar()
+    val lonSecond = ((newLongitude / 2) % 10).toInt()
+    val latSecond = (newLatitude % 10).toInt()
+    val lonThird = (65 + (newLongitude % 2) * 12).toInt().toChar().lowercaseChar()
+    val latThird = (65 + (newLatitude % 1) * 24).toInt().toChar().lowercaseChar()
+    return "$lonFirst$latFirst$lonSecond$latSecond$lonThird$latThird"
+}
+
+private fun isValidPosition(lat: Double, lon: Double): Boolean {
+    return (lat >= -90.0 && lat <= 90.0) && (lon >= -180.0 && lon <= 360.0)
+}
+
+private fun isValidLocator(locator: String): Boolean {
+    return locator.matches("[a-xA-X][a-xA-X]\\d\\d[a-xA-X][a-xA-X]".toRegex())
+}

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/DataParserTest.kt

@@ -0,0 +1,105 @@
+/*
+ * 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.core.domain
+
+import com.rtbishop.look4sat.core.domain.utility.DataParser
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+@ExperimentalCoroutinesApi
+class DataParserTest {
+
+    private val testDispatcher = StandardTestDispatcher()
+    private val dataParser = DataParser(testDispatcher)
+    private val validCSVStream = """
+        OBJECT_NAME,OBJECT_ID,EPOCH,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY,EPHEMERIS_TYPE,CLASSIFICATION_TYPE,NORAD_CAT_ID,ELEMENT_SET_NO,REV_AT_EPOCH,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION_DDOT
+        ISS (ZARYA),1998-067A,2021-11-16T12:28:09.322176,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
+        ISS (ZARYA),1998-067A,2024-03-09T05:45:04.737024,15.49756209,.0005741,51.6418,90.7424,343.9724,92.8274,0,U,25544,999,44305,.25016E-3,.1373E-3,0
+    """.trimIndent().byteInputStream()
+    private val invalidCSVStream = """
+        ISS (ZARYA),1998-067A,2021-11-16T12:28:09.322176,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
+        OBJECT_NAME,OBJECT_ID,EPOCH,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY,EPHEMERIS_TYPE,CLASSIFICATION_TYPE,NORAD_CAT_ID,ELEMENT_SET_NO,REV_AT_EPOCH,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION_DDOT
+    """.trimIndent().byteInputStream()
+    private val validTLEStream = """
+        ISS (ZARYA)
+        1 25544U 98067A   21320.51955234  .00001288  00000+0  31985-4 0  9990
+        2 25544  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
+        ISS (ZARYA)
+        1 25544U 98067A   24069.23963816  .00013730  00000+0  25016-3 0  9999
+        2 25544  51.6418  90.7424 0005741 343.9724  92.8274 15.49756209443058
+    """.trimIndent().byteInputStream()
+    private val invalidTLEStream = """
+        1 25544U 98067A   21320.51955234  .00001288  00000+0  31985-4 0  9990
+        2 25544  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
+    """.trimIndent().byteInputStream()
+    private val validJSONStream = """
+        [{"uuid":"UzPz4gcsNBPKPKAFPmer7g","description":"Upper side band (drifting)","alive":true,"type":"Transmitter","uplink_low":null,"uplink_high":null,"uplink_drift":null,"downlink_low":136658500,"downlink_high":null,"downlink_drift":null,"mode":"USB","mode_id":9,"uplink_mode":null,"invert":false,"baud":null,"sat_id":"SCHX-0895-2361-9925-0309","norad_cat_id":965,"status":"active","updated":"2019-04-18T05:39:53.343316Z","citation":"CITATION NEEDED - https://xkcd.com/285/","service":"Unknown","coordination":"","coordination_url":""}]
+    """.trimIndent().byteInputStream()
+    private val invalidJSONStream = """
+        [{"description":"Upper side band (drifting)","alive":true,"type":"Transmitter","uplink_low":null,"uplink_high":null,"uplink_drift":null,"downlink_low":136658500,"downlink_high":null,"downlink_drift":null,"mode":"USB","mode_id":9,"uplink_mode":null,"invert":false,"baud":null,"sat_id":"SCHX-0895-2361-9925-0309","norad_cat_id":965,"status":"active","updated":"2019-04-18T05:39:53.343316Z","citation":"CITATION NEEDED - https://xkcd.com/285/","service":"Unknown","coordination":"","coordination_url":""}]
+    """.trimIndent().byteInputStream()
+
+    @Test
+    fun `Given valid CSV stream returns valid data`() = runTest(testDispatcher) {
+        val parsedList = dataParser.parseCSVStream(validCSVStream)
+        assert(parsedList[0].epoch == 21320.51955234)
+        assert(parsedList[1].epoch == 24069.23963816)
+    }
+
+    @Test
+    fun `Given invalid CSV stream returns empty list`() = runTest(testDispatcher) {
+        assert(dataParser.parseCSVStream(invalidCSVStream).isEmpty())
+    }
+
+    @Test
+    fun `Given valid TLE stream returns valid data`() = runTest(testDispatcher) {
+        val parsedList = dataParser.parseTLEStream(validTLEStream)
+        assert(parsedList[0].epoch == 21320.51955234)
+        assert(parsedList[1].epoch == 24069.23963816)
+    }
+
+    @Test
+    fun `Given invalid TLE stream returns empty list`() = runTest(testDispatcher) {
+        assert(dataParser.parseTLEStream(invalidTLEStream).isEmpty())
+    }
+
+    @Test
+    fun `Given valid JSON stream returns valid data`() = runTest(testDispatcher) {
+        assert(dataParser.parseJSONStream(validJSONStream)[0].downlinkLow == 136658500L)
+    }
+
+    @Test
+    fun `Given invalid JSON stream returns empty list`() = runTest(testDispatcher) {
+        assert(dataParser.parseJSONStream(invalidJSONStream).isEmpty())
+    }
+
+    @Test
+    fun `Given valid data streams parsed results match`() = runTest(testDispatcher) {
+        assert(dataParser.parseCSVStream(validCSVStream) == dataParser.parseTLEStream(validTLEStream))
+    }
+
+    @Test
+    fun `Function isLeapYear returns correct data`() = runTest(testDispatcher) {
+        val years = listOf(1900, 1984, 1994, 2016, 2022, 2024, 2042, 2048)
+        val answers = listOf(false, true, false, true, false, true, false, true)
+        val results = years.map { dataParser.isLeapYear(it) }
+        assert(results == answers)
+    }
+}

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/QthConverterTest.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.core.domain
+
+import com.rtbishop.look4sat.core.domain.utility.positionToQth
+import com.rtbishop.look4sat.core.domain.utility.qthToPosition
+import org.junit.Test
+
+class QthConverterTest {
+
+    @Test
+    fun `Given valid QTH returns correct POS`() {
+        var result = qthToPosition("io91VL39FX")
+        assert(result?.latitude == 51.4792 && result.longitude == -0.2083)
+        result = qthToPosition("gf15vc")
+        assert(result?.latitude == -34.8958 && result.longitude == -56.2083)
+    }
+
+    @Test
+    fun `Given invalid QTH returns null`() {
+        assert(qthToPosition("ZZ00zz") == null)
+        assert(qthToPosition("JN58") == null)
+    }
+
+    @Test
+    fun `Given valid POS returns correct QTH`() {
+        assert(positionToQth(51.4878, -0.2146) == "IO91vl")
+        assert(positionToQth(48.1466, 11.6083) == "JN58td")
+    }
+
+    @Test
+    fun `Given invalid POS returns null`() {
+        assert(positionToQth(91.0542, -170.1142) == null)
+        assert(positionToQth(89.0542, -240.1142) == null)
+    }
+}

core/presentation/.gitignore

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

core/presentation/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    alias(libs.plugins.convention.composeLibraryPlugin)
+}
+
+android {
+    namespace = "com.rtbishop.look4sat.core.presentation"
+}

core/presentation/src/main/AndroidManifest.xml

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

core/presentation/src/main/java/com/rtbishop/look4sat/core/presentation/Components.kt

@@ -0,0 +1,414 @@
+/*
+ * 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.core.presentation
+
+import androidx.compose.foundation.MarqueeSpacing
+import androidx.compose.foundation.basicMarquee
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ElevatedButton
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.window.Dialog
+import com.rtbishop.look4sat.core.domain.predict.NearEarthObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+private val sdfTime = SimpleDateFormat("HH:mm:ss", Locale.ENGLISH)
+
+@Composable
+@Preview(showBackground = true)
+private fun TopBarPreview() = MainTheme {
+    TopBar {
+        IconCard(action = {}, resId = R.drawable.ic_filter)
+        TimerRow(timeString = "88:88:88", isTimeAos = true)
+        IconCard(action = {}, resId = R.drawable.ic_radios)
+    }
+}
+
+@Composable
+fun TopBar(content: @Composable (RowScope.() -> Unit)) {
+    Row(
+        modifier = Modifier.height(48.dp),
+        horizontalArrangement = Arrangement.spacedBy(6.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) { content() }
+}
+
+@Composable
+fun RowScope.TimerRow(timeString: String, isTimeAos: Boolean) {
+    val colorScheme = MaterialTheme.colorScheme
+    val aosColor = if (isTimeAos) colorScheme.primary else colorScheme.onSurface
+    val losColor = if (!isTimeAos) colorScheme.primary else colorScheme.onSurface
+    ElevatedCard(modifier = Modifier.weight(1f)) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.SpaceEvenly,
+            modifier = Modifier.fillMaxSize()
+        ) {
+            Text(text = "AOS", fontSize = 16.sp, fontWeight = FontWeight.Medium, color = aosColor)
+            Text(
+                text = timeString,
+                fontSize = 32.sp,
+                fontWeight = FontWeight.Bold,
+                color = MaterialTheme.colorScheme.primary
+            )
+            Text(text = "LOS", fontSize = 16.sp, fontWeight = FontWeight.Medium, color = losColor)
+        }
+    }
+}
+
+@Composable
+@Preview(showBackground = true)
+private fun NextPassRowPreview() = MainTheme {
+    TopBar { NextPassRow(pass = getDefaultPass()) }
+}
+
+@Composable
+fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
+    ElevatedCard(
+        modifier = modifier
+            .height(48.dp)
+            .weight(1f)
+    ) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy((-2).dp),
+            modifier = Modifier
+                .fillMaxSize()
+//                .background(color = MaterialTheme.colorScheme.background)
+                .padding(start = 6.dp, top = 1.dp, end = 6.dp, bottom = 0.dp)
+        ) {
+            val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    text = "$passSatId - ",
+                    color = MaterialTheme.colorScheme.primary
+                )
+                Text(
+                    text = pass.name,
+                    modifier = Modifier
+                        .weight(1f)
+                        .padding(end = 6.dp)
+                        .infiniteMarquee(),
+                    fontWeight = FontWeight.Medium,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis
+                )
+                Icon(
+                    painter = painterResource(id = R.drawable.ic_elevation),
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.size(16.dp)
+                )
+                Spacer(modifier = Modifier.width(4.dp))
+                Text(
+                    text = "${pass.maxElevation}°",
+                    color = MaterialTheme.colorScheme.primary
+                )
+            }
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.SpaceBetween,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Row(
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.Start,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = sdfTime.format(Date(pass.aosTime)),
+                        fontSize = 15.sp,
+                        modifier = Modifier.weight(1f)
+                    )
+                }
+                Row(
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.Center,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Icon(
+                        painter = painterResource(id = R.drawable.ic_altitude),
+                        contentDescription = null,
+                        modifier = Modifier.size(16.dp)
+                    )
+                    Spacer(modifier = Modifier.width(4.dp))
+                    Text(
+                        text = "${pass.altitude} km",
+                        fontSize = 15.sp
+                    )
+                }
+                Row(
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.End,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = stringResource(
+                            id = R.string.pass_aosLos,
+                            pass.aosAzimuth.toInt(),
+                            pass.losAzimuth.toInt()
+                        ),
+                        fontSize = 15.sp
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier) {
+    ElevatedButton(
+        onClick = { onClick() }, colors = ButtonDefaults.buttonColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant,
+            contentColor = MaterialTheme.colorScheme.onSurfaceVariant
+        ), shape = MaterialTheme.shapes.small, modifier = modifier,
+        contentPadding = PaddingValues(horizontal = 8.dp, vertical = 8.dp)
+    ) { Text(text = text, fontSize = 16.sp, textAlign = TextAlign.Center) }
+}
+
+@Composable
+fun IconCard(action: () -> Unit, resId: Int, modifier: Modifier = Modifier) {
+    val clickableMod = Modifier.clickable { action() }
+    ElevatedCard(modifier = Modifier.size(48.dp)) {
+        Box(modifier = clickableMod.fillMaxSize(), contentAlignment = Alignment.Center) {
+            Icon(painter = painterResource(resId), contentDescription = null, modifier = modifier)
+        }
+    }
+}
+
+@Composable
+fun PrimaryIconCard(modifier: Modifier = Modifier, resId: Int, onClick: () -> Unit) {
+    val clickableMod = modifier.clickable { onClick() }
+    ElevatedCard(
+        modifier = Modifier.size(102.dp, 48.dp),
+        colors = CardDefaults.elevatedCardColors(containerColor = MaterialTheme.colorScheme.primary)
+    ) {
+        Box(modifier = clickableMod.fillMaxSize(), contentAlignment = Alignment.Center) {
+            Icon(painter = painterResource(id = resId), contentDescription = null)
+        }
+    }
+}
+
+@Composable
+fun CardLoadingIndicator() {
+    Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
+        CircularProgressIndicator(modifier = Modifier.size(80.dp))
+    }
+}
+
+@Composable
+fun EmptyListCard(message: String) {
+    Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(24.dp),
+            modifier = Modifier.padding(32.dp)
+        ) {
+            Text(text = """¯\_(ツ)_/¯""", fontSize = 32.sp)
+            Text(text = stringResource(R.string.empty_list_message), fontSize = 21.sp, textAlign = TextAlign.Center)
+            Text(text = message, fontSize = 18.sp, textAlign = TextAlign.Center)
+        }
+    }
+}
+
+fun getDefaultPass(): OrbitalPass {
+    val orbitalData = OrbitalData(
+        """ ¯\_(ツ)_/¯ ⚠️""",
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        0.0
+    )
+    val satellite = NearEarthObject(orbitalData)
+    return OrbitalPass(0L, 0.0, Long.MAX_VALUE, 0.0, 0, 0.0, satellite, 0f)
+}
+
+@Composable
+fun SharedDialog(
+    title: String, onCancel: () -> Unit, onAccept: () -> Unit, content: @Composable () -> Unit
+) {
+    val padding = LocalSpacing.current.large
+    Dialog(onDismissRequest = { onCancel() }) {
+        ElevatedCard {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(padding)
+            ) {
+                Text(
+                    text = title,
+                    fontSize = 16.sp,
+                    fontWeight = FontWeight.Medium,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.padding(start = padding, top = padding, end = padding)
+                )
+                content()
+                Row(modifier = Modifier.padding(start = padding, bottom = padding, end = padding)) {
+                    CardButton(onClick = onCancel, text = stringResource(id = R.string.btn_cancel))
+                    Spacer(modifier = Modifier.weight(1f))
+                    CardButton(onClick = onAccept, text = stringResource(id = R.string.btn_accept))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun InfoDialog(title: String, text: String, onDismiss: () -> Unit) {
+    val padding = LocalSpacing.current.large
+    Dialog(onDismissRequest = {}) {
+        ElevatedCard {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(padding)
+            ) {
+                Text(
+                    text = title,
+                    fontSize = 18.sp,
+                    fontWeight = FontWeight.Medium,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.padding(start = padding, top = padding, end = padding)
+                )
+                Text(
+                    text = text,
+                    fontSize = 16.sp,
+                    color = MaterialTheme.colorScheme.onSurface,
+                    modifier = Modifier.padding(horizontal = padding)
+                )
+                Row(modifier = Modifier.padding(start = padding, bottom = padding, end = padding)) {
+                    Spacer(modifier = Modifier.weight(1f))
+                    CardButton(
+                        onClick = onDismiss,
+                        text = stringResource(id = R.string.btn_accept)
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun hasEnoughHeight(): Boolean {
+    return currentWindowAdaptiveInfo().windowSizeClass.isHeightAtLeastBreakpoint(480)
+}
+
+@Composable
+fun hasEnoughWidth(): Boolean {
+    return currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600)
+}
+
+@Composable
+fun isVerticalLayout(): Boolean {
+    return currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600).not()
+}
+
+@Composable
+fun Modifier.infiniteMarquee(): Modifier {
+    return basicMarquee(iterations = Int.MAX_VALUE, spacing = MarqueeSpacing(16.dp))
+}
+
+@Composable
+fun Modifier.layoutPadding(): Modifier {
+    val statusBarMod = this.statusBarsPadding()
+    val spacing = LocalSpacing.current.extraSmall
+    return statusBarMod.padding(start = spacing, top = 0.dp, end = spacing, bottom = spacing)
+}
+
+@Composable
+fun ScreenColumn(
+    topBar: @Composable (Boolean) -> Unit = {},
+    floatingBar: @Composable () -> Unit = {},
+    content: @Composable (Boolean) -> Unit = {}
+) {
+    val isVerticalLayout = isVerticalLayout()
+    Surface(color = MaterialTheme.colorScheme.background) {
+        Box(modifier = Modifier.layoutPadding(), contentAlignment = Alignment.BottomCenter) {
+            Column(verticalArrangement = Arrangement.spacedBy(LocalSpacing.current.extraSmall)) {
+                topBar(isVerticalLayout)
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.surfaceContainer
+                ) { content(isVerticalLayout) }
+            }
+            floatingBar()
+        }
+    }
+}
+
+@Composable
+fun TopBar(
+    isVerticalLayout: Boolean,
+    startAction: @Composable () -> Unit,
+    topInfo: @Composable (RowScope.() -> Unit),
+    bottomInfo: @Composable (RowScope.() -> Unit),
+    endAction: @Composable () -> Unit
+) {
+    val topBarRow = @Composable { content: @Composable RowScope.() -> Unit ->
+        Row(
+            modifier = Modifier.height(48.dp),
+            horizontalArrangement = Arrangement.spacedBy(6.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) { content() }
+    }
+    if (isVerticalLayout) {
+        topBarRow { startAction().also { topInfo() }.also { endAction() } }
+        topBarRow { bottomInfo() }
+    } else {
+        topBarRow { startAction().also { topInfo() }.also { bottomInfo() }.also { endAction() } }
+    }
+}

core/presentation/src/main/java/com/rtbishop/look4sat/core/presentation/MainTheme.kt

@@ -0,0 +1,161 @@
+/*
+ * 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.core.presentation
+
+import android.os.Build
+import androidx.activity.ComponentActivity
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Shapes
+import androidx.compose.material3.Typography
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.core.view.WindowCompat
+
+val LocalSpacing = compositionLocalOf { Spacing }
+
+data object Spacing {
+    val extraExtraSmall = 4.dp
+    val extraSmall = 6.dp
+    val small = 8.dp
+    val medium = 12.dp
+    val large = 16.dp
+    val extraLarge = 24.dp
+}
+
+@Composable
+fun MainTheme(isDarkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
+    val view = LocalView.current
+    if (view.isInEditMode) {
+        MaterialTheme(darkScheme, shapes, typography, content)
+    } else {
+        CompositionLocalProvider(LocalSpacing provides Spacing) {
+            val colorScheme = if (isDarkTheme) darkScheme else lightScheme
+            SideEffect {
+                val window = (view.context as ComponentActivity).window
+                val insetsController = WindowCompat.getInsetsController(window, view)
+                insetsController.isAppearanceLightStatusBars = false
+                insetsController.isAppearanceLightNavigationBars = false
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    window.isNavigationBarContrastEnforced = false
+                }
+            }
+            MaterialTheme(colorScheme, shapes, typography, content)
+        }
+    }
+}
+
+private val lightScheme = lightColorScheme(
+    primary = Color(0xFF715C0C),
+    onPrimary = Color(0xFFFFFFFF),
+    secondary = Color(0xFF685E40),
+    onSecondary = Color(0xFFFFFFFF),
+    secondaryContainer = Color(0xFFF1E1BB),
+    onSecondaryContainer = Color(0xFF221B04),
+    background = Color(0xFFFFF8F0),
+    onBackground = Color(0xFF1E1B13),
+    surface = Color(0xFFFFF8F0),
+    onSurface = Color(0xFF1E1B13),
+    surfaceTint = Color(0x00000000),
+    surfaceVariant = Color(0xFFEBE2CF),
+    onSurfaceVariant = Color(0xFF4C4639),
+    error = Color(0xFFDC0000),
+    outline = Color(0xFF7D7667),
+    scrim = Color(0xFF000000)
+)
+
+private val darkScheme = darkColorScheme(
+    primary = Color(0xFFFFE082), // main accent, switch background, active progress
+    onPrimary = Color(0xFF000000), // on main accent, switch knob
+//    primaryContainer = Color(0xFF121212),
+//    onPrimaryContainer = Color(0xFF121212),
+//    inversePrimary = Color(0xFF121212),
+    secondary = Color(0xFFE0E0E0),
+    onSecondary = Color(0xFF000000),
+    secondaryContainer = Color(0xFF404040), // navBar indicator,
+    onSecondaryContainer = Color(0xFFE0E0E0), // navBar active icon
+//    tertiary = Color(0xFF121212),
+//    onTertiary = Color(0xFF121212),
+//    tertiaryContainer = Color(0xFF121212),
+//    onTertiaryContainer = Color(0xFF121212),
+    background = Color(0xFF121212),
+    onBackground = Color(0xFFE0E0E0),
+    surface = Color(0xFF202020), // card background
+    onSurface = Color(0xFFE0E0E0), // on card background
+    surfaceVariant = Color(0xFF404040), // buttons background
+    onSurfaceVariant = Color(0xFFE0E0E0), // navBar inactive icon
+    surfaceTint = Color(0x00000000),
+//    inverseSurface = Color(0xFF121212),
+//    inverseOnSurface = Color(0xFF121212),
+    error = Color(0xFFDC0000),
+//    onError = Color(0xFFFFFFFF),
+//    errorContainer = Color(0xFF121212),
+//    onErrorContainer = Color(0xFF121212),
+    outline = Color(0xA3E0E0E0),
+//    outlineVariant = Color(0xFF121212),
+    scrim = Color(0xFF000000),
+//    surfaceBright = Color(0xFF121212),
+    surfaceContainer = Color(0xFF121212), // navBar background
+//    surfaceContainerHigh = Color(0xFF121212),
+    surfaceContainerHighest = Color(0xFF242424), // filled card background
+    surfaceContainerLow = Color(0xFF202020), // elevated card background
+    surfaceContainerLowest = Color(0xCC121212),
+//    surfaceDim = Color(0xFF121212),
+)
+
+private val shapes = Shapes(
+    extraSmall = RoundedCornerShape(4.dp), // menus, snackbars, text fields
+    small = RoundedCornerShape(8.dp), // buttons, chips
+    medium = RoundedCornerShape(12.dp), // cards, small FABs
+    large = RoundedCornerShape(24.dp), // extended FABs, FABs, nav drawers
+    extraLarge = RoundedCornerShape(32.dp) // large FABs
+)
+
+private val typography = Typography(
+    bodyLarge = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Normal,
+        fontSize = 16.sp,
+        lineHeight = 24.sp,
+        letterSpacing = 0.5.sp
+    ), titleLarge = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Normal,
+        fontSize = 22.sp,
+        lineHeight = 28.sp,
+        letterSpacing = 0.sp
+    ), labelSmall = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Medium,
+        fontSize = 11.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.5.sp
+    )
+)

core/presentation/src/main/java/com/rtbishop/look4sat/core/presentation/Navigation.kt

@@ -0,0 +1,9 @@
+package com.rtbishop.look4sat.core.presentation
+
+sealed class Screen(val route: String, val iconResId: Int, val titleResId: Int) {
+    data object Satellites : Screen("satellites", R.drawable.ic_satellites, R.string.nav_sat)
+    data object Passes : Screen("passes", R.drawable.ic_passes, R.string.nav_pass)
+    data object Radar : Screen("radar", R.drawable.ic_radar, R.string.nav_radar)
+    data object Map : Screen("map", R.drawable.ic_map, R.string.nav_map)
+    data object Settings : Screen("settings", R.drawable.ic_settings, R.string.nav_prefs)
+}