v4.4.4 - Icom CAT, components, filters and sources tweaks

Co-authored-by: atsunatsu <atsunatsu@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,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "never"

.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,121 @@
+# 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 Celestrak/SatNOGS orbital data, calculates positions via SGP4/SDP4, and predicts passes relative to
+the user's location. Features include polar radar visualization, SSTV image decoding, and ground track mapping. No ads,
+no tracking, no network required after initial data download.
+
+## Architecture & Design
+
+**MVI (Model-View-Intent)** with unidirectional data flow:
+- `State` data class (named `<Feature>State`) exposed via `StateFlow` from ViewModel
+- `Action` sealed interface (named `<Feature>Action`) 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 isolation:**
+- `feature:*` modules depend only on `core:domain` and `core:presentation`.
+- No feature-to-feature dependencies; cross-feature communication goes through core layers.
+
+## Build & Platform
+
+```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**: Version catalog in `gradle/libs.versions.toml` + convention plugins in `build-logic/`
+
+## Tech Stack
+
+- **Compose** (BOM 2026.05.01) + Material3 Adaptive
+- **Navigation3**: Type-safe navigation with `@Serializable` nav keys
+- **Room** (KSP code generation) for local satellite/orbital storage
+- **OkHttp** 5.x for data downloads
+- **OSMDroid** for map rendering
+- **Kotlin Serialization** for navigation args and parsing
+- **Coroutines** + `StateFlow` for async/reactive patterns
+- **Localization**: 7 languages (en, es, ru, si, tr, uk, zh)
+
+## Data Formats & Migration
+
+Look4Sat supports both TLE and OMM (Orbit Mean-Elements Message) CSV formats:
+
+- **TLE format**: Legacy 3-line element format limited by 5-digit NORAD IDs
+- **OMM/CSV format**: Successor format with ISO 8601 timestamps and larger NORAD ID support
+- New 5-digit NORAD IDs are exhausted; TLE is officially deprecated and OMM/CSV is the clear default
+- `DataParser.kt` supports both via `parseTLEStream()` and `parseCSVStream()`
+- Downloads auto-detect format; both produce identical `OrbitalData` objects
+- Existing code already supports transparent source transition without feature changes
+- Refresh orbital data weekly for accurate pass prediction (orbital decay)
+
+## Engineering Heuristics (Lazy = Efficient)
+
+- Treat "lazy" as efficient, not careless: the best code is the code never written.
+- First understand the task and trace the real flow end-to-end, then climb this ladder:
+  1. Does this need to be built now? (YAGNI)
+  2. Does it already exist in this codebase? Reuse helpers/patterns before rewriting.
+  3. Does Kotlin/Java stdlib already solve it?
+  4. Does the Android/platform API already solve it?
+  5. Does an already-installed dependency solve it?
+  6. Can this be simpler (including one-liner simple)?
+  7. Only then: write the minimum code that works.
+- Prefer deletion to addition, boring over clever, and the fewest touched files.
+- Avoid new abstractions, dependencies, and boilerplate unless explicitly requested.
+- Manual DI only: ViewModels use companion `factory()` methods with `IMainContainer`.
+- Release builds use ProGuard: avoid reflection-heavy libraries unless explicitly approved.
+- When two options are similar in size, choose the edge-case-correct one.
+- If you keep a deliberate simplification (for example O(n^2) scan or global lock), leave a short comment with the ceiling and upgrade path.
+- For complex asks, challenge scope when appropriate: "Do you need X, or does Y already cover it?"
+
+## Bug-Fix Policy
+
+- Fix root cause, not just the reported symptom.
+- If touching a shared function, inspect callers and prefer one shared fix over per-caller patches.
+- The smallest correct diff wins only after behavior is understood.
+
+## 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/` — dense vector math (SGP4/SDP4). Tread carefully.
+- SSTV decoding in `feature:radar` is experimental; image quality depends on signal strength during satellite pass.
+- `build-logic/convention/` contains shared Gradle configuration — edit there, not in individual modules.
+
+## 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/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,11 +12,14 @@
     <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:networkSecurityConfig="@xml/network_security_config"
         android:roundIcon="@mipmap/ic_launcher_round">
 
         <activity
@@ -26,6 +30,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

@@ -25,6 +25,10 @@ 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
@@ -32,6 +36,7 @@ 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
@@ -39,11 +44,14 @@ 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.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -56,150 +64,194 @@ 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.ElevationThresholds
+import com.rtbishop.look4sat.core.presentation.LocalElevationThresholds
+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.radiocontrol.RadioControlDestination
 import com.rtbishop.look4sat.feature.satellites.SatellitesDestination
 import com.rtbishop.look4sat.feature.settings.SettingsDestination
 
 @Composable
-fun MainScreen() {
+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.removeAt(backStack.size - 1) }
+    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 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()
+    val otherSettings by container.settingsRepo.otherSettings.collectAsStateWithLifecycle()
 
