v4.4.3 - Added required tweaks to support Android 17 (API 37)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/copilot-instructions.md

@@ -0,0 +1,5 @@
+# GitHub Copilot Instructions
+
+Read `AGENTS.md` first, then `CLAUDE.md`.
+
+`AGENTS.md` contains the architecture, module boundaries, implementation details, conventions, and gotchas.

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/release.yml

@@ -16,59 +16,64 @@ jobs:
       contents: write
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Setup Java
         uses: actions/setup-java@v5
         with:
           distribution: 'temurin'
-          java-version: '17'
+          java-version: '21'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v5
+        uses: gradle/actions/setup-gradle@v6
 
       - name: Assemble Artifacts
-        run: |
-          ./gradlew assembleRelease
-          ./gradlew bundleRelease
+        run: ./gradlew assembleRelease bundleRelease
 
       - name: Sign APK
-        uses: r0adkll/sign-android-release@v1
-        id: sign_apk
-        with:
-          releaseDirectory: app/build/outputs/apk/release
-          signingKeyBase64: ${{ secrets.KEY_STORE }}
-          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
-          alias: ${{ secrets.KEY_ALIAS }}
-          keyPassword: ${{ secrets.KEY_PASSWORD }}
-        env:
-          BUILD_TOOLS_VERSION: "36.0.0"
+        run: |
+          echo "${{ secrets.KEY_STORE }}" | base64 -d > keystore.jks
+          APK=$(find app/build/outputs/apk/release -name "*.apk" | head -1)
+          BUILD_TOOLS=$(ls -d ${ANDROID_HOME}/build-tools/*/ | sort -V | tail -1)
+          ${BUILD_TOOLS}apksigner sign \
+            --ks keystore.jks \
+            --ks-pass pass:${{ secrets.KEY_STORE_PASSWORD }} \
+            --ks-key-alias ${{ secrets.KEY_ALIAS }} \
+            --key-pass pass:${{ secrets.KEY_PASSWORD }} \
+            --out app/build/outputs/apk/release/look4sat.apk \
+            "$APK"
+          rm keystore.jks
 
       - name: Sign Bundle
-        uses: r0adkll/sign-android-release@v1
-        id: sign_bundle
-        with:
-          releaseDirectory: app/build/outputs/bundle/release
-          signingKeyBase64: ${{ secrets.KEY_STORE }}
-          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
-          alias: ${{ secrets.KEY_ALIAS }}
-          keyPassword: ${{ secrets.KEY_PASSWORD }}
-        env:
-          BUILD_TOOLS_VERSION: "36.0.0"
-
-      - name: Rename Artifacts
         run: |
-          mv ${{steps.sign_apk.outputs.signedReleaseFile}} app/build/outputs/apk/release/look4sat.apk
-          mv ${{steps.sign_bundle.outputs.signedReleaseFile}} app/build/outputs/apk/release/look4sat.aab
+          echo "${{ secrets.KEY_STORE }}" | base64 -d > keystore.jks
+          AAB=$(find app/build/outputs/bundle/release -name "*.aab" | head -1)
+          jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256 \
+            -keystore keystore.jks \
+            -storepass ${{ secrets.KEY_STORE_PASSWORD }} \
+            -keypass ${{ secrets.KEY_PASSWORD }} \
+            "$AAB" ${{ secrets.KEY_ALIAS }}
+          rm keystore.jks
 
-      - name: Deploy Bundle
-        uses: r0adkll/upload-google-play@v1
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
         with:
-          serviceAccountJsonPlainText: ${{secrets.SERVICE_ACCOUNT_JSON}}
-          packageName: com.rtbishop.look4sat
-          releaseFiles: app/build/outputs/apk/release/look4sat.aab
-          track: production
-          whatsNewDirectory: fastlane/metadata/android/en-US/whatsnew
+          ruby-version: '3.4'
+
+      - name: Deploy Bundle to Google Play
+        run: |
+          gem install multi_json
+          gem install fastlane --no-document
+          AAB=$(find app/build/outputs/bundle/release -name "*.aab" | head -1)
+          echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+          fastlane supply \
+            --aab "$AAB" \
+            --json_key service_account.json \
+            --package_name com.rtbishop.look4sat \
+            --track production \
+            --skip_upload_images true \
+            --skip_upload_screenshots true \
+          rm service_account.json
 
       - name: Create Release
         run: |

AGENTS.md

@@ -0,0 +1,122 @@
+# Look4Sat AI Agent Instructions
+
+This is the canonical project guide for all AI assistants working on Look4Sat.
+All assistant-specific files (`CLAUDE.md`, `.github/copilot-instructions.md`) point here.
+
+---
+
+## Project Overview
+
+Look4Sat is an open-source, fully offline Android satellite tracker and pass predictor. It tracks 9000+ active
+satellites using TLE/OMM data from Celestrak/SatNOGS, calculates orbital positions via SGP4/SDP4 models, and displays
+passes relative to the user's location. Features include polar radar visualization, SSTV image decoding, satellite
+ground track mapping, and pass predictions up to 10 days ahead. No ads, no tracking, no network required after initial
+data download.
+
+## Architecture
+
+**MVI (Model-View-Intent)** with unidirectional data flow:
+- `State` data class → exposed via `StateFlow` from ViewModel
+- `Action` sealed interface → user intents dispatched to ViewModel's `onAction()`
+- Jetpack Compose UI observes state and recomposes reactively
+
+**Clean Architecture layers:**
+
+| Module               | Responsibility                                                      |
+|----------------------|---------------------------------------------------------------------|
+| `app`                | Entry point. Aggregates all modules                                 |
+| `core:data`          | Android library. Room DB, OkHttp networking, repo implementations   |
+| `core:domain`        | Pure Kotlin (JVM). Orbital math (SGP4/SDP4), models, repo contracts |
+| `core:presentation`  | Android library. Compose theme, shared UI components, NavKeys       |
+| `feature:map`        | OSMDroid map with ground tracks                                     |
+| `feature:passes`     | Pass predictions and upcoming events                                |
+| `feature:radar`      | Polar radar view of satellite positions, SSTV image decoding        |
+| `feature:satellites` | Satellite list, filtering, selection                                |
+| `feature:settings`   | User preferences                                                    |
+
+- `feature:*` modules depend only on `core:domain` + `core:presentation`. Features never depend on each other.
+
+## Build & Run
+
+```shell
+# Debug build
+./gradlew assembleDebug
+
+# Release build (minified, shrunk resources)
+./gradlew assembleRelease
+
+# Run tests
+./gradlew test
+```
+
+- **Min SDK**: 24 | **Target SDK**: 36 | **JDK**: 17
+- **Gradle**: Uses version catalog (`gradle/libs.versions.toml`) + convention plugins in `build-logic/`
+
+## Key Libraries
+
+- **Compose** (BOM 2026.05.01) + Material3 Adaptive
+- **Navigation3** (type-safe, uses `@Serializable` NavKeys)
+- **Room** (KSP code generation) for local satellite/TLE storage
+- **OkHttp** 5.x for TLE downloads
+- **OSMDroid** for map rendering
+- **Kotlin Serialization** for navigation args and data parsing
+- **Coroutines** + `StateFlow` for async/reactive patterns
+
+## Conventions
+
+- **Minimal dependencies**: Avoid adding libraries when a simple manual solution exists. Fewer deps = less maintenance.
+- **DI**: Manual — ViewModels use companion `factory()` methods with `IMainContainer` interface.
+- **Navigation**: Type-safe Compose Navigation3 with `@Serializable` data classes as nav keys.
+- **State naming**: `<Feature>State` data class + `<Feature>Action` sealed interface per feature.
+- **No feature-to-feature deps**: All cross-feature communication goes through core layers.
+- **Localization**: 7 languages (en, es, ru, si, tr, uk, zh).
+
+## Data Formats & Migration
+
+**TLE vs. OMM/CSV format:**
+
+Look4Sat supports both TLE and OMM (Orbit Mean-Elements Message) formats for backward compatibility:
+
+- **TLE format**: Traditional 3-line element format (deprecated). NORAD catalog numbers are 5-digit integers, which
+  are running out of space. Celestrak has signaled that TLE format will eventually be phased out.
+- **OMM/CSV format**: The future standard. CSV files contain the same orbital parameters as TLE but use ISO 8601
+  timestamps and support larger NORAD IDs. Celestrak and SatNOGS already provide OMM data in CSV format.
+
+**Current implementation:**
+- `DataParser.kt` handles both `parseTLEStream()` and `parseCSVStream()` seamlessly
+- TLE data is downloaded from configured sources and stored in Room database
+- When downloading satellite data, the app automatically detects format and parses accordingly
+- Both formats produce identical `OrbitalData` objects, ensuring transparent format switching
+
+**Migration path:**
+As NORAD catalog space becomes constrained, OMM/CSV will become the primary format. Look4Sat is already positioned
+to handle this transition without code changes — existing users can continue using TLE files while new sources
+transition to OMM/CSV automatically.
+
+## Code Style
+
+- Prefer **short, focused functions** — single responsibility, easy to read.
+- **Exceptions**: Composable functions and math-heavy algorithms (SGP4/SDP4) may be longer.
+- Strict code style — no dead code, no unused imports, consistent formatting.
+
+## Roadmap
+
+- **KMP migration**: `core:domain` is to become a fully shareable KMM module. Keep it pure Kotlin/JVM.
+
+## Gotchas
+
+- Orbital math lives in `core:domain/predict/` — it's dense vector math (SGP4/SDP4). Tread carefully.
+- TLE/OMM data must be refreshed weekly for accurate predictions (satellite orbits decay). TLE format is legacy and
+  will eventually be deprecated in favor of OMM/CSV as NORAD catalog numbers approach the 5-digit limit.
+- SSTV decoding in `feature:radar` is experimental; image quality depends on signal strength during satellite pass.
+- `build-logic/convention/` contains all shared Gradle configuration — edit there, not in individual modules.
+- ProGuard is enabled for release builds — don't add reflection-based libs or any other dependencies without asking.
+
+## Copilot Working Mode: Code-Only
+
+- Default to code changes only. Provide explanations in chat only.
+- If documentation seems useful, ask first before creating files.
+- Do NOT create any `.md` documentation files unless explicitly requested.
+- Do NOT add README, guides, summaries, migration notes, or how-to files unless asked.
+- Prefer minimal diffs focused on requested implementation.
+- Default validation is static checks (`get_errors`). Do NOT run Gradle compile/test tasks unless explicitly requested.

CLAUDE.md

@@ -0,0 +1,5 @@
+# CLAUDE.md
+
+Read `AGENTS.md` first, then follow the instructions there.
+
+`AGENTS.md` contains the architecture, module boundaries, implementation details, conventions, and gotchas.

README.md

@@ -33,3 +33,13 @@ It is now and always will be completely ad-free and open-source.
 *  Showing the satellite positional data, footprint and ground track on the map
 *  Custom TLE satellite data import is available via Three Line Element .txt files
 *  Offline first: calculations are made offline. Weekly TLE data update is recommended.
+
+## Star History
+
+<a href="https://www.star-history.com/?repos=rt-bishop%2FLook4Sat&type=timeline&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=rt-bishop/Look4Sat&type=timeline&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=rt-bishop/Look4Sat&type=timeline&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=rt-bishop/Look4Sat&type=timeline&legend=top-left" />
+ </picture>
+</a>

app/build.gradle.kts

@@ -1,3 +1,3 @@
 plugins {
-    alias(libs.plugins.convention.androidAppPlugin)
+    alias(libs.plugins.convention.applicationPlugin)
 }

app/src/main/AndroidManifest.xml

@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission
@@ -11,9 +12,11 @@
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
     <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
 
     <application
         android:name=".MainApplication"
+        android:allowBackup="false"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round">
@@ -26,6 +29,14 @@
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+<!--            <intent-filter android:autoVerify="true">-->
+<!--                <action android:name="android.intent.action.VIEW" />-->
+<!--                <category android:name="android.intent.category.DEFAULT" />-->
+<!--                <category android:name="android.intent.category.BROWSABLE" />-->
+<!--                <data android:scheme="https" />-->
+<!--                <data android:host="github.com" />-->
+<!--                <data android:pathPattern="/rt-bishop/Look4Sat/passes.*" />-->
+<!--            </intent-filter>-->
         </activity>
 
         <meta-data

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

@@ -19,12 +19,21 @@ package com.rtbishop.look4sat
 
 import android.content.Context
 import android.content.res.Configuration
+import android.graphics.ColorMatrix
+import android.graphics.ColorMatrixColorFilter
+import android.graphics.Paint
 import android.os.Bundle
+import android.view.View
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
+import androidx.lifecycle.lifecycleScope
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.presentation.MainTheme
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
 
 class MainActivity : ComponentActivity() {
 
@@ -38,8 +47,37 @@ class MainActivity : ComponentActivity() {
         installSplashScreen()
         enableEdgeToEdge()
         super.onCreate(savedInstanceState)
+        observeNightFilterState()
         setContent {
             MainTheme(isDarkTheme = true) { MainScreen() }
         }
     }
+
+    private fun observeNightFilterState() {
+        val mainContainer = (applicationContext as IContainerProvider).getMainContainer()
+        lifecycleScope.launch {
+            mainContainer.settingsRepo.otherSettings
+                .map { it.stateOfNightMode }
+                .distinctUntilChanged()
+                .collect { nightMode -> applyNightFilter(nightMode) }
+        }
+    }
+
+    private fun applyNightFilter(enabled: Boolean) {
+        if (enabled) {
+            val nightMatrix = ColorMatrix(
+                floatArrayOf(
+                    1f, 0f, 0f, 0f, 0f,   // R → R
+                    0f, 0f, 0f, 0f, 0f,   // G → 0
+                    0f, 0f, 0f, 0f, 0f,   // B → 0
+                    0f, 0f, 0f, 1f, 0f    // A → A
+                )
+            )
+            window.decorView.setLayerType(View.LAYER_TYPE_HARDWARE, Paint().apply {
+                colorFilter = ColorMatrixColorFilter(nightMatrix)
+            })
+        } else {
+            window.decorView.setLayerType(View.LAYER_TYPE_NONE, null)
+        }
+    }
 }

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

@@ -17,74 +17,232 @@
  */
 package com.rtbishop.look4sat
 
+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.animation.fadeIn
 import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+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.shape.CircleShape
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
 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.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
 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 androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.runtime.rememberNavBackStack
+import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.ui.NavDisplay
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.presentation.DeeplinkResolver
+import com.rtbishop.look4sat.core.presentation.RadarDestination
 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
+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
+fun NavRoot(deeplink: String? = null) {
+    val rootBackStack = rememberNavBackStack(Screen.Passes)
+    val deeplinkResolver = DeeplinkResolver()
+    LaunchedEffect(deeplink) {
+        deeplink?.let {
+            val destination = deeplinkResolver.resolve(it) // rootBackStack.clear()
+            rootBackStack.add(destination)
+        }
+    }
+    val navigateBack: () -> Unit = { rootBackStack.removeLastOrNull() }
+    val slideInTransition = slideInHorizontally(initialOffsetX = { it }) togetherWith scaleOut(targetScale = 0.9f)
+    val slideOutTransition = scaleIn(initialScale = 0.9f) togetherWith slideOutHorizontally(targetOffsetX = { it })
+    NavDisplay(
+        modifier = Modifier.fillMaxSize(),
+        backStack = rootBackStack,
+        onBack = navigateBack,
+        transitionSpec = { slideInTransition },
+        popTransitionSpec = { slideOutTransition },
+        predictivePopTransitionSpec = { slideOutTransition },
+        entryDecorators = listOf(
+            rememberSaveableStateHolderNavEntryDecorator(), // Required for saving Compose state per entry
+            rememberViewModelStoreNavEntryDecorator() // Required for ViewModel scoping per entry
+        ),
+        entryProvider = entryProvider {
+            entry<Screen.Passes> { MainScreen(navigateToRadar = { rootBackStack.add(RadarDestination) }) }
+            entry<RadarDestination> {
+                Scaffold { innerPadding ->
+                    RadarDestination(navigateUp = navigateBack)
+                    innerPadding.calculateTopPadding()
+                }
+            }
+        }
+    )
+}
+
+@Composable
+fun MainScreen(navigateToRadar: () -> Unit = {}) {
+    val backStack = rememberNavBackStack(Screen.Passes)
+    val currentKey = backStack.lastOrNull()
+    val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
+    val fadeTransition = fadeIn(animationSpec = tween(350)) togetherWith fadeOut(animationSpec = tween(350))
+    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Map, Screen.Settings)
+
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val trackingState by container.radioTrackingService.state.collectAsStateWithLifecycle()
+
     NavigationSuiteScaffold(
         navigationSuiteItems = {
-            items.forEach {
+            navItems.forEach { screen ->
+                val isSelected = when (currentKey) {
+                    is Screen.Satellites -> screen is Screen.Satellites
+                    is Screen.Passes -> screen is Screen.Passes
+                    is Screen.Radar -> screen is Screen.Radar
+                    is Screen.Map -> screen is Screen.Map
+                    is Screen.Settings -> screen is Screen.Settings
+                    else -> false
+                }
                 item(
-                    icon = { Icon(painterResource(it.iconResId), stringResource(it.titleResId)) },
-                    label = { Text(stringResource(it.titleResId)) },
-                    selected = currentDestination?.contains(it.route) ?: false,
+                    icon = { Icon(painterResource(screen.iconResId), stringResource(screen.titleResId)) },
+                    label = { Text(stringResource(screen.titleResId)) },
+                    selected = isSelected,
                     onClick = {
-                        if (currentDestination?.contains(it.route) ?: false) return@item
-                        navController.navigate(it.route) {
-                            popUpTo(startDestination) { saveState = false }
-                            launchSingleTop = true
-                            restoreState = false
-                        }
-                    })
+                        if (isSelected) return@item
+                        while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+                        if (screen !is Screen.Passes) backStack.add(screen)
+                    }
+                )
             }
-        }, navigationSuiteColors = NavigationSuiteDefaults.colors(
+        },
+        navigationSuiteColors = NavigationSuiteDefaults.colors(
             navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
-        ), layoutType = when {
+        ),
+        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)
+        Column {
+            NavDisplay(
+                backStack = backStack,
+                modifier = Modifier.weight(1f),
+                onBack = navigateBack,
+                transitionSpec = { fadeTransition },
+                popTransitionSpec = { fadeTransition },
+                predictivePopTransitionSpec = { fadeTransition },
+                entryDecorators = listOf(
+                    // Required for saving Compose state per entry
+                    rememberSaveableStateHolderNavEntryDecorator(),
+                    // Required for ViewModel scoping per entry
+                    rememberViewModelStoreNavEntryDecorator()
+                ),
+                entryProvider = entryProvider {
+                    entry<Screen.Satellites> {
+                        SatellitesDestination(navigateUp = navigateBack)
+                    }
+                    entry<Screen.Passes> {
+                        PassesDestination { catNum, aosTime ->
+                            container.satelliteRepo.selectPass(catNum, aosTime)
+                            backStack.add(Screen.Radar)
+//                            navigateToRadar()
+                        }
+                    }
+                    entry<Screen.Radar> {
+                        RadarDestination(navigateUp = navigateBack)
+                    }
+                    entry<Screen.Map> {
+                        MapDestination()
+                    }
+                    entry<Screen.Settings> {
+                        SettingsDestination()
+                    }
+                }
+            )
+            // Radio tracking status banner
+            if (trackingState.isActive) {
+                val infiniteTransition = rememberInfiniteTransition(label = "trackingPulse")
+                val alpha by infiniteTransition.animateFloat(
+                    initialValue = 1f, targetValue = 0.4f,
+                    animationSpec = infiniteRepeatable(
+                        animation = tween(1000, easing = LinearEasing),
+                        repeatMode = RepeatMode.Reverse
+                    ), label = "pulseAlpha"
+                )
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .background(MaterialTheme.colorScheme.primaryContainer)
+                        .clickable {
+                            val pass = trackingState.currentPass
+                            if (pass != null) {
+                                container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
+                                backStack.add(Screen.Radar)
+                            }
+                        }
+                        .padding(horizontal = 12.dp, vertical = 6.dp)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(8.dp)
+                            .clip(CircleShape)
+                            .background(Color(0xFF4CAF50).copy(alpha = alpha))
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(
+                        text = "Tracking: ${trackingState.currentPass?.name ?: ""}",
+                        fontSize = 13.sp,
+                        fontWeight = FontWeight.Medium,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer,
+                        modifier = Modifier.weight(1f)
+                    )
+                    val txOk = if (trackingState.txConnected) "TX" else ""
+                    val rxOk = if (trackingState.rxConnected) "RX" else ""
+                    Text(
+                        text = listOf(txOk, rxOk).filter { it.isNotBlank() }.joinToString("/"),
+                        fontSize = 12.sp,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer
+                    )
+                }
             }
-            radarDestination { navController.navigateUp() }
-            mapDestination()
-            settingsDestination()
         }
     }
 }

build-logic/convention/build.gradle.kts

@@ -24,25 +24,25 @@ 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("applicationPlugin") {
+            id = libs.plugins.convention.applicationPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.ApplicationPlugin"
         }
-        register("androidLibraryPlugin") {
-            id = libs.plugins.convention.androidLibraryPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.AndroidLibraryPlugin"
+        register("coreDataPlugin") {
+            id = libs.plugins.convention.coreDataPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.CoreDataPlugin"
         }
-        register("composeFeaturePlugin") {
-            id = libs.plugins.convention.composeFeaturePlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.ComposeFeaturePlugin"
+        register("coreDomainPlugin") {
+            id = libs.plugins.convention.coreDomainPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.CoreDomainPlugin"
         }
-        register("composeLibraryPlugin") {
-            id = libs.plugins.convention.composeLibraryPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.ComposeLibraryPlugin"
+        register("corePresentationPlugin") {
+            id = libs.plugins.convention.corePresentationPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.CorePresentationPlugin"
         }
-        register("kotlinLibraryPlugin") {
-            id = libs.plugins.convention.kotlinLibraryPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.KotlinLibraryPlugin"
+        register("featurePlugin") {
+            id = libs.plugins.convention.featurePlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.FeaturePlugin"
         }
     }
 }

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

@@ -22,25 +22,24 @@ 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)
-            }
+internal class ApplicationPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        setupAndroidApp()
+        setupCompose()
+        setupKotlin()
+        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)
+            implementation(libs.compose.material3.adaptive)
+            implementation(libs.compose.navigation3)
+            androidTestImplementation(libs.bundles.androidTest)
         }
     }
 }

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

@@ -22,25 +22,19 @@ 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)
-            }
+internal class CoreDataPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        applyPlugin(libs.plugins.google.ksp)
+        setupAndroidLib()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:domain"))
+            implementation(libs.androidx.core.ktx)
+            implementation(libs.androidx.room)
+            implementation(libs.androidx.room.runtime)
+            ksp(libs.androidx.room.compiler)
+            implementation(libs.kotlin.coroutines)
+            implementation(libs.other.okhttp)
         }
     }
 }

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

@@ -22,18 +22,14 @@ 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)
-            }
+internal class CoreDomainPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        applyPlugin(libs.plugins.kotlin.jvm)
+        applyPlugin(libs.plugins.kotlin.serialization)
+        setupKotlin()
+        dependencies {
+            implementation(libs.kotlin.coroutines)
+            implementation(libs.kotlin.serialization)
         }
     }
 }

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

@@ -22,18 +22,17 @@ 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)
-            }
+internal class CorePresentationPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        applyPlugin(libs.plugins.kotlin.serialization)
+        setupAndroidLib()
+        setupCompose()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:domain"))
+            implementation(libs.androidx.core.splashscreen)
+            implementation(libs.kotlin.serialization)
+            implementation(libs.compose.material3.adaptive)
         }
     }
 }

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

@@ -22,18 +22,14 @@ 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"))
-            }
+internal class FeaturePlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        setupAndroidLib()
+        setupCompose()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:domain"))
+            implementation(project(":core:presentation"))
         }
     }
 }

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

@@ -21,7 +21,7 @@ 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.artifacts.dsl.DependencyHandler
 import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.accessors.runtime.extensionOf
 import org.gradle.kotlin.dsl.configure
@@ -29,23 +29,30 @@ 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.applyPlugin(notation: Provider<PluginDependency>) {
+    pluginManager.apply(notation.get().pluginId)
 }
 
-internal fun Project.setupAndroidApplication() {
-    with(pluginManager) {
-        alias(libs.plugins.android.application)
-    }
+internal fun DependencyHandler.implementation(dependencyNotation: Any) =
+    add("implementation", dependencyNotation)
+
+internal fun DependencyHandler.debugImplementation(dependencyNotation: Any) =
+    add("debugImplementation", dependencyNotation)
+
+internal fun DependencyHandler.testImplementation(dependencyNotation: Any) =
+    add("testImplementation", dependencyNotation)
+
+internal fun DependencyHandler.androidTestImplementation(dependencyNotation: Any) =
+    add("androidTestImplementation", dependencyNotation)
+
+internal fun DependencyHandler.ksp(dependencyNotation: Any) =
+    add("ksp", dependencyNotation)
+
+internal fun Project.setupAndroidApp() {
+    applyPlugin(libs.plugins.android.application)
     extensions.configure<ApplicationExtension> {
         namespace = libs.versions.packageName.get()
         compileSdk = libs.versions.compileSdk.get().toInt()
@@ -55,9 +62,6 @@ internal fun Project.setupAndroidApplication() {
             versionCode = libs.versions.appVersionCode.get().toInt()
             versionName = libs.versions.appVersionName.get()
         }
-        buildFeatures {
-            compose = true
-        }
         buildTypes {
             debug {
                 applicationIdSuffix = ".debug"
@@ -70,49 +74,38 @@ internal fun Project.setupAndroidApplication() {
         }
         androidResources {
             generateLocaleConfig = true
-            localeFilters.addAll(listOf("en", "es", "ru", "si", "uk", "zh"))
+            localeFilters.addAll(listOf("en", "es", "ru", "si", "tr", "uk", "zh"))
         }
         packaging { resources { excludes += listOf("META-INF/*") } }
     }
 }
 
-internal fun Project.setupCommonLibrary() {
-    with(pluginManager) {
-        alias(libs.plugins.android.library)
-    }
+internal fun Project.setupAndroidLib() {
+    applyPlugin(libs.plugins.android.library)
     extensions.configure<CommonExtension> {
         compileSdk = libs.versions.compileSdk.get().toInt()
         defaultConfig.minSdk = libs.versions.minSdk.get().toInt()
     }
+    dependencies {
+        androidTestImplementation(libs.bundles.androidTest)
+    }
 }
 
-internal fun Project.setupComposeFeature() {
-    with(pluginManager) {
-        alias(libs.plugins.compose.compiler)
-    }
+internal fun Project.setupCompose() {
+    applyPlugin(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)
+        implementation(platform(libs.compose.bom))
+        implementation(libs.bundles.composeAll)
+        debugImplementation(libs.bundles.composeDebug)
     }
 }
 
-internal fun Project.setupKotlinToolchain() {
+internal fun Project.setupKotlin() {
     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)
+        testImplementation(libs.bundles.unitTest)
     }
 }

build.gradle.kts

@@ -4,8 +4,10 @@ plugins {
     alias(libs.plugins.compose.compiler) apply false
     alias(libs.plugins.google.ksp) apply false
     alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.serialization) apply false
 }
 
 tasks.register("clean", Delete::class.java) {
+    description = "Cleans the build directory"
     delete(rootProject.layout.buildDirectory)
 }

core/data/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    alias(libs.plugins.convention.androidLibraryPlugin)
+    alias(libs.plugins.convention.coreDataPlugin)
 }
 
 android {

core/data/src/main/AndroidManifest.xml

@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission
@@ -11,5 +12,6 @@
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
     <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
 
 </manifest>

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

@@ -25,11 +25,11 @@ data class SatRadio(
     @PrimaryKey val uuid: String,
     val info: String,
     val isAlive: Boolean,
-    var downlinkLow: Long?,
-    var downlinkHigh: Long?,
+    val downlinkLow: Long?,
+    val downlinkHigh: Long?,
     val downlinkMode: String?,
-    var uplinkLow: Long?,
-    var uplinkHigh: Long?,
+    val uplinkLow: Long?,
+    val uplinkHigh: Long?,
     val uplinkMode: String?,
     val isInverted: Boolean,
     val catnum: Int?

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

@@ -20,121 +20,112 @@ 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 com.rtbishop.look4sat.core.domain.repository.IReporter
 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 reporterScope: CoroutineScope,
+    private val rotatorDeviceId: String,
+    private val frequencyDeviceId: String
+) : IReporter {
 
     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 sppId: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
     private val writeMutex = Mutex()
 
-    override fun isConnected(service: BtService): Boolean {
-        val deviceId = serviceToDevice[service] ?: return false
-        return deviceConnections[deviceId]?.connected == true
-    }
+    private var rotatorSocket: BluetoothSocket? = null
+    private var rotatorStream: OutputStream? = null
+    private var rotatorConnected = false
+    private var rotatorConnecting = false
 
-    override fun isConnecting(service: BtService): Boolean {
-        val deviceId = serviceToDevice[service] ?: return false
-        return deviceConnections[deviceId]?.connecting == true
-    }
+    private var frequencySocket: BluetoothSocket? = null
+    private var frequencyStream: OutputStream? = null
+    private var frequencyConnected = false
+    private var frequencyConnecting = false
 
-    override fun connect(service: BtService, deviceId: String) {
-        serviceToDevice[service] = deviceId
-        val connection = deviceConnections.getOrPut(deviceId) {
-            DeviceConnection()
+    override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
+        reporterScope.launch {
+            ensureRotatorConnected()
+            if (!rotatorConnected) return@launch
+            val el = if (elevation > 0.0) elevation else 0.0
+            val command = format
+                .replace($$"$AZ", azimuth.toString())
+                .replace($$"$EL", el.toString())
+                .unescapeControlChars()
+            write(rotatorStream, command) { rotatorConnected = false }
         }
-        if (connection.connected || connection.connecting) return
-        connection.connectionJob = reporterScope.launch {
+    }
+
+    override fun reportFrequency(format: String, frequency: Long) {
+        reporterScope.launch {
+            ensureFrequencyConnected()
+            if (!frequencyConnected) return@launch
+            val command = format
+                .replace($$"$FREQ", frequency.toString())
+                .unescapeControlChars()
+            write(frequencyStream, command) { frequencyConnected = false }
+        }
+    }
+
+    private fun ensureRotatorConnected() {
+        if (rotatorConnected || rotatorConnecting || rotatorDeviceId.isBlank()) return
+        reporterScope.launch {
             try {
-                connection.connecting = true
-                val device = bluetoothManager.adapter.getRemoteDevice(deviceId)
-                val socket = device.createInsecureRfcommSocketToServiceRecord(sppid)
+                rotatorConnecting = true
+                val device = bluetoothManager.adapter.getRemoteDevice(rotatorDeviceId)
+                val socket = device.createInsecureRfcommSocketToServiceRecord(sppId)
                 socket.connect()
-                connection.socket = socket
-                connection.outputStream = socket.outputStream
-                connection.connected = true
-                Log.i(tag, "$tag: Connected to $deviceId")
+                rotatorSocket = socket
+                rotatorStream = socket.outputStream
+                rotatorConnected = true
+                Log.i(tag, "Rotator connected to $rotatorDeviceId")
             } catch (e: Exception) {
-                Log.e(tag, "$tag: ${e.message}")
-                connection.connected = false
+                Log.e(tag, "Rotator connect error: ${e.message}")
+                rotatorConnected = false
             } finally {
-                connection.connecting = false
+                rotatorConnecting = false
             }
         }
     }
 
-    private suspend fun write(service: BtService, buffer: String) {
-        val deviceId = serviceToDevice[service] ?: return
-        val connection = deviceConnections[deviceId] ?: return
-        if (!connection.connected) return
+    private fun ensureFrequencyConnected() {
+        if (frequencyConnected || frequencyConnecting || frequencyDeviceId.isBlank()) return
+        reporterScope.launch {
+            try {
+                frequencyConnecting = true
+                val device = bluetoothManager.adapter.getRemoteDevice(frequencyDeviceId)
+                val socket = device.createInsecureRfcommSocketToServiceRecord(sppId)
+                socket.connect()
+                frequencySocket = socket
+                frequencyStream = socket.outputStream
+                frequencyConnected = true
+                Log.i(tag, "Frequency connected to $frequencyDeviceId")
+            } catch (e: Exception) {
+                Log.e(tag, "Frequency connect error: ${e.message}")
+                frequencyConnected = false
+            } finally {
+                frequencyConnecting = false
+            }
+        }
+    }
+
+    private suspend fun write(stream: OutputStream?, data: String, onError: () -> Unit) {
         try {
             writeMutex.withLock {
-                connection.outputStream?.write(buffer.toByteArray())
+                stream?.write(data.toByteArray())
             }
         } catch (e: Exception) {
-            Log.e(tag, "$tag: Write failed ${e.message}")
-            connection.connected = false
+            Log.e(tag, "Write error: ${e.message}")
+            onError()
         }
     }
 
-    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"
-        }
-    }
+    private fun String.unescapeControlChars(): String =
+        replace("\\r", "\r").replace("\\n", "\n").replace("\\t", "\t")
 }

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

@@ -0,0 +1,139 @@
+/*
+ * 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 java.util.Locale
+import kotlin.math.roundToLong
+
+object Ft817CatProtocol {
+
+    const val CMD_SET_FREQ: Byte = 0x01
+    const val CMD_READ_FREQ_MODE: Byte = 0x03
+    const val CMD_SET_MODE: Byte = 0x07
+    const val CMD_PTT_ON: Byte = 0x08
+    const val CMD_PTT_OFF: Byte = 0x88.toByte()
+    const val CMD_CTCSS_MODE: Byte = 0x0A
+    const val CMD_CTCSS_TONE: Byte = 0x0B
+
+    const val CTCSS_ENC_ON: Byte = 0x2A
+    const val CTCSS_OFF: Byte = 0x8A.toByte()
+
+    val MODE_TO_BYTE: Map<String, Byte> = mapOf(
+        "LSB" to 0x00,
+        "USB" to 0x01,
+        "CW" to 0x02,
+        "CW-R" to 0x03,
+        "AM" to 0x04,
+        "FM" to 0x08,
+        "DIG" to 0x0A,
+        "PKT" to 0x0C
+    )
+
+    val BYTE_TO_MODE: Map<Byte, String> = MODE_TO_BYTE.entries.associate { it.value to it.key }
+
+    /**
+     * Encode frequency in Hz to 4-byte BCD with 10 Hz resolution.
+     * Example: 145500000 Hz → [0x14, 0x55, 0x00, 0x00]
+     */
+    fun encodeFrequencyBcd(frequencyHz: Long): ByteArray {
+        val freq10Hz = frequencyHz / 10
+        val bcd = ByteArray(4)
+        val digits = String.format(Locale.US, "%08d", freq10Hz)
+        for (i in 0 until 4) {
+            val high = digits[i * 2] - '0'
+            val low = digits[i * 2 + 1] - '0'
+            bcd[i] = ((high shl 4) or low).toByte()
+        }
+        return bcd
+    }
+
+    /**
+     * Decode 4-byte BCD frequency to Hz.
+     */
+    fun decodeFrequencyBcd(bcd: ByteArray): Long {
+        var freq10Hz = 0L
+        for (i in 0 until 4) {
+            val b = bcd[i].toInt() and 0xFF
+            val high = b shr 4
+            val low = b and 0x0F
+            freq10Hz = freq10Hz * 100 + high * 10 + low
+        }
+        return freq10Hz * 10
+    }
+
+    /**
+     * Encode CTCSS tone frequency (in Hz, e.g. 67.0) to 2-byte BCD.
+     * 67.0 Hz → 670 (in 0.1 Hz) → BCD [0x06, 0x70]
+     */
+    fun encodeCtcssToneBcd(toneHz: Double): ByteArray {
+        val tone01Hz = (toneHz * 10).roundToLong()
+        val digits = String.format(Locale.US, "%04d", tone01Hz)
+        val bcd = ByteArray(2)
+        for (i in 0 until 2) {
+            val high = digits[i * 2] - '0'
+            val low = digits[i * 2 + 1] - '0'
+            bcd[i] = ((high shl 4) or low).toByte()
+        }
+        return bcd
+    }
+
+    fun buildSetFreqCommand(frequencyHz: Long): ByteArray {
+        val bcd = encodeFrequencyBcd(frequencyHz)
+        return byteArrayOf(bcd[0], bcd[1], bcd[2], bcd[3], CMD_SET_FREQ)
+    }
+
+    fun buildSetModeCommand(mode: String): ByteArray? {
+        val modeByte = MODE_TO_BYTE[mode.uppercase(Locale.US)] ?: return null
+        return byteArrayOf(modeByte, 0x00, 0x00, 0x00, CMD_SET_MODE)
+    }
+
+    fun buildReadFreqModeCommand(): ByteArray {
+        return byteArrayOf(0x00, 0x00, 0x00, 0x00, CMD_READ_FREQ_MODE)
+    }
+
+    fun buildPttOnCommand(): ByteArray {
+        return byteArrayOf(0x00, 0x00, 0x00, 0x00, CMD_PTT_ON)
+    }
+
+    fun buildPttOffCommand(): ByteArray {
+        return byteArrayOf(0x00, 0x00, 0x00, 0x00, CMD_PTT_OFF)
+    }
+
+    fun buildCtcssModeCommand(enabled: Boolean): ByteArray {
+        val sub = if (enabled) CTCSS_ENC_ON else CTCSS_OFF
+        return byteArrayOf(sub, 0x00, 0x00, 0x00, CMD_CTCSS_MODE)
+    }
+
+    fun buildSetCtcssToneCommand(toneHz: Double): ByteArray {
+        val bcd = encodeCtcssToneBcd(toneHz)
+        return byteArrayOf(bcd[0], bcd[1], 0x00, 0x00, CMD_CTCSS_TONE)
+    }
+
+    /**
+     * Parse the 5-byte response from a READ FREQ+MODE command.
+     * Returns (frequencyHz, modeString) or null if parsing fails.
+     */
+    fun parseReadResponse(response: ByteArray): Pair<Long, String>? {
+        if (response.size < 5) return null
+        val freqBcd = response.copyOfRange(0, 4)
+        val frequencyHz = decodeFrequencyBcd(freqBcd)
+        val modeByte = response[4]
+        val mode = BYTE_TO_MODE[modeByte] ?: return null
+        return Pair(frequencyHz, mode)
+    }
+}

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

@@ -0,0 +1,207 @@
+/*
+ * 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.IRadioController
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.UUID
+import kotlin.time.Duration.Companion.milliseconds
+
+class Ft817Controller(
+    private val bluetoothManager: BluetoothManager,
+    private val deviceAddress: String
+) : IRadioController {
+
+    private val tag = "FT817"
+    private val sppId: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
+    private val ioMutex = Mutex()
+    private val commandDelayMs = 200L
+    private val maxAckReadFailures = 3
+
+    private var socket: BluetoothSocket? = null
+    private var outputStream: OutputStream? = null
+    private var inputStream: InputStream? = null
+    private var ackReadFailureCount = 0
+
+    override var isConnected: Boolean = false
+        private set
+
+    override suspend fun connect(): Boolean = withContext(Dispatchers.IO) {
+        if (isConnected) return@withContext true
+        if (deviceAddress.isBlank()) return@withContext false
+        try {
+            val device = bluetoothManager.adapter.getRemoteDevice(deviceAddress)
+            val btSocket = device.createInsecureRfcommSocketToServiceRecord(sppId)
+            btSocket.connect()
+            socket = btSocket
+            outputStream = btSocket.outputStream
+            inputStream = btSocket.inputStream
+            ackReadFailureCount = 0
+            isConnected = true
+            Log.i(tag, "Connected to $deviceAddress")
+            true
+        } catch (e: Exception) {
+            Log.e(tag, "Connect error: ${e.message}")
+            isConnected = false
+            false
+        }
+    }
+
+    override suspend fun disconnect() {
+        withContext(Dispatchers.IO) {
+            try {
+                inputStream?.close()
+                outputStream?.close()
+                socket?.close()
+            } catch (e: Exception) {
+                Log.e(tag, "Disconnect error: ${e.message}")
+            } finally {
+                inputStream = null
+                outputStream = null
+                socket = null
+                ackReadFailureCount = 0
+                isConnected = false
+                Log.i(tag, "Disconnected from $deviceAddress")
+            }
+        }
+    }
+
+    override suspend fun setFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            sendCommandWithAck(Ft817CatProtocol.buildSetFreqCommand(frequencyHz))
+        }
+    }
+
+    override suspend fun setMode(mode: String): Boolean = withContext(Dispatchers.IO) {
+        val cmd = Ft817CatProtocol.buildSetModeCommand(mode) ?: return@withContext false
+        ioMutex.withLock { sendCommandWithAck(cmd) }
+    }
+
+    override suspend fun setCtcssMode(enabled: Boolean): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            sendCommandWithAck(Ft817CatProtocol.buildCtcssModeCommand(enabled))
+        }
+    }
+
+    override suspend fun setCtcssTone(toneHz: Double): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            sendCommandWithAck(Ft817CatProtocol.buildSetCtcssToneCommand(toneHz))
+        }
+    }
+
+    override suspend fun readFrequencyAndMode(): Pair<Long, String>? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val sent = sendCommand(Ft817CatProtocol.buildReadFreqModeCommand())
+            if (!sent) return@withContext null
+            delay(commandDelayMs.milliseconds)
+            val response = readResponse() ?: return@withContext null
+            Ft817CatProtocol.parseReadResponse(response)
+        }
+    }
+
+    override suspend fun pttOn(): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock { sendCommandWithAck(Ft817CatProtocol.buildPttOnCommand()) }
+    }
+
+    override suspend fun pttOff(): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock { sendCommandWithAck(Ft817CatProtocol.buildPttOffCommand()) }
+    }
+
+    private suspend fun sendCommand(bytes: ByteArray): Boolean {
+        return withContext(Dispatchers.IO) {
+            try {
+                outputStream?.write(bytes) ?: return@withContext false
+                outputStream?.flush()
+                delay(commandDelayMs.milliseconds)
+                true
+            } catch (e: Exception) {
+                Log.e(tag, "Send error: ${e.message}")
+                isConnected = false
+                false
+            }
+        }
+    }
+
+    /** Send command and read the 1-byte ACK response (0x00 = OK). */
+    private suspend fun sendCommandWithAck(bytes: ByteArray): Boolean {
+        if (!sendCommand(bytes)) return false
+        return withContext(Dispatchers.IO) {
+            try {
+                val ack = inputStream?.read() ?: run {
+                    ackReadFailureCount = 0
+                    isConnected = false
+                    return@withContext false
+                }
+                if (ack < 0) {
+                    ackReadFailureCount = 0
+                    Log.i(tag, "ACK stream closed by remote device")
+                    isConnected = false
+                    return@withContext false
+                }
+                ackReadFailureCount = 0
+                ack == 0x00
+            } catch (e: Exception) {
+                ackReadFailureCount += 1
+                Log.w(tag, "ACK read error (${ackReadFailureCount}/$maxAckReadFailures): ${e.message}")
+                if (ackReadFailureCount >= maxAckReadFailures) {
+                    Log.e(tag, "Too many ACK read errors, marking radio disconnected")
+                    isConnected = false
+                    false
+                } else {
+                    true // Command was sent, treat transient ACK read failures as best-effort
+                }
+            }
+        }
+    }
+
+    private suspend fun readResponse(): ByteArray? {
+        return withContext(Dispatchers.IO) {
+            try {
+                val responseSize = 5
+                val buffer = ByteArray(responseSize)
+                var read = 0
+                while (read < responseSize) {
+                    val count = inputStream?.read(buffer, read, responseSize - read) ?: run {
+                        isConnected = false
+                        return@withContext null
+                    }
+                    if (count < 0) {
+                        Log.i(tag, "Response stream closed by remote device")
+                        isConnected = false
+                        return@withContext null
+                    }
+                    read += count
+                }
+                buffer
+            } catch (e: Exception) {
+                Log.e(tag, "Read error: ${e.message}")
+                isConnected = false
+                null
+            }
+        }
+    }
+}

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

@@ -17,11 +17,8 @@
  */
 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 com.rtbishop.look4sat.core.domain.repository.IReporter
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -29,89 +26,94 @@ import java.net.InetSocketAddress
 import java.nio.ByteBuffer
 import java.nio.channels.SocketChannel
 
-enum class NetworkService { ROTATOR, FREQUENCY }
+class NetworkReporter(
+    private val reporterScope: CoroutineScope,
+    private val rotatorServer: String,
+    private val rotatorPort: Int,
+    private val frequencyServer: String,
+    private val frequencyPort: Int
+) : IReporter {
 
-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 var rotatorSocket: SocketChannel? = null
+    private var rotatorConnected = false
+    private var rotatorConnecting = false
+
+    private var frequencySocket: SocketChannel? = null
+    private var frequencyConnected = false
+    private var frequencyConnecting = false
+
+    override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
+        reporterScope.launch {
+            ensureRotatorConnected()
+            if (!rotatorConnected) return@launch
+            val el = if (elevation > 0.0) elevation else 0.0
+            val command = format
+                .replace($$"$AZ", azimuth.toString())
+                .replace($$"$EL", el.toString())
+                .unescapeControlChars()
+            write(rotatorSocket, command) { rotatorConnected = false }
+        }
     }
 
-    private fun getOrCreateConnection(addr: String): SocketConnection {
-        return connections.getOrPut(addr) { SocketConnection() }
+    override fun reportFrequency(format: String, frequency: Long) {
+        reporterScope.launch {
+            ensureFrequencyConnected()
+            if (!frequencyConnected) return@launch
+            val command = format
+                .replace($$"$FREQ", frequency.toString())
+                .unescapeControlChars()
+            write(frequencySocket, command) { frequencyConnected = false }
+        }
     }
 
-    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 {
+    private fun ensureRotatorConnected() {
+        if (rotatorConnected || rotatorConnecting || rotatorServer.isBlank()) return
+        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")
+                rotatorConnecting = true
+                rotatorSocket = SocketChannel.open(InetSocketAddress(rotatorServer, rotatorPort))
+                rotatorConnected = true
+                println("NetworkReporter: Rotator connected to $rotatorServer:$rotatorPort")
             } catch (e: Exception) {
-                println("NetworkReporter connect error: ${e.message}")
-                connection.connected = false
+                println("NetworkReporter rotator connect error: ${e.message}")
+                rotatorConnected = false
             } finally {
-                connection.connecting = false
+                rotatorConnecting = false
             }
         }
     }
 
-    private suspend fun write(service: NetworkService, command: String) {
-        val addr = serviceToAddress[service] ?: return
-        val connection = connections[addr] ?: return
-        if (!connection.connected) return
+    private fun ensureFrequencyConnected() {
+        if (frequencyConnected || frequencyConnecting || frequencyServer.isBlank()) return
+        reporterScope.launch {
+            try {
+                frequencyConnecting = true
+                frequencySocket = SocketChannel.open(InetSocketAddress(frequencyServer, frequencyPort))
+                frequencyConnected = true
+                println("NetworkReporter: Frequency connected to $frequencyServer:$frequencyPort")
+            } catch (e: Exception) {
+                println("NetworkReporter frequency connect error: ${e.message}")
+                frequencyConnected = false
+            } finally {
+                frequencyConnecting = false
+            }
+        }
+    }
+
+    private suspend fun write(socket: SocketChannel?, command: String, onError: () -> Unit) {
         try {
             writeMutex.withLock {
-                val buffer = ByteBuffer.wrap("\\$command\n".toByteArray())
-                connection.socket?.write(buffer)
+                val buffer = ByteBuffer.wrap("$command\n".toByteArray())
+                socket?.write(buffer)
             }
         } catch (e: Exception) {
             println("NetworkReporter write error: ${e.message}")
-            connection.connected = false
+            onError()
         }
     }
 
-    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)
-        }
-    }
+    private fun String.unescapeControlChars(): String =
+        replace("\\r", "\r").replace("\\n", "\n").replace("\\t", "\t")
 }

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

@@ -0,0 +1,357 @@
+/*
+ * 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.util.Log
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.repository.IRadioController
+import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.RadioTrackingState
+import com.rtbishop.look4sat.core.domain.utility.TransponderMapper
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+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 RadioTrackingService(
+    private val appScope: CoroutineScope,
+    private val bluetoothManager: BluetoothManager,
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo
+) : IRadioTrackingService {
+
+    private val tag = "RadioTracking"
+    private val _state = MutableStateFlow(RadioTrackingState())
+    override val state: StateFlow<RadioTrackingState> = _state
+
+    private var txController: IRadioController? = null
+    private var rxController: IRadioController? = null
+    private var trackingJob: Job? = null
+
+    override suspend fun connectRadios() {
+        // Disconnect old controllers if any
+        txController?.disconnect()
+        rxController?.disconnect()
+
+        // Read current addresses from settings
+        val rcSettings = settingsRepo.radioControlSettings.value
+        val txAddr = rcSettings.txRadioAddress
+        val rxAddr = rcSettings.rxRadioAddress
+
+        Log.i(tag, "Connecting TX=$txAddr RX=$rxAddr")
+
+        if (txAddr.isBlank() && rxAddr.isBlank()) {
+            _state.update { it.copy(errorMessage = "No radio addresses configured in Settings") }
+            return
+        }
+
+        val tx = Ft817Controller(bluetoothManager, txAddr)
+        val rx = Ft817Controller(bluetoothManager, rxAddr)
+        txController = tx
+        rxController = rx
+
+        _state.update { it.copy(errorMessage = null) }
+        val txOk = if (txAddr.isNotBlank()) tx.connect() else false
+        val rxOk = if (rxAddr.isNotBlank()) rx.connect() else false
+        _state.update {
+            it.copy(
+                txConnected = txOk,
+                rxConnected = rxOk,
+                errorMessage = when {
+                    !txOk && !rxOk -> "Could not connect to TX and RX radios"
+                    !txOk -> "Could not connect to TX radio ($txAddr)"
+                    !rxOk -> "Could not connect to RX radio ($rxAddr)"
+                    else -> null
+                }
+            )
+        }
+    }
+
+    override suspend fun disconnectRadios() {
+        stopTracking()
+        txController?.disconnect()
+        rxController?.disconnect()
+        txController = null
+        rxController = null
+        _state.update {
+            it.copy(
+                txConnected = false,
+                rxConnected = false,
+                isActive = false
+            )
+        }
+    }
+
+    override fun startTracking(pass: OrbitalPass, transponder: SatRadio, txBaseFreqHz: Long?) {
+        _state.update {
+            it.copy(
+                isActive = true,
+                currentPass = pass,
+                selectedTransponder = transponder,
+                txBaseFrequencyHz = txBaseFreqHz
+            )
+        }
+        trackingJob?.cancel()
+        trackingJob = appScope.launch {
+            // Set modes on both radios at tracking start
+            val tx = txController
+            val rx = rxController
+            val txMode = transponder.uplinkMode
+            val rxMode = transponder.downlinkMode
+                ?: transponder.uplinkMode?.let {
+                    TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+                }
+            if (tx != null && tx.isConnected && txMode != null) {
+                tx.setMode(txMode)
+                Log.i(tag, "TX mode set to $txMode")
+            }
+            if (rx != null && rx.isConnected && rxMode != null) {
+                rx.setMode(rxMode)
+                Log.i(tag, "RX mode set to $rxMode")
+            }
+            // Set CTCSS if FM
+            if (txMode?.uppercase() == "FM") {
+                _state.value.ctcssTone?.let { tone ->
+                    tx?.setCtcssTone(tone)
+                    tx?.setCtcssMode(true)
+                }
+            }
+            _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
+
+            var lastSetTxFreq = 0.0
+            var lastSetRxFreq = 0.0
+            var tuningRadio = "" // "", "tx", or "rx" - which radio the user is tuning
+            var lastReadFreq = 0L
+            var stableCount = 0
+
+            while (isActive) {
+                val currentState = _state.value
+                if (!currentState.isActive) break
+
+                val satPass = currentState.currentPass ?: break
+                val xpdr = currentState.selectedTransponder ?: break
+                var txBaseFreq = currentState.txBaseFrequencyHz
+                val stationPos = settingsRepo.stationPosition.value
+                val timeNow = System.currentTimeMillis()
+
+                val pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, timeNow)
+                val tx = txController
+                val rx = rxController
+                val hasUplink = txBaseFreq != null
+                val c = com.rtbishop.look4sat.core.domain.predict.SPEED_OF_LIGHT
+                val v = pos.distanceRate * 1000.0
+
+                if (tuningRadio.isNotEmpty()) {
+                    // --- User is tuning: keep reading, wait for stabilization ---
+                    val radio = if (tuningRadio == "tx") tx else rx
+                    if (radio != null && radio.isConnected) {
+                        val readResult = radio.readFrequencyAndMode()
+                        if (readResult != null) {
+                            val (freq, _) = readResult
+                            if (kotlin.math.abs(freq - lastReadFreq) <= 20) {
+                                stableCount++
+                            } else {
+                                stableCount = 0
+                                lastReadFreq = freq
+                            }
+                            // Stable for 2 reads → user stopped turning
+                            if (stableCount >= 2) {
+                                if (tuningRadio == "tx" && txBaseFreq != null) {
+                                    val newBase = (freq.toDouble() * c / (c + v)).toLong()
+                                    if (newBase > 0) {
+                                        txBaseFreq = newBase
+                                        _state.update { it.copy(txBaseFrequencyHz = newBase) }
+                                        Log.i(tag, "TX tuning done → base=$newBase")
+                                    }
+                                } else if (tuningRadio == "rx") {
+                                    val rxNominal = (freq.toDouble() * c / (c - v)).toLong()
+                                    val newTxBase = TransponderMapper.mapDownlinkToUplink(rxNominal, xpdr)
+                                    if (newTxBase != null && newTxBase > 0) {
+                                        txBaseFreq = newTxBase
+                                        _state.update { it.copy(txBaseFrequencyHz = newTxBase) }
+                                        Log.i(tag, "RX tuning done → txBase=$newTxBase")
+                                    }
+                                }
+                                tuningRadio = ""
+                                stableCount = 0
+                                lastSetTxFreq = 0.0
+                                lastSetRxFreq = 0.0
+                            }
+                        }
+                    }
+                } else {
+                    // --- Normal tracking: read, detect changes, command ---
+
+                    // TX dial feedback
+                    if (hasUplink && tx != null && tx.isConnected && lastSetTxFreq > 0.0) {
+                        val readResult = tx.readFrequencyAndMode()
+                        if (readResult != null) {
+                            val (actualTxFreq, _) = readResult
+                            if (kotlin.math.abs(actualTxFreq - lastSetTxFreq) >= 20.0) {
+                                tuningRadio = "tx"
+                                lastReadFreq = actualTxFreq
+                                stableCount = 0
+                                Log.i(tag, "TX tuning detected (read=$actualTxFreq, lastSet=$lastSetTxFreq)")
+                            }
+                        }
+                    }
+
+                    // RX dial feedback (only if TX not tuning)
+                    if (tuningRadio.isEmpty() && rx != null && rx.isConnected && lastSetRxFreq > 0.0) {
+                        val readResult = rx.readFrequencyAndMode()
+                        if (readResult != null) {
+                            val (actualRxFreq, _) = readResult
+                            if (kotlin.math.abs(actualRxFreq - lastSetRxFreq) >= 20.0) {
+                                tuningRadio = "rx"
+                                lastReadFreq = actualRxFreq
+                                stableCount = 0
+                                Log.i(tag, "RX tuning detected (read=$actualRxFreq, lastSet=$lastSetRxFreq)")
+                            }
+                        }
+                    }
+                }
+
+                // Compute Doppler-corrected frequencies
+                val txRadioFreq = txBaseFreq?.let { pos.getUplinkFreq(it) }
+                val rxBaseFreq = if (txBaseFreq != null) {
+                    TransponderMapper.mapUplinkToDownlink(txBaseFreq, xpdr)
+                } else {
+                    xpdr.downlinkLow
+                }
+                val rxRadioFreq = rxBaseFreq?.let { pos.getDownlinkFreq(it) }
+
+                // Command radios (only when not tuning)
+                if (tuningRadio.isEmpty()) {
+                    if (tx != null && tx.isConnected && txRadioFreq != null) {
+                        tx.setFrequency(txRadioFreq)
+                        lastSetTxFreq = txRadioFreq.toDouble()
+                    }
+                    if (rx != null && rx.isConnected && rxRadioFreq != null) {
+                        rx.setFrequency(rxRadioFreq)
+                        lastSetRxFreq = rxRadioFreq.toDouble()
+                    }
+                }
+
+                _state.update {
+                    it.copy(
+                        txConnected = tx?.isConnected ?: false,
+                        rxConnected = rx?.isConnected ?: false,
+                        txFrequencyHz = txRadioFreq,
+                        rxFrequencyHz = rxRadioFreq,
+                        azimuth = Math.toDegrees(pos.azimuth),
+                        elevation = Math.toDegrees(pos.elevation),
+                        distance = pos.distance
+                    )
+                }
+
+                delay(1000)
+            }
+        }
+    }
+
+    override fun stopTracking() {
+        trackingJob?.cancel()
+        trackingJob = null
+        _state.update { it.copy(isActive = false) }
+    }
+
+    override fun setTransponder(transponder: SatRadio) {
+        appScope.launch {
+            val tx = txController
+            val rx = rxController
+            transponder.uplinkMode?.let { tx?.setMode(it) }
+            val rxMode = transponder.downlinkMode
+                ?: transponder.uplinkMode?.let {
+                    TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+                }
+            rxMode?.let { rx?.setMode(it) }
+
+            if (transponder.uplinkMode?.uppercase() == "FM") {
+                _state.value.ctcssTone?.let { tone ->
+                    tx?.setCtcssTone(tone)
+                    tx?.setCtcssMode(true)
+                }
+            }
+        }
+        val txCenter = when {
+            transponder.uplinkLow != null && transponder.uplinkHigh != null ->
+                (transponder.uplinkLow!! + transponder.uplinkHigh!!) / 2
+            transponder.uplinkLow != null -> transponder.uplinkLow!!
+            else -> null
+        }
+        // Show nominal frequencies immediately
+        val rxNominal = if (txCenter != null) {
+            TransponderMapper.mapUplinkToDownlink(txCenter, transponder)
+        } else {
+            // Downlink-only transponder (beacon etc.) - use downlink directly
+            transponder.downlinkLow
+        }
+        _state.update {
+            it.copy(
+                selectedTransponder = transponder,
+                txBaseFrequencyHz = txCenter,
+                txFrequencyHz = txCenter,
+                rxFrequencyHz = rxNominal,
+                txMode = transponder.uplinkMode,
+                rxMode = transponder.downlinkMode
+                    ?: transponder.uplinkMode?.let { m ->
+                        TransponderMapper.mapUplinkModeToDownlinkMode(m, transponder.isInverted)
+                    }
+            )
+        }
+    }
+
+    override fun setTxBaseFrequency(frequencyHz: Long) {
+        _state.update { it.copy(txBaseFrequencyHz = frequencyHz) }
+    }
+
+    override fun adjustTxBaseFrequency(deltaHz: Long) {
+        val current = _state.value.txBaseFrequencyHz ?: return
+        _state.update { it.copy(txBaseFrequencyHz = current + deltaHz) }
+    }
+
+    override fun setCtcssTone(toneHz: Double?) {
+        _state.update { it.copy(ctcssTone = toneHz) }
+        appScope.launch {
+            val tx = txController
+            if (toneHz != null) {
+                tx?.setCtcssTone(toneHz)
+                tx?.setCtcssMode(true)
+            } else {
+                tx?.setCtcssMode(false)
+            }
+        }
+    }
+
+    override fun setMode(txMode: String, rxMode: String) {
+        appScope.launch {
+            txController?.setMode(txMode)
+            rxController?.setMode(rxMode)
+        }
+        _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
+    }
+
+}

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

@@ -1,15 +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.data.injection
 
 import android.bluetooth.BluetoothManager
 import android.content.Context
-import android.hardware.Sensor
 import android.hardware.SensorManager
+import android.hardware.display.DisplayManager
 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.Ft817Controller
 import com.rtbishop.look4sat.core.data.framework.NetworkReporter
+import com.rtbishop.look4sat.core.data.framework.RadioTrackingService
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
 import com.rtbishop.look4sat.core.data.repository.SatelliteRepo
 import com.rtbishop.look4sat.core.data.repository.SelectionRepo
@@ -18,19 +36,23 @@ 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.AudioCapture
+import com.rtbishop.look4sat.core.data.usecase.SaveImage
 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.IRadioController
+import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
+import com.rtbishop.look4sat.core.domain.repository.IReporter
 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.IAudioCapture
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
 import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import com.rtbishop.look4sat.core.domain.utility.DataParser
 import kotlinx.coroutines.CoroutineExceptionHandler
@@ -48,25 +70,57 @@ class MainContainer(private val context: Context) : IMainContainer {
     override val selectionRepo = provideSelectionRepo()
     override val satelliteRepo = provideSatelliteRepo()
     override val databaseRepo = provideDatabaseRepo()
+    override val radioTrackingService: IRadioTrackingService by lazy {
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        RadioTrackingService(appScope, manager, satelliteRepo, settingsRepo)
+    }
 
     override fun provideAddToCalendar(): IAddToCalendar = AddToCalendar(context)
 
     override fun provideShowToast(): IShowToast = ShowToast(context)
 
-    override fun provideBluetoothReporter(): IReporterRepo<WithoutExtParams> {
+    override fun provideAudioCapture(): IAudioCapture = AudioCapture()
+
+    override fun provideSaveImage(): ISaveImage = SaveImage(context)
+
+    override fun provideBluetoothReporter(): IReporter {
         val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-        return BluetoothReporter(manager, CoroutineScope(Dispatchers.IO))
+        val rc = settingsRepo.rcSettings.value
+        return BluetoothReporter(
+            manager,
+            CoroutineScope(Dispatchers.IO),
+            rc.bluetoothRotatorAddress,
+            rc.bluetoothFrequencyAddress
+        )
     }
 
-    override fun provideNetworkReporter(): IReporterRepo<ExtendedParams> {
-        return NetworkReporter(CoroutineScope(Dispatchers.IO))
+    override fun provideNetworkReporter(): IReporter {
+        val rc = settingsRepo.rcSettings.value
+        return NetworkReporter(
+            CoroutineScope(Dispatchers.IO),
+            rc.rotatorAddress,
+            rc.rotatorPort.toIntOrNull() ?: 0,
+            rc.frequencyAddress,
+            rc.frequencyPort.toIntOrNull() ?: 0
+        )
+    }
+
+    override fun provideTxRadioController(): IRadioController {
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val address = settingsRepo.radioControlSettings.value.txRadioAddress
+        return Ft817Controller(manager, address)
+    }
+
+    override fun provideRxRadioController(): IRadioController {
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val address = settingsRepo.radioControlSettings.value.rxRadioAddress
+        return Ft817Controller(manager, address)
     }
 
     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)
+        val displayManager = context.getSystemService(DisplayManager::class.java)
+        return SensorsRepo(manager, displayManager)
     }
 
     private fun provideDatabaseRepo(): IDatabaseRepo {

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

@@ -18,7 +18,6 @@
 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
@@ -28,7 +27,9 @@ 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.awaitAll
 import kotlinx.coroutines.withContext
+import java.io.InputStream
 import java.util.zip.ZipInputStream
 
 class DatabaseRepo(
@@ -39,78 +40,49 @@ class DatabaseRepo(
     private val settingsRepo: ISettingsRepo
 ) : IDatabaseRepo {
 
+    private val customSourceType = "Other"
+
     override suspend fun updateTLEFromFile(uri: String) = withContext(dispatcher) {
-        val importedSatellites = remoteSource.getFileStream(uri)?.let { dataParser.parseTLEStream(it) }
-        importedSatellites?.let { localSource.insertEntries(it) }
+        remoteSource.getFileStream(uri)?.let { stream ->
+            val entries = dataParser.parseTLEStream(unwrapIfZipped(uri, stream))
+            localSource.insertEntries(entries)
+            settingsRepo.setSatelliteTypeIds(customSourceType, entries.map { it.catnum })
+        }
         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)
-            }
+        remoteSource.getFileStream(uri)?.let { stream ->
+            val transceivers = dataParser.parseJSONStream(unwrapIfZipped(uri, stream))
+            localSource.insertRadios(transceivers)
         }
         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 dataSourcesSettings = settingsRepo.dataSourcesSettings.value
+        val tleUrls = buildMap {
+            putAll(Sources.satelliteDataUrls)
+            if (dataSourcesSettings.useCustomTLE) put(customSourceType, dataSourcesSettings.tleUrl)
+        }.filterValues { it.isNotBlank() }
+        val radioUrls = buildMap {
+            putAll(Sources.transceiversDataUrls)
+            if (dataSourcesSettings.useCustomTransceivers) put(customSourceType, dataSourcesSettings.transceiversUrl)
+        }.filterValues { it.isNotBlank() }
+        // launch all network requests concurrently
+        val tleJobs = tleUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
+        val radioJobs = radioUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
+        // parse fetched data concurrently and associate with types
+        val importedEntries = tleJobs.awaitAll().flatMap { (url, stream) ->
+            val type = tleUrls.entries.find { it.value == url }?.key ?: customSourceType
+            stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty().also { entries ->
+                settingsRepo.setSatelliteTypeIds(type, entries.map { it.catnum })
             }
         }
-        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 importedRadios = radioJobs.awaitAll().flatMap { (url, stream) ->
+            stream?.let { dataParser.parseJSONStream(unwrapIfZipped(url, it)) }.orEmpty()
         }
-        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
+        // insert parsed data into the database
         localSource.insertEntries(importedEntries)
         localSource.insertRadios(importedRadios)
         setUpdateSuccessful(System.currentTimeMillis())
@@ -122,9 +94,17 @@ class DatabaseRepo(
         setUpdateSuccessful(0L)
     }
 
-    private suspend fun setUpdateSuccessful(timestamp: Long) = withContext(dispatcher) {
-        val numberOfRadios = localSource.getRadiosTotal()
-        val numberOfSatellites = localSource.getEntriesTotal()
-        settingsRepo.updateDatabaseState(DatabaseState(numberOfRadios, numberOfSatellites, timestamp))
+    private suspend fun parseSatelliteStream(url: String, stream: InputStream): List<OrbitalData> = when {
+        url.contains("FORMAT=csv", ignoreCase = true) -> dataParser.parseCSVStream(stream)
+        else -> dataParser.parseTLEStream(stream)
     }
+
+    private suspend fun setUpdateSuccessful(timestamp: Long) {
+        settingsRepo.updateDatabaseState(
+            DatabaseState(localSource.getRadiosTotal(), localSource.getEntriesTotal(), timestamp)
+        )
+    }
+
+    private fun unwrapIfZipped(url: String, stream: InputStream): InputStream =
+        if (url.endsWith(".zip", ignoreCase = true)) ZipInputStream(stream).apply { nextEntry } else stream
 }

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

@@ -28,6 +28,10 @@ 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.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -42,17 +46,26 @@ class SatelliteRepo(
     private val _passes = MutableStateFlow<List<OrbitalPass>>(emptyList())
     override val passes: StateFlow<List<OrbitalPass>> = _passes
 
+    private val _isCalculating = MutableStateFlow(false)
+    override val isCalculating: StateFlow<Boolean> = _isCalculating
+
     private val _satellites = MutableStateFlow<List<OrbitalObject>>(emptyList())
     override val satellites: StateFlow<List<OrbitalObject>> = _satellites
 
+    private val _selectedPass = MutableStateFlow(0 to 0L)
+    override val selectedPass: StateFlow<Pair<Int, Long>> = _selectedPass
+
+    override fun selectPass(catNum: Int, aosTime: Long) {
+        _selectedPass.value = catNum to aosTime
+    }
+
     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)
+            val (_, hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
+            calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
         }
     }
 
@@ -62,7 +75,8 @@ class SatelliteRepo(
 
     override suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos> {
         return withContext(dispatcher) {
-            val positions = mutableListOf<OrbitalPos>()
+            val estimatedSize = ((end - start) / 15000).toInt() + 1
+            val positions = ArrayList<OrbitalPos>(estimatedSize)
             var currentTime = start
             while (currentTime < end) {
                 positions.add(sat.getPosition(pos, currentTime))
@@ -80,65 +94,70 @@ class SatelliteRepo(
     ): 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) }
+            radios.map { transmitter ->
+                transmitter.copy(
+                    downlinkLow = transmitter.downlinkLow?.let { satPos.getDownlinkFreq(it) },
+                    downlinkHigh = transmitter.downlinkHigh?.let { satPos.getDownlinkFreq(it) },
+                    uplinkLow = transmitter.uplinkLow?.let { satPos.getUplinkFreq(it) },
+                    uplinkHigh = transmitter.uplinkHigh?.let { 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))
+        _isCalculating.value = true
+        // Normalize to the start of the current minute so that coarse 60-second stepping
+        // in getLeoPass always begins from the same phase, producing stable AOS/LOS times
+        val normalizedTime = time / 60_000L * 60_000L
+        val currentSatellites = _satellites.value
+        withContext(dispatcher) {
+            val idsWithModes = localStorage.getIdsWithModes(modes)
+            val stationPos = settingsRepo.stationPosition.value
+            val filteredSatellites = if (idsWithModes.isEmpty()) {
+                currentSatellites
+            } else {
+                currentSatellites.filter { it.data.catnum in idsWithModes }
+            }
+            // Compute passes for each satellite in parallel
+            val passLists = coroutineScope {
+                filteredSatellites.map { satellite ->
+                    async { satellite.getPasses(stationPos, normalizedTime, hoursAhead) }
+                }.awaitAll()
+            }
+            // Flatten and filter in a single pass
+            val timeFuture = normalizedTime + (hoursAhead * 60L * 60L * 1000L)
+            val newPasses = ArrayList<OrbitalPass>()
+            for (list in passLists) {
+                for (pass in list) {
+                    if (pass.losTime > time && pass.aosTime < timeFuture && pass.maxElevation > minElevation) {
+                        newPasses.add(pass)
                     }
                 }
-                _passes.update { newPasses.filter(time, hoursAhead, minElevation) }
             }
-        } else {
-            _passes.update { emptyList() }
+            newPasses.sortBy { it.aosTime }
+            delay(1000) // Simulate loading time for better UX
+            _passes.update { newPasses }
         }
+        _isCalculating.value = false
     }
 
     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()
+        val decayed = this.data.hasDecayed(time)
         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))
+                passes.add(getGeoPass(this, pos, time, decayed))
             } else {
                 do {
                     if (count > 0) shouldRewind = false
-                    val pass = getLeoPass(this, pos, startDate, shouldRewind)
+                    val pass = getLeoPass(this, pos, startDate, shouldRewind, decayed)
                     lastAosDate = pass.aosTime
                     passes.add(pass)
                     startDate = pass.losTime + (quarterOrbitMin * 3) * 60L * 1000L
@@ -149,94 +168,80 @@ class SatelliteRepo(
         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 {
+    private fun getGeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, decayed: Boolean): 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)
+        return OrbitalPass(aos, az, los, az, alt.toInt(), elev, sat, hasDecayed = decayed)
     }
 
-    private fun getLeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, rewind: Boolean): OrbitalPass {
+    private fun getLeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, rewind: Boolean, decayed: 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
+        if (rewind) calendarTimeMillis -= quarterOrbitMin * 60L * 1000L
 
-        var satPos = sat.getPosition(pos, calendarTimeMillis)
-        if (satPos.elevation > 0.0) {
+        // Use lightweight elevation check for coarse searching
+        if (sat.getElevation(pos, calendarTimeMillis) > 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)
+            } while (sat.getElevation(pos, calendarTimeMillis) > 0.0)
             // move forward 3/4 of an orbit
             calendarTimeMillis += quarterOrbitMin * 3 * 60L * 1000L
         }
 
-        // find the next time sat comes above the horizon
+        // find the next time sat comes above the horizon (coarse: 60s steps)
         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)
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation < 0.0)
 
-        // refine to 1 second
-        calendarTimeMillis += -60L * 1000L
+        // refine AOS to ~500ms precision
+        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)
+            calendarTimeMillis += 500L
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation < 0.0)
 
-        val aos = 1000 * ((satPos.time + 500) / 1000)
-        val aosAz = satPos.azimuth.toDegrees().round(1)
+        // Get full position for AOS data (azimuth, altitude)
+        val aosPos = sat.getFullPosition(pos, calendarTimeMillis)
+        val aos = 1000 * ((aosPos.time + 500) / 1000)
+        val aosAz = aosPos.azimuth.toDegrees().round(1)
 
-        // find when sat goes below
+        // find when sat goes below (coarse: 30s steps)
         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)
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation > 0.0)
 
-        // refine to 1 second
-        calendarTimeMillis += -30L * 1000L
+        // refine LOS to ~500ms precision
+        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)
+            calendarTimeMillis += 500L
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation > 0.0)
+
+        // Get full position for LOS data (azimuth, altitude)
+        val losPos = sat.getFullPosition(pos, calendarTimeMillis)
+        val los = 1000 * ((losPos.time + 500) / 1000)
+        val losAz = losPos.azimuth.toDegrees().round(1)
+
+        // Get altitude at approximate TCA (max elevation)
+        val tcaTime = (aos + los) / 2
+        val tcaPos = sat.getFullPosition(pos, tcaTime)
+        val alt = tcaPos.altitude
 
-        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)
+        return OrbitalPass(aos, aosAz, los, losAz, alt.toInt(), elev, sat, hasDecayed = decayed)
     }
 }

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

@@ -40,11 +40,23 @@ class SelectionRepo(
     private val currentItems = MutableStateFlow<List<SatItem>>(emptyList())
     private val currentTypes = MutableStateFlow(settingsRepo.selectedTypes.value)
     private val currentQuery = MutableStateFlow("")
+
+    // Resolve type IDs once when types change, then filter items reactively.
+    // The HashSet gives O(1) catnum lookups instead of O(n) with a List.
     private val itemsWithTypes = currentTypes.flatMapLatest { types: List<String> ->
-        currentItems.map { items -> items.filterByTypes(types) }
+        val catnumSet: Set<Int>? = if (types.isEmpty()) {
+            null // null = no filtering
+        } else {
+            val ids = settingsRepo.getSatelliteTypesIds(types)
+            if (ids.isEmpty()) null else ids.toHashSet()
+        }
+        currentItems.map { items ->
+            if (catnumSet == null) items else items.filter { it.catnum in catnumSet }
+        }
     }
+
     private val itemsWithQuery = currentQuery.flatMapLatest { query ->
-        itemsWithTypes.map { items -> items.filterByQuery(query) }
+        itemsWithTypes.map { items -> filterByQuery(items, query) }
     }
 
     override fun getCurrentTypes() = currentTypes.value
@@ -54,7 +66,7 @@ class SelectionRepo(
     }
 
     override suspend fun getEntriesFlow() = withContext(dispatcher) {
-        val selectedIds = settingsRepo.selectedIds.value
+        val selectedIds = settingsRepo.selectedIds.value.toHashSet()
         currentItems.value = localSource.getEntriesList().map { item ->
             item.copy(isSelected = item.catnum in selectedIds)
         }
@@ -66,17 +78,19 @@ class SelectionRepo(
         settingsRepo.setSelectedTypes(types)
     }
 
-    override suspend fun setQuery(query: String) = withContext(dispatcher) {
+    override suspend fun setQuery(query: String) {
         currentQuery.value = query
     }
 
     override suspend fun setSelection(selectAll: Boolean) = withContext(dispatcher) {
-        setSelection(itemsWithQuery.first().map { item -> item.catnum }, selectAll)
+        val visibleIds = itemsWithQuery.first().mapTo(HashSet()) { it.catnum }
+        setSelection(visibleIds, selectAll)
     }
 
     override suspend fun setSelection(ids: List<Int>, isTicked: Boolean) = withContext(dispatcher) {
+        val idSet = ids.toHashSet()
         currentItems.value = currentItems.value.map { item ->
-            if (item.catnum in ids) item.copy(isSelected = isTicked) else item
+            if (item.catnum in idSet) item.copy(isSelected = isTicked) else item
         }
     }
 
@@ -85,19 +99,24 @@ class SelectionRepo(
         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()) }
+    /**
+     * Bulk selection using a pre-built Set for O(1) lookups.
+     */
+    private suspend fun setSelection(idSet: Set<Int>, isTicked: Boolean) = withContext(dispatcher) {
+        currentItems.value = currentItems.value.map { item ->
+            if (item.catnum in idSet) item.copy(isSelected = isTicked) else item
         }
     }
+
+    /**
+     * Filters items by query. Uses toIntOrNull() instead of exception-based flow,
+     * and lowercases the query once up front instead of per-item.
+     */
+    private fun filterByQuery(items: List<SatItem>, query: String): List<SatItem> {
+        if (query.isBlank()) return items
+        val catnum = query.toIntOrNull()
+        if (catnum != null) return items.filter { it.catnum == catnum }
+        val lowerQuery = query.lowercase()
+        return items.filter { it.name.lowercase().contains(lowerQuery) }
+    }
 }

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

@@ -22,8 +22,9 @@ import android.hardware.Sensor
 import android.hardware.SensorEvent
 import android.hardware.SensorEventListener
 import android.hardware.SensorManager
+import android.hardware.display.DisplayManager
+import android.view.Display
 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
@@ -31,82 +32,101 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlin.math.round
 
+private const val SMOOTHING_FACTOR = 0.15f
+private const val SENSOR_RATE_US = 16_000
+
 class SensorsRepo(
     private val sensorManager: SensorManager,
-    private val sensor: Sensor?,
-    private val windowManager: WindowManager
-) :
-    SensorEventListener, ISensorsRepo {
+    private val displayManager: DisplayManager?
+) : ISensorsRepo, SensorEventListener {
 
-    private val _orientation = MutableStateFlow(Pair(0f, 0f))
+    private val _sensorData = MutableStateFlow(Pair(0f, 0f))
+    private val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
     private val rotationMatrix = FloatArray(9)
+    private val tempMatrix = FloatArray(9)
     private val orientationValues = FloatArray(3)
-    private var sensorAccuracy = SensorManager.SENSOR_STATUS_UNRELIABLE
+    private var smoothAzimuth = 0f
+    private var smoothPitch = 0f
+    private var hasInitialReading = false
 
-    override val orientation: StateFlow<Pair<Float, Float>> = _orientation
+    override val sensorData: StateFlow<Pair<Float, Float>> = _sensorData
 
     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
+        return GeomagneticField(
+            geoPos.latitude.toFloat(),
+            geoPos.longitude.toFloat(),
+            geoPos.altitude.toFloat(),
+            time
+        ).declination
     }
 
     override fun enableSensor() {
-        sensor?.let { sensorManager.registerListener(this, it, 8000) }
+        hasInitialReading = false
+        sensor?.let { sensorManager.registerListener(this, it, SENSOR_RATE_US) }
     }
 
     override fun disableSensor() = sensorManager.unregisterListener(this)
 
-    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
-        sensorAccuracy = accuracy
-    }
+    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) = Unit
 
-    override fun onSensorChanged(event: SensorEvent) = when {
-        sensorAccuracy == SensorManager.SENSOR_STATUS_UNRELIABLE -> {}
-        event.sensor == sensor -> updateOrientation(event.values)
-        else -> {}
+    override fun onSensorChanged(event: SensorEvent) {
+        if (event.sensor.type == Sensor.TYPE_ROTATION_VECTOR) handleSensorEvent(event)
     }
 
     private fun getDisplayRotation(): Int {
-        return try {
-            @Suppress("DEPRECATION")
-            windowManager.defaultDisplay.rotation
-        } catch (e: Exception) {
-            Surface.ROTATION_0
-        }
+        return displayManager?.getDisplay(Display.DEFAULT_DISPLAY)?.rotation ?: 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 remapForRotation(rotation: Int) {
+        val remapped = when (rotation) {
+            Surface.ROTATION_90 -> SensorManager.remapCoordinateSystem(
+                rotationMatrix, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, tempMatrix
+            )
+
+            Surface.ROTATION_180 -> SensorManager.remapCoordinateSystem(
+                rotationMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_MINUS_Y, tempMatrix
+            )
+
+            Surface.ROTATION_270 -> SensorManager.remapCoordinateSystem(
+                rotationMatrix, SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_X, tempMatrix
+            )
+
+            else -> false
         }
+        if (remapped) System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
     }
 
-    private fun updateOrientation(rotationVector: FloatArray) {
-        SensorManager.getRotationMatrixFromVector(rotationMatrix, rotationVector)
-        transformRotationMatrix(rotationMatrix, getDisplayRotation())
+    private fun handleSensorEvent(event: SensorEvent) {
+        SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values)
+        remapForRotation(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)
+        val azimuth = normalizeAzimuth((orientationValues[0] * RAD2DEG).toFloat())
+        val pitch = (orientationValues[1] * RAD2DEG).toFloat()
+        if (!hasInitialReading) {
+            smoothAzimuth = azimuth
+            smoothPitch = pitch
+            hasInitialReading = true
+        } else {
+            smoothAzimuth = lowPassAngle(smoothAzimuth, azimuth)
+            smoothPitch = lowPass(smoothPitch, pitch)
+        }
+        _sensorData.value = Pair(round(smoothAzimuth * 10) / 10, round(smoothPitch * 10) / 10)
     }
+
+    private fun lowPass(previous: Float, current: Float): Float {
+        return previous + SMOOTHING_FACTOR * (current - previous)
+    }
+
+    /**
+     * Low-pass filter that accounts for the 0°/360° wraparound.
+     * Always takes the shortest angular path between the two values.
+     */
+    private fun lowPassAngle(previous: Float, current: Float): Float {
+        var delta = current - previous
+        while (delta > 180f) delta -= 360f
+        while (delta <= -180f) delta += 360f
+        return normalizeAzimuth(previous + SMOOTHING_FACTOR * delta)
+    }
+
+    private fun normalizeAzimuth(value: Float): Float = (value + 360f) % 360f
 }

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

@@ -28,6 +28,7 @@ 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.model.RadioControlSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
@@ -50,6 +51,7 @@ class SettingsRepo(
     private val keyBluetoothFrequencyState = "bluetoothFrequencyState"
     private val keyBluetoothFrequencyAddress = "bluetoothFrequencyAddress"
     private val keyBluetoothFrequencyFormat = "bluetoothFrequencyFormat"
+    private val keyFilterShowDeepSpace = "filterShowDeepSpace"
     private val keyFilterHoursAhead = "filterHoursAhead"
     private val keyFilterMinElevation = "filterMinElevation"
     private val keyNumberOfRadios = "numberOfRadios"
@@ -70,6 +72,7 @@ class SettingsRepo(
     private val keyStateOfSweep = "stateOfSweep"
     private val keyStateOfUtc = "stateOfUtc"
     private val keyStateOfLightTheme = "stateOfLightTheme"
+    private val keyStateOfNightMode = "stateOfNightMode"
     private val keyStationAltitude = "stationAltitude"
     private val keyStationLatitude = "stationLatitude"
     private val keyStationLongitude = "stationLongitude"
@@ -78,6 +81,7 @@ class SettingsRepo(
     private val keyUpdateTimestamp = "updateTimestamp"
     private val keyShouldSeeWarning = "shouldSeeWarning"
     private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew_v$appVersionName"
+    private val keySstvMode = "sstvMode"
     private val keyUseCustomTle = "useCustomTle"
     private val keyUseCustomTransceivers = "useCustomTransceivers"
     private val keyTleUrl = "tleUrl"
@@ -109,8 +113,8 @@ class SettingsRepo(
     }
 
     private fun getSelectedTypes(): List<String> {
-        val typesString = preferences.getString(keySelectedTypes, null)
-        if (typesString.isNullOrEmpty()) return listOf("Amateur")
+        val typesString = preferences.getString(keySelectedTypes, "Amateur")
+        if (typesString.isNullOrEmpty()) return emptyList()
         return typesString.split(separatorComma)
     }
     //endregion
@@ -120,6 +124,7 @@ class SettingsRepo(
     override val passesSettings: StateFlow<PassesSettings> = _passesSettings
 
     override fun setPassesSettings(settings: PassesSettings) = preferences.edit {
+        putBoolean(keyFilterShowDeepSpace, settings.showDeepSpace)
         putInt(keyFilterHoursAhead, settings.hoursAhead)
         putLong(keyFilterMinElevation, settings.minElevation.toRawBits())
         putString(keySelectedModes, settings.selectedModes.joinToString(separatorComma))
@@ -127,11 +132,12 @@ class SettingsRepo(
     }
 
     private fun getPassesSettings(): PassesSettings {
+        val showDeepSpace = preferences.getBoolean(keyFilterShowDeepSpace, true)
         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)
+        return PassesSettings(showDeepSpace, hoursAhead, minElevation, selectedModes)
     }
     //endregion
 
@@ -246,82 +252,51 @@ class SettingsRepo(
     //endregion
 
     //region # RC settings
+    init {
+        migrateRCFormats()
+    }
+
+    // TODO: Remove after a few releases (added in v4.2.0)
+    private val keyRCFormatsMigrated = "rcFormatsMigrated"
+
+    private fun migrateRCFormats() {
+        if (preferences.getBoolean(keyRCFormatsMigrated, false)) return
+        val formatKeys = listOf(
+            keyRotatorFormat, keyFrequencyFormat, keyBluetoothRotatorFormat, keyBluetoothFrequencyFormat
+        )
+        preferences.edit {
+            for (key in formatKeys) {
+                val value = preferences.getString(key, null) ?: continue
+                if (value.contains("_") && !value.startsWith("\\")) {
+                    putString(key, "\\$value")
+                }
+            }
+            putBoolean(keyRCFormatsMigrated, true)
+        }
+    }
+
     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) }
+    override fun updateRCSettings(settings: RCSettings) {
+        preferences.edit {
+            putBoolean(keyRotatorState, settings.rotatorState)
+            putString(keyRotatorAddress, settings.rotatorAddress)
+            putString(keyRotatorPort, settings.rotatorPort)
+            putString(keyRotatorFormat, settings.rotatorFormat)
+            putBoolean(keyFrequencyState, settings.frequencyState)
+            putString(keyFrequencyAddress, settings.frequencyAddress)
+            putString(keyFrequencyPort, settings.frequencyPort)
+            putString(keyFrequencyFormat, settings.frequencyFormat)
+            putBoolean(keyBluetoothRotatorState, settings.bluetoothRotatorState)
+            putString(keyBluetoothRotatorFormat, settings.bluetoothRotatorFormat)
+            putString(keyBluetoothRotatorName, settings.bluetoothRotatorName)
+            putString(keyBluetoothRotatorAddress, settings.bluetoothRotatorAddress)
+            putBoolean(keyBluetoothFrequencyState, settings.bluetoothFrequencyState)
+            putString(keyBluetoothFrequencyFormat, settings.bluetoothFrequencyFormat)
+            putString(keyBluetoothFrequencyAddress, settings.bluetoothFrequencyAddress)
+        }
+        _rcSettings.value = settings
     }
 
     private fun getRCSettings(): RCSettings = RCSettings(
@@ -332,14 +307,14 @@ class SettingsRepo(
         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",
+        frequencyFormat = preferences.getString(keyFrequencyFormat, null) ?: $$"F $FREQ",
         bluetoothRotatorState = preferences.getBoolean(keyBluetoothRotatorState, false),
-        bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"W$AZ $EL",
+        bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"P $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"
+        bluetoothFrequencyFormat = preferences.getString(keyBluetoothFrequencyFormat, null) ?: $$"F $FREQ"
     )
     //endregion
 
@@ -347,39 +322,22 @@ class SettingsRepo(
     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) }
+    override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) {
+        _otherSettings.update { current ->
+            val new = transform(current)
+            preferences.edit {
+                putBoolean(keyStateOfAutoUpdate, new.stateOfAutoUpdate)
+                putBoolean(keyStateOfSensors, new.stateOfSensors)
+                putBoolean(keyStateOfSweep, new.stateOfSweep)
+                putBoolean(keyStateOfUtc, new.stateOfUtc)
+                putBoolean(keyStateOfLightTheme, new.stateOfLightTheme)
+                putBoolean(keyStateOfNightMode, new.stateOfNightMode)
+                putBoolean(keyShouldSeeWarning, new.shouldSeeWarning)
+                putBoolean(keyShouldSeeWhatsNew, new.shouldSeeWhatsNew)
+                putString(keySstvMode, new.sstvMode)
+            }
+            new
+        }
     }
 
     private fun getOtherSettings(): OtherSettings = OtherSettings(
@@ -388,8 +346,10 @@ class SettingsRepo(
         stateOfSweep = preferences.getBoolean(keyStateOfSweep, true),
         stateOfUtc = preferences.getBoolean(keyStateOfUtc, false),
         stateOfLightTheme = preferences.getBoolean(keyStateOfLightTheme, false),
+        stateOfNightMode = preferences.getBoolean(keyStateOfNightMode, false),
         shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
-        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true)
+        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
+        sstvMode = preferences.getString(keySstvMode, null) ?: "Auto"
     )
     //endregion
 
@@ -397,24 +357,14 @@ class SettingsRepo(
     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) }
+    override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
+        preferences.edit {
+            putBoolean(keyUseCustomTle, settings.useCustomTLE)
+            putBoolean(keyUseCustomTransceivers, settings.useCustomTransceivers)
+            putString(keyTleUrl, settings.tleUrl)
+            putString(keyTransceiversUrl, settings.transceiversUrl)
+        }
+        _dataSourcesSettings.value = settings
     }
 
     private fun getDataSourcesSettings(): DataSourcesSettings = DataSourcesSettings(
@@ -424,4 +374,40 @@ class SettingsRepo(
         transceiversUrl = preferences.getString(keyTransceiversUrl, "https://example.com/radio.json") ?: ""
     )
     //endregion
+
+    //region # Radio control settings
+    private val keyRadioControlEnabled = "radioControlEnabled"
+    private val keyRadioModel = "radioModel"
+    private val keyTxRadioAddress = "txRadioAddress"
+    private val keyRxRadioAddress = "rxRadioAddress"
+    private val keyTxRadioName = "txRadioName"
+    private val keyRxRadioName = "rxRadioName"
+    private val keyRadioBaudRate = "radioBaudRate"
+
+    private val _radioControlSettings = MutableStateFlow(getRadioControlSettings())
+    override val radioControlSettings: StateFlow<RadioControlSettings> = _radioControlSettings
+
+    override fun updateRadioControlSettings(settings: RadioControlSettings) {
+        preferences.edit {
+            putBoolean(keyRadioControlEnabled, settings.enabled)
+            putString(keyRadioModel, settings.radioModel)
+            putString(keyTxRadioAddress, settings.txRadioAddress)
+            putString(keyRxRadioAddress, settings.rxRadioAddress)
+            putString(keyTxRadioName, settings.txRadioName)
+            putString(keyRxRadioName, settings.rxRadioName)
+            putInt(keyRadioBaudRate, settings.baudRate)
+        }
+        _radioControlSettings.value = settings
+    }
+
+    private fun getRadioControlSettings(): RadioControlSettings = RadioControlSettings(
+        enabled = preferences.getBoolean(keyRadioControlEnabled, false),
+        radioModel = preferences.getString(keyRadioModel, null) ?: "Yaesu FT-817/818",
+        txRadioAddress = preferences.getString(keyTxRadioAddress, null) ?: "",
+        rxRadioAddress = preferences.getString(keyRxRadioAddress, null) ?: "",
+        txRadioName = preferences.getString(keyTxRadioName, null) ?: "TX Radio",
+        rxRadioName = preferences.getString(keyRxRadioName, null) ?: "RX Radio",
+        baudRate = preferences.getInt(keyRadioBaudRate, 4800)
+    )
+    //endregion
 }

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

@@ -74,7 +74,6 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
     }
 
     override suspend fun insertRadios(radios: List<SatRadio>) {
-        look4SatDao.deleteRadios()
         look4SatDao.insertRadios(radios.toFrameworkRadios())
     }
 

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

@@ -24,6 +24,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okhttp3.Request
+import java.io.ByteArrayInputStream
 import java.io.InputStream
 
 class RemoteSource(
@@ -45,7 +46,10 @@ class RemoteSource(
     override suspend fun getNetworkStream(url: String): InputStream? = withContext(dispatcher) {
         try {
             val networkRequest = Request.Builder().url(url).build()
-            httpClient.newCall(networkRequest).execute().body.byteStream()
+            httpClient.newCall(networkRequest).execute().use { response ->
+                if (!response.isSuccessful) return@withContext null
+                ByteArrayInputStream(response.body.bytes())
+            }
         } catch (exception: Exception) {
             println("RemoteSource network stream exception: $exception")
             null

core/data/src/main/java/com/rtbishop/look4sat/core/data/usecase/AudioCapture.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.usecase
+
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder
+import androidx.annotation.RequiresPermission
+import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.isActive
+
+class AudioCapture : IAudioCapture {
+
+    override val sampleRate: Int = 44100
+
+    private val channelConfig = AudioFormat.CHANNEL_IN_MONO
+    private val audioFormat = AudioFormat.ENCODING_PCM_FLOAT
+    private val bufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
+        .coerceAtLeast(sampleRate) // at least 1 second buffer
+
+    @RequiresPermission(android.Manifest.permission.RECORD_AUDIO)
+    override fun audioFlow(): Flow<FloatArray> = flow {
+        val recorder = AudioRecord(
+            MediaRecorder.AudioSource.MIC,
+            sampleRate,
+            channelConfig,
+            audioFormat,
+            bufferSize * 4 // bytes for float
+        )
+        try {
+            recorder.startRecording()
+            val chunkSize = sampleRate / 10 // ~100ms chunks
+            val buffer = FloatArray(chunkSize)
+            while (currentCoroutineContext().isActive) {
+                val read = recorder.read(buffer, 0, chunkSize, AudioRecord.READ_BLOCKING)
+                if (read > 0) emit(if (read == chunkSize) buffer.copyOf() else buffer.copyOfRange(0, read))
+            }
+        } finally {
+            recorder.stop()
+            recorder.release()
+        }
+    }.flowOn(Dispatchers.IO)
+}

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

@@ -0,0 +1,84 @@
+/*
+ * 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.ContentValues
+import android.content.Context
+import android.graphics.Bitmap
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileOutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+//Saves images to the device gallery using MediaStore (API 29+) or direct file write (API < 29)
+class SaveImage(private val context: Context) : ISaveImage {
+
+    override suspend fun invoke(pixels: IntArray, width: Int, height: Int, modeName: String): Boolean {
+        return withContext(Dispatchers.IO) {
+            try {
+                val bitmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+                val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+                val filename = "SSTV_${modeName}_$timestamp.png"
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    saveWithMediaStore(bitmap, filename)
+                } else {
+                    saveToExternalStorage(bitmap, filename)
+                }
+                bitmap.recycle()
+                true
+            } catch (_: Exception) {
+                false
+            }
+        }
+    }
+
+    private fun saveWithMediaStore(bitmap: Bitmap, filename: String) {
+        val values = ContentValues().apply {
+            put(MediaStore.Images.Media.DISPLAY_NAME, filename)
+            put(MediaStore.Images.Media.MIME_TYPE, "image/png")
+            put(MediaStore.Images.Media.RELATIVE_PATH, "${Environment.DIRECTORY_PICTURES}/Look4Sat")
+            put(MediaStore.Images.Media.IS_PENDING, 1)
+        }
+        val resolver = context.contentResolver
+        val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
+            ?: throw IllegalStateException("Failed to create MediaStore entry")
+        resolver.openOutputStream(uri)?.use { stream ->
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+        }
+        values.clear()
+        values.put(MediaStore.Images.Media.IS_PENDING, 0)
+        resolver.update(uri, values, null, null)
+    }
+
+    private fun saveToExternalStorage(bitmap: Bitmap, filename: String) {
+        val picturesDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)
+        val dir = File(picturesDir, "Look4Sat")
+        if (!dir.exists()) dir.mkdirs()
+        val file = File(dir, filename)
+        FileOutputStream(file).use { stream ->
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+        }
+    }
+}

core/data/src/test/java/com/rtbishop/look4sat/core/data/Ft817CatProtocolTest.kt

@@ -0,0 +1,149 @@
+package com.rtbishop.look4sat.core.data
+
+import com.rtbishop.look4sat.core.data.framework.Ft817CatProtocol
+import org.junit.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class Ft817CatProtocolTest {
+
+    @Test
+    fun encodeFrequencyBcd_145500000() {
+        val bcd = Ft817CatProtocol.encodeFrequencyBcd(145500000L)
+        assertContentEquals(byteArrayOf(0x14, 0x55, 0x00, 0x00), bcd)
+    }
+
+    @Test
+    fun encodeFrequencyBcd_435100000() {
+        val bcd = Ft817CatProtocol.encodeFrequencyBcd(435100000L)
+        assertContentEquals(byteArrayOf(0x43, 0x51, 0x00, 0x00), bcd)
+    }
+
+    @Test
+    fun encodeFrequencyBcd_7074000() {
+        val bcd = Ft817CatProtocol.encodeFrequencyBcd(7074000L)
+        assertContentEquals(byteArrayOf(0x00, 0x70, 0x74, 0x00), bcd)
+    }
+
+    @Test
+    fun decodeFrequencyBcd_roundTrips() {
+        val testFreqs = listOf(145500000L, 435100000L, 7074000L, 14200000L, 28500000L)
+        for (freq in testFreqs) {
+            val rounded = (freq / 10) * 10
+            val bcd = Ft817CatProtocol.encodeFrequencyBcd(freq)
+            assertEquals(rounded, Ft817CatProtocol.decodeFrequencyBcd(bcd))
+        }
+    }
+
+    @Test
+    fun buildSetFreqCommand_correctFormat() {
+        val cmd = Ft817CatProtocol.buildSetFreqCommand(145500000L)
+        assertEquals(5, cmd.size)
+        assertEquals(0x01.toByte(), cmd[4])
+        assertContentEquals(byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x01), cmd)
+    }
+
+    @Test
+    fun buildSetModeCommand_usb() {
+        val cmd = Ft817CatProtocol.buildSetModeCommand("USB")
+        assertNotNull(cmd)
+        assertContentEquals(byteArrayOf(0x01, 0x00, 0x00, 0x00, 0x07), cmd)
+    }
+
+    @Test
+    fun buildSetModeCommand_fm() {
+        val cmd = Ft817CatProtocol.buildSetModeCommand("FM")
+        assertNotNull(cmd)
+        assertContentEquals(byteArrayOf(0x08, 0x00, 0x00, 0x00, 0x07), cmd)
+    }
+
+    @Test
+    fun buildSetModeCommand_unknownReturnsNull() {
+        assertNull(Ft817CatProtocol.buildSetModeCommand("INVALID"))
+    }
+
+    @Test
+    fun encodeCtcssTone_67_0() {
+        val bcd = Ft817CatProtocol.encodeCtcssToneBcd(67.0)
+        assertContentEquals(byteArrayOf(0x06, 0x70), bcd)
+    }
+
+    @Test
+    fun encodeCtcssTone_74_4() {
+        val bcd = Ft817CatProtocol.encodeCtcssToneBcd(74.4)
+        assertContentEquals(byteArrayOf(0x07, 0x44), bcd)
+    }
+
+    @Test
+    fun encodeCtcssTone_141_3() {
+        val bcd = Ft817CatProtocol.encodeCtcssToneBcd(141.3)
+        assertContentEquals(byteArrayOf(0x14, 0x13), bcd)
+    }
+
+    @Test
+    fun buildSetCtcssToneCommand_correctFormat() {
+        val cmd = Ft817CatProtocol.buildSetCtcssToneCommand(67.0)
+        assertEquals(5, cmd.size)
+        assertEquals(0x0B.toByte(), cmd[4])
+        assertContentEquals(byteArrayOf(0x06, 0x70, 0x00, 0x00, 0x0B), cmd)
+    }
+
+    @Test
+    fun buildCtcssModeCommand_enable() {
+        val cmd = Ft817CatProtocol.buildCtcssModeCommand(true)
+        assertContentEquals(byteArrayOf(0x2A, 0x00, 0x00, 0x00, 0x0A), cmd)
+    }
+
+    @Test
+    fun buildCtcssModeCommand_disable() {
+        val cmd = Ft817CatProtocol.buildCtcssModeCommand(false)
+        assertEquals(0x8A.toByte(), cmd[0])
+        assertEquals(0x0A.toByte(), cmd[4])
+    }
+
+    @Test
+    fun parseReadResponse_validResponse() {
+        val response = byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x01)
+        val result = Ft817CatProtocol.parseReadResponse(response)
+        assertNotNull(result)
+        assertEquals(145500000L, result.first)
+        assertEquals("USB", result.second)
+    }
+
+    @Test
+    fun parseReadResponse_fmMode() {
+        val response = byteArrayOf(0x14, 0x60, 0x00, 0x00, 0x08)
+        val result = Ft817CatProtocol.parseReadResponse(response)
+        assertNotNull(result)
+        assertEquals(146000000L, result.first)
+        assertEquals("FM", result.second)
+    }
+
+    @Test
+    fun parseReadResponse_tooShort() {
+        assertNull(Ft817CatProtocol.parseReadResponse(byteArrayOf(0x14, 0x55, 0x00)))
+    }
+
+    @Test
+    fun parseReadResponse_unknownMode() {
+        val response = byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x0F)
+        assertNull(Ft817CatProtocol.parseReadResponse(response))
+    }
+
+    @Test
+    fun buildPttCommands() {
+        val on = Ft817CatProtocol.buildPttOnCommand()
+        assertContentEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x08), on)
+
+        val off = Ft817CatProtocol.buildPttOffCommand()
+        assertEquals(0x88.toByte(), off[4])
+    }
+
+    @Test
+    fun buildReadCommand() {
+        val cmd = Ft817CatProtocol.buildReadFreqModeCommand()
+        assertContentEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x03), cmd)
+    }
+}

core/domain/build.gradle.kts

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

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

@@ -17,16 +17,20 @@
  */
 package com.rtbishop.look4sat.core.domain.model
 
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
 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?
+    @SerialName("uuid") val uuid: String,
+    @SerialName("description") val info: String,
+    @SerialName("alive") val isAlive: Boolean,
+    @SerialName("downlink_low") val downlinkLow: Long?,
+    @SerialName("downlink_high") val downlinkHigh: Long?,
+    @SerialName("mode") val downlinkMode: String?,
+    @SerialName("uplink_low") val uplinkLow: Long?,
+    @SerialName("uplink_high") val uplinkHigh: Long?,
+    @SerialName("uplink_mode") val uplinkMode: String?,
+    @SerialName("invert") val isInverted: Boolean,
+    @SerialName("norad_cat_id") val catnum: Int?
 )

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

@@ -24,6 +24,7 @@ data class DatabaseState(
 )
 
 data class PassesSettings(
+    val showDeepSpace: Boolean = true,
     val hoursAhead: Int,
     val minElevation: Double,
     val selectedModes: List<String>
@@ -53,8 +54,10 @@ data class OtherSettings(
     val stateOfSweep: Boolean,
     val stateOfUtc: Boolean,
     val stateOfLightTheme: Boolean,
+    val stateOfNightMode: Boolean = false,
     val shouldSeeWarning: Boolean,
-    val shouldSeeWhatsNew: Boolean
+    val shouldSeeWhatsNew: Boolean,
+    val sstvMode: String = "Auto"
 )
 
 data class DataSourcesSettings(
@@ -63,3 +66,20 @@ data class DataSourcesSettings(
     val tleUrl: String,
     val transceiversUrl: String
 )
+
+data class RadioControlSettings(
+    val enabled: Boolean,
+    val radioModel: String,
+    val txRadioAddress: String,
+    val rxRadioAddress: String,
+    val txRadioName: String,
+    val rxRadioName: String,
+    val baudRate: Int
+) {
+    companion object {
+        val SUPPORTED_RADIOS = listOf(
+            "Yaesu FT-817/818",
+            "Yaesu FT-857/897"
+        )
+    }
+}

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

@@ -0,0 +1,667 @@
+/*
+ * 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 com.rtbishop.look4sat.core.domain.utility.toDegrees
+import com.rtbishop.look4sat.core.domain.utility.toRadians
+import kotlin.math.PI
+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.floor
+import kotlin.math.log10
+import kotlin.math.pow
+import kotlin.math.sin
+import kotlin.math.sqrt
+import kotlin.math.tan
+
+/**
+ * Standalone celestial computations extracted from PREDICT v2.2.5.
+ * Provides Sun position, Moon position, satellite visibility classification,
+ * orbital metadata, RA/Dec conversion, and rise/set finding for Sun and Moon.
+ *
+ * All angles are in degrees unless noted. Time is Unix epoch milliseconds.
+ *
+ * Shared math utilities (thetaGJD, modulus, mod2PI, deltaET, millisToDaynum,
+ * solarPositionECI, eciToGeodetic) live in OrbitalMath.kt in the same package.
+ */
+object CelestialComputer {
+
+    // ── Result types ──
+
+    /** Sun position as seen from a ground observer. */
+    data class SunPosition(
+        val azimuth: Double,         // degrees, 0=N, 90=E
+        val elevation: Double,       // degrees, >0 above horizon
+        val distance: Double,        // normalized: 1.0 + ((range - AU) / AU)
+        val rangeRate: Double,       // km/s
+        val latitude: Double,        // sub-solar point latitude, degrees
+        val longitude: Double,       // sub-solar point longitude, degrees
+        val rightAscension: Double,  // degrees
+        val declination: Double      // degrees
+    )
+
+    /** Moon position as seen from a ground observer. */
+    data class MoonPosition(
+        val azimuth: Double,         // degrees, 0=N, 90=E
+        val elevation: Double,       // degrees
+        val rightAscension: Double,  // degrees
+        val declination: Double,     // degrees
+        val gha: Double,             // Greenwich Hour Angle, degrees
+        val angularDiameter: Double, // apparent diameter relative to Earth's diameter
+        val radialVelocity: Double   // m/s, Doppler radial velocity for EME
+    )
+
+    /**
+     * 3-state satellite visibility classification.
+     * - [VISIBLE]: satellite is sunlit, observer is in darkness (sun below -12°) — optically visible
+     * - [DAYLIGHT]: satellite is sunlit, observer is in daylight
+     * - [ECLIPSED]: satellite is in Earth's shadow
+     */
+    enum class SatVisibility { VISIBLE, DAYLIGHT, ECLIPSED }
+
+    /** Orbital metadata not typically included in pass data. */
+    data class OrbitalMetadata(
+        val footprintDiameter: Double, // km, ground coverage circle diameter
+        val orbitNumber: Long,         // current orbit/revolution number
+        val betaAngle: Double,         // degrees, angle between orbital plane and Sun
+        val orbitalPhase: Double       // 0-256 phase within current orbit
+    )
+
+    // ── Sun position ──
+
+    /**
+     * Compute the Sun's full position as seen from [observer] at [timeMillis].
+     * Includes az/el, RA/Dec, sub-solar lat/lon, range, and range rate.
+     * Based on FindSun() from PREDICT v2.2.5.
+     */
+    fun getSunPosition(observer: GeoPos, timeMillis: Long): SunPosition {
+        val daynum = millisToDaynum(timeMillis)
+        val julUtc = daynum + 2444238.5
+        val sunVec = solarPositionECI(julUtc)
+        val zeroVel = doubleArrayOf(0.0, 0.0, 0.0)
+        val obsGeo = observerGeodetic(observer)
+
+        // Az, El, Range, RangeRate
+        val obsSet = computeObsAngles(julUtc, sunVec, zeroVel, obsGeo)
+
+        // Lat/Lon of sub-solar point
+        val latLon = eciToGeodetic(julUtc, sunVec)
+
+        // RA/Dec
+        val raDec = calculateRADec(julUtc, sunVec, zeroVel, obsGeo)
+
+        return SunPosition(
+            azimuth = obsSet[0].toDegrees(),
+            elevation = obsSet[1].toDegrees(),
+            distance = 1.0 + ((obsSet[2] - ASTRONOMICAL_UNIT) / ASTRONOMICAL_UNIT),
+            rangeRate = 1000.0 * obsSet[3],
+            latitude = latLon[0].toDegrees(),
+            longitude = latLon[1].toDegrees().let { if (it > 180.0) it - 360.0 else it },
+            rightAscension = raDec[0].toDegrees(),
+            declination = raDec[1].toDegrees()
+        )
+    }
+
+    // ── Moon position ──
+
+    /**
+     * Compute the Moon's position as seen from [observer] at [timeMillis].
+     * Full Meeus lunar ephemeris from PREDICT v2.2.5 with expanded terms
+     * and radial velocity approximation for EME Doppler.
+     */
+    fun getMoonPosition(observer: GeoPos, timeMillis: Long): MoonPosition {
+        val daynum = millisToDaynum(timeMillis)
+        val jd = daynum + 2444238.5
+        var t = (jd - 2415020.0) / 36525.0
+        val t2 = t * t
+        val t3 = t2 * t
+
+        var l1 = 270.434164 + 481267.8831 * t - 0.001133 * t2 + 0.0000019 * t3
+        var mSun = 358.475833 + 35999.0498 * t - 0.00015 * t2 - 0.0000033 * t3
+        var m1 = 296.104608 + 477198.8491 * t + 0.009192 * t2 + 0.0000144 * t3
+        var d = 350.737486 + 445267.1142 * t - 0.001436 * t2 + 0.0000019 * t3
+        var ff = 11.250889 + 483202.0251 * t - 0.003211 * t2 - 0.0000003 * t3
+        val om = (259.183275 - 1934.142 * t + 0.002078 * t2 + 0.0000022 * t3) * DEG2RAD
+
+        val correction512 = sin((51.2 + 20.2 * t) * DEG2RAD)
+        val ss = 0.003964 * sin((346.56 + 132.87 * t - 0.0091731 * t2) * DEG2RAD)
+        l1 += 0.000233 * correction512 + ss + 0.001964 * sin(om)
+        mSun -= 0.001778 * correction512
+        m1 += 0.000817 * correction512 + ss + 0.002541 * sin(om)
+        d += 0.002011 * correction512 + ss + 0.001964 * sin(om)
+        ff += ss - 0.024691 * sin(om) - 0.004328 * sin(om + (275.05 - 2.3 * t) * DEG2RAD)
+
+        val ex = 1.0 - 0.002495 * t - 0.00000752 * t2
+        l1 = primeAngle(l1); mSun = primeAngle(mSun); m1 = primeAngle(m1)
+        d = primeAngle(d); ff = primeAngle(ff)
+
+        val mR = mSun * DEG2RAD
+        val m1R = m1 * DEG2RAD
+        val dR = d * DEG2RAD
+        val ffR = ff * DEG2RAD
+
+        // Ecliptic longitude — expanded v225 terms
+        var l = l1 + 6.28875 * sin(m1R) + 1.274018 * sin(2 * dR - m1R) + 0.658309 * sin(2 * dR)
+        l += 0.213616 * sin(2 * m1R) - ex * 0.185596 * sin(mR) - 0.114336 * sin(2 * ffR)
+        l += 0.058793 * sin(2 * dR - 2 * m1R) + ex * 0.057212 * sin(2 * dR - mR - m1R) + 0.05332 * sin(2 * dR + m1R)
+        l += ex * 0.045874 * sin(2 * dR - mR) + ex * 0.041024 * sin(m1R - mR) - 0.034718 * sin(dR)
+        l -= ex * 0.030465 * sin(mR + m1R) + 0.015326 * sin(2 * dR - 2 * ffR) - 0.012528 * sin(2 * ffR + m1R)
+        l -= 0.01098 * sin(2 * ffR - m1R) + 0.010674 * sin(4 * dR - m1R) + 0.010034 * sin(3 * m1R)
+        l += 0.008548 * sin(4 * dR - 2 * m1R) - ex * 0.00791 * sin(mR - m1R + 2 * dR)
+        l -= ex * 0.006783 * sin(2 * dR + mR)
+        l += 0.005162 * sin(m1R - dR) + ex * 0.005 * sin(mR + dR) + ex * 0.004049 * sin(m1R - mR + 2 * dR)
+        l += 0.003996 * sin(2 * m1R + 2 * dR) + 0.003862 * sin(4 * dR) + 0.003665 * sin(2 * dR - 3 * m1R)
+        l += ex * 0.002695 * sin(2 * m1R - mR) + 0.002602 * sin(m1R - 2 * ffR - 2 * dR)
+        l += ex * 0.002396 * sin(2 * dR - mR - 2 * m1R)
+        l -= 0.002349 * sin(m1R + dR) + ex * ex * 0.002249 * sin(2 * dR - 2 * mR)
+        l -= ex * 0.002125 * sin(2 * m1R + mR)
+        l -= ex * ex * 0.002079 * sin(2 * mR) + ex * ex * 0.002059 * sin(2 * dR - m1R - 2 * mR)
+        l -= 0.001773 * sin(m1R + 2 * dR - 2 * ffR)
+        l += ex * 0.00122 * sin(4 * dR - mR - m1R) - 0.00111 * sin(2 * m1R + 2 * ffR) + 0.000892 * sin(m1R - 3 * dR)
+        l -= ex * 0.000811 * sin(mR + m1R + 2 * dR) + ex * 0.000761 * sin(4 * dR - mR - 2 * m1R)
+        l += ex * ex * 0.000717 * sin(m1R - 2 * mR)
+        l += ex * ex * 0.000704 * sin(m1R - 2 * mR - 2 * dR) + ex * 0.000693 * sin(mR - 2 * m1R + 2 * dR)
+        l += ex * 0.000598 * sin(2 * dR - mR - 2 * ffR) + 0.00055 * sin(m1R + 4 * dR)
+        l += 0.000538 * sin(4 * m1R) + ex * 0.000521 * sin(4 * dR - mR) + 0.000486 * sin(2 * m1R - dR)
+        l -= 0.001595 * sin(2 * ffR + 2 * dR)
+
+        // Ecliptic latitude — expanded v225 terms
+        var b =
+            5.128189 * sin(ffR) + 0.280606 * sin(m1R + ffR) + 0.277693 * sin(m1R - ffR) + 0.173238 * sin(2 * dR - ffR)
+        b += 0.055413 * sin(2 * dR + ffR - m1R) + 0.046272 * sin(2 * dR - ffR - m1R) + 0.032573 * sin(2 * dR + ffR)
+        b += 0.017198 * sin(2 * m1R + ffR) + 9.266999e-03 * sin(2 * dR + m1R - ffR) + 0.008823 * sin(2 * m1R - ffR)
+        b += ex * 0.008247 * sin(2 * dR - mR - ffR) + 0.004323 * sin(2 * dR - ffR - 2 * m1R)
+        b += 0.0042 * sin(2 * dR + ffR + m1R)
+        b += ex * 0.003372 * sin(ffR - mR - 2 * dR) + ex * 0.002472 * sin(2 * dR + ffR - mR - m1R)
+        b += ex * 0.002222 * sin(2 * dR + ffR - mR)
+        b += 0.002072 * sin(2 * dR - ffR - mR - m1R) + ex * 0.001877 * sin(ffR - mR + m1R)
+        b += 0.001828 * sin(4 * dR - ffR - m1R)
+        b -= ex * 0.001803 * sin(ffR + mR) - 0.00175 * sin(3 * ffR)
+        b += ex * 0.00157 * sin(m1R - mR - ffR) - 0.001487 * sin(ffR + dR)
+        b -= ex * 0.001481 * sin(ffR + mR + m1R) + ex * 0.001417 * sin(ffR - mR - m1R)
+        b += ex * 0.00135 * sin(ffR - mR) + 0.00133 * sin(ffR - dR)
+        b += 0.001106 * sin(ffR + 3 * m1R) + 0.00102 * sin(4 * dR - ffR) + 0.000833 * sin(ffR + 4 * dR - m1R)
+        b += 0.000781 * sin(m1R - 3 * ffR) + 0.00067 * sin(ffR + 4 * dR - 2 * m1R)
+        b += 0.000606 * sin(2 * dR - 3 * ffR)
+        b += 0.000597 * sin(2 * dR + 2 * m1R - ffR) + ex * 0.000492 * sin(2 * dR + m1R - mR - ffR)
+        b += 0.00045 * sin(2 * m1R - ffR - 2 * dR)
+        b += 0.000439 * sin(3 * m1R - ffR) + 0.000423 * sin(ffR + 2 * dR + 2 * m1R)
+        b += 0.000422 * sin(2 * dR - ffR - 3 * m1R)
+        b -= ex * 0.000367 * sin(mR + ffR + 2 * dR - m1R) - ex * 0.000353 * sin(mR + ffR + 2 * dR)
+        b += 0.000331 * sin(ffR + 4 * dR)
+        b += ex * 0.000317 * sin(2 * dR + ffR - mR + m1R) + ex * ex * 0.000306 * sin(2 * dR - 2 * mR - ffR)
+        b -= 0.000283 * sin(m1R + 3 * ffR)
+
+        val w1 = 0.0004664 * cos(om)
+        val w2 = 0.0000754 * cos(om + (275.05 - 2.3 * t) * DEG2RAD)
+        val bt = b * (1.0 - w1 - w2)
+
+        // Parallax — expanded v225 terms
+        var p =
+            0.950724 + 0.051818 * cos(m1R) + 0.009531 * cos(2 * dR - m1R) + 0.007843 * cos(2 * dR) + 0.002824 * cos(2 * m1R)
+        p += 0.000857 * cos(2 * dR + m1R) + ex * 0.000533 * cos(2 * dR - mR) + ex * 0.000401 * cos(2 * dR - mR - m1R)
+        p += 0.000173 * cos(3 * m1R) + 0.000167 * cos(4 * dR - m1R) - ex * 0.000111 * cos(mR)
+        p += 0.000103 * cos(4 * dR - 2 * m1R) - 0.000084 * cos(2 * m1R - 2 * dR) - ex * 0.000083 * cos(2 * dR + mR)
+        p += 0.000079 * cos(2 * dR + 2 * m1R)
+        p += 0.000072 * cos(4 * dR) + ex * 0.000064 * cos(2 * dR - mR + m1R) - ex * 0.000063 * cos(2 * dR + mR - m1R)
+        p += ex * 0.000041 * cos(mR + dR) + ex * 0.000035 * cos(2 * m1R - mR) - 0.000033 * cos(3 * m1R - 2 * dR)
+        p -= 0.00003 * cos(m1R + dR) - 0.000029 * cos(2 * ffR - 2 * dR) - ex * 0.000029 * cos(2 * m1R + mR)
+        p += ex * ex * 0.000026 * cos(2 * dR - 2 * mR) - 0.000023 * cos(2 * ffR - 2 * dR + m1R)
+        p += ex * 0.000019 * cos(4 * dR - mR - m1R)
+
+        val bRad = bt * DEG2RAD
+        val lm = l * DEG2RAD
+        val moonDx = 3.0 / (PI * p)
+
+        // Ecliptic → equatorial
+        val z = (jd - 2415020.5) / 365.2422
+        val ob = (23.452294 - (0.46845 * z + 5.9e-07 * z * z) / 3600.0).toRadians()
+        val dec = asin(sin(bRad) * cos(ob) + cos(bRad) * sin(ob) * sin(lm))
+        var ra = acos(cos(bRad) * cos(lm) / cos(dec)); if (lm > PI) ra = TWO_PI - ra
+
+        val n = observer.latitude * DEG2RAD
+        t = (jd - 2451545.0) / 36525.0
+        var teg = 280.46061837 + 360.98564736629 * (jd - 2451545.0) + (0.000387933 * t - t * t / 38710000.0) * t
+        while (teg > 360.0) teg -= 360.0
+        // LST = GMST + east longitude (positive east convention)
+        val th = mod2PI((teg + observer.longitude) * DEG2RAD)
+        val h = th - ra
+        val azVal = atan2(sin(h), cos(h) * sin(n) - tan(dec) * cos(n)) + PI
+        val el = asin(sin(n) * sin(dec) + cos(n) * cos(dec) * cos(h))
+
+        // Moon radial velocity approximation (from "Amateur Radio Software", GM4ANB, RSGB 1985)
+        val mm = fixAngle(1.319238 + daynum * 0.228027135)
+        val radT2 = 0.10976
+        val radT1 = mm + radT2 * sin(mm)
+        var dv = 0.01255 * moonDx * moonDx * sin(radT1) * (1.0 + radT2 * cos(mm))
+        dv *= 4449.0
+        val earthR = 6378.0
+        val moonDist = 384401.0
+        val radT3 = earthR * moonDist * (cos(dec) * cos(n) * sin(h)) /
+            sqrt(moonDist * moonDist - moonDist * earthR * sin(el))
+        val moonDv = dv + radT3 * 0.0753125
+
+        val moonRa = ra / DEG2RAD
+        var moonGha = teg - moonRa
+        if (moonGha < 0.0) moonGha += 360.0
+
+        return MoonPosition(
+            azimuth = azVal / DEG2RAD,
+            elevation = el / DEG2RAD,
+            rightAscension = moonRa,
+            declination = dec / DEG2RAD,
+            gha = moonGha,
+            angularDiameter = moonDx,
+            radialVelocity = moonDv
+        )
+    }
+
+    // ── Satellite visibility ──
+
+    /**
+     * Classify satellite visibility given its eclipse state and the Sun's elevation
+     * at the observer's location.
+     *
+     * @param isEclipsed whether the satellite is in Earth's shadow
+     * @param sunElevationDeg Sun elevation at observer in degrees
+     * @param satElevationDeg satellite elevation at observer in degrees (must be >= 0)
+     */
+    fun classifyVisibility(
+        isEclipsed: Boolean,
+        sunElevationDeg: Double,
+        satElevationDeg: Double
+    ): SatVisibility {
+        if (isEclipsed) return SatVisibility.ECLIPSED
+        return if (sunElevationDeg <= -12.0 && satElevationDeg >= 0.0) SatVisibility.VISIBLE
+        else SatVisibility.DAYLIGHT
+    }
+
+    // ── Orbital metadata ──
+
+    /**
+     * Compute orbital metadata for a satellite at its current position.
+     *
+     * @param altitudeKm satellite altitude in km
+     * @param meanMotion revolutions per day from TLE
+     * @param bstar drag term from TLE
+     * @param meanAnomaly mean anomaly at epoch (radians)
+     * @param revNumAtEpoch revolution number at TLE epoch
+     * @param ageDays days since TLE epoch (julUTC - julEpoch)
+     * @param phase orbital phase in radians (from SGP4/SDP4 output)
+     * @param satPosECI satellite ECI position [x, y, z]
+     * @param satVelECI satellite ECI velocity [vx, vy, vz]
+     * @param sunPosECI sun ECI position [x, y, z]
+     */
+    fun computeOrbitalMetadata(
+        altitudeKm: Double,
+        meanMotion: Double,
+        bstar: Double,
+        meanAnomaly: Double,
+        revNumAtEpoch: Int,
+        ageDays: Double,
+        phase: Double,
+        satPosECI: DoubleArray,
+        satVelECI: DoubleArray,
+        sunPosECI: DoubleArray
+    ): OrbitalMetadata {
+        // Footprint diameter (km)
+        val footprint = 12756.33 * acos(EARTH_RADIUS / (EARTH_RADIUS + altitudeKm))
+
+        // Orbit number
+        val xmnpda = 1.44E3
+        val orbitNum = floor(
+            (meanMotion * xmnpda / TWO_PI + ageDays * bstar) * ageDays + meanAnomaly / TWO_PI
+        ).toLong() + revNumAtEpoch
+
+        // Beta angle: angle between orbital plane and Sun direction
+        // Orbital plane normal = cross(pos, vel)
+        val nx = satPosECI[1] * satVelECI[2] - satPosECI[2] * satVelECI[1]
+        val ny = satPosECI[2] * satVelECI[0] - satPosECI[0] * satVelECI[2]
+        val nz = satPosECI[0] * satVelECI[1] - satPosECI[1] * satVelECI[0]
+        val nMag = sqrt(nx * nx + ny * ny + nz * nz)
+        val sMag = sqrt(sunPosECI[0] * sunPosECI[0] + sunPosECI[1] * sunPosECI[1] + sunPosECI[2] * sunPosECI[2])
+        val dotNS = nx * sunPosECI[0] + ny * sunPosECI[1] + nz * sunPosECI[2]
+        val betaAngle = if (nMag > 0 && sMag > 0) {
+            (PI / 2.0 - acos(dotNS / (nMag * sMag))).toDegrees()
+        } else 0.0
+
+        // Phase (0-256 scale, matching PREDICT convention)
+        val orbitalPhase = 256.0 * (phase / TWO_PI)
+
+        return OrbitalMetadata(footprint, orbitNum, betaAngle, orbitalPhase)
+    }
+
+    // ── Satellite status checks ──
+
+    /** Check if a satellite is geostationary (mean motion ≈ 1.0027 rev/day). */
+    fun isGeostationary(meanMotion: Double): Boolean = abs(meanMotion - 1.0027) < 0.0002
+
+    /**
+     * Check if a satellite has likely decayed based on drag and time since epoch.
+     *
+     * @param meanMotion revolutions per day
+     * @param drag first derivative of mean motion / 2 (from TLE line 1)
+     * @param epochDaynum TLE epoch as daynum (days since 31Dec79)
+     * @param currentDaynum current time as daynum
+     */
+    fun hasDecayed(meanMotion: Double, drag: Double, epochDaynum: Double, currentDaynum: Double): Boolean {
+        return epochDaynum + ((16.666666 - meanMotion) / (10.0 * abs(drag))) < currentDaynum
+    }
+
+    // ── Rise/Set finding ──
+
+    /** Rise and set times for a celestial body. */
+    data class RiseSetTimes(
+        val riseTimeMillis: Long,  // 0 if not found
+        val setTimeMillis: Long    // 0 if not found
+    )
+
+    /**
+     * Find the next sunrise and sunset times from [startMillis] for [observer].
+     * Uses elevation threshold of -0.8333° to match the standard civil definition:
+     * upper limb on geometric horizon with standard atmospheric refraction (~0.57°)
+     * and solar semidiameter (~0.27°) corrections applied, matching USNO/timeanddate.com.
+     */
+    fun findSunRiseSet(observer: GeoPos, startMillis: Long): RiseSetTimes {
+        // Standard civil threshold: center elevation when upper limb meets geometric horizon
+        // -0.8333° = standard refraction (~0.5667°) + solar semidiameter (~0.2667°)
+        val threshold = 0.8333
+        var daynum = millisToDaynum(startMillis)
+        var sunPos = getSunPosition(observer, daynumToMillis(daynum))
+
+        // Phase 1: if sun is above threshold, fast-forward to well past sunset into night
+        if (sunPos.elevation > -threshold) {
+            var guard = 0
+            while (sunPos.elevation > -threshold && guard++ < 500) {
+                daynum += 0.008  // fixed ~11.5 min steps past the setting sun
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+            // Now advance until sun is clearly below minimum (deep night)
+            guard = 0
+            while (sunPos.elevation > -12.0 && guard++ < 500) {
+                daynum += 0.02
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+        }
+
+        // Phase 2: advance until sun starts rising toward threshold (elevation increasing)
+        var guard = 0
+        while (sunPos.elevation < -threshold && guard++ < 500) {
+            daynum += 0.008
+            sunPos = getSunPosition(observer, daynumToMillis(daynum))
+        }
+
+        // Phase 3: converge symmetrically on elevation = -threshold (sunrise)
+        var sunrise = 0.0
+        guard = 0
+        while (sunrise == 0.0 && guard++ < 200) {
+            val delta = sunPos.elevation + threshold
+            if (abs(delta) < 0.01) {
+                sunrise = daynum
+            } else {
+                daynum -= 0.004 * delta
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (sunrise == 0.0) sunrise = daynum
+
+        // Phase 4: fast-forward through the day until sun drops back below threshold
+        daynum = sunrise
+        sunPos = getSunPosition(observer, daynumToMillis(daynum))
+        guard = 0
+        while (sunPos.elevation > -threshold && guard++ < 500) {
+            daynum += 0.008
+            sunPos = getSunPosition(observer, daynumToMillis(daynum))
+        }
+
+        // Phase 5: converge symmetrically on elevation = -threshold (sunset)
+        var sunset = 0.0
+        guard = 0
+        while (sunset == 0.0 && guard++ < 200) {
+            val delta = sunPos.elevation + threshold
+            if (abs(delta) < 0.01) {
+                sunset = daynum
+            } else {
+                daynum += 0.004 * delta
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (sunset == 0.0) sunset = daynum
+
+        return RiseSetTimes(daynumToMillis(sunrise), daynumToMillis(sunset))
+    }
+
+    /**
+     * Find the next moonrise and moonset times from [startMillis] for [observer].
+     * Uses the adaptive iteration from PREDICT v2.2.5's PredictMoon().
+     */
+    fun findMoonRiseSet(observer: GeoPos, startMillis: Long): RiseSetTimes {
+        var daynum = millisToDaynum(startMillis)
+        var moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+
+        // If moon is already up, move forward until it sets
+        var guard = 0
+        if (moonPos.elevation > 0) {
+            while (moonPos.elevation > 0 && guard++ < 1000) {
+                daynum += 0.004 * sin(DEG2RAD * (moonPos.elevation + 0.5))
+                moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+            }
+            daynum += 0.4
+            moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+        }
+        // Find moonrise
+        var moonrise = 0.0
+        guard = 0
+        while (moonrise == 0.0 && guard++ < 1000) {
+            if (abs(moonPos.elevation) < 0.03) {
+                moonrise = daynum
+            } else {
+                daynum -= 0.004 * moonPos.elevation
+                moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (moonrise == 0.0) moonrise = daynum
+
+        // Find moonset from moonrise
+        daynum = moonrise
+        moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+        guard = 0
+        while (moonPos.elevation > -1 && guard++ < 1000) {
+            daynum += 0.04 * cos(DEG2RAD * (moonPos.elevation + 0.5))
+            moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+        }
+        var moonset = 0.0
+        guard = 0
+        while (moonset == 0.0 && guard++ < 1000) {
+            if (abs(moonPos.elevation) < 0.03) {
+                moonset = daynum
+            } else {
+                daynum += 0.004 * moonPos.elevation
+                moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (moonset == 0.0) moonset = daynum
+
+        return RiseSetTimes(daynumToMillis(moonrise), daynumToMillis(moonset))
+    }
+
+    // ── Visual magnitude estimation ──
+
+    /**
+     * Estimate the apparent visual magnitude of a satellite.
+     *
+     * Uses the standard formula from McCants/Heavens-Above:
+     *   apparentMag = stdMag + 5 * log10(range / 1000) - 15 * log10(cos(phaseAngle / 2))
+     *
+     * @param rangeKm slant range from observer to satellite in km
+     * @param phaseAngleDeg Sun-satellite-observer angle in degrees
+     * @param stdMag intrinsic/standard magnitude (default 4.0)
+     * @return estimated apparent visual magnitude
+     */
+    fun estimateVisualMagnitude(rangeKm: Double, phaseAngleDeg: Double, stdMag: Double = 4.0): Double {
+        if (rangeKm <= 0) return stdMag
+        val halfPhaseRad = phaseAngleDeg.toRadians() / 2.0
+        val cosHalfPhase = cos(halfPhaseRad)
+        val phaseTerm = if (cosHalfPhase > 1e-6) -15.0 * log10(cosHalfPhase) else 99.0
+        return stdMag + 5.0 * log10(rangeKm / 1000.0) + phaseTerm
+    }
+
+    /**
+     * Compute the phase angle (Sun-satellite-observer) in degrees.
+     *
+     * @param satPosECI satellite ECI position [x, y, z] in km
+     * @param sunPosECI sun ECI position [x, y, z] in km
+     * @param obsPosECI observer ECI position [x, y, z] in km
+     * @return phase angle in degrees (0 = fully illuminated face toward observer)
+     */
+    fun computePhaseAngle(satPosECI: DoubleArray, sunPosECI: DoubleArray, obsPosECI: DoubleArray): Double {
+        val toSunX = sunPosECI[0] - satPosECI[0]
+        val toSunY = sunPosECI[1] - satPosECI[1]
+        val toSunZ = sunPosECI[2] - satPosECI[2]
+        val toObsX = obsPosECI[0] - satPosECI[0]
+        val toObsY = obsPosECI[1] - satPosECI[1]
+        val toObsZ = obsPosECI[2] - satPosECI[2]
+        val dot = toSunX * toObsX + toSunY * toObsY + toSunZ * toObsZ
+        val magSun = sqrt(toSunX * toSunX + toSunY * toSunY + toSunZ * toSunZ)
+        val magObs = sqrt(toObsX * toObsX + toObsY * toObsY + toObsZ * toObsZ)
+        if (magSun == 0.0 || magObs == 0.0) return 90.0
+        val cosAngle = (dot / (magSun * magObs)).coerceIn(-1.0, 1.0)
+        return acos(cosAngle).toDegrees()
+    }
+
+    // ── Doppler ──
+
+    /**
+     * Compute Doppler shift for a given base frequency and range rate.
+     *
+     * @param frequencyHz base frequency in Hz
+     * @param rangeRateKmS range rate in km/s (negative = approaching)
+     * @return shifted frequency in Hz
+     */
+    fun dopplerShift(frequencyHz: Double, rangeRateKmS: Double): Double {
+        return frequencyHz * (299792.458 - rangeRateKmS) / 299792.458
+    }
+
+    // ── Internal helpers ──
+
+    private fun observerGeodetic(pos: GeoPos): DoubleArray {
+        // [lat_rad, lon_rad, alt_km] — longitude positive east, matching OrbitalObject convention.
+        // LST = thetaGJD(julUtc) + obsGeo[1] = GMST + lon_rad (correct).
+        return doubleArrayOf(pos.latitude * DEG2RAD, pos.longitude * DEG2RAD, pos.altitude / 1000.0)
+    }
+
+    /**
+     * Convert az/el observation to Right Ascension / Declination.
+     * Returns [ra_rad, dec_rad].
+     * Based on Calculate_RADec() from PREDICT v2.2.5 (Escobal method).
+     */
+    private fun calculateRADec(
+        julUtc: Double,
+        targetPos: DoubleArray,
+        targetVel: DoubleArray,
+        obsGeo: DoubleArray
+    ): DoubleArray {
+        val obsSet = computeObsAngles(julUtc, targetPos, targetVel, obsGeo)
+        val az = obsSet[0]
+        val el = obsSet[1]
+        val phi = obsGeo[0]
+        val theta = mod2PI(thetaGJD(julUtc) + obsGeo[1])
+        val sinTheta = sin(theta)
+        val cosTheta = cos(theta)
+        val sinPhi = sin(phi)
+        val cosPhi = cos(phi)
+        val lxh = -cos(az) * cos(el)
+        val lyh = sin(az) * cos(el)
+        val lzh = sin(el)
+        val sx = sinPhi * cosTheta
+        val ex2 = -sinTheta
+        val zx = cosTheta * cosPhi
+        val sy = sinPhi * sinTheta
+        val zy = sinTheta * cosPhi
+        val sz = -cosPhi
+        val lx = sx * lxh + ex2 * lyh + zx * lzh
+        val ly = sy * lxh + cosTheta * lyh + zy * lzh
+        val lz = sz * lxh + 0.0 * lyh + sinPhi * lzh
+        val dec = asin(lz)
+        val cosDelta = sqrt(1.0 - lz * lz)
+        val sinAlpha = ly / cosDelta
+        val cosAlpha = lx / cosDelta
+        val ra = mod2PI(atan2(sinAlpha, cosAlpha))
+        return doubleArrayOf(ra, dec)
+    }
+
+    /**
+     * Compute observer look-angles (az, el, range, rangeRate) to a target at ECI position.
+     * Returns [azimuth_rad, elevation_rad, range_km, rangeRate_km/s].
+     * Azimuth is north-referenced (0=N, π/2=E), matching OrbitalObject's convention.
+     */
+    private fun computeObsAngles(
+        julUtc: Double,
+        targetPos: DoubleArray,
+        targetVel: DoubleArray,
+        obsGeo: DoubleArray // [lat_rad, lon_rad, alt_km]
+    ): DoubleArray {
+        val theta = mod2PI(thetaGJD(julUtc) + obsGeo[1])
+        val c = 1.0 / sqrt(1 + FLAT_FACT * (FLAT_FACT - 2) * sin(obsGeo[0]).pow(2))
+        val sq = (1 - FLAT_FACT).pow(2) * c
+        val achcp = (EARTH_RADIUS * c + obsGeo[2]) * cos(obsGeo[0])
+        val ox = achcp * cos(theta)
+        val oy = achcp * sin(theta)
+        val oz = (EARTH_RADIUS * sq + obsGeo[2]) * sin(obsGeo[0])
+        val ovx = -MFACTOR * oy
+        val ovy = MFACTOR * ox
+
+        val rx = targetPos[0] - ox
+        val ry = targetPos[1] - oy
+        val rz = targetPos[2] - oz
+        val rMag = sqrt(rx * rx + ry * ry + rz * rz)
+        val rvx = targetVel[0] - ovx
+        val rvy = targetVel[1] - ovy
+        val rvz = targetVel[2]
+
+        val sinLat = sin(obsGeo[0])
+        val cosLat = cos(obsGeo[0])
+        val sinTheta = sin(theta)
+        val cosTheta = cos(theta)
+        val topS = sinLat * cosTheta * rx + sinLat * sinTheta * ry - cosLat * rz
+        val topE = -sinTheta * rx + cosTheta * ry
+        val topZ = cosLat * cosTheta * rx + cosLat * sinTheta * ry + sinLat * rz
+
+        // Match north-based convention (0=N, 90=E) used by OrbitalObject.calculateObs
+        // Must use atan(-topE / topS) not atan2(-topE, topS) — they differ in quadrant handling
+        var azim = atan(-topE / topS)
+        if (topS > 0.0) azim += PI
+        if (azim < 0.0) azim += TWO_PI
+        val el = asin(topZ / rMag)
+        val rangeRate = (rx * rvx + ry * rvy + rz * rvz) / rMag
+
+        return doubleArrayOf(azim, el, rMag, rangeRate)
+    }
+
+    private const val MFACTOR = 7.292115E-5
+
+    private fun primeAngle(x: Double) = x - 360.0 * floor(x / 360.0)
+
+    private fun fixAngle(x: Double): Double {
+        var a = x; while (a > TWO_PI) a -= TWO_PI; return a
+    }
+}

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

@@ -21,6 +21,7 @@ const val ASTRONOMICAL_UNIT = 1.49597870691E8
 const val DEG2RAD = 0.017453292519943295
 const val RAD2DEG = 57.29577951308232
 const val EARTH_RADIUS = 6378.137
+const val EARTH_ROT_PER_SID_DAY = 1.00273790934
 const val EPSILON = 1.0E-12
 const val FLAT_FACT = 3.35281066474748E-3
 const val J3_HARMONIC = -2.53881E-6

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

@@ -97,40 +97,38 @@ class DeepSpaceObject(data: OrbitalData) : OrbitalObject(data) {
     }
 
     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)
-        }
+        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) {

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

@@ -141,53 +141,51 @@ class NearEarthObject(data: OrbitalData) : OrbitalObject(data) {
     }
 
     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)
+        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 = tSince * 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 * tempa
+        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(

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

@@ -27,7 +27,8 @@ data class OrbitalData(
     val argper: Double,
     val meanan: Double,
     val catnum: Int,
-    val bstar: Double
+    val bstar: Double,
+    val ndot: Double = 0.0
 ) {
     val xincl: Double = incl * DEG2RAD
     val xnodeo: Double = raan * DEG2RAD
@@ -37,4 +38,29 @@ data class OrbitalData(
     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)
+
+    /** Check if satellite has likely decayed by the given time. */
+    fun hasDecayed(currentTimeMillis: Long): Boolean {
+        if (ndot == 0.0) return false
+        val currentDaynum = (currentTimeMillis - 315446400000L) / 86400000.0
+        val epochDaynum = epochToDaynum(epoch)
+        return CelestialComputer.hasDecayed(meanmo, ndot, epochDaynum, currentDaynum)
+    }
+
+    private fun epochToDaynum(epoch: Double): Double {
+        var year = kotlin.math.floor(epoch * 1E-3)
+        val day = (epoch * 1E-3 - year) * 1000.0
+        year = if (year < 57) year + 2000 else year + 1900
+        // daynum = days since 31 Dec 1979, Julian date of 31Dec79 = 2444238.5
+        val jan1Jd = julianDateOfYear(year)
+        return jan1Jd + day - 2444238.5
+    }
+
+    private fun julianDateOfYear(theYear: Double): Double {
+        val aYear = theYear - 1
+        val a = kotlin.math.floor(aYear / 100).toLong()
+        val b = 2 - a + a / 4
+        val i = kotlin.math.floor(365.25 * aYear).toLong()
+        return i + (30.6001 * 14).toLong() + 1720994.5 + b
+    }
 }

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

@@ -0,0 +1,141 @@
+/*
+ * 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.sin
+import kotlin.math.sqrt
+
+// ── Shared orbital math utilities ──
+// Used by both CelestialComputer (sun/moon/celestial) and OrbitalObject (SGP4/SDP4).
+// Package-internal — not part of the public API.
+
+/**
+ * Greenwich Mean Sidereal Time from Julian Date, in radians [0, 2π).
+ * Identical algorithm used in PREDICT v2.2.5 for both solar and satellite calculations.
+ */
+internal fun thetaGJD(jd: Double): Double {
+    val ut = fraction(jd + 0.5)
+    val aJD = jd - 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 * EARTH_ROT_PER_SID_DAY * ut, SEC_PER_DAY)
+    return TWO_PI * gmst / SEC_PER_DAY
+}
+
+/** Fractional part of [arg]. */
+internal fun fraction(arg: Double): Double = arg - floor(arg)
+
+/** Modulo: returns [arg1] mod [arg2], result always in [0, arg2). */
+internal fun modulus(arg1: Double, arg2: Double): Double {
+    var r = arg1
+    val i = floor(r / arg2).toInt()
+    r -= i * arg2
+    if (r < 0.0) r += arg2
+    return r
+}
+
+/** Reduce [value] to [0, 2π). */
+internal fun mod2PI(value: Double): Double {
+    var r = value
+    val i = (r / TWO_PI).toInt()
+    r -= i * TWO_PI
+    if (r < 0.0) r += TWO_PI
+    return r
+}
+
+/**
+ * Delta-ET: difference between Universal Time and Ephemeris Time (seconds).
+ * Based on least-squares fit from 1950 to 1991 (PREDICT v2.2.5).
+ */
+internal fun deltaET(year: Double): Double =
+    26.465 + 0.747622 * (year - 1950) + 1.886913 * sin(TWO_PI * (year - 1975) / 33)
+
+/**
+ * Convert Unix epoch milliseconds to daynum (days since 31 Dec 1979 00:00:00 UTC).
+ */
+internal fun millisToDaynum(timeMillis: Long): Double =
+    (timeMillis - 315446400000L) / 86400000.0
+
+/** Convert daynum back to Unix epoch milliseconds. */
+internal fun daynumToMillis(daynum: Double): Long =
+    ((daynum + 3651.0) * 86400000.0).toLong()
+
+/**
+ * Compute the Sun's ECI position vector at [julUtc] (Julian UTC).
+ * Returns [x, y, z, magnitude] in km.
+ * Based on Calculate_Solar_Position() / FindSun() from PREDICT v2.2.5.
+ */
+internal fun solarPositionECI(julUtc: Double): DoubleArray {
+    val mjd = julUtc - 2415020.0
+    val year = 1900 + mjd / 365.25
+    val t = (mjd + deltaET(year) / SEC_PER_DAY) / 36525.0
+    val mDeg = mod360(358.47583 + mod360(35999.04975 * t) - (0.000150 + 0.0000033 * t) * t * t)
+    val m = mDeg * DEG2RAD
+    val lDeg = mod360(279.69668 + mod360(36000.76892 * t) + 0.0003025 * t * t)
+    val l = lDeg * DEG2RAD
+    val e = 0.01675104 - (0.0000418 + 0.000000126 * t) * t
+    val cDeg = (1.919460 - (0.004789 + 0.000014 * t) * t) * sin(m) +
+        (0.020094 - 0.000100 * t) * sin(2 * m) + 0.000293 * sin(3 * m)
+    val c = cDeg * DEG2RAD
+    val oDeg = mod360(259.18 - 1934.142 * t)
+    val o = oDeg * DEG2RAD
+    val lsa = mod2PI(l + c - (0.00569 - 0.00479 * sin(o)) * DEG2RAD)
+    val nu = mod2PI(m + c)
+    var r = 1.0000002 * (1.0 - e * e) / (1.0 + e * cos(nu))
+    val epsDeg = 23.452294 - (0.0130125 + (0.00000164 - 0.000000503 * t) * t) * t + 0.00256 * cos(o)
+    val eps = epsDeg * DEG2RAD
+    r *= ASTRONOMICAL_UNIT
+    return doubleArrayOf(r * cos(lsa), r * sin(lsa) * cos(eps), r * sin(lsa) * sin(eps), r)
+}
+
+/**
+ * Convert ECI position [eciPos] = [x, y, z] (km) to geodetic [lat_rad, lon_rad, alt_km].
+ * Based on Calculate_LatLonAlt() from PREDICT v2.2.5.
+ */
+internal fun eciToGeodetic(julUtc: Double, eciPos: DoubleArray): DoubleArray {
+    val thetaPos = atan2(eciPos[1], eciPos[0])
+    val lon = mod2PI(thetaPos - thetaGJD(julUtc))
+    val r = sqrt(eciPos[0] * eciPos[0] + eciPos[1] * eciPos[1])
+    val e2 = FLAT_FACT * (2.0 - FLAT_FACT)
+    var lat = atan2(eciPos[2], r)
+    var phi: Double
+    var c: Double
+    var i = 0
+    do {
+        phi = lat
+        c = 1.0 / sqrt(1.0 - e2 * sin(phi) * sin(phi))
+        lat = atan2(eciPos[2] + EARTH_RADIUS * c * e2 * sin(phi), r)
+    } while (i++ < 10 && abs(lat - phi) >= 1E-10)
+    val alt = r / cos(lat) - EARTH_RADIUS * c
+    if (lat > PI_2) lat -= TWO_PI
+    return doubleArrayOf(lat, lon, alt)
+}
+
+// Private helpers
+
+private fun mod360(x: Double): Double {
+    var r = x
+    val i = (r / 360.0).toInt()
+    r -= i * 360.0
+    if (r < 0.0) r += 360.0
+    return r
+}

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

@@ -42,6 +42,27 @@ abstract class OrbitalObject(val data: OrbitalData) {
     var qoms24 = 0.0
     var s4 = 0.0
 
+    // Pre-allocated reusable vectors to avoid GC pressure in hot loops
+    private val obsPos = Vector4()
+    private val obsVel = Vector4()
+    private val rangeVector = Vector4()
+    private val rgvelVector = Vector4()
+    private val squintVector = Vector4()
+
+    // Cached observer position data to avoid recalculation when observer hasn't moved
+    private var cachedGsLat = Double.NaN
+    private var cachedGsLon = Double.NaN
+    private var cachedGsAlt = Double.NaN
+    private var cachedSinLat = 0.0
+    private var cachedCosLat = 0.0
+    private var cachedObsC = 0.0
+    private var cachedObsSq = 0.0
+    private var cachedObsAchFactor = 0.0
+    private var cachedObsZFactor = 0.0
+
+    // Cache for julian epoch to avoid recomputing every call
+    private val julEpoch: Double = juliandDateOfEpoch(data.epoch)
+
     fun willBeSeen(pos: GeoPos): Boolean {
         return if (data.meanmo < 1e-8) false
         else {
@@ -57,15 +78,13 @@ abstract class OrbitalObject(val data: OrbitalData) {
         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)
+        // Calculate time since epoch in minutes
         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)
@@ -75,6 +94,38 @@ abstract class OrbitalObject(val data: OrbitalData) {
         return orbitalPos
     }
 
+    /**
+     * Lightweight elevation-only check for pass finding. Avoids full lat/lon/alt,
+     * eclipse, and squint calculations that aren't needed when just searching for
+     * horizon crossings.
+     */
+    fun getElevation(pos: GeoPos, time: Long): Double {
+        julUTC = calcCurrentDaynum(time) + 2444238.5
+        val tsince = (julUTC - julEpoch) * MIN_PER_DAY
+        calculateSDP4orSGP4(tsince)
+        convertSatState(position, velocity)
+        magnitude(velocity)
+        calculateObs(julUTC, position, velocity, pos, squintVector)
+        return orbitalPos.elevation
+    }
+
+    /**
+     * Full position calculation that also populates azimuth, altitude, etc.
+     * Used when we need all fields (AOS/LOS refinement, track computation).
+     */
+    fun getFullPosition(pos: GeoPos, time: Long): OrbitalPos {
+        orbitalPos = OrbitalPos()
+        julUTC = calcCurrentDaynum(time) + 2444238.5
+        val tsince = (julUTC - julEpoch) * MIN_PER_DAY
+        calculateSDP4orSGP4(tsince)
+        convertSatState(position, velocity)
+        magnitude(velocity)
+        calculateObs(julUTC, position, velocity, pos, squintVector)
+        calculateLatLonAlt(julUTC)
+        orbitalPos.time = time
+        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
@@ -117,38 +168,34 @@ abstract class OrbitalObject(val data: OrbitalData) {
         gsPos: GeoPos,
         squintVector: Vector4
     ) {
-        val obsPos = Vector4()
-        val obsVel = Vector4()
-        val range = Vector4()
-        val rgvel = Vector4()
         calculateUserPosVel(julianUTC, gsPos, obsPos, obsVel)
-        range.setXYZ(
+        rangeVector.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(
+        squintVector.setXYZ(rangeVector.x, rangeVector.y, rangeVector.z)
+        rgvelVector.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)
+        magnitude(rangeVector)
+        val sinLat = cachedSinLat
+        val cosLat = cachedCosLat
         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
+        val topS = sinLat * cosTheta * rangeVector.x + sinLat * sinTheta * rangeVector.y - cosLat * rangeVector.z
+        val topE = -sinTheta * rangeVector.x + cosTheta * rangeVector.y
+        val topZ = cosLat * cosTheta * rangeVector.x + cosLat * sinTheta * rangeVector.y + sinLat * rangeVector.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
+        orbitalPos.elevation = asin(topZ / rangeVector.w)
+        orbitalPos.distance = rangeVector.w
+        orbitalPos.distanceRate = dot(rangeVector, rgvelVector) / rangeVector.w
         var elevation = orbitalPos.elevation / TWO_PI * 360.0
         if (elevation > 90) elevation = 180 - elevation
         orbitalPos.aboveHorizon = elevation - 0 > EPSILON
@@ -163,12 +210,24 @@ abstract class OrbitalObject(val data: OrbitalData) {
     ) {
         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)
+
+        // Cache trig and position factors when observer position changes
+        if (gsPos.latitude != cachedGsLat || gsPos.longitude != cachedGsLon || gsPos.altitude != cachedGsAlt) {
+            cachedGsLat = gsPos.latitude
+            cachedGsLon = gsPos.longitude
+            cachedGsAlt = gsPos.altitude
+            cachedSinLat = sin(DEG2RAD * gsPos.latitude)
+            cachedCosLat = cos(DEG2RAD * gsPos.latitude)
+            cachedObsC = invert(sqrt(1.0 + FLAT_FACT * (FLAT_FACT - 2) * sqr(cachedSinLat)))
+            cachedObsSq = sqr(1.0 - FLAT_FACT) * cachedObsC
+            cachedObsAchFactor = (EARTH_RADIUS * cachedObsC + gsPos.altitude / 1000.0) * cachedCosLat
+            cachedObsZFactor = (EARTH_RADIUS * cachedObsSq + gsPos.altitude / 1000.0) * cachedSinLat
+        }
+
         obsPos.setXYZ(
-            achcp * cos(gsPosTheta), achcp * sin(gsPosTheta),
-            (EARTH_RADIUS * sq + gsPos.altitude / 1000.0) * sin(DEG2RAD * gsPos.latitude)
+            cachedObsAchFactor * cos(gsPosTheta),
+            cachedObsAchFactor * sin(gsPosTheta),
+            cachedObsZFactor
         )
         obsVel.setXYZ(-mFactor * obsPos.y, mFactor * obsPos.x, 0.0)
         magnitude(obsPos)
@@ -255,14 +314,8 @@ abstract class OrbitalObject(val data: OrbitalData) {
         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
-    }
+    // Delegates to package-level mod2PI in OrbitalMath.kt
+    internal fun mod2PI(value: Double): Double = com.rtbishop.look4sat.core.domain.predict.mod2PI(value)
 
     // Solves Keplers' Equation
     internal fun converge(temp: DoubleArray, axn: Double, ayn: Double, capu: Double) {
@@ -364,19 +417,8 @@ abstract class OrbitalObject(val data: OrbitalData) {
         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))
-    }
+    // Delegates to package-level deltaET in OrbitalMath.kt
+    private fun deltaEt(year: Double): Double = deltaET(year)
 
     private fun radians(degrees: Double): Double {
         return degrees * DEG2RAD
@@ -387,23 +429,13 @@ abstract class OrbitalObject(val data: OrbitalData) {
         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
-    }
+    private fun modulus(arg1: Double, arg2: Double = SEC_PER_DAY): Double =
+        com.rtbishop.look4sat.core.domain.predict.modulus(arg1, arg2)
 
     // Multiplies the vector v1 by the scalar k
     private fun scaleVector(k: Double, v: Vector4) {
@@ -411,13 +443,6 @@ abstract class OrbitalObject(val data: OrbitalData) {
         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
-    }
+    // Delegates to package-level thetaGJD in OrbitalMath.kt
+    private fun thetaGJD(theJD: Double): Double = com.rtbishop.look4sat.core.domain.predict.thetaGJD(theJD)
 }

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

@@ -25,9 +25,10 @@ data class OrbitalPass(
     val altitude: Int = 1000,
     val maxElevation: Double = 75.0,
     val orbitalObject: OrbitalObject,
-    var progress: Float = 0.0f
+    val progress: Float = 0.0f,
+    val hasDecayed: Boolean = false
 ) {
     val catNum: Int = orbitalObject.data.catnum
-    val name: String = orbitalObject.data.name
+    val name: String = if (hasDecayed) "${orbitalObject.data.name} (decayed?)" else orbitalObject.data.name
     val isDeepSpace: Boolean = orbitalObject.data.isDeepSpace
 }

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

@@ -21,7 +21,6 @@ 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
 
@@ -50,23 +49,30 @@ data class OrbitalPos(
     }
 
     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
+        val radius = EARTH_RADIUS_M + altitude * 1000.0
+        return sqrt(GM_EARTH / radius) / 1000.0
     }
 
     fun getRangeCircle(): List<GeoPos> {
-        val rangeCirclePoints = mutableListOf<GeoPos>()
-        val beta = acos(EARTH_RADIUS / (EARTH_RADIUS + altitude)) // * EARTH_RADIUS = radiusKm
+        val pointCount = 721
+        val rangeCirclePoints = ArrayList<GeoPos>(pointCount)
+        val beta = acos(EARTH_RADIUS / (EARTH_RADIUS + altitude))
+        val sinLat = sin(latitude)
+        val cosLat = cos(latitude)
+        val cosBeta = cos(beta)
+        val sinBeta = sin(beta)
         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)
-            ))
+            val lat = asin(sinLat * cosBeta + cosLat * sinBeta * cos(rads))
+            val lon = longitude + atan2(sin(rads) * sinBeta * cosLat, cosBeta - sinLat * sin(lat))
             rangeCirclePoints.add(GeoPos(lat * RAD2DEG, lon * RAD2DEG))
         }
         return rangeCirclePoints
     }
+
+    companion object {
+        // Pre-computed constants for orbital velocity calculation
+        private const val GM_EARTH = 3.986004418E14 // m^3/s^2
+        private const val EARTH_RADIUS_M = 6.37E6 // meters
+    }
 }

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

@@ -1,6 +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
 
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
 import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import kotlinx.coroutines.CoroutineScope
 
@@ -10,11 +29,16 @@ interface IMainContainer {
     val selectionRepo: ISelectionRepo
     val satelliteRepo: ISatelliteRepo
     val databaseRepo: IDatabaseRepo
+    val radioTrackingService: IRadioTrackingService
     fun provideAddToCalendar(): IAddToCalendar
     fun provideShowToast(): IShowToast
-    fun provideBluetoothReporter(): IReporterRepo<WithoutExtParams>
-    fun provideNetworkReporter(): IReporterRepo<ExtendedParams>
+    fun provideBluetoothReporter(): IReporter
+    fun provideNetworkReporter(): IReporter
     fun provideSensorsRepo(): ISensorsRepo
+    fun provideTxRadioController(): IRadioController
+    fun provideRxRadioController(): IRadioController
+    fun provideAudioCapture(): IAudioCapture
+    fun provideSaveImage(): ISaveImage
 }
 
 interface IContainerProvider {

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/IRadioController.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.domain.repository
+
+interface IRadioController {
+
+    val isConnected: Boolean
+
+    suspend fun connect(): Boolean
+
+    suspend fun disconnect()
+
+    suspend fun setFrequency(frequencyHz: Long): Boolean
+
+    suspend fun setMode(mode: String): Boolean
+
+    suspend fun setCtcssMode(enabled: Boolean): Boolean
+
+    suspend fun setCtcssTone(toneHz: Double): Boolean
+
+    suspend fun readFrequencyAndMode(): Pair<Long, String>?
+
+    suspend fun pttOn(): Boolean
+
+    suspend fun pttOff(): Boolean
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/IRadioTrackingService.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.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import kotlinx.coroutines.flow.StateFlow
+
+data class RadioTrackingState(
+    val isActive: Boolean = false,
+    val txConnected: Boolean = false,
+    val rxConnected: Boolean = false,
+    val txFrequencyHz: Long? = null,
+    val rxFrequencyHz: Long? = null,
+    val txMode: String? = null,
+    val rxMode: String? = null,
+    val ctcssTone: Double? = null,
+    val txBaseFrequencyHz: Long? = null,
+    val selectedTransponder: SatRadio? = null,
+    val currentPass: OrbitalPass? = null,
+    val azimuth: Double = 0.0,
+    val elevation: Double = 0.0,
+    val distance: Double = 0.0,
+    val errorMessage: String? = null
+)
+
+interface IRadioTrackingService {
+    val state: StateFlow<RadioTrackingState>
+
+    suspend fun connectRadios()
+    suspend fun disconnectRadios()
+    fun startTracking(pass: OrbitalPass, transponder: SatRadio, txBaseFreqHz: Long?)
+    fun stopTracking()
+    fun setTransponder(transponder: SatRadio)
+    fun setTxBaseFrequency(frequencyHz: Long)
+    fun adjustTxBaseFrequency(deltaHz: Long)
+    fun setCtcssTone(toneHz: Double?)
+    fun setMode(txMode: String, rxMode: String)
+}

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

@@ -17,18 +17,7 @@
  */
 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)
+interface IReporter {
+    fun reportRotation(format: String, azimuth: Double, elevation: Double)
+    fun reportFrequency(format: String, frequency: Long)
 }
-
-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

@@ -25,13 +25,36 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import kotlinx.coroutines.flow.StateFlow
 
 interface ISatelliteRepo {
-    val passes: StateFlow<List<OrbitalPass>>
+    /** All selected OrbitalObjects, updated when the selection changes. */
     val satellites: StateFlow<List<OrbitalObject>>
-    suspend fun getRadiosWithId(id: Int): List<SatRadio>
+
+    /** Raw calculated passes (without live progress). Updated on selection/filter change. */
+    val passes: StateFlow<List<OrbitalPass>>
+
+    /** Whether the repo is currently calculating passes. */
+    val isCalculating: StateFlow<Boolean>
+
+    /** Currently selected pass (catNum + aosTime), persisted across screen navigations. */
+    val selectedPass: StateFlow<Pair<Int, Long>>
+
+    /** Set the currently selected pass. */
+    fun selectPass(catNum: Int, aosTime: Long)
+
+    /** Load satellite objects from DB based on the current selection. */
     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>
+
+    /** Recalculate passes with the given filter parameters. */
     suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>)
+
+    /** Get the current position of a single satellite. */
+    suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos
+
+    /** Get the ground track for a satellite over a time range. */
+    suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos>
+
+    /** Get Doppler-shifted radio frequencies for a satellite at the given time. */
+    suspend fun getRadios(sat: OrbitalObject, pos: GeoPos, radios: List<SatRadio>, time: Long): List<SatRadio>
+
+    /** Fetch radio transceivers for a satellite by its catalog number. */
+    suspend fun getRadiosWithId(id: Int): List<SatRadio>
 }

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

@@ -21,7 +21,7 @@ import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import kotlinx.coroutines.flow.StateFlow
 
 interface ISensorsRepo {
-    val orientation: StateFlow<Pair<Float, Float>>
+    val sensorData: 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

@@ -22,6 +22,7 @@ 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.model.RadioControlSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import kotlinx.coroutines.flow.StateFlow
 
@@ -57,39 +58,23 @@ interface ISettingsRepo {
 
     //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)
+    fun updateRCSettings(settings: RCSettings)
     //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()
+    fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings)
+    fun setWarningDismissed() = updateOtherSettings { it.copy(shouldSeeWarning = false) }
+    fun setWhatsNewDismissed() = updateOtherSettings { it.copy(shouldSeeWhatsNew = false) }
     //endregion
 
     //region # Transceivers settings
     val dataSourcesSettings: StateFlow<DataSourcesSettings>
-    fun setUseCustomTle(value: Boolean)
-    fun setUseCustomTransceivers(value: Boolean)
-    fun setTleUrl(value: String)
-    fun setTransceiversUrl(value: String)
+    fun updateDataSourcesSettings(settings: DataSourcesSettings)
+    //endregion
+
+    //region # Radio control settings
+    val radioControlSettings: StateFlow<RadioControlSettings>
+    fun updateRadioControlSettings(settings: RadioControlSettings)
     //endregion
 }

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

@@ -18,7 +18,6 @@
 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",
@@ -49,4 +48,7 @@ object Sources {
         "R4UAB" to "https://r4uab.ru/satonline.txt",
         "Other" to "" // key for sats filter
     )
+    val transceiversDataUrls = mapOf(
+        "SatNOGS" to "https://db.satnogs.org/api/transmitters/?format=json&status=active"
+    )
 }

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/sstv/SstvDecoder.kt

@@ -0,0 +1,611 @@
+/*
+ * 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.sstv
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.withContext
+import kotlin.math.abs
+import kotlin.math.round
+import kotlin.math.sqrt
+
+class SstvFrame(
+    val imagePixels: IntArray?,
+    val imageWidth: Int,
+    val imageHeight: Int,
+    val modeName: String
+)
+
+class SstvDecoder(
+    sampleRate: Int = 44100,
+    scopeWidth: Int = 320,
+    scopeHeight: Int = 256,
+    private val channelSelect: Int = 0
+) {
+    private val scopeBuffer = PixelBuffer(scopeWidth, scopeHeight * 2)
+    private val imageBuffer = PixelBuffer(scopeWidth, scopeHeight)
+    private val decoder = DecoderEngine(scopeBuffer, imageBuffer, "Raw", sampleRate)
+    private val _frames = MutableSharedFlow<SstvFrame>(
+        replay = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
+    )
+    val frames: SharedFlow<SstvFrame> = _frames
+    val supportedModes: List<String> = decoder.allModes.map { it.name }
+
+    suspend fun feedSamples(samples: FloatArray) = withContext(Dispatchers.Default) {
+        // Normalize to a fixed RMS before processing so that both direct audio
+        // coupling and air-coupled microphone input decode with equal reliability.
+        normalise(samples)
+        val hasNewLines = decoder.process(samples, channelSelect)
+        if (hasNewLines) emitFrame()
+    }
+
+    fun lockMode(modeName: String) = decoder.setMode(modeName)
+
+    fun clearPixels() {
+        imageBuffer.line = -1
+        imageBuffer.pixels.fill(0)
+    }
+
+    private fun emitFrame() {
+        val imageWidth = imageBuffer.width
+        val imageHeight = imageBuffer.height
+        // Copy only the active image region — imageBuffer.pixels is pre-allocated
+        // at the maximum possible size (PD-290: 800×616), so we must not copyOf()
+        // the entire array and send padding pixels to the observer.
+        val imagePixels = if (imageBuffer.line > 0) imageBuffer.pixels.copyOf(imageWidth * imageHeight) else null
+        val modeName = decoder.currentMode.name
+        _frames.tryEmit(SstvFrame(imagePixels, imageWidth, imageHeight, modeName))
+    }
+
+    // Target RMS level for the normalizer. 0.25 leaves headroom while keeping the
+    // FM demodulator well above its noise floor regardless of input gain.
+    private val targetRms = 0.25f
+
+    // Bring the buffer to a fixed RMS so that microphone and direct-coupled inputs
+    // both decode reliably. The guard prevents amplifying pure silence into noise.
+    private fun normalise(buffer: FloatArray) {
+        var sumSq = 0f
+        for (s in buffer) sumSq += s * s
+        val rms = sqrt(sumSq / buffer.size)
+        if (rms > 1e-6f) {
+            val gain = targetRms / rms
+            for (i in buffer.indices) buffer[i] *= gain
+        }
+    }
+}
+
+internal enum class SyncPulseWidth { FiveMs, NineMs, TwentyMs }
+
+internal class SyncPulseDetector(sampleRate: Int) {
+
+    companion object {
+        const val SYNC_FREQ = 1200.0
+        const val BLACK_FREQ = 1500.0
+        const val WHITE_FREQ = 2300.0
+    }
+
+    var detectedWidth: SyncPulseWidth = SyncPulseWidth.NineMs; private set
+    var pulseOffset: Int = 0; private set
+    var freqOffset: Float = 0f; private set
+
+    private val bandwidth = WHITE_FREQ - BLACK_FREQ
+    private val fm = FmDemodulator(bandwidth, sampleRate.toDouble())
+    private val min5ms: Int = round(0.0025 * sampleRate).toInt()
+    private val max5ms: Int = round(0.007 * sampleRate).toInt()
+    private val max9ms: Int = round(0.0145 * sampleRate).toInt()
+    private val max20ms: Int = round(0.025 * sampleRate).toInt()
+    private val filterDelay: Int
+    private val avgFilter: MovingAverage
+    private val delayLine: Delay
+    private val lowPass: ComplexFirFilter
+    private val oscillator: Phasor
+    private val syncFreqValue: Float
+    private val syncFreqTolerance: Float
+    private val trigger: SchmittTrigger
+    private var counter = 0
+    private var baseBand = Complex()
+
+    init {
+        val filterLen = round(0.0025 * sampleRate).toInt() or 1
+        filterDelay = (filterLen - 1) / 2
+        avgFilter = MovingAverage(filterLen)
+        delayLine = Delay(filterLen)
+        val loFreq = 1000.0
+        val hiFreq = 2800.0
+        val cutoff = (hiFreq - loFreq) / 2
+        val lpLen = round(0.002 * sampleRate).toInt() or 1
+        lowPass = ComplexFirFilter(lpLen)
+        for (i in 0 until lpLen)
+            lowPass.taps[i] = (WindowFunctions.kaiser(2.0, i, lpLen) * WindowFunctions.sinc(
+                cutoff,
+                sampleRate.toDouble(),
+                i,
+                lpLen
+            )).toFloat()
+        val center = (loFreq + hiFreq) / 2
+        oscillator = Phasor(-center, sampleRate.toDouble())
+        syncFreqValue = ((SYNC_FREQ - center) * 2 / bandwidth).toFloat()
+        syncFreqTolerance = (50 * 2 / bandwidth).toFloat()
+        val porchFreq = 1500.0
+        val hiThresh = (SYNC_FREQ + porchFreq) / 2
+        val loThresh = (SYNC_FREQ + hiThresh) / 2
+        trigger = SchmittTrigger(
+            ((loThresh - center) * 2 / bandwidth).toFloat(),
+            ((hiThresh - center) * 2 / bandwidth).toFloat()
+        )
+    }
+
+    fun process(buffer: FloatArray, channelSelect: Int): Boolean {
+        var detected = false
+        val channels = if (channelSelect > 0) 2 else 1
+        // NOTE: buffer[i] is overwritten in-place with the FM-demodulated frequency
+        // value for every mono sample (channelSelect == 0). DecoderEngine.process()
+        // reads back these values to populate scanLineBuffer. Callers must not reuse
+        // the buffer after this call.
+        for (i in 0 until buffer.size / channels) {
+            when (channelSelect) {
+                1 -> baseBand.set(buffer[2 * i])
+                2 -> baseBand.set(buffer[2 * i + 1])
+                3 -> baseBand.set(buffer[2 * i] + buffer[2 * i + 1])
+                4 -> baseBand.set(buffer[2 * i], buffer[2 * i + 1])
+                else -> baseBand.set(buffer[i])
+            }
+            baseBand = lowPass.filter(baseBand.mul(oscillator.rotate()))
+            val freq = fm.demodulate(baseBand)
+            val avg = avgFilter.avg(freq)
+            val delayed = delayLine.push(avg)
+            buffer[i] = freq
+            if (!trigger.process(avg)) {
+                ++counter
+            } else if (counter !in min5ms..max20ms || abs(delayed - syncFreqValue) > syncFreqTolerance) {
+                counter = 0
+            } else {
+                detectedWidth = when {
+                    counter < max5ms -> SyncPulseWidth.FiveMs
+                    counter < max9ms -> SyncPulseWidth.NineMs
+                    else -> SyncPulseWidth.TwentyMs
+                }
+                pulseOffset = i - filterDelay
+                freqOffset = delayed - syncFreqValue
+                detected = true
+                counter = 0
+            }
+        }
+        return detected
+    }
+}
+
+internal class DecoderEngine(
+    private val scopeBuffer: PixelBuffer,
+    private val imageBuffer: PixelBuffer,
+    rawName: String,
+    sampleRate: Int
+) {
+    private val pixelBuffer = PixelBuffer(800, 2)
+    private val detector = SyncPulseDetector(sampleRate)
+    private val pulseFilter: MovingAverage
+    private val pulseFilterDelay: Int
+    private val scanLineBuffer: FloatArray
+    private val scratch: FloatArray
+    private val sync5ms = IntArray(5)
+    private val sync9ms = IntArray(5)
+    private val sync20ms = IntArray(5)
+    private val lines5ms = IntArray(4)
+    private val lines9ms = IntArray(4)
+    private val lines20ms = IntArray(4)
+    private val offsets5ms = FloatArray(5)
+    private val offsets9ms = FloatArray(5)
+    private val offsets20ms = FloatArray(5)
+    private val visFreqs = FloatArray(10)
+    private val scanLineMin: Int
+    private val syncTolerance: Int
+    private val lineTolerance: Int
+    private val leaderLen: Int
+    private val leaderTol: Int
+    private val transition: Int
+    private val visBitLen: Int
+    private val visLen: Int
+    private val rawMode: SstvMode
+    private val modes5ms: ArrayList<SstvMode>
+    private val modes9ms: ArrayList<SstvMode>
+    private val modes20ms: ArrayList<SstvMode>
+
+    var currentMode: SstvMode; private set
+    val allModes: List<SstvMode> get() = modes5ms + modes9ms + modes20ms
+
+    private var lockMode = false
+    private var sample = 0
+    private var leaderBreak = 0
+    private var lastSync = 0
+    private var curLineSamples: Int
+    private var lastOffset = 0f
+
+    init {
+        imageBuffer.line = -1
+        // Pre-allocate for the largest possible mode (PD-290: 800×616 = 492 800 ints)
+        // so that handleHeader/processPulse can reuse the array with a fill(0) instead
+        // of allocating a fresh IntArray on every new image, reducing GC pressure.
+        imageBuffer.pixels = IntArray(800 * 616)
+        val pfLen = round(0.0025 * sampleRate).toInt() or 1
+        pulseFilterDelay = (pfLen - 1) / 2
+        pulseFilter = MovingAverage(pfLen)
+        scanLineBuffer = FloatArray(round(7.0 * sampleRate).toInt())
+        scratch = FloatArray(round(1.1 * sampleRate).toInt())
+        leaderLen = round(0.3 * sampleRate).toInt()
+        leaderTol = round(0.06 * sampleRate).toInt()
+        transition = round(0.0005 * sampleRate).toInt()
+        visBitLen = round(0.03 * sampleRate).toInt()
+        visLen = round(0.3 * sampleRate).toInt()
+        scanLineMin = round(0.05 * sampleRate).toInt()
+        syncTolerance = round(0.03 * sampleRate).toInt()
+        lineTolerance = round(0.001 * sampleRate).toInt()
+        rawMode = RawMode(rawName, sampleRate)
+        val robot36 = Robot36Mode(sampleRate)
+        currentMode = robot36
+        curLineSamples = robot36.scanLineSamples
+        modes5ms = arrayListOf(
+            RgbMode.wraaseSc2180(sampleRate),
+            RgbMode.martin("1", 44, 0.146432, sampleRate),
+            RgbMode.martin("2", 40, 0.073216, sampleRate)
+        )
+        modes9ms = arrayListOf(
+            robot36, Robot72Mode(sampleRate),
+            RgbMode.scottie("1", 60, 0.138240, sampleRate),
+            RgbMode.scottie("2", 56, 0.088064, sampleRate),
+            RgbMode.scottie("DX", 76, 0.3456, sampleRate)
+        )
+        modes20ms = arrayListOf(
+            PdMode("50", 93, 320, 256, 0.09152, sampleRate),
+            PdMode("90", 99, 320, 256, 0.17024, sampleRate),
+            PdMode("120", 95, 640, 496, 0.1216, sampleRate),
+            PdMode("160", 98, 512, 400, 0.195584, sampleRate),
+            PdMode("180", 96, 640, 496, 0.18304, sampleRate),
+            PdMode("240", 97, 640, 496, 0.24448, sampleRate),
+            PdMode("290", 94, 800, 616, 0.2288, sampleRate)
+        )
+    }
+
+    fun process(recordBuffer: FloatArray, channelSelect: Int): Boolean {
+        var newLines = false
+        val detected = detector.process(recordBuffer, channelSelect)
+        var syncIdx = sample + detector.pulseOffset
+        val channels = if (channelSelect > 0) 2 else 1
+        for (j in 0 until recordBuffer.size / channels) {
+            if (sample >= scanLineBuffer.size) {
+                shift(curLineSamples)
+                syncIdx -= curLineSamples
+                if (sample >= scanLineBuffer.size) sample = scanLineBuffer.size - 1
+            }
+            scanLineBuffer[sample++] = recordBuffer[j]
+        }
+        if (detected) {
+            when (detector.detectedWidth) {
+                SyncPulseWidth.FiveMs -> newLines = processPulse(modes5ms, offsets5ms, sync5ms, lines5ms, syncIdx)
+                SyncPulseWidth.NineMs -> {
+                    leaderBreak = syncIdx; newLines = processPulse(modes9ms, offsets9ms, sync9ms, lines9ms, syncIdx)
+                }
+
+                SyncPulseWidth.TwentyMs -> {
+                    leaderBreak = syncIdx; newLines = processPulse(modes20ms, offsets20ms, sync20ms, lines20ms, syncIdx)
+                }
+            }
+        } else if (handleHeader()) {
+            newLines = true
+        } else if (sample > lastSync + (curLineSamples * 5) / 4) {
+            copyLines(
+                currentMode.decodeScanLine(
+                    pixelBuffer,
+                    scratch,
+                    scanLineBuffer,
+                    scopeBuffer.width,
+                    lastSync,
+                    curLineSamples,
+                    lastOffset
+                )
+            )
+            lastSync += curLineSamples; newLines = true
+        }
+        return newLines
+    }
+
+    fun setMode(name: String) {
+        val mode = allModes.firstOrNull { it.name == name }
+        if (mode == currentMode) {
+            lockMode = true; return
+        }
+        if (mode != null) {
+            lockMode = true; imageBuffer.line = -1; currentMode = mode; curLineSamples = mode.scanLineSamples; return
+        }
+        lockMode = false
+    }
+
+    private fun mean(a: IntArray): Double = a.sumOf { it.toDouble() } / a.size
+    private fun stdDev(a: IntArray, m: Double): Double {
+        var s = 0.0; for (v in a) s += (v - m) * (v - m); return sqrt(s / a.size)
+    }
+
+    private fun meanF(a: FloatArray): Float {
+        var s = 0f; for (v in a) s += v; return s / a.size
+    }
+
+    private fun detectMode(modes: ArrayList<SstvMode>, samples: Int): SstvMode {
+        var best: SstvMode = rawMode
+        var bestD = Int.MAX_VALUE
+        for (m in modes) {
+            val d = abs(samples - m.scanLineSamples); if (d <= lineTolerance && d < bestD) {
+                bestD = d; best = m
+            }
+        }
+        return best
+    }
+
+    // scopeBuffer is twice the display height. Each decoded scan line is written
+    // to both the current rolling position (top half, wraps at height/2) and the
+    // same row offset in the bottom half. The UI displays a window that always
+    // spans the half-height boundary, giving a seamless non-wrapping scroll effect.
+    private fun copyUnscaled() {
+        val w = minOf(scopeBuffer.width, pixelBuffer.width)
+        for (row in 0 until pixelBuffer.height) {
+            val line = scopeBuffer.width * scopeBuffer.line
+            pixelBuffer.pixels.copyInto(scopeBuffer.pixels, line, row * pixelBuffer.width, row * pixelBuffer.width + w)
+            scopeBuffer.pixels.fill(0, line + w, line + scopeBuffer.width)
+
+            scopeBuffer.pixels.copyInto(
+                scopeBuffer.pixels,
+                scopeBuffer.width * (scopeBuffer.line + scopeBuffer.height / 2),
+                line,
+                line + scopeBuffer.width
+            )
+            scopeBuffer.line = (scopeBuffer.line + 1) % (scopeBuffer.height / 2)
+        }
+    }
+
+    private fun copyScaled(scale: Int) {
+        for (row in 0 until pixelBuffer.height) {
+            val line = scopeBuffer.width * scopeBuffer.line
+            for (col in 0 until pixelBuffer.width) for (i in 0 until scale) scopeBuffer.pixels[line + col * scale + i] =
+                pixelBuffer.pixels[pixelBuffer.width * row + col]
+            scopeBuffer.pixels.fill(0, line + pixelBuffer.width * scale, line + scopeBuffer.width)
+
+            scopeBuffer.pixels.copyInto(
+                scopeBuffer.pixels,
+                scopeBuffer.width * (scopeBuffer.line + scopeBuffer.height / 2),
+                line,
+                line + scopeBuffer.width
+            )
+            scopeBuffer.line = (scopeBuffer.line + 1) % (scopeBuffer.height / 2)
+            repeat(scale - 1) {
+
+                scopeBuffer.pixels.copyInto(
+                    scopeBuffer.pixels, scopeBuffer.width * scopeBuffer.line, line, line + scopeBuffer.width
+                )
+
+                scopeBuffer.pixels.copyInto(
+                    scopeBuffer.pixels,
+                    scopeBuffer.width * (scopeBuffer.line + scopeBuffer.height / 2),
+                    line,
+                    line + scopeBuffer.width
+                )
+                scopeBuffer.line = (scopeBuffer.line + 1) % (scopeBuffer.height / 2)
+            }
+        }
+    }
+
+    private fun copyLines(ok: Boolean) {
+        if (!ok) return
+        var finish = false
+        if (imageBuffer.line in 0 until imageBuffer.height && imageBuffer.width == pixelBuffer.width) {
+            val w = imageBuffer.width
+            for (row in 0 until pixelBuffer.height) {
+                if (imageBuffer.line >= imageBuffer.height) break
+                pixelBuffer.pixels.copyInto(imageBuffer.pixels, imageBuffer.line * w, row * w, row * w + w)
+                imageBuffer.line++
+            }
+            finish = imageBuffer.line == imageBuffer.height
+        }
+        val scale = scopeBuffer.width / pixelBuffer.width
+        if (scale <= 1) copyUnscaled() else copyScaled(scale)
+        if (finish) drawLines(0xff000000.toInt(), 10)
+    }
+
+    private fun drawLines(color: Int, count: Int) {
+        repeat(count) {
+            scopeBuffer.pixels.fill(
+                color,
+                scopeBuffer.line * scopeBuffer.width,
+                (scopeBuffer.line + 1) * scopeBuffer.width
+            )
+            scopeBuffer.pixels.fill(
+                color,
+                (scopeBuffer.line + scopeBuffer.height / 2) * scopeBuffer.width,
+                (scopeBuffer.line + 1 + scopeBuffer.height / 2) * scopeBuffer.width
+            )
+            scopeBuffer.line = (scopeBuffer.line + 1) % (scopeBuffer.height / 2)
+        }
+    }
+
+    private fun adjust(pulses: IntArray, shift: Int) {
+        for (i in pulses.indices) pulses[i] -= shift
+    }
+
+    private fun shift(amount: Int) {
+        if ((amount <= 0) || (amount > sample)) return
+        sample -= amount; leaderBreak -= amount; lastSync -= amount
+        adjust(sync5ms, amount); adjust(sync9ms, amount); adjust(sync20ms, amount)
+        // Discard already-decoded samples by sliding the live region back to index 0.
+        // System.arraycopy handles the overlapping regions correctly and is a native
+        // memcpy on JVM, so this is fast despite moving the full remaining window.
+        scanLineBuffer.copyInto(scanLineBuffer, 0, amount, amount + sample)
+    }
+
+    private fun handleHeader(): Boolean {
+        if (leaderBreak < visBitLen + leaderTol || sample < leaderBreak + leaderLen + leaderTol + visLen + visBitLen) return false
+        val bp = leaderBreak; leaderBreak = 0
+        var preFreq = 0f
+        for (i in 0 until leaderTol) preFreq += scanLineBuffer[bp - visBitLen - leaderTol + i]
+        val toneFreq = 1900f
+        val center = 1900f
+        val tol = 50f
+        val halfBw = 400f
+        preFreq = preFreq * halfBw / leaderTol + center
+        if (abs(preFreq - toneFreq) > tol) return false
+        var ldrFreq = 0f
+        for (i in transition until leaderLen - leaderTol) ldrFreq += scanLineBuffer[bp + i]
+        val ldrOffset = ldrFreq / (leaderLen - transition - leaderTol)
+        ldrFreq = ldrOffset * halfBw + center
+        if (abs(ldrFreq - toneFreq) > tol) return false
+        val stopFreq = 1200f
+        val pulseThr = ((stopFreq + toneFreq) / 2 - center) / halfBw
+        var vBegin = bp + leaderLen - leaderTol
+        val vEnd = bp + leaderLen + leaderTol + visBitLen
+        repeat(pulseFilter.length) { pulseFilter.avg(scanLineBuffer[vBegin++] - ldrOffset) }
+        while (++vBegin < vEnd) if (pulseFilter.avg(scanLineBuffer[vBegin] - ldrOffset) < pulseThr) break
+        if (vBegin >= vEnd) return false
+        vBegin -= pulseFilterDelay
+        val visEnd = vBegin + visLen
+        visFreqs.fill(0f)
+        for (j in 0 until 10) for (i in transition until visBitLen - transition) visFreqs[j] += scanLineBuffer[vBegin + visBitLen * j + i] - ldrOffset
+        for (i in 0 until 10) visFreqs[i] = visFreqs[i] * halfBw / (visBitLen - 2 * transition) + center
+        if (abs(visFreqs[0] - stopFreq) > tol || abs(visFreqs[9] - stopFreq) > tol) return false
+        for (i in 1 until 9) if (abs(visFreqs[i] - 1100f) > tol && abs(visFreqs[i] - 1300f) > tol) return false
+        var vis = 0
+        for (i in 0 until 8) vis = vis or ((if (visFreqs[i + 1] < stopFreq) 1 else 0) shl i)
+        var chk = true; for (i in 0 until 8) chk = chk xor ((vis and (1 shl i)) != 0)
+        vis = vis and 127; if (!chk) return false
+        val syncThr = ((1200f + 1500f) / 2 - center) / halfBw
+        var sIdx = visEnd - visBitLen
+        val sMax = visEnd + visBitLen
+        repeat(pulseFilter.length) { pulseFilter.avg(scanLineBuffer[sIdx++] - ldrOffset) }
+        while (++sIdx < sMax) if (pulseFilter.avg(scanLineBuffer[sIdx] - ldrOffset) > syncThr) break
+        if (sIdx >= sMax) return false
+        sIdx -= pulseFilterDelay
+        val mode: SstvMode
+        val pulses: IntArray
+        val lines: IntArray
+        val f5 = modes5ms.firstOrNull { it.visCode == vis }
+        val f9 = modes9ms.firstOrNull { it.visCode == vis }
+        val f20 = modes20ms.firstOrNull { it.visCode == vis }
+        when {
+            f5 != null -> {
+                mode = f5; pulses = sync5ms; lines = lines5ms
+            }
+
+            f9 != null -> {
+                mode = f9; pulses = sync9ms; lines = lines9ms
+            }
+
+            f20 != null -> {
+                mode = f20; pulses = sync20ms; lines = lines20ms
+            }
+
+            else -> {
+                if (!lockMode) drawLines(0xffff0000.toInt(), 8); return false
+            }
+        }
+        if (lockMode && mode != currentMode) return false
+        mode.resetState()
+        imageBuffer.width = mode.width; imageBuffer.height = mode.height
+        imageBuffer.pixels.fill(0, 0, mode.width * mode.height); imageBuffer.line = 0
+        currentMode = mode
+        lastSync = sIdx + mode.firstSyncPulseIndex; curLineSamples = mode.scanLineSamples; lastOffset = ldrOffset
+        var oldest = lastSync - (pulses.size - 1) * curLineSamples
+        if (mode.firstSyncPulseIndex > 0) oldest -= curLineSamples
+        for (i in pulses.indices) pulses[i] = oldest + i * curLineSamples
+        lines.fill(curLineSamples)
+        shift(lastSync + mode.firstPixelSampleIndex)
+        drawLines(0xff00ff00.toInt(), 8); drawLines(0xff000000.toInt(), 10)
+        return true
+    }
+
+    private fun processPulse(
+        modes: ArrayList<SstvMode>,
+        freqOffs: FloatArray,
+        syncPulses: IntArray,
+        lineLen: IntArray,
+        latest: Int
+    ): Boolean {
+        for (i in 1 until syncPulses.size) syncPulses[i - 1] = syncPulses[i]
+        syncPulses[syncPulses.size - 1] = latest
+        for (i in 1 until lineLen.size) lineLen[i - 1] = lineLen[i]
+        lineLen[lineLen.size - 1] = syncPulses.last() - syncPulses[syncPulses.size - 2]
+        for (i in 1 until freqOffs.size) freqOffs[i - 1] = freqOffs[i]
+        freqOffs[freqOffs.size - 1] = detector.freqOffset
+        if (lineLen[0] == 0) return false
+        val m = mean(lineLen)
+        val lineSamples = round(m).toInt()
+        if (lineSamples < scanLineMin || lineSamples > scratch.size) return false
+        if (stdDev(lineLen, m) > lineTolerance) return false
+        var changed = false
+        if (lockMode || imageBuffer.line in 0 until imageBuffer.height) {
+            if (currentMode != rawMode && abs(lineSamples - currentMode.scanLineSamples) > lineTolerance) return false
+            // Try continuous decoding
+            if (lockMode && imageBuffer.line == -1 && currentMode != rawMode) {
+                currentMode.resetState()
+                imageBuffer.width = currentMode.width
+                imageBuffer.height = currentMode.height
+                imageBuffer.pixels.fill(0, 0, currentMode.width * currentMode.height)
+                imageBuffer.line = 0
+                drawLines(0xff000000.toInt(), 10); drawLines(0xffffff00.toInt(), 8); drawLines(0xff000000.toInt(), 10)
+            }
+        } else {
+            val prev = currentMode; currentMode = detectMode(modes, lineSamples)
+            changed =
+                currentMode != prev || abs(curLineSamples - lineSamples) > lineTolerance || abs(lastSync + lineSamples - syncPulses.last()) > syncTolerance
+        }
+        if (changed) {
+            drawLines(0xff000000.toInt(), 10); drawLines(0xff00ffff.toInt(), 8); drawLines(0xff000000.toInt(), 10)
+        }
+        val offset = meanF(freqOffs)
+        if (syncPulses[0] >= lineSamples && changed) {
+            val end = syncPulses[0]
+            val extra = end / lineSamples
+            val first = end - extra * lineSamples
+            var p = first; while (p < end) {
+                copyLines(
+                    currentMode.decodeScanLine(
+                        pixelBuffer,
+                        scratch,
+                        scanLineBuffer,
+                        scopeBuffer.width,
+                        p,
+                        lineSamples,
+                        offset
+                    )
+                ); p += lineSamples
+            }
+        }
+        val start = if (changed) 0 else lineLen.size - 1
+        for (i in start until lineLen.size) copyLines(
+            currentMode.decodeScanLine(
+                pixelBuffer,
+                scratch,
+                scanLineBuffer,
+                scopeBuffer.width,
+                syncPulses[i],
+                lineLen[i],
+                offset
+            )
+        )
+        lastSync = syncPulses.last(); curLineSamples = lineSamples; lastOffset = offset
+        shift(lastSync + currentMode.firstPixelSampleIndex)
+        return true
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/sstv/SstvDsp.kt

@@ -0,0 +1,240 @@
+/*
+ * 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.sstv
+
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.pow
+import kotlin.math.round
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+internal class Complex(var real: Float = 0f, var imag: Float = 0f) {
+
+    fun set(real: Float, imag: Float): Complex {
+        this.real = real; this.imag = imag; return this
+    }
+
+    fun set(real: Float): Complex = set(real, 0f)
+
+    fun abs(): Float = sqrt(real * real + imag * imag)
+
+    fun mul(other: Complex): Complex {
+        val tmp = real * other.real - imag * other.imag
+        imag = real * other.imag + imag * other.real
+        real = tmp
+        return this
+    }
+
+    fun div(value: Float): Complex {
+        real /= value; imag /= value; return this
+    }
+}
+
+internal object WindowFunctions {
+
+    fun sinc(cutoff: Double, rate: Double, n: Int, nN: Int): Double {
+        val f = 2 * cutoff / rate
+        val x = n - (nN - 1) / 2.0
+        val fx = f * x
+        return if (fx == 0.0) f else f * sin(PI * fx) / (PI * fx)
+    }
+
+    fun kaiser(a: Double, n: Int, nN: Int): Double {
+        fun square(v: Double) = v * v
+        fun i0(x: Double): Double {
+            val terms = DoubleArray(35)
+            terms[0] = 1.0
+            var v = 1.0
+            for (m in 1 until 35) {
+                v *= x / (2 * m); terms[m] = square(v)
+            }
+            terms.sort()
+            var sum = 0.0; for (m in 34 downTo 0) sum += terms[m]
+            return sum
+        }
+        return i0(PI * a * sqrt(1 - square((2.0 * n) / (nN - 1) - 1))) / i0(PI * a)
+    }
+}
+
+// O(1) ring buffer — simpler and faster than a segment tree for the short window
+// lengths used here (≤512 samples). Float32 accumulated drift over such windows
+// is ~6e-5, negligible for audio-frequency processing.
+internal open class MovingSum(val length: Int) {
+    private val buf = FloatArray(length)
+    private var pos = 0
+    private var runningSum = 0f
+
+    fun add(input: Float) {
+        runningSum += input - buf[pos]
+        buf[pos] = input
+        if (++pos >= length) pos = 0
+    }
+
+    fun sum(): Float = runningSum
+    fun sum(input: Float): Float {
+        add(input); return sum()
+    }
+}
+
+internal class MovingAverage(length: Int) : MovingSum(length) {
+    fun avg(input: Float): Float = sum(input) / length
+}
+
+internal class Ema {
+    private var alpha: Float = 1f
+    private var prev: Float = 0f
+
+    fun process(input: Float): Float {
+        prev = prev * (1 - alpha) + alpha * input; return prev
+    }
+
+    fun setCutoff(freq: Double, rate: Double, order: Int = 1) {
+        alpha = computeAlpha(freq, rate, order)
+    }
+
+    fun reset() {
+        prev = 0f
+    }
+
+    companion object {
+
+        fun computeAlpha(freq: Double, rate: Double, order: Int = 1): Float {
+            val x = cos(2 * PI * (freq.coerceAtMost(rate * 0.499)) / rate)
+            val discriminant = (x * (x - 4) + 3).coerceAtLeast(0.0)
+            return (x - 1 + sqrt(discriminant)).coerceIn(0.0, 1.0).pow(1.0 / order).toFloat()
+        }
+
+        fun withCutoff(freq: Double, rate: Double, order: Int = 1): Ema {
+            return Ema().also { it.setCutoff(freq, rate, order) }
+        }
+    }
+}
+
+internal class Phasor(freq: Double, rate: Double) {
+    private val value = Complex(1f, 0f)
+    private val delta: Complex = run {
+        val omega = 2 * PI * freq / rate
+        Complex(cos(omega).toFloat(), sin(omega).toFloat())
+    }
+    private var count = 0
+
+    // Renormalize every 512 rotations to prevent magnitude drift accumulation,
+    // eliminating the per-sample sqrt without sacrificing demodulation accuracy.
+    fun rotate(): Complex {
+        value.mul(delta)
+        if (++count == 512) { value.div(value.abs()); count = 0 }
+        return value
+    }
+}
+
+internal class FmDemodulator(bandwidth: Double, sampleRate: Double) {
+    private val scale = (sampleRate / (bandwidth * PI)).toFloat()
+    private val pi = PI.toFloat()
+    private val twoPi = (2 * PI).toFloat()
+    private var prev = 0f
+
+    fun demodulate(input: Complex): Float {
+        // Use fast polynomial atan2 instead of the exact trigonometric call.
+        // Max error ~0.005 rad translates to <1 Hz frequency error at 44100 Hz,
+        // well within the 50 Hz sync tolerance.
+        val phase = fastAtan2(input.imag, input.real)
+        var delta = phase - prev; prev = phase
+        if (delta < -pi) delta += twoPi else if (delta > pi) delta -= twoPi
+        return scale * delta
+    }
+
+    // Rajan's polynomial approximation of atan2 — avoids a transcendental call
+    // in the per-sample hot path (~44 k calls/s at 44100 Hz sample rate).
+    private fun fastAtan2(y: Float, x: Float): Float {
+        val absY = kotlin.math.abs(y) + 1e-10f
+        val r: Float
+        val angle: Float
+        if (x >= 0f) {
+            r = (x - absY) / (x + absY)
+            angle = 0.1963f * r * r * r - 0.9817f * r + pi / 4f
+        } else {
+            r = (x + absY) / (absY - x)
+            angle = 0.1963f * r * r * r - 0.9817f * r + 3f * pi / 4f
+        }
+        return if (y < 0f) -angle else angle
+    }
+}
+
+internal class ComplexFirFilter(val length: Int) {
+    private val real = FloatArray(length)
+    private val imag = FloatArray(length)
+    private val sum = Complex()
+    private var pos = 0
+
+    val taps = FloatArray(length)
+
+    fun filter(input: Complex): Complex {
+        real[pos] = input.real; imag[pos] = input.imag
+        if (++pos >= length) pos = 0
+        sum.real = 0f; sum.imag = 0f
+        for (tap in taps) {
+            sum.real += tap * real[pos]; sum.imag += tap * imag[pos]; if (++pos >= length) pos = 0
+        }
+        return sum
+    }
+}
+
+internal class Delay(val length: Int) {
+    private val buf = FloatArray(length)
+    private var pos = 0
+
+    fun push(input: Float): Float {
+        val tmp = buf[pos]; buf[pos] = input; if (++pos >= length) pos = 0; return tmp
+    }
+}
+
+internal class SchmittTrigger(private val low: Float, private val high: Float) {
+    private var state = false
+
+    fun process(input: Float): Boolean {
+        if (state) {
+            if (input < low) state = false
+        } else {
+            if (input > high) state = true
+        }
+        return state
+    }
+}
+
+internal object ColorConverter {
+
+    private fun clamp(v: Int) = v.coerceIn(0, 255)
+    private fun toInt(level: Float) = clamp(round(255 * level).toInt())
+    private fun compress(level: Float) = toInt(sqrt(level.coerceIn(0f, 1f)))
+
+    private fun yuv2rgb(yY: Int, uU: Int, vV: Int): Int {
+        val y = yY - 16
+        val u = uU - 128
+        val v = vV - 128
+        val r = clamp((298 * y + 409 * v + 128) shr 8)
+        val g = clamp((298 * y - 100 * u - 208 * v + 128) shr 8)
+        val b = clamp((298 * y + 516 * u + 128) shr 8)
+        return 0xff000000.toInt() or (r shl 16) or (g shl 8) or b
+    }
+
+    fun gray(level: Float): Int = 0xff000000.toInt() or (0x00010101 * compress(level))
+    fun rgb(r: Float, g: Float, b: Float): Int = 0xff000000.toInt() or (toInt(r) shl 16) or (toInt(g) shl 8) or toInt(b)
+    fun yuv2rgb(yY: Float, uU: Float, vV: Float): Int = yuv2rgb(toInt(yY), toInt(uU), toInt(vV))
+    fun yuv2rgb(packed: Int): Int = yuv2rgb((packed shr 16) and 0xff, (packed shr 8) and 0xff, packed and 0xff)
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/sstv/SstvModes.kt

@@ -0,0 +1,434 @@
+/*
+ * 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.sstv
+
+import kotlin.math.round
+
+internal class PixelBuffer(var width: Int, var height: Int) {
+    var pixels = IntArray(width * height)
+    var line = 0
+}
+
+internal sealed interface SstvMode {
+    val name: String
+    val visCode: Int
+    val width: Int
+    val height: Int
+    val firstPixelSampleIndex: Int
+    val firstSyncPulseIndex: Int
+    val scanLineSamples: Int
+
+    fun resetState() {}
+
+    fun decodeScanLine(
+        pixelBuffer: PixelBuffer,
+        scratch: FloatArray,
+        scanLine: FloatArray,
+        scopeWidth: Int,
+        syncPulseIndex: Int,
+        lineSamples: Int,
+        freqOffset: Float
+    ): Boolean
+}
+
+internal class RgbMode(
+    override val name: String,
+    override val visCode: Int,
+    private val hPixels: Int,
+    private val vPixels: Int,
+    override val firstSyncPulseIndex: Int,
+    override val scanLineSamples: Int,
+    override val firstPixelSampleIndex: Int,
+    private val redBegin: Int,
+    private val redLen: Int,
+    private val greenBegin: Int,
+    private val greenLen: Int,
+    private val blueBegin: Int,
+    private val blueLen: Int,
+    private val endSamples: Int,
+) : SstvMode {
+    override val width get() = hPixels
+    override val height get() = vPixels
+    private val ema = Ema.withCutoff(hPixels.toDouble(), (2 * greenLen).toDouble(), 2)
+
+    override fun decodeScanLine(
+        pixelBuffer: PixelBuffer,
+        scratch: FloatArray,
+        scanLine: FloatArray,
+        scopeWidth: Int,
+        syncPulseIndex: Int,
+        lineSamples: Int,
+        freqOffset: Float
+    ): Boolean {
+        val begin = firstPixelSampleIndex
+        if (syncPulseIndex + begin < 0 || syncPulseIndex + endSamples > scanLine.size) return false
+        ema.reset()
+        for (i in 0 until endSamples - begin) scratch[i] = ema.process(scanLine[syncPulseIndex + begin + i])
+        ema.reset()
+        for (i in endSamples - begin - 1 downTo 0) scratch[i] = freqToLevel(ema.process(scratch[i]), freqOffset)
+        for (i in 0 until hPixels) {
+            val r = redBegin + (i * redLen) / hPixels
+            val g = greenBegin + (i * greenLen) / hPixels
+            val b = blueBegin + (i * blueLen) / hPixels
+            pixelBuffer.pixels[i] = ColorConverter.rgb(scratch[r], scratch[g], scratch[b])
+        }
+        pixelBuffer.width = hPixels; pixelBuffer.height = 1
+        return true
+    }
+
+    companion object {
+        fun martin(variant: String, code: Int, channelSec: Double, sampleRate: Int): RgbMode {
+            val sync = 0.004862
+            val sep = 0.000572
+            val scanLine = sync + sep + 3 * (channelSec + sep)
+            val gEnd = sep + channelSec
+            val bBegin = gEnd + sep
+            val bEnd = bBegin + channelSec
+            val rBegin = bEnd + sep
+            val rEnd = rBegin + channelSec
+            return fromSeconds(
+                name = "Martin $variant",
+                code = code,
+                firstSyncSec = 0.0,
+                scanLineSec = scanLine,
+                beginSec = sep,
+                rBeginSec = rBegin,
+                rEndSec = rEnd,
+                gBeginSec = sep,
+                gEndSec = gEnd,
+                bBeginSec = bBegin,
+                bEndSec = bEnd,
+                endSec = rEnd,
+                sr = sampleRate
+            )
+        }
+
+        fun scottie(variant: String, code: Int, channelSec: Double, sampleRate: Int): RgbMode {
+            val sync = 0.009
+            val sep = 0.0015
+            val firstSync = sync + 2 * (sep + channelSec)
+            val scanLine = sync + 3 * (channelSec + sep)
+            val bEnd = -sync
+            val bBegin = bEnd - channelSec
+            val gEnd = bBegin - sep
+            val gBegin = gEnd - channelSec
+            val rEnd = sep + channelSec
+            return fromSeconds(
+                name = "Scottie $variant",
+                code = code,
+                firstSyncSec = firstSync,
+                scanLineSec = scanLine,
+                beginSec = gBegin,
+                rBeginSec = sep,
+                rEndSec = rEnd,
+                gBeginSec = gBegin,
+                gEndSec = gEnd,
+                bBeginSec = bBegin,
+                bEndSec = bEnd,
+                endSec = rEnd,
+                sr = sampleRate
+            )
+        }
+
+        fun wraaseSc2180(sampleRate: Int): RgbMode {
+            val sync = 0.0055225
+            val porch = 0.0005
+            val ch = 0.235
+            val scanLine = sync + porch + 3 * ch
+            val rEnd = porch + ch
+            val gEnd = rEnd + ch
+            val bEnd = gEnd + ch
+            return fromSeconds(
+                name = "Wraase SC2-180",
+                code = 55,
+                firstSyncSec = 0.0,
+                scanLineSec = scanLine,
+                beginSec = porch,
+                rBeginSec = porch,
+                rEndSec = rEnd,
+                gBeginSec = rEnd,
+                gEndSec = gEnd,
+                bBeginSec = gEnd,
+                bEndSec = bEnd,
+                endSec = bEnd,
+                sr = sampleRate
+            )
+        }
+
+        private fun fromSeconds(
+            name: String, code: Int, w: Int = 320, h: Int = 256,
+            firstSyncSec: Double, scanLineSec: Double, beginSec: Double,
+            rBeginSec: Double, rEndSec: Double, gBeginSec: Double, gEndSec: Double,
+            bBeginSec: Double, bEndSec: Double, endSec: Double, sr: Int
+        ): RgbMode {
+            val begin = round(beginSec * sr).toInt()
+            return RgbMode(
+                name = name, visCode = code, hPixels = w, vPixels = h,
+                firstSyncPulseIndex = round(firstSyncSec * sr).toInt(),
+                scanLineSamples = round(scanLineSec * sr).toInt(),
+                firstPixelSampleIndex = begin,
+                redBegin = round(rBeginSec * sr).toInt() - begin,
+                redLen = round((rEndSec - rBeginSec) * sr).toInt(),
+                greenBegin = round(gBeginSec * sr).toInt() - begin,
+                greenLen = round((gEndSec - gBeginSec) * sr).toInt(),
+                blueBegin = round(bBeginSec * sr).toInt() - begin,
+                blueLen = round((bEndSec - bBeginSec) * sr).toInt(),
+                endSamples = round(endSec * sr).toInt()
+            )
+        }
+    }
+}
+
+internal class Robot36Mode(sampleRate: Int) : SstvMode {
+    override val name = "Robot 36 Color"
+    override val visCode = 8
+    override val width = 320
+    override val height = 240
+    override val firstSyncPulseIndex = 0
+    override val scanLineSamples: Int
+    override val firstPixelSampleIndex: Int
+
+    private val lumSamples: Int
+    private val sepSamples: Int
+    private val chromSamples: Int
+    private val lumBegin: Int
+    private val sepBegin: Int
+    private val chromBegin: Int
+    private val end: Int
+    private val ema: Ema
+    private var lastEven = false
+
+    init {
+        val syncPorch = 0.003
+        val lum = 0.088
+        val sep = 0.0045
+        val porch = 0.0015
+        val chrom = 0.044
+        scanLineSamples = round((0.009 + syncPorch + lum + sep + porch + chrom) * sampleRate).toInt()
+        lumSamples = round(lum * sampleRate).toInt(); sepSamples = round(sep * sampleRate).toInt()
+        chromSamples = round(chrom * sampleRate).toInt()
+        lumBegin = round(syncPorch * sampleRate).toInt(); firstPixelSampleIndex = lumBegin
+        sepBegin = round((syncPorch + lum) * sampleRate).toInt()
+        chromBegin = round((syncPorch + lum + sep + porch) * sampleRate).toInt()
+        end = round((syncPorch + lum + sep + porch + chrom) * sampleRate).toInt()
+        ema = Ema.withCutoff(width.toDouble(), (2 * lumSamples).toDouble(), 2)
+    }
+
+    override fun resetState() {
+        lastEven = false
+    }
+
+    override fun decodeScanLine(
+        pixelBuffer: PixelBuffer,
+        scratch: FloatArray,
+        scanLine: FloatArray,
+        scopeWidth: Int,
+        syncPulseIndex: Int,
+        lineSamples: Int,
+        freqOffset: Float
+    ): Boolean {
+        if (syncPulseIndex + firstPixelSampleIndex < 0 || syncPulseIndex + end > scanLine.size) return false
+        var sep = 0f
+        for (i in 0 until sepSamples) sep += scanLine[syncPulseIndex + sepBegin + i]
+        sep = sep / sepSamples - freqOffset
+        var even = sep < 0
+        if (sep < -1.1f || (sep > -0.9f && sep < 0.9f) || sep > 1.1f) even = !lastEven
+        lastEven = even
+        ema.reset()
+        for (i in firstPixelSampleIndex until end) scratch[i] = ema.process(scanLine[syncPulseIndex + i])
+        ema.reset()
+        for (i in end - 1 downTo firstPixelSampleIndex) scratch[i] = freqToLevel(ema.process(scratch[i]), freqOffset)
+        for (i in 0 until width) {
+            val lPos = lumBegin + (i * lumSamples) / width
+            val cPos = chromBegin + (i * chromSamples) / width
+            if (even) {
+                // Even line: store Y in the red channel slot and Cr in the blue slot,
+                // using ColorConverter.rgb() as a convenient 3×byte packer (not RGB).
+                // The odd line will read these back and combine with its own Cb to
+                // produce the final YUV→RGB conversion for both rows.
+                pixelBuffer.pixels[i] = ColorConverter.rgb(scratch[lPos], 0f, scratch[cPos])
+            } else {
+                val evenYuv = pixelBuffer.pixels[i]
+                // Even pixel packing: 0xAARRGGBB → Y=RR, Cb=GG(unused), Cr=BB
+                // Odd pixel:  Y=lPos, Cb=cPos, Cr=(borrowed from even's BB slot)
+                // Merge: take Y+Cr from even row (bits 0x00ff00ff) and Cb from odd (0x0000ff00).
+                val oddYuv = ColorConverter.rgb(scratch[lPos], scratch[cPos], 0f)
+                pixelBuffer.pixels[i] = ColorConverter.yuv2rgb((evenYuv and 0x00ff00ff) or (oddYuv and 0x0000ff00))
+                pixelBuffer.pixels[i + width] =
+                    ColorConverter.yuv2rgb((oddYuv and 0x00ffff00) or (evenYuv and 0x000000ff))
+            }
+        }
+        pixelBuffer.width = width; pixelBuffer.height = 2
+        return !even
+    }
+}
+
+internal class Robot72Mode(sampleRate: Int) : SstvMode {
+    override val name = "Robot 72 Color"
+    override val visCode = 12
+    override val width = 320
+    override val height = 240
+    override val firstSyncPulseIndex = 0
+    override val scanLineSamples: Int
+    override val firstPixelSampleIndex: Int
+
+    private val lumSamples: Int
+    private val chromSamples: Int
+    private val yBegin: Int
+    private val vBegin: Int
+    private val uBegin: Int
+    private val end: Int
+    private val ema: Ema
+
+    init {
+        val syncPorch = 0.003
+        val lum = 0.138
+        val sep = 0.0045
+        val porch = 0.0015
+        val chrom = 0.069
+        scanLineSamples = round((0.009 + syncPorch + lum + 2 * (sep + porch + chrom)) * sampleRate).toInt()
+        lumSamples = round(lum * sampleRate).toInt(); chromSamples = round(chrom * sampleRate).toInt()
+        yBegin = round(syncPorch * sampleRate).toInt(); firstPixelSampleIndex = yBegin
+        vBegin = round((syncPorch + lum + sep + porch) * sampleRate).toInt()
+        uBegin = round((syncPorch + lum + sep + porch + chrom + sep + porch) * sampleRate).toInt()
+        end = round((syncPorch + lum + 2 * (sep + porch + chrom)) * sampleRate).toInt()
+        ema = Ema.withCutoff(width.toDouble(), (2 * lumSamples).toDouble(), 2)
+    }
+
+    override fun decodeScanLine(
+        pixelBuffer: PixelBuffer,
+        scratch: FloatArray,
+        scanLine: FloatArray,
+        scopeWidth: Int,
+        syncPulseIndex: Int,
+        lineSamples: Int,
+        freqOffset: Float
+    ): Boolean {
+        if (syncPulseIndex + firstPixelSampleIndex < 0 || syncPulseIndex + end > scanLine.size) return false
+        ema.reset()
+        for (i in firstPixelSampleIndex until end) scratch[i] = ema.process(scanLine[syncPulseIndex + i])
+        ema.reset()
+        for (i in end - 1 downTo firstPixelSampleIndex) scratch[i] = freqToLevel(ema.process(scratch[i]), freqOffset)
+        for (i in 0 until width) {
+            val yP = yBegin + (i * lumSamples) / width
+            val uP = uBegin + (i * chromSamples) / width
+            val vP = vBegin + (i * chromSamples) / width
+            pixelBuffer.pixels[i] = ColorConverter.yuv2rgb(scratch[yP], scratch[uP], scratch[vP])
+        }
+        pixelBuffer.width = width; pixelBuffer.height = 1
+        return true
+    }
+}
+
+internal class PdMode(
+    variant: String,
+    override val visCode: Int,
+    private val hPixels: Int,
+    private val vPixels: Int,
+    channelSec: Double,
+    sampleRate: Int
+) : SstvMode {
+    override val name = "PD $variant"
+    override val width get() = hPixels
+    override val height get() = vPixels
+    override val firstSyncPulseIndex = 0
+    override val scanLineSamples: Int
+    override val firstPixelSampleIndex: Int
+
+    private val chSamples: Int
+    private val yEvenBegin: Int
+    private val vAvgBegin: Int
+    private val uAvgBegin: Int
+    private val yOddBegin: Int
+    private val end: Int
+    private val ema: Ema
+
+    init {
+        val syncPorch = 0.00208
+        scanLineSamples = round((0.02 + syncPorch + 4 * channelSec) * sampleRate).toInt()
+        chSamples = round(channelSec * sampleRate).toInt()
+        yEvenBegin = round(syncPorch * sampleRate).toInt(); firstPixelSampleIndex = yEvenBegin
+        vAvgBegin = round((syncPorch + channelSec) * sampleRate).toInt()
+        uAvgBegin = round((syncPorch + 2 * channelSec) * sampleRate).toInt()
+        yOddBegin = round((syncPorch + 3 * channelSec) * sampleRate).toInt()
+        end = round((syncPorch + 4 * channelSec) * sampleRate).toInt()
+        ema = Ema.withCutoff(hPixels.toDouble(), (2 * chSamples).toDouble(), 2)
+    }
+
+    override fun decodeScanLine(
+        pixelBuffer: PixelBuffer,
+        scratch: FloatArray,
+        scanLine: FloatArray,
+        scopeWidth: Int,
+        syncPulseIndex: Int,
+        lineSamples: Int,
+        freqOffset: Float
+    ): Boolean {
+        if (syncPulseIndex + firstPixelSampleIndex < 0 || syncPulseIndex + end > scanLine.size) return false
+        ema.reset()
+        for (i in firstPixelSampleIndex until end) scratch[i] = ema.process(scanLine[syncPulseIndex + i])
+        ema.reset()
+        for (i in end - 1 downTo firstPixelSampleIndex) scratch[i] = freqToLevel(ema.process(scratch[i]), freqOffset)
+        for (i in 0 until hPixels) {
+            val pos = (i * chSamples) / hPixels
+            pixelBuffer.pixels[i] =
+                ColorConverter.yuv2rgb(scratch[pos + yEvenBegin], scratch[pos + uAvgBegin], scratch[pos + vAvgBegin])
+            pixelBuffer.pixels[i + hPixels] =
+                ColorConverter.yuv2rgb(scratch[pos + yOddBegin], scratch[pos + uAvgBegin], scratch[pos + vAvgBegin])
+        }
+        pixelBuffer.width = hPixels; pixelBuffer.height = 2
+        return true
+    }
+}
+
+internal class RawMode(override val name: String, sampleRate: Int) : SstvMode {
+    override val visCode = -1
+    override val width = -1
+    override val height = -1
+    override val firstPixelSampleIndex = 0
+    override val firstSyncPulseIndex = -1
+    override val scanLineSamples = -1
+
+    private val smallMax = round(0.125 * sampleRate).toInt()
+    private val medMax = round(0.175 * sampleRate).toInt()
+    private val ema = Ema()
+
+    override fun decodeScanLine(
+        pixelBuffer: PixelBuffer,
+        scratch: FloatArray,
+        scanLine: FloatArray,
+        scopeWidth: Int,
+        syncPulseIndex: Int,
+        lineSamples: Int,
+        freqOffset: Float
+    ): Boolean {
+        if (syncPulseIndex < 0 || syncPulseIndex + lineSamples > scanLine.size) return false
+        var px = scopeWidth
+        if (lineSamples < smallMax) px /= 2
+        if (lineSamples < medMax) px /= 2
+        ema.setCutoff(px.toDouble(), (2 * lineSamples).toDouble(), 2); ema.reset()
+        for (i in 0 until lineSamples) scratch[i] = ema.process(scanLine[syncPulseIndex + i])
+        ema.reset()
+        for (i in lineSamples - 1 downTo 0) scratch[i] = freqToLevel(ema.process(scratch[i]), freqOffset)
+        for (i in 0 until px) pixelBuffer.pixels[i] = ColorConverter.gray(scratch[(i * lineSamples) / px])
+        pixelBuffer.width = px; pixelBuffer.height = 1
+        return true
+    }
+}
+
+private fun freqToLevel(frequency: Float, offset: Float): Float = 0.5f * (frequency - offset + 1f)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/usecase/IAudioCapture.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.usecase
+
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Platform abstraction for microphone audio capture.
+ * Produces a flow of mono Float PCM buffers at the configured sample rate.
+ */
+interface IAudioCapture {
+    val sampleRate: Int
+
+    /**
+     * Start capturing audio. Emits FloatArray buffers continuously until the flow is canceled.
+     * Caller is responsible for holding RECORD_AUDIO permission before calling this.
+     */
+    fun audioFlow(): Flow<FloatArray>
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/usecase/ISaveImage.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.usecase
+
+/**
+ * Saves a decoded SSTV image to the device gallery.
+ * @return true if the image was saved successfully
+ */
+interface ISaveImage {
+    suspend operator fun invoke(pixels: IntArray, width: Int, height: Int, modeName: String): Boolean
+}

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

@@ -21,134 +21,94 @@ 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 kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.decodeFromJsonElement
 import java.io.InputStream
 import kotlin.math.pow
 
 class DataParser(private val dispatcher: CoroutineDispatcher) {
 
+    private val json = Json {
+        ignoreUnknownKeys = true
+        coerceInputValues = true
+    }
+
     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) }
-                }
-            }
+            lines.drop(1).mapNotNull { parseCSV(it.split(",")) }.toList()
         }
-        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
+        stream.bufferedReader().readLines()
+            .chunked(3)
+            .filter { it.size == 3 && it[1].startsWith("1") && it[2].startsWith("2") }
+            .mapNotNull { parseTLE(it) }
     }
 
     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
-        }
+        runCatching {
+            val root = json.parseToJsonElement(stream.bufferedReader().readText())
+            (root as? JsonArray)?.mapNotNull { element ->
+                runCatching { json.decodeFromJsonElement<SatRadio>(element) }
+                    .onFailure { println("JSON parsing exception: $it") }
+                    .getOrNull()
+            } ?: emptyList()
+        }.getOrDefault(emptyList())
     }
 
-    fun isLeapYear(year: Int): Boolean {
-        return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)
-    }
-
-    private fun parseCSV(values: List<String>): OrbitalData? = try {
+    private fun parseCSV(values: List<String>): OrbitalData? = runCatching {
         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
-    }
+        val timestamp = values[2]
+        val year = timestamp.substring(0, 4)
+        val month = timestamp.substring(5, 7).toInt()
+        val dayOfMonth = timestamp.substring(8, 10).toInt()
+        val dayInt = getDayOfYear(year.toInt(), month, dayOfMonth)
+        val day = dayInt.toString().padStart(3, '0')
+        val hour = timestamp.substring(11, 13).toInt() * 3600000
+        val min = timestamp.substring(14, 16).toInt() * 60000
+        val sec = timestamp.substring(17, 19).toInt() * 1000
+        val ms = timestamp.substring(20, 26).toInt() / 1000.0
+        val frac = ((hour + min + sec + ms) / 86400000.0).toString().substring(1)
+        val epoch = "${year.substring(2)}$day$frac".toDouble()
+        OrbitalData(
+            name = name,
+            epoch = epoch,
+            meanmo = values[3].toDouble(),
+            eccn = values[4].toDouble(),
+            incl = values[5].toDouble(),
+            raan = values[6].toDouble(),
+            argper = values[7].toDouble(),
+            meanan = values[8].toDouble(),
+            catnum = values[11].toInt(),
+            bstar = values[14].toDouble(),
+            ndot = values[15].toDouble()
+        )
+    }.onFailure { println("CSV parsing exception: $it") }.getOrNull()
 
-    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 parseTLE(tle: List<String>): OrbitalData? = runCatching {
+        val line1 = tle[1]
+        val line2 = tle[2]
+        OrbitalData(
+            name = tle[0].trim(),
+            epoch = line1.substring(18, 32).toDouble(),
+            meanmo = line2.substring(52, 63).toDouble(),
+            eccn = line2.substring(26, 33).toDouble() / 1e7,
+            incl = line2.substring(8, 16).toDouble(),
+            raan = line2.substring(17, 25).toDouble(),
+            argper = line2.substring(34, 42).toDouble(),
+            meanan = line2.substring(43, 51).toDouble(),
+            catnum = line1.substring(2, 7).trim().toInt(),
+            bstar = 1e-5 * line1.substring(53, 59).toDouble() / 10.0.pow(line1.substring(60, 61).toDouble()),
+            ndot = line1.substring(33, 43).trim().toDouble()
+        )
+    }.onFailure { println("TLE parsing exception: $it") }.getOrNull()
 
-    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
-    }
+    fun isLeapYear(year: Int): Boolean = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
 
-    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
+    fun getDayOfYear(year: Int, month: Int, dayOfMonth: Int): Int {
+        val daysInMonth = intArrayOf(31, if (isLeapYear(year)) 29 else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+        return daysInMonth.take(month - 1).sum() + dayOfMonth
     }
 }

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

@@ -21,10 +21,11 @@ import java.util.Locale
 import java.util.concurrent.TimeUnit
 
 fun Long.toTimerString(): String {
+    val millis = coerceAtLeast(0L)
     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
+    val hours = TimeUnit.MILLISECONDS.toHours(millis)
+    val minutes = TimeUnit.MILLISECONDS.toMinutes(millis) % 60
+    val seconds = TimeUnit.MILLISECONDS.toSeconds(millis) % 60
     return String.format(Locale.ENGLISH, format, hours, minutes, seconds)
 }
 

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

@@ -17,11 +17,18 @@
  */
 package com.rtbishop.look4sat.core.domain.utility
 
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.DEG2RAD
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import com.rtbishop.look4sat.core.domain.predict.RAD2DEG
+import kotlin.math.acos
+import kotlin.math.atan2
+import kotlin.math.cos
 import kotlin.math.max
 import kotlin.math.min
+import kotlin.math.sin
 
+private const val AVG_EARTH_RADIUS_KM = 6371.009
 private const val MIN_LATITUDE = -85.05112877980658
 private const val MAX_LATITUDE = 85.05112877980658
 private const val MIN_LONGITUDE = -180.0
@@ -48,6 +55,27 @@ fun Double.toRadians(): Double = this * DEG2RAD
 //    return MIN_LONGITUDE + (MAX_LONGITUDE - MIN_LONGITUDE) * this
 //}
 
+// Great-circle distance between two positions in kilometers using the spherical law of cosines.
+fun greatCircleDistanceKm(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
+    val lat1R = lat1.toRadians()
+    val lat2R = lat2.toRadians()
+    val lon1R = lon1.toRadians()
+    val lon2R = lon2.toRadians()
+    return acos(
+        sin(lat1R) * sin(lat2R) + cos(lat1R) * cos(lat2R) * cos(lon2R - lon1R)
+    ) * AVG_EARTH_RADIUS_KM
+}
+
+// Initial bearing (azimuth) from position 1 to position 2, in degrees (0-360).
+fun bearingDeg(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
+    val lat1R = lat1.toRadians()
+    val lat2R = lat2.toRadians()
+    val dLon = (lon2 - lon1).toRadians()
+    val y = sin(dLon) * cos(lat2R)
+    val x = cos(lat1R) * sin(lat2R) - sin(lat1R) * cos(lat2R) * cos(dLon)
+    return (atan2(y, x).toDegrees() + 360) % 360
+}
+
 fun clipLat(latitude: Double): Double {
     return clip(latitude, MIN_LATITUDE, MAX_LATITUDE)
 }
@@ -59,6 +87,13 @@ fun clipLon(longitude: Double): Double {
     return clip(result, MIN_LONGITUDE, MAX_LONGITUDE)
 }
 
+fun OrbitalPos.toMapGeoPos(): GeoPos {
+    return GeoPos(
+        latitude = clipLat(latitude.toDegrees()),
+        longitude = clipLon(longitude.toDegrees())
+    )
+}
+
 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/TransponderMapper.kt

@@ -0,0 +1,73 @@
+/*
+ * 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
+
+object TransponderMapper {
+
+    fun mapUplinkToDownlink(txFreqHz: Long, transponder: SatRadio): Long? {
+        val uplinkLow = transponder.uplinkLow ?: return null
+        val downlinkLow = transponder.downlinkLow ?: return null
+
+        // Single-frequency transponder (FM repeater) - just return the downlink freq
+        val uplinkHigh = transponder.uplinkHigh
+        val downlinkHigh = transponder.downlinkHigh
+        if (uplinkHigh == null || downlinkHigh == null
+            || uplinkLow == uplinkHigh || downlinkLow == downlinkHigh
+        ) {
+            return downlinkLow
+        }
+
+        // Passband transponder (linear) - map within the band
+        val offset = txFreqHz - uplinkLow
+        return if (transponder.isInverted) {
+            downlinkHigh - offset
+        } else {
+            downlinkLow + offset
+        }
+    }
+
+    fun mapDownlinkToUplink(rxFreqHz: Long, transponder: SatRadio): Long? {
+        val uplinkLow = transponder.uplinkLow ?: return null
+        val downlinkLow = transponder.downlinkLow ?: return null
+
+        val uplinkHigh = transponder.uplinkHigh
+        val downlinkHigh = transponder.downlinkHigh
+        if (uplinkHigh == null || downlinkHigh == null
+            || uplinkLow == uplinkHigh || downlinkLow == downlinkHigh
+        ) {
+            return uplinkLow
+        }
+
+        return if (transponder.isInverted) {
+            uplinkLow + (downlinkHigh - rxFreqHz)
+        } else {
+            uplinkLow + (rxFreqHz - downlinkLow)
+        }
+    }
+
+    fun mapUplinkModeToDownlinkMode(txMode: String, isInverted: Boolean): String {
+        if (!isInverted) return txMode
+        return when (txMode.uppercase()) {
+            "USB" -> "LSB"
+            "LSB" -> "USB"
+            else -> txMode
+        }
+    }
+}

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

@@ -59,10 +59,53 @@ class DataParserTest {
     @Test
     fun `Given valid CSV stream returns valid data`() = runTest(testDispatcher) {
         val parsedList = dataParser.parseCSVStream(validCSVStream)
+        assert(parsedList.size == 2)
         assert(parsedList[0].epoch == 21320.51955234)
         assert(parsedList[1].epoch == 24069.23963816)
     }
 
+    @Test
+    fun `Given valid CSV stream all orbital fields are parsed correctly`() = runTest(testDispatcher) {
+        val csvStream = """
+            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
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseCSVStream(csvStream)[0]
+        assert(sat.name == "ISS (ZARYA)")
+        assert(sat.catnum == 25544)
+        assert(sat.meanmo == 15.48582035)
+        assert(sat.eccn == 0.0004694)
+        assert(sat.incl == 51.6447)
+        assert(sat.raan == 309.4881)
+        assert(sat.argper == 203.6966)
+        assert(sat.meanan == 299.8876)
+        assert(sat.bstar == 0.31985E-4)
+        assert(sat.ndot == 0.1288E-4)
+    }
+
+    @Test
+    fun `Given valid CSV stream ndot is parsed for decay detection`() = runTest(testDispatcher) {
+        val csvStream = """
+            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
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseCSVStream(csvStream)[0]
+        // ISS is healthy, should not be decayed even years later
+        assert(!sat.hasDecayed(System.currentTimeMillis()))
+    }
+
+    @Test
+    fun `Given CSV with high drag satellite detects decay`() = runTest(testDispatcher) {
+        // Simulate a satellite with high drag and old epoch that should have decayed
+        val csvStream = """
+            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
+            DEBRIS,2020-001A,2020-01-15T00:00:00.000000,15.9,.001,51.0,100.0,200.0,300.0,0,U,99999,1,100,.5E-3,.05,0
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseCSVStream(csvStream)[0]
+        // High mean motion (15.9) + high drag (.05) + old epoch → should be decayed by now
+        assert(sat.hasDecayed(System.currentTimeMillis()))
+    }
+
     @Test
     fun `Given invalid CSV stream returns empty list`() = runTest(testDispatcher) {
         assert(dataParser.parseCSVStream(invalidCSVStream).isEmpty())
@@ -71,10 +114,41 @@ class DataParserTest {
     @Test
     fun `Given valid TLE stream returns valid data`() = runTest(testDispatcher) {
         val parsedList = dataParser.parseTLEStream(validTLEStream)
+        assert(parsedList.size == 2)
         assert(parsedList[0].epoch == 21320.51955234)
         assert(parsedList[1].epoch == 24069.23963816)
     }
 
+    @Test
+    fun `Given valid TLE stream all orbital fields are parsed correctly`() = runTest(testDispatcher) {
+        val tleStream = """
+            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
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseTLEStream(tleStream)[0]
+        assert(sat.name == "ISS (ZARYA)")
+        assert(sat.catnum == 25544)
+        assert(sat.meanmo == 15.48582035)
+        assert(sat.eccn == 0.0004694)
+        assert(sat.incl == 51.6447)
+        assert(sat.raan == 309.4881)
+        assert(sat.argper == 203.6966)
+        assert(sat.meanan == 299.8876)
+        assert(sat.ndot == 0.00001288)
+    }
+
+    @Test
+    fun `Given valid TLE stream ndot is parsed for decay detection`() = runTest(testDispatcher) {
+        val tleStream = """
+            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
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseTLEStream(tleStream)[0]
+        assert(!sat.hasDecayed(System.currentTimeMillis()))
+    }
+
     @Test
     fun `Given invalid TLE stream returns empty list`() = runTest(testDispatcher) {
         assert(dataParser.parseTLEStream(invalidTLEStream).isEmpty())
@@ -85,6 +159,43 @@ class DataParserTest {
         assert(dataParser.parseJSONStream(validJSONStream)[0].downlinkLow == 136658500L)
     }
 
+    @Test
+    fun `Given valid JSON stream all radio fields are parsed correctly`() = runTest(testDispatcher) {
+        val jsonStream = """
+            [{"uuid":"UzPz4gcsNBPKPKAFPmer7g","description":"Upper side band (drifting)","alive":true,"type":"Transmitter","uplink_low":145900000,"uplink_high":146000000,"uplink_drift":null,"downlink_low":136658500,"downlink_high":136700000,"downlink_drift":null,"mode":"USB","mode_id":9,"uplink_mode":"FM","invert":true,"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","service":"Unknown","coordination":"","coordination_url":""}]
+        """.trimIndent().byteInputStream()
+        val radio = dataParser.parseJSONStream(jsonStream)[0]
+        assert(radio.uuid == "UzPz4gcsNBPKPKAFPmer7g")
+        assert(radio.info == "Upper side band (drifting)")
+        assert(radio.isAlive)
+        assert(radio.downlinkLow == 136658500L)
+        assert(radio.downlinkHigh == 136700000L)
+        assert(radio.downlinkMode == "USB")
+        assert(radio.uplinkLow == 145900000L)
+        assert(radio.uplinkHigh == 146000000L)
+        assert(radio.uplinkMode == "FM")
+        assert(radio.isInverted)
+        assert(radio.catnum == 965)
+    }
+
+    @Test
+    fun `Given JSON with null optional fields parses without error`() = runTest(testDispatcher) {
+        val jsonStream = """
+            [{"uuid":"abc123","description":"Beacon","alive":false,"type":"Transmitter","uplink_low":null,"uplink_high":null,"uplink_drift":null,"downlink_low":145800000,"downlink_high":null,"downlink_drift":null,"mode":null,"mode_id":null,"uplink_mode":null,"invert":false,"baud":null,"sat_id":"TEST","norad_cat_id":12345,"status":"active","updated":"2024-01-01T00:00:00Z","citation":"","service":"Unknown","coordination":"","coordination_url":""}]
+        """.trimIndent().byteInputStream()
+        val radio = dataParser.parseJSONStream(jsonStream)[0]
+        assert(radio.uuid == "abc123")
+        assert(!radio.isAlive)
+        assert(radio.downlinkLow == 145800000L)
+        assert(radio.downlinkHigh == null)
+        assert(radio.downlinkMode == null)
+        assert(radio.uplinkLow == null)
+        assert(radio.uplinkHigh == null)
+        assert(radio.uplinkMode == null)
+        assert(!radio.isInverted)
+        assert(radio.catnum == 12345)
+    }
+
     @Test
     fun `Given invalid JSON stream returns empty list`() = runTest(testDispatcher) {
         assert(dataParser.parseJSONStream(invalidJSONStream).isEmpty())
@@ -96,10 +207,36 @@ class DataParserTest {
     }
 
     @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)
+    fun `isLeapYear returns correct results`() {
+        val years = listOf(1900, 1984, 1994, 2000, 2016, 2022, 2024, 2042, 2048, 2100)
+        val expected = listOf(false, true, false, true, true, false, true, false, true, false)
         val results = years.map { dataParser.isLeapYear(it) }
-        assert(results == answers)
+        assert(results == expected)
+    }
+
+    @Test
+    fun `getDayOfYear returns correct day for January 1st`() {
+        assert(dataParser.getDayOfYear(2024, 1, 1) == 1)
+        assert(dataParser.getDayOfYear(2023, 1, 1) == 1)
+    }
+
+    @Test
+    fun `getDayOfYear returns correct day for March 1st in leap and non-leap years`() {
+        // 2024 is leap: Jan(31) + Feb(29) + 1 = 61
+        assert(dataParser.getDayOfYear(2024, 3, 1) == 61)
+        // 2023 is not leap: Jan(31) + Feb(28) + 1 = 60
+        assert(dataParser.getDayOfYear(2023, 3, 1) == 60)
+    }
+
+    @Test
+    fun `getDayOfYear returns correct day for December 31st`() {
+        assert(dataParser.getDayOfYear(2024, 12, 31) == 366) // leap year
+        assert(dataParser.getDayOfYear(2023, 12, 31) == 365) // non-leap year
+    }
+
+    @Test
+    fun `getDayOfYear returns correct day for November 16th`() {
+        // Matches the CSV test data epoch: 2021-11-16 → day 320
+        assert(dataParser.getDayOfYear(2021, 11, 16) == 320)
     }
 }

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

@@ -0,0 +1,91 @@
+package com.rtbishop.look4sat.core.domain
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.utility.TransponderMapper
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class TransponderMapperTest {
+
+    private fun makeRadio(
+        uplinkLow: Long? = 435000000L,
+        uplinkHigh: Long? = 435100000L,
+        downlinkLow: Long? = 145800000L,
+        downlinkHigh: Long? = 145900000L,
+        isInverted: Boolean = true
+    ) = SatRadio(
+        uuid = "test",
+        info = "Test",
+        isAlive = true,
+        downlinkLow = downlinkLow,
+        downlinkHigh = downlinkHigh,
+        downlinkMode = "USB",
+        uplinkLow = uplinkLow,
+        uplinkHigh = uplinkHigh,
+        uplinkMode = "USB",
+        isInverted = isInverted,
+        catnum = 0
+    )
+
+    @Test
+    fun invertedTransponder_mapsFrequencyCorrectly() {
+        val radio = makeRadio(isInverted = true)
+        // TX at uplinkLow → RX should be downlinkHigh
+        assertEquals(145900000L, TransponderMapper.mapUplinkToDownlink(435000000L, radio))
+        // TX at uplinkHigh → RX should be downlinkLow
+        assertEquals(145800000L, TransponderMapper.mapUplinkToDownlink(435100000L, radio))
+        // TX at center → RX at center
+        assertEquals(145850000L, TransponderMapper.mapUplinkToDownlink(435050000L, radio))
+    }
+
+    @Test
+    fun nonInvertedTransponder_mapsFrequencyCorrectly() {
+        val radio = makeRadio(isInverted = false)
+        // TX at uplinkLow → RX should be downlinkLow
+        assertEquals(145800000L, TransponderMapper.mapUplinkToDownlink(435000000L, radio))
+        // TX at uplinkHigh → RX should be downlinkHigh
+        assertEquals(145900000L, TransponderMapper.mapUplinkToDownlink(435100000L, radio))
+    }
+
+    @Test
+    fun nullFrequencies_returnsNull() {
+        assertNull(TransponderMapper.mapUplinkToDownlink(435000000L, makeRadio(uplinkLow = null)))
+        assertNull(TransponderMapper.mapUplinkToDownlink(435000000L, makeRadio(downlinkLow = null)))
+    }
+
+    @Test
+    fun singleFrequencyTransponder_returnsDownlinkLow() {
+        // FM repeater style: no passband, just single frequencies
+        val radio = makeRadio(
+            uplinkLow = 145990000L, uplinkHigh = null,
+            downlinkLow = 436300000L, downlinkHigh = null,
+            isInverted = false
+        )
+        assertEquals(436300000L, TransponderMapper.mapUplinkToDownlink(145990000L, radio))
+    }
+
+    @Test
+    fun equalLowHighTransponder_returnsDownlinkLow() {
+        val radio = makeRadio(
+            uplinkLow = 145990000L, uplinkHigh = 145990000L,
+            downlinkLow = 436300000L, downlinkHigh = 436300000L,
+            isInverted = false
+        )
+        assertEquals(436300000L, TransponderMapper.mapUplinkToDownlink(145990000L, radio))
+    }
+
+    @Test
+    fun invertedMode_swapsUsbLsb() {
+        assertEquals("LSB", TransponderMapper.mapUplinkModeToDownlinkMode("USB", true))
+        assertEquals("USB", TransponderMapper.mapUplinkModeToDownlinkMode("LSB", true))
+        assertEquals("FM", TransponderMapper.mapUplinkModeToDownlinkMode("FM", true))
+    }
+
+    @Test
+    fun nonInvertedMode_keepsSame() {
+        assertEquals("USB", TransponderMapper.mapUplinkModeToDownlinkMode("USB", false))
+        assertEquals("LSB", TransponderMapper.mapUplinkModeToDownlinkMode("LSB", false))
+        assertEquals("FM", TransponderMapper.mapUplinkModeToDownlinkMode("FM", false))
+    }
+}

core/presentation/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    alias(libs.plugins.convention.composeLibraryPlugin)
+    alias(libs.plugins.convention.corePresentationPlugin)
 }
 
 android {

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

@@ -0,0 +1,424 @@
+/*
+ * 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.graphics.Paint
+import android.graphics.LinearGradient
+import android.graphics.RadialGradient
+import android.graphics.Shader
+import androidx.compose.foundation.Canvas
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.core.graphics.withRotation
+import kotlinx.coroutines.isActive
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
+import kotlin.math.sqrt
+import kotlin.random.Random
+
+@Immutable
+data class BubblesStyle(
+    val bgColor: Color = Color.Black,
+    val bubbleCount: Int = 16,
+    val minBubbleCount: Int = 8,
+    val maxBubbleCount: Int = 16,
+    val adaptiveBubbleCount: Boolean = true,
+    val spawnIntervalMs: Long = 800L,
+    val bubbleRadiusFraction: Float = 0.24f,
+    val adaptiveSizing: Boolean = true,
+    val referenceMinSizePx: Float = 360f,
+    val referenceAreaPx: Float = 360f * 800f,
+    val minBubbleRadiusPx: Float = 16f,
+    val maxBubbleRadiusPx: Float = 256f,
+    val speedScale: Float = 0.99f,
+    val minVelocity: Float = 0.8f,
+    val maxVelocity: Float = 3.2f,
+    val hueRotationSpeedDps: Float = 60f, // degrees per second
+)
+
+@Composable
+fun BubblesEffect(
+    modifier: Modifier = Modifier,
+    isRunning: Boolean = true,
+    style: BubblesStyle = BubblesStyle(),
+) {
+    val renderer = remember { BubblesRenderer() }
+    var frameSignal by remember { mutableIntStateOf(0) }
+
+    // Animation loop
+    LaunchedEffect(isRunning, style) {
+        if (!isRunning) return@LaunchedEffect
+        var previousNanos = 0L
+        while (isActive) {
+            withFrameNanos { now ->
+                if (previousNanos == 0L) previousNanos = now
+                val deltaSec = ((now - previousNanos).coerceAtMost(MAX_STEP_NANOS)).toFloat() / NANOS_TO_SECONDS
+                previousNanos = now
+                renderer.update(deltaSec, style)
+                frameSignal++
+            }
+        }
+    }
+    Canvas(modifier = modifier) {
+        frameSignal
+        renderer.ensureLayout(size)
+        renderer.draw(this, style)
+    }
+}
+
+private const val MAX_STEP_NANOS = 16_666_667L // ~60 FPS
+private const val NANOS_TO_SECONDS = 1_000_000_000f
+private val SHELL_GRADIENT_STOPS = floatArrayOf(0f, 0.52f, 0.66f, 0.79f, 0.90f, 0.968f, 0.993f, 1f)
+private val INNER_GRADIENT_STOPS = floatArrayOf(0f, 0.34f, 0.68f, 1f)
+
+private data class Velocity(var x: Float, var y: Float)
+
+private data class Bubble(
+    var x: Float,
+    var y: Float,
+    val radius: Float,
+    val velocity: Velocity,
+    val baseHue: Float, // 0-360, unique for each bubble
+)
+
+private class BubblesRenderer {
+    private var width = 0f
+    private var height = 0f
+    private val bubbles = mutableListOf<Bubble>()
+    private val random = Random(System.currentTimeMillis())
+    private var globalHueRotation = 0f // degrees, rotates all bubbles hues
+    private var spawnAccumulatorSec = 0f
+    private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+    private val shellColors = IntArray(8)
+    private val innerColors = IntArray(4)
+
+    fun ensureLayout(size: Size) {
+        val targetWidth = size.width
+        val targetHeight = size.height
+        if (targetWidth <= 0f || targetHeight <= 0f) return
+        val shouldRebuild = width != targetWidth || height != targetHeight
+        if (shouldRebuild) {
+            width = targetWidth
+            height = targetHeight
+            bubbles.clear()
+            spawnAccumulatorSec = 0f
+        }
+    }
+
+    fun spawnBubble(style: BubblesStyle): Boolean {
+        if (width <= 0f || height <= 0f) return false
+        val radius = resolveBubbleRadius(style)
+        val (velocityMin, velocityMax) = resolveVelocityRange(style)
+        val bubble = Bubble(
+            x = radius,
+            y = height - radius,
+            radius = radius,
+            velocity = Velocity(
+                x = randomInRange(velocityMin, velocityMax),
+                y = -randomInRange(velocityMin, velocityMax),
+            ),
+            baseHue = random.nextFloat() * 360f, // Random starting hue for this bubble
+        )
+        bubbles.add(bubble)
+        return true
+    }
+
+    fun update(deltaSeconds: Float, style: BubblesStyle) {
+        if (width <= 0f || height <= 0f) return
+
+        spawnMissingBubbles(deltaSeconds, style)
+
+        // Rotate hue for all bubbles
+        globalHueRotation += style.hueRotationSpeedDps * deltaSeconds
+        if (globalHueRotation >= 360f) globalHueRotation -= 360f
+        val frameScale = deltaSeconds * 60f
+        for (i in bubbles.indices) {
+            val bubble = bubbles[i]
+            // Update position
+            bubble.x += bubble.velocity.x * frameScale
+            bubble.y += bubble.velocity.y * frameScale
+            // Bounce off walls
+            if (bubble.x > width - bubble.radius) {
+                bubble.x = width - bubble.radius
+                bubble.velocity.x *= -1
+            }
+            if (bubble.x < bubble.radius) {
+                bubble.x = bubble.radius
+                bubble.velocity.x *= -1
+            }
+            if (bubble.y > height - bubble.radius) {
+                bubble.y = height - bubble.radius
+                bubble.velocity.y *= -1
+            }
+            if (bubble.y < bubble.radius) {
+                bubble.y = bubble.radius
+                bubble.velocity.y *= -1
+            }
+        }
+        // Collision detection and resolution
+        for (i in bubbles.indices) {
+            for (j in (i + 1) until bubbles.size) {
+                val b1 = bubbles[i]
+                val b2 = bubbles[j]
+                if (isCollided(b1, b2)) resolveCollision(b1, b2)
+            }
+        }
+    }
+
+    private fun spawnMissingBubbles(deltaSeconds: Float, style: BubblesStyle) {
+        val targetCount = resolveTargetBubbleCount(style)
+        if (bubbles.size >= targetCount) return
+
+        val spawnIntervalSec = style.spawnIntervalMs.coerceAtLeast(1L) / 1_000f
+        spawnAccumulatorSec += deltaSeconds
+
+        while (bubbles.size < targetCount && spawnAccumulatorSec >= spawnIntervalSec) {
+            if (!spawnBubble(style)) break
+            spawnAccumulatorSec -= spawnIntervalSec
+        }
+    }
+
+    fun draw(scope: DrawScope, style: BubblesStyle) {
+        if (width <= 0f || height <= 0f) return
+        scope.drawRect(style.bgColor)
+        val canvas = scope.drawContext.canvas.nativeCanvas
+        for (i in bubbles.indices) {
+            drawBubbleWithGradient(canvas, bubbles[i])
+        }
+    }
+
+    private fun drawBubbleWithGradient(canvas: android.graphics.Canvas, bubble: Bubble) {
+        val hue = (bubble.baseHue + globalHueRotation) % 360f
+        val lit = 53.33f + maxOf(0f, (70f - kotlin.math.abs(244f - hue)) / 4f)
+        val rgb = hueToRgb(hue, lit)
+        val shellColor = mixWithWhite(rgb, 0.04f)
+        val innerColor = mixWithWhite(rgb, 0.10f)
+        val shimmerColor = mixWithWhite(rgb, 0.35f)
+        // Outer shell
+        val shellGradient = RadialGradient(
+            bubble.x, bubble.y, bubble.radius,
+            buildShellColors(shellColor),
+            SHELL_GRADIENT_STOPS,
+            Shader.TileMode.CLAMP
+        )
+        paint.style = Paint.Style.FILL
+        paint.shader = shellGradient
+        canvas.drawCircle(bubble.x, bubble.y, bubble.radius, paint)
+        // Subtle thin rim
+        paint.shader = null
+        paint.style = Paint.Style.STROKE
+        paint.strokeWidth = maxOf(1f, bubble.radius * 0.024f)
+        paint.color = colorWithAlpha(mixWithWhite(shellColor, 0.08f), 0.30f)
+        canvas.drawCircle(bubble.x, bubble.y, bubble.radius - paint.strokeWidth * 0.5f, paint)
+        // Top internal bubble
+        val innerTop = bubble.y - bubble.radius * 0.96f
+        val innerBottom = bubble.y + bubble.radius * 0.48f
+        val innerLeft = bubble.x - bubble.radius * 0.84f
+        val innerRight = bubble.x + bubble.radius * 0.84f
+        val innerGradient = LinearGradient(
+            bubble.x,
+            innerTop,
+            bubble.x,
+            innerBottom,
+            buildInnerColors(innerColor),
+            INNER_GRADIENT_STOPS,
+            Shader.TileMode.CLAMP
+        )
+        paint.style = Paint.Style.FILL
+        paint.shader = innerGradient
+        canvas.drawOval(
+            innerLeft,
+            innerTop,
+            innerRight,
+            innerBottom,
+            paint
+        )
+        // Top-left shimmer
+        paint.shader = null
+        paint.style = Paint.Style.FILL
+        paint.color = colorWithAlpha(shimmerColor, 0.95f)
+        val shimmerCx = bubble.x - bubble.radius * 0.40f
+        val shimmerCy = bubble.y - bubble.radius * 0.72f
+        val shimmerHalfWidth = bubble.radius * 0.06f
+        val shimmerHalfHeight = bubble.radius * 0.21f
+        canvas.withRotation(60f, shimmerCx, shimmerCy) {
+            drawOval(
+                shimmerCx - shimmerHalfWidth,
+                shimmerCy - shimmerHalfHeight,
+                shimmerCx + shimmerHalfWidth,
+                shimmerCy + shimmerHalfHeight,
+                paint
+            )
+        }
+    }
+
+    private fun isCollided(bubble1: Bubble, bubble2: Bubble): Boolean {
+        val dx = bubble1.x - bubble2.x
+        val dy = bubble1.y - bubble2.y
+        val radius = (bubble1.radius + bubble2.radius) * 0.9f
+        return dx * dx + dy * dy < radius * radius
+    }
+
+    private fun resolveCollision(particle: Bubble, otherParticle: Bubble) {
+        val xVelocityDiff = particle.velocity.x - otherParticle.velocity.x
+        val yVelocityDiff = particle.velocity.y - otherParticle.velocity.y
+        val xDist = otherParticle.x - particle.x
+        val yDist = otherParticle.y - particle.y
+        // Prevent accidental overlap
+        if (xVelocityDiff * xDist + yVelocityDiff * yDist >= 0) {
+            val angle = -atan2(otherParticle.y - particle.y, otherParticle.x - particle.x)
+            val m1 = 1f
+            val m2 = 1f
+            val u1 = rotate(particle.velocity, angle)
+            val u2 = rotate(otherParticle.velocity, angle)
+            val v1 = Velocity(
+                x = (u1.x * (m1 - m2)) / (m1 + m2) + (u2.x * 2 * m2) / (m1 + m2),
+                y = u1.y,
+            )
+            val v2 = Velocity(
+                x = (u2.x * (m1 - m2)) / (m1 + m2) + (u1.x * 2 * m2) / (m1 + m2),
+                y = u2.y,
+            )
+            val vFinal1 = rotate(v1, -angle)
+            val vFinal2 = rotate(v2, -angle)
+            particle.velocity.x = vFinal1.x
+            particle.velocity.y = vFinal1.y
+            otherParticle.velocity.x = vFinal2.x
+            otherParticle.velocity.y = vFinal2.y
+        }
+    }
+
+    private fun rotate(velocity: Velocity, angle: Float): Velocity {
+        return Velocity(
+            x = velocity.x * cos(angle) - velocity.y * sin(angle),
+            y = velocity.x * sin(angle) + velocity.y * cos(angle),
+        )
+    }
+
+    private fun buildShellColors(shellColor: Int): IntArray {
+        shellColors[0] = colorWithAlpha(shellColor, 0f)
+        shellColors[1] = colorWithAlpha(shellColor, 0f)
+        shellColors[2] = colorWithAlpha(shellColor, 0.04f)
+        shellColors[3] = colorWithAlpha(shellColor, 0.12f)
+        shellColors[4] = colorWithAlpha(shellColor, 0.28f)
+        shellColors[5] = colorWithAlpha(shellColor, 0.44f)
+        shellColors[6] = colorWithAlpha(shellColor, 0.58f)
+        shellColors[7] = colorWithAlpha(shellColor, 0.64f)
+        return shellColors
+    }
+
+    private fun buildInnerColors(innerColor: Int): IntArray {
+        innerColors[0] = colorWithAlpha(innerColor, 0.48f)
+        innerColors[1] = colorWithAlpha(innerColor, 0.36f)
+        innerColors[2] = colorWithAlpha(innerColor, 0.08f)
+        innerColors[3] = colorWithAlpha(innerColor, 0f)
+        return innerColors
+    }
+
+    private fun resolveBubbleRadius(style: BubblesStyle): Float {
+        val minDimension = min(width, height)
+        val baseRadius = minDimension * style.bubbleRadiusFraction
+        val minRadius = style.minBubbleRadiusPx.coerceAtLeast(1f)
+        val maxRadius = maxOf(minRadius, style.maxBubbleRadiusPx)
+        if (!style.adaptiveSizing || minDimension <= 0f) {
+            return baseRadius.coerceIn(minRadius, maxRadius)
+        }
+
+        val reference = style.referenceMinSizePx.coerceAtLeast(1f)
+        val dampening = sqrt((reference / minDimension).coerceAtMost(1f))
+        return (baseRadius * dampening).coerceIn(minRadius, maxRadius)
+    }
+
+    private fun resolveTargetBubbleCount(style: BubblesStyle): Int {
+        val baseCount = style.bubbleCount.coerceAtLeast(1)
+        if (!style.adaptiveBubbleCount) return baseCount
+
+        val area = width * height
+        val referenceArea = style.referenceAreaPx.coerceAtLeast(1f)
+        val areaScale = sqrt((area / referenceArea).coerceAtLeast(0.25f))
+        val scaledCount = (baseCount * areaScale).toInt()
+        val minCount = style.minBubbleCount.coerceAtLeast(1)
+        val maxCount = maxOf(minCount, style.maxBubbleCount.coerceAtLeast(1))
+        return scaledCount.coerceIn(minCount, maxCount)
+    }
+
+    private fun resolveVelocityRange(style: BubblesStyle): Pair<Float, Float> {
+        val referenceMaxVelocity = maxOf(height / 300f, 1f)
+        val velocityMin = (style.minVelocity * style.speedScale).coerceAtLeast(0.05f)
+        val velocityMax = maxOf(velocityMin, min(style.maxVelocity, referenceMaxVelocity) * style.speedScale)
+        return velocityMin to velocityMax
+    }
+
+    private fun randomInRange(min: Float, max: Float): Float {
+        return random.nextFloat() * (max - min) + min
+    }
+}
+
+private fun hueToRgb(h: Float, l: Float): Int {
+    val hNorm = h / 360f
+    val lNorm = l / 100f
+    val sNorm = 1f
+    val c = (1f - kotlin.math.abs(2f * lNorm - 1f)) * sNorm
+    val hp = hNorm * 6f
+    val x = c * (1f - kotlin.math.abs((hp % 2f) - 1f))
+    val m = lNorm - c / 2f
+    val (r, g, b) = when {
+        hp < 1f -> Triple(c, x, 0f)
+        hp < 2f -> Triple(x, c, 0f)
+        hp < 3f -> Triple(0f, c, x)
+        hp < 4f -> Triple(0f, x, c)
+        hp < 5f -> Triple(x, 0f, c)
+        else -> Triple(c, 0f, x)
+    }
+    val r8 = ((r + m) * 255).toInt().coerceIn(0, 255)
+    val g8 = ((g + m) * 255).toInt().coerceIn(0, 255)
+    val b8 = ((b + m) * 255).toInt().coerceIn(0, 255)
+    return (0xFF shl 24) or (r8 shl 16) or (g8 shl 8) or b8
+}
+
+private fun colorWithAlpha(color: Int, alpha: Float): Int {
+    val a = (alpha * 255).toInt().coerceIn(0, 255)
+    val r = (color shr 16) and 0xFF
+    val g = (color shr 8) and 0xFF
+    val b = color and 0xFF
+    return (a shl 24) or (r shl 16) or (g shl 8) or b
+}
+
+private fun mixWithWhite(color: Int, amount: Float): Int {
+    val t = amount.coerceIn(0f, 1f)
+    val r = (color shr 16) and 0xFF
+    val g = (color shr 8) and 0xFF
+    val b = color and 0xFF
+    val mixedR = (r + (255 - r) * t).toInt().coerceIn(0, 255)
+    val mixedG = (g + (255 - g) * t).toInt().coerceIn(0, 255)
+    val mixedB = (b + (255 - b) * t).toInt().coerceIn(0, 255)
+    return (0xFF shl 24) or (mixedR shl 16) or (mixedG shl 8) or mixedB
+}

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

@@ -40,19 +40,31 @@ import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ElevatedButton
 import androidx.compose.material3.ElevatedCard
 import androidx.compose.material3.Icon
+import androidx.compose.material3.LocalTextStyle
 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.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.hideFromAccessibility
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.TextLayoutResult
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.TextUnit
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.compose.ui.window.Dialog
@@ -62,8 +74,7 @@ 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)
+import java.util.TimeZone
 
 @Composable
 @Preview(showBackground = true)
@@ -76,19 +87,23 @@ private fun TopBarPreview() = MainTheme {
 }
 
 @Composable
-fun TopBar(content: @Composable (RowScope.() -> Unit)) {
+fun TopBar(content: @Composable RowScope.() -> Unit) {
     Row(
         modifier = Modifier.height(48.dp),
         horizontalArrangement = Arrangement.spacedBy(6.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) { content() }
+        verticalAlignment = Alignment.CenterVertically,
+        content = 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
+    val (aosColor, losColor) = if (isTimeAos) {
+        colorScheme.primary to colorScheme.onSurface
+    } else {
+        colorScheme.onSurface to colorScheme.primary
+    }
     ElevatedCard(modifier = Modifier.weight(1f)) {
         Row(
             verticalAlignment = Alignment.CenterVertically,
@@ -100,7 +115,7 @@ fun RowScope.TimerRow(timeString: String, isTimeAos: Boolean) {
                 text = timeString,
                 fontSize = 32.sp,
                 fontWeight = FontWeight.Bold,
-                color = MaterialTheme.colorScheme.primary
+                color = colorScheme.primary
             )
             Text(text = "LOS", fontSize = 16.sp, fontWeight = FontWeight.Medium, color = losColor)
         }
@@ -114,7 +129,13 @@ private fun NextPassRowPreview() = MainTheme {
 }
 
 @Composable
-fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
+fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc: Boolean = false) {
+    val timeZone = remember(isUtc) {
+        if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
+    }
+    val sdfTime = remember(isUtc) {
+        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+    }
     ElevatedCard(
         modifier = modifier
             .height(48.dp)
@@ -124,13 +145,11 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
             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 - ",
+                    text = "${stringResource(R.string.pass_satId, pass.catNum)} - ",
                     color = MaterialTheme.colorScheme.primary
                 )
                 Text(
@@ -143,16 +162,17 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis
                 )
+                val elevColor = elevationColor(pass.maxElevation)
                 Icon(
-                    painter = painterResource(id = R.drawable.ic_elevation),
+                    painter = painterResource(R.drawable.ic_elevation),
                     contentDescription = null,
-                    tint = MaterialTheme.colorScheme.primary,
+                    tint = elevColor,
                     modifier = Modifier.size(16.dp)
                 )
                 Spacer(modifier = Modifier.width(4.dp))
                 Text(
                     text = "${pass.maxElevation}°",
-                    color = MaterialTheme.colorScheme.primary
+                    color = elevColor
                 )
             }
             Row(
@@ -160,47 +180,24 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
                 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)
-                    )
-                }
+                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
-                    )
+                    Text(text = "${pass.altitude} km", fontSize = 15.sp)
                 }
+                Text(
+                    text = stringResource(R.string.pass_aosLos, pass.aosAzimuth.toInt(), pass.losAzimuth.toInt()),
+                    fontSize = 15.sp,
+                    textAlign = TextAlign.End,
+                    modifier = Modifier.weight(1f)
+                )
             }
         }
     }
@@ -209,19 +206,21 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier) {
 @Composable
 fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier) {
     ElevatedButton(
-        onClick = { onClick() }, colors = ButtonDefaults.buttonColors(
+        onClick = onClick,
+        colors = ButtonDefaults.buttonColors(
             containerColor = MaterialTheme.colorScheme.surfaceVariant,
             contentColor = MaterialTheme.colorScheme.onSurfaceVariant
-        ), shape = MaterialTheme.shapes.small, modifier = modifier,
+        ),
+        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) {
+fun IconCard(action: () -> Unit, resId: Int, modifier: Modifier = Modifier, enabled: Boolean = true) {
+    ElevatedCard(modifier = Modifier.size(48.dp), enabled = enabled, onClick = action) {
+        Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
             Icon(painter = painterResource(resId), contentDescription = null, modifier = modifier)
         }
     }
@@ -229,14 +228,16 @@ fun IconCard(action: () -> Unit, resId: Int, modifier: 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)
-        }
+        Box(
+            modifier = modifier
+                .clickable(onClick = onClick)
+                .fillMaxSize(),
+            contentAlignment = Alignment.Center
+        ) { Icon(painter = painterResource(resId), contentDescription = null) }
     }
 }
 
@@ -262,56 +263,56 @@ fun EmptyListCard(message: String) {
     }
 }
 
-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)
-}
+private val defaultOrbitalData = OrbitalData(
+    name = """ ¯\_(ツ)_/¯ ⚠️""",
+    epoch = 0.0, meanmo = 0.0, eccn = 0.0, incl = 0.0,
+    raan = 0.0, argper = 0.0, meanan = 0.0, catnum = 0, bstar = 0.0
+)
+
+fun getDefaultPass(): OrbitalPass = OrbitalPass(
+    aosTime = 0L, aosAzimuth = 0.0, losTime = Long.MAX_VALUE, losAzimuth = 0.0,
+    altitude = 0, maxElevation = 0.0, orbitalObject = NearEarthObject(defaultOrbitalData), progress = 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))
-                }
-            }
+    DialogShell(title = title, titleFontSize = 16, onDismissRequest = onCancel) {
+        content()
+        Row(modifier = Modifier.padding(start = it, bottom = it, end = it)) {
+            CardButton(onClick = onCancel, text = stringResource(R.string.btn_cancel))
+            Spacer(modifier = Modifier.weight(1f))
+            CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
         }
     }
 }
 
 @Composable
 fun InfoDialog(title: String, text: String, onDismiss: () -> Unit) {
+    DialogShell(title = title, titleFontSize = 18, onDismissRequest = {}) {
+        Text(
+            text = text,
+            fontSize = 16.sp,
+            color = MaterialTheme.colorScheme.onSurface,
+            modifier = Modifier.padding(horizontal = it)
+        )
+        Row(modifier = Modifier.padding(start = it, bottom = it, end = it)) {
+            Spacer(modifier = Modifier.weight(1f))
+            CardButton(onClick = onDismiss, text = stringResource(R.string.btn_accept))
+        }
+    }
+}
+
+@Composable
+private fun DialogShell(
+    title: String,
+    titleFontSize: Int,
+    onDismissRequest: () -> Unit,
+    content: @Composable (padding: androidx.compose.ui.unit.Dp) -> Unit
+) {
     val padding = LocalSpacing.current.large
-    Dialog(onDismissRequest = {}) {
+    Dialog(onDismissRequest = onDismissRequest) {
         ElevatedCard {
             Column(
                 horizontalAlignment = Alignment.CenterHorizontally,
@@ -319,54 +320,36 @@ fun InfoDialog(title: String, text: String, onDismiss: () -> Unit) {
             ) {
                 Text(
                     text = title,
-                    fontSize = 18.sp,
+                    fontSize = titleFontSize.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)
-                    )
-                }
+                content(padding)
             }
         }
     }
 }
 
 @Composable
-fun hasEnoughHeight(): Boolean {
-    return currentWindowAdaptiveInfo().windowSizeClass.isHeightAtLeastBreakpoint(480)
-}
+fun hasEnoughHeight(): Boolean =
+    currentWindowAdaptiveInfo().windowSizeClass.isHeightAtLeastBreakpoint(480)
 
 @Composable
-fun hasEnoughWidth(): Boolean {
-    return currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600)
-}
+fun hasEnoughWidth(): Boolean =
+    currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600)
 
 @Composable
-fun isVerticalLayout(): Boolean {
-    return currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600).not()
-}
+fun isVerticalLayout(): Boolean = !hasEnoughWidth()
 
 @Composable
-fun Modifier.infiniteMarquee(): Modifier {
-    return basicMarquee(iterations = Int.MAX_VALUE, spacing = MarqueeSpacing(16.dp))
-}
+fun Modifier.infiniteMarquee(): Modifier =
+    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)
+    return statusBarsPadding().padding(start = spacing, top = 0.dp, end = spacing, bottom = spacing)
 }
 
 @Composable
@@ -375,15 +358,15 @@ fun ScreenColumn(
     floatingBar: @Composable () -> Unit = {},
     content: @Composable (Boolean) -> Unit = {}
 ) {
-    val isVerticalLayout = isVerticalLayout()
+    val isVertical = isVerticalLayout()
     Surface(color = MaterialTheme.colorScheme.background) {
         Box(modifier = Modifier.layoutPadding(), contentAlignment = Alignment.BottomCenter) {
             Column(verticalArrangement = Arrangement.spacedBy(LocalSpacing.current.extraSmall)) {
-                topBar(isVerticalLayout)
+                topBar(isVertical)
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.surfaceContainer
-                ) { content(isVerticalLayout) }
+                ) { content(isVertical) }
             }
             floatingBar()
         }
@@ -394,21 +377,96 @@ fun ScreenColumn(
 fun TopBar(
     isVerticalLayout: Boolean,
     startAction: @Composable () -> Unit,
-    topInfo: @Composable (RowScope.() -> Unit),
-    bottomInfo: @Composable (RowScope.() -> 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() }
+        TopBar { startAction(); topInfo(); endAction() }
+        TopBar { bottomInfo() }
     } else {
-        topBarRow { startAction().also { topInfo() }.also { bottomInfo() }.also { endAction() } }
+        TopBar { startAction(); topInfo(); bottomInfo(); endAction() }
     }
 }
+
+@Composable
+fun elevationColor(elevation: Double): Color {
+    return when {
+        elevation < 15.0 -> Color(0xFFEF5350) // soft red for low elevation
+        elevation < 45.0 -> MaterialTheme.colorScheme.primary // accent yellow for normal
+        else -> Color(0xFF66BB6A) // soft green for high elevation
+    }
+}
+
+@Composable
+fun OutlinedText(
+    text: String,
+    modifier: Modifier = Modifier,
+    fillColor: Color = Color.Unspecified,
+    outlineColor: Color,
+    fontSize: TextUnit = TextUnit.Unspecified,
+    fontStyle: FontStyle? = null,
+    fontWeight: FontWeight? = null,
+    fontFamily: FontFamily? = null,
+    letterSpacing: TextUnit = TextUnit.Unspecified,
+    textDecoration: TextDecoration? = null,
+    textAlign: TextAlign? = null,
+    lineHeight: TextUnit = TextUnit.Unspecified,
+    overflow: TextOverflow = TextOverflow.Clip,
+    softWrap: Boolean = true,
+    maxLines: Int = Int.MAX_VALUE,
+    minLines: Int = 1,
+    onTextLayout: (TextLayoutResult) -> Unit = {},
+    style: TextStyle = LocalTextStyle.current,
+    outlineDrawStyle: Stroke = Stroke(width = 8f),
+) {
+    Box(modifier = modifier) {
+        Text(
+            text = text,
+            modifier = Modifier.semantics { hideFromAccessibility() },
+            color = outlineColor,
+            fontSize = fontSize,
+            fontStyle = fontStyle,
+            fontWeight = fontWeight,
+            fontFamily = fontFamily,
+            letterSpacing = letterSpacing,
+            textDecoration = null,
+            textAlign = textAlign,
+            lineHeight = lineHeight,
+            overflow = overflow,
+            softWrap = softWrap,
+            maxLines = maxLines,
+            minLines = minLines,
+            onTextLayout = onTextLayout,
+            style = style.copy(shadow = null, drawStyle = outlineDrawStyle),
+        )
+
+        Text(
+            text = text,
+            color = fillColor,
+            fontSize = fontSize,
+            fontStyle = fontStyle,
+            fontWeight = fontWeight,
+            fontFamily = fontFamily,
+            letterSpacing = letterSpacing,
+            textDecoration = textDecoration,
+            textAlign = textAlign,
+            lineHeight = lineHeight,
+            overflow = overflow,
+            softWrap = softWrap,
+            maxLines = maxLines,
+            minLines = minLines,
+            onTextLayout = onTextLayout,
+            style = style,
+        )
+    }
+}
+
+// Formats a frequency in Hz as "MMM.KKK.HHH" (e.g. 145.825.000) or "---"
+fun formatFrequency(frequencyHz: Long): String {
+    if (frequencyHz <= 0) return "---"
+    val mhz = frequencyHz / 1_000_000
+    val khz = (frequencyHz % 1_000_000) / 1_000
+    val hz = frequencyHz % 1_000
+    return String.format(Locale.ENGLISH, "%d.%03d.%03d", mhz, khz, hz)
+}

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

@@ -0,0 +1,260 @@
+/*
+ * 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.graphics.Paint
+import android.graphics.Typeface
+import androidx.compose.foundation.Canvas
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.TextUnit
+import androidx.compose.ui.unit.sp
+import kotlinx.coroutines.isActive
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.random.Random
+
+@Immutable
+data class MatrixStyle(
+    val bgColor: Color = Color.Black,
+    val bodyColor: Color = Color(0xFF29C94A),
+    val headColor: Color = Color(0xFFC2FFC6),
+    val tailAlphaFloor: Float = 0.14f, // 0.14f - 0.18f,
+    val fontSize: TextUnit = 14.sp, // 11.sp - 14.sp
+    val minStreamLength: Int = 8, // 6 - 8
+    val maxStreamLength: Int = 28,  // 20 - 28
+    val minSpeedRps: Float = 10f, // 10f - 15f
+    val maxSpeedRps: Float = 38f, // 38f - 45f
+    val resetPauseSec: ClosedFloatingPointRange<Float> = 0.1f..1.0f,
+)
+
+@Composable
+fun MatrixEffect(
+    modifier: Modifier = Modifier,
+    isRunning: Boolean = true,
+    style: MatrixStyle = MatrixStyle(),
+    symbols: String = DEFAULT_SYMBOLS,
+) {
+    val density = LocalDensity.current
+    val renderer = remember { MatrixRenderer() }
+    var frameSignal by remember { mutableIntStateOf(0) }
+
+    LaunchedEffect(isRunning, style, symbols) {
+        if (!isRunning) return@LaunchedEffect
+
+        var previousNanos = 0L
+        while (isActive) {
+            withFrameNanos { now ->
+                if (previousNanos == 0L) previousNanos = now
+                val deltaSec = ((now - previousNanos).coerceAtMost(MAX_STEP_NANOS)).toFloat() / NANOS_TO_SECONDS
+                previousNanos = now
+                renderer.update(deltaSec, style)
+                frameSignal++
+            }
+        }
+    }
+
+    Canvas(modifier = modifier) {
+        frameSignal
+        renderer.ensureLayout(size, density.density, style, symbols)
+        renderer.draw(this, style)
+    }
+}
+
+private const val MAX_STEP_NANOS = 33_333_333L
+private const val NANOS_TO_SECONDS = 1_000_000_000f
+private const val DEFAULT_SYMBOLS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<>=*+-~:;/[]{}()"
+
+private fun Color.toArgb(): Int {
+    val a = (alpha.coerceIn(0f, 1f) * 255f + 0.5f).toInt()
+    val r = (red.coerceIn(0f, 1f) * 255f + 0.5f).toInt()
+    val g = (green.coerceIn(0f, 1f) * 255f + 0.5f).toInt()
+    val b = (blue.coerceIn(0f, 1f) * 255f + 0.5f).toInt()
+    return (a shl 24) or (r shl 16) or (g shl 8) or b
+}
+
+private class MatrixRenderer {
+    private var columns = 0
+    private var rows = 0
+    private var width = 0f
+    private var height = 0f
+    private var fontSizePx = 0f
+    private var charWidth = 0f
+    private var charHeight = 0f
+    private var baselineOffset = 0f
+    private var symbolSet = ""
+    private var symbols = charArrayOf()
+
+    private var glyphs = charArrayOf()
+    private var streams = emptyArray<StreamState>()
+
+    private val bodyPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { typeface = Typeface.MONOSPACE }
+    private val headPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { typeface = Typeface.MONOSPACE }
+    private val charBuffer = CharArray(1)
+    private val random = Random(System.currentTimeMillis())
+
+    fun ensureLayout(size: Size, density: Float, style: MatrixStyle, symbols: String) {
+        val targetFontPx = style.fontSize.value * density
+        val targetWidth = size.width
+        val targetHeight = size.height
+        val targetSymbols = symbols.ifBlank { DEFAULT_SYMBOLS }
+
+        if (targetWidth <= 0f || targetHeight <= 0f) return
+
+        val shouldRebuild = width != targetWidth ||
+            height != targetHeight ||
+            fontSizePx != targetFontPx ||
+            symbolSet != targetSymbols
+
+        if (!shouldRebuild) return
+
+        width = targetWidth
+        height = targetHeight
+        fontSizePx = targetFontPx
+        symbolSet = targetSymbols
+        this.symbols = targetSymbols.toCharArray()
+
+        bodyPaint.textSize = targetFontPx
+        headPaint.textSize = targetFontPx
+        charWidth = max(bodyPaint.measureText("W"), 1f)
+        val metrics = bodyPaint.fontMetrics
+        charHeight = max(metrics.descent - metrics.ascent, 1f)
+        baselineOffset = -metrics.ascent
+
+        columns = max((width / charWidth).toInt(), 1)
+        rows = max((height / charHeight).toInt() + 2, 1)
+
+        glyphs = CharArray(columns * rows) { randomGlyph() }
+        streams = Array(columns) { StreamState.random(rows, style, random) }
+    }
+
+    fun update(deltaSeconds: Float, style: MatrixStyle) {
+        if (columns == 0 || rows == 0 || deltaSeconds <= 0f) return
+
+        for (column in streams.indices) {
+            val stream = streams[column]
+            stream.pauseSec -= deltaSeconds
+            if (stream.pauseSec > 0f) continue
+
+            val previousHead = floor(stream.headRow).toInt()
+            stream.headRow += stream.speedRps * deltaSeconds
+            val newHead = floor(stream.headRow).toInt()
+
+            if (newHead > previousHead) {
+                for (row in (previousHead + 1)..newHead) {
+                    if (row in 0 until rows) {
+                        glyphs[row * columns + column] = randomGlyph()
+                    }
+                }
+            }
+
+            if (newHead - stream.length > rows) {
+                stream.reset(rows, style, random)
+            }
+        }
+    }
+
+    fun draw(scope: androidx.compose.ui.graphics.drawscope.DrawScope, style: MatrixStyle) {
+        if (columns == 0 || rows == 0) return
+
+        scope.drawRect(style.bgColor)
+
+        bodyPaint.color = style.bodyColor.toArgb()
+        headPaint.color = style.headColor.toArgb()
+        val tailAlphaFloor = style.tailAlphaFloor.coerceIn(0f, 1f)
+
+        val canvas = scope.drawContext.canvas.nativeCanvas
+        for (column in streams.indices) {
+            val stream = streams[column]
+            if (stream.pauseSec > 0f) continue
+
+            val head = floor(stream.headRow).toInt()
+            val startRow = max(0, head - stream.length + 1)
+            val endRow = min(rows - 1, head)
+            if (startRow > endRow) continue
+
+            for (row in endRow downTo startRow) {
+                val tailIndex = head - row
+
+                val paint = if (tailIndex == 0) headPaint else bodyPaint
+                if (tailIndex != 0) {
+                    val normalized = ((stream.length - tailIndex).toFloat() / stream.length).coerceIn(0f, 1f)
+                    val alpha = tailAlphaFloor + (1f - tailAlphaFloor) * normalized
+                    paint.alpha = (alpha * 255).toInt()
+                } else {
+                    paint.alpha = 255
+                }
+
+                val glyph = glyphs[row * columns + column]
+                charBuffer[0] = glyph
+                val x = column * charWidth
+                val y = row * charHeight + baselineOffset
+                canvas.drawText(charBuffer, 0, 1, x, y, paint)
+            }
+        }
+    }
+
+    private fun randomGlyph(): Char = symbols[random.nextInt(symbols.size)]
+}
+
+private data class StreamState(
+    var headRow: Float,
+    var length: Int,
+    var speedRps: Float,
+    var pauseSec: Float,
+) {
+    fun reset(rows: Int, style: MatrixStyle, random: Random) {
+        val randomOffset = random.nextFloat() * rows
+        headRow = -randomOffset
+        length = random.nextInt(
+            from = style.minStreamLength.coerceAtLeast(2),
+            until = (style.maxStreamLength.coerceAtLeast(style.minStreamLength + 1) + 1),
+        )
+        speedRps = random.nextFloat() * (style.maxSpeedRps - style.minSpeedRps) + style.minSpeedRps
+        pauseSec = random.nextFloat() * (style.resetPauseSec.endInclusive - style.resetPauseSec.start) +
+            style.resetPauseSec.start
+    }
+
+    companion object {
+        fun random(rows: Int, style: MatrixStyle, random: Random): StreamState {
+            val length = random.nextInt(
+                from = style.minStreamLength.coerceAtLeast(2),
+                until = (style.maxStreamLength.coerceAtLeast(style.minStreamLength + 1) + 1),
+            )
+            return StreamState(
+                headRow = -random.nextFloat() * rows,
+                length = length,
+                speedRps = random.nextFloat() * (style.maxSpeedRps - style.minSpeedRps) + style.minSpeedRps,
+                pauseSec = random.nextFloat() * (style.resetPauseSec.endInclusive - style.resetPauseSec.start) +
+                    style.resetPauseSec.start,
+            )
+        }
+    }
+}

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

@@ -1,9 +1,70 @@
+/*
+ * 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
 
-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)
+import androidx.navigation3.runtime.NavKey
+import kotlinx.serialization.Serializable
+
+@Serializable
+sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
+
+    @Serializable
+    data object Satellites : Screen(R.drawable.ic_satellites, R.string.nav_sat)
+
+    @Serializable
+    data object Passes : Screen(R.drawable.ic_passes, R.string.nav_pass)
+
+    @Serializable
+    data object Radar : Screen(R.drawable.ic_radar, R.string.nav_radar)
+
+    @Serializable
+    data object Map : Screen(R.drawable.ic_map, R.string.nav_map)
+
+    @Serializable
+    data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs)
+}
+
+@Serializable
+data object RadarDestination : NavKey
+
+interface IDeeplinkMatcher {
+    fun match(deeplink: String): NavKey?
+}
+
+object PassDetailsMatcher : IDeeplinkMatcher {
+    val passDetailsRegex = """https://github.com/rt-bishop/Look4Sat/passes/(.*)""".toRegex()
+
+    override fun match(deeplink: String): NavKey? {
+        val passMatch = passDetailsRegex.find(deeplink)
+        passMatch?.let { match ->
+            val passId = match.groupValues[1]
+            if (passId.isNotEmpty()) return RadarDestination
+        }
+        return null
+    }
+}
+
+class DeeplinkResolver(private val fallbackDestination: NavKey = Screen.Passes) {
+
+    private val matchers: List<IDeeplinkMatcher> = listOf(PassDetailsMatcher)
+
+    fun resolve(deeplink: String): NavKey {
+        matchers.forEach { it.match(deeplink)?.let { match -> return match } }
+        return fallbackDestination
+    }
 }

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

@@ -0,0 +1,105 @@
+package com.rtbishop.look4sat.core.presentation
+
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SwipeToDismissBox
+import androidx.compose.material3.SwipeToDismissBoxValue
+import androidx.compose.material3.rememberSwipeToDismissBoxState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.dropShadow
+import androidx.compose.ui.draw.innerShadow
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+
+@Composable
+fun SwipeableItem(onSwipeRight: () -> Unit, onSwipeLeft: () -> Unit, content: @Composable () -> Unit) {
+    val coroutineScope = rememberCoroutineScope()
+    val dismissThresholdPx = with(LocalDensity.current) { 120.dp.toPx() }
+    val dismissState = rememberSwipeToDismissBoxState { dismissThresholdPx }
+    val willTrigger by remember { derivedStateOf { dismissState.targetValue != SwipeToDismissBoxValue.Settled } }
+    val hapticFeedback = LocalHapticFeedback.current
+    LaunchedEffect(willTrigger) {
+        val feedbackType = if (willTrigger) HapticFeedbackType.LongPress else HapticFeedbackType.SegmentTick
+        if (willTrigger) hapticFeedback.performHapticFeedback(feedbackType)
+    }
+    SwipeToDismissBox(
+        state = dismissState,
+        enableDismissFromStartToEnd = true,
+        enableDismissFromEndToStart = true,
+        backgroundContent = {
+            val isSwipeRight = dismissState.dismissDirection == SwipeToDismissBoxValue.StartToEnd
+            SwipeBackground(isSwipeRight, willTrigger, MaterialTheme.colorScheme.primary)
+        },
+        content = { content() },
+        onDismiss = {
+            val targetValue = dismissState.targetValue
+            when (targetValue) {
+                SwipeToDismissBoxValue.StartToEnd -> onSwipeRight()
+                SwipeToDismissBoxValue.EndToStart -> onSwipeLeft()
+                SwipeToDismissBoxValue.Settled -> {}
+            }
+            if (targetValue != SwipeToDismissBoxValue.Settled) {
+                coroutineScope.launch { dismissState.snapTo(SwipeToDismissBoxValue.Settled) }
+            }
+        }
+    )
+}
+
+@Composable
+fun SwipeBackground(isSwipeRight: Boolean, willTrigger: Boolean, bgColor: Color = Color(0x00000000)) {
+    val shape = RectangleShape
+    Box(
+        contentAlignment = if (isSwipeRight) Alignment.CenterStart else Alignment.CenterEnd,
+        modifier = Modifier
+            .fillMaxSize()
+            .border(width = 1.dp, shape = shape, color = bgColor)
+            .dropShadow(shape = shape) {
+                color = bgColor
+                radius = 40f
+                alpha = if (willTrigger) .2f else 0f
+            }
+            .innerShadow(shape = shape) {
+                color = bgColor
+                radius = 40f
+                alpha = if (willTrigger) 1f else .2f
+            }
+    ) {
+        val iconScale by animateFloatAsState(targetValue = if (willTrigger) 1f else .8f)
+        val slide by animateDpAsState(targetValue = if (willTrigger) 32.dp else (12).dp)
+        Icon(
+            painter = painterResource(R.drawable.ic_filter),
+            contentDescription = null,
+            modifier = Modifier
+                .size(32.dp)
+                .fillMaxHeight()
+                .rotate(if (isSwipeRight) 0f else 180f)
+                .graphicsLayer {
+                    scaleX = iconScale
+                    scaleY = iconScale
+                    translationX = slide.toPx()
+                }
+        )
+    }
+}

core/presentation/src/main/res/drawable/ic_delete.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M6,19c0,1.1 0.9,2 2,2h8c1.1,0 2,-0.9 2,-2V7H6v12zM19,4h-3.5l-1,-1h-5l-1,1H5v2h14V4z" />
+</vector>

core/presentation/src/main/res/drawable/ic_moon.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M12.34,2.02C6.59,1.82 2,6.42 2,12c0,5.52 4.48,10 10,10c3.71,0 6.93,-2.02 8.66,-5.02C13.15,16.73 8.57,8.55 12.34,2.02z" />
+</vector>

core/presentation/src/main/res/drawable/ic_pause.xml

@@ -5,5 +5,5 @@
     android:viewportHeight="24">
     <path
         android:fillColor="@android:color/white"
-        android:pathData="M4,20h16v2L4,22zM4,2h16v2L4,4zM13,9h3l-4,-4 -4,4h3v6L8,15l4,4 4,-4h-3z" />
+        android:pathData="M6,19h4L10,5L6,5v14zM14,5v14h4L18,5h-4z" />
 </vector>

core/presentation/src/main/res/drawable/ic_play.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M8,5v14l11,-7z" />
+</vector>

core/presentation/src/main/res/drawable/ic_save.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M17,3L5,3c-1.11,0 -2,0.9 -2,2v14c0,1.1 0.89,2 2,2h14c1.1,0 2,-0.9 2,-2L21,7l-4,-4zM12,19c-1.66,0 -3,-1.34 -3,-3s1.34,-3 3,-3 3,1.34 3,3 -1.34,3 -3,3zM15,9L5,9L5,5h10v4z" />
+</vector>

core/presentation/src/main/res/drawable/ic_sun.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M11,4V2c0,-0.55 0.45,-1 1,-1s1,0.45 1,1v2c0,0.55 -0.45,1 -1,1S11,4.55 11,4zM18.36,7.05l1.41,-1.42c0.39,-0.39 0.39,-1.02 0,-1.41c-0.39,-0.39 -1.02,-0.39 -1.41,0l-1.41,1.42c-0.39,0.39 -0.39,1.02 0,1.41C17.34,7.44 17.97,7.44 18.36,7.05zM22,11h-2c-0.55,0 -1,0.45 -1,1s0.45,1 1,1h2c0.55,0 1,-0.45 1,-1S22.55,11 22,11zM12,19c-0.55,0 -1,0.45 -1,1v2c0,0.55 0.45,1 1,1s1,-0.45 1,-1v-2C13,19.45 12.55,19 12,19zM5.64,7.05L4.22,5.64c-0.39,-0.39 -0.39,-1.03 0,-1.41s1.03,-0.39 1.41,0l1.41,1.41c0.39,0.39 0.39,1.03 0,1.41S6.02,7.44 5.64,7.05zM16.95,16.95c-0.39,0.39 -0.39,1.03 0,1.41l1.41,1.41c0.39,0.39 1.03,0.39 1.41,0c0.39,-0.39 0.39,-1.03 0,-1.41l-1.41,-1.41C17.98,16.56 17.34,16.56 16.95,16.95zM2,13h2c0.55,0 1,-0.45 1,-1s-0.45,-1 -1,-1H2c-0.55,0 -1,0.45 -1,1S1.45,13 2,13zM5.64,19.78l1.41,-1.41c0.39,-0.39 0.39,-1.03 0,-1.41s-1.03,-0.39 -1.41,0l-1.41,1.41c-0.39,0.39 -0.39,1.03 0,1.41C4.61,20.17 5.25,20.17 5.64,19.78zM12,6c-3.31,0 -6,2.69 -6,6s2.69,6 6,6s6,-2.69 6,-6S15.31,6 12,6z" />
+</vector>

core/presentation/src/main/res/values-es/strings.xml

@@ -118,12 +118,10 @@
 
     <string name="prefs_net_title">Salida de datos de red</string>
     <string name="prefs_net_rotator_switch">Enable rotation output</string>
-    <string name="prefs_net_rotator_ip_hint">Dirección IP</string>
-    <string name="prefs_net_rotator_port_hint">Puerto</string>
+    <string name="prefs_net_rotator_address_hint">IP:Puerto</string>
     <string name="prefs_net_rotator_format_hint">Formato de datos</string>
     <string name="prefs_net_frequency_switch">Enable frequency output</string>
-    <string name="prefs_net_frequency_ip_hint">Dirección IP</string>
-    <string name="prefs_net_frequency_port_hint">Puerto</string>
+    <string name="prefs_net_frequency_address_hint">IP:Puerto</string>
     <string name="prefs_net_frequency_format_hint">Formato de datos</string>
 
     <string name="prefs_bt_title">Salida por Bluetooth</string>
@@ -134,6 +132,7 @@
     <string name="prefs_bt_frequency_device_hint">Id dispositivo</string>
     <string name="prefs_bt_frequency_output_hint">Formato de datos</string>
     <string name="prefs_bt_perm_error">Revisa los permisos de Bluetooth</string>
+    <string name="prefs_net_perm_error">Revisa los permisos de red</string>
 
     <string name="prefs_other_title">Otros ajustes</string>
     <string name="prefs_other_switch_utc">Mostrar tiempos de pase en UTC</string>

core/presentation/src/main/res/values-ru/strings.xml

@@ -117,12 +117,10 @@
 
     <string name="prefs_net_title">Вывод сетевых данных</string>
     <string name="prefs_net_rotator_switch">Включить вывод ротатора</string>
-    <string name="prefs_net_rotator_ip_hint">IP адрес</string>
-    <string name="prefs_net_rotator_port_hint">Порт</string>
+    <string name="prefs_net_rotator_address_hint">IP:Порт</string>
     <string name="prefs_net_rotator_format_hint">Формат</string>
     <string name="prefs_net_frequency_switch">Включить вывод частоты</string>
-    <string name="prefs_net_frequency_ip_hint">IP адрес</string>
-    <string name="prefs_net_frequency_port_hint">Порт</string>
+    <string name="prefs_net_frequency_address_hint">IP:Порт</string>
     <string name="prefs_net_frequency_format_hint">Формат</string>
 
     <string name="prefs_bt_title">Вывод данных Bluetooth</string>
@@ -133,6 +131,7 @@
     <string name="prefs_bt_frequency_device_hint">Id устройства</string>
     <string name="prefs_bt_frequency_output_hint">Формат</string>
     <string name="prefs_bt_perm_error">Нет разрешения использовать bluetooth</string>
+    <string name="prefs_net_perm_error">Нет разрешения использовать сеть</string>
 
     <string name="prefs_other_title">Другие настройки</string>
     <string name="prefs_other_switch_utc">Показывать время по UTC</string>

core/presentation/src/main/res/values-si/strings.xml

@@ -118,12 +118,10 @@
 
     <string name="prefs_net_title">ජාල ප්‍රතිදානය</string>
     <string name="prefs_net_rotator_switch">Enable rotation output</string>
-    <string name="prefs_net_rotator_ip_hint">IP ලිපිනය</string>
-    <string name="prefs_net_rotator_port_hint">Port</string>
+    <string name="prefs_net_rotator_address_hint">IP:Port</string>
     <string name="prefs_net_rotator_format_hint">දත්ත අකාරය</string>
     <string name="prefs_net_frequency_switch">Enable frequency output</string>
-    <string name="prefs_net_frequency_ip_hint">IP ලිපිනය</string>
-    <string name="prefs_net_frequency_port_hint">Port</string>
+    <string name="prefs_net_frequency_address_hint">IP:Port</string>
     <string name="prefs_net_frequency_format_hint">දත්ත අකාරය</string>
 
     <string name="prefs_bt_title">Bluetooth දත්ත ප්‍රතිදානය</string>
@@ -134,6 +132,7 @@
     <string name="prefs_bt_frequency_device_hint">උපාංග id</string>
     <string name="prefs_bt_frequency_output_hint">දත්ත අකාරය</string>
     <string name="prefs_bt_perm_error">Bluetooth අවසර පරික්‍ෂා ක°</string>
+    <string name="prefs_net_perm_error">Network අවසර පරික්‍ෂා කරන්න</string>
 
     <string name="prefs_other_title">වෙනත් සැකසුම්</string>
     <string name="prefs_other_switch_utc">පසුකර වේලාවන් UTC මගින්</string>

core/presentation/src/main/res/values-tr/strings.xml

@@ -0,0 +1,196 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Commmon -->
+    <string name="app_name" translatable="false">Look4Sat</string>
+    <string name="btn_accept">Kabul et</string>
+    <string name="btn_cancel">İptal</string>
+    <string name="empty_list_message">Gösterilecek veri bulunamadı</string>
+
+    <!-- Navigation -->
+    <string name="nav_sat">Uydular</string>
+    <string name="nav_pass">Geçişler</string>
+    <string name="nav_radar">Radar</string>
+    <string name="nav_map">Harita</string>
+    <string name="nav_prefs">Ayarlar</string>
+
+    <!-- Satellites screen -->
+    <string name="sat_type_hint">Uydu türü: %s</string>
+    <string name="sat_type_title">Uydu türü seçin</string>
+    <string name="sat_search_hint">Id - Ad</string>
+    <string name="sat_search_clear">Temizle</string>
+    <string name="sat_clear_all">Tümünü temizle</string>
+    <string name="sat_select_all">Tümünü seç</string>
+    <string name="sat_empty_list_message">"Arama sorgunuzun doğru olduğundan ve veritabanının güncellendiğinden emin olun"</string>
+    <string name="sat_warning_title">Uyarı\!</string>
+    <string name="sat_warning_message">
+        Bu uygulamada 9000\'den fazla uydu listelenmiştir.
+        Hepsini aynı anda takip etmek anlamsızdır.
+        \n\nListeyi yalnızca ilgilendiğiniz uydularla
+        daraltmak için arama ve tür seçiciyi kullanın.</string>
+
+    <!-- Passes screen -->
+    <string name="pass_filter_title">Geçişleri filtrele</string>
+    <string name="pass_filter_elev">Minimum yükseklik açısı</string>
+    <string name="pass_filter_hours">Gösterilecek saat aralığı</string>
+    <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
+    <string name="pass_modes_title">Modulasyon türü seçin</string>
+    <string name="pass_satId" translatable="false">%05d</string>
+    <string name="pass_elevation">Yükseklik açısı: %.1f°</string>
+    <string name="pass_deep_space" translatable="false">DeepSpace</string>
+    <string name="pass_altitude">İrtifa: %d km</string>
+    <string name="pass_aosLos" translatable="false">%03d° - %03d°</string>
+    <string name="pass_empty_list_message">
+        Filtrelerinizin doğru olduğundan ve uydu seçtiğinizden emin olun</string>
+    <string name="pass_error_message">Gösterilecek yaklaşan uydu geçişi bulunmuyor</string>
+    <string name="pass_welcome_title">Look4Sat\'a hoş geldiniz\!</string>
+    <string name="pass_welcome_message">
+        Ayarlar\'dan GPS, Enlem/Boylam veya QTH kullanarak konumunuzu belirlediğinizden emin olun.
+        \n\nDoğru tahminler alabilmek için veritabanını en az haftada bir güncelleyin.</string>
+    <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat</string>
+    <string name="pass_whatsnew_message" translatable="false">
+        * Switched to short-form commands in NetworkReporter, by theojalba
+        \n* Added CAT radio control for full-duplex SAT operation, by jcmerg
+        \n* Added normalized time for passes AOS/LOS, fixed refresh state bug
+        \n* Added multiple performance tweaks, improved passes calculation
+        \n* Fixed UTC pass time problem mentioned in issue #201
+    </string>
+
+    <!-- Radar screen -->
+    <string name="radar_back">Geri</string>
+    <string name="radar_notify">Bildir</string>
+    <string name="radar_az_text">Azimut</string>
+    <string name="radar_az_value" translatable="false">%.1f°</string>
+    <string name="radar_el_text">Yükseklik açısı</string>
+    <string name="radar_el_value" translatable="false">%.1f°</string>
+    <string name="radar_alt_text">İrtifa</string>
+    <string name="radar_alt_value" translatable="false">%.0f km</string>
+    <string name="radar_dist_text">Mesafe</string>
+    <string name="radar_dist_value" translatable="false">%.0f km</string>
+    <string name="radar_eclipsed">Gölgede</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">Bu uyduda transceiver bulunmuyor</string>
+    <string name="radar_add">Ekle</string>
+    <string name="radar_data">Uydu transceiver\'ları:</string>
+    <string name="radar_inverted">Ters çevrilmiş: %s</string>
+    <string name="radar_mode">Modülasyon: %s</string>
+    <string name="radar_string_no">Hayır</string>
+    <string name="radar_string_yes">Evet</string>
+    <string name="radar_visible">Görünür</string>
+
+    <!-- Map screen -->
+    <string name="map_prev">Önceki</string>
+    <string name="map_next">Sonraki</string>
+    <string name="map_copyright" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_azimuth">Azimut: %.1f°</string>
+    <string name="map_elevation">Yükseklik açısı: %.1f°</string>
+    <string name="map_altitude">İrtifa: %.0f km</string>
+    <string name="map_distance">Mesafe: %.0f km</string>
+    <string name="map_latitude">Enlem: %.1f°</string>
+    <string name="map_longitude">Boylam: %.1f°</string>
+    <string name="map_qth" translatable="false">QTH: %s</string>
+    <string name="map_phase">Faz: %.1f°</string>
+    <string name="map_eclipsed">Gölgede</string>
+    <string name="map_period">Periyot: %.0f dk</string>
+    <string name="map_velocity">Hız: %.2f km/s</string>
+    <string name="map_visibility">Görünürlük: %s</string>
+    <string name="map_visible">Görünür</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">Bağış yap</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">Gizlilik Politikası</string>
+    <string name="prefs_privacy_url" translatable="false">https://sites.google.com/view/look4sat-privacy-policy/home</string>
+
+    <string name="prefs_updated_title">Güncellendi: %s</string>
+    <string name="prefs_updated_time">d MMM yyyy - HH:mm:ss</string>
+
+    <string name="prefs_loc_title">İstasyon konumu</string>
+    <string name="prefs_loc_gps_title">GPS</string>
+    <string name="prefs_loc_gps_error">Konum izinlerinizi kontrol edin</string>
+    <string name="prefs_loc_input_title">Manuel giriş</string>
+    <string name="prefs_loc_input_error">Geçersiz konum girildi</string>
+    <string name="prefs_loc_qth_title">QTH</string>
+    <string name="prefs_loc_qth_error">Geçersiz QTH konumlandırıcısı</string>
+    <string name="prefs_loc_success">Konum başarıyla güncellendi</string>
+    <string name="prefs_station_title">İstasyon konumu ayarları</string>
+    <string name="prefs_station_lat_text">Yer istasyonunuzun enlemini girin</string>
+    <string name="prefs_station_lon_text">Yer istasyonunuzun boylamını girin</string>
+    <string name="prefs_locator_title">QTH konumlandırıcı ayarları</string>
+    <string name="prefs_locator_text">İstasyon konumunu konumlandırıcı ile ayarlayın</string>
+
+    <string name="prefs_data_title">Uydu verisi</string>
+    <string name="prefs_data_entries">Uydular: %s</string>
+    <string name="prefs_data_radios">Transceiver\'lar: %s</string>
+    <string name="prefs_data_update">Güncelle</string>
+    <string name="prefs_data_import">İçe aktar</string>
+    <string name="prefs_data_clear">Temizle</string>
+    <string name="prefs_data_clear_success">Veriler başarıyla temizlendi</string>
+    <string name="prefs_data_update_success">Güncelleme başarıyla tamamlandı</string>
+
+    <string name="prefs_data_sources_title">Özel veri kaynakları</string>
+    <string name="prefs_data_sources_tle_switch">Özel TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">Özel transceiver URL</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
+
+    <string name="prefs_data_output_title">Veri aktarımı</string>
+    <string name="prefs_net_output">Ağ</string>
+    <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>
+
+    <!-- Radio Control -->
+    <string name="nav_radiocontrol">Radyo Kontrolü</string>
+    <string name="rc_settings_title">CAT Radyo Kontrolü</string>
+    <string name="rc_radio_model">Radyo Modeli</string>
+    <string name="rc_tx_device_hint">TX Radyo BT Adresi</string>
+    <string name="rc_rx_device_hint">RX Radyo BT Adresi</string>
+    <string name="rc_tx_name_hint">TX Radyo Adı</string>
+    <string name="rc_rx_name_hint">RX Radyo Adı</string>
+    <string name="rc_enable_switch">CAT Kontrolünü Etkinleştir</string>
+
+    <string name="prefs_net_title">Ağ veri çıkışı</string>
+    <string name="prefs_net_rotator_switch">Döndürme çıkışını etkinleştir</string>
+    <string name="prefs_net_rotator_address_hint">IP:Port</string>
+    <string name="prefs_net_rotator_format_hint">Biçim</string>
+    <string name="prefs_net_frequency_switch">Frekans çıkışını etkinleştir</string>
+    <string name="prefs_net_frequency_address_hint">IP:Port</string>
+    <string name="prefs_net_frequency_format_hint">Biçim</string>
+
+    <string name="prefs_bt_title">Bluetooth veri çıkışı</string>
+    <string name="prefs_bt_rotator_switch">Döndürme çıkışını etkinleştir</string>
+    <string name="prefs_bt_rotator_device_hint">Cihaz kimliği</string>
+    <string name="prefs_bt_rotator_output_hint">Veri biçimi</string>
+    <string name="prefs_bt_frequency_switch">Frekans çıkışını etkinleştir</string>
+    <string name="prefs_bt_frequency_device_hint">Cihaz kimliği</string>
+    <string name="prefs_bt_frequency_output_hint">Veri biçimi</string>
+    <string name="prefs_bt_perm_error">Bluetooth izninizi kontrol edin</string>
+    <string name="prefs_net_perm_error">Ağ izninizi kontrol edin</string>
+
+    <string name="prefs_other_title">Diğer ayarlar</string>
+    <string name="prefs_other_switch_utc">Geçiş saatini UTC olarak göster</string>
+    <string name="prefs_other_switch_update">Otomatik veri güncellemeyi etkinleştir</string>
+    <string name="prefs_other_switch_sweep">Radar taramasını etkinleştir</string>
+    <string name="prefs_other_switch_sensors">Radar görünümünü döndürmek için sensörleri kullan</string>
+
+    <string name="prefs_outro_title">Teşekkürler</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">Bu uygulama herhangi bir garanti sunmaz</string>
+
+</resources>

core/presentation/src/main/res/values-uk/strings.xml

@@ -118,12 +118,10 @@
 
     <string name="prefs_net_title">Вивід мережевих даних</string>
     <string name="prefs_net_rotator_switch">Enable rotation output</string>
-    <string name="prefs_net_rotator_ip_hint">IP адреса</string>
-    <string name="prefs_net_rotator_port_hint">Порт</string>
+    <string name="prefs_net_rotator_address_hint">IP:Порт</string>
     <string name="prefs_net_rotator_format_hint">Формат даних</string>
     <string name="prefs_net_frequency_switch">Enable frequency output</string>
-    <string name="prefs_net_frequency_ip_hint">IP адреса</string>
-    <string name="prefs_net_frequency_port_hint">Порт</string>
+    <string name="prefs_net_frequency_address_hint">IP:Порт</string>
     <string name="prefs_net_frequency_format_hint">Формат даних</string>
 
     <string name="prefs_bt_title">Вивід даних Bluetooth</string>
@@ -134,6 +132,7 @@
     <string name="prefs_bt_frequency_device_hint">Id пристрою</string>
     <string name="prefs_bt_frequency_output_hint">Формат даних</string>
     <string name="prefs_bt_perm_error">Перевірте дозвіл Bluetooth</string>
+    <string name="prefs_net_perm_error">Перевірте дозвіл мережі</string>
 
     <string name="prefs_other_title">Інші налаштування</string>
     <string name="prefs_other_switch_utc">Показувати час в UTC</string>

core/presentation/src/main/res/values-zh/strings.xml

@@ -110,12 +110,10 @@
 
     <string name="prefs_net_title">网络数据输出</string>
     <string name="prefs_net_rotator_switch">启用方位俯仰角输出</string>
-    <string name="prefs_net_rotator_ip_hint">IP地址</string>
-    <string name="prefs_net_rotator_port_hint">端口</string>
+    <string name="prefs_net_rotator_address_hint">IP:端口</string>
     <string name="prefs_net_rotator_format_hint">数据格式</string>
     <string name="prefs_net_frequency_switch">启用多普勒频率输出</string>
-    <string name="prefs_net_frequency_ip_hint">IP地址</string>
-    <string name="prefs_net_frequency_port_hint">端口</string>
+    <string name="prefs_net_frequency_address_hint">IP:端口</string>
     <string name="prefs_net_frequency_format_hint">数据格式</string>
 
     <string name="prefs_bt_title">蓝牙数据输出</string>
@@ -126,14 +124,23 @@
     <string name="prefs_bt_frequency_device_hint">蓝牙设备 ID</string>
     <string name="prefs_bt_frequency_output_hint">数据格式</string>
     <string name="prefs_bt_perm_error">请检查蓝牙权限</string>
+    <string name="prefs_net_perm_error">请检查网络权限</string>
 
     <string name="prefs_other_title">其他设置</string>
     <string name="prefs_other_switch_utc">以 UTC 时间显示</string>
     <string name="prefs_other_switch_update">启用卫星数据自动更新</string>
     <string name="prefs_other_switch_sweep">启用雷达扫描动画</string>
     <string name="prefs_other_switch_sensors">使用传感器旋转雷达视图</string>
+    <string name="prefs_other_switch_night_mode">启用红色夜间模式</string>
 
     <string name="prefs_outro_title">我要感谢：</string>
+    <string name="prefs_outro_thanks" translatable="false">
+        • Look4Sat 所有用户及贡献者!
+        \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">该应用程序不提供任何保修.</string>
 
 </resources>

core/presentation/src/main/res/values/strings.xml

@@ -32,6 +32,7 @@
     <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_filter_deep_space">DeepSpace (period >225min)</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>
@@ -48,8 +49,8 @@
         \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 fixed the track path creation issue for split screen
-        as well as enabled the compass data usage for landscape orientation
+        * Added required tweaks to support Android 17 (API 37)
+        \n\n* Added ACCESS_LOCAL_NETWORK permission check to support network data output
     </string>
 
     <!-- Radar screen -->
@@ -144,15 +145,24 @@
     <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_cat_output">CAT</string>
+
+    <!-- Radio Control -->
+    <string name="nav_radiocontrol">Radio Control</string>
+    <string name="rc_settings_title">CAT Radio Control</string>
+    <string name="rc_radio_model">Radio Model</string>
+    <string name="rc_tx_device_hint">TX Radio BT Address</string>
+    <string name="rc_rx_device_hint">RX Radio BT Address</string>
+    <string name="rc_tx_name_hint">TX Radio Name</string>
+    <string name="rc_rx_name_hint">RX Radio Name</string>
+    <string name="rc_enable_switch">Enable CAT Control</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_address_hint">IP: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_address_hint">IP:Port</string>
     <string name="prefs_net_frequency_format_hint">Format</string>
 
     <string name="prefs_bt_title">Bluetooth data output</string>
@@ -163,21 +173,25 @@
     <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_net_perm_error">Check your network 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_other_switch_night_mode">Enable red night mode filter</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>
+        * 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)
+        \n* xdsopl and Robot36 contributors!
+    </string>
     <string name="prefs_outro_license">The app comes with no warranty</string>
 
 </resources>

core/presentation/src/test/java/com/rtbishop/look4sat/core/presentation/DeeplinkResolverTest.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.core.presentation
+
+import org.junit.Test
+
+class DeeplinkResolverTest {
+
+    @Test
+    fun returnsDefaultDestination() {
+        val deeplinkResolver = DeeplinkResolver()
+        val result = deeplinkResolver.resolve("/deeplink")
+        assert(result == Screen.Passes)
+    }
+
+    @Test
+    fun returnsRadarDestination() {
+        val passId = "some-pass-id"
+        val passDeeplink = "https://github.com/rt-bishop/Look4Sat/passes/$passId"
+        val deeplinkResolver = DeeplinkResolver()
+        val result = deeplinkResolver.resolve(passDeeplink)
+        assert(result == RadarDestination)
+    }
+}

fastlane/metadata/android/en-US/changelogs/default.txt

@@ -1,2 +1,2 @@
-* Fixed track path creation issue for split screens (#199) by londre7
-* Enabled using compass data for landscape orientation (#202) by londre7
+* Added required tweaks to support Android 17 (API 37)
+* Added ACCESS_LOCAL_NETWORK permission check to support network data output

fastlane/metadata/android/en-US/whatsnew/whatsnew-en-US

@@ -1,2 +0,0 @@
-* Fixed track path creation issue for split screens (#199) by londre7
-* Enabled using compass data for landscape orientation (#202) by londre7

feature/map/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    alias(libs.plugins.convention.composeFeaturePlugin)
+    alias(libs.plugins.convention.featurePlugin)
 }
 
 android {

feature/map/src/main/java/com/rtbishop/look4sat/feature/map/MapNightOverlay.kt

@@ -0,0 +1,152 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.map
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import org.osmdroid.views.MapView
+import org.osmdroid.views.overlay.Overlay
+import kotlin.math.cos
+import kotlin.math.sin
+
+/**
+ * Custom osmdroid overlay that shades the night side of the globe.
+ *
+ * Works entirely in screen-pixel space: for each vertical strip on screen it
+ * asks osmdroid for the geographic coordinate, then tests whether that point is
+ * in the night half-sphere relative to the sub-solar point.  Because the
+ * computation happens during draw() the result is always correct regardless
+ * of zoom level or map scroll position — no polygon winding issues possible.
+ *
+ * A point (latRad, lonRad) is in night when the angle to the sub-solar point
+ * exceeds 90°, i.e. the dot product of the two unit vectors is negative:
+ *   dot = sin(lat)*sin(sunLat) + cos(lat)*cos(sunLat)*cos(lon - sunLon) < 0
+ *
+ * Performance: we sample one column per [stepPx] pixels (default 4) and draw
+ * filled vertical rectangles.  On a 1080-wide screen this means ~270 trig
+ * evaluations per row, which is imperceptible.
+ */
+class MapNightOverlay : Overlay() {
+
+    /** Sub-solar latitude in degrees. */
+    var sunLatDeg: Double = 0.0
+
+    /** Sub-solar longitude in degrees. */
+    var sunLonDeg: Double = 0.0
+
+    private val nightPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.FILL
+        color = Color.argb(75, 0, 0, 0)
+    }
+
+    private val rect = RectF()
+
+    override fun draw(canvas: Canvas, mapView: MapView, shadow: Boolean) {
+        if (shadow) return
+
+        val proj = mapView.projection
+        val sunLatRad = Math.toRadians(sunLatDeg)
+        val sunLonRad = Math.toRadians(sunLonDeg)
+        val sinSunLat = sin(sunLatRad)
+        val cosSunLat = cos(sunLatRad)
+
+        val w = mapView.width
+        val h = mapView.height
+        val stepPx = 4 // sample every N pixels — balance quality vs CPU
+
+        // We scan column by column. For each column we determine the longitude,
+        // then find the latitude range that is in night and shade it.
+        // Since longitude is constant along a vertical strip and the day/night
+        // boundary at a given longitude is at most two latitudes, we can do a
+        // scan-line fill efficiently.
+
+        var x = 0
+        while (x < w) {
+            // Get the geographic coordinate at the top and bottom of this column.
+            val geoTop = proj.fromPixels(x, 0) ?: run { x += stepPx; continue }
+            val geoBot = proj.fromPixels(x, h - 1) ?: run { x += stepPx; continue }
+
+            val lonRad = Math.toRadians(geoTop.longitude)
+            val cosLonDiff = cos(lonRad - sunLonRad)
+
+            // Top pixel geographic lat
+            val latTopRad = Math.toRadians(geoTop.latitude)
+            // Bottom pixel geographic lat (osmdroid: y=0 is top of screen, higher y = lower lat)
+            val latBotRad = Math.toRadians(geoBot.latitude)
+
+            // dot(sunVec, pointVec) < 0 → night
+            // dot = sin(lat)*sinSunLat + cos(lat)*cosSunLat*cosLonDiff
+            val dotTop = sin(latTopRad) * sinSunLat + cos(latTopRad) * cosSunLat * cosLonDiff
+            val dotBot = sin(latBotRad) * sinSunLat + cos(latBotRad) * cosSunLat * cosLonDiff
+
+            when {
+                dotTop < 0 && dotBot < 0 -> {
+                    // Entire column is night — shade from top to bottom
+                    rect.set(x.toFloat(), 0f, (x + stepPx).toFloat(), h.toFloat())
+                    canvas.drawRect(rect, nightPaint)
+                }
+
+                dotTop >= 0 && dotBot >= 0 -> {
+                    // Entire column is day — nothing to draw
+                }
+
+                else -> {
+                    // Terminator crosses this column — find the crossing pixel by binary search
+                    val crossY = findCrossingY(proj, x, 0, h - 1, sinSunLat, cosSunLat, cosLonDiff)
+                    if (dotTop < 0) {
+                        // Night at top, day at bottom
+                        rect.set(x.toFloat(), 0f, (x + stepPx).toFloat(), crossY.toFloat())
+                        canvas.drawRect(rect, nightPaint)
+                    } else {
+                        // Day at top, night at bottom
+                        rect.set(x.toFloat(), crossY.toFloat(), (x + stepPx).toFloat(), h.toFloat())
+                        canvas.drawRect(rect, nightPaint)
+                    }
+                }
+            }
+            x += stepPx
+        }
+    }
+
+    /**
+     * Binary-search for the pixel row where the day/night boundary crosses column [x].
+     * [yTop] is in day, [yBot] is in night (or vice versa).
+     */
+    private fun findCrossingY(
+        proj: org.osmdroid.views.Projection,
+        x: Int,
+        yTop: Int,
+        yBot: Int,
+        sinSunLat: Double,
+        cosSunLat: Double,
+        cosLonDiff: Double
+    ): Int {
+        var lo = yTop
+        var hi = yBot
+        while (hi - lo > 1) {
+            val mid = (lo + hi) / 2
+            val geo = proj.fromPixels(x, mid) ?: return mid
+            val latRad = Math.toRadians(geo.latitude)
+            val dot = sin(latRad) * sinSunLat + cos(latRad) * cosSunLat * cosLonDiff
+            if (dot < 0) hi = mid else lo = mid
+        }
+        return (lo + hi) / 2
+    }
+}

feature/map/src/main/java/com/rtbishop/look4sat/feature/map/MapScreen.kt

@@ -24,6 +24,7 @@ import android.graphics.ColorMatrixColorFilter
 import android.graphics.Paint
 import android.graphics.Rect
 import android.graphics.drawable.Drawable
+import androidx.collection.LruCache
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -40,7 +41,7 @@ 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.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -59,15 +60,13 @@ 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.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.presentation.IconCard
 import com.rtbishop.look4sat.core.presentation.NextPassRow
 import com.rtbishop.look4sat.core.presentation.R
-import com.rtbishop.look4sat.core.presentation.Screen
 import com.rtbishop.look4sat.core.presentation.TimerRow
 import com.rtbishop.look4sat.core.presentation.TopBar
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
@@ -80,6 +79,16 @@ import org.osmdroid.views.overlay.FolderOverlay
 import org.osmdroid.views.overlay.Marker
 import org.osmdroid.views.overlay.Polyline
 
+// Overlay indices
+private const val OVERLAY_STATION = 0
+private const val OVERLAY_TRACK = 1
+private const val OVERLAY_FOOTPRINT = 2
+private const val OVERLAY_POSITIONS = 3
+private const val OVERLAY_TERMINATOR = 4
+private const val OVERLAY_SUN = 5
+private const val OVERLAY_MOON = 6
+private const val OVERLAY_COUNT = 7
+
 private val minLat = MapView.getTileSystem().minLatitude
 private val maxLat = MapView.getTileSystem().maxLatitude
 private val trackPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
@@ -100,98 +109,122 @@ private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
     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)
-    }
+private val iconCache = LruCache<String, Drawable>(128)
+private val sunIconPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    colorFilter =
+        android.graphics.PorterDuffColorFilter("#FFE082".toColorInt(), android.graphics.PorterDuff.Mode.SRC_IN)
+}
+private val moonIconPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    colorFilter =
+        android.graphics.PorterDuffColorFilter("#E0E0E0".toColorInt(), android.graphics.PorterDuff.Mode.SRC_IN)
 }
 
 @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) }
+fun MapDestination() {
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val viewModel: MapViewModel = viewModel(factory = MapViewModel.factory(container))
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val mapView = rememberMapViewWithLifecycle()
+    MapScreen(uiState, viewModel::onAction, mapView)
+}
+
+@Composable
+private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView: MapView) {
     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))
+    val timeString = uiState.mapData?.aosTime ?: "00:00:00"
+    val isTimeAos = uiState.mapData?.isTimeAos ?: true
+
+    LaunchedEffect(uiState.track) {
+        val firstPos = uiState.track?.firstOrNull()?.firstOrNull() ?: return@LaunchedEffect
+        mapView.controller.animateTo(GeoPoint(firstPos.latitude, firstPos.longitude))
     }
     Column(modifier = Modifier.layoutPadding(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
-        if (isVerticalLayout()) {
+        val isVertical = isVerticalLayout()
+        if (isVertical) {
             TopBar {
-                IconCard(action = selectPrev, resId = R.drawable.ic_arrow, modifier = rotateMod)
+                IconCard(action = { onAction(MapAction.SelectPrev) }, resId = R.drawable.ic_arrow, modifier = rotateMod)
                 TimerRow(timeString = timeString, isTimeAos = isTimeAos)
-                IconCard(action = selectNext, resId = R.drawable.ic_arrow)
+                IconCard(action = { onAction(MapAction.SelectNext) }, resId = R.drawable.ic_arrow)
             }
-            TopBar { NextPassRow(pass = uiState.value.orbitalPass) }
+            TopBar { NextPassRow(pass = uiState.orbitalPass, isUtc = uiState.isUtc) }
         } else {
             TopBar {
-                IconCard(action = selectPrev, resId = R.drawable.ic_arrow, modifier = rotateMod)
+                IconCard(action = { onAction(MapAction.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)
+                NextPassRow(pass = uiState.orbitalPass, modifier = Modifier.weight(1f), isUtc = uiState.isUtc)
+                IconCard(action = { onAction(MapAction.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) }
+                AndroidView({ mapView }) { view ->
+                    uiState.stationPosition?.let { setStationPosition(it, view) }
+                    uiState.track?.let { setSatelliteTrack(it, view) }
+                    uiState.footprint?.let { setFootprint(it, view) }
+                    uiState.positions?.let { setPositions(it, view) { item -> onAction(MapAction.SelectItem(item)) } }
+                    setTerminator(uiState.sunLatDeg, uiState.sunLonDeg, view)
+                    setSubSolarPoint(uiState.sunLatDeg, uiState.sunLonDeg, view)
+                    setMoonPosition(uiState.moonLatDeg, uiState.moonLonDeg, view)
+                    view.invalidate()
                 }
-                uiState.value.mapData?.let { mapData ->
-                    if (isVerticalLayout()) MapDataCard(mapData) else MapDataCards(mapData)
+                uiState.mapData?.let { mapData ->
+                    if (isVertical) MapDataCard(mapData) else MapDataCards(mapData)
                 }
             }
         }
     }
 }
 
+// region Map data composables
 @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) {
+    Column(horizontalAlignment = Alignment.CenterHorizontally) {
         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))
-                }
+                MapDataRow(
+                    stringResource(R.string.map_azimuth, data.azimuth) to textColor,
+                    stringResource(R.string.map_elevation, data.elevation) to textColor
+                )
+                MapDataRow(
+                    stringResource(R.string.map_altitude, data.altitude) to null,
+                    stringResource(R.string.map_distance, data.range) to null
+                )
+                MapDataRow(
+                    stringResource(R.string.map_latitude, data.osmPos.latitude) to textColor,
+                    stringResource(R.string.map_longitude, data.osmPos.longitude) to textColor
+                )
+                MapDataRow(
+                    stringResource(R.string.map_qth, data.qthLoc) to null,
+                    stringResource(R.string.map_phase, data.phase) to null
+                )
             }
         }
     }
 }
 
+@Composable
+private fun MapDataRow(
+    left: Pair<String, androidx.compose.ui.graphics.Color?>,
+    right: Pair<String, androidx.compose.ui.graphics.Color?>
+) {
+    Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
+        if (left.second != null) Text(text = left.first, color = left.second!!)
+        else Text(text = left.first)
+        if (right.second != null) Text(text = right.first, color = right.second!!)
+        else Text(text = right.first)
+    }
+}
+
 @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)) {
@@ -212,7 +245,11 @@ private fun MapDataCards(data: MapData) {
                 Text(text = stringResource(R.string.map_qth, data.qthLoc))
             }
         }
-        Text(text = osmText, fontSize = 14.sp, modifier = Modifier.align(Alignment.BottomCenter))
+        Text(
+            text = stringResource(R.string.map_copyright),
+            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)
@@ -221,113 +258,250 @@ private fun MapDataCards(data: MapData) {
         }
     }
 }
+// endregion
 
+// region Map overlay helpers
 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 {
+        val overlay = mapView.overlays[OVERLAY_STATION]
+        if (overlay is Marker) {
+            overlay.position = GeoPoint(stationPos.latitude, stationPos.longitude)
+        } else {
+            mapView.overlays[OVERLAY_STATION] = 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)
+                setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
+                icon = ContextCompat.getDrawable(mapView.context, R.drawable.ic_position)
+                position = GeoPoint(stationPos.latitude, stationPos.longitude)
             }
         }
-        mapView.overlays[3] = markers
-        mapView.invalidate()
-    } catch (exception: Exception) {
-        println(exception)
+    } catch (e: Exception) {
+        println(e)
     }
 }
 
-private fun getCustomTextIcon(textLabel: String, mapView: MapView): Drawable {
-    textPaint.getTextBounds(textLabel, 0, textLabel.length, labelRect)
+/** Pool of reusable Marker objects keyed by satellite name, to avoid re-creation every frame */
+private val markerPool = HashMap<String, Marker>()
+private var lastMapView: MapView? = null
+
+private fun setPositions(
+    posMap: Map<OrbitalObject, GeoPos>,
+    mapView: MapView,
+    action: (OrbitalObject) -> Unit
+) {
+    try {
+        // Clear caches when the MapView instance changes (e.g. config change)
+        if (lastMapView !== mapView) {
+            lastMapView = mapView
+            markerPool.clear()
+            iconCache.evictAll()
+            footprintPolyline = null
+            footprintPoints = null
+        }
+        // Reuse the existing FolderOverlay — creating a new one and replacing it
+        // causes osmdroid to detach shared Marker objects, making them invisible.
+        val folder = mapView.overlays[OVERLAY_POSITIONS] as? FolderOverlay ?: FolderOverlay().also {
+            mapView.overlays[OVERLAY_POSITIONS] = it
+        }
+        folder.items.clear()
+
+        val activeNames = HashSet<String>(posMap.size)
+        posMap.forEach { (satellite, geoPos) ->
+            val name = satellite.data.name
+            activeNames.add(name)
+            val marker = markerPool.getOrPut(name) {
+                Marker(mapView).apply {
+                    setInfoWindow(null)
+                    setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
+                    icon = getCachedTextIcon(name, mapView)
+                }
+            }
+            // Update position in-place — reuse existing GeoPoint if available
+            val pos = marker.position
+            if (pos != null) {
+                pos.latitude = geoPos.latitude
+                pos.longitude = geoPos.longitude
+            } else {
+                marker.position = GeoPoint(geoPos.latitude, geoPos.longitude)
+            }
+            marker.setOnMarkerClickListener { _, _ ->
+                action(satellite)
+                true
+            }
+            folder.add(marker)
+        }
+        // Evict markers for satellites no longer tracked
+        val iter = markerPool.keys.iterator()
+        while (iter.hasNext()) {
+            if (iter.next() !in activeNames) iter.remove()
+        }
+    } catch (e: Exception) {
+        println(e)
+    }
+}
+
+private fun getCachedTextIcon(name: String, mapView: MapView): Drawable {
+    iconCache[name]?.let { return it }
+    val labelRect = Rect()
+    textPaint.getTextBounds(name, 0, name.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)
+        drawText(name, iconSize / 2f, height - iconSize, textPaint)
     }
-    return bitmap.toDrawable(mapView.context.resources)
+    val drawable = bitmap.toDrawable(mapView.context.resources)
+    iconCache.put(name, drawable)
+    return drawable
 }
 
 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)
+                setPoints(track.map { GeoPoint(it.latitude, it.longitude) })
                 outlinePaint.set(trackPaint)
                 trackOverlay.add(this)
             }
         }
-        mapView.overlays[1] = trackOverlay
-    } catch (exception: Exception) {
-        println(exception)
+        mapView.overlays[OVERLAY_TRACK] = trackOverlay
+    } catch (e: Exception) {
+        println(e)
     }
 }
 
+/** Reusable footprint Polyline — created once, points updated in-place each frame */
+private var footprintPolyline: Polyline? = null
+private var footprintPoints: ArrayList<GeoPoint>? = null
+
 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)
+        val rangeCircle = orbitalPos.getRangeCircle()
+        var pts = footprintPoints
+        if (pts == null || pts.size != rangeCircle.size) {
+            pts = ArrayList(rangeCircle.size)
+            for (gp in rangeCircle) pts.add(GeoPoint(gp.latitude, gp.longitude))
+            footprintPoints = pts
+        } else {
+            for (i in rangeCircle.indices) {
+                pts[i].latitude = rangeCircle[i].latitude
+                pts[i].longitude = rangeCircle[i].longitude
+            }
         }
-        mapView.overlays[2] = footprintOverlay
-    } catch (exception: Exception) {
-        println(exception)
+        val polyline = footprintPolyline ?: Polyline().apply {
+            outlinePaint.set(footprintPaint)
+            footprintPolyline = this
+        }
+        polyline.setPoints(pts)
+        mapView.overlays[OVERLAY_FOOTPRINT] = polyline
+    } catch (e: Exception) {
+        println(e)
     }
 }
 
+/**
+ * Update the NightOverlay with the current sub-solar position.
+ * The overlay is created once and kept in OVERLAY_TERMINATOR; only its
+ * sunLatDeg/sunLonDeg fields are updated each tick so osmdroid redraws it.
+ */
+private fun setTerminator(sunLatDeg: Double, sunLonDeg: Double, mapView: MapView) {
+    try {
+        val overlay = mapView.overlays[OVERLAY_TERMINATOR]
+        if (overlay is MapNightOverlay) {
+            overlay.sunLatDeg = sunLatDeg
+            overlay.sunLonDeg = sunLonDeg
+        } else {
+            mapView.overlays[OVERLAY_TERMINATOR] = MapNightOverlay().apply {
+                this.sunLatDeg = sunLatDeg
+                this.sunLonDeg = sunLonDeg
+            }
+        }
+    } catch (e: Exception) {
+        println(e)
+    }
+}
+
+/** Place an ic_sun icon marker at the sub-solar point. */
+private fun setSubSolarPoint(sunLatDeg: Double, sunLonDeg: Double, mapView: MapView) {
+    try {
+        val overlay = mapView.overlays[OVERLAY_SUN]
+        val sunPos = GeoPoint(sunLatDeg, sunLonDeg)
+        if (overlay is Marker) {
+            overlay.position = sunPos
+        } else {
+            val iconSize = 48
+            val bmp = createBitmap(iconSize, iconSize)
+            ContextCompat.getDrawable(mapView.context, R.drawable.ic_sun)?.apply {
+                setBounds(0, 0, iconSize, iconSize)
+                colorFilter = sunIconPaint.colorFilter
+                draw(Canvas(bmp))
+            }
+            mapView.overlays[OVERLAY_SUN] = Marker(mapView).apply {
+                setInfoWindow(null)
+                setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
+                icon = bmp.toDrawable(mapView.context.resources)
+                position = sunPos
+            }
+        }
+    } catch (e: Exception) {
+        println(e)
+    }
+}
+
+/** Place an ic_moon icon marker at the sub-lunar point. */
+private fun setMoonPosition(moonLatDeg: Double, moonLonDeg: Double, mapView: MapView) {
+    try {
+        val overlay = mapView.overlays[OVERLAY_MOON]
+        val moonPos = GeoPoint(moonLatDeg, moonLonDeg)
+        if (overlay is Marker) {
+            overlay.position = moonPos
+        } else {
+            val iconSize = 48
+            val bmp = createBitmap(iconSize, iconSize)
+            val c = Canvas(bmp)
+            ContextCompat.getDrawable(mapView.context, R.drawable.ic_moon)?.apply {
+                setBounds(0, 0, iconSize, iconSize)
+                colorFilter = moonIconPaint.colorFilter
+                draw(c)
+            }
+            mapView.overlays[OVERLAY_MOON] = Marker(mapView).apply {
+                setInfoWindow(null)
+                setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
+                icon = bmp.toDrawable(mapView.context.resources)
+                position = moonPos
+            }
+        }
+    } catch (e: Exception) {
+        println(e)
+    }
+}
+// endregion
+
+// region MapView lifecycle
 @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() })
+    val isVertical = isVerticalLayout()
+    val mapView = remember {
+        MapView(context).apply {
+            setMultiTouchControls(true)
+            setUseDataConnection(false)
+            setTileSource(tileSource)
+            minZoomLevel = getMinZoom(resources.displayMetrics.heightPixels, isVertical)
+            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(createColorFilter())
+            setScrollableAreaLimitLatitude(maxLat, minLat, 0)
+            overlays.addAll(Array(OVERLAY_COUNT) { FolderOverlay() })
+        }
     }
-    // Makes MapView follow the lifecycle of this composable
     val lifecycleObserver = rememberMapViewLifecycleObserver(mapView)
     val lifecycle = LocalLifecycleOwner.current.lifecycle
     DisposableEffect(lifecycle) {
@@ -348,8 +522,7 @@ private fun rememberMapViewLifecycleObserver(mapView: MapView) = remember(mapVie
     }
 }
 
-@Composable
-private fun getColorFilter(): ColorMatrixColorFilter {
+private fun createColorFilter(): 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)
@@ -358,8 +531,8 @@ private fun getColorFilter(): ColorMatrixColorFilter {
     return ColorMatrixColorFilter(negative)
 }
 
-@Composable
-private fun getMinZoom(screenHeight: Int): Double {
-    if (!isVerticalLayout()) return 3.5
+private fun getMinZoom(screenHeight: Int, isVertical: Boolean): Double {
+    if (!isVertical) return 3.5
     return MapView.getTileSystem().getLatitudeZoom(maxLat, minLat, screenHeight)
 }
+// endregion

feature/map/src/main/java/com/rtbishop/look4sat/feature/map/MapState.kt

@@ -23,21 +23,25 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 
 data class MapState(
-    val mapData: MapData?,
-    val isLightUi: Boolean,
-    val stationPosition: GeoPos?,
+    val mapData: MapData? = null,
+    val isLightUi: Boolean = false,
+    val isUtc: Boolean = false,
+    val stationPosition: GeoPos? = null,
     val orbitalPass: OrbitalPass,
-    val track: List<List<GeoPos>>?,
-    val footprint: OrbitalPos?,
-    val positions: Map<OrbitalObject, GeoPos>?,
-    val sendAction: (MapAction) -> Unit
+    val track: List<List<GeoPos>>? = null,
+    val footprint: OrbitalPos? = null,
+    val positions: Map<OrbitalObject, GeoPos>? = null,
+    val sunLatDeg: Double = 0.0,
+    val sunLonDeg: Double = 0.0,
+    val moonLatDeg: Double = 0.0,
+    val moonLonDeg: Double = 0.0
 )
 
-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()
+sealed interface 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(

feature/map/src/main/java/com/rtbishop/look4sat/feature/map/MapViewModel.kt

@@ -18,46 +18,50 @@
 package com.rtbishop.look4sat.feature.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.core.domain.predict.CelestialComputer
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
-import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.utility.clipLat
 import com.rtbishop.look4sat.core.domain.utility.clipLon
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
+import com.rtbishop.look4sat.core.domain.utility.toMapGeoPos
 import com.rtbishop.look4sat.core.domain.utility.toDegrees
 import com.rtbishop.look4sat.core.domain.utility.toTimerString
 import com.rtbishop.look4sat.core.presentation.getDefaultPass
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.coroutineScope
 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
 import java.util.Date
 
-class MapViewModel(private val satelliteRepo: ISatelliteRepo, settingsRepo: ISettingsRepo) :
-    ViewModel() {
+class MapViewModel(
+    private val satelliteRepo: ISatelliteRepo,
+    private val 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
+            isUtc = settingsRepo.otherSettings.value.stateOfUtc,
+            orbitalPass = defaultPass
         )
     )
     private var allPasses = satelliteRepo.passes.value
@@ -68,10 +72,16 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, settingsRepo: ISet
     val uiState: StateFlow<MapState> = _uiState
 
     init {
-        selectDefaultSatellite(-1)
+        viewModelScope.launch {
+            settingsRepo.otherSettings.collectLatest { settings ->
+                _uiState.update { it.copy(isUtc = settings.stateOfUtc) }
+            }
+        }
+        val (selectedCatNum, _) = satelliteRepo.selectedPass.value
+        selectDefaultSatellite(if (selectedCatNum != 0) selectedCatNum else -1)
     }
 
-    private fun handleAction(action: MapAction) {
+    fun onAction(action: MapAction) {
         when (action) {
             MapAction.SelectPrev -> scrollSelection(true)
             MapAction.SelectNext -> scrollSelection(false)
@@ -118,63 +128,94 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, settingsRepo: ISet
                 val dateNow = Date()
                 getStationPosition()
                 getSatTrack(orbitalObject, stationPos, dateNow)
+                // Scale update interval based on satellite count to avoid excessive CPU usage
+                val effectiveRate = when {
+                    allSatellites.size > 5000 -> maxOf(updateFreq, 3000L)
+                    allSatellites.size > 1000 -> maxOf(updateFreq, 2000L)
+                    else -> updateFreq
+                }
                 while (isActive) {
                     dateNow.time = System.currentTimeMillis()
-                    getPositions(allSatellites, stationPos, dateNow)
-                    getSatFootprint(orbitalObject, stationPos, dateNow)
-                    getSatData(orbitalObject, stationPos, dateNow)
-                    delay(updateFreq)
+                    updateMapState(orbitalObject, allSatellites, stationPos, dateNow)
+                    delay(effectiveRate)
                 }
             }
         }
     }
 
-    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()
+    /**
+     * Combined update: computes all satellite positions in parallel, then derives
+     * the selected satellite's footprint and info panel data from the same batch,
+     * and emits a single state update to avoid redundant recompositions.
+     */
+    private suspend fun updateMapState(
+        selected: OrbitalObject,
+        orbitalObjects: List<OrbitalObject>,
+        pos: GeoPos,
+        date: Date
+    ) {
+        // 1. Compute all positions in parallel, collecting full OrbitalPos for the selected sat
+        val positionsMap = HashMap<OrbitalObject, GeoPos>(orbitalObjects.size)
+        var selectedSatPos: OrbitalPos? = null
+
+        coroutineScope {
+            // Chunk satellites to balance parallelism vs coroutine overhead
+            val chunkSize = maxOf(1, orbitalObjects.size / PARALLEL_CHUNKS)
+            val deferreds = orbitalObjects.chunked(chunkSize).map { chunk ->
+                async {
+                    val localPositions = ArrayList<Pair<OrbitalObject, GeoPos>>(chunk.size)
+                    var localSelectedPos: OrbitalPos? = null
+                    for (satellite in chunk) {
+                        val satPos = satelliteRepo.getPosition(satellite, pos, date.time)
+                        localPositions.add(satellite to satPos.toMapGeoPos())
+                        if (satellite === selected) {
+                            localSelectedPos = satPos
+                        }
+                    }
+                    Pair(localPositions, localSelectedPos)
+                }
+            }
+            for ((localPositions, localSelectedPos) in deferreds.awaitAll()) {
+                for (pair in localPositions) {
+                    positionsMap[pair.first] = pair.second
+                }
+                if (localSelectedPos != null) {
+                    selectedSatPos = localSelectedPos
+                }
             }
-            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)
+        // 2. Derive footprint, info data, sun and moon position from already-computed state
+        val satPos = selectedSatPos ?: satelliteRepo.getPosition(selected, pos, date.time)
+        val footprint = satPos
+        val mapData = buildMapData(selected, satPos, date)
+        val sunPos = CelestialComputer.getSunPosition(stationPos, date.time)
+        val moonPos = CelestialComputer.getMoonPosition(stationPos, date.time)
+
+        // 3. Single atomic state update — one recomposition per cycle
+        _uiState.update {
+            it.copy(
+                positions = positionsMap,
+                footprint = footprint,
+                mapData = mapData.first,
+                orbitalPass = mapData.second,
+                sunLatDeg = sunPos.latitude,
+                sunLonDeg = sunPos.longitude,
+                moonLatDeg = moonPos.declination, // sub-lunar latitude = declination
+                moonLonDeg = if (moonPos.gha <= 180.0) -moonPos.gha else 360.0 - moonPos.gha
+            )
         }
-        _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) {
+    /**
+     * Builds the map info panel data from an already-computed OrbitalPos.
+     * No additional getPosition() call needed.
+     */
+    private fun buildMapData(
+        sat: OrbitalObject,
+        satPos: OrbitalPos,
+        date: Date
+    ): Pair<MapData, OrbitalPass> {
         var orbitalPass = defaultPass
         var aosTime = 0L.toTimerString()
         var isTimeAos = true
@@ -182,23 +223,25 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, settingsRepo: ISet
             ?.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()
+                    when {
+                        date.time < satPass.aosTime -> {
+                            // Pass hasn't started yet — count down to AOS
+                            isTimeAos = true
+                            aosTime = (satPass.aosTime - date.time).toTimerString()
+                        }
+
+                        date.time < satPass.losTime -> {
+                            // Pass is in progress — count down to LOS
+                            isTimeAos = false
+                            aosTime = (satPass.losTime - date.time).toTimerString()
+                        }
+                        // else: pass has ended (losTime <= date.time) — keep default "00:00:00"
                     }
                 }
             }
-        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 osmPos = satPos.toMapGeoPos()
         val qthLoc = positionToQth(osmPos.latitude, osmPos.longitude) ?: "-- --"
         val velocity = satPos.getOrbitalVelocity()
         val phase = satPos.phase.toDegrees()
@@ -219,15 +262,46 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, settingsRepo: ISet
             phase,
             visibility
         )
-        _uiState.update { it.copy(mapData = satData, orbitalPass = orbitalPass) }
+        return satData to orbitalPass
+    }
+
+    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 currentPosition = satPos.toMapGeoPos()
+            if (oldLongitude < -170.0 && currentPosition.longitude > 170.0) {
+                // adding left terminal position
+                currentTrack.add(GeoPos(currentPosition.latitude, -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(currentPosition.latitude, 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) }
     }
 
     companion object {
-        val Factory: ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
+        /** Number of parallel chunks for satellite position computation */
+        private const val PARALLEL_CHUNKS = 4
+
+        fun factory(container: IMainContainer) = viewModelFactory {
             initializer {
-                val container = (this[applicationKey] as IContainerProvider).getMainContainer()
-                MapViewModel(container.satelliteRepo, container.settingsRepo)
+                MapViewModel(
+                    satelliteRepo = container.satelliteRepo,
+                    settingsRepo = container.settingsRepo
+                )
             }
         }
     }

feature/passes/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    alias(libs.plugins.convention.composeFeaturePlugin)
+    alias(libs.plugins.convention.featurePlugin)
 }
 
 android {

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesDialog.kt

@@ -32,15 +32,18 @@ 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.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableDoubleStateOf
 import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
@@ -52,6 +55,7 @@ import com.rtbishop.look4sat.core.presentation.LocalSpacing
 import com.rtbishop.look4sat.core.presentation.MainTheme
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.SharedDialog
+import com.rtbishop.look4sat.core.presentation.elevationColor
 
 private val allModes = listOf(
     "AFSK", "AFSK S-Net", "AFSK SALSAT", "AHRPT", "AM", "APT", "BPSK", "BPSK PMT-A3",
@@ -61,34 +65,50 @@ private val allModes = listOf(
     "PSK", "PSK31", "PSK63", "QPSK", "QPSK31", "QPSK63", "SSTV", "USB", "WSJT"
 )
 
+private val hourSteps = listOf(1, 2, 4, 8, 12, 24, 48, 72, 96, 120, 144, 168, 192, 216, 240)
+
 @Preview
 @Composable
 private fun PassesDialogPreview() {
-    MainTheme { PassesDialog(24, 16.0, {}) { _, _ -> } }
+    MainTheme { PassesDialog(24, 16.0, true, {}) { _, _, _ -> } }
 }
 
 @Composable
-fun PassesDialog(hours: Int, elevation: Double, cancel: () -> Unit, accept: (Int, Double) -> Unit) {
-    val hoursValue = remember { mutableIntStateOf(hours) }
+internal fun PassesDialog(
+    hours: Int,
+    elevation: Double,
+    showDeepSpace: Boolean,
+    cancel: () -> Unit,
+    accept: (Int, Double, Boolean) -> Unit
+) {
+    val hoursIndex = remember { mutableIntStateOf(hourSteps.indexOfFirst { it >= hours }.coerceAtLeast(0)) }
     val elevationValueNew = remember { mutableDoubleStateOf(elevation) }
+    var deepSpaceEnabled by remember { mutableStateOf(showDeepSpace) }
     val onAccept = {
-        accept(hoursValue.intValue, elevationValueNew.doubleValue).also { cancel() }
+        accept(hourSteps[hoursIndex.intValue], elevationValueNew.doubleValue, deepSpaceEnabled).also { cancel() }
     }
     SharedDialog(title = stringResource(R.string.pass_filter_title), onCancel = cancel, onAccept = onAccept) {
+        ToggleRow(
+            title = stringResource(R.string.pass_filter_deep_space),
+            checked = deepSpaceEnabled,
+            onCheckedChange = { deepSpaceEnabled = it }
+        )
         SliderRow(
             title = stringResource(R.string.pass_filter_elev),
             value = elevationValueNew.doubleValue,
-            valuePostfix = "°",
+            displayValue = "${elevationValueNew.doubleValue.toInt()}°",
             valueResId = R.drawable.ic_elevation,
-            valueRange = 0f..60f
+            valueRange = 0f..60f,
+            accentColor = elevationColor(elevationValueNew.doubleValue)
         ) { elevationValueNew.doubleValue = it.toDouble() }
         SliderRow(
             title = stringResource(R.string.pass_filter_hours),
-            value = hoursValue.intValue.toDouble(),
-            valuePostfix = "h",
+            value = hoursIndex.intValue.toDouble(),
+            displayValue = "${hourSteps[hoursIndex.intValue]}h",
             valueResId = R.drawable.ic_clock,
-            valueRange = 1f..240f
-        ) { hoursValue.intValue = it.toInt() }
+            valueRange = 0f..(hourSteps.size - 1).toFloat(),
+            steps = hourSteps.size - 2
+        ) { hoursIndex.intValue = it.toInt().coerceIn(0, hourSteps.size - 1) }
     }
 }
 
@@ -96,9 +116,11 @@ fun PassesDialog(hours: Int, elevation: Double, cancel: () -> Unit, accept: (Int
 private fun SliderRow(
     title: String,
     value: Double,
-    valuePostfix: String,
+    displayValue: String,
     valueResId: Int,
     valueRange: ClosedFloatingPointRange<Float>,
+    steps: Int = 0,
+    accentColor: Color = MaterialTheme.colorScheme.primary,
     onChange: (Float) -> Unit
 ) {
     Column(
@@ -119,17 +141,17 @@ private fun SliderRow(
             Icon(
                 painter = painterResource(id = valueResId),
                 contentDescription = null,
-                tint = MaterialTheme.colorScheme.primary,
+                tint = accentColor,
                 modifier = Modifier.size(20.dp)
             )
             Text(
-                text = "${value.toInt()}$valuePostfix",
+                text = displayValue,
                 fontSize = 18.sp,
                 fontWeight = FontWeight.Medium,
-                color = MaterialTheme.colorScheme.primary
+                color = accentColor
             )
         }
-        Slider(value = value.toFloat(), onValueChange = onChange, valueRange = valueRange)
+        Slider(value = value.toFloat(), onValueChange = onChange, valueRange = valueRange, steps = steps)
     }
 }
 
@@ -140,12 +162,12 @@ private fun RadiosDialogPreview() {
 }
 
 @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)
+internal fun RadiosDialog(modes: List<String>, cancel: () -> Unit, accept: (List<String>) -> Unit) {
+    val selected = remember { mutableStateOf(modes.toSet()) }
+    val toggle = { mode: String ->
+        selected.value = if (mode in selected.value) selected.value - mode else selected.value + mode
     }
-    val onAccept = { accept(selected.toList()).also { cancel() } }
+    val onAccept = { accept(selected.value.toList()).also { cancel() } }
     SharedDialog(title = stringResource(R.string.pass_modes_title), onCancel = cancel, onAccept = onAccept) {
         LazyVerticalGrid(
             columns = GridCells.Adaptive(240.dp),
@@ -156,34 +178,49 @@ fun RadiosDialog(modes: List<String>, cancel: () -> Unit, accept: (List<String>)
             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)
-                        )
-                    }
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .background(MaterialTheme.colorScheme.surface)
+                        .clickable { toggle(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 = item in selected.value,
+                        onCheckedChange = null,
+                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+                    )
                 }
             }
         }
     }
 }
+
+@Composable
+private fun ToggleRow(title: String, checked: Boolean, onCheckedChange: (Boolean) -> Unit) {
+    Row(
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+    ) {
+        Text(
+            text = title,
+            fontSize = 16.sp,
+            modifier = Modifier.weight(1f),
+            color = MaterialTheme.colorScheme.onSurface
+        )
+        Switch(checked = checked, onCheckedChange = onCheckedChange)
+    }
+}

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesScreen.kt

@@ -17,6 +17,11 @@
  */
 package com.rtbishop.look4sat.feature.passes
 
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
@@ -29,23 +34,23 @@ 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.HorizontalDivider
 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.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
@@ -55,59 +60,60 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
-import androidx.navigation.NavGraphBuilder
-import androidx.navigation.compose.composable
 import com.rtbishop.look4sat.core.domain.predict.DeepSpaceObject
 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 com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.presentation.EmptyListCard
 import com.rtbishop.look4sat.core.presentation.IconCard
 import com.rtbishop.look4sat.core.presentation.InfoDialog
 import com.rtbishop.look4sat.core.presentation.MainTheme
 import com.rtbishop.look4sat.core.presentation.NextPassRow
 import com.rtbishop.look4sat.core.presentation.R
-import com.rtbishop.look4sat.core.presentation.Screen
 import com.rtbishop.look4sat.core.presentation.ScreenColumn
+import com.rtbishop.look4sat.core.presentation.SwipeableItem
 import com.rtbishop.look4sat.core.presentation.TimerRow
 import com.rtbishop.look4sat.core.presentation.TopBar
+import com.rtbishop.look4sat.core.presentation.elevationColor
 import com.rtbishop.look4sat.core.presentation.infiniteMarquee
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
+import java.util.TimeZone
 
-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
+fun PassesDestination(navigateToRadar: (Int, Long) -> Unit) {
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val viewModel: PassesViewModel = viewModel(factory = PassesViewModel.factory(container))
+    val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
+    PassesScreen(uiState, viewModel::onAction, 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) }
+private fun PassesScreen(
+    uiState: PassesState,
+    onAction: (PassesAction) -> Unit,
+    navigateToRadar: (Int, Long) -> Unit
+) {
     if (uiState.isPassesDialogShown) {
         PassesDialog(
             hours = uiState.hours,
             elevation = uiState.elevation,
-            cancel = showPassesDialog
-        ) { hours, elevation ->
-            uiState.takeAction(PassesAction.FilterPasses(hours, elevation))
+            showDeepSpace = uiState.showDeepSpace,
+            cancel = { onAction(PassesAction.TogglePassesDialog) }
+        ) { hours, elevation, showDeepSpace ->
+            onAction(PassesAction.FilterPasses(hours, elevation, showDeepSpace))
         }
     }
     if (uiState.isRadiosDialogShown) {
-        RadiosDialog(modes = uiState.modes, cancel = showRadiosDialog) { modes ->
-            uiState.takeAction(PassesAction.FilterRadios(modes))
+        RadiosDialog(
+            modes = uiState.modes,
+            cancel = { onAction(PassesAction.ToggleRadiosDialog) }
+        ) { modes ->
+            onAction(PassesAction.FilterRadios(modes))
         }
     }
     if (uiState.shouldSeeWhatsNew) {
@@ -115,35 +121,37 @@ private fun PassesScreen(uiState: PassesState, navigateToRadar: (Int, Long) -> U
             title = stringResource(R.string.pass_whatsnew_title),
             text = stringResource(R.string.pass_whatsnew_message)
         ) {
-            uiState.takeAction(PassesAction.DismissWhatsNew)
+            onAction(PassesAction.DismissWhatsNew)
         }
     }
-    val gridState = rememberLazyGridState()
     ScreenColumn(
         topBar = { isVerticalLayout ->
             TopBar(
                 isVerticalLayout = isVerticalLayout,
                 startAction = {
-                    IconCard(action = showPassesDialog, resId = R.drawable.ic_filter)
+                    IconCard(action = { onAction(PassesAction.TogglePassesDialog) }, resId = R.drawable.ic_filter)
                 },
                 topInfo = {
                     TimerRow(timeString = uiState.nextTime, isTimeAos = uiState.isNextTimeAos)
                 },
                 bottomInfo = {
-                    NextPassRow(pass = uiState.nextPass)
+                    NextPassRow(pass = uiState.nextPass, isUtc = uiState.isUtc)
                 },
                 endAction = {
-                    IconCard(action = showRadiosDialog, resId = R.drawable.ic_radios)
+                    IconCard(action = { onAction(PassesAction.ToggleRadiosDialog) }, resId = R.drawable.ic_radios)
                 }
             )
         }
     ) { _ ->
         PassesList(
             isRefreshing = uiState.isRefreshing,
+            isUtc = uiState.isUtc,
             passes = uiState.itemsList,
+            groupedPasses = uiState.groupedPasses,
+            sunTimes = uiState.sunTimes,
+            focusedCatNum = uiState.focusedCatNum,
             navigateToRadar = navigateToRadar,
-            refreshPasses = refreshList,
-            gridState = gridState
+            onAction = onAction
         )
     }
 }
@@ -152,10 +160,13 @@ private fun PassesScreen(uiState: PassesState, navigateToRadar: (Int, Long) -> U
 @Composable
 private fun PassesList(
     isRefreshing: Boolean,
+    isUtc: Boolean,
     passes: List<OrbitalPass>,
+    groupedPasses: Map<String, List<OrbitalPass>>,
+    sunTimes: Map<String, Pair<String, String>>,
+    focusedCatNum: Int?,
     navigateToRadar: (Int, Long) -> Unit,
-    refreshPasses: () -> Unit,
-    gridState: LazyGridState
+    onAction: (PassesAction) -> Unit
 ) {
     val isVerticalLayout = isVerticalLayout()
     val refreshState = rememberPullToRefreshState()
@@ -163,7 +174,7 @@ private fun PassesList(
         PullToRefreshBox(
             isRefreshing = isRefreshing,
             state = refreshState,
-            onRefresh = refreshPasses,
+            onRefresh = { onAction(PassesAction.RefreshPasses) },
             indicator = {
                 PullToRefreshDefaults.Indicator(
                     state = refreshState,
@@ -177,18 +188,37 @@ private fun PassesList(
             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
-                        )
+                AnimatedContent(
+                    targetState = focusedCatNum,
+                    transitionSpec = { fadeIn(tween(200)) togetherWith fadeOut(tween(200)) },
+                    label = "PassesFocusTransition"
+                ) { targetFocus ->
+                    LazyVerticalGrid(columns = GridCells.Adaptive(320.dp), modifier = Modifier.fillMaxSize()) {
+                        for ((dateLabel, dayPasses) in groupedPasses) {
+                            val headerVisible = targetFocus == null || dayPasses.any { it.catNum == targetFocus }
+                            if (headerVisible) {
+                                stickyHeader(key = "header_$dateLabel") {
+                                    val (rise, set) = sunTimes[dateLabel] ?: ("--:--" to "--:--")
+                                    StickyDateHeader(label = dateLabel, sunriseTime = rise, sunsetTime = set)
+                                }
+                            }
+                            val visiblePasses = if (targetFocus == null) dayPasses
+                            else dayPasses.filter { it.catNum == targetFocus }
+                            items(items = visiblePasses, key = { item -> item.catNum + item.aosTime }) { pass ->
+                                SwipeableItem(
+                                    onSwipeRight = { onAction(PassesAction.FocusCatNum(pass.catNum)) },
+                                    onSwipeLeft = { onAction(PassesAction.ClearFocus) }
+                                ) {
+                                    PassItem(
+                                        pass = pass,
+                                        navigateToRadar = navigateToRadar,
+                                        modifier = Modifier.animateItem(),
+                                        isVerticalLayout = isVerticalLayout,
+                                        isUtc = isUtc
+                                    )
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -196,13 +226,52 @@ private fun PassesList(
     }
 }
 
+@Composable
+private fun StickyDateHeader(label: String, sunriseTime: String, sunsetTime: String) {
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.SpaceBetween,
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest)
+            .padding(horizontal = 12.dp, vertical = 4.dp)
+    ) {
+        Text(
+            text = label,
+            fontSize = 14.sp,
+            fontWeight = FontWeight.Normal,
+            color = MaterialTheme.colorScheme.primary
+        )
+        Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_sun),
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.size(16.dp)
+                )
+                Text(text = sunriseTime, fontSize = 14.sp, color = MaterialTheme.colorScheme.onSurface)
+            }
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_moon),
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurface,
+                    modifier = Modifier.size(16.dp)
+                )
+                Text(text = sunsetTime, fontSize = 14.sp, color = MaterialTheme.colorScheme.onSurface)
+            }
+        }
+    }
+}
+
 @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, { _, _ -> }) }
+    MainTheme { PassItem(pass = pass, { _, _ -> }) }
 }
 
 @Preview(showBackground = true)
@@ -211,126 +280,137 @@ 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, { _, _ -> }) }
+    MainTheme { PassItem(pass = pass, { _, _ -> }) }
 }
 
 @Composable
-private fun NearEarthPass(
+private fun PassItem(
     pass: OrbitalPass,
     navigateToRadar: (Int, Long) -> Unit,
     modifier: Modifier = Modifier,
-    isVerticalLayout: Boolean = true
+    isVerticalLayout: Boolean = true,
+    isUtc: Boolean = false
 ) {
     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)
+    val timeZone = remember(isUtc) {
+        if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
+    }
+    val sdfTime = remember(isUtc) {
+        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+    }
+    val aosTimeStr = remember(pass.aosTime, isUtc) { sdfTime.format(Date(pass.aosTime)) }
+    val losTimeStr = remember(pass.losTime, isUtc) { sdfTime.format(Date(pass.losTime)) }
+    val durationStr = remember(pass.aosTime, pass.losTime) {
+        val seconds = (pass.losTime - pass.aosTime) / 1000
+        "${seconds / 60}m ${seconds % 60}s"
+    }
+
+    Column(
+        modifier = modifier.clickable { navigateToRadar(pass.catNum, pass.aosTime) }
+    ) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy(1.dp),
+            modifier = Modifier
+                .fillMaxWidth()
+                .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,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                val elevColor = elevationColor(pass.maxElevation)
+                Icon(
+                    painter = painterResource(id = R.drawable.ic_elevation),
+                    contentDescription = null,
+                    tint = elevColor,
+                    modifier = Modifier.size(16.dp)
+                )
+                Spacer(modifier = Modifier.width(4.dp))
+                Text(
+                    text = "${pass.maxElevation}°",
+                    color = elevColor
+                )
+            }
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.SpaceBetween,
+                modifier = Modifier.fillMaxWidth()
             ) {
-                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()
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.Start,
+                    verticalAlignment = Alignment.CenterVertically
                 ) {
-                    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))
+                    if (pass.isDeepSpace) {
                         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
+                            text = stringResource(R.string.pass_deep_space),
+                            fontSize = 15.sp,
+                            color = MaterialTheme.colorScheme.onSurface
                         )
+                    } else {
+                        Text(text = durationStr, fontSize = 15.sp, color = MaterialTheme.colorScheme.onSurface)
                     }
                 }
                 Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    modifier = Modifier.fillMaxWidth()
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.Center,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(text = "${pass.altitude} km", fontSize = 15.sp, color = MaterialTheme.colorScheme.onSurface)
+                }
+                Row(
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.End,
+                    verticalAlignment = Alignment.CenterVertically
                 ) {
-                    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
+                        text = stringResource(
+                            id = R.string.pass_aosLos,
+                            pass.aosAzimuth.toInt(),
+                            pass.losAzimuth.toInt()
+                        ),
+                        fontSize = 15.sp,
+                        color = MaterialTheme.colorScheme.onSurface
                     )
                 }
             }
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.SpaceBetween,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                val defaultTime = "   - - : - -   "
+                Text(
+                    text = if (pass.isDeepSpace) defaultTime else aosTimeStr,
+                    fontSize = 15.sp,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                LinearProgressIndicator(
+                    progress = { if (pass.isDeepSpace) 100f else pass.progress },
+                    drawStopIndicator = {},
+                    modifier = Modifier.fillMaxWidth(0.75f)
+                )
+                Text(
+                    text = if (pass.isDeepSpace) defaultTime else losTimeStr,
+                    fontSize = 15.sp,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            }
         }
+        HorizontalDivider(thickness = 2.dp, color = MaterialTheme.colorScheme.background)
     }
 }

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesState.kt

@@ -20,26 +20,31 @@ package com.rtbishop.look4sat.feature.passes
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 
 data class PassesState(
-    val isPassesDialogShown: Boolean,
-    val isRadiosDialogShown: Boolean,
-    val isRefreshing: Boolean,
-    val isUtc: Boolean,
+    val isPassesDialogShown: Boolean = false,
+    val isRadiosDialogShown: Boolean = false,
+    val isRefreshing: Boolean = true,
+    val isUtc: Boolean = false,
     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
+    val nextTime: String = "00:00:00",
+    val isNextTimeAos: Boolean = true,
+    val hours: Int = 24,
+    val elevation: Double = 16.0,
+    val showDeepSpace: Boolean = true,
+    val modes: List<String> = emptyList(),
+    val itemsList: List<OrbitalPass> = emptyList(),
+    val groupedPasses: Map<String, List<OrbitalPass>> = emptyMap(),
+    val shouldSeeWhatsNew: Boolean = false,
+    val sunTimes: Map<String, Pair<String, String>> = emptyMap(),
+    val focusedCatNum: Int? = null
 )
 
-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()
+sealed interface PassesAction {
+    data object DismissWhatsNew : PassesAction
+    data class FilterPasses(val hoursAhead: Int, val minElevation: Double, val showDeepSpace: Boolean) : PassesAction
+    data class FilterRadios(val modes: List<String>) : PassesAction
+    data object RefreshPasses : PassesAction
+    data object TogglePassesDialog : PassesAction
+    data object ToggleRadiosDialog : PassesAction
+    data class FocusCatNum(val catNum: Int) : PassesAction
+    data object ClearFocus : PassesAction
 }

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesViewModel.kt

@@ -18,19 +18,18 @@
 package com.rtbishop.look4sat.feature.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.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.predict.CelestialComputer
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
-import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.utility.round
 import com.rtbishop.look4sat.core.domain.utility.toTimerString
 import com.rtbishop.look4sat.core.presentation.getDefaultPass
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -38,110 +37,189 @@ import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
 
 class PassesViewModel(
     private val satelliteRepo: ISatelliteRepo,
     private val settingsRepo: ISettingsRepo
 ) : ViewModel() {
 
+    private val defaultPass = getDefaultPass()
     private val _uiState = MutableStateFlow(
         PassesState(
-            isPassesDialogShown = false,
-            isRadiosDialogShown = false,
-            isRefreshing = true,
             isUtc = settingsRepo.otherSettings.value.stateOfUtc,
-            nextTime = "00:00:00",
-            isNextTimeAos = true,
-            nextPass = getDefaultPass(),
+            nextPass = defaultPass,
             hours = settingsRepo.passesSettings.value.hoursAhead,
             elevation = settingsRepo.passesSettings.value.minElevation,
+            showDeepSpace = settingsRepo.passesSettings.value.showDeepSpace,
             modes = settingsRepo.passesSettings.value.selectedModes,
-            itemsList = emptyList(),
-            shouldSeeWhatsNew = settingsRepo.otherSettings.value.shouldSeeWhatsNew,
-            takeAction = ::handleAction
+            shouldSeeWhatsNew = settingsRepo.otherSettings.value.shouldSeeWhatsNew
         )
     )
-    private var processing: Job? = null
     val uiState: StateFlow<PassesState> = _uiState
 
     init {
+        // Refresh indicator: mirrors the repo's isCalculating state
         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)
+            satelliteRepo.isCalculating.collect { calculating ->
+                _uiState.update { it.copy(isRefreshing = calculating) }
+            }
+        }
+        // React to settings changes: update UTC flag and whatsNew
+        viewModelScope.launch {
+            settingsRepo.otherSettings.collectLatest { settings ->
+                _uiState.update { it.copy(isUtc = settings.stateOfUtc, shouldSeeWhatsNew = settings.shouldSeeWhatsNew) }
+            }
+        }
+        // Main tick loop: reacts to new passes, then ticks every second
+        viewModelScope.launch {
+            satelliteRepo.passes.collectLatest { allPasses ->
+                while (isActive) {
+                    val timeNow = System.currentTimeMillis()
+                    val isUtc = _uiState.value.isUtc
+                    val showDeepSpace = _uiState.value.showDeepSpace
+                    val filtered = allPasses
+                        .let { if (showDeepSpace) it else it.filter { pass -> !pass.isDeepSpace } }
+                    val processed = computePassProgress(filtered, timeNow)
+                    val (nextPass, nextTime, isAos) = resolveNextPass(processed, timeNow)
+                    val sunTimes = computeSunTimes(processed, isUtc)
+                    val grouped = groupPasses(processed, isUtc)
+                    _uiState.update {
+                        it.copy(
+                            itemsList = processed,
+                            groupedPasses = grouped,
+                            sunTimes = sunTimes,
+                            nextPass = nextPass,
+                            nextTime = nextTime,
+                            isNextTimeAos = isAos
+                        )
                     }
+                    delay(1000)
                 }
             }
         }
-        viewModelScope.launch {
-            settingsRepo.otherSettings.collectLatest { settings ->
-                _uiState.update { it.copy(shouldSeeWhatsNew = settings.shouldSeeWhatsNew) }
-            }
-        }
     }
 
-    private fun handleAction(action: PassesAction) {
+    fun onAction(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)
+            is PassesAction.FilterPasses ->
+                applyFilter(action.hoursAhead, action.minElevation, action.showDeepSpace, _uiState.value.modes)
+            is PassesAction.FilterRadios ->
+                applyFilter(_uiState.value.hours, _uiState.value.elevation, _uiState.value.showDeepSpace, action.modes)
             PassesAction.RefreshPasses -> refreshPasses()
-            PassesAction.TogglePassesDialog -> toggleFilterDialog()
-            PassesAction.ToggleRadiosDialog -> toggleRadiosDialog()
+            PassesAction.TogglePassesDialog ->
+                _uiState.update { it.copy(isPassesDialogShown = !it.isPassesDialogShown) }
+            PassesAction.ToggleRadiosDialog ->
+                _uiState.update { it.copy(isRadiosDialogShown = !it.isRadiosDialogShown) }
+            is PassesAction.FocusCatNum -> _uiState.update { it.copy(focusedCatNum = action.catNum) }
+            PassesAction.ClearFocus -> _uiState.update { it.copy(focusedCatNum = null) }
         }
     }
 
-    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) }
+    // Computes sunrise/sunset strings for each unique calendar day in the pass list, plus today for DeepSpace
+    private fun computeSunTimes(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, Pair<String, String>> {
+        val stationPos = settingsRepo.stationPosition.value
+        val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
+        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfTime = SimpleDateFormat("HH:mm", Locale.ENGLISH).also { it.timeZone = tz }
+        val result = LinkedHashMap<String, Pair<String, String>>()
+        // DeepSpace group always shows today's sun times
+        if (passes.any { it.isDeepSpace }) {
+            val riseSet = CelestialComputer.findSunRiseSet(stationPos, System.currentTimeMillis())
+            val rise = if (riseSet.riseTimeMillis > 0) sdfTime.format(Date(riseSet.riseTimeMillis)) else "--:--"
+            val set = if (riseSet.setTimeMillis > 0) sdfTime.format(Date(riseSet.setTimeMillis)) else "--:--"
+            result["DeepSpace (period >225min)"] = rise to set
+        }
+        for (pass in passes) {
+            if (pass.isDeepSpace) continue
+            val label = sdfDate.format(Date(pass.aosTime))
+            if (label in result) continue
+            val riseSet = CelestialComputer.findSunRiseSet(stationPos, pass.aosTime)
+            val rise = if (riseSet.riseTimeMillis > 0) sdfTime.format(Date(riseSet.riseTimeMillis)) else "--:--"
+            val set = if (riseSet.setTimeMillis > 0) sdfTime.format(Date(riseSet.setTimeMillis)) else "--:--"
+            result[label] = rise to set
+        }
+        return result
+    }
+
+    private fun groupPasses(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, List<OrbitalPass>> {
+        val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
+        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val ordered = LinkedHashMap<String, List<OrbitalPass>>()
+        val deepSpace = passes.filter { it.isDeepSpace }
+        if (deepSpace.isNotEmpty()) ordered["DeepSpace (period >225min)"] = deepSpace
+        passes.filter { !it.isDeepSpace }
+            .groupByTo(LinkedHashMap()) { sdfDate.format(Date(it.aosTime)) }
+            .forEach { (k, v) -> ordered[k] = v }
+        return ordered
+    }
+
+    /** Computes live progress for each pass, filtering out expired ones. */
+    private fun computePassProgress(passList: List<OrbitalPass>, time: Long): List<OrbitalPass> {
+        val result = ArrayList<OrbitalPass>(passList.size)
+        for (pass in passList) {
+            if (!pass.isDeepSpace && time > pass.aosTime) {
+                val deltaNow = time.minus(pass.aosTime).toFloat()
+                val deltaTotal = pass.losTime.minus(pass.aosTime).toFloat()
+                val newProgress = (deltaNow / deltaTotal).round(2)
+                if (newProgress >= 1.0f) continue
+                if (newProgress != pass.progress) {
+                    result.add(pass.copy(progress = newProgress))
+                } else {
+                    result.add(pass)
+                }
+            } else {
+                result.add(pass)
+            }
+        }
+        return result
+    }
+
+    /** Resolves the next upcoming or active pass and its countdown timer. */
+    private fun resolveNextPass(
+        passes: List<OrbitalPass>,
+        timeNow: Long
+    ): Triple<OrbitalPass, String, Boolean> {
+        val upcoming = passes.firstOrNull { it.aosTime > timeNow }
+        if (upcoming != null) {
+            return Triple(upcoming, (upcoming.aosTime - timeNow).toTimerString(), true)
+        }
+        if (passes.isNotEmpty()) {
+            val lastPass = passes.last()
+            return Triple(lastPass, (lastPass.losTime - timeNow).toTimerString(), false)
+        }
+        return Triple(defaultPass, "00:00:00", true)
+    }
+
+    private fun applyFilter(
+        hoursAhead: Int,
+        minElevation: Double,
+        showDeepSpace: Boolean,
+        modes: List<String>
+    ) = viewModelScope.launch {
+        settingsRepo.setPassesSettings(PassesSettings(showDeepSpace, hoursAhead, minElevation, modes))
+        _uiState.update {
+            it.copy(hours = hoursAhead, elevation = minElevation, showDeepSpace = showDeepSpace, 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
+        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
+        fun factory(container: IMainContainer) = viewModelFactory {
             initializer {
-                val container = (this[applicationKey] as IContainerProvider).getMainContainer()
-                PassesViewModel(container.satelliteRepo, container.settingsRepo)
+                PassesViewModel(
+                    satelliteRepo = container.satelliteRepo,
+                    settingsRepo = container.settingsRepo
+                )
             }
         }
     }