-    NavigationSuiteScaffold(
-        navigationSuiteItems = {
-            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(screen.iconResId), stringResource(screen.titleResId)) },
-                    label = { Text(stringResource(screen.titleResId)) },
-                    selected = isSelected,
-                    onClick = {
-                        if (isSelected) return@item
-                        while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
-                        if (screen !is Screen.Passes) backStack.add(screen)
-                    }
-                )
-            }
-        },
-        navigationSuiteColors = NavigationSuiteDefaults.colors(
-            navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
-        ),
-        layoutType = when {
-            !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
-            !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
-            else -> NavigationSuiteType.ShortNavigationBarMedium
-        }
+    CompositionLocalProvider(
+        LocalElevationThresholds provides ElevationThresholds(
+            low = otherSettings.lowElevation,
+            high = otherSettings.highElevation
+        )
     ) {
-        Column {
-            NavDisplay(
-                backStack = backStack,
-                modifier = Modifier.weight(1f),
-                onBack = navigateBack,
-                transitionSpec = { fadeTransition },
-                popTransitionSpec = { fadeTransition },
-                predictivePopTransitionSpec = { fadeTransition },
-                entryProvider = entryProvider {
-                    entry<Screen.Satellites> {
-                        SatellitesDestination(navigateUp = navigateBack)
+        NavigationSuiteScaffold(
+            navigationSuiteItems = {
+                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
                     }
-                    entry<Screen.Passes> {
-                        PassesDestination { catNum, aosTime ->
-                            backStack.add(Screen.Radar(catNum, aosTime))
+                    item(
+                        icon = { Icon(painterResource(screen.iconResId), stringResource(screen.titleResId)) },
+                        label = { Text(stringResource(screen.titleResId)) },
+                        selected = isSelected,
+                        onClick = {
+                            if (isSelected) return@item
+                            while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+                            if (screen !is Screen.Passes) backStack.add(screen)
                         }
-                    }
-                    entry<Screen.Radar> { route ->
-                        RadarDestination(
-                            catNum = route.catNum,
-                            aosTime = route.aosTime,
-                            navigateUp = navigateBack,
-                            navigateToRadioControl = { catNum, aosTime ->
-                                backStack.add(Screen.RadioControl(catNum, aosTime))
-                            }
-                        )
-                    }
-                    entry<Screen.RadioControl> { route ->
-                        RadioControlDestination(
-                            catNum = route.catNum,
-                            aosTime = route.aosTime,
-                            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) {
-                                backStack.add(Screen.RadioControl(pass.catNum, pass.aosTime))
+            },
+            navigationSuiteColors = NavigationSuiteDefaults.colors(
+                navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
+            ),
+            layoutType = when {
+                !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
+                !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
+                else -> NavigationSuiteType.ShortNavigationBarMedium
+            }
+        ) {
+            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()
                             }
                         }
-                        .padding(horizontal = 12.dp, vertical = 6.dp)
-                ) {
-                    Box(
+                        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
-                            .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
-                    )
+                            .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
+                        )
+                    }
                 }
             }
         }

app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true" />
+</network-security-config>

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

@@ -34,7 +34,6 @@ internal class ApplicationPlugin : Plugin<Project> {
             implementation(project(":feature:map"))
             implementation(project(":feature:passes"))
             implementation(project(":feature:radar"))
-            implementation(project(":feature:radiocontrol"))
             implementation(project(":feature:satellites"))
             implementation(project(":feature:settings"))
             implementation(libs.androidx.core.splashscreen)

build.gradle.kts

@@ -8,5 +8,6 @@ plugins {
 }
 
 tasks.register("clean", Delete::class.java) {
+    description = "Cleans the build directory"
     delete(rootProject.layout.buildDirectory)
 }

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/Look4SatDao.kt

@@ -45,7 +45,12 @@ interface Look4SatDao {
     @Query("DELETE FROM entries")
     suspend fun deleteEntries()
 
-    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes)")
+    @Query(
+        """
+        SELECT DISTINCT catnum FROM radios WHERE isAlive = 1
+        AND (downlinkMode IN (:modes) OR uplinkMode IN (:modes))
+        """
+    )
     suspend fun getIdsWithModes(modes: List<String>): List<Int>
 
     @Query("SELECT COUNT(*) FROM radios")

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

@@ -17,6 +17,9 @@
  */
 package com.rtbishop.look4sat.core.data.framework
 
+import java.util.Locale
+import kotlin.math.roundToLong
+
 object Ft817CatProtocol {
 
     const val CMD_SET_FREQ: Byte = 0x01
@@ -50,7 +53,7 @@ object Ft817CatProtocol {
     fun encodeFrequencyBcd(frequencyHz: Long): ByteArray {
         val freq10Hz = frequencyHz / 10
         val bcd = ByteArray(4)
-        val digits = String.format("%08d", freq10Hz)
+        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'
@@ -78,8 +81,8 @@ object Ft817CatProtocol {
      * 67.0 Hz → 670 (in 0.1 Hz) → BCD [0x06, 0x70]
      */
     fun encodeCtcssToneBcd(toneHz: Double): ByteArray {
-        val tone01Hz = (toneHz * 10).toLong()
-        val digits = String.format("%04d", tone01Hz)
+        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'
@@ -95,7 +98,7 @@ object Ft817CatProtocol {
     }
 
     fun buildSetModeCommand(mode: String): ByteArray? {
-        val modeByte = MODE_TO_BYTE[mode.uppercase()] ?: return null
+        val modeByte = MODE_TO_BYTE[mode.uppercase(Locale.US)] ?: return null
         return byteArrayOf(modeByte, 0x00, 0x00, 0x00, CMD_SET_MODE)
     }
 

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

@@ -29,6 +29,7 @@ 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,
@@ -39,10 +40,12 @@ class Ft817Controller(
     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
@@ -57,6 +60,7 @@ class Ft817Controller(
             socket = btSocket
             outputStream = btSocket.outputStream
             inputStream = btSocket.inputStream
+            ackReadFailureCount = 0
             isConnected = true
             Log.i(tag, "Connected to $deviceAddress")
             true
@@ -79,6 +83,7 @@ class Ft817Controller(
                 inputStream = null
                 outputStream = null
                 socket = null
+                ackReadFailureCount = 0
                 isConnected = false
                 Log.i(tag, "Disconnected from $deviceAddress")
             }
@@ -112,8 +117,8 @@ class Ft817Controller(
         ioMutex.withLock {
             val sent = sendCommand(Ft817CatProtocol.buildReadFreqModeCommand())
             if (!sent) return@withContext null
-            delay(commandDelayMs)
-            val response = readResponse(5) ?: return@withContext null
+            delay(commandDelayMs.milliseconds)
+            val response = readResponse() ?: return@withContext null
             Ft817CatProtocol.parseReadResponse(response)
         }
     }
@@ -127,44 +132,76 @@ class Ft817Controller(
     }
 
     private suspend fun sendCommand(bytes: ByteArray): Boolean {
-        return try {
-            outputStream?.write(bytes) ?: return false
-            outputStream?.flush()
-            delay(commandDelayMs)
-            true
-        } catch (e: Exception) {
-            Log.e(tag, "Send error: ${e.message}")
-            isConnected = false
-            false
+        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 try {
-            val ack = inputStream?.read() ?: return false
-            ack == 0x00
-        } catch (e: Exception) {
-            Log.e(tag, "ACK read error: ${e.message}")
-            true // command was sent, ACK read failed - continue anyway
+        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 fun readResponse(length: Int): ByteArray? {
-        return try {
-            val buffer = ByteArray(length)
-            var read = 0
-            while (read < length) {
-                val count = inputStream?.read(buffer, read, length - read) ?: return null
-                if (count < 0) return null
-                read += count
+    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
             }
-            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/Ic705Controller.kt

@@ -0,0 +1,364 @@
+/*
+ * 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
+
+/**
+ * Icom IC-705 CI-V controller over Bluetooth SPP.
+ *
+ * The IC-705 emits broadcast frames continuously (band scope, UTC, signal
+ * level, …).  A reply to any command we send may therefore be buried in
+ * that noise.  All response reads drain up to [ACK_TIMEOUT_MS] and scan the
+ * entire accumulated buffer for the frame we expect rather than assuming
+ * the very next byte is the response.
+ */
+class Ic705Controller(
+    private val bluetoothManager: BluetoothManager,
+    private val deviceAddress: String
+) : IRadioController {
+
+    private val tag = "IC705"
+    private val sppId: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
+    private val ioMutex = Mutex()
+
+    /** Time budget (ms) to wait for a response amid broadcast noise. */
+    private val ACK_TIMEOUT_MS = 500L
+    /** Polling interval while draining the input buffer. */
+    private val POLL_INTERVAL_MS = 20L
+    /** Small pause after writing a command before reading the response. */
+    private val WRITE_SETTLE_MS = 50L
+
+    private var socket: BluetoothSocket? = null
+    private var outputStream: OutputStream? = null
+    private var inputStream: InputStream? = null
+
+    override var isConnected: Boolean = false
+        private set
+
+    // ── Connection ──────────────────────────────────────────────────────────
+
+    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
+            isConnected  = true
+            // Enter VFO mode — frequency/mode commands return FA if the radio
+            // is in memory-channel mode. Safe to send regardless of current state.
+            Log.i(tag, "Connected to $deviceAddress — entering VFO mode")
+            val vfoCmd = IcomCivProtocol.buildEnterVfoModeCommand()
+            Log.d(tag, "CMD enterVfoMode → ${IcomCivProtocol.toHex(vfoCmd)}")
+            ioMutex.withLock { sendAndWaitAck(vfoCmd) }
+            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
+                isConnected  = false
+                Log.i(tag, "Disconnected from $deviceAddress")
+            }
+        }
+    }
+
+    // ── IRadioController – standard operations ──────────────────────────────
+
+    override suspend fun setFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setFrequency: ${frequencyHz}Hz")
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildSetFreqCommand(frequencyHz)
+            Log.d(tag, "CMD setFreq → ${IcomCivProtocol.toHex(cmd)}")
+            sendAndWaitAck(cmd)
+        }
+    }
+
+    override suspend fun setMode(mode: String): Boolean = withContext(Dispatchers.IO) {
+        val cmd = IcomCivProtocol.buildSetModeCommand(mode) ?: run {
+            Log.w(tag, "setMode: unknown mode '$mode'")
+            return@withContext false
+        }
+        Log.d(tag, "setMode: $mode")
+        Log.d(tag, "CMD setMode → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    override suspend fun setCtcssMode(enabled: Boolean): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setCtcssMode: $enabled")
+        val cmd = IcomCivProtocol.buildCtcssModeCommand(enabled)
+        Log.d(tag, "CMD ctcssMode → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    override suspend fun setCtcssTone(toneHz: Double): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setCtcssTone: ${toneHz}Hz")
+        val cmd = IcomCivProtocol.buildSetCtcssToneCommand(toneHz)
+        Log.d(tag, "CMD ctcssTone → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    override suspend fun readFrequencyAndMode(): Pair<Long, String>? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildReadFreqCommand()
+            Log.d(tag, "CMD readFreq → ${IcomCivProtocol.toHex(cmd)}")
+            val payload = sendAndReadResponse(cmd, IcomCivProtocol.CMD_READ_FREQ) ?: return@withContext null
+            // Read-freq reply payload: [cmd byte already stripped by parseResponse] [5 freq bytes] [mode] [filter]
+            IcomCivProtocol.parseFreqModePayload(payload).also {
+                if (it != null) Log.d(tag, "readFreqMode: ${it.first}Hz, ${it.second}")
+                else Log.w(tag, "readFreqMode: parse failed, payload=${IcomCivProtocol.toHex(payload)}")
+            }
+        }
+    }
+
+    override suspend fun pttOn(): Boolean = withContext(Dispatchers.IO) {
+        Log.w(tag, "pttOn: not used for IC-705")
+        true
+    }
+
+    override suspend fun pttOff(): Boolean = withContext(Dispatchers.IO) {
+        Log.w(tag, "pttOff: not used for IC-705")
+        true
+    }
+
+    // ── IRadioController – IC-705 extended operations ───────────────────────
+
+    /** Select the band for [frequencyHz] via CMD 0x1A sub 0x00 (band stacking register). */
+    override suspend fun setBand(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        val cmd = IcomCivProtocol.buildBandSelectCommand(frequencyHz) ?: run {
+            Log.w(tag, "setBand: no band code for ${frequencyHz}Hz — skipping")
+            return@withContext false
+        }
+        Log.d(tag, "CMD setBand (${frequencyHz}Hz) → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /** Select VFO-A (main/RX) or VFO-B (sub/TX). */
+    override suspend fun setVfo(vfoA: Boolean): Boolean = withContext(Dispatchers.IO) {
+        val cmd = if (vfoA) IcomCivProtocol.buildSelectVfoACommand()
+                  else      IcomCivProtocol.buildSelectVfoBCommand()
+        Log.d(tag, "CMD selectVFO${if (vfoA) "A" else "B"} → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Enable or disable SPLIT mode (TX on sub-VFO while listening on main VFO).
+     */
+    override suspend fun setSplitMode(enabled: Boolean): Boolean = withContext(Dispatchers.IO) {
+        val cmd = IcomCivProtocol.buildSplitModeCommand(enabled)
+        Log.d(tag, "CMD split ${if (enabled) "ON" else "OFF"} → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Set the frequency of the **currently active** VFO (CMD 0x25 sub 0x00).
+     * In split mode the radio automatically switches active VFO on PTT, so
+     * always writing to the active VFO is the correct strategy.
+     */
+    override suspend fun setWorkingFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setWorkingFrequency (0x25/00): ${frequencyHz}Hz")
+        val cmd = IcomCivProtocol.buildSetWorkingFreqCommand(frequencyHz)
+        Log.d(tag, "CMD setWorkingFreq → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Set TX VFO frequency via CMD 0x25 sub 0x01 (unselected VFO).
+     * Sent every tracking cycle in split mode alongside [setWorkingFrequency].
+     */
+    override suspend fun setTxVfoFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setTxVfoFrequency (0x25/01): ${frequencyHz}Hz")
+        val cmd = IcomCivProtocol.buildSetUnselectedVfoFreqCommand(frequencyHz)
+        Log.d(tag, "CMD setTxVfoFreq → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Read the frequency of the currently active VFO (CMD 0x25 sub 0x00).
+     * Used for tuning detection in split mode.
+     */
+    override suspend fun readWorkingFrequency(): Long? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildReadWorkingFreqCommand()
+            Log.d(tag, "CMD readWorkingFreq → ${IcomCivProtocol.toHex(cmd)}")
+            val payload = sendAndReadResponse(cmd, IcomCivProtocol.CMD_SELECTED_VFO_FREQ) ?: return@withContext null
+            // Response payload: [sub] [5 freq bytes] — CMD byte already stripped by parseResponse
+            Log.d(tag, "readWorkingFreq: got ${payload.size} bytes: ${IcomCivProtocol.toHex(payload)}")
+            if (payload.size < 6) {
+                Log.w(tag, "readWorkingFreq: payload too short (${payload.size} bytes)")
+                return@withContext null
+            }
+            val freqBcd = payload.sliceArray(1..5)
+            val freq = IcomCivProtocol.decodeFrequencyBcd(freqBcd)
+            Log.d(tag, "readWorkingFreq: ${freq}Hz")
+            freq
+        }
+    }
+
+    /**
+     * Read the frequency of the inactive/TX VFO (CMD 0x25 sub 0x01).
+     * Used for tuning detection in split mode.
+     */
+    override suspend fun readTxVfoFrequency(): Long? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildReadTxVfoFreqCommand()
+            Log.d(tag, "CMD readTxVfoFreq → ${IcomCivProtocol.toHex(cmd)}")
+            val payload = sendAndReadResponse(cmd, IcomCivProtocol.CMD_SELECTED_VFO_FREQ) ?: return@withContext null
+            // Response payload: [sub] [5 freq bytes] — CMD byte already stripped by parseResponse
+            Log.d(tag, "readTxVfoFreq: got ${payload.size} bytes: ${IcomCivProtocol.toHex(payload)}")
+            if (payload.size < 6) {
+                Log.w(tag, "readTxVfoFreq: payload too short (${payload.size} bytes)")
+                return@withContext null
+            }
+            val freqBcd = payload.sliceArray(1..5)
+            val freq = IcomCivProtocol.decodeFrequencyBcd(freqBcd)
+            Log.d(tag, "readTxVfoFreq: ${freq}Hz")
+            freq
+        }
+    }
+
+    // ── Internal I/O helpers ────────────────────────────────────────────────
+
+    /**
+     * Write [cmd] to the radio and drain the input stream for up to
+     * [ACK_TIMEOUT_MS], looking for an OK/NG acknowledgement frame.
+     */
+    private suspend fun sendAndWaitAck(cmd: ByteArray): Boolean {
+        if (!write(cmd)) return false
+        delay(WRITE_SETTLE_MS)
+        val buf = drainWithTimeout(ACK_TIMEOUT_MS)
+        val ok  = IcomCivProtocol.containsAck(buf)
+        if (!ok) Log.w(tag, "ACK not found in ${buf.size} bytes: ${IcomCivProtocol.toHex(buf)}")
+        return ok
+    }
+
+    /**
+     * Write [cmd] to the radio and drain the input stream for up to
+     * [ACK_TIMEOUT_MS], scanning for a response frame carrying [expectCmd].
+     * Returns the payload bytes of that frame, or null on timeout/error.
+     */
+    private suspend fun sendAndReadResponse(cmd: ByteArray, expectCmd: Byte): ByteArray? {
+        if (!write(cmd)) return null
+        delay(WRITE_SETTLE_MS)
+        val buf      = drainWithTimeout(ACK_TIMEOUT_MS)
+        val response = IcomCivProtocol.parseResponse(buf, expectCmd)
+        if (response == null) {
+            Log.w(tag, "No response for cmd 0x${String.format("%02X", expectCmd.toInt() and 0xFF)} " +
+                    "in ${buf.size} bytes: ${IcomCivProtocol.toHex(buf)}")
+        }
+        return response?.payload
+    }
+
+    /**
+     * Drain whatever bytes the radio has buffered within a [timeoutMs] window.
+     * Exits early as soon as a complete CI-V frame addressed to us is present
+     * in the buffer (i.e., FE FE E0 A4 … FD), so we don't waste the remaining
+     * timeout on responses that already arrived.
+     */
+    private suspend fun drainWithTimeout(timeoutMs: Long): ByteArray {
+        val result   = mutableListOf<Byte>()
+        val deadline = System.currentTimeMillis() + timeoutMs
+        val stream   = inputStream ?: return ByteArray(0)
+        while (System.currentTimeMillis() < deadline) {
+            try {
+                val available = stream.available()
+                if (available > 0) {
+                    val chunk = ByteArray(available)
+                    val read  = stream.read(chunk)
+                    if (read > 0) {
+                        result.addAll(chunk.take(read))
+                        // Exit early once we have a complete frame for us
+                        if (hasCompleteFrameForUs(result)) break
+                    }
+                } else {
+                    delay(POLL_INTERVAL_MS)
+                }
+            } catch (e: Exception) {
+                Log.e(tag, "Drain error: ${e.message}")
+                isConnected = false
+                break
+            }
+        }
+        return result.toByteArray()
+    }
+
+    /**
+     * Returns true if [buf] contains a complete CI-V frame addressed to the
+     * controller (FE FE [ADDR_CTRL] [ADDR_IC705] … FD).
+     * CI-V data bytes cannot be 0xFD, so the first 0xFD after the header is
+     * always the frame terminator.
+     */
+    private fun hasCompleteFrameForUs(buf: List<Byte>): Boolean {
+        var i = 0
+        while (i < buf.size - 4) {
+            if (buf[i]     == IcomCivProtocol.PREAMBLE    &&
+                buf[i + 1] == IcomCivProtocol.PREAMBLE    &&
+                buf[i + 2] == IcomCivProtocol.ADDR_CTRL   &&
+                buf[i + 3] == IcomCivProtocol.ADDR_IC705
+            ) {
+                for (k in i + 4 until buf.size) {
+                    if (buf[k] == IcomCivProtocol.END_OF_MSG) return true
+                }
+                return false  // header found but no FD yet
+            }
+            i++
+        }
+        return false
+    }
+
+    private fun write(bytes: ByteArray): Boolean {
+        return try {
+            outputStream?.write(bytes)
+            outputStream?.flush()
+            true
+        } catch (e: Exception) {
+            Log.e(tag, "Write error: ${e.message}")
+            isConnected = false
+            false
+        }
+    }
+}

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

@@ -0,0 +1,352 @@
+/*
+ * 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
+
+/**
+ * Icom CI-V protocol encoder/decoder for the IC-705.
+ *
+ * Frame structure:
+ *   FE FE <DEST> <SRC> <CMD> [<SUB>] [<DATA...>] FD
+ *
+ * IC-705 default CI-V address : 0xA4
+ * Controller (us) address     : 0xE0
+ */
+object IcomCivProtocol {
+
+    // ── Framing constants ──────────────────────────────────────────────────
+    const val PREAMBLE: Byte      = 0xFE.toByte()
+    const val END_OF_MSG: Byte    = 0xFD.toByte()
+    const val ACK_OK: Byte        = 0xFB.toByte()
+    const val ACK_NG: Byte        = 0xFA.toByte()
+
+    // ── Address constants ──────────────────────────────────────────────────
+    /** Default CI-V address of the IC-705. */
+    const val ADDR_IC705: Byte    = 0xA4.toByte()
+    /** Default CI-V address of the controller (us). */
+    const val ADDR_CTRL: Byte     = 0xE0.toByte()
+
+    // ── Command bytes ──────────────────────────────────────────────────────
+    /** Read operating frequency (main VFO). */
+    const val CMD_READ_FREQ: Byte           = 0x03
+    /** Set operating frequency (main VFO). */
+    const val CMD_SET_FREQ: Byte            = 0x05
+    /** Set operating mode. */
+    const val CMD_SET_MODE: Byte            = 0x06
+    /** Select VFO / memory. */
+    const val CMD_SELECT_VFO: Byte          = 0x07
+    /**
+     * Select operating mode (VFO vs memory-channel).
+     * Sub 0x00 = VFO mode. Must be sent after connect if the radio is in
+     * memory-channel mode — frequency/mode commands return FA until it is.
+     */
+    const val CMD_SELECT_OP_MODE: Byte      = 0x08
+    /** Set repeater duplex / SPLIT. */
+    const val CMD_DUPLEX_SPLIT: Byte        = 0x0F
+    /** Band stacking register / band select (sub 0x00 = select, data = BCD band number). */
+    const val CMD_BAND_SELECT: Byte         = 0x1A
+    /** Read/write CTCSS tone frequency. */
+    const val CMD_CTCSS_TONE: Byte          = 0x1B
+    /** Read/write misc settings (used for enabling CTCSS encode). */
+    const val CMD_MISC_SETTING: Byte        = 0x16
+    /** Read/write selected-VFO frequency (cmd 0x25). */
+    const val CMD_SELECTED_VFO_FREQ: Byte   = 0x25
+
+    // ── Sub-command bytes ──────────────────────────────────────────────────
+    /** Sub for CMD_SELECT_VFO: select VFO-A (main). */
+    const val SUB_VFO_A: Byte   = 0x00
+    /** Sub for CMD_SELECT_VFO: select VFO-B (sub). */
+    const val SUB_VFO_B: Byte   = 0x01
+    /** Sub for CMD_DUPLEX_SPLIT: simplex / split OFF. */
+    const val SUB_SPLIT_OFF: Byte = 0x00
+    /** Sub for CMD_DUPLEX_SPLIT: SPLIT ON. */
+    const val SUB_SPLIT_ON: Byte  = 0x01
+    /** Sub for CMD_SELECTED_VFO_FREQ: selected (active) VFO frequency. */
+    const val SUB_SELECTED_VFO: Byte = 0x00
+    /** Sub for CMD_SELECTED_VFO_FREQ: unselected (inactive / TX in split) VFO frequency. */
+    const val SUB_UNSELECTED_VFO: Byte = 0x01
+    /** Sub for CMD_MISC_SETTING: CTCSS/DTCS tone squelch. */
+    const val SUB_CTCSS_SETTING: Byte = 0x42.toByte()
+
+    // ── Mode bytes ────────────────────────────────────────────────────────
+    /** Maps mode strings (upper-case) → IC-705 mode bytes. */
+    val MODE_TO_BYTE: Map<String, Byte> = mapOf(
+        "LSB"    to 0x00,
+        "USB"    to 0x01,
+        "AM"     to 0x02,
+        "CW"     to 0x03,
+        "RTTY"   to 0x04,
+        "FM"     to 0x05,
+        "WFM"    to 0x06,
+        "CW-R"   to 0x07,
+        "RTTY-R" to 0x08,
+        "DV"     to 0x12,
+        "AFSK"   to 0x05  // AFSK uses FM modulation
+    )
+
+    val BYTE_TO_MODE: Map<Byte, String> = MODE_TO_BYTE.entries.associate { it.value to it.key }
+
+    // ── Frequency BCD encoding ─────────────────────────────────────────────
+
+    /**
+     * Encode a frequency in Hz to the IC-705's 5-byte BCD format.
+     *
+     * The IC-705 uses 5 bytes, LSB pair first, with 1 Hz resolution.
+     * Example: 145,500,000 Hz → "0145500000" → pairs LSB→MSB:
+     *   [00, 00, 50, 45, 01]
+     */
+    fun encodeFrequencyBcd(frequencyHz: Long): ByteArray {
+        val digits = String.format(Locale.US, "%010d", frequencyHz)
+        val bcd = ByteArray(5)
+        for (i in 0 until 5) {
+            // digits are MSB first; we want pair index 0 = LSB pair
+            val pairIndex = 4 - i
+            val high = digits[pairIndex * 2] - '0'
+            val low  = digits[pairIndex * 2 + 1] - '0'
+            bcd[i] = ((high shl 4) or low).toByte()
+        }
+        return bcd
+    }
+
+    /**
+     * Decode 5-byte BCD frequency (LSB pair first) to Hz.
+     */
+    fun decodeFrequencyBcd(bcd: ByteArray): Long {
+        // Build digit string MSB→LSB by reversing the byte order
+        var freqHz = 0L
+        for (i in 4 downTo 0) {
+            val b    = bcd[i].toInt() and 0xFF
+            val high = b shr 4
+            val low  = b and 0x0F
+            freqHz   = freqHz * 100 + high * 10 + low
+        }
+        return freqHz
+    }
+
+    /**
+     * Encode a CTCSS tone (Hz, e.g. 67.0) to 2-byte BCD (0.1 Hz resolution).
+     * 67.0 → 670 (tenths of Hz) → BCD bytes [0x06, 0x70].
+     */
+    fun encodeCtcssToneBcd(toneHz: Double): ByteArray {
+        val tone01 = (toneHz * 10).toLong()
+        val digits = String.format(Locale.US, "%04d", tone01)
+        return byteArrayOf(
+            ((digits[0] - '0') shl 4 or (digits[1] - '0')).toByte(),
+            ((digits[2] - '0') shl 4 or (digits[3] - '0')).toByte()
+        )
+    }
+
+    // ── Message builders ───────────────────────────────────────────────────
+
+    /** Wrap payload bytes in a CI-V frame: FE FE DEST SRC ... FD. */
+    private fun frame(vararg payload: Byte): ByteArray {
+        return byteArrayOf(PREAMBLE, PREAMBLE, ADDR_IC705, ADDR_CTRL) +
+                payload +
+                byteArrayOf(END_OF_MSG)
+    }
+
+    /** Set operating frequency via CMD 0x05 (main VFO). */
+    fun buildSetFreqCommand(frequencyHz: Long): ByteArray {
+        return frame(CMD_SET_FREQ, *encodeFrequencyBcd(frequencyHz))
+    }
+
+    /**
+     * Set selected-VFO frequency via CMD 0x25 sub 0x00.
+     * This updates whichever VFO is currently active (RX or TX after split).
+     */
+    fun buildSetWorkingFreqCommand(frequencyHz: Long): ByteArray {
+        return frame(CMD_SELECTED_VFO_FREQ, SUB_SELECTED_VFO, *encodeFrequencyBcd(frequencyHz))
+    }
+
+    /**
+     * Set unselected-VFO frequency via CMD 0x25 sub 0x01.
+     * In split mode while PTT is pressed the IC-705 makes VFO-B active, so
+     * this command targets VFO-A (the RX VFO) — and vice-versa when in RX.
+     * Use this to update the TX VFO when PTT is on.
+     */
+    fun buildSetUnselectedVfoFreqCommand(frequencyHz: Long): ByteArray {
+        return frame(CMD_SELECTED_VFO_FREQ, SUB_UNSELECTED_VFO, *encodeFrequencyBcd(frequencyHz))
+    }
+
+    /** Read operating frequency (CMD 0x03). */
+    fun buildReadFreqCommand(): ByteArray = frame(CMD_READ_FREQ)
+
+    /** Read selected (active) VFO frequency (CMD 0x25 sub 0x00). */
+    fun buildReadWorkingFreqCommand(): ByteArray = frame(CMD_SELECTED_VFO_FREQ, SUB_SELECTED_VFO)
+
+    /** Read unselected (inactive/TX in split) VFO frequency (CMD 0x25 sub 0x01). */
+    fun buildReadTxVfoFreqCommand(): ByteArray = frame(CMD_SELECTED_VFO_FREQ, SUB_UNSELECTED_VFO)
+
+    /**
+     * Select band via CMD 0x1A sub 0x00.
+     * Band codes are BCD-numbered: 1=160m, 2=80m, …, 9=10m, 0x10=6m, 0x11=2m, 0x12=70cm, 0x13=23cm.
+     * Returns null if [frequencyHz] doesn't fall in a known amateur band.
+     */
+    fun buildBandSelectCommand(frequencyHz: Long): ByteArray? {
+        val code = bandCodeForFrequency(frequencyHz) ?: return null
+        return frame(CMD_BAND_SELECT, 0x00, code)
+    }
+
+    /**
+     * Map a frequency in Hz to the IC-705 band stacking register code.
+     * Codes are BCD (band number in decimal expressed as hex nibbles).
+     */
+    fun bandCodeForFrequency(frequencyHz: Long): Byte? = when {
+        frequencyHz in 1_800_000L     ..1_999_999L     -> 0x01 // 160 m
+        frequencyHz in 3_500_000L     ..3_999_999L     -> 0x02 // 80 m
+        frequencyHz in 7_000_000L     ..7_299_999L     -> 0x03 // 40 m
+        frequencyHz in 10_100_000L    ..10_149_999L    -> 0x04 // 30 m
+        frequencyHz in 14_000_000L    ..14_349_999L    -> 0x05 // 20 m
+        frequencyHz in 18_068_000L    ..18_167_999L    -> 0x06 // 17 m
+        frequencyHz in 21_000_000L    ..21_449_999L    -> 0x07 // 15 m
+        frequencyHz in 24_890_000L    ..24_989_999L    -> 0x08 // 12 m
+        frequencyHz in 28_000_000L    ..29_699_999L    -> 0x09 // 10 m
+        frequencyHz in 50_000_000L    ..53_999_999L    -> 0x10 // 6 m  (BCD 10)
+        frequencyHz in 144_000_000L   ..147_999_999L   -> 0x11 // 2 m  (BCD 11)
+        frequencyHz in 420_000_000L   ..449_999_999L   -> 0x12 // 70 cm (BCD 12)
+        frequencyHz in 1_240_000_000L ..1_299_999_999L -> 0x13 // 23 cm (BCD 13)
+        else -> null
+    }
+
+    /** Set operating mode (CMD 0x06). Filter byte is omitted — radio uses its default filter for the mode. */
+    fun buildSetModeCommand(mode: String): ByteArray? {
+        val modeByte = MODE_TO_BYTE[mode.uppercase(Locale.US)] ?: return null
+        return frame(CMD_SET_MODE, modeByte)
+    }
+
+    /** Select VFO-A (CMD 0x07 sub 0x00). */
+    fun buildSelectVfoACommand(): ByteArray = frame(CMD_SELECT_VFO, SUB_VFO_A)
+
+    /** Select VFO-B (CMD 0x07 sub 0x01). */
+    fun buildSelectVfoBCommand(): ByteArray = frame(CMD_SELECT_VFO, SUB_VFO_B)
+
+    /**
+     * Enter VFO operating mode (CMD 0x08 sub 0x00).
+     * Sent after connect — if the radio is in memory-channel mode frequency
+     * and mode commands return FA until this is issued.
+     */
+    fun buildEnterVfoModeCommand(): ByteArray = frame(CMD_SELECT_OP_MODE, 0x00)
+
+    /** Enable or disable SPLIT mode (CMD 0x0F). */
+    fun buildSplitModeCommand(enable: Boolean): ByteArray {
+        val sub = if (enable) SUB_SPLIT_ON else SUB_SPLIT_OFF
+        return frame(CMD_DUPLEX_SPLIT, sub)
+    }
+
+    /**
+     * Enable/disable CTCSS encode (CMD 0x16 sub 0x42).
+     * 0x01 = CTCSS encoder ON, 0x00 = OFF.
+     */
+    fun buildCtcssModeCommand(enabled: Boolean): ByteArray {
+        val value: Byte = if (enabled) 0x01 else 0x00
+        return frame(CMD_MISC_SETTING, SUB_CTCSS_SETTING, value)
+    }
+
+    /**
+     * Set CTCSS tone frequency (CMD 0x1B sub 0x00).
+     */
+    fun buildSetCtcssToneCommand(toneHz: Double): ByteArray {
+        val bcd = encodeCtcssToneBcd(toneHz)
+        return frame(CMD_CTCSS_TONE, 0x00, *bcd)
+    }
+
+    // ── Response parsing ───────────────────────────────────────────────────
+
+    /**
+     * Find and parse a complete CI-V response frame from a buffer.
+     *
+     * Returns the bytes between "FE FE E0 A4 <CMD>" and FD, or null if no
+     * complete frame was found. The search is tolerant of interleaved
+     * broadcast traffic.
+     *
+     * @param buf       bytes accumulated from the radio
+     * @param expectCmd the command byte we are looking for in the reply, or
+     *                  null to accept any command response from the radio
+     */
+    fun parseResponse(buf: ByteArray, expectCmd: Byte?): ParsedResponse? {
+        var i = 0
+        while (i < buf.size - 5) {
+            // Look for FE FE preamble
+            if (buf[i] != PREAMBLE || buf[i + 1] != PREAMBLE) { i++; continue }
+            val dest = buf[i + 2]
+            val src  = buf[i + 3]
+            val cmd  = buf[i + 4]
+            // We only care about frames addressed to us from the radio
+            if (dest != ADDR_CTRL || src != ADDR_IC705) { i++; continue }
+            // Find the terminating FD
+            val fdIdx = buf.indexOf(END_OF_MSG, startIndex = i + 5)
+            if (fdIdx < 0) break  // incomplete frame, wait for more data
+            val payload = buf.copyOfRange(i + 5, fdIdx)
+            if (expectCmd == null || cmd == expectCmd) {
+                return ParsedResponse(cmd, payload, fdIdx + 1)
+            }
+            i = fdIdx + 1
+        }
+        return null
+    }
+
+    private fun ByteArray.indexOf(b: Byte, startIndex: Int): Int {
+        for (k in startIndex until size) if (this[k] == b) return k
+        return -1
+    }
+
+    /**
+     * Check whether a buffer contains an OK acknowledgement (FB FD) from
+     * the radio. Tolerates broadcast noise before the ACK.
+     */
+    fun containsAck(buf: ByteArray): Boolean {
+        var i = 0
+        while (i < buf.size - 5) {
+            if (buf[i] != PREAMBLE || buf[i + 1] != PREAMBLE) { i++; continue }
+            val dest = buf[i + 2]
+            val src  = buf[i + 3]
+            val cmd  = buf[i + 4]
+            if (dest != ADDR_CTRL || src != ADDR_IC705) { i++; continue }
+            // Skip to FD
+            val fdIdx = buf.indexOf(END_OF_MSG, startIndex = i + 5)
+            if (fdIdx < 0) break
+            if (cmd == ACK_OK) return true
+            if (cmd == ACK_NG) return false
+            i = fdIdx + 1
+        }
+        return false
+    }
+
+    /**
+     * Parse frequency + mode from a CMD_READ_FREQ reply payload.
+     * Payload layout after stripping command byte: [5 freq bytes] [mode byte] [filter byte]
+     */
+    fun parseFreqModePayload(payload: ByteArray): Pair<Long, String>? {
+        if (payload.size < 6) return null
+        val freqHz = decodeFrequencyBcd(payload.copyOfRange(0, 5))
+        val mode   = BYTE_TO_MODE[payload[5]] ?: return null
+        return freqHz to mode
+    }
+
+    /** Hex dump of bytes, useful for debug logging. */
+    fun toHex(bytes: ByteArray): String =
+        bytes.joinToString(" ") { String.format(Locale.US, "%02X", it.toInt() and 0xFF) }
+
+    data class ParsedResponse(
+        val cmd: Byte,
+        val payload: ByteArray,
+        /** Index in the source buffer immediately after the FD terminator. */
+        val nextOffset: Int
+    )
+}

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

@@ -19,8 +19,10 @@ package com.rtbishop.look4sat.core.data.framework
 
 import android.bluetooth.BluetoothManager
 import android.util.Log
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
 import com.rtbishop.look4sat.core.domain.model.SatRadio
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.predict.SPEED_OF_LIGHT
 import com.rtbishop.look4sat.core.domain.repository.IRadioController
 import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
@@ -29,6 +31,7 @@ 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.currentCoroutineContext
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -44,6 +47,8 @@ class RadioTrackingService(
 ) : IRadioTrackingService {
 
     private val tag = "RadioTracking"
+    /** Delay between each step of the split-mode init sequence (ms). */
+    private val INIT_STEP_DELAY_MS = 200L
     private val _state = MutableStateFlow(RadioTrackingState())
     override val state: StateFlow<RadioTrackingState> = _state
 
@@ -51,227 +56,427 @@ class RadioTrackingService(
     private var rxController: IRadioController? = null
     private var trackingJob: Job? = null
 
+    // ── Connection ──────────────────────────────────────────────────────────
+
     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
+        val txAddr     = rcSettings.txRadioAddress
+        val rxAddr     = rcSettings.rxRadioAddress
+        val isIcom     = rcSettings.radioModel == RadioControlSettings.MODEL_ICOM_IC705
+        val isSplit    = isIcom && rcSettings.splitMode
 
-        Log.i(tag, "Connecting TX=$txAddr RX=$rxAddr")
+        Log.i(tag, "connectRadios model=${rcSettings.radioModel} split=$isSplit TX=$txAddr RX=$rxAddr")
 
-        if (txAddr.isBlank() && rxAddr.isBlank()) {
-            _state.update { it.copy(errorMessage = "No radio addresses configured. Set them in Settings → FT-817.") }
-            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
-                }
-            )
+        if (isSplit) {
+            // Single-radio split mode: only TX slot is used
+            if (txAddr.isBlank()) {
+                _state.update { it.copy(errorMessage = "No radio address configured in Settings") }
+                return
+            }
+            val tx = makeController(isIcom, txAddr)
+            txController = tx
+            rxController = null
+            _state.update { it.copy(errorMessage = null) }
+            val txOk = tx.connect()
+            _state.update {
+                it.copy(
+                    txConnected = txOk,
+                    rxConnected = false,
+                    errorMessage = if (!txOk) "Could not connect to radio ($txAddr)" else null
+                )
+            }
+            Log.i(tag, "IC-705 split mode connected: txOk=$txOk")
+        } else {
+            if (txAddr.isBlank() && rxAddr.isBlank()) {
+                _state.update { it.copy(errorMessage = "No radio addresses configured in Settings") }
+                return
+            }
+            val tx = makeController(isIcom, txAddr)
+            val rx = makeController(isIcom, 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
+                    }
+                )
+            }
+            Log.i(tag, "Dual-radio connected: txOk=$txOk rxOk=$rxOk")
         }
     }
 
+    private fun makeController(isIcom: Boolean, address: String): IRadioController =
+        if (isIcom) Ic705Controller(bluetoothManager, address)
+        else        Ft817Controller(bluetoothManager, address)
+
     override suspend fun disconnectRadios() {
         stopTracking()
         txController?.disconnect()
         rxController?.disconnect()
         txController = null
         rxController = null
-        _state.update {
-            it.copy(
-                txConnected = false,
-                rxConnected = false,
-                isActive = false
-            )
-        }
+        _state.update { it.copy(txConnected = false, rxConnected = false, isActive = false) }
     }
 
+    // ── Tracking ────────────────────────────────────────────────────────────
+
     override fun startTracking(pass: OrbitalPass, transponder: SatRadio, txBaseFreqHz: Long?) {
         _state.update {
             it.copy(
-                isActive = true,
-                currentPass = pass,
-                selectedTransponder = transponder,
-                txBaseFrequencyHz = txBaseFreqHz
+                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
+        val rcSettings = settingsRepo.radioControlSettings.value
+        val isIcom     = rcSettings.radioModel == RadioControlSettings.MODEL_ICOM_IC705
+        val isSplit    = isIcom && rcSettings.splitMode
 
-            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)
-            }
+        if (isSplit) {
+            trackingJob = appScope.launch { runSplitTracking(transponder, txBaseFreqHz) }
+        } else {
+            trackingJob = appScope.launch { runDualRadioTracking(transponder, txBaseFreqHz) }
         }
     }
 
+    // ── Dual-radio tracking (Yaesu or two IC-705s) ──────────────────────────
+
+    private suspend fun runDualRadioTracking(transponder: SatRadio, initialTxBaseFreqHz: Long?) {
+        val tx = txController
+        val rx = rxController
+
+        // Initial setup: set band/mode/CTCSS on both radios
+        val txMode = transponder.uplinkMode
+        val rxMode = transponder.downlinkMode
+            ?: transponder.uplinkMode?.let {
+                TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+            }
+
+        Log.i(tag, "DualRadio start: txMode=$txMode rxMode=$rxMode")
+
+        if (tx != null && tx.isConnected && txMode != null) {
+            Log.d(tag, "Setting TX mode: $txMode")
+            tx.setMode(txMode)
+        }
+        if (rx != null && rx.isConnected && rxMode != null) {
+            Log.d(tag, "Setting RX mode: $rxMode")
+            rx.setMode(rxMode)
+        }
+        if (txMode?.uppercase() == "FM") {
+            _state.value.ctcssTone?.let { tone ->
+                Log.d(tag, "Setting CTCSS: ${tone}Hz")
+                tx?.setCtcssTone(tone)
+                tx?.setCtcssMode(true)
+            }
+        }
+        _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
+
+        var lastSetTxFreq = 0.0
+        var lastSetRxFreq = 0.0
+        var tuningRadio   = ""
+        var lastReadFreq  = 0L
+        var stableCount   = 0
+
+        while (currentCoroutineContext().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 pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, System.currentTimeMillis())
+            val txNow = txController
+            val rxNow = rxController
+            val v = pos.distanceRate * 1000.0
+
+            if (tuningRadio.isNotEmpty()) {
+                val radio = if (tuningRadio == "tx") txNow else rxNow
+                if (radio != null && radio.isConnected) {
+                    val read = radio.readFrequencyAndMode()
+                    if (read != null) {
+                        val (freq, _) = read
+                        if (kotlin.math.abs(freq - lastReadFreq) <= 20) stableCount++
+                        else { stableCount = 0; lastReadFreq = freq }
+                        if (stableCount >= 2) {
+                            if (tuningRadio == "tx" && txBaseFreq != null) {
+                                val newBase = (freq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT + 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() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT - 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 {
+                // Detect manual dial changes
+                if (txBaseFreq != null && txNow != null && txNow.isConnected && lastSetTxFreq > 0.0) {
+                    val read = txNow.readFrequencyAndMode()
+                    if (read != null && kotlin.math.abs(read.first - lastSetTxFreq) >= 20.0) {
+                        tuningRadio  = "tx"
+                        lastReadFreq = read.first
+                        stableCount  = 0
+                        Log.i(tag, "TX tuning detected (read=${read.first}, lastSet=$lastSetTxFreq)")
+                    }
+                }
+                if (tuningRadio.isEmpty() && rxNow != null && rxNow.isConnected && lastSetRxFreq > 0.0) {
+                    val read = rxNow.readFrequencyAndMode()
+                    if (read != null && kotlin.math.abs(read.first - lastSetRxFreq) >= 20.0) {
+                        tuningRadio  = "rx"
+                        lastReadFreq = read.first
+                        stableCount  = 0
+                        Log.i(tag, "RX tuning detected (read=${read.first}, lastSet=$lastSetRxFreq)")
+                    }
+                }
+            }
+
+            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) }
+
+            if (tuningRadio.isEmpty()) {
+                if (txNow != null && txNow.isConnected && txRadioFreq != null) {
+                    txNow.setFrequency(txRadioFreq)
+                    lastSetTxFreq = txRadioFreq.toDouble()
+                }
+                if (rxNow != null && rxNow.isConnected && rxRadioFreq != null) {
+                    rxNow.setFrequency(rxRadioFreq)
+                    lastSetRxFreq = rxRadioFreq.toDouble()
+                }
+            }
+
+            _state.update {
+                it.copy(
+                    txConnected  = txNow?.isConnected ?: false,
+                    rxConnected  = rxNow?.isConnected ?: false,
+                    txFrequencyHz = txRadioFreq,
+                    rxFrequencyHz = rxRadioFreq,
+                    azimuth      = Math.toDegrees(pos.azimuth),
+                    elevation    = Math.toDegrees(pos.elevation),
+                    distance     = pos.distance
+                )
+            }
+            delay(1000)
+        }
+    }
+
+    // ── IC-705 split-radio tracking ─────────────────────────────────────────
+
+    private suspend fun runSplitTracking(transponder: SatRadio, initialTxBaseFreqHz: Long?) {
+        val radio = txController ?: return
+        if (!radio.isConnected) return
+
+        val txMode = transponder.uplinkMode
+        val rxMode = transponder.downlinkMode
+            ?: transponder.uplinkMode?.let {
+                TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+            }
+
+        // Compute nominal base frequencies
+        val txCenter = when {
+            transponder.uplinkLow != null && transponder.uplinkHigh != null ->
+                (transponder.uplinkLow!! + transponder.uplinkHigh!!) / 2
+            transponder.uplinkLow != null -> transponder.uplinkLow!!
+            else -> null
+        }
+        val rxNominal = if (txCenter != null) {
+            TransponderMapper.mapUplinkToDownlink(txCenter, transponder)
+        } else transponder.downlinkLow
+
+        val txBase = initialTxBaseFreqHz ?: txCenter
+        Log.i(tag, "IC-705 split setup: txBase=${txBase}Hz rxNominal=${rxNominal}Hz txMode=$txMode rxMode=$rxMode")
+
+        // ── Initial setup sequence ──────────────────────────────────────────
+        // Sequence per IC-705: explicitly select VFO, then band → freq → mode.
+        // ACK from each command gates the next — no fixed delays needed.
+
+        // VFO-A = RX (downlink)
+        Log.d(tag, "Split init: selecting VFO-A for RX (downlink)")
+        radio.setVfo(vfoA = true)
+        if (rxNominal != null) {
+            Log.d(tag, "Split init: VFO-A band for ${rxNominal}Hz")
+            radio.setBand(rxNominal)
+            Log.d(tag, "Split init: VFO-A freq=${rxNominal}Hz")
+            radio.setFrequency(rxNominal)
+        }
+        if (rxMode != null) {
+            Log.d(tag, "Split init: VFO-A mode=$rxMode")
+            radio.setMode(rxMode)
+        }
+
+        // VFO-B = TX (uplink)
+        Log.d(tag, "Split init: selecting VFO-B for TX (uplink)")
+        radio.setVfo(vfoA = false)
+        if (txBase != null) {
+            Log.d(tag, "Split init: VFO-B band for ${txBase}Hz")
+            radio.setBand(txBase)
+            Log.d(tag, "Split init: VFO-B freq=${txBase}Hz")
+            radio.setFrequency(txBase)
+        }
+        if (txMode != null) {
+            Log.d(tag, "Split init: VFO-B mode=$txMode")
+            radio.setMode(txMode)
+        }
+        if (txMode?.uppercase() == "FM") {
+            val tone = _state.value.ctcssTone
+            if (tone != null) {
+                Log.d(tag, "Split init: CTCSS=${tone}Hz")
+                radio.setCtcssTone(tone)
+                radio.setCtcssMode(true)
+            } else {
+                radio.setCtcssMode(false)
+            }
+        }
+
+        // Enable SPLIT on VFO-A (return display to RX VFO first)
+        Log.d(tag, "Split init: returning to VFO-A, then enabling SPLIT mode")
+        radio.setVfo(vfoA = true)
+        radio.setSplitMode(enabled = true)
+
+        _state.update { it.copy(txMode = txMode, rxMode = rxMode, txBaseFrequencyHz = txBase) }
+        Log.i(tag, "IC-705 split init done — entering tracking loop")
+
+        // ── Tracking loop with tuning detection ─────────────────────────────
+        var lastSetTxFreq = 0.0
+        var lastSetRxFreq = 0.0
+        var tuningRadio   = ""  // "tx" or "rx" when manual tuning detected
+        var lastReadFreq  = 0L
+        var stableCount   = 0
+
+        while (currentCoroutineContext().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 pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, System.currentTimeMillis())
+            val v = pos.distanceRate * 1000.0
+
+            if (tuningRadio.isNotEmpty()) {
+                // User is tuning — wait for frequency to stabilize
+                val readFreq = if (tuningRadio == "tx") radio.readTxVfoFrequency() else radio.readWorkingFrequency()
+                if (readFreq != null) {
+                    if (kotlin.math.abs(readFreq - lastReadFreq) <= 20) stableCount++
+                    else { stableCount = 0; lastReadFreq = readFreq }
+
+                    if (stableCount >= 2) {
+                        // Frequency stable — reverse-calculate base frequency
+                        if (tuningRadio == "tx" && txBaseFreq != null) {
+                            val newBase = (readFreq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT + v)).toLong()
+                            if (newBase > 0) {
+                                txBaseFreq = newBase
+                                _state.update { it.copy(txBaseFrequencyHz = newBase) }
+                                Log.i(tag, "Split TX tuning done → base=$newBase")
+                            }
+                        } else if (tuningRadio == "rx") {
+                            val rxNominal = (readFreq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT - v)).toLong()
+                            val newTxBase = TransponderMapper.mapDownlinkToUplink(rxNominal, xpdr)
+                            if (newTxBase != null && newTxBase > 0) {
+                                txBaseFreq = newTxBase
+                                _state.update { it.copy(txBaseFrequencyHz = newTxBase) }
+                                Log.i(tag, "Split RX tuning done → txBase=$newTxBase")
+                            }
+                        }
+                        tuningRadio   = ""
+                        stableCount   = 0
+                        lastSetTxFreq = 0.0
+                        lastSetRxFreq = 0.0
+                    }
+                }
+            } else {
+                // Detect manual dial changes
+                if (txBaseFreq != null && lastSetTxFreq > 0.0) {
+                    val readTx = radio.readTxVfoFrequency()
+                    if (readTx != null && kotlin.math.abs(readTx - lastSetTxFreq) >= 20.0) {
+                        tuningRadio  = "tx"
+                        lastReadFreq = readTx
+                        stableCount  = 0
+                        Log.i(tag, "Split TX tuning detected (read=${readTx}, lastSet=$lastSetTxFreq)")
+                    }
+                }
+                if (tuningRadio.isEmpty() && lastSetRxFreq > 0.0) {
+                    val readRx = radio.readWorkingFrequency()
+                    if (readRx != null && kotlin.math.abs(readRx - lastSetRxFreq) >= 20.0) {
+                        tuningRadio  = "rx"
+                        lastReadFreq = readRx
+                        stableCount  = 0
+                        Log.i(tag, "Split RX tuning detected (read=${readRx}, lastSet=$lastSetRxFreq)")
+                    }
+                }
+            }
+
+            // Determine Doppler-corrected frequencies
+            val txRadioFreq = txBaseFreq?.let { pos.getUplinkFreq(it) }
+            val rxBaseCalc  = if (txBaseFreq != null) {
+                TransponderMapper.mapUplinkToDownlink(txBaseFreq, xpdr)
+            } else xpdr.downlinkLow
+            val rxRadioFreq = rxBaseCalc?.let { pos.getDownlinkFreq(it) }
+
+            if (radio.isConnected && tuningRadio.isEmpty()) {
+                // Update both VFOs every cycle — no PTT polling needed.
+                // 0x25/00 = active (RX) VFO, 0x25/01 = inactive (TX) VFO.
+                if (rxRadioFreq != null) {
+                    Log.d(tag, "Split loop RX (0x25/00): ${rxRadioFreq}Hz")
+                    radio.setWorkingFrequency(rxRadioFreq)
+                    lastSetRxFreq = rxRadioFreq.toDouble()
+                }
+                if (txRadioFreq != null) {
+                    Log.d(tag, "Split loop TX (0x25/01): ${txRadioFreq}Hz")
+                    radio.setTxVfoFrequency(txRadioFreq)
+                    lastSetTxFreq = txRadioFreq.toDouble()
+                }
+            }
+
+            _state.update {
+                it.copy(
+                    txConnected   = radio.isConnected,
+                    rxConnected   = false,  // single radio
+                    txFrequencyHz = txRadioFreq,
+                    rxFrequencyHz = rxRadioFreq,
+                    azimuth       = Math.toDegrees(pos.azimuth),
+                    elevation     = Math.toDegrees(pos.elevation),
+                    distance      = pos.distance
+                )
+            }
+            delay(1000)
+        }
+    }
+
+    // ── Other IRadioTrackingService methods ─────────────────────────────────
+
     override fun stopTracking() {
         trackingJob?.cancel()
         trackingJob = null
@@ -288,7 +493,6 @@ class RadioTrackingService(
                     TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
                 }
             rxMode?.let { rx?.setMode(it) }
-
             if (transponder.uplinkMode?.uppercase() == "FM") {
                 _state.value.ctcssTone?.let { tone ->
                     tx?.setCtcssTone(tone)
@@ -302,21 +506,17 @@ class RadioTrackingService(
             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
-        }
+        } else transponder.downlinkLow
         _state.update {
             it.copy(
                 selectedTransponder = transponder,
-                txBaseFrequencyHz = txCenter,
-                txFrequencyHz = txCenter,
-                rxFrequencyHz = rxNominal,
-                txMode = transponder.uplinkMode,
-                rxMode = transponder.downlinkMode
+                txBaseFrequencyHz   = txCenter,
+                txFrequencyHz       = txCenter,
+                rxFrequencyHz       = rxNominal,
+                txMode              = transponder.uplinkMode,
+                rxMode              = transponder.downlinkMode
                     ?: transponder.uplinkMode?.let { m ->
                         TransponderMapper.mapUplinkModeToDownlinkMode(m, transponder.isInverted)
                     }
@@ -353,5 +553,4 @@ class RadioTrackingService(
         }
         _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
     }
-
 }

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

@@ -1,15 +1,32 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.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.Ic705Controller
 import com.rtbishop.look4sat.core.data.framework.NetworkReporter
 import com.rtbishop.look4sat.core.data.framework.RadioTrackingService
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
@@ -20,7 +37,10 @@ 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.model.RadioControlSettings
 import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.IRadioController
@@ -33,6 +53,8 @@ import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import com.rtbishop.look4sat.core.domain.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
@@ -59,6 +81,10 @@ class MainContainer(private val context: Context) : IMainContainer {
 
     override fun provideShowToast(): IShowToast = ShowToast(context)
 
+    override fun provideAudioCapture(): IAudioCapture = AudioCapture()
+
+    override fun provideSaveImage(): ISaveImage = SaveImage(context)
+
     override fun provideBluetoothReporter(): IReporter {
         val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
         val rc = settingsRepo.rcSettings.value
@@ -82,22 +108,38 @@ class MainContainer(private val context: Context) : IMainContainer {
     }
 
     override fun provideTxRadioController(): IRadioController {
-        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-        val address = settingsRepo.radioControlSettings.value.txRadioAddress
-        return Ft817Controller(manager, address)
+        val manager  = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val settings = settingsRepo.radioControlSettings.value
+        val address  = settings.txRadioAddress
+        return if (settings.radioModel == RadioControlSettings.MODEL_ICOM_IC705) {
+            Ic705Controller(manager, address)
+        } else {
+            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)
+        val manager  = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val settings = settingsRepo.radioControlSettings.value
+        val address  = settings.rxRadioAddress
+        return if (settings.radioModel == RadioControlSettings.MODEL_ICOM_IC705) {
+            Ic705Controller(manager, address)
+        } else {
+            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)
+    }
+
+    override fun providePairedBluetoothDevices(): List<Pair<String, String>> = buildList {
+        try {
+            val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+            manager.adapter?.bondedDevices?.forEach { add(Pair(it.name ?: "Unknown", it.address ?: "")) }
+        } catch (_: SecurityException) {}
     }
 
     private fun provideDatabaseRepo(): IDatabaseRepo {

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

@@ -40,57 +40,51 @@ class DatabaseRepo(
     private val settingsRepo: ISettingsRepo
 ) : IDatabaseRepo {
 
-    private companion object {
-        val tleTypes = setOf("Amsat", "R4UAB", "Other")
-        val zippedTleTypes = setOf("McCants", "Classified")
-    }
+    private val customSourceType = "Other"
 
-    override suspend fun updateTLEFromFile(uri: String) = withContext(dispatcher) {
+    override suspend fun updateTLEFromFile(uri: String): Int = withContext(dispatcher) {
+        var importedCount = 0
         remoteSource.getFileStream(uri)?.let { stream ->
-            val entries = dataParser.parseTLEStream(stream)
+            val entries = parseSatelliteStream(uri, unwrapIfZipped(uri, stream))
             localSource.insertEntries(entries)
-            settingsRepo.setSatelliteTypeIds("Other", entries.map { it.catnum })
+            importedCount = entries.size
         }
         setUpdateSuccessful(System.currentTimeMillis())
+        importedCount
     }
 
-    override suspend fun updateTransceiversFromFile(uri: String) = withContext(dispatcher) {
-        remoteSource.getFileStream(uri)
-            ?.let { dataParser.parseJSONStream(it) }
-            ?.takeIf { it.isNotEmpty() }
-            ?.let {
-                localSource.deleteRadios()
-                localSource.insertRadios(it)
-            }
+    override suspend fun updateTransceiversFromFile(uri: String): Int = withContext(dispatcher) {
+        var importedCount = 0
+        remoteSource.getFileStream(uri)?.let { stream ->
+            val transceivers = dataParser.parseJSONStream(unwrapIfZipped(uri, stream))
+            localSource.insertRadios(transceivers)
+            importedCount = transceivers.size
+        }
         setUpdateSuccessful(System.currentTimeMillis())
+        importedCount
     }
 
     override suspend fun updateFromRemote() = withContext(dispatcher) {
         val dataSourcesSettings = settingsRepo.dataSourcesSettings.value
         val tleUrls = buildMap {
             putAll(Sources.satelliteDataUrls)
-            if (dataSourcesSettings.useCustomTLE) put("Other", dataSourcesSettings.tleUrl)
-        }.filterValues { it.isNotEmpty() }
-
-        val radioUrls = buildList {
-            add(Sources.RADIO_DATA_URL)
-            if (dataSourcesSettings.useCustomTransceivers) add(dataSourcesSettings.transceiversUrl)
-        }
-
+            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.map { (type, url) -> async { type to remoteSource.getNetworkStream(url) } }
-        val radioJobs = radioUrls.map { url -> async { remoteSource.getNetworkStream(url) } }
-
-        // parse satellite data
-        val importedEntries = tleJobs.awaitAll().flatMap { (type, stream) ->
-            stream?.let { parseSatelliteStream(type, it) }.orEmpty().also { satellites ->
-                settingsRepo.setSatelliteTypeIds(type, satellites.map { it.catnum })
-            }
+        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
+        val importedEntries = tleJobs.awaitAll().flatMap { (url, stream) ->
+            stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty()
         }
-
-        // parse radio data
-        val importedRadios = radioJobs.awaitAll().filterNotNull().flatMap { dataParser.parseJSONStream(it) }
-
+        val importedRadios = radioJobs.awaitAll().flatMap { (url, stream) ->
+            stream?.let { dataParser.parseJSONStream(unwrapIfZipped(url, it)) }.orEmpty()
+        }
+        // insert parsed data into the database
         localSource.insertEntries(importedEntries)
         localSource.insertRadios(importedRadios)
         setUpdateSuccessful(System.currentTimeMillis())
@@ -102,10 +96,31 @@ class DatabaseRepo(
         setUpdateSuccessful(0L)
     }
 
-    private suspend fun parseSatelliteStream(type: String, stream: InputStream): List<OrbitalData> = when (type) {
-        in tleTypes -> dataParser.parseTLEStream(stream)
-        in zippedTleTypes -> dataParser.parseTLEStream(ZipInputStream(stream).apply { nextEntry })
-        else -> dataParser.parseCSVStream(stream)
+    private suspend fun parseSatelliteStream(url: String, stream: InputStream): List<OrbitalData> {
+        val bufferedStream = stream.buffered()
+        return when {
+            hasCsvHint(url) || looksLikeCsv(bufferedStream) -> dataParser.parseCSVStream(bufferedStream)
+            else -> dataParser.parseTLEStream(bufferedStream)
+        }
+    }
+
+    private fun hasCsvHint(url: String): Boolean {
+        return url.contains("FORMAT=csv", ignoreCase = true) ||
+            url.endsWith(".csv", ignoreCase = true) ||
+            url.endsWith(".csv.zip", ignoreCase = true)
+    }
+
+    private fun looksLikeCsv(stream: InputStream): Boolean {
+        if (!stream.markSupported()) return false
+        stream.mark(4096)
+        val preview = ByteArray(4096)
+        val length = stream.read(preview)
+        stream.reset()
+        if (length <= 0) return false
+        val line = preview.decodeToString(0, length).lineSequence().firstOrNull()?.trim().orEmpty()
+        return line.contains("OBJECT_NAME", ignoreCase = true) ||
+            line.contains("NORAD_CAT_ID", ignoreCase = true) ||
+            line.count { it == ',' } >= 4
     }
 
     private suspend fun setUpdateSuccessful(timestamp: Long) {
@@ -113,4 +128,7 @@ class DatabaseRepo(
             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

@@ -36,6 +36,8 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
+import java.util.TimeZone
+import kotlin.time.Duration.Companion.milliseconds
 
 class SatelliteRepo(
     private val dispatcher: CoroutineDispatcher,
@@ -52,13 +54,28 @@ class SatelliteRepo(
     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
-            calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
+            val settings = settingsRepo.passesSettings.value
+            calculatePasses(
+                time = System.currentTimeMillis(),
+                hoursAhead = settings.hoursAhead,
+                minElevation = settings.minElevation,
+                aosStartMinute = settings.aosStartMinute,
+                aosEndMinute = settings.aosEndMinute,
+                invertAosTimeWindow = settings.invertAosTimeWindow,
+                modes = settingsRepo.selectedSatModes.value
+            )
         }
     }
 
@@ -98,7 +115,15 @@ class SatelliteRepo(
         }
     }
 
-    override suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>) {
+    override suspend fun calculatePasses(
+        time: Long,
+        hoursAhead: Int,
+        minElevation: Double,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean,
+        modes: List<String>
+    ) {
         _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
@@ -123,33 +148,56 @@ class SatelliteRepo(
             val newPasses = ArrayList<OrbitalPass>()
             for (list in passLists) {
                 for (pass in list) {
-                    if (pass.losTime > time && pass.aosTime < timeFuture && pass.maxElevation > minElevation) {
+                    if (
+                        pass.losTime > time
+                        && pass.aosTime < timeFuture
+                        && pass.maxElevation > minElevation
+                        && (pass.isDeepSpace || isAosInRange(pass.aosTime, aosStartMinute, aosEndMinute, invertAosTimeWindow))
+                    ) {
                         newPasses.add(pass)
                     }
                 }
             }
             newPasses.sortBy { it.aosTime }
-            delay(1000) // Simulate loading time for better UX
+            delay(1000.milliseconds) // Simulate loading time for better UX
             _passes.update { newPasses }
         }
         _isCalculating.value = false
     }
 
+    private fun isAosInRange(
+        aosTime: Long,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean
+    ): Boolean {
+        val offsetMillis = TimeZone.getDefault().getOffset(aosTime).toLong()
+        val localMillis = Math.floorMod(aosTime + offsetMillis, 24L * 60L * 60L * 1000L)
+        val aosMinute = (localMillis / 60_000L).toInt()
+        val inRange = if (aosStartMinute <= aosEndMinute) {
+            aosMinute in aosStartMinute..aosEndMinute
+        } else {
+            aosMinute !in (aosEndMinute + 1)..<aosStartMinute
+        }
+        return if (invertAosTimeWindow) !inRange else inRange
+    }
+
     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
@@ -160,17 +208,17 @@ class SatelliteRepo(
         return passes
     }
 
-    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
@@ -234,6 +282,6 @@ class SatelliteRepo(
         val alt = tcaPos.altitude
 
         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

@@ -38,16 +38,16 @@ class SelectionRepo(
 ) : ISelectionRepo {
 
     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.
+    // Resolve sat IDs once when modes 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> ->
-        val catnumSet: Set<Int>? = if (types.isEmpty()) {
+    // Directly observe settingsRepo.selectedSatModes to ensure real-time sync across screens.
+    private val itemsWithModes = settingsRepo.selectedSatModes.flatMapLatest { list: List<String> ->
+        val catnumSet: Set<Int>? = if (list.isEmpty()) {
             null // null = no filtering
         } else {
-            val ids = settingsRepo.getSatelliteTypesIds(types)
+            val ids = localSource.getIdsWithModes(list)
             if (ids.isEmpty()) null else ids.toHashSet()
         }
         currentItems.map { items ->
@@ -56,14 +56,18 @@ class SelectionRepo(
     }
 
     private val itemsWithQuery = currentQuery.flatMapLatest { query ->
-        itemsWithTypes.map { items -> filterByQuery(items, query) }
+        itemsWithModes.map { items ->
+            filterByQuery(items, query).sortedWith(
+                compareByDescending<SatItem> { it.isSelected }
+                    .thenBy { it.name }
+                    .thenBy { it.catnum }
+            )
+        }
     }
 
-    override fun getCurrentTypes() = currentTypes.value
+    override fun getCurrentModes() = settingsRepo.selectedSatModes.value
 
-    override fun getTypesList() = Sources.satelliteDataUrls.keys.sorted().toMutableList().apply {
-        removeAt(0)
-    }
+    override fun getModesList() = Sources.satelliteModes
 
     override suspend fun getEntriesFlow() = withContext(dispatcher) {
         val selectedIds = settingsRepo.selectedIds.value.toHashSet()
@@ -73,9 +77,8 @@ class SelectionRepo(
         return@withContext itemsWithQuery
     }
 
-    override suspend fun setTypes(types: List<String>) {
-        currentTypes.value = types
-        settingsRepo.setSelectedTypes(types)
+    override suspend fun setModes(modes: List<String>) {
+        settingsRepo.setSelectedSatModes(modes)
     }
 
     override suspend fun setQuery(query: String) {

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,13 +32,16 @@ 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)
@@ -45,11 +49,7 @@ class SensorsRepo(
     private var smoothPitch = 0f
     private var hasInitialReading = false
 
-    companion object {
-        private const val SMOOTHING_FACTOR = 0.15f
-    }
-
-    override val orientation: StateFlow<Pair<Float, Float>> = _orientation
+    override val sensorData: StateFlow<Pair<Float, Float>> = _sensorData
 
     override fun getMagDeclination(geoPos: GeoPos, time: Long): Float {
         return GeomagneticField(
@@ -62,7 +62,7 @@ class SensorsRepo(
 
     override fun enableSensor() {
         hasInitialReading = false
-        sensor?.let { sensorManager.registerListener(this, it, 8000) }
+        sensor?.let { sensorManager.registerListener(this, it, SENSOR_RATE_US) }
     }
 
     override fun disableSensor() = sensorManager.unregisterListener(this)
@@ -70,16 +70,11 @@ class SensorsRepo(
     override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) = Unit
 
     override fun onSensorChanged(event: SensorEvent) {
-        if (event.sensor == sensor) updateOrientation(event.values)
+        if (event.sensor.type == Sensor.TYPE_ROTATION_VECTOR) handleSensorEvent(event)
     }
 
     private fun getDisplayRotation(): Int {
-        return try {
-            @Suppress("DEPRECATION")
-            windowManager.defaultDisplay.rotation
-        } catch (_: Exception) {
-            Surface.ROTATION_0
-        }
+        return displayManager?.getDisplay(Display.DEFAULT_DISPLAY)?.rotation ?: Surface.ROTATION_0
     }
 
     private fun remapForRotation(rotation: Int) {
@@ -101,30 +96,23 @@ class SensorsRepo(
         if (remapped) System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
     }
 
-    private fun updateOrientation(rotationVector: FloatArray) {
-        SensorManager.getRotationMatrixFromVector(rotationMatrix, rotationVector)
+    private fun handleSensorEvent(event: SensorEvent) {
+        SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values)
         remapForRotation(getDisplayRotation())
         SensorManager.getOrientation(rotationMatrix, orientationValues)
-        val azimuth = (orientationValues[0] * RAD2DEG).toFloat()
+        val azimuth = normalizeAzimuth((orientationValues[0] * RAD2DEG).toFloat())
         val pitch = (orientationValues[1] * RAD2DEG).toFloat()
-        val magneticAzimuth = (azimuth + 360f) % 360f
-
         if (!hasInitialReading) {
-            smoothAzimuth = magneticAzimuth
+            smoothAzimuth = azimuth
             smoothPitch = pitch
             hasInitialReading = true
         } else {
-            smoothAzimuth = lowPassAngle(smoothAzimuth, magneticAzimuth)
+            smoothAzimuth = lowPassAngle(smoothAzimuth, azimuth)
             smoothPitch = lowPass(smoothPitch, pitch)
         }
-
-        _orientation.value = Pair(
-            round(smoothAzimuth * 10) / 10,
-            round(smoothPitch * 10) / 10
-        )
+        _sensorData.value = Pair(round(smoothAzimuth * 10) / 10, round(smoothPitch * 10) / 10)
     }
 
-    /** Standard exponential low-pass filter. */
     private fun lowPass(previous: Float, current: Float): Float {
         return previous + SMOOTHING_FACTOR * (current - previous)
     }
@@ -135,9 +123,10 @@ class SensorsRepo(
      */
     private fun lowPassAngle(previous: Float, current: Float): Float {
         var delta = current - previous
-        // Normalise delta into the range (-180, 180]
         while (delta > 180f) delta -= 360f
         while (delta <= -180f) delta += 360f
-        return (previous + SMOOTHING_FACTOR * delta + 360f) % 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

@@ -54,6 +54,9 @@ class SettingsRepo(
     private val keyFilterShowDeepSpace = "filterShowDeepSpace"
     private val keyFilterHoursAhead = "filterHoursAhead"
     private val keyFilterMinElevation = "filterMinElevation"
+    private val keyFilterAosStartMinute = "filterAosStartMinute"
+    private val keyFilterAosEndMinute = "filterAosEndMinute"
+    private val keyFilterAosInvert = "filterAosInvert"
     private val keyNumberOfRadios = "numberOfRadios"
     private val keyNumberOfSatellites = "numberOfSatellites"
     private val keyRotatorAddress = "rotatorAddress"
@@ -65,13 +68,13 @@ class SettingsRepo(
     private val keyFrequencyPort = "frequencyPort"
     private val keyFrequencyFormat = "frequencyFormat"
     private val keySelectedIds = "selectedIds"
-    private val keySelectedTypes = "selectedTypes"
-    private val keySelectedModes = "selectedModes"
+    private val keySelectedSatModes = "selectedSatModes"
     private val keyStateOfAutoUpdate = "stateOfAutoUpdate"
     private val keyStateOfSensors = "stateOfSensors"
     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"
@@ -80,6 +83,11 @@ class SettingsRepo(
     private val keyUpdateTimestamp = "updateTimestamp"
     private val keyShouldSeeWarning = "shouldSeeWarning"
     private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew_v$appVersionName"
+    private val keySstvMode = "sstvMode"
+    private val keyLowElevation = "lowElevation"
+    private val keyHighElevation = "highElevation"
+    private val keyRadarCompassOffset = "radarCompassOffset"
+    private val keyRadarCompassOffsetElev = "radarCompassOffsetElev"
     private val keyUseCustomTle = "useCustomTle"
     private val keyUseCustomTransceivers = "useCustomTransceivers"
     private val keyTleUrl = "tleUrl"
@@ -88,9 +96,9 @@ class SettingsRepo(
 
     //region # Satellites selection settings
     private val _satelliteSelection = MutableStateFlow(getSelectedIds())
-    private val _typesSelection = MutableStateFlow(getSelectedTypes())
+    private val _satelliteModeSelection = MutableStateFlow(getSelectedSatModes())
     override val selectedIds: StateFlow<List<Int>> = _satelliteSelection
-    override val selectedTypes: StateFlow<List<String>> = _typesSelection
+    override val selectedSatModes: StateFlow<List<String>> = _satelliteModeSelection
 
     override fun setSelectedIds(ids: List<Int>) {
         val selectionString = ids.joinToString(separatorComma)
@@ -98,10 +106,10 @@ class SettingsRepo(
         _satelliteSelection.value = ids
     }
 
-    override fun setSelectedTypes(types: List<String>) {
-        val typesString = types.joinToString(separatorComma)
-        preferences.edit { putString(keySelectedTypes, typesString) }
-        _typesSelection.value = types
+    override fun setSelectedSatModes(modes: List<String>) {
+        val modesString = modes.joinToString(separatorComma)
+        preferences.edit { putString(keySelectedSatModes, modesString) }
+        _satelliteModeSelection.value = modes
     }
 
     private fun getSelectedIds(): List<Int> {
@@ -110,10 +118,10 @@ class SettingsRepo(
         return selectionString.split(separatorComma).map { it.toInt() }
     }
 
-    private fun getSelectedTypes(): List<String> {
-        val typesString = preferences.getString(keySelectedTypes, null)
-        if (typesString.isNullOrEmpty()) return listOf("Amateur")
-        return typesString.split(separatorComma)
+    private fun getSelectedSatModes(): List<String> {
+        val modesString = preferences.getString(keySelectedSatModes, null)
+        if (modesString.isNullOrEmpty()) return emptyList()
+        return modesString.split(separatorComma).sorted()
     }
     //endregion
 
@@ -125,7 +133,9 @@ class SettingsRepo(
         putBoolean(keyFilterShowDeepSpace, settings.showDeepSpace)
         putInt(keyFilterHoursAhead, settings.hoursAhead)
         putLong(keyFilterMinElevation, settings.minElevation.toRawBits())
-        putString(keySelectedModes, settings.selectedModes.joinToString(separatorComma))
+        putInt(keyFilterAosStartMinute, settings.aosStartMinute)
+        putInt(keyFilterAosEndMinute, settings.aosEndMinute)
+        putBoolean(keyFilterAosInvert, settings.invertAosTimeWindow)
         _passesSettings.value = settings
     }
 
@@ -133,9 +143,17 @@ class SettingsRepo(
         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(showDeepSpace, hoursAhead, minElevation, selectedModes)
+        val aosStartMinute = preferences.getInt(keyFilterAosStartMinute, 0).coerceIn(0, 23 * 60 + 59)
+        val aosEndMinute = preferences.getInt(keyFilterAosEndMinute, 23 * 60 + 59).coerceIn(0, 23 * 60 + 59)
+        val invertAosTimeWindow = preferences.getBoolean(keyFilterAosInvert, false)
+        return PassesSettings(
+            showDeepSpace,
+            hoursAhead,
+            minElevation,
+            aosStartMinute,
+            aosEndMinute,
+            invertAosTimeWindow
+        )
     }
     //endregion
 
@@ -214,25 +232,6 @@ class SettingsRepo(
     private val _databaseState = MutableStateFlow(getDatabaseState())
     override val databaseState: StateFlow<DatabaseState> = _databaseState
 
-    override fun getSatelliteTypesIds(types: List<String>): List<Int> {
-        val idsSet = mutableSetOf<Int>()
-        types.forEach { type ->
-            val typeString = preferences.getString("type$type", null)
-            val typeIds = if (typeString.isNullOrBlank()) {
-                emptyList()
-            } else {
-                typeString.split(separatorComma).map { it.toInt() }
-            }
-            idsSet.addAll(typeIds)
-        }
-        return idsSet.toList()
-    }
-
-    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
-        if (type == "All") return
-        val typesString = ids.joinToString(separatorComma)
-        preferences.edit { putString("type$type", typesString) }
-    }
 
     override fun updateDatabaseState(state: DatabaseState) = preferences.edit {
         putInt(keyNumberOfSatellites, state.numberOfSatellites)
@@ -329,8 +328,14 @@ class SettingsRepo(
                 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)
+                putLong(keyLowElevation, new.lowElevation.toRawBits())
+                putLong(keyHighElevation, new.highElevation.toRawBits())
+                putFloat(keyRadarCompassOffset, new.radarCompassOffset)
+                putFloat(keyRadarCompassOffsetElev, new.radarCompassOffsetElev)
             }
             new
         }
@@ -342,8 +347,14 @@ 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",
+        lowElevation = Double.fromBits(preferences.getLong(keyLowElevation, 15.0.toRawBits())),
+        highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits())),
+        radarCompassOffset = preferences.getFloat(keyRadarCompassOffset, 0f),
+        radarCompassOffsetElev = preferences.getFloat(keyRadarCompassOffsetElev, 0f)
     )
     //endregion
 
@@ -377,6 +388,7 @@ class SettingsRepo(
     private val keyTxRadioName = "txRadioName"
     private val keyRxRadioName = "rxRadioName"
     private val keyRadioBaudRate = "radioBaudRate"
+    private val keyRadioSplitMode = "radioSplitMode"
 
     private val _radioControlSettings = MutableStateFlow(getRadioControlSettings())
     override val radioControlSettings: StateFlow<RadioControlSettings> = _radioControlSettings
@@ -390,18 +402,20 @@ class SettingsRepo(
             putString(keyTxRadioName, settings.txRadioName)
             putString(keyRxRadioName, settings.rxRadioName)
             putInt(keyRadioBaudRate, settings.baudRate)
+            putBoolean(keyRadioSplitMode, settings.splitMode)
         }
         _radioControlSettings.value = settings
     }
 
     private fun getRadioControlSettings(): RadioControlSettings = RadioControlSettings(
         enabled = preferences.getBoolean(keyRadioControlEnabled, false),
-        radioModel = preferences.getString(keyRadioModel, null) ?: "Yaesu FT-817/818",
+        radioModel = preferences.getString(keyRadioModel, null) ?: RadioControlSettings.MODEL_YAESU_FT817,
         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)
+        baudRate = preferences.getInt(keyRadioBaudRate, 4800),
+        splitMode = preferences.getBoolean(keyRadioSplitMode, false)
     )
     //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

@@ -45,7 +45,14 @@ 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()
+            val response = httpClient.newCall(networkRequest).execute()
+            if (!response.isSuccessful) {
+                response.close()
+                return@withContext null
+            }
+            // Return the body stream directly as the caller is responsible for closing it
+            // That returns the connection to OkHttp's pool
+            response.body.byteStream().buffered()
         } 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/framework/Ft817CatProtocolTest.kt

@@ -1,30 +1,29 @@
-package com.rtbishop.look4sat.core.data
+package com.rtbishop.look4sat.core.data.framework
 
-import com.rtbishop.look4sat.core.data.framework.Ft817CatProtocol
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
 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)
+        assertArrayEquals(byteArrayOf(0x14, 0x55, 0x00, 0x00), bcd)
     }
 
     @Test
     fun encodeFrequencyBcd_435100000() {
         val bcd = Ft817CatProtocol.encodeFrequencyBcd(435100000L)
-        assertContentEquals(byteArrayOf(0x43, 0x51, 0x00, 0x00), bcd)
+        assertArrayEquals(byteArrayOf(0x43, 0x51, 0x00, 0x00), bcd)
     }
 
     @Test
     fun encodeFrequencyBcd_7074000() {
         val bcd = Ft817CatProtocol.encodeFrequencyBcd(7074000L)
-        assertContentEquals(byteArrayOf(0x00, 0x70, 0x74, 0x00), bcd)
+        assertArrayEquals(byteArrayOf(0x00, 0x70, 0x74, 0x00), bcd)
     }
 
     @Test
@@ -42,21 +41,21 @@ class Ft817CatProtocolTest {
         val cmd = Ft817CatProtocol.buildSetFreqCommand(145500000L)
         assertEquals(5, cmd.size)
         assertEquals(0x01.toByte(), cmd[4])
-        assertContentEquals(byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x01), cmd)
+        assertArrayEquals(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)
+        assertArrayEquals(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)
+        assertArrayEquals(byteArrayOf(0x08, 0x00, 0x00, 0x00, 0x07), cmd)
     }
 
     @Test
@@ -67,19 +66,19 @@ class Ft817CatProtocolTest {
     @Test
     fun encodeCtcssTone_67_0() {
         val bcd = Ft817CatProtocol.encodeCtcssToneBcd(67.0)
-        assertContentEquals(byteArrayOf(0x06, 0x70), bcd)
+        assertArrayEquals(byteArrayOf(0x06, 0x70), bcd)
     }
 
     @Test
     fun encodeCtcssTone_74_4() {
         val bcd = Ft817CatProtocol.encodeCtcssToneBcd(74.4)
-        assertContentEquals(byteArrayOf(0x07, 0x44), bcd)
+        assertArrayEquals(byteArrayOf(0x07, 0x44), bcd)
     }
 
     @Test
     fun encodeCtcssTone_141_3() {
         val bcd = Ft817CatProtocol.encodeCtcssToneBcd(141.3)
-        assertContentEquals(byteArrayOf(0x14, 0x13), bcd)
+        assertArrayEquals(byteArrayOf(0x14, 0x13), bcd)
     }
 
     @Test
@@ -87,13 +86,13 @@ class Ft817CatProtocolTest {
         val cmd = Ft817CatProtocol.buildSetCtcssToneCommand(67.0)
         assertEquals(5, cmd.size)
         assertEquals(0x0B.toByte(), cmd[4])
-        assertContentEquals(byteArrayOf(0x06, 0x70, 0x00, 0x00, 0x0B), cmd)
+        assertArrayEquals(byteArrayOf(0x06, 0x70, 0x00, 0x00, 0x0B), cmd)
     }
 
     @Test
     fun buildCtcssModeCommand_enable() {
         val cmd = Ft817CatProtocol.buildCtcssModeCommand(true)
-        assertContentEquals(byteArrayOf(0x2A, 0x00, 0x00, 0x00, 0x0A), cmd)
+        assertArrayEquals(byteArrayOf(0x2A, 0x00, 0x00, 0x00, 0x0A), cmd)
     }
 
     @Test
@@ -108,6 +107,7 @@ class Ft817CatProtocolTest {
         val response = byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x01)
         val result = Ft817CatProtocol.parseReadResponse(response)
         assertNotNull(result)
+        result ?: return
         assertEquals(145500000L, result.first)
         assertEquals("USB", result.second)
     }
@@ -117,6 +117,7 @@ class Ft817CatProtocolTest {
         val response = byteArrayOf(0x14, 0x60, 0x00, 0x00, 0x08)
         val result = Ft817CatProtocol.parseReadResponse(response)
         assertNotNull(result)
+        result ?: return
         assertEquals(146000000L, result.first)
         assertEquals("FM", result.second)
     }
@@ -135,7 +136,7 @@ class Ft817CatProtocolTest {
     @Test
     fun buildPttCommands() {
         val on = Ft817CatProtocol.buildPttOnCommand()
-        assertContentEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x08), on)
+        assertArrayEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x08), on)
 
         val off = Ft817CatProtocol.buildPttOffCommand()
         assertEquals(0x88.toByte(), off[4])
@@ -144,6 +145,6 @@ class Ft817CatProtocolTest {
     @Test
     fun buildReadCommand() {
         val cmd = Ft817CatProtocol.buildReadFreqModeCommand()
-        assertContentEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x03), cmd)
+        assertArrayEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x03), cmd)
     }
 }

core/data/src/test/java/com/rtbishop/look4sat/core/data/repository/DatabaseRepoTest.kt

@@ -0,0 +1,225 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.utility.DataParser
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.InputStream
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class DatabaseRepoTest {
+
+    private val dispatcher = StandardTestDispatcher()
+    private val dataParser = DataParser(dispatcher)
+
+    @Test
+    fun `manual satellite import parses csv stream from content uri`() = runTest(dispatcher) {
+        val uri = "content://look4sat/import/satellites"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            fileStreams[uri] = { validCsvStream() }
+        }
+        val settingsRepo = FakeSettingsRepo()
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateTLEFromFile(uri)
+
+        assertEquals(1, localSource.insertedEntries.size)
+        assertEquals(25544, localSource.insertedEntries.first().catnum)
+        assertTrue(settingsRepo.databaseState.value.numberOfSatellites > 0)
+    }
+
+    @Test
+    fun `manual satellite import keeps tle support`() = runTest(dispatcher) {
+        val uri = "content://look4sat/import/legacy"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            fileStreams[uri] = { validTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo()
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateTLEFromFile(uri)
+
+        assertEquals(1, localSource.insertedEntries.size)
+        assertEquals(25544, localSource.insertedEntries.first().catnum)
+    }
+
+    @Test
+    fun `custom data source imports omm csv from web`() = runTest(dispatcher) {
+        val customCsvUrl = "https://example.com/custom-omm.csv"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[customCsvUrl] = { validCsvStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                useCustomTLE = true,
+                useCustomTransceivers = false,
+                tleUrl = customCsvUrl,
+                transceiversUrl = ""
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        assertTrue(localSource.insertedEntries.any { it.catnum == 25544 })
+    }
+
+    private fun validCsvStream(): InputStream = """
+        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()
+
+    private fun validTleStream(): InputStream = """
+        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()
+}
+
+private class FakeRemoteSource : IRemoteSource {
+    val fileStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
+    val networkStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
+
+    override suspend fun getFileStream(uri: String): InputStream? = fileStreams[uri]?.invoke()
+
+    override suspend fun getNetworkStream(url: String): InputStream? = networkStreams[url]?.invoke()
+}
+
+private class FakeLocalSource : ILocalSource {
+    val insertedEntries = mutableListOf<OrbitalData>()
+    private val insertedRadios = mutableListOf<SatRadio>()
+
+    override suspend fun getEntriesTotal(): Int = insertedEntries.size
+
+    override suspend fun getEntriesList(): List<SatItem> = emptyList()
+
+    override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
+
+    override suspend fun insertEntries(entries: List<OrbitalData>) {
+        insertedEntries += entries
+    }
+
+    override suspend fun deleteEntries() {
+        insertedEntries.clear()
+    }
+
+    override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+
+    override suspend fun getRadiosTotal(): Int = insertedRadios.size
+
+    override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()
+
+    override suspend fun insertRadios(radios: List<SatRadio>) {
+        insertedRadios += radios
+    }
+
+    override suspend fun deleteRadios() {
+        insertedRadios.clear()
+    }
+}
+
+private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSourcesSettings()) : ISettingsRepo {
+
+    override val appVersionName: String = "test"
+
+    override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
+
+    override val selectedSatModes: StateFlow<List<String>> = MutableStateFlow(emptyList())
+
+    override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
+        PassesSettings(hoursAhead = 24, minElevation = 0.0)
+    )
+
+    override val stationPosition: StateFlow<GeoPos> = MutableStateFlow(GeoPos(0.0, 0.0))
+
+    override val databaseState: MutableStateFlow<DatabaseState> = MutableStateFlow(DatabaseState(0, 0, 0L))
+
+    override val rcSettings: StateFlow<RCSettings> = MutableStateFlow(
+        RCSettings(false, "", "", "", false, "", "", "", false, "", "", "", false, "", "")
+    )
+
+    override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
+        OtherSettings(false, false, false, false, false, false, false, false)
+    )
+
+    override val dataSourcesSettings: MutableStateFlow<DataSourcesSettings> = MutableStateFlow(dataSources)
+
+    override val radioControlSettings: StateFlow<RadioControlSettings> = MutableStateFlow(
+        RadioControlSettings(false, RadioControlSettings.MODEL_YAESU_FT817, "", "", "", "", 9600)
+    )
+
+    override fun setSelectedIds(ids: List<Int>) = Unit
+
+    override fun setSelectedSatModes(modes: List<String>) = Unit
+
+    override fun setPassesSettings(settings: PassesSettings) = Unit
+
+    override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean = true
+
+    override fun setStationPosition(): Boolean = true
+
+    override fun setStationPosition(locator: String): Boolean = true
+
+
+    override fun updateDatabaseState(state: DatabaseState) {
+        databaseState.value = state
+    }
+
+    override fun updateRCSettings(settings: RCSettings) = Unit
+
+    override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) = Unit
+
+    override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
+        dataSourcesSettings.value = settings
+    }
+
+    override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
+}
+
+private fun defaultDataSourcesSettings(): DataSourcesSettings {
+    return DataSourcesSettings(
+        useCustomTLE = false,
+        useCustomTransceivers = false,
+        tleUrl = "",
+        transceiversUrl = ""
+    )
+}

core/data/src/test/java/com/rtbishop/look4sat/core/data/repository/SelectionRepoTest.kt

@@ -0,0 +1,173 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SelectionRepoTest {
+
+    private val dispatcher = StandardTestDispatcher()
+
+    @Test
+    fun `unknown mode values do not crash and do not filter out entries`() = runTest(dispatcher) {
+        val localSource = FakeLocalSource(
+            entries = listOf(
+                SatItem(25544, "ISS (ZARYA)", false),
+                SatItem(40967, "TIANGONG", false)
+            )
+        )
+        val settingsRepo = FakeSettingsRepo(selectedModes = listOf("REMOVED_MODE"))
+        val repository = SelectionRepo(dispatcher, localSource, settingsRepo)
+
+        val flow = repository.getEntriesFlow()
+        repository.setModes(listOf("REMOVED_MODE"))
+
+        val items = flow.first()
+
+        assertEquals(listOf(25544, 40967), items.map { it.catnum })
+        assertEquals(listOf("REMOVED_MODE"), repository.getCurrentModes())
+    }
+
+    @Test
+    fun `selected satellites are shown first`() = runTest(dispatcher) {
+        val localSource = FakeLocalSource(
+            entries = listOf(
+                SatItem(44444, "Zeta", false),
+                SatItem(25544, "Alpha", false),
+                SatItem(40967, "Beta", false)
+            )
+        )
+        val settingsRepo = FakeSettingsRepo(selectedModes = emptyList())
+        val repository = SelectionRepo(dispatcher, localSource, settingsRepo)
+
+        val flow = repository.getEntriesFlow()
+        repository.setSelection(listOf(40967), true)
+
+        val items = flow.first()
+
+        assertEquals(listOf(40967, 25544, 44444), items.map { it.catnum })
+        assertEquals(listOf(true, false, false), items.map { it.isSelected })
+    }
+
+    private class FakeLocalSource(
+        private val entries: List<SatItem>
+    ) : ILocalSource {
+        override suspend fun getEntriesTotal(): Int = entries.size
+
+        override suspend fun getEntriesList(): List<SatItem> = entries
+
+        override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
+
+        override suspend fun insertEntries(entries: List<com.rtbishop.look4sat.core.domain.predict.OrbitalData>) = Unit
+
+        override suspend fun deleteEntries() = Unit
+
+        override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+
+        override suspend fun getRadiosTotal(): Int = 0
+
+        override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()
+
+        override suspend fun insertRadios(radios: List<SatRadio>) = Unit
+
+        override suspend fun deleteRadios() = Unit
+    }
+
+    private class FakeSettingsRepo(
+        selectedModes: List<String>
+    ) : ISettingsRepo {
+
+        override val appVersionName: String = "test"
+
+        override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
+
+        override val selectedSatModes: MutableStateFlow<List<String>> = MutableStateFlow(selectedModes)
+
+        override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
+            PassesSettings(hoursAhead = 24, minElevation = 0.0)
+        )
+
+        override val stationPosition: StateFlow<GeoPos> = MutableStateFlow(GeoPos(0.0, 0.0))
+
+        override val databaseState: MutableStateFlow<DatabaseState> = MutableStateFlow(DatabaseState(0, 0, 0L))
+
+        override val rcSettings: StateFlow<RCSettings> = MutableStateFlow(
+            RCSettings(false, "", "", "", false, "", "", "", false, "", "", "", false, "", "")
+        )
+
+        override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
+            OtherSettings(false, false, false, false, false, false, false, false)
+        )
+
+        override val dataSourcesSettings: StateFlow<DataSourcesSettings> = MutableStateFlow(
+            DataSourcesSettings(false, false, "", "")
+        )
+
+        override val radioControlSettings: StateFlow<RadioControlSettings> = MutableStateFlow(
+            RadioControlSettings(false, RadioControlSettings.MODEL_YAESU_FT817, "", "", "", "", 9600)
+        )
+
+        override fun setSelectedIds(ids: List<Int>) = Unit
+
+        override fun setSelectedSatModes(modes: List<String>) {
+            selectedSatModes.value = modes
+        }
+
+        override fun setPassesSettings(settings: PassesSettings) = Unit
+
+        override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean = true
+
+        override fun setStationPosition(): Boolean = true
+
+        override fun setStationPosition(locator: String): Boolean = true
+
+        override fun updateDatabaseState(state: DatabaseState) {
+            databaseState.value = state
+        }
+
+        override fun updateRCSettings(settings: RCSettings) = Unit
+
+        override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) = Unit
+
+        override fun updateDataSourcesSettings(settings: DataSourcesSettings) = Unit
+
+        override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
+    }
+}
+
+

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

@@ -27,7 +27,9 @@ data class PassesSettings(
     val showDeepSpace: Boolean = true,
     val hoursAhead: Int,
     val minElevation: Double,
-    val selectedModes: List<String>
+    val aosStartMinute: Int = 0,
+    val aosEndMinute: Int = 23 * 60 + 59,
+    val invertAosTimeWindow: Boolean = false
 )
 
 data class RCSettings(
@@ -54,8 +56,14 @@ 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",
+    val lowElevation: Double = 15.0,
+    val highElevation: Double = 45.0,
+    val radarCompassOffset: Float = 0f,
+    val radarCompassOffsetElev: Float = 0f
 )
 
 data class DataSourcesSettings(
@@ -72,12 +80,20 @@ data class RadioControlSettings(
     val rxRadioAddress: String,
     val txRadioName: String,
     val rxRadioName: String,
-    val baudRate: Int
+    val baudRate: Int,
+    /** IC-705 only: use single-radio split-VFO mode instead of two radios. */
+    val splitMode: Boolean = false
 ) {
     companion object {
-        val SUPPORTED_RADIOS = listOf(
-            "Yaesu FT-817/818",
-            "Yaesu FT-857/897"
-        )
+        const val MODEL_YAESU_FT817   = "Yaesu FT-817/818"
+        const val MODEL_YAESU_FT857   = "Yaesu FT-857/897"
+        const val MODEL_ICOM_IC705    = "Icom IC-705"
+
+        val SUPPORTED_RADIOS = listOf(MODEL_YAESU_FT817, MODEL_YAESU_FT857, MODEL_ICOM_IC705)
+
+        /** Baud rates available for Yaesu radios. */
+        val BAUD_RATES_YAESU = listOf(4800, 9600, 38400)
+        /** Baud rates available for Icom IC-705 (higher speeds supported via CI-V USB/BT). */
+        val BAUD_RATES_ICOM  = listOf(4800, 9600, 19200, 38400, 57600, 115200)
     }
 }

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/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

@@ -314,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) {
@@ -423,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 the 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
@@ -446,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) {
@@ -470,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,
-    val 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

@@ -63,10 +63,8 @@ data class OrbitalPos(
         val sinBeta = sin(beta)
         for (azimuth in 0..720) {
             val rads = azimuth * DEG2RAD
-            val sinRads = sin(rads)
-            val cosRads = cos(rads)
-            val lat = asin(sinLat * cosBeta + cosLat * sinBeta * cosRads)
-            val lon = longitude + atan2(sinRads * sinBeta * cosLat, cosBeta - sinLat * 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

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

@@ -18,8 +18,8 @@
 package com.rtbishop.look4sat.core.domain.repository
 
 interface IDatabaseRepo {
-    suspend fun updateTLEFromFile(uri: String)
-    suspend fun updateTransceiversFromFile(uri: String)
+    suspend fun updateTLEFromFile(uri: String): Int
+    suspend fun updateTransceiversFromFile(uri: String): Int
     suspend fun updateFromRemote()
     suspend fun clearAllData()
 }

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,6 +29,7 @@ interface IMainContainer {
     val selectionRepo: ISelectionRepo
     val satelliteRepo: ISatelliteRepo
     val databaseRepo: IDatabaseRepo
+    val radioTrackingService: IRadioTrackingService
     fun provideAddToCalendar(): IAddToCalendar
     fun provideShowToast(): IShowToast
     fun provideBluetoothReporter(): IReporter
@@ -17,7 +37,9 @@ interface IMainContainer {
     fun provideSensorsRepo(): ISensorsRepo
     fun provideTxRadioController(): IRadioController
     fun provideRxRadioController(): IRadioController
-    val radioTrackingService: IRadioTrackingService
+    fun provideAudioCapture(): IAudioCapture
+    fun provideSaveImage(): ISaveImage
+    fun providePairedBluetoothDevices(): List<Pair<String, String>>
 }
 
 interface IContainerProvider {

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

@@ -38,4 +38,51 @@ interface IRadioController {
     suspend fun pttOn(): Boolean
 
     suspend fun pttOff(): Boolean
+
+    // ── Extended operations (IC-705 / CI-V) ──────────────────────────────
+
+    /**
+     * Select the band matching [frequencyHz] via the band stacking register.
+     * Must be called before [setFrequency] and [setMode] when first tracking.
+     * Default: no-op (Yaesu radios auto-switch band via frequency).
+     */
+    suspend fun setBand(frequencyHz: Long): Boolean = false
+
+    /**
+     * Select the active VFO.
+     * @param vfoA true → VFO-A (main/RX), false → VFO-B (sub/TX in split).
+     */
+    suspend fun setVfo(vfoA: Boolean): Boolean = false
+
+    /**
+     * Enable or disable SPLIT mode (TX on sub-VFO, RX on main VFO).
+     * Default: not supported.
+     */
+    suspend fun setSplitMode(enabled: Boolean): Boolean = false
+
+    /**
+     * Set the frequency of the currently active VFO (IC-705: CMD 0x25 sub 0x00).
+     * Default: delegates to [setFrequency].
+     */
+    suspend fun setWorkingFrequency(frequencyHz: Long): Boolean = setFrequency(frequencyHz)
+
+    /**
+     * Set the frequency of the inactive/TX VFO (IC-705: CMD 0x25 sub 0x01).
+     * Sent every tracking cycle alongside [setWorkingFrequency] in split mode.
+     * Default: delegates to [setWorkingFrequency].
+     */
+    suspend fun setTxVfoFrequency(frequencyHz: Long): Boolean = setWorkingFrequency(frequencyHz)
+
+    /**
+     * Read the frequency of the currently active VFO (IC-705: CMD 0x25 sub 0x00).
+     * Default: delegates to [readFrequencyAndMode].
+     */
+    suspend fun readWorkingFrequency(): Long? = readFrequencyAndMode()?.first
+
+    /**
+     * Read the frequency of the inactive/TX VFO (IC-705: CMD 0x25 sub 0x01).
+     * Used for tuning detection in split mode.
+     * Default: delegates to [readWorkingFrequency].
+     */
+    suspend fun readTxVfoFrequency(): Long? = readWorkingFrequency()
 }

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

@@ -34,11 +34,25 @@ interface ISatelliteRepo {
     /** 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()
 
     /** Recalculate passes with the given filter parameters. */
-    suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>)
+    suspend fun calculatePasses(
+        time: Long,
+        hoursAhead: Int,
+        minElevation: Double,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean,
+        modes: List<String>
+    )
 
     /** Get the current position of a single satellite. */
     suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos

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

@@ -21,10 +21,10 @@ import com.rtbishop.look4sat.core.domain.model.SatItem
 import kotlinx.coroutines.flow.Flow
 
 interface ISelectionRepo {
-    fun getCurrentTypes(): List<String>
-    fun getTypesList(): List<String>
+    fun getCurrentModes(): List<String>
+    fun getModesList(): List<String>
     suspend fun getEntriesFlow(): Flow<List<SatItem>>
-    suspend fun setTypes(types: List<String>)
+    suspend fun setModes(modes: List<String>)
     suspend fun setQuery(query: String)
     suspend fun setSelection(selectAll: Boolean)
     suspend fun setSelection(ids: List<Int>, isTicked: Boolean)

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

@@ -32,9 +32,9 @@ interface ISettingsRepo {
 
     //region # Satellites selection settings
     val selectedIds: StateFlow<List<Int>>
-    val selectedTypes: StateFlow<List<String>>
+    val selectedSatModes: StateFlow<List<String>>
     fun setSelectedIds(ids: List<Int>)
-    fun setSelectedTypes(types: List<String>)
+    fun setSelectedSatModes(modes: List<String>)
     //endregion
 
     //region # Passes filter settings
@@ -51,8 +51,6 @@ interface ISettingsRepo {
 
     //region # Database update settings
     val databaseState: StateFlow<DatabaseState>
-    fun getSatelliteTypesIds(types: List<String>): List<Int>
-    fun setSatelliteTypeIds(type: String, ids: List<Int>)
     fun updateDatabaseState(state: DatabaseState)
     //endregion
 

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

@@ -18,35 +18,26 @@
 package com.rtbishop.look4sat.core.domain.source
 
 object Sources {
-    const val RADIO_DATA_URL = "https://db.satnogs.org/api/transmitters/?format=json&status=active"
     val satelliteDataUrls = mapOf(
-        "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
-        "Amateur" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=csv",
-        "Brightest" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=visual&FORMAT=csv",
-        "Cubesat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=cubesat&FORMAT=csv",
-        "Education" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=education&FORMAT=csv",
-        "Engineer" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=engineering&FORMAT=csv",
-        "Geostationary" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=geo&FORMAT=csv",
-        "Globalstar" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=globalstar&FORMAT=csv",
-        "GNSS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=gnss&FORMAT=csv",
-        "Intelsat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=intelsat&FORMAT=csv",
-        "Iridium" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=iridium-NEXT&FORMAT=csv",
-        "Military" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=military&FORMAT=csv",
-        "New" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=last-30-days&FORMAT=csv",
-        "OneWeb" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=oneweb&FORMAT=csv",
-        "Orbcomm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=orbcomm&FORMAT=csv",
-        "Resource" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=resource&FORMAT=csv",
-        "SatNOGS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv",
-        "Science" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=science&FORMAT=csv",
-        "Spire" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=spire&FORMAT=csv",
-        "Starlink" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=starlink&FORMAT=csv",
-        "Swarm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=swarm&FORMAT=csv",
-        "Weather" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=weather&FORMAT=csv",
-        "X-Comm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=x-comm&FORMAT=csv",
-        "Amsat" to "https://amsat.org/tle/current/nasabare.txt",
-        "Classified" to "https://www.mmccants.org/tles/classfd.zip",
-        "McCants" to "https://www.mmccants.org/tles/inttles.zip",
+        "CelesTrak" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
+        "AMSAT" to "https://amsat.org/tle/current/nasabare.txt",
+        "McCants Classified" to "https://www.mmccants.org/tles/classfd.zip",
+        "McCants Integrated" to "https://www.mmccants.org/tles/inttles.zip",
         "R4UAB" to "https://r4uab.ru/satonline.txt",
+        "SatNOGS" to "https://db.satnogs.org/api/tle/?format=3le",
+        "ARISS" to "https://live.ariss.org/iss.txt",
         "Other" to "" // key for sats filter
     )
+    val transceiversDataUrls = mapOf(
+        "SatNOGS" to "https://db.satnogs.org/api/transmitters/?format=json&status=active"
+    )
+    val satelliteModes = listOf(
+        "4FSK", "64-QAM", "AFSK", "AFSK TUBiX10", "AHRPT", "AM", "APT", "ASK", "BPSK",
+        "BPSK PMT-A3", "CERTO", "CW", "DATV", "DBPSK", "DOKA", "DPSK", "DQPSK", "DSB", "DSTAR",
+        "DUV", "DVB-S2", "FFSK", "FM", "FMN", "FSK", "FSK AX.100 Mode 5", "FSK AX.100 Mode 6",
+        "FSK AX.25 G3RUH", "FT8", "GENESIS FSK", "GFSK", "GFSK Pkst", "GFSK Rktr", "GFSK/BPSK",
+        "GMSK", "GMSK USP", "HRPT", "LoRa", "LRPT", "LSB", "MFSK", "MSK", "MSK AX.100 Mode 5",
+        "MSK AX.100 Mode 6", "OFDM", "OQPSK", "PPM", "PSK", "PSK31", "PSK63", "QPSK", "QPSK31",
+        "QPSK63", "SIDLOC", "SQPSK", "SSDV", "SSTV", "UNKNOWN", "USB", "WSJT"
+    )
 }

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

@@ -0,0 +1,816 @@
+/*
+ * 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.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.withContext
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.round
+import kotlin.math.sqrt
+
+class SstvFrame(
+    val scopePixels: IntArray?,
+    val scopeWidth: Int,
+    val scopeHeight: Int,
+    val imagePixels: IntArray?,
+    val imageWidth: Int,
+    val imageHeight: Int,
+    val modeName: String,
+    val imageComplete: Boolean,
+    val inputRms: Float,
+    val appliedGain: Float,
+    val syncHitRate: Float,
+    val predictedLineBursts: Int,
+    val maxPredictedStreak: Int,
+    val timingErrorSamples: Int
+)
+
+/**
+ * Decoder quality metrics for diagnostics and logging. Useful for profiling decode
+ * performance on noisy recordings.
+ */
+data class SstvQualityMetrics(
+    val syncHitRate: Float,
+    val predictedLineBursts: Int,
+    val maxPredictedStreak: Int,
+    val timingErrorSamples: Int
+)
+
+enum class LineRecoveryStrategy {
+    Look4SatLimited,
+    Robot36Compatible
+}
+
+class SstvDiagnosticsHandle internal constructor(
+    val enabled: Boolean,
+    val metrics: StateFlow<SstvQualityMetrics?>
+)
+
+class SstvDecoder(
+    sampleRate: Int = 44100,
+    scopeWidth: Int = 320,
+    scopeHeight: Int = 256,
+    private val channelSelect: Int = 0,
+    targetRmsLevel: Float = 0.25f,
+    private val includeScopeData: Boolean = false,
+    private val enableRmsNormalization: Boolean = true,
+    preFilterCutoffHz: Double = 500.0,
+    enablePreFilter: Boolean = true,
+    private val enableDiagnosticsHandle: Boolean = false,
+    lineRecoveryStrategy: LineRecoveryStrategy = LineRecoveryStrategy.Look4SatLimited
+) {
+    private val scopeBuffer = PixelBuffer(scopeWidth, scopeHeight * 2)
+    private val imageBuffer = PixelBuffer(scopeWidth, scopeHeight)
+    private val decoder = DecoderEngine(scopeBuffer, imageBuffer, "Raw", sampleRate, lineRecoveryStrategy)
+    private val _frames = MutableSharedFlow<SstvFrame>(
+        replay = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
+    )
+    private var lastInputRms = 0f
+    private var lastAppliedGain = 1f
+    private val _qualityMetrics = MutableStateFlow<SstvQualityMetrics?>(null)
+    private val preFilter = if (enablePreFilter) HighPassFilter(preFilterCutoffHz, sampleRate.toDouble()) else null
+    private val diagnosticsHandle = SstvDiagnosticsHandle(enableDiagnosticsHandle, _qualityMetrics)
+    val frames: SharedFlow<SstvFrame> = _frames
+    val supportedModes: List<String> = decoder.allModes.map { it.name }
+
+    suspend fun feedSamples(samples: FloatArray) = withContext(Dispatchers.Default) {
+        // Optional pre-filtering: remove DC offset and subsonic noise that can mask
+        // weak signals and corrupt the RMS normalization baseline.
+        preFilter?.apply(samples)
+
+        // Optional RMS normalization: bring input to a consistent level so the
+        // FM demodulator operates in a predictable region. However, this amplifies
+        // noise proportionally. Aggressive RMS targets (e.g., 0.25) can hurt weak
+        // signals by boosting noise floor. Safer defaults: 0.35-0.50 for noisy inputs.
+        // Disable entirely for direct line-level inputs (e.g., receiver discriminator).
+        val gain = if (enableRmsNormalization) normalise(samples) else GainInfo(0f, 1f)
+        lastInputRms = gain.inputRms
+        lastAppliedGain = gain.appliedGain
+        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)
+        decoder.resetQuality()
+        if (enableDiagnosticsHandle) _qualityMetrics.value = null
+    }
+
+    fun getDiagnosticsHandle(): SstvDiagnosticsHandle? = diagnosticsHandle.takeIf { it.enabled }
+
+    /**
+     * Export quality metrics for logging/diagnostics. Useful for profiling decode
+     * performance on noisy recordings. Returns null before first frame is emitted.
+     */
+    @Suppress("unused")
+    fun getQualityMetrics(): SstvQualityMetrics? {
+        if (enableDiagnosticsHandle) return _qualityMetrics.value
+        val q = decoder.quality()
+        return SstvQualityMetrics(
+            syncHitRate = q.syncHitRate,
+            predictedLineBursts = q.predictedLineBursts,
+            maxPredictedStreak = q.maxPredictedStreak,
+            timingErrorSamples = q.timingErrorSamples
+        )
+    }
+
+    private fun emitFrame() {
+        val imageWidth = imageBuffer.width
+        val imageHeight = imageBuffer.height
+        val quality = decoder.quality()
+        if (enableDiagnosticsHandle) {
+            _qualityMetrics.value = SstvQualityMetrics(
+                syncHitRate = quality.syncHitRate,
+                predictedLineBursts = quality.predictedLineBursts,
+                maxPredictedStreak = quality.maxPredictedStreak,
+                timingErrorSamples = quality.timingErrorSamples
+            )
+        }
+        val imageComplete = imageBuffer.line >= imageHeight && imageBuffer.line > 0
+        // 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
+        val scopePixels = if (includeScopeData) scopeBuffer.pixels.copyOf() else null
+        val scopeWidth = if (includeScopeData) scopeBuffer.width else 0
+        val scopeHeight = if (includeScopeData) scopeBuffer.height else 0
+        _frames.tryEmit(
+            SstvFrame(
+                scopePixels = scopePixels,
+                scopeWidth = scopeWidth,
+                scopeHeight = scopeHeight,
+                imagePixels = imagePixels,
+                imageWidth = imageWidth,
+                imageHeight = imageHeight,
+                modeName = modeName,
+                imageComplete = imageComplete,
+                inputRms = lastInputRms,
+                appliedGain = lastAppliedGain,
+                syncHitRate = quality.syncHitRate,
+                predictedLineBursts = quality.predictedLineBursts,
+                maxPredictedStreak = quality.maxPredictedStreak,
+                timingErrorSamples = quality.timingErrorSamples
+            )
+        )
+    }
+
+    // Target RMS level for the normalizer. 0.25 leaves headroom while keeping the
+    // FM demodulator well above its noise floor regardless of input gain.
+    // TUNING GUIDE:
+    //   - 0.20-0.25: Aggressive, best for clean direct-coupled inputs, worst for mic noise
+    //   - 0.35-0.40: Moderate, good balance for typical phone/mic inputs (RECOMMENDED)
+    //   - 0.50-0.60: Conservative, best for noisy environments, reduces amplitude resolution
+    // Disable RMS normalization entirely if using a professional receiver discriminator output.
+    private val targetRms = targetRmsLevel.coerceIn(0.05f, 0.8f)
+
+    private class GainInfo(
+        val inputRms: Float,
+        val appliedGain: Float
+    )
+
+    // 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): GainInfo {
+        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
+            return GainInfo(rms, gain)
+        }
+        return GainInfo(rms, 1f)
+    }
+}
+
+/**
+ * Simple high-pass filter to remove DC offset and subsonic interference before RMS
+ * normalization. Improves noise floor estimation and prevents low-freq noise from
+ * corrupting the gain calculation.
+ *
+ * Design: First-order butterworth (pole at cutoff frequency). Fast, minimal latency,
+ * suitable for real-time preprocessing.
+ */
+internal class HighPassFilter(cutoffHz: Double, sampleRateHz: Double) {
+    private val alpha: Float
+    private var prevInput = 0f
+    private var prevOutput = 0f
+
+    init {
+        // First-order pole placement: alpha = wc / (wc + ws) where wc = 2*pi*fc, ws = 2*pi*fs
+        val omega = 2f * PI.toFloat() * (cutoffHz / sampleRateHz).toFloat()
+        alpha = omega / (omega + 1f)
+    }
+
+    fun apply(buffer: FloatArray) {
+        for (i in buffer.indices) {
+            val input = buffer[i]
+            prevOutput = alpha * (prevOutput + input - prevInput)
+            buffer[i] = prevOutput
+            prevInput = input
+        }
+    }
+}
+
+internal class DecoderQuality(
+    val syncHitRate: Float,
+    val predictedLineBursts: Int,
+    val maxPredictedStreak: Int,
+    val timingErrorSamples: Int
+)
+
+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,
+    lineRecoveryStrategy: LineRecoveryStrategy
+) {
+    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
+    private var syncChecks = 0
+    private var syncHits = 0
+    private var predictedLineBursts = 0
+    private var predictedStreak = 0
+    private var maxPredictedStreak = 0
+    private var timingErrorSamples = 0
+
+    // Look4Sat strategy limits synthetic lines to avoid visible vertical collapse.
+    // Robot36 strategy preserves legacy behavior by allowing unlimited synthesis.
+    private val maxConsecutivePredictedLines = when (lineRecoveryStrategy) {
+        LineRecoveryStrategy.Look4SatLimited -> 2
+        LineRecoveryStrategy.Robot36Compatible -> Int.MAX_VALUE
+    }
+
+    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)
+        syncChecks++
+        if (detected) {
+            syncHits++
+            predictedStreak = 0
+        }
+        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()) {
+            predictedStreak = 0
+            newLines = true
+        } else if (sample > lastSync + (curLineSamples * 5) / 4) {
+            newLines = decodePredictedLine()
+        }
+        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
+    }
+
+    fun quality(): DecoderQuality {
+        val hitRate = if (syncChecks > 0) syncHits.toFloat() / syncChecks else 0f
+        return DecoderQuality(
+            syncHitRate = hitRate,
+            predictedLineBursts = predictedLineBursts,
+            maxPredictedStreak = maxPredictedStreak,
+            timingErrorSamples = timingErrorSamples
+        )
+    }
+
+    fun resetQuality() {
+        syncChecks = 0
+        syncHits = 0
+        predictedLineBursts = 0
+        predictedStreak = 0
+        maxPredictedStreak = 0
+        timingErrorSamples = 0
+    }
+
+    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 decodePredictedLine(): Boolean {
+        // Avoid long streaks of synthetic lines; once we exceed the cap we wait for
+        // real sync to reduce visible vertical compression on weak/noisy signals.
+        if (predictedStreak >= maxConsecutivePredictedLines) return false
+        val expectedSync = lastSync + curLineSamples
+        timingErrorSamples = sample - expectedSync
+        val decoded = currentMode.decodeScanLine(
+            pixelBuffer,
+            scratch,
+            scanLineBuffer,
+            scopeBuffer.width,
+            lastSync,
+            curLineSamples,
+            lastOffset
+        )
+        copyLines(decoded)
+        lastSync = expectedSync
+        predictedLineBursts++
+        predictedStreak++
+        if (predictedStreak > maxPredictedStreak) maxPredictedStreak = predictedStreak
+        return decoded
+    }
+
+    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 {
+        predictedStreak = 0
+        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

@@ -58,8 +58,6 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
         }.getOrDefault(emptyList())
     }
 
-    fun isLeapYear(year: Int): Boolean = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
-
     private fun parseCSV(values: List<String>): OrbitalData? = runCatching {
         val name = values[0]
         val timestamp = values[2]
@@ -84,7 +82,8 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
             argper = values[7].toDouble(),
             meanan = values[8].toDouble(),
             catnum = values[11].toInt(),
-            bstar = values[14].toDouble()
+            bstar = values[14].toDouble(),
+            ndot = values[15].toDouble()
         )
     }.onFailure { println("CSV parsing exception: $it") }.getOrNull()
 
@@ -92,7 +91,7 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
         val line1 = tle[1]
         val line2 = tle[2]
         OrbitalData(
-            name = tle[0].trim(),
+            name = tle[0].trim().removePrefix("0 "),
             epoch = line1.substring(18, 32).toDouble(),
             meanmo = line2.substring(52, 63).toDouble(),
             eccn = line2.substring(26, 33).toDouble() / 1e7,
@@ -101,11 +100,14 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
             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())
+            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 getDayOfYear(year: Int, month: Int, dayOfMonth: Int): Int {
+    fun isLeapYear(year: Int): Boolean = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
+
+    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/DopplerFrequencyCalculator.kt

@@ -0,0 +1,122 @@
+/*
+ * 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.
+ */
+package com.rtbishop.look4sat.core.domain.utility
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import java.util.Locale
+
+/**
+ * Computes Doppler-corrected reciprocal frequencies for linear transponders.
+ *
+ * For a linear (passband) transponder, uplink and downlink frequencies are
+ * related by a fixed passband offset. When the satellite moves, both are
+ * Doppler-shifted. Given one, this computes the other:
+ *
+ *   downlink → uplink: mapDownlinkToUplink (passband) → getUplinkFreq (Doppler)
+ *   uplink → downlink: mapUplinkToDownlink (passband) → getDownlinkFreq (Doppler)
+ */
+object DopplerFrequencyCalculator {
+
+    /**
+     * Given a downlink frequency, compute the Doppler-corrected uplink frequency.
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeUplinkFromDownlink(
+        downlinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz, transponder) ?: return null
+        return orbitalPos.getUplinkFreq(baseUplink)
+    }
+
+    /**
+     * Given a downlink frequency, compute the Doppler-corrected uplink frequency
+     * with an offset applied to the downlink (in Hz).
+     * Returns null if the transponder is not a linear passband type.
+     *
+     * The user-entered downlink frequency already includes the offset, so subtract
+     * it before mapping the downlink passband position back to the uplink.
+     */
+    fun computeUplinkFromDownlinkWithOffset(
+        downlinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos,
+        offsetHz: Long
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz - offsetHz, transponder) ?: return null
+        return orbitalPos.getUplinkFreq(baseUplink)
+    }
+
+    /**
+     * Given an uplink frequency, compute the Doppler-corrected downlink frequency.
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeDownlinkFromUplink(
+        uplinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
+        return orbitalPos.getDownlinkFreq(baseDownlink)
+    }
+
+    /**
+     * Given an uplink frequency, compute the Doppler-corrected downlink frequency
+     * with an offset applied to the downlink (in Hz).
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeDownlinkFromUplinkWithOffset(
+        uplinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos,
+        offsetHz: Long
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
+        return orbitalPos.getDownlinkFreq(baseDownlink + offsetHz)
+    }
+
+    /** True if this transponder supports linear passband mapping. */
+    fun isLinearTransponder(transponder: SatRadio): Boolean {
+        val upLow = transponder.uplinkLow
+        val upHigh = transponder.uplinkHigh
+        val downLow = transponder.downlinkLow
+        val downHigh = transponder.downlinkHigh
+        return upLow != null && upHigh != null && downLow != null && downHigh != null
+                && upLow != upHigh && downLow != downHigh
+    }
+
+    /**
+     * True for the radio entry that should drive the standalone Calculator page.
+     *
+     * A frequency range alone is not enough: some non-user-facing or drifting data entries
+     * can also have low/high frequencies. The calculator is meant for named linear
+     * transponders, e.g. "Linear Transponder", "Linear Transp.", "SSB Transponder".
+     */
+    fun isNamedLinearTransponder(transponder: SatRadio): Boolean {
+        if (!isLinearTransponder(transponder)) return false
+
+        val info = transponder.info.lowercase(Locale.ENGLISH)
+        val modes = listOfNotNull(transponder.downlinkMode, transponder.uplinkMode)
+            .joinToString(separator = " ")
+            .lowercase(Locale.ENGLISH)
+        val hasLinearName = info.contains("linear")
+        val hasTransponderName = info.contains("transponder") || info.contains("transp") ||
+                info.contains("xponder") || info.contains("xpdr")
+        val hasLinearMode = listOf("ssb", "usb", "lsb", "cw").any { modes.contains(it) }
+
+        return (hasLinearName && hasTransponderName) || (hasTransponderName && hasLinearMode)
+    }
+}

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/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/DopplerFrequencyCalculatorTest.kt

@@ -0,0 +1,190 @@
+package com.rtbishop.look4sat.core.domain
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DopplerFrequencyCalculatorTest {
+
+    private fun linearTransponder(
+        upLow: Long = 145_000_000L,
+        upHigh: Long = 145_500_000L,
+        downLow: Long = 435_000_000L,
+        downHigh: Long? = 435_500_000L,
+        inverted: Boolean = false,
+        info: String = "Linear Transponder",
+        downlinkMode: String? = "USB",
+        uplinkMode: String? = "LSB"
+    ) = SatRadio(
+        uuid = "linear", info = info, isAlive = true,
+        downlinkLow = downLow, downlinkHigh = downHigh,
+        downlinkMode = downlinkMode, uplinkLow = upLow, uplinkHigh = upHigh,
+        uplinkMode = uplinkMode, isInverted = inverted, catnum = 12345
+    )
+
+    private fun fmTransponder() = SatRadio(
+        uuid = "fm", info = "FM Repeater", isAlive = true,
+        downlinkLow = 435_600_000L, downlinkHigh = null,
+        downlinkMode = "FM", uplinkLow = 145_900_000L, uplinkHigh = null,
+        uplinkMode = "FM", isInverted = false, catnum = 99999
+    )
+
+    private fun pos(distanceRateKmS: Double = 0.0) = OrbitalPos().apply {
+        this.distanceRate = distanceRateKmS
+    }
+
+    @Test
+    fun isLinearTransponder_returnsTrueForLinear() {
+        assertTrue(DopplerFrequencyCalculator.isLinearTransponder(linearTransponder()))
+    }
+
+    @Test
+    fun isLinearTransponder_returnsFalseForFM() {
+        assertFalse(DopplerFrequencyCalculator.isLinearTransponder(fmTransponder()))
+    }
+
+    @Test
+    fun isLinearTransponder_returnsFalseForNullDownlinkHigh() {
+        val xpdr = linearTransponder(downHigh = null)
+        assertFalse(DopplerFrequencyCalculator.isLinearTransponder(xpdr))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsTrueForLinearTransponderName() {
+        assertTrue(DopplerFrequencyCalculator.isNamedLinearTransponder(linearTransponder()))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsTrueForSsbTransponderName() {
+        val xpdr = linearTransponder(info = "Mode V/U SSB Transponder", downlinkMode = "USB", uplinkMode = "LSB")
+        assertTrue(DopplerFrequencyCalculator.isNamedLinearTransponder(xpdr))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsFalseForRangeEntryWithoutTransponderName() {
+        val driftingRangeEntry = linearTransponder(info = "Upper side band (drifting)")
+        assertFalse(DopplerFrequencyCalculator.isNamedLinearTransponder(driftingRangeEntry))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsFalseForFmRepeater() {
+        assertFalse(DopplerFrequencyCalculator.isNamedLinearTransponder(fmTransponder()))
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_linear_noDoppler() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        assertEquals(145_200_000L, uplink)
+    }
+
+    @Test
+    fun computeDownlinkFromUplink_linear_noDoppler() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val downlink = DopplerFrequencyCalculator.computeDownlinkFromUplink(145_200_000L, xpdr, orbitalPos)
+        assertNotNull(downlink)
+        assertEquals(435_200_000L, downlink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_withDoppler_positiveRangeRate() {
+        // Satellite receding (positive range rate) → ground must transmit higher freq to compensate.
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(7.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        assertTrue(uplink!! > 145_200_000L)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_fmTransponder_returnsNull() {
+        val orbitalPos = pos()
+        val result = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_600_000L, fmTransponder(), orbitalPos)
+        assertNull(result)
+    }
+
+    @Test
+    fun computeDownlinkFromUplink_fmTransponder_returnsNull() {
+        val orbitalPos = pos()
+        val result = DopplerFrequencyCalculator.computeDownlinkFromUplink(145_900_000L, fmTransponder(), orbitalPos)
+        assertNull(result)
+    }
+
+    @Test
+    fun computeDownlinkFromUplink_withPositiveOffset_addsOffsetToDownlink() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val downlink = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+            uplinkHz = 145_200_000L,
+            transponder = xpdr,
+            orbitalPos = orbitalPos,
+            offsetHz = 2_500L
+        )
+        assertEquals(435_202_500L, downlink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_withPositiveOffset_subtractsOffsetBeforeMapping() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+            downlinkHz = 435_202_500L,
+            transponder = xpdr,
+            orbitalPos = orbitalPos,
+            offsetHz = 2_500L
+        )
+        assertEquals(145_200_000L, uplink)
+    }
+
+    @Test
+    fun computeOffsetRoundTrip_handlesNegativeOffset() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val downlink = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+            uplinkHz = 145_200_000L,
+            transponder = xpdr,
+            orbitalPos = orbitalPos,
+            offsetHz = -2_500L
+        )
+        assertEquals(435_197_500L, downlink)
+
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+            downlinkHz = downlink!!,
+            transponder = xpdr,
+            orbitalPos = orbitalPos,
+            offsetHz = -2_500L
+        )
+        assertEquals(145_200_000L, uplink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_invertedTransponder() {
+        val xpdr = linearTransponder(inverted = true, downHigh = 435_500_000L)
+        val orbitalPos = pos(0.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        assertEquals(145_300_000L, uplink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_roundTrip() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(3.5)
+        val originalDownlink = 435_250_000L
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(originalDownlink, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        val roundTripDownlink = DopplerFrequencyCalculator.computeDownlinkFromUplink(uplink!!, xpdr, orbitalPos)
+        assertNotNull(roundTripDownlink)
+        val error = kotlin.math.abs(roundTripDownlink!! - originalDownlink)
+        assertTrue("Round-trip error too large: $error", error < 10000)
+    }
+}

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

@@ -34,29 +34,51 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ElevatedButton
 import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
+import androidx.compose.material3.LocalTextStyle
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.SheetValue
+import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 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.Dp
+import androidx.compose.ui.unit.TextUnit
+import androidx.compose.ui.unit.Velocity
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import androidx.compose.ui.window.Dialog
 import com.rtbishop.look4sat.core.domain.predict.NearEarthObject
 import com.rtbishop.look4sat.core.domain.predict.OrbitalData
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
@@ -123,7 +145,7 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
         if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
     }
     val sdfTime = remember(isUtc) {
-        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", displayLocale()).also { it.timeZone = timeZone }
     }
     ElevatedCard(
         modifier = modifier
@@ -151,16 +173,17 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis
                 )
+                val elevColor = elevationColor(pass.maxElevation)
                 Icon(
                     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(
@@ -178,12 +201,6 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
                     horizontalArrangement = Arrangement.Center,
                     verticalAlignment = Alignment.CenterVertically
                 ) {
-                    Icon(
-                        painter = painterResource(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)
                 }
                 Text(
@@ -197,6 +214,11 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
     }
 }
 
+private fun displayLocale(): Locale {
+    val locale = Locale.getDefault()
+    return if (locale.language == Locale.CHINESE.language) locale else Locale.ENGLISH
+}
+
 @Composable
 fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier) {
     ElevatedButton(
@@ -212,14 +234,11 @@ fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier)
 }
 
 @Composable
-fun IconCard(action: () -> Unit, resId: Int, modifier: Modifier = Modifier) {
-    ElevatedCard(modifier = Modifier.size(48.dp)) {
-        Box(
-            modifier = Modifier
-                .clickable(onClick = action)
-                .fillMaxSize(),
-            contentAlignment = Alignment.Center
-        ) { Icon(painter = painterResource(resId), contentDescription = null, modifier = modifier) }
+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)
+        }
     }
 }
 
@@ -275,55 +294,92 @@ fun getDefaultPass(): OrbitalPass = OrbitalPass(
 fun SharedDialog(
     title: String, onCancel: () -> Unit, onAccept: () -> Unit, content: @Composable () -> Unit
 ) {
-    DialogShell(title = title, titleFontSize = 16, onDismissRequest = onCancel) {
+    SharedDialog(title = title, onDismissRequest = onCancel, onCancel = onCancel, onAccept = onAccept) { _ ->
         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))
+fun SharedDialog(
+    title: String,
+    onDismissRequest: () -> Unit,
+    onCancel: (() -> Unit)? = null,
+    onAccept: (() -> Unit)? = null,
+    titleFontSize: Int = 16,
+    titleTextAlign: TextAlign = if (onCancel != null && onAccept != null) TextAlign.Center else TextAlign.Start,
+    content: @Composable (padding: Dp) -> Unit
+) {
+    val dismissible = onCancel != null
+    DialogShell(onDismissRequest = onDismissRequest, dismissible = dismissible) { padding ->
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(start = padding, top = padding, end = padding)
+        ) {
+            if (onCancel != null) {
+                CardButton(onClick = onCancel, text = stringResource(R.string.btn_cancel))
+            }
+            Text(
+                text = title,
+                fontSize = titleFontSize.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary,
+                textAlign = titleTextAlign,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(horizontal = if (onCancel != null && onAccept != null) padding else 0.dp)
+            )
+            if (onAccept != null) {
+                CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
+            }
         }
+        content(padding)
     }
 }
 
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun DialogShell(
-    title: String,
-    titleFontSize: Int,
     onDismissRequest: () -> Unit,
-    content: @Composable (padding: androidx.compose.ui.unit.Dp) -> Unit
+    dismissible: Boolean = true,
+    content: @Composable (padding: Dp) -> Unit
 ) {
     val padding = LocalSpacing.current.large
-    Dialog(onDismissRequest = onDismissRequest) {
-        ElevatedCard {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.spacedBy(padding)
-            ) {
-                Text(
-                    text = title,
-                    fontSize = titleFontSize.sp,
-                    fontWeight = FontWeight.Medium,
-                    color = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.padding(start = padding, top = padding, end = padding)
-                )
-                content(padding)
+    val sheetState = rememberModalBottomSheetState(
+        skipPartiallyExpanded = true,
+        confirmValueChange = { if (dismissible) true else it != SheetValue.Hidden }
+    )
+    val stopSheetFling = remember {
+        object : NestedScrollConnection {
+            override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
+                return available
             }
+
+            override fun onPostScroll(
+                consumed: Offset,
+                available: Offset,
+                source: NestedScrollSource
+            ): Offset = Offset.Zero
+        }
+    }
+    ModalBottomSheet(
+        onDismissRequest = if (dismissible) onDismissRequest else { {} },
+        sheetState = sheetState,
+        dragHandle = null,
+        shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
+        scrimColor = Color.Black.copy(alpha = 0.64f)
+    ) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(padding),
+            modifier = Modifier
+                .fillMaxWidth()
+                .nestedScroll(stopSheetFling)
+        ) {
+            content(padding)
         }
     }
 }
@@ -385,3 +441,98 @@ fun TopBar(
         TopBar { startAction(); topInfo(); bottomInfo(); endAction() }
     }
 }
+
+@Composable
+fun elevationColor(elevation: Double): Color {
+    val thresholds = LocalElevationThresholds.current
+    return when {
+        elevation < thresholds.low -> ElevationLowColor // soft red for low elevation
+        elevation < thresholds.high -> MaterialTheme.colorScheme.primary // accent yellow for normal
+        else -> ElevationHighColor // soft green for high elevation
+    }
+}
+
+/** User-configurable elevation highlight thresholds (in degrees). */
+data class ElevationThresholds(val low: Double = 15.0, val high: Double = 45.0)
+
+/** Provided at the app root from settings; defaults keep the original 15°/45° behavior. */
+val LocalElevationThresholds = compositionLocalOf { ElevationThresholds() }
+
+/** Soft red used for elevations below the low threshold. */
+val ElevationLowColor = Color(0xFFEF5350)
+
+/** Soft green used for elevations above the high threshold. */
+val ElevationHighColor = Color(0xFF66BB6A)
+
+@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

@@ -30,10 +30,7 @@ sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
     data object Passes : Screen(R.drawable.ic_passes, R.string.nav_pass)
 
     @Serializable
-    data class Radar(val catNum: Int = 0, val aosTime: Long = 0L) : Screen(R.drawable.ic_radar, R.string.nav_radar)
-
-    @Serializable
-    data class RadioControl(val catNum: Int = 0, val aosTime: Long = 0L) : Screen(0, 0)
+    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)
@@ -41,3 +38,33 @@ sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
     @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_like.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="15"
+    android:viewportHeight="15">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M13.91,6.75c-1.17,2.25 -4.3,5.31 -6.07,6.94c-0.19,0.172 -0.48,0.172 -0.67,0C5.39,12.06 2.26,9 1.09,6.75C-1.48,1.8 5,-1.5 7.5,3.45C10,-1.5 16.48,1.8 13.91,6.75z" />
+</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_pound.xml

@@ -1,9 +0,0 @@
-<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="M14,21c1.93,0 3.62,-1.17 4,-3l-1.75,-0.88C16,18.21 15.33,19 14,19l-4.9,0c0.83,-1 1.5,-2.34 1.5,-4c0,-0.35 -0.03,-0.69 -0.08,-1L14,14v-2l-4.18,0C9,10.42 8,9.6 8,8c0,-1.93 1.57,-3.5 3.5,-3.5c1.5,0 2.79,0.95 3.28,2.28L16.63,6c-0.8,-2.05 -2.79,-3.5 -5.13,-3.5C8.46,2.5 6,4.96 6,8c0,1.78 0.79,2.9 1.49,4L6,12v2l2.47,0c0.08,0.31 0.13,0.64 0.13,1c0,2.7 -2.6,4 -2.6,4v2H14z" />
-</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/drawable/ic_tags.xml

@@ -1,9 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="960"
-    android:viewportHeight="960">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M240,800L280,640L120,640L140,560L300,560L340,400L180,400L200,320L360,320L400,160L480,160L440,320L600,320L640,160L720,160L680,320L840,320L820,400L660,400L620,560L780,560L760,640L600,640L560,800L480,800L520,640L360,640L320,800L240,800ZM380,560L540,560L580,400L420,400L380,560Z" />
-</vector>

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

@@ -13,12 +13,16 @@
     <string name="nav_prefs">Ajustes</string>
 
     <!-- Satellites screen -->
-    <string name="sat_type_hint">Tipo: %s</string>
-    <string name="sat_type_title">Seleccionar tipo de satélite</string>
+    <string name="sat_type_hint">Modos: %s</string>
+    <string name="sat_type_title">Seleccionar modos</string>
     <string name="sat_search_hint">Id - Nombre</string>
     <string name="sat_search_clear">Vaciar</string>
     <string name="sat_clear_all">Vaciar todo</string>
     <string name="sat_select_all">Seleccionar todo</string>
+    <string name="sat_group_selected">Seleccionados</string>
+    <string name="sat_group_available">Disponibles</string>
+    <string name="sat_group_selected_count">Seleccionados (%1$d)</string>
+    <string name="sat_group_available_count">Disponibles (%1$d)</string>
     <string name="sat_empty_list_message">
         Asegúrese de que su consulta de búsqueda sea correcta y que la base de datos esté actualizada</string>
     <string name="sat_warning_title">Alarma\!</string>
@@ -26,13 +30,16 @@
         Esta aplicación incluye más de 9000 satélites.
         No tiene sentido rastrearlos todos a la vez.
         \n\nIntenta siempre limitar la lista a los que te
-        interesen mediante la búsqueda y el selector de tipos.</string>
+        interesen mediante la búsqueda y el selector de modos.</string>
 
     <!-- Passes screen -->
     <string name="pass_filter_title">Filtrar pases</string>
     <string name="pass_filter_elev">Elevación mínima</string>
-    <string name="pass_filter_hours">Horas por delante</string>
-    <string name="pass_modes_title">Tipo de modulación</string>
+    <string name="pass_filter_hours">Tiempo por delante</string>
+    <string name="pass_filter_aos_time">Ventana AOS</string>
+    <string name="pass_filter_invert_time">Invertir ventana AOS</string>
+    <string name="pass_filter_deep_space">DeepSpace (período &gt;225min)</string>
+    <string name="pass_modes_title">Seleccionar modos</string>
     <string name="pass_elevation">Elevación: %.1f°</string>
     <string name="pass_altitude">Altitud: %.0f km</string>
     <string name="pass_empty_list_message">
@@ -93,11 +100,11 @@
     <string name="prefs_loc_qth_title">QTH</string>
     <string name="prefs_loc_qth_error">Ubicación QTH no válida</string>
     <string name="prefs_loc_success">Ubicación actualizada con éxito</string>
-    <string name="prefs_station_title">Ajustar ubicaicón de la estación</string>
-    <string name="prefs_station_lat_text">Latitud de tu estación terrestre</string>
-    <string name="prefs_station_lon_text">Longitud de tu estación terrestre</string>
-    <string name="prefs_locator_title">Ajustes ubicación QTH</string>
-    <string name="prefs_locator_text">Ajustar posición de la estación con tu ubicación</string>
+    <string name="prefs_station_title">Ubicación de la estación</string>
+    <string name="prefs_station_lat_text">Latitud de estación</string>
+    <string name="prefs_station_lon_text">Longitud de estación</string>
+    <string name="prefs_locator_title">Localizador QTH</string>
+    <string name="prefs_locator_text">Posición por localizador</string>
 
     <string name="prefs_data_title">Datos satelitales</string>
     <string name="prefs_data_entries">Satélites: %s</string>
@@ -107,37 +114,57 @@
     <string name="prefs_data_clear">Vaciar</string>
     <string name="prefs_data_clear_success">Datos eliminados con éxito</string>
     <string name="prefs_data_update_success">Actualización completada con éxito</string>
+    <string name="prefs_data_import_satellites_error">No se importaron satélites. Usa un TLE/3LE (.txt) u OMM (.csv) válido.</string>
+    <string name="prefs_data_import_transceivers_error">No se importaron transceptores. Usa un SatNOGS (.json) válido.</string>
 
-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">Fuentes personalizadas</string>
+    <string name="prefs_data_sources_tle_switch">URL TLE</string>
+    <string name="prefs_data_sources_transceivers_switch">URL transceptores</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
 
-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
+    <string name="prefs_data_output_title">Salida de datos</string>
+    <string name="prefs_net_output">Red</string>
     <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>
 
-    <string name="prefs_net_title">Salida de datos de red</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
+    <string name="nav_radiocontrol">Control de radio</string>
+    <string name="rc_settings_title">Control CAT</string>
+    <string name="rc_radio_model">Modelo de radio</string>
+    <string name="rc_tx_device_hint">Dirección BT TX</string>
+    <string name="rc_rx_device_hint">Dirección BT RX</string>
+    <string name="rc_tx_name_hint">Nombre radio TX</string>
+    <string name="rc_rx_name_hint">Nombre radio RX</string>
+    <string name="rc_enable_switch">Activar CAT</string>
+
+    <string name="prefs_net_title">Salida de red</string>
+    <string name="prefs_net_rotator_switch">Activar salida de rotación</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_switch">Activar salida de frecuencia</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>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Id dispositivo</string>
-    <string name="prefs_bt_rotator_output_hint">Formato de datos</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <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_title">Salida Bluetooth</string>
+    <string name="prefs_bt_rotator_switch">Activar salida de rotación</string>
+    <string name="prefs_bt_rotator_device_hint">ID dispositivo</string>
+    <string name="prefs_bt_rotator_output_hint">Formato</string>
+    <string name="prefs_bt_frequency_switch">Activar salida de frecuencia</string>
+    <string name="prefs_bt_frequency_device_hint">ID dispositivo</string>
+    <string name="prefs_bt_frequency_output_hint">Formato</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>
-    <string name="prefs_other_switch_update">Habilitar auto actualización de datos</string>
-    <string name="prefs_other_switch_sweep">Habilitar animaciones radar</string>
-    <string name="prefs_other_switch_sensors">Usar sensores para rotar vista de radar</string>
+    <string name="prefs_other_title">Otros</string>
+    <string name="prefs_other_switch_utc">Hora UTC</string>
+    <string name="prefs_other_switch_update">Actualización automática</string>
+    <string name="prefs_other_switch_sweep">Animación radar</string>
+    <string name="prefs_other_switch_sensors">Sensores</string>
+    <string name="prefs_other_switch_night_mode">Filtro nocturno</string>
+
+    <string name="prefs_highlight_title">Resaltado de elevación</string>
+    <string name="prefs_highlight_low">Baja &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">Media %1$d-%2$d°</string>
+    <string name="prefs_highlight_high">Alta &gt; %1$d°</string>
 
     <string name="prefs_outro_title">Me gustaría dar las gracias a:</string>
     <string name="prefs_outro_license">La app viene sin garantías de ningún tipo.</string>

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

@@ -13,25 +13,32 @@
     <string name="nav_prefs">Настройки</string>
 
     <!-- Satellites screen -->
-    <string name="sat_type_hint">Тип: %s</string>
-    <string name="sat_type_title">Выберите тип спутника</string>
+    <string name="sat_type_hint">Режимы: %s</string>
+    <string name="sat_type_title">Выберите режимы</string>
     <string name="sat_search_hint">Id - Название</string>
     <string name="sat_search_clear">Очистить</string>
     <string name="sat_clear_all">Очистить</string>
     <string name="sat_select_all">Выбрать</string>
+    <string name="sat_group_selected">Выбранные</string>
+    <string name="sat_group_available">Доступные</string>
+    <string name="sat_group_selected_count">Выбранные (%1$d)</string>
+    <string name="sat_group_available_count">Доступные (%1$d)</string>
     <string name="sat_empty_list_message">Убедитесь, что ваш поисковый запрос верен и база данных обновлена</string>
     <string name="sat_warning_title">Внимание\!</string>
     <string name="sat_warning_message">
         В этом приложении перечислено более 9000 спутников.
         Отслеживать их все одновременно бессмысленно.
         \n\nВсегда старайтесь сузить список до тех,
-        которые вас интересуют, используя поиск и селектор типов.</string>
+        которые вас интересуют, используя поиск и выбор режимов.</string>
 
     <!-- Passes screen -->
     <string name="pass_filter_title">Фильтровать пролеты</string>
     <string name="pass_filter_elev">Минимальная элевация</string>
-    <string name="pass_filter_hours">Количество часов</string>
-    <string name="pass_modes_title">Выберите тип модуляции</string>
+    <string name="pass_filter_hours">Период расчёта</string>
+    <string name="pass_filter_aos_time">Окно AOS</string>
+    <string name="pass_filter_invert_time">Инвертировать окно AOS</string>
+    <string name="pass_filter_deep_space">DeepSpace (период &gt;225мин)</string>
+    <string name="pass_modes_title">Выберите режимы</string>
     <string name="pass_elevation">Элевация: %.1f°</string>
     <string name="pass_altitude">Высота: %d км</string>
     <string name="pass_empty_list_message">
@@ -92,11 +99,11 @@
     <string name="prefs_loc_qth_title">QTH</string>
     <string name="prefs_loc_qth_error">Неправильный локатор QTH</string>
     <string name="prefs_loc_success">Позиция успешно обновлена</string>
-    <string name="prefs_station_title">Настройки местоположения</string>
-    <string name="prefs_station_lat_text">Введите широту наземной станции</string>
-    <string name="prefs_station_lon_text">Введите долготу наземной станции</string>
-    <string name="prefs_locator_title">Настройки локатора QTH</string>
-    <string name="prefs_locator_text">Введите позицию через локатор</string>
+    <string name="prefs_station_title">Положение станции</string>
+    <string name="prefs_station_lat_text">Широта станции</string>
+    <string name="prefs_station_lon_text">Долгота станции</string>
+    <string name="prefs_locator_title">Локатор QTH</string>
+    <string name="prefs_locator_text">Позиция по локатору</string>
 
     <string name="prefs_data_title">Данные спутников</string>
     <string name="prefs_data_entries">Спутников: %s</string>
@@ -106,16 +113,30 @@
     <string name="prefs_data_clear">Очистить</string>
     <string name="prefs_data_clear_success">Очистка прошла успешно</string>
     <string name="prefs_data_update_success">Обновление прошло успешно</string>
+    <string name="prefs_data_import_satellites_error">Спутники не импортированы. Нужен TLE/3LE (.txt) или OMM (.csv).</string>
+    <string name="prefs_data_import_transceivers_error">Трансиверы не импортированы. Нужен SatNOGS (.json).</string>
 
-    <string name="prefs_data_sources_title">Свои источники данных</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom Transceivers URL</string>
+    <string name="prefs_data_sources_title">Свои источники</string>
+    <string name="prefs_data_sources_tle_switch">URL TLE</string>
+    <string name="prefs_data_sources_transceivers_switch">URL трансиверов</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
 
-    <string name="prefs_data_output_title">Вывод данных</string>
+    <string name="prefs_data_output_title">Вывод</string>
     <string name="prefs_net_output">Сеть</string>
     <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>
 
-    <string name="prefs_net_title">Вывод сетевых данных</string>
+    <string name="nav_radiocontrol">Управление радио</string>
+
+    <string name="rc_settings_title">CAT управление</string>
+    <string name="rc_radio_model">Модель радио</string>
+    <string name="rc_tx_device_hint">BT адрес TX</string>
+    <string name="rc_rx_device_hint">BT адрес RX</string>
+    <string name="rc_tx_name_hint">Имя радио TX</string>
+    <string name="rc_rx_name_hint">Имя радио RX</string>
+    <string name="rc_enable_switch">Включить CAT</string>
+
+    <string name="prefs_net_title">Сетевой вывод</string>
     <string name="prefs_net_rotator_switch">Включить вывод ротатора</string>
     <string name="prefs_net_rotator_address_hint">IP:Порт</string>
     <string name="prefs_net_rotator_format_hint">Формат</string>
@@ -123,20 +144,27 @@
     <string name="prefs_net_frequency_address_hint">IP:Порт</string>
     <string name="prefs_net_frequency_format_hint">Формат</string>
 
-    <string name="prefs_bt_title">Вывод данных Bluetooth</string>
+    <string name="prefs_bt_title">Вывод Bluetooth</string>
     <string name="prefs_bt_rotator_switch">Включить вывод ротатора</string>
-    <string name="prefs_bt_rotator_device_hint">Id устройства</string>
+    <string name="prefs_bt_rotator_device_hint">ID устройства</string>
     <string name="prefs_bt_rotator_output_hint">Формат</string>
     <string name="prefs_bt_frequency_switch">Включить вывод частоты</string>
-    <string name="prefs_bt_frequency_device_hint">Id устройства</string>
+    <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>
-    <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_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_highlight_title">Подсветка высоты</string>
+    <string name="prefs_highlight_low">Низко &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">Средне %1$d-%2$d°</string>
+    <string name="prefs_highlight_high">Высоко &gt; %1$d°</string>
 
     <string name="prefs_outro_title">Я хотел бы сказать спасибо:</string>
     <string name="prefs_outro_license">Это ПО поставляется без гарантий.</string>

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

@@ -13,26 +13,33 @@
     <string name="nav_prefs">පසුතල</string>
 
     <!-- Satellites screen -->
-    <string name="sat_type_hint">වර්ගය: %s</string>
-    <string name="sat_type_title">චන්ද්‍රිකා ආකාරය තෝරන්න</string>
+    <string name="sat_type_hint">මාදිලි: %s</string>
+    <string name="sat_type_title">මාදිලි තෝරන්න</string>
     <string name="sat_search_hint">Id - නම</string>
     <string name="sat_search_clear">පිරිසිදු ක°</string>
     <string name="sat_clear_all">සියල්ල පිරිසිදු ක°</string>
     <string name="sat_select_all">සියල්ල තෝරන්න</string>
+    <string name="sat_group_selected">තෝරාගත්</string>
+    <string name="sat_group_available">තිබෙන</string>
+    <string name="sat_group_selected_count">තෝරාගත් (%1$d)</string>
+    <string name="sat_group_available_count">තිබෙන (%1$d)</string>
     <string name="sat_empty_list_message">
         ඔබගේ සෙවුම් විමසුම නිවැරදි බවත් දත්ත සමුදාය යාවත්කාලීන කර ඇති බවත් සහතික කර ගන්න</string>
     <string name="sat_warning_title">අවවාදයයි\!</string>
     <string name="sat_warning_message">
         මෙම යෙදුමේ ලැයිස්තුගත කර ඇති චන්ද්‍රිකා 9000 කට වඩා තිබේ.
         ඒවා සියල්ලම එකවර නිරීක්ෂණය කිරීම තේරුමක් නැති දෙයක්.
-        \n\nසෙවීම සහ වර්ග තේරීම හරහා ඔබ උනන්දුවක් දක්වන
+        \n\nසෙවීම සහ මාදිලි තේරීම හරහා ඔබ උනන්දුවක් දක්වන
         ඒවාට පමණක් ලැයිස්තුව පටු කිරීමට සැමවිටම උත්සාහ කරන්න.</string>
 
     <!-- Passes screen -->
     <string name="pass_filter_title">පසුකිරිම් පිරිපහදුව</string>
     <string name="pass_filter_elev">අවම උත්තෝලනය</string>
-    <string name="pass_filter_hours">ඉදිරි පැය</string>
-    <string name="pass_modes_title">මූර්ජන ආකාරය තෝරන්න</string>
+    <string name="pass_filter_hours">ඉදිරි කාලය</string>
+    <string name="pass_filter_aos_time">AOS කවුළුව</string>
+    <string name="pass_filter_invert_time">AOS කවුළුව ප්‍රතිවිරුද්ධ කරන්න</string>
+    <string name="pass_filter_deep_space">DeepSpace (කාලය &gt;225min)</string>
+    <string name="pass_modes_title">මූර්ජන තෝරන්න</string>
     <string name="pass_elevation">උත්තෝලනය: %.1f°</string>
     <string name="pass_altitude">උන්නතාශය: %d km</string>
     <string name="pass_empty_list_message">
@@ -93,11 +100,11 @@
     <string name="prefs_loc_qth_title">QTH</string>
     <string name="prefs_loc_qth_error">QTH locator වලංගු නොවේ</string>
     <string name="prefs_loc_success">පිහිටීම යාවත්කාලීනය සාර්ථකයි</string>
-    <string name="prefs_station_title">පොළෙහි පිහිටීම් පසුතල</string>
-    <string name="prefs_station_lat_text">ඔබගේ පොළෙහි අක්‍ෂාංශය සකසන්න</string>
-    <string name="prefs_station_lon_text">ඔබගේ පොළෙහි දේශාංශය සකසන්න</string>
-    <string name="prefs_locator_title">QTH locator පසුතල</string>
-    <string name="prefs_locator_text"> ඔබගේ locator භාවිතා කර පොළහි පිහිටීම සකසන්න</string>
+    <string name="prefs_station_title">පොළ පිහිටීම</string>
+    <string name="prefs_station_lat_text">පොළ අක්‍ෂාංශය</string>
+    <string name="prefs_station_lon_text">පොළ දේශාංශය</string>
+    <string name="prefs_locator_title">QTH locator</string>
+    <string name="prefs_locator_text">locator මඟින් පොළ පිහිටීම සකසන්න</string>
 
     <string name="prefs_data_title">චන්ද්‍රිකා දත්ත</string>
     <string name="prefs_data_entries">චන්ද්‍රිකා: %s</string>
@@ -107,37 +114,57 @@
     <string name="prefs_data_clear">පිරිසිදු ක°</string>
     <string name="prefs_data_clear_success">දත්ත ඉවත් කිරීම සාර්ථකයි</string>
     <string name="prefs_data_update_success">යාවත්කාලීනය සම්පූර්ණ කිරීම සාර්ථකයි</string>
+    <string name="prefs_data_import_satellites_error">චන්ද්‍රිකා ආයාත නොවීය. වලංගු TLE/3LE (.txt) හෝ OMM (.csv) ගොනුවක් තෝරන්න.</string>
+    <string name="prefs_data_import_transceivers_error">සම්ප්‍රේෂක ආයාත නොවීය. වලංගු SatNOGS (.json) ගොනුවක් තෝරන්න.</string>
 
-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">අභිරුචි මූලාශ්‍ර</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">Transceivers URL</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
 
-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
+    <string name="prefs_data_output_title">දත්ත ප්‍රතිදානය</string>
+    <string name="prefs_net_output">ජාලය</string>
     <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>
+
+    <string name="nav_radiocontrol">රේඩියෝ පාලනය</string>
+    <string name="rc_settings_title">CAT පාලනය</string>
+    <string name="rc_radio_model">රේඩියෝ මාදිලිය</string>
+    <string name="rc_tx_device_hint">TX BT ලිපිනය</string>
+    <string name="rc_rx_device_hint">RX BT ලිපිනය</string>
+    <string name="rc_tx_name_hint">TX රේඩියෝ නම</string>
+    <string name="rc_rx_name_hint">RX රේඩියෝ නම</string>
+    <string name="rc_enable_switch">CAT සබල කරන්න</string>
 
     <string name="prefs_net_title">ජාල ප්‍රතිදානය</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
+    <string name="prefs_net_rotator_switch">Rotation ප්‍රතිදානය සබල කරන්න</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_rotator_format_hint">දත්ත ආකෘතිය</string>
+    <string name="prefs_net_frequency_switch">Frequency ප්‍රතිදානය සබල කරන්න</string>
     <string name="prefs_net_frequency_address_hint">IP:Port</string>
-    <string name="prefs_net_frequency_format_hint">දත්ත අකාරය</string>
+    <string name="prefs_net_frequency_format_hint">දත්ත ආකෘතිය</string>
 
-    <string name="prefs_bt_title">Bluetooth දත්ත ප්‍රතිදානය</string>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">උපාංග id</string>
-    <string name="prefs_bt_rotator_output_hint">දත්ත අකාරය</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">උපාංග id</string>
-    <string name="prefs_bt_frequency_output_hint">දත්ත අකාරය</string>
+    <string name="prefs_bt_title">Bluetooth ප්‍රතිදානය</string>
+    <string name="prefs_bt_rotator_switch">Rotation ප්‍රතිදානය සබල කරන්න</string>
+    <string name="prefs_bt_rotator_device_hint">උපාංග ID</string>
+    <string name="prefs_bt_rotator_output_hint">දත්ත ආකෘතිය</string>
+    <string name="prefs_bt_frequency_switch">Frequency ප්‍රතිදානය සබල කරන්න</string>
+    <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>
-    <string name="prefs_other_switch_update">ස්වයං දත්ත යාවත්කාලීනය</string>
-    <string name="prefs_other_switch_sweep">radar sweep සජීවිකරණය සබල කරන්න</string>
-    <string name="prefs_other_switch_sensors">Radar දර්ශනය කරකැවීමට සංවේදක භාවිතා කරන්න </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">Radar sweep</string>
+    <string name="prefs_other_switch_sensors">සංවේදක</string>
+    <string name="prefs_other_switch_night_mode">රාත්‍රී පෙරහන</string>
+
+    <string name="prefs_highlight_title">උස් උද්දීපනය</string>
+    <string name="prefs_highlight_low">අඩු &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">මධ්‍ය %1$d-%2$d°</string>
+    <string name="prefs_highlight_high">ඉහළ &gt; %1$d°</string>
 
     <string name="prefs_outro_title">මම ස්තුති කිරීමට කැමති:</string>
     <string name="prefs_outro_license">මෘදුකාංගය වගකීමක් සමග නොලැබේ</string>

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

@@ -14,26 +14,33 @@
     <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_type_hint">Modlar: %s</string>
+    <string name="sat_type_title">Modları 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_group_selected">Seçilenler</string>
+    <string name="sat_group_available">Kullanılabilir</string>
+    <string name="sat_group_selected_count">Seçilenler (%1$d)</string>
+    <string name="sat_group_available_count">Kullanılabilir (%1$d)</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>
+        daraltmak için arama ve mod 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">İlerideki saatler</string>
+    <string name="pass_filter_hours">Gösterilecek zaman</string>
+    <string name="pass_filter_aos_time">AOS aralığı</string>
+    <string name="pass_filter_invert_time">AOS aralığını tersine çevir</string>
+    <string name="pass_filter_deep_space">DeepSpace (periyot &gt;225dk)</string>
     <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
-    <string name="pass_modes_title">Modulasyon türü seçin</string>
+    <string name="pass_modes_title">Modları 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>
@@ -66,7 +73,7 @@
     <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">Tutulumda</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>
@@ -93,7 +100,7 @@
     <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">Tutulumda</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>
@@ -124,11 +131,11 @@
     <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_station_title">İstasyon konumu</string>
+    <string name="prefs_station_lat_text">İstasyon enlemi</string>
+    <string name="prefs_station_lon_text">İstasyon boylamı</string>
+    <string name="prefs_locator_title">QTH konumlandırıcı</string>
+    <string name="prefs_locator_text">Konumu lokatörle ayarla</string>
 
     <string name="prefs_data_title">Uydu verisi</string>
     <string name="prefs_data_entries">Uydular: %s</string>
@@ -138,28 +145,30 @@
     <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_import_satellites_error">Uydu içe aktarılmadı. Geçerli bir TLE/3LE (.txt) veya OMM (.csv) dosyası seçin.</string>
+    <string name="prefs_data_import_transceivers_error">Transceiver içe aktarılmadı. Geçerli bir SatNOGS (.json) dosyası seçin.</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_title">Özel kaynaklar</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">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_data_output_title">Veri çıkışı</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_settings_title">CAT 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_device_hint">TX BT adresi</string>
+    <string name="rc_rx_device_hint">RX 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="rc_enable_switch">CAT\'i etkinleştir</string>
 
-    <string name="prefs_net_title">Ağ veri çıkışı</string>
+    <string name="prefs_net_title">Ağ çı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>
@@ -167,22 +176,29 @@
     <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_title">Bluetooth çı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_rotator_output_hint">Biçim</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_frequency_output_hint">Biçim</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_other_title">Diğer</string>
+    <string name="prefs_other_switch_utc">UTC saati</string>
+    <string name="prefs_other_switch_update">Veriyi otomatik güncelle</string>
+    <string name="prefs_other_switch_sweep">Radar taraması</string>
+    <string name="prefs_other_switch_sensors">Sensör</string>
+    <string name="prefs_other_switch_night_mode">Gece filtresi</string>
 
-    <string name="prefs_outro_title">Teşekkür etmek istiyorum</string>
+    <string name="prefs_highlight_title">Elevasyon vurgusu</string>
+    <string name="prefs_highlight_low">Düşük &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">Orta %1$d-%2$d°</string>
+    <string name="prefs_highlight_high">Yüksek &gt; %1$d°</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)

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

@@ -13,12 +13,16 @@
     <string name="nav_prefs">Налаштування</string>
 
     <!-- Satellites screen -->
-    <string name="sat_type_hint">Тип: %s</string>
-    <string name="sat_type_title">Виберіть тип супутника</string>
+    <string name="sat_type_hint">Режими: %s</string>
+    <string name="sat_type_title">Виберіть режими</string>
     <string name="sat_search_hint">Id - Назва</string>
     <string name="sat_search_clear">Очистити</string>
     <string name="sat_clear_all">Очистити всі</string>
     <string name="sat_select_all">Вибрати всі</string>
+    <string name="sat_group_selected">Обрані</string>
+    <string name="sat_group_available">Доступні</string>
+    <string name="sat_group_selected_count">Обрані (%1$d)</string>
+    <string name="sat_group_available_count">Доступні (%1$d)</string>
     <string name="sat_empty_list_message">
         Переконайтеся, що ваш пошуковий запит правильний, а база даних оновлена</string>
     <string name="sat_warning_title">Увага\!</string>
@@ -26,13 +30,16 @@
         У цьому додатку перелічено понад 9000 супутників.
         Немає сенсу відстежувати їх усі одночасно.
         \n\nЗавжди намагайтеся звузити список лише до тих,
-        які вас цікавлять, за допомогою пошуку та селектора типів.</string>
+        які вас цікавлять, за допомогою пошуку та вибору режимів.</string>
 
     <!-- Passes screen -->
     <string name="pass_filter_title">Фільтр прольотів</string>
-    <string name="pass_filter_elev">Мінімальне піднесення</string>
-    <string name="pass_filter_hours">Кількість годин</string>
-    <string name="pass_modes_title">Виберіть тип модуляції</string>
+    <string name="pass_filter_elev">Мінімальне піднесень</string>
+    <string name="pass_filter_hours">Час вперед</string>
+    <string name="pass_filter_aos_time">Вікно AOS</string>
+    <string name="pass_filter_invert_time">Інвертувати вікно AOS</string>
+    <string name="pass_filter_deep_space">DeepSpace (період &gt;225хв)</string>
+    <string name="pass_modes_title">Виберіть режими</string>
     <string name="pass_elevation">Піднес.: %.1f°</string>
     <string name="pass_altitude">Висота: %.0f км</string>
     <string name="pass_empty_list_message">
@@ -66,7 +73,7 @@
     <string name="map_prev">Попередній</string>
     <string name="map_next">Наступний</string>
     <string name="map_azimuth">Азимут: %.1f°</string>
-    <string name="map_elevation">Піднесення: %.1f°</string>
+    <string name="map_elevation">Піднесень: %.1f°</string>
     <string name="map_altitude">Висота: %.0f км</string>
     <string name="map_distance">Дистанція: %.0f км</string>
     <string name="map_latitude">Широта: %.1f°</string>
@@ -93,11 +100,11 @@
     <string name="prefs_loc_qth_title">QTH</string>
     <string name="prefs_loc_qth_error">Некоректний локатор QTH</string>
     <string name="prefs_loc_success">Позицію успішно оновлено</string>
-    <string name="prefs_station_title">Налаштування місцезнаходження станції</string>
-    <string name="prefs_station_lat_text">Широта місцезнаходження станції</string>
-    <string name="prefs_station_lon_text">Довгота місцезнаходження станції</string>
-    <string name="prefs_locator_title">Налаштування QTH локатора</string>
-    <string name="prefs_locator_text">Задати позицію за QTH локатором</string>
+    <string name="prefs_station_title">Позиція станції</string>
+    <string name="prefs_station_lat_text">Широта станції</string>
+    <string name="prefs_station_lon_text">Довгота станції</string>
+    <string name="prefs_locator_title">Локатор QTH</string>
+    <string name="prefs_locator_text">Позиція за локатором</string>
 
     <string name="prefs_data_title">Супутникові дані</string>
     <string name="prefs_data_entries">Супутників: %s</string>
@@ -107,37 +114,57 @@
     <string name="prefs_data_clear">Очистити</string>
     <string name="prefs_data_clear_success">Дані успішно очищено</string>
     <string name="prefs_data_update_success">Оновлення успішне</string>
+    <string name="prefs_data_import_satellites_error">Супутники не імпортовано. Потрібен TLE/3LE (.txt) або OMM (.csv).</string>
+    <string name="prefs_data_import_transceivers_error">Трансивери не імпортовано. Потрібен SatNOGS (.json).</string>
 
-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">Власні джерела</string>
+    <string name="prefs_data_sources_tle_switch">URL TLE</string>
+    <string name="prefs_data_sources_transceivers_switch">URL трансиверів</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
 
-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
+    <string name="prefs_data_output_title">Вивід даних</string>
+    <string name="prefs_net_output">Мережа</string>
     <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>
 
-    <string name="prefs_net_title">Вивід мережевих даних</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
+    <string name="nav_radiocontrol">Керування радіо</string>
+    <string name="rc_settings_title">CAT керування</string>
+    <string name="rc_radio_model">Модель радіо</string>
+    <string name="rc_tx_device_hint">BT адреса TX</string>
+    <string name="rc_rx_device_hint">BT адреса RX</string>
+    <string name="rc_tx_name_hint">Назва радіо TX</string>
+    <string name="rc_rx_name_hint">Назва радіо RX</string>
+    <string name="rc_enable_switch">Увімкнути CAT</string>
+
+    <string name="prefs_net_title">Мережевий вивід</string>
+    <string name="prefs_net_rotator_switch">Увімкнути вивід повороту</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_switch">Увімкнути вивід частоти</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>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Id пристрою</string>
+    <string name="prefs_bt_title">Вивід Bluetooth</string>
+    <string name="prefs_bt_rotator_switch">Увімкнути вивід повороту</string>
+    <string name="prefs_bt_rotator_device_hint">ID пристрою</string>
     <string name="prefs_bt_rotator_output_hint">Формат даних</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">Id пристрою</string>
+    <string name="prefs_bt_frequency_switch">Увімкнути вивід частоти</string>
+    <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>
-    <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_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_highlight_title">Підсвічування висоти</string>
+    <string name="prefs_highlight_low">Низько &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">Середньо %1$d-%2$d°</string>
+    <string name="prefs_highlight_high">Високо &gt; %1$d°</string>
 
     <string name="prefs_outro_title">Я хотів би подякувати:</string>
     <string name="prefs_outro_license">Ця програма поставляється без жодних гарантій</string>

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

@@ -13,21 +13,28 @@
     <string name="nav_prefs">设置</string>
 
     <!-- Satellites screen -->
-    <string name="sat_type_hint">类型：%s</string>
-    <string name="sat_type_title">选择卫星类型</string>
+    <string name="sat_type_hint">模式：%s</string>
+    <string name="sat_type_title">选择模式</string>
     <string name="sat_search_hint">Id - 名称</string>
     <string name="sat_search_clear">清空</string>
     <string name="sat_clear_all">全部清空</string>
     <string name="sat_select_all">全选</string>
+    <string name="sat_group_selected">已选择</string>
+    <string name="sat_group_available">可用</string>
+    <string name="sat_group_selected_count">已选择（%1$d）</string>
+    <string name="sat_group_available_count">可用（%1$d）</string>
     <string name="sat_empty_list_message">请确保您的搜索查询正确且数据库已更新</string>
     <string name="sat_warning_title">警告\!</string>
-    <string name="sat_warning_message">此应用收录了超过9000颗卫星信息\n同时追踪所有卫星并不现实\n建议始终通过搜索和分类筛选功能仅勾选您感兴趣的卫星</string>
+    <string name="sat_warning_message">此应用收录了超过9000颗卫星信息\n同时追踪所有卫星并不现实\n建议始终通过搜索和模式筛选功能仅勾选您感兴趣的卫星</string>
 
     <!-- Passes screen -->
     <string name="pass_filter_title">筛选过境</string>
     <string name="pass_filter_elev">仰角值</string>
-    <string name="pass_filter_hours">小时数</string>
-    <string name="pass_modes_title">选择调制类型</string>
+    <string name="pass_filter_hours">提前时间</string>
+    <string name="pass_filter_aos_time">AOS 时间段</string>
+    <string name="pass_filter_invert_time">反选 AOS 时间段</string>
+    <string name="pass_filter_deep_space">DeepSpace（周期 &gt;225分钟）</string>
+    <string name="pass_modes_title">选择模式</string>
     <string name="pass_elevation">仰角：%.1f°</string>
     <string name="pass_altitude">高度：%d km</string>
     <string name="pass_empty_list_message">请确保您的过滤器设置正确，并且已选择卫星</string>
@@ -53,6 +60,9 @@
     <string name="radar_string_no">否</string>
     <string name="radar_string_yes">是</string>
     <string name="radar_visible">日照中</string>
+    <string name="radar_doppler_tx_hint">输入上行频率 (MHz)</string>
+    <string name="radar_doppler_rx_hint">输入下行频率 (MHz)</string>
+    <string name="radar_doppler_offset_hint">偏移 (kHz)</string>
 
     <!-- Map screen -->
     <string name="map_prev">上一个</string>
@@ -85,11 +95,11 @@
     <string name="prefs_loc_qth_title">QTH 网格</string>
     <string name="prefs_loc_qth_error">无效的 QTH 网格</string>
     <string name="prefs_loc_success">位置更新成功</string>
-    <string name="prefs_station_title">站位设置</string>
-    <string name="prefs_station_lat_text">输入站位的纬度</string>
-    <string name="prefs_station_lon_text">输入站位的经度</string>
-    <string name="prefs_locator_title">QTH 网格</string>
-    <string name="prefs_locator_text">使用梅登黑德网格设置站位</string>
+    <string name="prefs_station_title">站位</string>
+    <string name="prefs_station_lat_text">站位纬度</string>
+    <string name="prefs_station_lon_text">站位经度</string>
+    <string name="prefs_locator_title">QTH 定位</string>
+    <string name="prefs_locator_text">通过 QTH 设置站位</string>
 
     <string name="prefs_data_title">卫星数据更新</string>
     <string name="prefs_data_entries">卫星：%s</string>
@@ -99,16 +109,29 @@
     <string name="prefs_data_clear">清空</string>
     <string name="prefs_data_clear_success">数据清空成功</string>
     <string name="prefs_data_update_success">更新成功</string>
+    <string name="prefs_data_import_satellites_error">未导入卫星。请选择有效的 TLE/3LE (.txt) 或 OMM (.csv) 文件。</string>
+    <string name="prefs_data_import_transceivers_error">未导入收发器。请选择有效的 SatNOGS (.json) 文件。</string>
 
-    <string name="prefs_data_sources_title">自定义数据源</string>
-    <string name="prefs_data_sources_tle_switch">自定义TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">自定义收发器URL</string>
+    <string name="prefs_data_sources_title">自定义源</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">收发器 URL</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
 
     <string name="prefs_data_output_title">数据输出</string>
     <string name="prefs_net_output">网络</string>
     <string name="prefs_bt_output">蓝牙</string>
+    <string name="prefs_cat_output">CAT</string>
 
-    <string name="prefs_net_title">网络数据输出</string>
+    <string name="nav_radiocontrol">电台控制</string>
+    <string name="rc_settings_title">CAT 控制</string>
+    <string name="rc_radio_model">电台型号</string>
+    <string name="rc_tx_device_hint">TX 电台蓝牙地址</string>
+    <string name="rc_rx_device_hint">RX 电台蓝牙地址</string>
+    <string name="rc_tx_name_hint">TX 电台名称</string>
+    <string name="rc_rx_name_hint">RX 电台名称</string>
+    <string name="rc_enable_switch">启用 CAT</string>
+
+    <string name="prefs_net_title">网络输出</string>
     <string name="prefs_net_rotator_switch">启用方位俯仰角输出</string>
     <string name="prefs_net_rotator_address_hint">IP:端口</string>
     <string name="prefs_net_rotator_format_hint">数据格式</string>
@@ -116,7 +139,7 @@
     <string name="prefs_net_frequency_address_hint">IP:端口</string>
     <string name="prefs_net_frequency_format_hint">数据格式</string>
 
-    <string name="prefs_bt_title">蓝牙数据输出</string>
+    <string name="prefs_bt_title">蓝牙输出</string>
     <string name="prefs_bt_rotator_switch">启用方位俯仰角输出</string>
     <string name="prefs_bt_rotator_device_hint">蓝牙设备 ID</string>
     <string name="prefs_bt_rotator_output_hint">数据格式</string>
@@ -124,14 +147,28 @@
     <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_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_highlight_title">仰角高亮</string>
+    <string name="prefs_highlight_low">低 &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">中 %1$d-%2$d°</string>
+    <string name="prefs_highlight_high">高 &gt; %1$d°</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

@@ -14,27 +14,33 @@
     <string name="nav_prefs">Settings</string>
 
     <!-- Satellites screen -->
-    <string name="sat_type_hint">Type: %s</string>
-    <string name="sat_type_title">Select satellite type</string>
+    <string name="sat_type_hint">Modes: %s</string>
+    <string name="sat_type_title">Select modes</string>
     <string name="sat_search_hint">Id - Name</string>
     <string name="sat_search_clear">Clear</string>
     <string name="sat_clear_all">Clear all</string>
     <string name="sat_select_all">Select all</string>
+    <string name="sat_group_selected">Selected</string>
+    <string name="sat_group_available">Available</string>
+    <string name="sat_group_selected_count">Selected (%1$d)</string>
+    <string name="sat_group_available_count">Available (%1$d)</string>
     <string name="sat_empty_list_message">"Make sure your search query is correct and the DB is updated"</string>
     <string name="sat_warning_title">Warning\!</string>
     <string name="sat_warning_message">
         There are over 9000 satellites listed in this app.
         It makes no sense to track them all at the same time.
         \n\nAlways try to narrow down the list to only the ones
-        you\'re interested in via search and types selector.</string>
+        you\'re interested in via search and the modes selector.</string>
 
     <!-- Passes screen -->
     <string name="pass_filter_title">Filter passes</string>
     <string name="pass_filter_elev">Minimal elevation</string>
-    <string name="pass_filter_hours">Hours ahead</string>
+    <string name="pass_filter_hours">Time ahead</string>
+    <string name="pass_filter_aos_time">AOS window</string>
+    <string name="pass_filter_invert_time">Invert AOS window</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_modes_title">Select modes</string>
     <string name="pass_satId" translatable="false">%05d</string>
     <string name="pass_elevation">Elevation: %.1f°</string>
     <string name="pass_deep_space" translatable="false">DeepSpace</string>
@@ -49,10 +55,16 @@
         \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">
-        * Added Turkish translation, by Emre Can Akdaş (TA3ECR)
-        \n* Added DeepSpace passes filter option to the dialog
-        \n* Fixed the radar blip disappearing while eclipsed
-        \n* Fixed (hopefully) the refresh indicator being stuck
+        * Added small tweaks to Sources and strings. Added official ISS source (#225)
+        \n* Implemented AOS window and elevation highlight filters (#226)
+        \n* Added cleartext traffic support for custom TLE URLs (#227)
+        \n* Fixed manual OMM (.csv) data import, tweaked error messaging (#228)
+        \n* Added support for Icom IC-705 CAT by ruilvo (#229)
+        \n* Added configurable Radar offset to the sensors output by qwqtoday (#230)
+        \n* Localized pass date and time formats for Chinese by atsunatsu (#231)
+        \n* Added linear transponder Doppler calculator by atsunatsu (#232)
+        \n* Added a few tweaks to SSTV sensitivity and reception, similar to Robot36
+        \n* Replaced the types selection dialog with modes selection to avoid confusion
     </string>
 
     <!-- Radar screen -->
@@ -80,6 +92,9 @@
     <string name="radar_string_no">No</string>
     <string name="radar_string_yes">Yes</string>
     <string name="radar_visible">Visible</string>
+    <string name="radar_doppler_tx_hint">Enter TX freq (MHz)</string>
+    <string name="radar_doppler_rx_hint">Enter RX freq (MHz)</string>
+    <string name="radar_doppler_offset_hint">Offset (kHz)</string>
 
     <!-- Map screen -->
     <string name="map_prev">Prev</string>
@@ -124,11 +139,11 @@
     <string name="prefs_loc_qth_title">QTH</string>
     <string name="prefs_loc_qth_error">Invalid QTH locator</string>
     <string name="prefs_loc_success">Position updated successfully</string>
-    <string name="prefs_station_title">Station position settings</string>
-    <string name="prefs_station_lat_text">Set your ground station\'s latitude</string>
-    <string name="prefs_station_lon_text">Set your ground station\'s longitude</string>
-    <string name="prefs_locator_title">QTH locator settings</string>
-    <string name="prefs_locator_text">Set station\'s position using locator</string>
+    <string name="prefs_station_title">Station position</string>
+    <string name="prefs_station_lat_text">Station latitude</string>
+    <string name="prefs_station_lon_text">Station longitude</string>
+    <string name="prefs_locator_title">QTH locator</string>
+    <string name="prefs_locator_text">Set position via locator</string>
 
     <string name="prefs_data_title">Satellite data</string>
     <string name="prefs_data_entries">Satellites: %s</string>
@@ -138,10 +153,12 @@
     <string name="prefs_data_clear">Clear</string>
     <string name="prefs_data_clear_success">Data was cleared successfully</string>
     <string name="prefs_data_update_success">Update completed successfully</string>
+    <string name="prefs_data_import_satellites_error">No satellites imported. Select a valid TLE/3LE (.txt) or OMM (.csv) file.</string>
+    <string name="prefs_data_import_transceivers_error">No transceivers imported. Select a valid SatNOGS (.json) file.</string>
 
-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">Custom sources</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">Transceivers URL</string>
     <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
 
     <string name="prefs_data_output_title">Data output</string>
@@ -151,15 +168,15 @@
 
     <!-- Radio Control -->
     <string name="nav_radiocontrol">Radio Control</string>
-    <string name="rc_settings_title">CAT Radio Control</string>
+    <string name="rc_settings_title">CAT 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_device_hint">TX BT address</string>
+    <string name="rc_rx_device_hint">RX 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="rc_enable_switch">Enable CAT</string>
 
-    <string name="prefs_net_title">Network data output</string>
+    <string name="prefs_net_title">Network output</string>
     <string name="prefs_net_rotator_switch">Enable rotation output</string>
     <string name="prefs_net_rotator_address_hint">IP:Port</string>
     <string name="prefs_net_rotator_format_hint">Format</string>
@@ -167,29 +184,40 @@
     <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>
+    <string name="prefs_bt_title">Bluetooth output</string>
     <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Device id</string>
-    <string name="prefs_bt_rotator_output_hint">Data format</string>
+    <string name="prefs_bt_rotator_device_hint">Device ID</string>
+    <string name="prefs_bt_rotator_output_hint">Format</string>
     <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">Device id</string>
-    <string name="prefs_bt_frequency_output_hint">Data format</string>
+    <string name="prefs_bt_frequency_device_hint">Device ID</string>
+    <string name="prefs_bt_frequency_output_hint">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_title">Other</string>
+    <string name="prefs_other_switch_utc">UTC time</string>
+    <string name="prefs_other_switch_update">Auto-update data</string>
+    <string name="prefs_other_switch_sweep">Radar sweep</string>
+    <string name="prefs_other_switch_sensors">Use sensors</string>
+    <string name="prefs_other_switch_night_mode">Night filter</string>
+    <string name="prefs_other_compass_offset">Radar compass offset</string>
+    <string name="prefs_other_compass_offset_elev">Radar compass offset (elev)</string>
+
+    <string name="prefs_highlight_title">Elevation highlight</string>
+    <string name="prefs_highlight_low">Low &lt; %1$d°</string>
+    <string name="prefs_highlight_mid">Mid %1$d–%2$d°</string>
+    <string name="prefs_highlight_high">High &gt; %1$d°</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,4 +1,8 @@
-* Added Turkish translation, by Emre Can Akdaş (TA3ECR)
-* Added DeepSpace passes filter option to the dialog
-* Fixed the radar blip disappearing while eclipsed
-* Fixed (hopefully) the refresh indicator being stuck
+* Added ARISS source, tweaked SSTV sensitivity #225
+* Implemented AOS window and elev filter #226
+* Added cleartext traffic support for TLEs #227
+* Fixed OMM import, tweaked error messages #228
+* Added support for Icom CAT by ruilvo #229
+* Added tweakable Radar offset by qwqtoday #230
+* Localized date/time formats by atsunatsu #231
+* Added linear radio Doppler calc by atsunatsu #232

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

@@ -1,4 +0,0 @@
-* Added Turkish translation, by Emre Can Akdaş (TA3ECR)
-* Added DeepSpace passes filter option to the dialog
-* Fixed the radar blip disappearing while eclipsed
-* Fixed (hopefully) the refresh indicator being stuck

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

@@ -63,6 +63,7 @@ import androidx.lifecycle.viewmodel.compose.viewModel
 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
@@ -83,7 +84,10 @@ 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_COUNT = 4
+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
@@ -106,13 +110,20 @@ private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
     setShadowLayer(3f, 3f, 3f, Color.BLACK)
 }
 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
 fun MapDestination() {
-    val viewModel = viewModel(
-        modelClass = MapViewModel::class.java,
-        factory = MapViewModel.Factory
-    )
+    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)
@@ -152,6 +163,9 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
                     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.mapData?.let { mapData ->
@@ -365,14 +379,12 @@ private var footprintPoints: ArrayList<GeoPoint>? = null
 private fun setFootprint(orbitalPos: OrbitalPos, mapView: MapView) {
     try {
         val rangeCircle = orbitalPos.getRangeCircle()
-        // Lazily initialize the reusable point list and polyline
         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 {
-            // Update coordinates in-place — zero allocations
             for (i in rangeCircle.indices) {
                 pts[i].latitude = rangeCircle[i].latitude
                 pts[i].longitude = rangeCircle[i].longitude
@@ -388,6 +400,83 @@ private fun setFootprint(orbitalPos: OrbitalPos, mapView: MapView) {
         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

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

@@ -30,7 +30,11 @@ data class MapState(
     val orbitalPass: OrbitalPass,
     val track: List<List<GeoPos>>? = null,
     val footprint: OrbitalPos? = null,
-    val positions: Map<OrbitalObject, GeoPos>? = 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 interface MapAction {

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

@@ -18,20 +18,21 @@
 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.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
-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.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
@@ -49,8 +50,10 @@ import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import java.util.Date
 
-class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settingsRepo: ISettingsRepo) :
-    ViewModel() {
+class MapViewModel(
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo
+) : ViewModel() {
 
     private val stationPos = settingsRepo.stationPosition.value
     private val defaultPass = getDefaultPass()
@@ -74,7 +77,8 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
                 _uiState.update { it.copy(isUtc = settings.stateOfUtc) }
             }
         }
-        selectDefaultSatellite(-1)
+        val (selectedCatNum, _) = satelliteRepo.selectedPass.value
+        selectDefaultSatellite(if (selectedCatNum != 0) selectedCatNum else -1)
     }
 
     fun onAction(action: MapAction) {
@@ -124,10 +128,16 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
                 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()
                     updateMapState(orbitalObject, allSatellites, stationPos, dateNow)
-                    delay(updateFreq)
+                    delay(effectiveRate)
                 }
             }
         }
@@ -157,9 +167,7 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
                     var localSelectedPos: OrbitalPos? = null
                     for (satellite in chunk) {
                         val satPos = satelliteRepo.getPosition(satellite, pos, date.time)
-                        val osmLat = clipLat(satPos.latitude.toDegrees())
-                        val osmLon = clipLon(satPos.longitude.toDegrees())
-                        localPositions.add(satellite to GeoPos(osmLat, osmLon))
+                        localPositions.add(satellite to satPos.toMapGeoPos())
                         if (satellite === selected) {
                             localSelectedPos = satPos
                         }
@@ -177,10 +185,12 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
             }
         }
 
-        // 2. Derive footprint and info data from the already-computed selected position
+        // 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 {
@@ -188,7 +198,11 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
                 positions = positionsMap,
                 footprint = footprint,
                 mapData = mapData.first,
-                orbitalPass = mapData.second
+                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
             )
         }
     }
@@ -227,9 +241,7 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
             }
         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()
@@ -259,18 +271,16 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
         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)
+            val currentPosition = satPos.toMapGeoPos()
             if (oldLongitude < -170.0 && currentPosition.longitude > 170.0) {
                 // adding left terminal position
-                currentTrack.add(GeoPos(osmLat, -180.0))
+                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(osmLat, 180.0))
+                currentTrack.add(GeoPos(currentPosition.latitude, 180.0))
                 val finishedTrack = mutableListOf<GeoPos>().apply { addAll(currentTrack) }
                 satTracks.add(finishedTrack)
                 currentTrack.clear()
@@ -286,11 +296,12 @@ class MapViewModel(private val satelliteRepo: ISatelliteRepo, private val settin
         /** Number of parallel chunks for satellite position computation */
         private const val PARALLEL_CHUNKS = 4
 
-        val Factory: ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
+        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/src/main/java/com/rtbishop/look4sat/feature/passes/PassesDialog.kt

@@ -21,8 +21,11 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.grid.GridCells
@@ -31,6 +34,7 @@ import androidx.compose.foundation.lazy.grid.itemsIndexed
 import androidx.compose.material3.Checkbox
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RangeSlider
 import androidx.compose.material3.Slider
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
@@ -43,6 +47,7 @@ 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
@@ -54,70 +59,167 @@ 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
-
-private val allModes = listOf(
-    "AFSK", "AFSK S-Net", "AFSK SALSAT", "AHRPT", "AM", "APT", "BPSK", "BPSK PMT-A3",
-    "CERTO", "CW", "DQPSK", "DSTAR", "DUV", "FFSK", "FM", "FMN", "FSK", "FSK AX.100 Mode 5",
-    "FSK AX.100 Mode 6", "FSK AX.25 G3RUH", "GFSK", "GFSK Rktr", "GMSK", "HRPT", "LoRa",
-    "LRPT", "LSB", "MFSK", "MSK", "MSK AX.100 Mode 5", "MSK AX.100 Mode 6", "OFDM", "OQPSK",
-    "PSK", "PSK31", "PSK63", "QPSK", "QPSK31", "QPSK63", "SSTV", "USB", "WSJT"
-)
+import com.rtbishop.look4sat.core.presentation.ElevationHighColor
+import com.rtbishop.look4sat.core.presentation.ElevationLowColor
+import com.rtbishop.look4sat.core.presentation.elevationColor
+import com.rtbishop.look4sat.core.domain.source.Sources
+import kotlin.math.roundToInt
 
 private val hourSteps = listOf(1, 2, 4, 8, 12, 24, 48, 72, 96, 120, 144, 168, 192, 216, 240)
+private const val dayMinutes = 24 * 60
+private const val minuteStep = 15
+private const val endOfDayMinute = dayMinutes - 1
+private const val quarterHourSlots = dayMinutes / minuteStep
+
+data class PassFilterParams(
+    val hours: Int,
+    val elevation: Double,
+    val lowElevation: Double,
+    val highElevation: Double,
+    val aosStartMinute: Int,
+    val aosEndMinute: Int,
+    val invertAosTimeWindow: Boolean,
+    val showDeepSpace: Boolean
+)
 
 @Preview
 @Composable
 private fun PassesDialogPreview() {
-    MainTheme { PassesDialog(24, 16.0, true, {}) { _, _, _ -> } }
+    MainTheme {
+        PassesFilterDialog(
+            hours = 24,
+            elevation = 16.0,
+            lowElevation = 16.0,
+            highElevation = 65.0,
+            aosStartMinute = 0,
+            aosEndMinute = 23 * 60 + 59,
+            invertAosTimeWindow = false,
+            showDeepSpace = true,
+            cancel = {},
+            accept = {}
+        )
+    }
 }
 
 @Composable
-internal fun PassesDialog(
+internal fun PassesFilterDialog(
     hours: Int,
     elevation: Double,
+    lowElevation: Double,
+    highElevation: Double,
+    aosStartMinute: Int,
+    aosEndMinute: Int,
+    invertAosTimeWindow: Boolean,
     showDeepSpace: Boolean,
     cancel: () -> Unit,
-    accept: (Int, Double, Boolean) -> Unit
+    accept: (PassFilterParams) -> Unit
 ) {
     val hoursIndex = remember { mutableIntStateOf(hourSteps.indexOfFirst { it >= hours }.coerceAtLeast(0)) }
     val elevationValueNew = remember { mutableDoubleStateOf(elevation) }
+    val highlightBounds = 0f..90f
+    var highlightRange by remember(lowElevation, highElevation) {
+        mutableStateOf(lowElevation.toFloat()..highElevation.toFloat())
+    }
+    var aosRangeValue by remember {
+        mutableStateOf(minuteToSlot(aosStartMinute).toFloat()..minuteToSlot(aosEndMinute).toFloat())
+    }
+    var invertedAosRange by remember { mutableStateOf(invertAosTimeWindow) }
     var deepSpaceEnabled by remember { mutableStateOf(showDeepSpace) }
     val onAccept = {
-        accept(hourSteps[hoursIndex.intValue], elevationValueNew.doubleValue, deepSpaceEnabled).also { cancel() }
+        accept(
+            PassFilterParams(
+                hours = hourSteps[hoursIndex.intValue],
+                elevation = elevationValueNew.doubleValue,
+                lowElevation = highlightRange.start.roundToInt().toDouble(),
+                highElevation = highlightRange.endInclusive.roundToInt().toDouble(),
+                aosStartMinute = slotToMinute(aosRangeValue.start),
+                aosEndMinute = slotToMinute(aosRangeValue.endInclusive),
+                invertAosTimeWindow = invertedAosRange,
+                showDeepSpace = deepSpaceEnabled
+            )
+        )
+        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,
             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 = hoursIndex.intValue.toDouble(),
-            displayValue = "${hourSteps[hoursIndex.intValue]}h",
+            displayValue = formatHoursLabel(hourSteps[hoursIndex.intValue]),
             valueResId = R.drawable.ic_clock,
             valueRange = 0f..(hourSteps.size - 1).toFloat(),
             steps = hourSteps.size - 2
         ) { hoursIndex.intValue = it.toInt().coerceIn(0, hourSteps.size - 1) }
+        ToggleRow(
+            title = stringResource(R.string.pass_filter_deep_space),
+            checked = deepSpaceEnabled,
+            onCheckedChange = { deepSpaceEnabled = it }
+        )
+        ElevationColorsRangeSliderRow(
+            title = stringResource(R.string.prefs_highlight_title),
+            range = highlightRange,
+            valueRange = highlightBounds
+        ) { highlightRange = it }
+        TimeRangeSliderRow(
+            title = stringResource(R.string.pass_filter_aos_time),
+            range = aosRangeValue,
+            displayValue = formatTimeRange(aosRangeValue, invertedAosRange),
+            valueResId = R.drawable.ic_clock,
+            valueRange = 0f..quarterHourSlots.toFloat(),
+        ) { aosRangeValue = it }
+        ToggleRow(
+            title = stringResource(R.string.pass_filter_invert_time),
+            checked = invertedAosRange,
+            onCheckedChange = { invertedAosRange = it }
+        )
+        Spacer(modifier = Modifier.height(0.dp))
     }
 }
 
+private fun slotToMinute(value: Float): Int {
+    val slot = value.roundToInt().coerceIn(0, quarterHourSlots)
+    return if (slot == quarterHourSlots) endOfDayMinute else slot * minuteStep
+}
+
+private fun minuteToSlot(minute: Int): Int {
+    if (minute >= endOfDayMinute) return quarterHourSlots
+    return ((minute + minuteStep / 2) / minuteStep).coerceIn(0, quarterHourSlots)
+}
+
+private fun formatMinuteOfDay(minute: Int): String {
+    val hourPart = minute / 60
+    val minutePart = minute % 60
+    return "%02d:%02d".format(hourPart, minutePart)
+}
+
+private fun formatHoursLabel(hours: Int): String {
+    if (hours < 24) return "${hours}h"
+    val days = hours / 24
+    val remainder = hours % 24
+    return if (remainder == 0) "${days}d" else "${days}d ${remainder}h"
+}
+
+private fun formatTimeRange(
+    range: ClosedFloatingPointRange<Float>,
+    inverted: Boolean
+): String {
+    val start = formatMinuteOfDay(slotToMinute(range.start))
+    val end = formatMinuteOfDay(slotToMinute(range.endInclusive))
+    return if (inverted) "$end - $start" else "$start - $end"
+}
+
 @Composable
-private fun SliderRow(
+private fun SliderSection(
     title: String,
-    value: Double,
-    displayValue: String,
-    valueResId: Int,
-    valueRange: ClosedFloatingPointRange<Float>,
-    steps: Int = 0,
-    onChange: (Float) -> Unit
+    trailingContent: @Composable () -> Unit,
+    sliderContent: @Composable () -> Unit
 ) {
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -134,6 +236,56 @@ private fun SliderRow(
                 modifier = Modifier.weight(1f),
                 color = MaterialTheme.colorScheme.onSurface
             )
+            trailingContent()
+        }
+        sliderContent()
+    }
+}
+
+@Composable
+private fun SliderRow(
+    title: String,
+    value: Double,
+    displayValue: String,
+    valueResId: Int,
+    valueRange: ClosedFloatingPointRange<Float>,
+    steps: Int = 0,
+    accentColor: Color = MaterialTheme.colorScheme.primary,
+    onChange: (Float) -> Unit
+) {
+    SliderSection(
+        title = title,
+        trailingContent = {
+            Icon(
+                painter = painterResource(id = valueResId),
+                contentDescription = null,
+                tint = accentColor,
+                modifier = Modifier.size(20.dp)
+            )
+            Text(
+                text = displayValue,
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Medium,
+                color = accentColor
+            )
+        }
+    ) {
+        Slider(value = value.toFloat(), onValueChange = onChange, valueRange = valueRange, steps = steps)
+    }
+}
+
+@Composable
+private fun TimeRangeSliderRow(
+    title: String,
+    range: ClosedFloatingPointRange<Float>,
+    displayValue: String,
+    valueResId: Int,
+    valueRange: ClosedFloatingPointRange<Float>,
+    onChange: (ClosedFloatingPointRange<Float>) -> Unit
+) {
+    SliderSection(
+        title = title,
+        trailingContent = {
             Icon(
                 painter = painterResource(id = valueResId),
                 contentDescription = null,
@@ -147,7 +299,56 @@ private fun SliderRow(
                 color = MaterialTheme.colorScheme.primary
             )
         }
-        Slider(value = value.toFloat(), onValueChange = onChange, valueRange = valueRange, steps = steps)
+    ) {
+        RangeSlider(
+            value = range,
+            onValueChange = { onChange(it.start..it.endInclusive) },
+            valueRange = valueRange,
+            steps = 0,
+            modifier = Modifier.fillMaxWidth()
+        )
+    }
+}
+
+@Composable
+private fun ElevationColorsRangeSliderRow(
+    title: String,
+    range: ClosedFloatingPointRange<Float>,
+    valueRange: ClosedFloatingPointRange<Float>,
+    onChange: (ClosedFloatingPointRange<Float>) -> Unit
+) {
+    val low = range.start.roundToInt()
+    val high = range.endInclusive.roundToInt()
+    SliderSection(
+        title = title,
+        trailingContent = {
+            Text(
+                text = "$low°",
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Medium,
+                color = ElevationLowColor
+            )
+            Text(
+                text = "..",
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary
+            )
+            Text(
+                text = "$high°",
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Medium,
+                color = ElevationHighColor
+            )
+        }
+    ) {
+        RangeSlider(
+            value = range,
+            onValueChange = { onChange(it.start..it.endInclusive) },
+            valueRange = valueRange,
+            steps = 0,
+            modifier = Modifier.fillMaxWidth()
+        )
     }
 }
 
@@ -173,7 +374,7 @@ internal fun RadiosDialog(modes: List<String>, cancel: () -> Unit, accept: (List
             horizontalArrangement = Arrangement.spacedBy(1.dp),
             verticalArrangement = Arrangement.spacedBy(1.dp)
         ) {
-            itemsIndexed(allModes) { index, item ->
+            itemsIndexed(Sources.satelliteModes) { index, item ->
                 Row(
                     verticalAlignment = Alignment.CenterVertically,
                     modifier = Modifier

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
@@ -25,14 +30,13 @@ 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.height
 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
@@ -47,6 +51,7 @@ 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
@@ -60,15 +65,18 @@ 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.ScreenColumn
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+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
@@ -78,10 +86,9 @@ import java.util.TimeZone
 
 @Composable
 fun PassesDestination(navigateToRadar: (Int, Long) -> Unit) {
-    val viewModel = viewModel(
-        modelClass = PassesViewModel::class.java,
-        factory = PassesViewModel.Factory
-    )
+    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)
 }
@@ -93,14 +100,31 @@ private fun PassesScreen(
     navigateToRadar: (Int, Long) -> Unit
 ) {
     if (uiState.isPassesDialogShown) {
-        PassesDialog(
+        PassesFilterDialog(
             hours = uiState.hours,
             elevation = uiState.elevation,
+            lowElevation = uiState.lowElevation,
+            highElevation = uiState.highElevation,
+            aosStartMinute = uiState.aosStartMinute,
+            aosEndMinute = uiState.aosEndMinute,
+            invertAosTimeWindow = uiState.invertAosTimeWindow,
             showDeepSpace = uiState.showDeepSpace,
-            cancel = { onAction(PassesAction.TogglePassesDialog) }
-        ) { hours, elevation, showDeepSpace ->
-            onAction(PassesAction.FilterPasses(hours, elevation, showDeepSpace))
-        }
+            cancel = { onAction(PassesAction.TogglePassesDialog) },
+            accept = { params ->
+                onAction(
+                    PassesAction.FilterPasses(
+                        hoursAhead = params.hours,
+                        minElevation = params.elevation,
+                        lowElevation = params.lowElevation,
+                        highElevation = params.highElevation,
+                        aosStartMinute = params.aosStartMinute,
+                        aosEndMinute = params.aosEndMinute,
+                        invertAosTimeWindow = params.invertAosTimeWindow,
+                        showDeepSpace = params.showDeepSpace
+                    )
+                )
+            }
+        )
     }
     if (uiState.isRadiosDialogShown) {
         RadiosDialog(
@@ -111,14 +135,22 @@ private fun PassesScreen(
         }
     }
     if (uiState.shouldSeeWhatsNew) {
-        InfoDialog(
+        val dismiss = { onAction(PassesAction.DismissWhatsNew) }
+        SharedDialog(
             title = stringResource(R.string.pass_whatsnew_title),
-            text = stringResource(R.string.pass_whatsnew_message)
-        ) {
-            onAction(PassesAction.DismissWhatsNew)
+            onDismissRequest = dismiss,
+            onAccept = dismiss,
+            titleFontSize = 18
+        ) { padding ->
+            Text(
+                text = stringResource(R.string.pass_whatsnew_message),
+                fontSize = 16.sp,
+                color = MaterialTheme.colorScheme.onSurface,
+                modifier = Modifier.padding(horizontal = padding)
+            )
+            Spacer(modifier = Modifier.height(0.dp))
         }
     }
-    val gridState = rememberLazyGridState()
     ScreenColumn(
         topBar = { isVerticalLayout ->
             TopBar(
@@ -142,9 +174,11 @@ private fun PassesScreen(
             isRefreshing = uiState.isRefreshing,
             isUtc = uiState.isUtc,
             passes = uiState.itemsList,
+            groupedPasses = uiState.groupedPasses,
+            sunTimes = uiState.sunTimes,
+            focusedCatNum = uiState.focusedCatNum,
             navigateToRadar = navigateToRadar,
-            refreshPasses = { onAction(PassesAction.RefreshPasses) },
-            gridState = gridState
+            onAction = onAction
         )
     }
 }
@@ -155,9 +189,11 @@ 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()
@@ -165,7 +201,7 @@ private fun PassesList(
         PullToRefreshBox(
             isRefreshing = isRefreshing,
             state = refreshState,
-            onRefresh = refreshPasses,
+            onRefresh = { onAction(PassesAction.RefreshPasses) },
             indicator = {
                 PullToRefreshDefaults.Indicator(
                     state = refreshState,
@@ -179,19 +215,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 ->
-                        PassItem(
-                            pass = pass,
-                            navigateToRadar = navigateToRadar,
-                            modifier = Modifier.animateItem(),
-                            isVerticalLayout = isVerticalLayout,
-                            isUtc = isUtc
-                        )
+                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
+                                    )
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -199,6 +253,50 @@ 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)
+            }
+        }
+    }
+}
+
+private fun displayLocale(): Locale {
+    val locale = Locale.getDefault()
+    return if (locale.language == Locale.CHINESE.language) locale else Locale.ENGLISH
+}
+
 @Preview(showBackground = true)
 @Composable
 private fun DeepSpacePassPreview() {
@@ -230,15 +328,15 @@ private fun PassItem(
     val timeZone = remember(isUtc) {
         if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
     }
-    val sdfDate = remember(isUtc) {
-        SimpleDateFormat("EEE dd MMM", Locale.ENGLISH).also { it.timeZone = timeZone }
-    }
     val sdfTime = remember(isUtc) {
-        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", displayLocale()).also { it.timeZone = timeZone }
     }
-    val aosDateStr = remember(pass.aosTime, isUtc) { sdfDate.format(Date(pass.aosTime)) }
     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) }
@@ -266,16 +364,17 @@ private fun PassItem(
                     overflow = TextOverflow.Ellipsis,
                     color = MaterialTheme.colorScheme.onSurface
                 )
+                val elevColor = elevationColor(pass.maxElevation)
                 Icon(
                     painter = painterResource(id = 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(
@@ -295,7 +394,7 @@ private fun PassItem(
                             color = MaterialTheme.colorScheme.onSurface
                         )
                     } else {
-                        Text(text = aosDateStr, fontSize = 15.sp, color = MaterialTheme.colorScheme.onSurface)
+                        Text(text = durationStr, fontSize = 15.sp, color = MaterialTheme.colorScheme.onSurface)
                     }
                 }
                 Row(
@@ -303,13 +402,6 @@ private fun PassItem(
                     horizontalArrangement = Arrangement.Center,
                     verticalAlignment = Alignment.CenterVertically
                 ) {
-                    Icon(
-                        painter = painterResource(id = R.drawable.ic_altitude),
-                        contentDescription = null,
-                        modifier = Modifier.size(16.dp),
-                        tint = MaterialTheme.colorScheme.onSurface
-                    )
-                    Spacer(modifier = Modifier.width(4.dp))
                     Text(text = "${pass.altitude} km", fontSize = 15.sp, color = MaterialTheme.colorScheme.onSurface)
                 }
                 Row(

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

@@ -29,17 +29,36 @@ data class PassesState(
     val isNextTimeAos: Boolean = true,
     val hours: Int = 24,
     val elevation: Double = 16.0,
+    val lowElevation: Double = 16.0,
+    val highElevation: Double = 65.0,
+    val aosStartMinute: Int = 0,
+    val aosEndMinute: Int = 23 * 60 + 59,
+    val invertAosTimeWindow: Boolean = false,
     val showDeepSpace: Boolean = true,
     val modes: List<String> = emptyList(),
     val itemsList: List<OrbitalPass> = emptyList(),
-    val shouldSeeWhatsNew: Boolean = false
+    val groupedPasses: Map<String, List<OrbitalPass>> = emptyMap(),
+    val shouldSeeWhatsNew: Boolean = false,
+    val sunTimes: Map<String, Pair<String, String>> = emptyMap(),
+    val focusedCatNum: Int? = null
 )
 
 sealed interface PassesAction {
     data object DismissWhatsNew : PassesAction
-    data class FilterPasses(val hoursAhead: Int, val minElevation: Double, val showDeepSpace: Boolean) : PassesAction
+    data class FilterPasses(
+        val hoursAhead: Int,
+        val minElevation: Double,
+        val lowElevation: Double,
+        val highElevation: Double,
+        val aosStartMinute: Int,
+        val aosEndMinute: Int,
+        val invertAosTimeWindow: Boolean,
+        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,13 +18,13 @@
 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
@@ -34,9 +34,17 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 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
+import kotlin.time.Duration.Companion.milliseconds
 
 class PassesViewModel(
     private val satelliteRepo: ISatelliteRepo,
@@ -50,8 +58,13 @@ class PassesViewModel(
             nextPass = defaultPass,
             hours = settingsRepo.passesSettings.value.hoursAhead,
             elevation = settingsRepo.passesSettings.value.minElevation,
+            lowElevation = settingsRepo.otherSettings.value.lowElevation,
+            highElevation = settingsRepo.otherSettings.value.highElevation,
+            aosStartMinute = settingsRepo.passesSettings.value.aosStartMinute,
+            aosEndMinute = settingsRepo.passesSettings.value.aosEndMinute,
+            invertAosTimeWindow = settingsRepo.passesSettings.value.invertAosTimeWindow,
             showDeepSpace = settingsRepo.passesSettings.value.showDeepSpace,
-            modes = settingsRepo.passesSettings.value.selectedModes,
+            modes = settingsRepo.selectedSatModes.value,
             shouldSeeWhatsNew = settingsRepo.otherSettings.value.shouldSeeWhatsNew
         )
     )
@@ -64,55 +77,136 @@ class PassesViewModel(
                 _uiState.update { it.copy(isRefreshing = calculating) }
             }
         }
-        // Local tick loop — computes pass progress and countdown timer every second
-        viewModelScope.launch {
-            while (isActive) {
-                val timeNow = System.currentTimeMillis()
-                val showDeepSpace = _uiState.value.showDeepSpace
-                val allPasses = satelliteRepo.passes.value
-                val filtered = if (showDeepSpace) allPasses else allPasses.filter { !it.isDeepSpace }
-                val processed = computePassProgress(filtered, timeNow)
-                val (nextPass, nextTime, isAos) = resolveNextPass(processed, timeNow)
-                _uiState.update {
-                    it.copy(
-                        itemsList = processed,
-                        nextPass = nextPass,
-                        nextTime = nextTime,
-                        isNextTimeAos = isAos
-                    )
-                }
-                delay(1000)
-            }
-        }
+        // 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
+                        shouldSeeWhatsNew = settings.shouldSeeWhatsNew,
+                        lowElevation = settings.lowElevation,
+                        highElevation = settings.highElevation
                     )
                 }
             }
         }
+        viewModelScope.launch {
+            settingsRepo.selectedSatModes.collectLatest { modes ->
+                _uiState.update { it.copy(modes = modes) }
+            }
+        }
+        // Tick loop: restarts on passes change, UTC/DeepSpace changes. Grouping/sun-time
+        // computations run once per restart, progress/countdown are calculated every second.
+        viewModelScope.launch {
+            combine(
+                satelliteRepo.passes,
+                settingsRepo.otherSettings.map { it.stateOfUtc }.distinctUntilChanged(),
+                settingsRepo.passesSettings.map { it.showDeepSpace }.distinctUntilChanged()
+            ) { passes, isUtc, showDeepSpace -> Triple(passes, isUtc, showDeepSpace) }
+                .collectLatest { (allPasses, isUtc, showDeepSpace) ->
+                    val filtered = if (showDeepSpace) allPasses
+                    else allPasses.filter { !it.isDeepSpace }
+                    // Expensive: recompute once per pass-list/UTC change, not every second
+                    val sunTimes = computeSunTimes(filtered, isUtc)
+                    val grouped = groupPasses(filtered, isUtc)
+                    _uiState.update { it.copy(sunTimes = sunTimes, groupedPasses = grouped) }
+                    while (isActive) {
+                        val timeNow = System.currentTimeMillis()
+                        val processed = computePassProgress(filtered, timeNow)
+                        val (nextPass, nextTime, isAos) = resolveNextPass(processed, timeNow)
+                        _uiState.update {
+                            it.copy(
+                                itemsList = processed,
+                                nextPass = nextPass,
+                                nextTime = nextTime,
+                                isNextTimeAos = isAos
+                            )
+                        }
+                        delay(1000.milliseconds)
+                    }
+                }
+        }
     }
 
     fun onAction(action: PassesAction) {
         when (action) {
             PassesAction.DismissWhatsNew -> settingsRepo.setWhatsNewDismissed()
             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)
+                applyFilter(
+                    hoursAhead = action.hoursAhead,
+                    minElevation = action.minElevation,
+                    lowElevation = action.lowElevation,
+                    highElevation = action.highElevation,
+                    aosStartMinute = action.aosStartMinute,
+                    aosEndMinute = action.aosEndMinute,
+                    invertAosTimeWindow = action.invertAosTimeWindow,
+                    showDeepSpace = action.showDeepSpace
+                )
+            is PassesAction.FilterRadios -> setModesFilter(action.modes)
             PassesAction.RefreshPasses -> refreshPasses()
             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 displayLocale(): Locale {
+        val locale = Locale.getDefault()
+        return if (locale.language == Locale.CHINESE.language) locale else Locale.ENGLISH
+    }
+
+    /** Returns the visible pass-date format. Keep non-Chinese locales identical to upstream. */
+    private fun dateFormat(tz: TimeZone): SimpleDateFormat {
+        val locale = displayLocale()
+        val pattern = if (locale.language == Locale.CHINESE.language) {
+            "yyyy'年'M'月'd'日' EEEE"
+        } else {
+            "EEE, dd MMM yyyy"
+        }
+        return SimpleDateFormat(pattern, locale).also { it.timeZone = tz }
+    }
+
+    // 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 = dateFormat(tz)
+        val sdfTime = SimpleDateFormat("HH:mm", displayLocale()).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 = dateFormat(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)
@@ -153,27 +247,82 @@ class PassesViewModel(
     private fun applyFilter(
         hoursAhead: Int,
         minElevation: Double,
-        showDeepSpace: Boolean,
-        modes: List<String>
+        lowElevation: Double,
+        highElevation: Double,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean,
+        showDeepSpace: Boolean
     ) = viewModelScope.launch {
-        settingsRepo.setPassesSettings(PassesSettings(showDeepSpace, hoursAhead, minElevation, modes))
+        settingsRepo.setPassesSettings(
+            PassesSettings(
+                showDeepSpace,
+                hoursAhead,
+                minElevation,
+                aosStartMinute,
+                aosEndMinute,
+                invertAosTimeWindow
+            )
+        )
+        settingsRepo.updateOtherSettings { it.copy(lowElevation = lowElevation, highElevation = highElevation) }
         _uiState.update {
-            it.copy(hours = hoursAhead, elevation = minElevation, showDeepSpace = showDeepSpace, modes = modes)
+            it.copy(
+                hours = hoursAhead,
+                elevation = minElevation,
+                lowElevation = lowElevation,
+                highElevation = highElevation,
+                aosStartMinute = aosStartMinute,
+                aosEndMinute = aosEndMinute,
+                invertAosTimeWindow = invertAosTimeWindow,
+                showDeepSpace = showDeepSpace
+            )
         }
-        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
+        val modes = settingsRepo.selectedSatModes.value
+        satelliteRepo.calculatePasses(
+            time = System.currentTimeMillis(),
+            hoursAhead = hoursAhead,
+            minElevation = minElevation,
+            aosStartMinute = aosStartMinute,
+            aosEndMinute = aosEndMinute,
+            invertAosTimeWindow = invertAosTimeWindow,
+            modes = modes
+        )
+    }
+
+    private fun setModesFilter(modes: List<String>) = viewModelScope.launch {
+        settingsRepo.setSelectedSatModes(modes)
+        _uiState.update { it.copy(modes = modes) }
+        satelliteRepo.calculatePasses(
+            time = System.currentTimeMillis(),
+            hoursAhead = _uiState.value.hours,
+            minElevation = _uiState.value.elevation,
+            aosStartMinute = _uiState.value.aosStartMinute,
+            aosEndMinute = _uiState.value.aosEndMinute,
+            invertAosTimeWindow = _uiState.value.invertAosTimeWindow,
+            modes = modes
+        )
     }
 
     private fun refreshPasses() = viewModelScope.launch {
-        val (_, hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
-        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
+        val settings = settingsRepo.passesSettings.value
+        satelliteRepo.calculatePasses(
+            time = System.currentTimeMillis(),
+            hoursAhead = settings.hoursAhead,
+            minElevation = settings.minElevation,
+            aosStartMinute = settings.aosStartMinute,
+            aosEndMinute = settings.aosEndMinute,
+            invertAosTimeWindow = settings.invertAosTimeWindow,
+            modes = settingsRepo.selectedSatModes.value
+        )
     }
 
     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
+                )
             }
         }
     }

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarScreen.kt

@@ -17,15 +17,17 @@
  */
 package com.rtbishop.look4sat.feature.radar
 
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.RepeatMode
 import androidx.compose.animation.core.animateFloat
 import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
 import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -33,61 +35,70 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.pager.HorizontalPager
+import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.PrimaryTabRow
+import androidx.compose.material3.Tab
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 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.rotate
 import androidx.compose.ui.keepScreenOn
-import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.core.content.ContextCompat
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
-import com.rtbishop.look4sat.core.domain.model.SatRadio
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
 import com.rtbishop.look4sat.core.domain.utility.toDegrees
 import com.rtbishop.look4sat.core.presentation.EmptyListCard
 import com.rtbishop.look4sat.core.presentation.IconCard
-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.TimerRow
 import com.rtbishop.look4sat.core.presentation.TopBar
+import com.rtbishop.look4sat.core.presentation.formatFrequency
 import com.rtbishop.look4sat.core.presentation.getDefaultPass
-import com.rtbishop.look4sat.core.presentation.infiniteMarquee
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import com.rtbishop.look4sat.core.presentation.layoutPadding
+import kotlinx.coroutines.launch
+
+private enum class RadarPage(val title: String) {
+    Transceivers("Transceivers"),
+    Calculator("Calculator"),
+    Sstv("SSTV")
+}
 
 @Composable
-fun RadarDestination(
-    catNum: Int = 0,
-    aosTime: Long = 0L,
-    navigateUp: () -> Unit,
-    navigateToRadioControl: (Int, Long) -> Unit = { _, _ -> }
-) {
-    val viewModel = viewModel(
-        modelClass = RadarViewModel::class.java,
-        key = "$catNum-$aosTime",
-        factory = RadarViewModel.factory(catNum, aosTime)
-    )
+fun RadarDestination(navigateUp: () -> Unit) {
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val viewModel: RadarViewModel = viewModel(factory = RadarViewModel.factory(container))
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    RadarScreen(uiState, viewModel::onAction, navigateUp, navigateToRadioControl)
+    // Sync actual permission state on every recomposition so it survives screen re-entry
+    val hasPermission = ContextCompat.checkSelfPermission(
+        context, Manifest.permission.RECORD_AUDIO
+    ) == PackageManager.PERMISSION_GRANTED
+    LaunchedEffect(hasPermission) {
+        viewModel.onAction(RadarAction.SstvPermissionResult(hasPermission))
+    }
+    val permissionLauncher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { granted -> viewModel.onAction(RadarAction.SstvPermissionResult(granted)) }
+    RadarScreen(uiState, viewModel::onAction, navigateUp, requestMicPermission = {
+        permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
+    })
 }
 
 @Composable
@@ -95,20 +106,11 @@ private fun RadarScreen(
     uiState: RadarState,
     onAction: (RadarAction) -> Unit,
     navigateUp: () -> Unit,
-    navigateToRadioControl: (Int, Long) -> Unit
+    requestMicPermission: () -> Unit
 ) {
     val upcomingPass = uiState.currentPass ?: getDefaultPass()
-    LaunchedEffect(uiState.isLos) { if (uiState.isLos) navigateUp() }
-
     val addToCalendar: () -> Unit = {
-        uiState.currentPass?.let { pass ->
-            onAction(RadarAction.AddToCalendar(pass.name, pass.aosTime, pass.losTime))
-        }
-    }
-    val openRadioControl: () -> Unit = {
-        uiState.currentPass?.let { pass ->
-            navigateToRadioControl(pass.catNum, pass.aosTime)
-        }
+        uiState.currentPass?.let { onAction(RadarAction.AddToCalendar(it.name, it.aosTime, it.losTime)) }
     }
     Column(
         modifier = Modifier
@@ -119,26 +121,92 @@ private fun RadarScreen(
         val isVertical = isVerticalLayout()
         if (isVertical) {
             TopBar {
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
+                IconCard(action = navigateUp, resId = R.drawable.ic_back)
                 TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
-                IconCard(action = openRadioControl, resId = R.drawable.ic_radios)
+                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
             }
             TopBar { NextPassRow(pass = upcomingPass, isUtc = uiState.isUtc) }
         } else {
             TopBar {
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
+                IconCard(action = navigateUp, resId = R.drawable.ic_back)
                 TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
                 NextPassRow(pass = upcomingPass, modifier = Modifier.weight(1f), isUtc = uiState.isUtc)
-                IconCard(action = openRadioControl, resId = R.drawable.ic_radios)
+                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
             }
         }
         if (isVertical) {
             RadarCard(uiState, Modifier.weight(1f))
-            TransmittersCard(uiState.transmitters, uiState.selectedTransmitterUuid, onAction, Modifier.weight(1f))
+            PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
         } else {
             Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
                 RadarCard(uiState, Modifier.weight(1f))
-                TransmittersCard(uiState.transmitters, uiState.selectedTransmitterUuid, onAction, Modifier.weight(1f))
+                PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
+            }
+        }
+    }
+}
+
+@Composable
+private fun PagerCard(
+    uiState: RadarState,
+    onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val hasCalculatorPage = remember(uiState.transceivers.transmitters) {
+        uiState.transceivers.transmitters.any(DopplerFrequencyCalculator::isNamedLinearTransponder)
+    }
+    val pages = remember(hasCalculatorPage) {
+        buildList {
+            add(RadarPage.Transceivers)
+            if (hasCalculatorPage) add(RadarPage.Calculator)
+            add(RadarPage.Sstv)
+        }
+    }
+    val pagerState = rememberPagerState(pageCount = { pages.size })
+    val coroutineScope = rememberCoroutineScope()
+
+    LaunchedEffect(pages.size) {
+        val lastPage = pages.lastIndex
+        if (pagerState.currentPage > lastPage) pagerState.scrollToPage(lastPage)
+    }
+
+    ElevatedCard(modifier = modifier) {
+        Column(modifier = Modifier.fillMaxSize()) {
+            val selectedTabIndex = pagerState.currentPage.coerceIn(0, pages.lastIndex)
+            PrimaryTabRow(selectedTabIndex = selectedTabIndex) {
+                pages.forEachIndexed { index, page ->
+                    Tab(
+                        selected = selectedTabIndex == index,
+                        onClick = { coroutineScope.launch { pagerState.animateScrollToPage(index) } },
+                        text = { Text(text = page.title, maxLines = 1, overflow = TextOverflow.Ellipsis) }
+                    )
+                }
+            }
+            HorizontalPager(
+                state = pagerState,
+                modifier = Modifier.fillMaxSize()
+            ) { pageIndex ->
+                when (pages[pageIndex]) {
+                    RadarPage.Transceivers -> TransceiversPage(
+                        transceivers = uiState.transceivers.transmitters,
+                        selectedUuid = uiState.transceivers.selectedUuid,
+                        radioControl = uiState.radioControl,
+                        onAction = onAction
+                    )
+                    RadarPage.Calculator -> CalculatorPage(
+                        transceivers = uiState.transceivers.transmitters,
+                        selectedUuid = uiState.transceivers.selectedUuid,
+                        orbitalPos = uiState.orbitalPos,
+                        onAction = onAction
+                    )
+                    RadarPage.Sstv -> SstvPage(
+                        sstv = uiState.sstv,
+                        dopplerFrequency = uiState.transceivers.selectedFrequency?.let { formatFrequency(it) },
+                        onAction = onAction,
+                        requestMicPermission = requestMicPermission
+                    )
+                }
             }
         }
     }
@@ -147,25 +215,26 @@ private fun RadarScreen(
 @Composable
 private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
     val satellitePos = uiState.orbitalPos
-    val borderModifier = if (satellitePos?.aboveHorizon == true && satellitePos.eclipsed) {
-        val infiniteTransition = rememberInfiniteTransition(label = "eclipsedBorder")
-        val borderAlpha by infiniteTransition.animateFloat(
-            initialValue = 1.0f,
-            targetValue = 0.0f,
-            animationSpec = infiniteRepeatable(
-                animation = tween(durationMillis = 1000, delayMillis = 25, easing = LinearEasing),
-                repeatMode = RepeatMode.Reverse
-            ),
-            label = "eclipsedBorderAlpha"
-        )
+    val shouldAnimateBorder = satellitePos?.aboveHorizon == true && satellitePos.eclipsed
+    // Always call these composables unconditionally — conditional composable calls violate
+    // Compose's slot-table stability rules and can crash or produce incorrect state
+    val infiniteTransition = rememberInfiniteTransition(label = "eclipsedBorder")
+    val borderAlpha by infiniteTransition.animateFloat(
+        initialValue = 1.0f,
+        targetValue = 0.0f,
+        animationSpec = infiniteRepeatable(
+            animation = tween(durationMillis = 1000, delayMillis = 25, easing = LinearEasing),
+            repeatMode = RepeatMode.Reverse
+        ),
+        label = "eclipsedBorderAlpha"
+    )
+    val borderModifier = if (shouldAnimateBorder) {
         Modifier.border(
             width = 0.5.dp,
             color = MaterialTheme.colorScheme.primary.copy(alpha = borderAlpha),
             shape = MaterialTheme.shapes.medium
         )
-    } else {
-        Modifier
-    }
+    } else Modifier
     ElevatedCard(modifier = modifier.then(borderModifier)) {
         Box(contentAlignment = Alignment.Center) {
             val position = uiState.orbitalPos
@@ -180,7 +249,10 @@ private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
                     azimElev = uiState.orientationValues,
                     shouldShowSweep = uiState.shouldShowSweep,
                     shouldUseCompass = uiState.shouldUseCompass,
-                    modifier = Modifier.align(Alignment.Center)
+                    shouldFlipRadar = uiState.shouldFlipRadar,
+                    modifier = Modifier.align(Alignment.Center),
+                    sunPosition = uiState.sunPosition,
+                    moonPosition = uiState.moonPosition,
                 )
                 PositionOverlay(position)
             }
@@ -250,181 +322,3 @@ private fun RadarLabel(
         }
     }
 }
-
-@Composable
-private fun TransmittersCard(
-    transmitters: List<SatRadio>,
-    selectedUuid: String?,
-    onAction: (RadarAction) -> Unit,
-    modifier: Modifier = Modifier
-) {
-    ElevatedCard(modifier = modifier) {
-        if (transmitters.isEmpty()) {
-            EmptyTransmittersContent()
-        } else {
-            TransmittersList(
-                transmitters = transmitters,
-                selectedUuid = selectedUuid,
-                onSelect = { uuid ->
-                    if (selectedUuid != null) {
-                        onAction(RadarAction.SelectTransmitter(uuid))
-                    }
-                }
-            )
-        }
-    }
-}
-
-@Composable
-private fun EmptyTransmittersContent() {
-    Box(contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize()) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(24.dp),
-            modifier = Modifier.padding(32.dp)
-        ) {
-            Text(text = """¯\_(ツ)_/¯""", fontSize = 32.sp)
-            Text(
-                text = stringResource(R.string.empty_list_message),
-                fontSize = 21.sp,
-                textAlign = TextAlign.Center
-            )
-            Text(
-                text = stringResource(R.string.radar_no_data),
-                fontSize = 18.sp,
-                textAlign = TextAlign.Center
-            )
-        }
-    }
-}
-
-@Composable
-private fun TransmittersList(
-    transmitters: List<SatRadio>,
-    selectedUuid: String?,
-    onSelect: (String) -> Unit
-) {
-    LazyColumn(modifier = Modifier.fillMaxSize()) {
-        items(items = transmitters, key = { it.uuid }) { radio ->
-            TransmitterItem(
-                radio = radio,
-                isClickable = selectedUuid != null,
-                isSelected = radio.uuid == selectedUuid,
-                onClick = { onSelect(radio.uuid) }
-            )
-        }
-    }
-}
-
-@Preview
-@Composable
-private fun TransmitterItemPreview() {
-    val transmitter = SatRadio(
-        "", "Extremely powerful transmitter", true, 10000000000L, 10000000000L,
-        null, 10000000000L, 10000000000L, "FSK AX.100 Mode 5", true, 0
-    )
-    MainTheme { TransmitterItem(transmitter, isClickable = true, isSelected = true, onClick = {}) }
-}
-
-@Composable
-private fun TransmitterItem(
-    radio: SatRadio,
-    isClickable: Boolean,
-    isSelected: Boolean,
-    onClick: () -> Unit
-) {
-    val title = if (radio.isInverted) "INVERTED: ${radio.info}" else radio.info
-    val fullTitle = "$title - (${radio.downlinkMode ?: "--"}/${radio.uplinkMode ?: "--"})"
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .then(if (isClickable) Modifier.clickable { onClick() } else Modifier)
-    ) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(6.dp),
-            modifier = Modifier
-                .fillMaxWidth()
-                .background(MaterialTheme.colorScheme.surface)
-                .padding(horizontal = 8.dp, vertical = 6.dp)
-        ) {
-            Box {
-                Text(
-                    text = fullTitle,
-                    textAlign = TextAlign.Center,
-                    color = MaterialTheme.colorScheme.onSurface,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 6.dp)
-                        .infiniteMarquee()
-                )
-                if (isSelected) {
-                    Icon(
-                        painter = painterResource(id = R.drawable.ic_radios),
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.primary,
-                        modifier = Modifier.background(color = MaterialTheme.colorScheme.surface)
-                    )
-                }
-            }
-            FrequencyRow(radio = radio, isDownlink = true)
-            FrequencyRow(radio = radio, isDownlink = false)
-        }
-        HorizontalDivider(thickness = 2.dp, color = MaterialTheme.colorScheme.background)
-    }
-}
-
-@Composable
-private fun FrequencyRow(radio: SatRadio, isDownlink: Boolean) {
-    Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
-        val desc = if (isDownlink) stringResource(R.string.radar_downlink)
-        else stringResource(R.string.radar_uplink)
-        Text(
-            text = if (isDownlink) "D:" else "U:",
-            textAlign = TextAlign.Center,
-            fontSize = 18.sp,
-            color = MaterialTheme.colorScheme.onSurface,
-            modifier = Modifier
-                .size(24.dp)
-                .semantics { contentDescription = desc }
-        )
-        FrequencyText(
-            frequency = if (isDownlink) radio.downlinkLow else radio.uplinkLow,
-            modifier = Modifier.weight(1f)
-        )
-        Text(
-            text = "-",
-            textAlign = TextAlign.Center,
-            fontSize = 21.sp,
-            fontWeight = FontWeight.Bold,
-            color = MaterialTheme.colorScheme.primary
-        )
-        FrequencyText(
-            frequency = if (isDownlink) radio.downlinkHigh else radio.uplinkHigh,
-            modifier = Modifier.weight(1f)
-        )
-        Icon(
-            painter = painterResource(id = R.drawable.ic_arrow),
-            tint = MaterialTheme.colorScheme.onSurface,
-            contentDescription = null,
-            modifier = Modifier
-                .rotate(if (isDownlink) 90f else -90f)
-                .size(24.dp)
-        )
-    }
-}
-
-@Composable
-private fun FrequencyText(frequency: Long?, modifier: Modifier = Modifier) {
-    val text = frequency?.let {
-        stringResource(id = R.string.radar_link_low, it / 1000000f)
-    } ?: stringResource(R.string.radar_no_link)
-    Text(
-        text = text,
-        textAlign = TextAlign.Center,
-        fontSize = 21.sp,
-        fontWeight = FontWeight.Bold,
-        color = MaterialTheme.colorScheme.primary,
-        modifier = modifier
-    )
-}

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarState.kt

@@ -18,26 +18,83 @@
 package com.rtbishop.look4sat.feature.radar
 
 import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.CelestialComputer
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.sstv.SstvFrame
+import com.rtbishop.look4sat.core.domain.sstv.SstvQualityMetrics
+
+data class RadioPanelState(
+    val label: String = "",
+    val isConnected: Boolean = false,
+    val frequencyHz: Long? = null,
+    val frequencyDisplay: String = "---",
+    val mode: String? = null
+)
+
+data class RadioControlSubState(
+    val txPanel: RadioPanelState = RadioPanelState("TX (Uplink)"),
+    val rxPanel: RadioPanelState = RadioPanelState("RX (Downlink)"),
+    val selectedTransponderUuid: String? = null,
+    val txBaseFrequencyHz: Long? = null,
+    val ctcssTone: Double? = null,
+    val isTracking: Boolean = false,
+    val errorMessage: String? = null
+)
+
+data class TransceiverSubState(
+    val transmitters: List<SatRadio> = emptyList(),
+    val selectedUuid: String? = null,
+    val selectedFrequency: Long? = null,
+)
 
 data class RadarState(
     val currentPass: OrbitalPass? = null,
     val currentTime: String = "00:00:00",
     val isTimeAos: Boolean = true,
-    val isLos: Boolean = false,
     val isUtc: Boolean = false,
     val orientationValues: Pair<Float, Float> = 0f to 0f,
     val orbitalPos: OrbitalPos? = null,
     val satTrack: List<OrbitalPos> = emptyList(),
     val shouldShowSweep: Boolean = false,
     val shouldUseCompass: Boolean = false,
-    val transmitters: List<SatRadio> = emptyList(),
-    val selectedTransmitterUuid: String? = null,
-    val selectedFrequency: Long? = null
+    val shouldFlipRadar: Boolean = false,
+    val sunPosition: CelestialComputer.SunPosition? = null,
+    val moonPosition: CelestialComputer.MoonPosition? = null,
+    val transceivers: TransceiverSubState = TransceiverSubState(),
+    val radioControl: RadioControlSubState = RadioControlSubState(),
+    val sstv: SstvSubState = SstvSubState()
+)
+
+enum class SstvStatus { Idle, Recording }
+
+data class SstvSubState(
+    val status: SstvStatus = SstvStatus.Idle,
+    val isSaving: Boolean = false,
+    val hasPermission: Boolean = false,
+    val selectedMode: String = "Auto",
+    val supportedModes: List<String> = emptyList(),
+    val currentFrame: SstvFrame? = null,
+    val diagnosticsMetrics: SstvQualityMetrics? = null
 )
 
 sealed interface RadarAction {
     data class AddToCalendar(val name: String, val aosTime: Long, val losTime: Long) : RadarAction
     data class SelectTransmitter(val uuid: String) : RadarAction
+
+    // Radio control actions
+    data class SetTxFrequency(val frequencyHz: Long) : RadarAction
+    data class AdjustTxFrequency(val deltaHz: Long) : RadarAction
+    data class SetCtcssTone(val toneHz: Double?) : RadarAction
+    data object ToggleTracking : RadarAction
+    data object ConnectRadios : RadarAction
+    data object DisconnectRadios : RadarAction
+
+    // SSTV actions
+    data object SstvStartRecording : RadarAction
+    data object SstvStopRecording : RadarAction
+    data object SstvSaveImage : RadarAction
+    data object SstvReset : RadarAction
+    data class SstvSelectMode(val modeName: String) : RadarAction
+    data class SstvPermissionResult(val granted: Boolean) : RadarAction
 }

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarView.kt

@@ -17,6 +17,7 @@
  */
 package com.rtbishop.look4sat.feature.radar
 
+import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.animateFloat
 import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
@@ -32,11 +33,13 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.Path
 import androidx.compose.ui.graphics.PathEffect
 import androidx.compose.ui.graphics.PathMeasure
 import androidx.compose.ui.graphics.ShaderBrush
+import androidx.compose.ui.graphics.ColorFilter
 import androidx.compose.ui.graphics.StampedPathEffectStyle
 import androidx.compose.ui.graphics.SweepGradientShader
 import androidx.compose.ui.graphics.drawscope.DrawScope
@@ -44,20 +47,25 @@ import androidx.compose.ui.graphics.drawscope.Fill
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.drawscope.rotate
 import androidx.compose.ui.graphics.drawscope.translate
+import androidx.compose.ui.graphics.drawscope.withTransform
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.TextMeasurer
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.drawText
 import androidx.compose.ui.text.rememberTextMeasurer
 import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.domain.predict.CelestialComputer
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import com.rtbishop.look4sat.core.domain.predict.PI_2
 import com.rtbishop.look4sat.core.domain.utility.toRadians
+import com.rtbishop.look4sat.core.presentation.R
 import kotlin.math.cos
 import kotlin.math.sin
 
 private const val CIRCLES = 3
 private const val STROKE_WIDTH = 6f
-private const val SWEEP_INCREMENT = 360f / 12f / 60f
+private const val SWEEP_DURATION_MS = 8_000
 
 @Composable
 fun RadarViewCompose(
@@ -66,11 +74,15 @@ fun RadarViewCompose(
     azimElev: Pair<Float, Float>,
     shouldShowSweep: Boolean,
     shouldUseCompass: Boolean,
-    modifier: Modifier = Modifier
+    shouldFlipRadar: Boolean,
+    modifier: Modifier = Modifier,
+    sunPosition: CelestialComputer.SunPosition? = null,
+    moonPosition: CelestialComputer.MoonPosition? = null,
 ) {
-    val radarColor = MaterialTheme.colorScheme.secondary
-    val trackColor = MaterialTheme.colorScheme.primary
     val aimColor = MaterialTheme.colorScheme.error
+    val primaryColor = MaterialTheme.colorScheme.primary
+    val radarColor = MaterialTheme.colorScheme.secondary
+    val sunColor = MaterialTheme.colorScheme.primary
     val animTransition = rememberInfiniteTransition(label = "animScale")
     val animScale by animTransition.animateFloat(
         initialValue = 16f,
@@ -78,31 +90,68 @@ fun RadarViewCompose(
         animationSpec = infiniteRepeatable(tween(1000)),
         label = "animScale"
     )
+    // Drive the sweep from the animation framework to eliminate state mutation inside the draw block
+    val sweepTransition = rememberInfiniteTransition(label = "sweep")
+    val sweepDegrees by sweepTransition.animateFloat(
+        initialValue = 0f,
+        targetValue = 360f,
+        animationSpec = infiniteRepeatable(tween(SWEEP_DURATION_MS, easing = LinearEasing)),
+        label = "sweepDegrees"
+    )
     val measurer = rememberTextMeasurer()
-    var sweepDegrees by remember { mutableFloatStateOf(0f) }
+    val sunPainter = painterResource(R.drawable.ic_sun)
+    val moonPainter = painterResource(R.drawable.ic_moon)
+    // Track path cache — keyed by both canvas size and items reference so it rebuilds
+    // when the satellite track data arrives asynchronously after the first composition
     var cachedRadius by remember { mutableFloatStateOf(0f) }
+    var cachedItemsRef by remember { mutableStateOf<List<OrbitalPos>>(emptyList()) }
+    var cachedSweepColor by remember { mutableStateOf(Color.Unspecified) }
     var trackPath by remember { mutableStateOf(Path()) }
     var trackEffect by remember { mutableStateOf(PathEffect.cornerPathEffect(0f)) }
+    // ShaderBrush is cached to avoid allocating a new GPU shader object every frame
+    var cachedSweepBrush by remember { mutableStateOf<ShaderBrush?>(null) }
 
     Canvas(modifier = modifier.aspectRatio(1f)) {
         val radius = size.minDimension / 2f * 0.95f
-        if (radius != cachedRadius) {
+        // Rebuild track path and sweep brush when canvas size or track data changes
+        if (radius != cachedRadius || items !== cachedItemsRef) {
             trackPath = createTrackPath(items, radius)
             trackEffect = createTrackEffect(trackPath)
+            cachedSweepBrush = makeSweepBrush(center, primaryColor)
             cachedRadius = radius
+            cachedItemsRef = items
+            cachedSweepColor = primaryColor
+        } else if (primaryColor != cachedSweepColor) {
+            // Rebuild brush on theme change without waiting for a size change
+            cachedSweepBrush = makeSweepBrush(center, primaryColor)
+            cachedSweepColor = primaryColor
         }
-        rotate(if (shouldUseCompass) -azimElev.first else 0f) {
-            if (shouldShowSweep) drawSweep(center, sweepDegrees, radius, trackColor)
+        val baseRotation = if (shouldUseCompass) -azimElev.first else 0f
+        val rotation = if (shouldFlipRadar) baseRotation + 180f else baseRotation
+        rotate(rotation) {
+            if (shouldShowSweep) cachedSweepBrush?.let { drawSweep(center, sweepDegrees, radius, it) }
             drawRadar(radius, radarColor)
-            drawElevationLabels(radius, trackColor, measurer)
+            drawElevationLabels(radius, primaryColor, measurer)
             translate(center.x, center.y) {
-                drawTrack(trackPath, trackEffect, aimColor, trackColor)
+                drawTrack(trackPath, trackEffect, aimColor, primaryColor)
                 if (item.elevation > 0) {
-                    drawPosition(item, radius, animScale, trackColor)
+                    drawPosition(item, radius, animScale, primaryColor)
+                }
+                sunPosition?.let { sun ->
+                    if (sun.elevation > 0) drawBodyIcon(sun.azimuth, sun.elevation, radius, sunColor, sunPainter, 52f)
+                }
+                moonPosition?.let { moon ->
+                    if (moon.elevation > 0) drawBodyIcon(
+                        moon.azimuth,
+                        moon.elevation,
+                        radius,
+                        radarColor,
+                        moonPainter,
+                        52f
+                    )
                 }
                 if (shouldUseCompass) drawAim(azimElev.first, azimElev.second, radius, aimColor)
             }
-            sweepDegrees = (sweepDegrees + SWEEP_INCREMENT) % 360f
         }
     }
 }
@@ -147,10 +196,13 @@ private fun DrawScope.drawAim(azim: Float, elev: Float, radius: Float, color: Co
     drawCircle(color, size / 2, pos, style = Stroke(STROKE_WIDTH))
 }
 
-private fun DrawScope.drawSweep(center: Offset, degrees: Float, radius: Float, color: Color) {
+private fun makeSweepBrush(center: Offset, color: Color): ShaderBrush {
     val colors = listOf(Color.Transparent, color.copy(alpha = 0.5f), color)
     val colorStops = listOf(0.64f, 0.995f, 1f)
-    val brush = ShaderBrush(SweepGradientShader(center, colors, colorStops))
+    return ShaderBrush(SweepGradientShader(center, colors, colorStops))
+}
+
+private fun DrawScope.drawSweep(center: Offset, degrees: Float, radius: Float, brush: ShaderBrush) {
     rotate(-90 + degrees, center) { drawCircle(brush, radius, style = Fill) }
 }
 
@@ -180,6 +232,27 @@ private fun createTrackEffect(trackPath: Path): PathEffect {
     return PathEffect.stampedPathEffect(shape, trackLength / 2f, trackLength / 4f, StampedPathEffectStyle.Rotate)
 }
 
+private fun DrawScope.drawBodyIcon(
+    azimDeg: Double,
+    elevDeg: Double,
+    radius: Float,
+    color: Color,
+    painter: Painter,
+    iconSize: Float
+) {
+    val azimRad = azimDeg.toRadians()
+    val elevRad = elevDeg.toRadians()
+    val pos = sph2Cart(azimRad, elevRad, radius.toDouble())
+    val half = iconSize / 2f
+    withTransform({
+        translate(pos.x - half, pos.y - half)
+    }) {
+        with(painter) {
+            draw(Size(iconSize, iconSize), colorFilter = ColorFilter.tint(color))
+        }
+    }
+}
+
 private fun sph2Cart(azim: Double, elev: Double, r: Double): Offset {
     val radius = r * (PI_2 - elev) / PI_2
     return Offset(

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarViewModel.kt

@@ -18,22 +18,31 @@
 package com.rtbishop.look4sat.feature.radar
 
 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.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.CelestialComputer
 import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
-import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+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.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.sstv.LineRecoveryStrategy
+import com.rtbishop.look4sat.core.domain.sstv.SstvDecoder
+import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
+import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import com.rtbishop.look4sat.core.domain.utility.round
 import com.rtbishop.look4sat.core.domain.utility.toDegrees
 import com.rtbishop.look4sat.core.domain.utility.toTimerString
+import com.rtbishop.look4sat.core.presentation.formatFrequency
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -41,86 +50,247 @@ import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
 
 class RadarViewModel(
-    private val catNum: Int,
-    private val aosTime: Long,
     private val bluetoothReporter: IReporter,
     private val networkReporter: IReporter,
     private val satelliteRepo: ISatelliteRepo,
     private val settingsRepo: ISettingsRepo,
     private val sensorsRepo: ISensorsRepo,
-    private val addToCalendar: IAddToCalendar
+    private val addToCalendar: IAddToCalendar,
+    private val trackingService: IRadioTrackingService,
+    private val audioCapture: IAudioCapture,
+    private val saveImage: ISaveImage,
+    private val showToast: IShowToast
 ) : ViewModel() {
 
     private val stationPos = settingsRepo.stationPosition.value
     private val magDeclination = sensorsRepo.getMagDeclination(stationPos)
+    private var compassOffset = settingsRepo.otherSettings.value.radarCompassOffset
+    private var compassOffsetElev = settingsRepo.otherSettings.value.radarCompassOffsetElev
+    private var transponders: List<SatRadio> = emptyList()
+    private var sstvDecoder: SstvDecoder? = null
+    private var sstvRecordingJob: Job? = null
+    private var sensorCollectionJob: Job? = null
+
+    // Celestial positions change slowly, recompute at most once per minute
+    private var lastCelestialUpdateMs = 0L
+    private var cachedSunPos: CelestialComputer.SunPosition? = null
+    private var cachedMoonPos: CelestialComputer.MoonPosition? = null
+
     private val _uiState = MutableStateFlow(
         RadarState(
             isUtc = settingsRepo.otherSettings.value.stateOfUtc,
-            orientationValues = sensorsRepo.orientation.value,
+            orientationValues = sensorsRepo.sensorData.value,
             shouldShowSweep = settingsRepo.otherSettings.value.stateOfSweep,
-            shouldUseCompass = settingsRepo.otherSettings.value.stateOfSensors
+            shouldUseCompass = settingsRepo.otherSettings.value.stateOfSensors,
+            sstv = SstvSubState(selectedMode = settingsRepo.otherSettings.value.sstvMode)
         )
     )
     val uiState: StateFlow<RadarState> = _uiState
 
     init {
-        // Compass sensor collection
-        if (settingsRepo.otherSettings.value.stateOfSensors) {
-            viewModelScope.launch {
-                sensorsRepo.enableSensor()
-                sensorsRepo.orientation.collect { data ->
-                    val orientationValues = (data.first + magDeclination) to data.second
-                    _uiState.update { it.copy(orientationValues = orientationValues) }
-                }
+        collectSettingsChanges()  // also handles initial sensor subscription
+        collectPassAndStartTickLoop()
+        collectRadioTrackingState()
+    }
+
+    // Starts sensor collection if not already running.
+    private fun startSensorCollection() {
+        if (sensorCollectionJob?.isActive == true) return
+        sensorCollectionJob = viewModelScope.launch {
+            sensorsRepo.enableSensor()
+            sensorsRepo.sensorData.collect { data ->
+                val orientationValues =
+                    (data.first + magDeclination + compassOffset) to (data.second + compassOffsetElev)
+                _uiState.update { it.copy(orientationValues = orientationValues) }
             }
         }
-        // React to UTC setting changes
+    }
+
+    // Stops sensor collection and disables the hardware sensor.
+    private fun stopSensorCollection() {
+        sensorCollectionJob?.cancel()
+        sensorCollectionJob = null
+        sensorsRepo.disableSensor()
+    }
+
+    private fun collectSettingsChanges() {
         viewModelScope.launch {
-            settingsRepo.otherSettings.collectLatest { settings ->
-                _uiState.update { it.copy(isUtc = settings.stateOfUtc) }
-            }
-        }
-        // Resolve which pass we're tracking and start the tick loop
-        viewModelScope.launch {
-            val passes = satelliteRepo.passes.value
-            val currentPass = passes.find { it.catNum == catNum && it.aosTime == aosTime }
-                ?: passes.firstOrNull()
-            currentPass?.let { satPass ->
-                _uiState.update { it.copy(currentPass = satPass) }
-                val transmitters = satelliteRepo.getRadiosWithId(satPass.catNum)
-                // Compute track once (it doesn't change for a given pass)
-                if (!satPass.isDeepSpace) {
-                    val track = satelliteRepo.getTrack(
-                        satPass.orbitalObject, stationPos, satPass.aosTime, satPass.losTime
+            settingsRepo.otherSettings.collect { settings ->
+                compassOffset = settings.radarCompassOffset
+                compassOffsetElev = settings.radarCompassOffsetElev
+                _uiState.update {
+                    it.copy(
+                        isUtc = settings.stateOfUtc,
+                        shouldShowSweep = settings.stateOfSweep,
+                        shouldUseCompass = settings.stateOfSensors,
+                        shouldFlipRadar = settings.radarCompassOffsetElev < 0f
                     )
-                    _uiState.update { it.copy(satTrack = track) }
                 }
-                // Tick loop — position, timer, and radio updates every second
-                while (isActive) {
-                    val timeNow = System.currentTimeMillis()
-                    val pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, timeNow)
-                    val (time, isAos) = computeTimer(satPass.isDeepSpace, satPass.aosTime, satPass.losTime, timeNow)
-                    val isLos = !satPass.isDeepSpace && timeNow > satPass.losTime
-                    _uiState.update { it.copy(currentTime = time, isTimeAos = isAos, isLos = isLos, orbitalPos = pos) }
-                    processRadios(transmitters, satPass.orbitalObject, timeNow)
-                    sendPassData(pos)
-                    delay(1000)
+                // Reactively wire sensor hardware to the compass setting
+                when {
+                    settings.stateOfSensors -> startSensorCollection()
+                    else -> stopSensorCollection()
+                }
+            }
+        }
+    }
+
+    // --- Pass loading split into focused functions ---
+
+    private fun collectPassAndStartTickLoop() {
+        viewModelScope.launch {
+            val pass = findCurrentPass() ?: return@launch
+            val allRadios = loadPassData(pass)
+            while (isActive) {
+                tickPass(pass, allRadios)
+                delay(1000.milliseconds)
+            }
+        }
+    }
+
+    private fun findCurrentPass(): OrbitalPass? {
+        val passes = satelliteRepo.passes.value
+        val (catNum, aosTime) = satelliteRepo.selectedPass.value
+        return passes.find { it.catNum == catNum && it.aosTime == aosTime }
+            ?: passes.firstOrNull()
+    }
+
+    // Loads transmitters and satellite track for pass, sets initial state, returns full radio list
+    private suspend fun loadPassData(pass: OrbitalPass): List<SatRadio> {
+        _uiState.update { it.copy(currentPass = pass) }
+        val allRadios = satelliteRepo.getRadiosWithId(pass.catNum)
+        transponders = allRadios.filter { it.downlinkLow != null }
+        if (allRadios.isNotEmpty()) {
+            val firstUuid = allRadios.first().uuid
+            _uiState.update { it.copy(transceivers = it.transceivers.copy(selectedUuid = firstUuid)) }
+            transponders.find { it.uuid == firstUuid }?.let { trackingService.setTransponder(it) }
+        }
+        if (!pass.isDeepSpace) {
+            val track = satelliteRepo.getTrack(pass.orbitalObject, stationPos, pass.aosTime, pass.losTime)
+            _uiState.update { it.copy(satTrack = track) }
+        }
+        return allRadios
+    }
+
+    // --- Per-second tick ---
+
+    private suspend fun tickPass(pass: OrbitalPass, allRadios: List<SatRadio>) {
+        val timeNow = System.currentTimeMillis()
+        val pos = satelliteRepo.getPosition(pass.orbitalObject, stationPos, timeNow)
+
+        // Recompute celestial positions at most once per minute (they move very slowly)
+        if (timeNow - lastCelestialUpdateMs >= 60_000L) {
+            cachedSunPos = CelestialComputer.getSunPosition(stationPos, timeNow)
+            cachedMoonPos = CelestialComputer.getMoonPosition(stationPos, timeNow)
+            lastCelestialUpdateMs = timeNow
+        }
+
+        val (time, isAos) = computeTimer(pass.isDeepSpace, pass.aosTime, pass.losTime, timeNow)
+        _uiState.update {
+            it.copy(
+                currentTime = time, isTimeAos = isAos,
+                orbitalPos = pos, sunPosition = cachedSunPos, moonPosition = cachedMoonPos
+            )
+        }
+        processRadios(allRadios, pass.orbitalObject, timeNow)
+        sendPassData(pos)
+    }
+
+    private fun collectRadioTrackingState() {
+        viewModelScope.launch {
+            trackingService.state.collect { svc ->
+                _uiState.update { state ->
+                    state.copy(
+                        radioControl = state.radioControl.copy(
+                            txPanel = RadioPanelState(
+                                label = "TX (Uplink)",
+                                isConnected = svc.txConnected,
+                                frequencyHz = svc.txFrequencyHz,
+                                frequencyDisplay = svc.txFrequencyHz?.let { formatFrequency(it) } ?: "---",
+                                mode = svc.txMode
+                            ),
+                            rxPanel = RadioPanelState(
+                                label = "RX (Downlink)",
+                                isConnected = svc.rxConnected,
+                                frequencyHz = svc.rxFrequencyHz,
+                                frequencyDisplay = svc.rxFrequencyHz?.let { formatFrequency(it) } ?: "---",
+                                mode = svc.rxMode
+                            ),
+                            txBaseFrequencyHz = svc.txBaseFrequencyHz,
+                            ctcssTone = svc.ctcssTone,
+                            isTracking = svc.isActive,
+                            selectedTransponderUuid = svc.selectedTransponder?.uuid,
+                            errorMessage = svc.errorMessage
+                        )
+                    )
                 }
             }
         }
     }
 
     override fun onCleared() {
-        sensorsRepo.disableSensor()
-        super.onCleared()
+        stopSensorCollection()
     }
 
     fun onAction(action: RadarAction) {
         when (action) {
             is RadarAction.AddToCalendar -> addToCalendar(action.name, action.aosTime, action.losTime)
-            is RadarAction.SelectTransmitter -> _uiState.update { it.copy(selectedTransmitterUuid = action.uuid) }
+            is RadarAction.SelectTransmitter -> {
+                // Compute toggle state before the update so we don't read post-update value
+                val isTogglingOff = _uiState.value.transceivers.selectedUuid == action.uuid
+                val newUuid = if (isTogglingOff) null else action.uuid
+                _uiState.update { it.copy(transceivers = it.transceivers.copy(selectedUuid = newUuid)) }
+                // Only update the tracking service when selecting a different transponder to
+                // avoid resetting a user-adjusted TX base on re-expand
+                if (!isTogglingOff) {
+                    transponders.find { it.uuid == action.uuid }?.let { trackingService.setTransponder(it) }
+                }
+            }
+            is RadarAction.SetTxFrequency -> trackingService.setTxBaseFrequency(action.frequencyHz)
+            is RadarAction.AdjustTxFrequency -> trackingService.adjustTxBaseFrequency(action.deltaHz)
+            is RadarAction.SetCtcssTone -> trackingService.setCtcssTone(action.toneHz)
+            RadarAction.ToggleTracking -> {
+                val svc = trackingService.state.value
+                if (svc.isActive) {
+                    trackingService.stopTracking()
+                } else {
+                    val pass = _uiState.value.currentPass ?: return
+                    val transponder = svc.selectedTransponder ?: return
+                    trackingService.startTracking(pass, transponder, svc.txBaseFrequencyHz)
+                }
+            }
+            RadarAction.ConnectRadios -> viewModelScope.launch { trackingService.connectRadios() }
+            RadarAction.DisconnectRadios -> viewModelScope.launch { trackingService.disconnectRadios() }
+
+            // SSTV actions
+            is RadarAction.SstvPermissionResult -> {
+                _uiState.update { it.copy(sstv = it.sstv.copy(hasPermission = action.granted)) }
+                if (action.granted) initSstvDecoder()
+            }
+            RadarAction.SstvStartRecording -> startSstvRecording()
+            RadarAction.SstvStopRecording -> stopSstvRecording()
+            RadarAction.SstvSaveImage -> {
+                val frame = _uiState.value.sstv.currentFrame ?: return
+                val pixels = frame.imagePixels ?: return
+                _uiState.update { it.copy(sstv = it.sstv.copy(isSaving = true)) }
+                viewModelScope.launch {
+                    saveImage(pixels, frame.imageWidth, frame.imageHeight, frame.modeName)
+                    _uiState.update { it.copy(sstv = it.sstv.copy(isSaving = false)) }
+                    showToast("Image saved")
+                }
+            }
+            is RadarAction.SstvSelectMode -> {
+                sstvDecoder?.lockMode(action.modeName)
+                _uiState.update { it.copy(sstv = it.sstv.copy(selectedMode = action.modeName)) }
+                settingsRepo.updateOtherSettings { it.copy(sstvMode = action.modeName) }
+            }
+            RadarAction.SstvReset -> {
+                sstvDecoder?.clearPixels()
+                _uiState.update { it.copy(sstv = it.sstv.copy(currentFrame = null)) }
+            }
         }
     }
 
@@ -154,13 +324,14 @@ class RadarViewModel(
         frequencyEnabled: Boolean,
         frequencyFormat: String
     ) {
-        if (rotatorEnabled) {
+        // Only send rotator commands when the satellite is above the horizon
+        if (rotatorEnabled && orbitalPos.aboveHorizon) {
             val azimuth = orbitalPos.azimuth.toDegrees().round(2)
             val elevation = orbitalPos.elevation.toDegrees().round(2)
             reporter.reportRotation(rotatorFormat, azimuth, elevation)
         }
         if (frequencyEnabled) {
-            _uiState.value.selectedFrequency?.let { freq ->
+            _uiState.value.transceivers.selectedFrequency?.let { freq ->
                 reporter.reportFrequency(frequencyFormat, freq)
             }
         }
@@ -168,53 +339,133 @@ class RadarViewModel(
 
     private suspend fun processRadios(radios: List<SatRadio>, orbitalObject: OrbitalObject, time: Long) {
         val transmitters = satelliteRepo.getRadios(orbitalObject, stationPos, radios, time)
-        val isFreqEnabled =
-            settingsRepo.rcSettings.value.frequencyState || settingsRepo.rcSettings.value.bluetoothFrequencyState
         _uiState.update { state ->
-            if (!isFreqEnabled) {
-                // Skip update if nothing changed
-                if (state.transmitters == transmitters && state.selectedTransmitterUuid == null && state.selectedFrequency == null) {
-                    return@update state
+            val freq = if (state.transceivers.selectedUuid != null) {
+                val selectedRadio = transmitters.firstOrNull { it.uuid == state.transceivers.selectedUuid }
+                selectedRadio?.let { radio ->
+                    val low = radio.downlinkLow
+                    val high = radio.downlinkHigh
+                    when {
+                        low != null && high != null -> (low + high) / 2
+                        low != null -> low
+                        else -> null
+                    }
                 }
-                return@update state.copy(
-                    transmitters = transmitters,
-                    selectedTransmitterUuid = null,
-                    selectedFrequency = null
-                )
-            }
-            val selectedUuid = state.selectedTransmitterUuid ?: transmitters.firstOrNull()?.uuid
-            val selectedRadio = transmitters.firstOrNull { it.uuid == selectedUuid }
-            val freq = selectedRadio?.let { radio ->
-                val low = radio.downlinkLow
-                val high = radio.downlinkHigh
-                when {
-                    low != null && high != null -> (low + high) / 2
-                    low != null -> low
-                    else -> null
-                }
-            }
-            // Skip update if nothing changed
-            if (state.transmitters == transmitters && state.selectedTransmitterUuid == selectedUuid && state.selectedFrequency == freq) {
+            } else null
+
+            val current = state.transceivers
+            if (current.transmitters == transmitters && current.selectedFrequency == freq) {
                 return@update state
             }
-            state.copy(transmitters = transmitters, selectedTransmitterUuid = selectedUuid, selectedFrequency = freq)
+            state.copy(transceivers = current.copy(transmitters = transmitters, selectedFrequency = freq))
         }
     }
 
+    private fun initSstvDecoder() {
+        if (sstvDecoder == null) {
+            val decoder = SstvDecoder(
+                sampleRate = audioCapture.sampleRate,
+                targetRmsLevel = SSTV_TARGET_RMS,
+                includeScopeData = SSTV_INCLUDE_SCOPE,
+                enableRmsNormalization = SSTV_ENABLE_RMS_NORMALIZATION,
+                preFilterCutoffHz = SSTV_PREFILTER_CUTOFF_HZ,
+                enablePreFilter = SSTV_ENABLE_PREFILTER,
+                enableDiagnosticsHandle = SSTV_ENABLE_DIAGNOSTICS_HANDLE,
+                lineRecoveryStrategy = SSTV_LINE_RECOVERY_STRATEGY
+            )
+            sstvDecoder = decoder
+            decoder.lockMode(_uiState.value.sstv.selectedMode)
+            _uiState.update { it.copy(sstv = it.sstv.copy(supportedModes = decoder.supportedModes)) }
+            viewModelScope.launch {
+                decoder.frames.collect { frame ->
+                    val metrics = decoder.getQualityMetrics()
+                    _uiState.update {
+                        it.copy(sstv = it.sstv.copy(currentFrame = frame, diagnosticsMetrics = metrics))
+                    }
+                }
+            }
+            decoder.getDiagnosticsHandle()?.let { handle ->
+                viewModelScope.launch {
+                    handle.metrics.collectLatest { metrics ->
+                        _uiState.update { it.copy(sstv = it.sstv.copy(diagnosticsMetrics = metrics)) }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun startSstvRecording() {
+        if (sstvRecordingJob?.isActive == true) return
+        initSstvDecoder()
+        _uiState.update { it.copy(sstv = it.sstv.copy(status = SstvStatus.Recording)) }
+        sstvRecordingJob = viewModelScope.launch {
+            audioCapture.audioFlow().collect { buffer ->
+                sstvDecoder?.feedSamples(buffer)
+            }
+        }
+    }
+
+    private fun stopSstvRecording() {
+        sstvRecordingJob?.cancel()
+        sstvRecordingJob = null
+        _uiState.update { it.copy(sstv = it.sstv.copy(status = SstvStatus.Idle)) }
+    }
+
     companion object {
-        fun factory(catNum: Int, aosTime: Long): ViewModelProvider.Factory = viewModelFactory {
-            val applicationKey = ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY
+        // SSTV Decoder Tuning Parameters
+        // ==============================
+        // SSTV_TARGET_RMS: Normalized signal level before FM demodulation.
+        //   - 0.25: Aggressive (original default), amplifies noise; use only for clean inputs
+        //   - 0.35-0.40: RECOMMENDED for typical phone/mic inputs
+        //   - 0.50-0.60: Conservative, best for noisy environments
+        private const val SSTV_TARGET_RMS = 0.45f  // Changed from 0.25 to safer default
+
+        // Enable/disable RMS normalization entirely. Set false for direct receiver outputs.
+        private const val SSTV_ENABLE_RMS_NORMALIZATION = true
+
+        // High-pass pre-filter to remove DC offset and subsonic noise before RMS normalization.
+        // Improves weak signal robustness by cleaning the noise floor estimate.
+        private const val SSTV_PREFILTER_CUTOFF_HZ = 500.0  // Removes everything below 500 Hz
+
+        // Enable pre-filtering. Set false to skip (minimal CPU cost if disabled).
+        private const val SSTV_ENABLE_PREFILTER = true
+
+        // Diagnostics handle can be enabled temporarily to capture field reports.
+        // Interpretation notes for noisy recordings:
+        //   - syncHitRate < 0.30: weak/noisy signal path or mistuned gain
+        //   - predictedLineBursts rising quickly: frequent sync loss and likely vertical collapse
+        //   - maxPredictedStreak > 3 in Robot36 mode: noisy path and synthetic line flooding
+        private const val SSTV_ENABLE_DIAGNOSTICS_HANDLE = false
+
+        // Line recovery policy:
+        //   - Look4SatLimited: caps predicted lines to reduce visible vertical collapse.
+        //   - Robot36Compatible: unlimited predicted lines (legacy Robot36 behavior).
+        // Ask users to compare both if they report line-skipping/compression artifacts.
+        private val SSTV_LINE_RECOVERY_STRATEGY = LineRecoveryStrategy.Robot36Compatible
+
+        // Debug: Return scope visualization in frames (increases per-frame memory usage).
+        private const val SSTV_INCLUDE_SCOPE = false
+
+        val CTCSS_TONES = listOf(
+            67.0, 69.3, 71.9, 74.4, 77.0, 79.7, 82.5, 85.4, 88.5, 91.5,
+            94.8, 97.4, 100.0, 103.5, 107.2, 110.9, 114.8, 118.8, 123.0, 127.3, 131.8, 136.5,
+            141.3, 146.2, 151.4, 156.7, 162.2, 167.9, 173.8, 179.9, 186.2, 192.8, 203.5, 210.7,
+            218.1, 225.7, 233.6, 241.8, 250.3
+        )
+
+        fun factory(container: IMainContainer) = viewModelFactory {
             initializer {
-                val container = (this[applicationKey] as IContainerProvider).getMainContainer()
                 RadarViewModel(
-                    catNum = catNum,
-                    aosTime = aosTime,
                     bluetoothReporter = container.provideBluetoothReporter(),
                     networkReporter = container.provideNetworkReporter(),
                     satelliteRepo = container.satelliteRepo,
                     settingsRepo = container.settingsRepo,
                     sensorsRepo = container.provideSensorsRepo(),
-                    addToCalendar = container.provideAddToCalendar()
+                    addToCalendar = container.provideAddToCalendar(),
+                    trackingService = container.radioTrackingService,
+                    audioCapture = container.provideAudioCapture(),
+                    saveImage = container.provideSaveImage(),
+                    showToast = container.provideShowToast()
                 )
             }
         }

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/SstvPage.kt

@@ -0,0 +1,269 @@
+/*
+ * 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.radar
+
+import android.graphics.Bitmap
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Button
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+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.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.presentation.IconCard
+import com.rtbishop.look4sat.core.presentation.OutlinedText
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+import com.rtbishop.look4sat.core.presentation.infiniteMarquee
+import kotlin.math.roundToInt
+
+@Composable
+internal fun SstvPage(
+    sstv: SstvSubState,
+    dopplerFrequency: String?,
+    onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit
+) {
+    if (!sstv.hasPermission) {
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier.fillMaxSize()
+        ) {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                Text(text = "🎙️", fontSize = 48.sp)
+                Text(
+                    text = "Microphone access needed",
+                    fontSize = 16.sp,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                Button(onClick = requestMicPermission) {
+                    Text("Grant permission")
+                }
+            }
+        }
+        return
+    }
+
+    // Mode selection dialog
+    val showModeDialog = remember { mutableStateOf(false) }
+
+    if (showModeDialog.value) {
+        val allModes = remember(sstv.supportedModes) { listOf("Auto") + sstv.supportedModes }
+        val dismiss = { showModeDialog.value = false }
+        SharedDialog(
+            title = "SSTV Mode",
+            onDismissRequest = dismiss,
+            onAccept = dismiss
+        ) { _ ->
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxHeight(0.7f)
+                    .background(MaterialTheme.colorScheme.background),
+                verticalArrangement = Arrangement.spacedBy(1.dp)
+            ) {
+                items(allModes) { mode ->
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .background(MaterialTheme.colorScheme.surface)
+                            .clickable {
+                                onAction(RadarAction.SstvSelectMode(mode))
+                                showModeDialog.value = false
+                            }
+                    ) {
+                        Text(
+                            text = mode,
+                            fontSize = 16.sp,
+                            fontWeight = FontWeight.Medium,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                            modifier = Modifier
+                                .weight(1f)
+                                .padding(start = 16.dp)
+                        )
+                        RadioButton(
+                            selected = mode == sstv.selectedMode,
+                            onClick = null,
+                            modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    // Main SSTV view — image fills entire area, controls overlay at bottom
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(Color.Black)
+    ) {
+        // Decoded image or placeholder — centered in available space
+        val frame = sstv.currentFrame
+        val pixels = frame?.imagePixels
+        if (pixels != null && frame.imageWidth > 0 && frame.imageHeight > 0) {
+            val bitmap = remember(pixels, frame.imageWidth, frame.imageHeight) {
+                Bitmap.createBitmap(
+                    pixels,
+                    frame.imageWidth,
+                    frame.imageHeight,
+                    Bitmap.Config.ARGB_8888
+                ).asImageBitmap()
+            }
+            Image(
+                bitmap = bitmap,
+                contentDescription = "Decoded SSTV image",
+                contentScale = ContentScale.Fit,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .align(Alignment.Center)
+            )
+        } else {
+            Text(
+                text = if (sstv.status == SstvStatus.Recording) "Listening…" else "No signal",
+                color = MaterialTheme.colorScheme.onSurface,
+                fontSize = 16.sp,
+                modifier = Modifier.align(Alignment.Center)
+            )
+        }
+
+        val qualityText = frame?.let {
+            val syncPct = (it.syncHitRate * 100f).roundToInt()
+            val gainX10 = (it.appliedGain * 10f).roundToInt() / 10f
+            val inputRmsX1000 = (it.inputRms * 1000f).roundToInt() / 1000f
+            val scope = if (it.scopePixels != null) " | Scope ${it.scopeWidth}x${it.scopeHeight}" else ""
+            val complete = if (it.imageComplete) " | Complete" else ""
+            "RMS $inputRmsX1000 | Gain x$gainX10 | Sync $syncPct% | Pred ${it.predictedLineBursts}/${it.maxPredictedStreak} | Err ${it.timingErrorSamples}$scope$complete"
+        } ?: sstv.diagnosticsMetrics?.let {
+            val syncPct = (it.syncHitRate * 100f).roundToInt()
+            "Sync $syncPct% | Pred ${it.predictedLineBursts}/${it.maxPredictedStreak} | Err ${it.timingErrorSamples}"
+        }
+
+        // Bottom control bar — dark, blends with the black canvas
+        Column(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .fillMaxWidth()
+                .padding(horizontal = 8.dp, vertical = 8.dp),
+            verticalArrangement = Arrangement.spacedBy(2.dp)
+        ) {
+            // Doppler-corrected downlink frequency hint
+            OutlinedText(
+                text = dopplerFrequency?.let { "RX: $it Hz" } ?: "No transceiver selected",
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Bold,
+                fillColor = MaterialTheme.colorScheme.primary,
+                outlineColor = MaterialTheme.colorScheme.background,
+                modifier = Modifier.align(Alignment.CenterHorizontally)
+            )
+            if (qualityText != null) {
+                OutlinedText(
+                    text = qualityText,
+                    fontSize = 12.sp,
+                    fillColor = MaterialTheme.colorScheme.onSurface,
+                    outlineColor = MaterialTheme.colorScheme.background,
+                    modifier = Modifier.align(Alignment.CenterHorizontally)
+                )
+            }
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                // Mode button — opens dialog
+                ElevatedCard(
+                    modifier = Modifier.weight(1f).height(48.dp),
+                    onClick = { showModeDialog.value = true },
+                    colors = CardDefaults.elevatedCardColors(
+                        containerColor = MaterialTheme.colorScheme.surface
+                    )
+                ) {
+                    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                        Text(
+                            text = "Mode: ${sstv.selectedMode}",
+                            fontSize = 14.sp,
+                            maxLines = 1,
+                            color = MaterialTheme.colorScheme.onSurface,
+                            modifier = Modifier.infiniteMarquee()
+                        )
+                    }
+                }
+                // Reset button — clears decoder state and image
+                IconCard(
+                    action = { onAction(RadarAction.SstvReset) },
+                    resId = R.drawable.ic_delete
+                )
+                // Save button — always visible, enabled when there are pixels
+                IconCard(
+                    action = { onAction(RadarAction.SstvSaveImage) },
+                    resId = R.drawable.ic_save,
+                    enabled = sstv.currentFrame?.imagePixels != null && !sstv.isSaving
+                )
+                // Record / Stop button
+                val playAction = {
+                    when (sstv.status) {
+                        SstvStatus.Idle -> onAction(RadarAction.SstvStartRecording)
+                        SstvStatus.Recording -> onAction(RadarAction.SstvStopRecording)
+                    }
+                }
+                val playColors = CardDefaults.elevatedCardColors(
+                    containerColor = if (sstv.status == SstvStatus.Recording) MaterialTheme.colorScheme.primary
+                    else MaterialTheme.colorScheme.surface
+                )
+                val playIcon = if (sstv.status == SstvStatus.Recording) R.drawable.ic_pause else R.drawable.ic_play
+                ElevatedCard(modifier = Modifier.size(48.dp), onClick = playAction, colors = playColors) {
+                    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                        Icon(painter = painterResource(playIcon), contentDescription = null)
+                    }
+                }
+            }
+        }
+    }
+}

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/TransceiversPage.kt

@@ -0,0 +1,631 @@
+/*
+ * 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.radar
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.FlowRow
+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.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+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.draw.clip
+import androidx.compose.ui.draw.rotate
+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
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
+import com.rtbishop.look4sat.core.presentation.CardButton
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.formatFrequency
+import com.rtbishop.look4sat.core.presentation.infiniteMarquee
+import java.util.Locale
+import kotlin.time.Duration.Companion.milliseconds
+
+@Composable
+fun TransceiversPage(
+    transceivers: List<SatRadio>,
+    selectedUuid: String?,
+    radioControl: RadioControlSubState,
+    onAction: (RadarAction) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    if (transceivers.isEmpty()) {
+        EmptyTransceiversContent(modifier)
+    } else {
+        val listState = rememberLazyListState()
+        // Snap the expanded item to the top of the visible area
+        LaunchedEffect(selectedUuid) {
+            if (selectedUuid != null) {
+                val index = transceivers.indexOfFirst { it.uuid == selectedUuid }
+                if (index >= 0) {
+                    kotlinx.coroutines.delay(300.milliseconds)
+                    listState.animateScrollToItem(index)
+                }
+            }
+        }
+        LazyColumn(modifier = modifier.fillMaxSize(), state = listState) {
+            itemsIndexed(items = transceivers, key = { _, radio -> radio.uuid }) { _, radio ->
+                val isExpanded = radio.uuid == selectedUuid
+                TransceiverItem(
+                    radio = radio,
+                    isExpanded = isExpanded,
+                    radioControl = radioControl,
+                    onAction = onAction,
+                    onToggle = { onAction(RadarAction.SelectTransmitter(radio.uuid)) }
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun CalculatorPage(
+    transceivers: List<SatRadio>,
+    selectedUuid: String?,
+    orbitalPos: OrbitalPos?,
+    onAction: (RadarAction) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val calculatorTransceivers = remember(transceivers) {
+        transceivers.filter(DopplerFrequencyCalculator::isNamedLinearTransponder)
+    }
+    val selectedTransceiver = remember(calculatorTransceivers, selectedUuid) {
+        calculatorTransceivers.firstOrNull { it.uuid == selectedUuid }
+            ?: calculatorTransceivers.firstOrNull()
+    }
+
+    if (selectedTransceiver == null) {
+        EmptyTransceiversContent(modifier)
+        return
+    }
+
+    LazyColumn(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(8.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp)
+    ) {
+        if (calculatorTransceivers.size > 1) {
+            item {
+                FlowRow(
+                    horizontalArrangement = Arrangement.spacedBy(6.dp),
+                    verticalArrangement = Arrangement.spacedBy(4.dp),
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    calculatorTransceivers.forEach { radio ->
+                        FilterChip(
+                            selected = radio.uuid == selectedTransceiver.uuid,
+                            onClick = {
+                                if (radio.uuid != selectedUuid) onAction(RadarAction.SelectTransmitter(radio.uuid))
+                            },
+                            label = {
+                                Text(
+                                    text = transceiverTitle(radio),
+                                    maxLines = 1,
+                                    overflow = TextOverflow.Ellipsis
+                                )
+                            }
+                        )
+                    }
+                }
+            }
+        }
+
+        item {
+            DopplerCalculatorPanel(
+                transponder = selectedTransceiver,
+                orbitalPos = orbitalPos,
+                modifier = Modifier.fillMaxWidth()
+            )
+        }
+    }
+}
+
+@Composable
+private fun EmptyTransceiversContent(modifier: Modifier = Modifier) {
+    Box(contentAlignment = Alignment.Center, modifier = modifier.fillMaxSize()) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(24.dp),
+            modifier = Modifier.padding(32.dp)
+        ) {
+            Text(text = """¯\_(ツ)_/¯""", fontSize = 32.sp)
+            Text(
+                text = stringResource(R.string.empty_list_message),
+                fontSize = 21.sp,
+                textAlign = TextAlign.Center
+            )
+            Text(
+                text = stringResource(R.string.radar_no_data),
+                fontSize = 18.sp,
+                textAlign = TextAlign.Center
+            )
+        }
+    }
+}
+
+@Composable
+private fun TransceiverItem(
+    radio: SatRadio,
+    isExpanded: Boolean,
+    radioControl: RadioControlSubState,
+    onAction: (RadarAction) -> Unit,
+    onToggle: () -> Unit
+) {
+    val bgColor = if (isExpanded) MaterialTheme.colorScheme.surfaceContainerHighest
+    else MaterialTheme.colorScheme.surface
+
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(bgColor)
+            .clickable(
+                interactionSource = remember { MutableInteractionSource() },
+                indication = null
+            ) { onToggle() }
+    ) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy(4.dp),
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 8.dp, vertical = 6.dp)
+        ) {
+            // Header: [arrow slot] [name - (mode)] [icon slot]
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                // Left icon slot — always reserved
+                Box(
+                    contentAlignment = Alignment.Center,
+                    modifier = Modifier.size(20.dp)
+                ) {
+                    Icon(
+                        painter = painterResource(id = R.drawable.ic_arrow),
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        contentDescription = null,
+                        modifier = Modifier
+                            .size(20.dp)
+                            .rotate(if (isExpanded) 270f else 90f)
+                    )
+                }
+                Text(
+                    text = transceiverTitle(radio),
+                    textAlign = TextAlign.Center,
+                    color = MaterialTheme.colorScheme.onSurface,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    modifier = Modifier
+                        .weight(1f)
+                        .infiniteMarquee()
+                )
+                // Right arrow slot — always reserved
+                val iconTint = if (isExpanded) MaterialTheme.colorScheme.primary
+                else MaterialTheme.colorScheme.outlineVariant
+                Box(
+                    contentAlignment = Alignment.Center,
+                    modifier = Modifier.size(24.dp)
+                ) {
+                    Icon(
+                        painter = painterResource(id = R.drawable.ic_radios),
+                        contentDescription = null,
+                        tint = iconTint,
+                        modifier = Modifier.size(20.dp)
+                    )
+                }
+            }
+
+            // Frequency rows
+            UnifiedFrequencyRow(
+                label = "TX",
+                frequencyLow = radio.uplinkLow,
+                frequencyHigh = radio.uplinkHigh,
+                isConnected = if (isExpanded) radioControl.txPanel.isConnected else null
+            )
+            UnifiedFrequencyRow(
+                label = "RX",
+                frequencyLow = radio.downlinkLow,
+                frequencyHigh = radio.downlinkHigh,
+                isConnected = if (isExpanded) radioControl.rxPanel.isConnected else null
+            )
+        }
+
+        // Expanded CAT control area
+        AnimatedVisibility(
+            visible = isExpanded,
+            enter = expandVertically(),
+            exit = shrinkVertically()
+        ) {
+            ExpandedRadioControl(
+                radio = radio,
+                radioControl = radioControl,
+                onAction = onAction
+            )
+        }
+
+        HorizontalDivider(thickness = 2.dp, color = MaterialTheme.colorScheme.background)
+    }
+}
+
+@Composable
+private fun UnifiedFrequencyRow(
+    label: String,
+    frequencyLow: Long?,
+    frequencyHigh: Long?,
+    isConnected: Boolean?
+) {
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        // TX:/RX: label
+        Text(
+            text = "$label:",
+            fontSize = 14.sp,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.width(24.dp)
+        )
+        // Low frequency
+        FrequencyText(
+            frequency = frequencyLow,
+            modifier = Modifier.weight(1f)
+        )
+        // Dash — always centered
+        Text(
+            text = "–",
+            textAlign = TextAlign.Center,
+            fontSize = 18.sp,
+            fontWeight = FontWeight.Bold,
+            color = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.width(16.dp)
+        )
+        // High frequency
+        FrequencyText(
+            frequency = frequencyHigh,
+            modifier = Modifier.weight(1f)
+        )
+        // Connection dot on the right
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier.width(24.dp)
+        ) {
+            Box(
+                modifier = Modifier
+                    .size(8.dp)
+                    .clip(CircleShape)
+                    .background(
+                        when (isConnected) {
+                            true -> Color(0xFF4CAF50)
+                            false -> Color(0xFFE57373)
+                            null -> MaterialTheme.colorScheme.outlineVariant
+                        }
+                    )
+            )
+        }
+    }
+}
+
+@Composable
+private fun ExpandedRadioControl(
+    radio: SatRadio,
+    radioControl: RadioControlSubState,
+    onAction: (RadarAction) -> Unit
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 8.dp)
+            .padding(bottom = 8.dp),
+        verticalArrangement = Arrangement.spacedBy(6.dp)
+    ) {
+        HorizontalDivider(
+            thickness = 1.dp,
+            color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
+        )
+
+        // Frequency tuner
+        if (radioControl.txBaseFrequencyHz != null) {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.Center,
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    Text(
+                        text = "TX Base: ",
+                        fontSize = 14.sp,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                    Text(
+                        text = "${formatFrequency(radioControl.txBaseFrequencyHz)} MHz",
+                        fontSize = 18.sp,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+                val upLow = radio.uplinkLow
+                val upHigh = radio.uplinkHigh
+                if (upLow != null && upHigh != null && upLow != upHigh) {
+                    Text(
+                        text = "(${formatFrequency(upLow)} – ${formatFrequency(upHigh)})",
+                        fontSize = 12.sp,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+                Spacer(modifier = Modifier.height(4.dp))
+                Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+                    FREQ_ADJUSTMENTS.forEach { (delta, label) ->
+                        CardButton(
+                            onClick = { onAction(RadarAction.AdjustTxFrequency(delta)) },
+                            text = label,
+                            modifier = Modifier.weight(1f)
+                        )
+                    }
+                }
+            }
+        }
+
+        // CTCSS (only for FM uplink)
+        if (radio.uplinkMode?.uppercase() == "FM") {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                Text(
+                    text = "CTCSS",
+                    fontSize = 14.sp,
+                    fontWeight = FontWeight.Medium,
+                    color = MaterialTheme.colorScheme.primary
+                )
+                Spacer(modifier = Modifier.height(4.dp))
+                FlowRow(
+                    horizontalArrangement = Arrangement.spacedBy(2.dp),
+                    maxItemsInEachRow = 5,
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    val chipModifier = Modifier.weight(1f)
+                    FilterChip(
+                        selected = radioControl.ctcssTone == null,
+                        onClick = { onAction(RadarAction.SetCtcssTone(null)) },
+                        label = {
+                            Text(
+                                text = "Off",
+                                fontSize = 12.sp,
+                                textAlign = TextAlign.Center,
+                                modifier = Modifier.fillMaxWidth()
+                            )
+                        },
+                        modifier = chipModifier
+                    )
+                    RadarViewModel.CTCSS_TONES.forEach { tone ->
+                        FilterChip(
+                            selected = radioControl.ctcssTone == tone,
+                            onClick = { onAction(RadarAction.SetCtcssTone(tone)) },
+                            label = {
+                                Text(
+                                    text = String.format(Locale.ENGLISH, "%.1f", tone),
+                                    fontSize = 12.sp,
+                                    textAlign = TextAlign.Center,
+                                    modifier = Modifier.fillMaxWidth()
+                                )
+                            },
+                            modifier = chipModifier
+                        )
+                    }
+                }
+            }
+        }
+
+        // Control buttons
+        Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+            if (!radioControl.txPanel.isConnected && !radioControl.rxPanel.isConnected) {
+                CardButton(
+                    onClick = { onAction(RadarAction.ConnectRadios) },
+                    text = "Connect",
+                    modifier = Modifier.weight(1f)
+                )
+            } else {
+                CardButton(
+                    onClick = { onAction(RadarAction.DisconnectRadios) },
+                    text = "Disconnect",
+                    modifier = Modifier.weight(1f)
+                )
+            }
+            CardButton(
+                onClick = { onAction(RadarAction.ToggleTracking) },
+                text = if (radioControl.isTracking) "Stop" else "Track",
+                modifier = Modifier.weight(1f)
+            )
+        }
+
+        // Error
+        radioControl.errorMessage?.let { msg ->
+            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Center) {
+                Text(text = msg, color = MaterialTheme.colorScheme.error, fontSize = 14.sp)
+            }
+        }
+    }
+}
+
+@Composable
+private fun DopplerCalculatorPanel(
+    transponder: SatRadio,
+    orbitalPos: OrbitalPos?,
+    modifier: Modifier = Modifier
+) {
+    if (orbitalPos == null || !DopplerFrequencyCalculator.isLinearTransponder(transponder)) return
+
+    var txInputMHz by remember(transponder.uuid) { mutableStateOf("") }
+    var rxInputMHz by remember(transponder.uuid) { mutableStateOf("") }
+    var offsetKHz by remember(transponder.uuid) { mutableStateOf("") }
+    var lastEditedBy by remember(transponder.uuid) { mutableStateOf(EditedField.TX) }
+
+    fun offsetHz(text: String): Long = text.toDoubleOrNull()?.let { (it * 1000).toLong() } ?: 0L
+    fun formatHz(hz: Long): String = String.format(Locale.ENGLISH, "%.6f", hz / 1_000_000.0)
+    fun mhzToHz(text: String): Long? = text.toDoubleOrNull()
+        ?.takeIf { it > 0.0 }
+        ?.let { (it * 1_000_000).toLong() }
+
+    fun calculateDownlink(txText: String, offsetText: String): String? {
+        val txHz = mhzToHz(txText) ?: return null
+        return DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+            uplinkHz = txHz,
+            transponder = transponder,
+            orbitalPos = orbitalPos,
+            offsetHz = offsetHz(offsetText)
+        )?.let(::formatHz)
+    }
+
+    fun calculateUplink(rxText: String, offsetText: String): String? {
+        val rxHz = mhzToHz(rxText) ?: return null
+        return DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+            downlinkHz = rxHz,
+            transponder = transponder,
+            orbitalPos = orbitalPos,
+            offsetHz = offsetHz(offsetText)
+        )?.let(::formatHz)
+    }
+
+    LaunchedEffect(orbitalPos, transponder.uuid) {
+        if (lastEditedBy == EditedField.TX) {
+            calculateDownlink(txInputMHz, offsetKHz)?.let { rxInputMHz = it }
+        } else {
+            calculateUplink(rxInputMHz, offsetKHz)?.let { txInputMHz = it }
+        }
+    }
+
+    Column(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(8.dp)
+    ) {
+        OutlinedTextField(
+            value = offsetKHz,
+            onValueChange = { newValue ->
+                offsetKHz = newValue
+                if (lastEditedBy == EditedField.TX) {
+                    calculateDownlink(txInputMHz, newValue)?.let { rxInputMHz = it }
+                } else {
+                    calculateUplink(rxInputMHz, newValue)?.let { txInputMHz = it }
+                }
+            },
+            label = { Text(stringResource(R.string.radar_doppler_offset_hint)) },
+            singleLine = true,
+            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
+            modifier = Modifier.fillMaxWidth()
+        )
+
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            OutlinedTextField(
+                value = txInputMHz,
+                onValueChange = { newValue ->
+                    txInputMHz = newValue
+                    lastEditedBy = EditedField.TX
+                    rxInputMHz = calculateDownlink(newValue, offsetKHz) ?: if (newValue.isEmpty()) "" else rxInputMHz
+                },
+                label = { Text(stringResource(R.string.radar_doppler_tx_hint)) },
+                singleLine = true,
+                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                modifier = Modifier.weight(1f)
+            )
+
+            OutlinedTextField(
+                value = rxInputMHz,
+                onValueChange = { newValue ->
+                    rxInputMHz = newValue
+                    lastEditedBy = EditedField.RX
+                    txInputMHz = calculateUplink(newValue, offsetKHz) ?: if (newValue.isEmpty()) "" else txInputMHz
+                },
+                label = { Text(stringResource(R.string.radar_doppler_rx_hint)) },
+                singleLine = true,
+                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                modifier = Modifier.weight(1f)
+            )
+        }
+    }
+}
+
+private enum class EditedField { TX, RX }
+
+@Composable
+private fun FrequencyText(frequency: Long?, modifier: Modifier = Modifier) {
+    val text = frequency?.let {
+        stringResource(id = R.string.radar_link_low, it / 1000000f)
+    } ?: stringResource(R.string.radar_no_link)
+    Text(
+        text = text,
+        textAlign = TextAlign.Center,
+        fontSize = 18.sp,
+        fontWeight = FontWeight.Bold,
+        color = MaterialTheme.colorScheme.primary,
+        modifier = modifier
+    )
+}
+
+private fun transceiverTitle(radio: SatRadio): String {
+    val title = if (radio.isInverted) "INV: ${radio.info}" else radio.info
+    val mode = "${radio.downlinkMode ?: "--"}/${radio.uplinkMode ?: "--"}"
+    return "$title ($mode)"
+}
+
+private val FREQ_ADJUSTMENTS =
+    listOf(-10_000L to "-10k", -1_000L to "-1k", -100L to "-100", 100L to "+100", 1_000L to "+1k", 10_000L to "+10k")

feature/radiocontrol/build.gradle.kts

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

feature/radiocontrol/src/main/AndroidManifest.xml

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

feature/radiocontrol/src/main/java/com/rtbishop/look4sat/feature/radiocontrol/RadioControlScreen.kt

@@ -1,392 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.feature.radiocontrol
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.FlowRow
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material3.ElevatedCard
-import androidx.compose.material3.FilterChip
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-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.keepScreenOn
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.viewmodel.compose.viewModel
-import com.rtbishop.look4sat.core.domain.model.SatRadio
-import com.rtbishop.look4sat.core.presentation.CardButton
-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.TimerRow
-import com.rtbishop.look4sat.core.presentation.TopBar
-import com.rtbishop.look4sat.core.presentation.getDefaultPass
-import com.rtbishop.look4sat.core.presentation.isVerticalLayout
-import com.rtbishop.look4sat.core.presentation.layoutPadding
-import java.util.Locale
-
-@Composable
-fun RadioControlDestination(catNum: Int = 0, aosTime: Long = 0L, navigateUp: () -> Unit) {
-    val viewModel = viewModel(
-        modelClass = RadioControlViewModel::class.java,
-        key = "$catNum-$aosTime",
-        factory = RadioControlViewModel.factory(catNum, aosTime)
-    )
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    RadioControlScreen(uiState, viewModel::onAction, navigateUp)
-}
-
-@Composable
-private fun RadioControlScreen(
-    uiState: RadioControlState,
-    onAction: (RadioControlAction) -> Unit,
-    navigateUp: () -> Unit
-) {
-    Column(
-        modifier = Modifier
-            .layoutPadding()
-            .keepScreenOn(),
-        verticalArrangement = Arrangement.spacedBy(6.dp)
-    ) {
-        val currentPass = uiState.currentPass ?: getDefaultPass()
-        val isVertical = isVerticalLayout()
-        if (isVertical) {
-            TopBar {
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isCurrentTimeAos)
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-            }
-            TopBar { NextPassRow(pass = currentPass) }
-        } else {
-            TopBar {
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isCurrentTimeAos)
-                NextPassRow(pass = currentPass, modifier = Modifier.weight(1f))
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-            }
-        }
-
-        RadioPanel(panel = uiState.txPanel)
-        RadioPanel(panel = uiState.rxPanel)
-
-        PositionRow(
-            azimuth = uiState.azimuth,
-            elevation = uiState.elevation,
-            distance = uiState.distance
-        )
-
-        val selectedTransponder = uiState.transponders.find {
-            it.uuid == uiState.selectedTransponderUuid
-        }
-
-        LazyColumn(
-            modifier = Modifier.weight(1f),
-            verticalArrangement = Arrangement.spacedBy(4.dp)
-        ) {
-            item {
-                TransponderSelector(
-                    transponders = uiState.transponders,
-                    selectedUuid = uiState.selectedTransponderUuid,
-                    onAction = onAction
-                )
-            }
-
-            if (selectedTransponder?.uplinkMode?.uppercase() == "FM") {
-                item {
-                    CtcssSelector(
-                        ctcssTone = uiState.ctcssTone,
-                        onAction = onAction
-                    )
-                }
-            }
-
-            if (uiState.txBaseFrequencyHz != null) {
-                item {
-                    FrequencyTuner(
-                        txBaseFrequencyHz = uiState.txBaseFrequencyHz,
-                        selectedTransponder = selectedTransponder,
-                        onAction = onAction
-                    )
-                }
-            }
-
-            uiState.errorMessage?.let { msg ->
-                item {
-                    Text(
-                        text = msg,
-                        color = MaterialTheme.colorScheme.error,
-                        modifier = Modifier.padding(8.dp)
-                    )
-                }
-            }
-        }
-
-        ControlButtons(
-            isConnected = uiState.txPanel.isConnected || uiState.rxPanel.isConnected,
-            isTracking = uiState.isTracking,
-            onAction = onAction
-        )
-    }
-}
-
-@Composable
-private fun RadioPanel(panel: RadioPanelState) {
-    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
-        Row(
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween,
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 12.dp, vertical = 8.dp)
-        ) {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                Box(
-                    modifier = Modifier
-                        .size(10.dp)
-                        .clip(CircleShape)
-                        .background(if (panel.isConnected) Color(0xFF4CAF50) else Color(0xFFE57373))
-                )
-                Spacer(modifier = Modifier.width(8.dp))
-                Text(text = panel.label, fontSize = 14.sp)
-            }
-            Text(
-                text = panel.frequencyDisplay,
-                fontSize = 24.sp,
-                fontWeight = FontWeight.Bold,
-                color = MaterialTheme.colorScheme.primary
-            )
-            Text(
-                text = panel.mode ?: "--",
-                fontSize = 16.sp,
-                fontWeight = FontWeight.Medium
-            )
-        }
-    }
-}
-
-@Composable
-private fun PositionRow(azimuth: String, elevation: String, distance: String) {
-    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
-        Row(
-            horizontalArrangement = Arrangement.SpaceEvenly,
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(vertical = 6.dp)
-        ) {
-            Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                Text(text = "Az", fontSize = 12.sp)
-                Text(text = "$azimuth°", fontSize = 16.sp, fontWeight = FontWeight.Medium)
-            }
-            Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                Text(text = "El", fontSize = 12.sp)
-                Text(text = "$elevation°", fontSize = 16.sp, fontWeight = FontWeight.Medium)
-            }
-            Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                Text(text = "Dist", fontSize = 12.sp)
-                Text(text = "$distance km", fontSize = 16.sp, fontWeight = FontWeight.Medium)
-            }
-        }
-    }
-}
-
-@Composable
-private fun TransponderSelector(
-    transponders: List<SatRadio>,
-    selectedUuid: String?,
-    onAction: (RadioControlAction) -> Unit
-) {
-    if (transponders.isEmpty()) {
-        ElevatedCard(modifier = Modifier.fillMaxWidth()) {
-            Text(
-                text = "No transponders with uplink+downlink available",
-                textAlign = TextAlign.Center,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp)
-            )
-        }
-        return
-    }
-    Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
-        transponders.forEach { radio ->
-            TransponderItem(
-                radio = radio,
-                isSelected = radio.uuid == selectedUuid,
-                onSelect = { onAction(RadioControlAction.SelectTransponder(radio.uuid)) }
-            )
-        }
-    }
-}
-
-@Composable
-private fun TransponderItem(radio: SatRadio, isSelected: Boolean, onSelect: () -> Unit) {
-    val invLabel = if (radio.isInverted) " INV" else ""
-    val modeLabel = "${radio.uplinkMode ?: "--"}/${radio.downlinkMode ?: "--"}$invLabel"
-    Surface(
-        color = if (isSelected) MaterialTheme.colorScheme.primaryContainer
-        else MaterialTheme.colorScheme.surface,
-        shape = MaterialTheme.shapes.small,
-        modifier = Modifier
-            .fillMaxWidth()
-            .clickable { onSelect() }
-    ) {
-        Row(
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically,
-            modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp)
-        ) {
-            Text(text = radio.info, modifier = Modifier.weight(1f))
-            Text(text = modeLabel, fontSize = 13.sp, fontWeight = FontWeight.Medium)
-        }
-    }
-}
-
-@OptIn(ExperimentalLayoutApi::class)
-@Composable
-private fun CtcssSelector(
-    ctcssTone: Double?,
-    onAction: (RadioControlAction) -> Unit
-) {
-    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
-        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 6.dp)) {
-            Text(text = "CTCSS Tone", color = MaterialTheme.colorScheme.primary)
-            Spacer(modifier = Modifier.height(4.dp))
-            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
-                FilterChip(
-                    selected = ctcssTone == null,
-                    onClick = { onAction(RadioControlAction.SetCtcssTone(null)) },
-                    label = { Text("Off") }
-                )
-                RadioControlViewModel.CTCSS_TONES.forEach { tone ->
-                    FilterChip(
-                        selected = ctcssTone == tone,
-                        onClick = { onAction(RadioControlAction.SetCtcssTone(tone)) },
-                        label = { Text(String.format(Locale.ENGLISH, "%.1f", tone)) }
-                    )
-                }
-            }
-        }
-    }
-}
-
-private val FREQ_ADJUSTMENTS =
-    listOf(-10_000L to "-10k", -1_000L to "-1k", -100L to "-100", 100L to "+100", 1_000L to "+1k", 10_000L to "+10k")
-
-@Composable
-private fun FrequencyTuner(
-    txBaseFrequencyHz: Long,
-    selectedTransponder: SatRadio?,
-    onAction: (RadioControlAction) -> Unit
-) {
-    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            modifier = Modifier.padding(horizontal = 8.dp, vertical = 6.dp)
-        ) {
-            Text(text = "TX Base Frequency", color = MaterialTheme.colorScheme.primary)
-            if (selectedTransponder != null) {
-                val upLow = selectedTransponder.uplinkLow
-                val upHigh = selectedTransponder.uplinkHigh
-                val dnLow = selectedTransponder.downlinkLow
-                val dnHigh = selectedTransponder.downlinkHigh
-                if (upLow != null && upHigh != null && upLow != upHigh) {
-                    Text(
-                        text = "UP: ${RadioControlViewModel.formatFrequency(upLow)} - ${RadioControlViewModel.formatFrequency(upHigh)}",
-                        fontSize = 11.sp,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-                if (dnLow != null && dnHigh != null && dnLow != dnHigh) {
-                    Text(
-                        text = "DN: ${RadioControlViewModel.formatFrequency(dnLow)} - ${RadioControlViewModel.formatFrequency(dnHigh)}",
-                        fontSize = 11.sp,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-            }
-            Spacer(modifier = Modifier.height(4.dp))
-            Text(
-                text = "${RadioControlViewModel.formatFrequency(txBaseFrequencyHz)} MHz",
-                fontSize = 20.sp,
-                fontWeight = FontWeight.Bold,
-                color = MaterialTheme.colorScheme.primary
-            )
-            Spacer(modifier = Modifier.height(4.dp))
-            Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
-                FREQ_ADJUSTMENTS.forEach { (delta, label) ->
-                    CardButton(
-                        onClick = { onAction(RadioControlAction.AdjustTxFrequency(delta)) },
-                        text = label,
-                        modifier = Modifier.weight(1f)
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun ControlButtons(
-    isConnected: Boolean,
-    isTracking: Boolean,
-    onAction: (RadioControlAction) -> Unit
-) {
-    Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-        if (!isConnected) {
-            CardButton(
-                onClick = { onAction(RadioControlAction.ConnectRadios) },
-                text = "Connect",
-                modifier = Modifier.weight(1f)
-            )
-        } else {
-            CardButton(
-                onClick = { onAction(RadioControlAction.DisconnectRadios) },
-                text = "Disconnect",
-                modifier = Modifier.weight(1f)
-            )
-        }
-        CardButton(
-            onClick = { onAction(RadioControlAction.ToggleTracking) },
-            text = if (isTracking) "Stop Tracking" else "Start Tracking",
-            modifier = Modifier.weight(1f)
-        )
-    }
-}

feature/radiocontrol/src/main/java/com/rtbishop/look4sat/feature/radiocontrol/RadioControlState.kt

@@ -1,56 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.feature.radiocontrol
-
-import com.rtbishop.look4sat.core.domain.model.SatRadio
-import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
-
-data class RadioPanelState(
-    val label: String,
-    val isConnected: Boolean,
-    val frequencyHz: Long?,
-    val frequencyDisplay: String,
-    val mode: String?
-)
-
-data class RadioControlState(
-    val currentPass: OrbitalPass?,
-    val currentTime: String,
-    val isCurrentTimeAos: Boolean,
-    val azimuth: String,
-    val elevation: String,
-    val distance: String,
-    val txPanel: RadioPanelState,
-    val rxPanel: RadioPanelState,
-    val transponders: List<SatRadio>,
-    val selectedTransponderUuid: String?,
-    val txBaseFrequencyHz: Long?,
-    val ctcssTone: Double?,
-    val isTracking: Boolean,
-    val errorMessage: String?
-)
-
-sealed interface RadioControlAction {
-    data class SelectTransponder(val uuid: String) : RadioControlAction
-    data class SetTxFrequency(val frequencyHz: Long) : RadioControlAction
-    data class AdjustTxFrequency(val deltaHz: Long) : RadioControlAction
-    data class SetCtcssTone(val toneHz: Double?) : RadioControlAction
-    data object ToggleTracking : RadioControlAction
-    data object ConnectRadios : RadioControlAction
-    data object DisconnectRadios : RadioControlAction
-}