fix: drop armeabi-v7a ABI filter now that the CW module is gone

The ndk abiFilters restriction was added in a333192 ("feat: add CW
decoder and linear calculator page") to accommodate Morse Expert's
32-bit-only libnativedecoderjni.so. Upstream app/build.gradle.kts
contains only the plugins block, so this is fork-specific.

With feature/cw removed, the filter no longer has a reason to exist and
it kept the app 32-bit only — which Google Play has rejected since
2019-08 (64-bit requirement).

Verified after the change:
- ./gradlew assembleDebug -> BUILD SUCCESSFUL
- APK now ships arm64-v8a, armeabi-v7a, x86, x86_64
  (the only remaining .so is androidx.graphics.path, 7 KB)
- ./gradlew test -> 82 tests, 0 failures

.gitignore

@@ -1,6 +1,9 @@
 # Built application files
 *.ap_
 
+# Hermes AI plans and metadata
+.hermes/
+
 # Files for the ART/Dalvik VM
 *.dex
 
@@ -15,6 +18,7 @@ out/
 # Gradle files
 .gradle/
 build/
+.cxx/
 
 # Local configuration file (sdk path, etc)
 local.properties
@@ -64,3 +68,4 @@ fastlane/readme.md
 /app/release/output-metadata.json
 /app/release/
 /.kotlin/sessions/
+dist/

README.md

@@ -1,45 +1,38 @@
-# Look4Sat: Satellite tracker
+# Look4Sat-BA7OPF
 
-[![Look4Sat CI](https://github.com/rt-bishop/Look4Sat/actions/workflows/release.yml/badge.svg)](https://github.com/rt-bishop/Look4Sat/actions/workflows/release.yml)
+[![Release](https://img.shields.io/github/v/release/atsunatsu/Look4Sat)](https://github.com/atsunatsu/Look4Sat/releases)
 
-[<img src="https://play.google.com/intl/en_gb/badges/static/images/badges/en_badge_web_generic.png" alt="Get it on Google Play" height="80">](https://play.google.com/store/apps/details?id=com.rtbishop.look4sat)
-[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="80">](https://f-droid.org/packages/com.rtbishop.look4sat/)
+**BA7OPF 定制版** — 基于 [rt-bishop/Look4Sat](https://github.com/rt-bishop/Look4Sat) 的业余无线电卫星追踪器，增加了线性卫星频率计算器等功能。
 
-### Radio satellite tracker and pass predictor for Android, inspired by Gpredict
+## 本仓库特色功能
 
-<p float="left">
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/1.png" width="192"/>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/2.png" width="192"/>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/3.png" width="192"/>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/4.png" width="192">
-</p>
+- **双站过境匹配（Mutual Pass）** — 输入友台经纬度/网格，筛选双方同时可见的卫星过境，在地图上同时显示双方仰角曲线和地面轨迹，支持一键跳转雷达页查看详情
+- **线性卫星转发器频率计算器** — 在雷达页的 Calculator 标签页中，支持 TX/RX 双向多普勒频率计算，以及下行频率偏移（offset）输入，方便操作带偏移的线性卫星
+- **CW 解码器** — 集成 Morse Expert 解码引擎，支持瀑布图、实时解码文本
+- **Passband 模式** — 支持通过位置滑块（Passband）自动计算 TX/RX 频率，避免切换时跳变
+- **AMSAT 状态页** — 实时查看卫星的业余无线电转发器状态（开启/关闭/待机），支持 72 小时历史记录回放
+- **中文界面优化** — 翻译修正、UI 布局调整，系统语言自动切换
 
-### Track satellite passes with ease!
+## 上游仓库
 
-Thanks to [Celestrak](https://celestrak.com/) and [SatNOGS](https://satnogs.org/) you have access to over 9000 active satellites.\
-You can search the entire database by NORAD Catalog Number or the satellite's name.
+本仓库是 [rt-bishop/Look4Sat](https://github.com/rt-bishop/Look4Sat) 的分支，上游仓库的原始功能包括：
 
-Orbital positions and passes are calculated relative to your location.\
-To get reliable data make sure to set the station position via the app Settings.
+- 基于 Celestrak / SatNOGS 数据的 9000+ 活跃卫星追踪
+- SGP4/SDP4 轨道预测，10 天过境预报
+- 极坐标雷达图、地面轨迹图
+- SSTV 图像解码
+- 无广告、无跟踪、完全离线
 
-The application is built using Kotlin, Coroutines, Jetpack Compose and Navigation.\
-It is now and always will be completely ad-free and open-source.
+## 许可证
 
-## Main features:
-
-*  Predicting satellite positions and passes for up to 10 days
-*  Showing the list of currently active and upcoming satellite passes
-*  Showing the active pass progress, polar trajectory and transceivers info
-*  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.
+GNU General Public License v3.0。详见 [LICENSE](LICENSE)。
 
 ## Star History
 
-<a href="https://www.star-history.com/?repos=rt-bishop%2FLook4Sat&type=timeline&legend=top-left">
+<a href="https://star-history.dera.page/#atsunatsu/Look4Sat&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" />
+   <source media="(prefers-color-scheme: dark)" srcset="https://star-history.dera.page/svg?repos=atsunatsu/Look4Sat&type=timeline&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://star-history.dera.page/svg?repos=atsunatsu/Look4Sat&type=timeline&legend=top-left" />
+   <img alt="Star History Chart" src="https://star-history.dera.page/svg?repos=atsunatsu/Look4Sat&type=timeline&legend=top-left" />
  </picture>
 </a>

app/build.gradle.kts

@@ -1,3 +1,23 @@
 plugins {
     alias(libs.plugins.convention.applicationPlugin)
 }
+
+android {
+    namespace = libs.versions.packageName.get()
+    defaultConfig {
+        applicationId = "cn.ba7opf.look4sat"
+    }
+    signingConfigs {
+        create("release") {
+            storeFile = file(System.getProperty("user.home") + "/my-release-key.jks")
+            storePassword = "look4sat123"
+            keyAlias = "look4sat"
+            keyPassword = "look4sat123"
+        }
+    }
+    buildTypes {
+        release {
+            signingConfig = signingConfigs.getByName("release")
+        }
+    }
+}

app/src/main/AndroidManifest.xml

@@ -19,11 +19,13 @@
         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
             android:name=".MainActivity"
             android:exported="true"
+            android:screenOrientation="portrait"
             android:theme="@style/Theme.Look4Sat.SplashScreen">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

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

@@ -49,7 +49,7 @@ class MainActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         observeNightFilterState()
         setContent {
-            MainTheme(isDarkTheme = true) { MainScreen() }
+            MainTheme(isDarkTheme = true) { NavRoot() }
         }
     }
 

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

@@ -17,7 +17,10 @@
  */
 package com.rtbishop.look4sat
 
+import android.app.Activity
 import android.app.Application
+import android.app.Application.ActivityLifecycleCallbacks
+import android.os.Bundle
 import com.rtbishop.look4sat.core.data.injection.MainContainer
 import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
@@ -35,12 +38,37 @@ class MainApplication : Application(), IContainerProvider {
     override fun onCreate() {
         super.onCreate()
         container = MainContainer(this)
+        clearAmSatCacheOnAppBackground()
         // trigger automatic update every 48 hours
         container.appScope.launch { checkAutoUpdate() }
         // load satellite data on every app start
         container.appScope.launch { container.satelliteRepo.initRepository() }
     }
 
+    private fun clearAmSatCacheOnAppBackground() {
+        registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
+            private var startedActivityCount = 0
+
+            override fun onActivityStarted(activity: Activity) {
+                if (startedActivityCount == 0) {
+                    container.appScope.launch { container.amSatRepo.prefetchStatus() }
+                }
+                startedActivityCount += 1
+            }
+
+            override fun onActivityStopped(activity: Activity) {
+                startedActivityCount = (startedActivityCount - 1).coerceAtLeast(0)
+                if (startedActivityCount == 0) container.amSatRepo.clearStatusCache()
+            }
+
+            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+            override fun onActivityResumed(activity: Activity) = Unit
+            override fun onActivityPaused(activity: Activity) = Unit
+            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+            override fun onActivityDestroyed(activity: Activity) = Unit
+        })
+    }
+
     private suspend fun checkAutoUpdate(timeNow: Long = System.currentTimeMillis()) {
         if (container.settingsRepo.otherSettings.value.stateOfAutoUpdate) {
             val timeDelta = timeNow - container.settingsRepo.databaseState.value.updateTimestamp

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

@@ -25,8 +25,6 @@ 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
@@ -44,14 +42,18 @@ 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.Surface
 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.runtime.mutableIntStateOf
+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
@@ -62,54 +64,77 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.lifecycle.ViewModelStoreOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
 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.domain.repository.MutualPassData
 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.mutual.MutualScreen
+import com.rtbishop.look4sat.feature.mutual.MutualViewModel
 import com.rtbishop.look4sat.feature.passes.PassesDestination
 import com.rtbishop.look4sat.feature.radar.RadarDestination
 import com.rtbishop.look4sat.feature.satellites.SatellitesDestination
 import com.rtbishop.look4sat.feature.settings.SettingsDestination
+import com.rtbishop.look4sat.feature.status.SatStatusDestination
 
 @Composable
 fun NavRoot(deeplink: String? = null) {
     val rootBackStack = rememberNavBackStack(Screen.Passes)
     val deeplinkResolver = DeeplinkResolver()
+    var openMapRequest by remember { mutableIntStateOf(0) }
     LaunchedEffect(deeplink) {
-        deeplink?.let {
-            val destination = deeplinkResolver.resolve(it) // rootBackStack.clear()
-            rootBackStack.add(destination)
-        }
+        deeplink?.let { rootBackStack.add(deeplinkResolver.resolve(it)) }
     }
     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 })
+    val navigateToRadar: () -> Unit = { rootBackStack.add(RadarDestination) }
+    val navigateToMap: () -> Unit = {
+        while (rootBackStack.size > 1) rootBackStack.removeAt(rootBackStack.size - 1)
+        openMapRequest += 1
+    }
+    // Incoming screen slides in from the right, outgoing drifts left at 1/3 speed (API35+ style)
+    val pushTransition = slideInHorizontally(tween(300)) { it } togetherWith
+        slideOutHorizontally(tween(300)) { -it / 3 }
+    // Reverse: outgoing slides out to the right, incoming drifts in from the left
+    val popTransition = slideInHorizontally(tween(300)) { -it / 3 } togetherWith
+        slideOutHorizontally(tween(300)) { it }
     NavDisplay(
         modifier = Modifier.fillMaxSize(),
         backStack = rootBackStack,
         onBack = navigateBack,
-        transitionSpec = { slideInTransition },
-        popTransitionSpec = { slideOutTransition },
-        predictivePopTransitionSpec = { slideOutTransition },
+        transitionSpec = { pushTransition },
+        popTransitionSpec = { popTransition },
+        predictivePopTransitionSpec = { popTransition },
         entryDecorators = listOf(
-            rememberSaveableStateHolderNavEntryDecorator(), // Required for saving Compose state per entry
-            rememberViewModelStoreNavEntryDecorator() // Required for ViewModel scoping per entry
+            rememberSaveableStateHolderNavEntryDecorator(),
+            rememberViewModelStoreNavEntryDecorator()
         ),
         entryProvider = entryProvider {
-            entry<Screen.Passes> { MainScreen(navigateToRadar = { rootBackStack.add(RadarDestination) }) }
+            entry<Screen.Passes> {
+                MainScreen(
+                    navigateToRadar = navigateToRadar,
+                    openMapRequest = openMapRequest,
+                    onOpenMapRequestHandled = { openMapRequest = 0 }
+                )
+            }
             entry<RadarDestination> {
-                Scaffold { innerPadding ->
-                    RadarDestination(navigateUp = navigateBack)
-                    innerPadding.calculateTopPadding()
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background
+                ) {
+                    RadarDestination(navigateUp = navigateBack, navigateToMap = navigateToMap)
                 }
             }
         }
@@ -117,130 +142,170 @@ fun NavRoot(deeplink: String? = null) {
 }
 
 @Composable
-fun MainScreen(navigateToRadar: () -> Unit = {}) {
+fun MainScreen(
+    navigateToRadar: () -> Unit = {},
+    openMapRequest: Int = 0,
+    onOpenMapRequestHandled: () -> Unit = {}
+) {
     val backStack = rememberNavBackStack(Screen.Passes)
     val currentKey = backStack.lastOrNull()
     val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
+    val navigateToMap: () -> Unit = {
+        while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+        backStack.add(Screen.Map)
+    }
+    LaunchedEffect(openMapRequest) {
+        if (openMapRequest > 0) {
+            navigateToMap()
+            onOpenMapRequestHandled()
+        }
+    }
     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.AMSAT, Screen.Mutual, 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()
+    // Activity-scoped so the mutual query results survive navigation to Radar and back
+    val mutualViewModel: MutualViewModel = viewModel(
+        viewModelStoreOwner = context as ViewModelStoreOwner,
+        factory = MutualViewModel.factory(container)
+    )
 
-    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 },
-                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)
+        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.Map -> screen is Screen.Passes
+                        is Screen.AMSAT -> screen is Screen.AMSAT
+                        is Screen.Mutual -> screen is Screen.Mutual
+                        is Screen.Settings -> screen is Screen.Settings
+                        else -> false
                     }
-                    entry<Screen.Passes> {
-                        PassesDestination { catNum, aosTime ->
-                            container.satelliteRepo.selectPass(catNum, aosTime)
-                            backStack.add(Screen.Radar)
-//                            navigateToRadar()
+                    item(
+                        icon = { Icon(painterResource(screen.iconResId), stringResource(screen.titleResId)) },
+                        label = { Text(stringResource(screen.titleResId)) },
+                        selected = isSelected,
+                        onClick = {
+                            if (isSelected && !(currentKey is Screen.Map && screen is Screen.Passes)) return@item
+                            while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+                            if (screen !is Screen.Passes) backStack.add(screen)
                         }
-                    }
-                    entry<Screen.Radar> {
-                        RadarDestination(navigateUp = navigateBack)
-                    }
-                    entry<Screen.Map> {
-                        MapDestination()
-                    }
-                    entry<Screen.Settings> {
-                        SettingsDestination()
-                    }
+                    )
                 }
-            )
-            // Radio tracking status banner
-            if (trackingState.isActive) {
-                val infiniteTransition = rememberInfiniteTransition(label = "trackingPulse")
-                val alpha by infiniteTransition.animateFloat(
-                    initialValue = 1f, targetValue = 0.4f,
-                    animationSpec = infiniteRepeatable(
-                        animation = tween(1000, easing = LinearEasing),
-                        repeatMode = RepeatMode.Reverse
-                    ), label = "pulseAlpha"
-                )
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(MaterialTheme.colorScheme.primaryContainer)
-                        .clickable {
-                            val pass = trackingState.currentPass
-                            if (pass != null) {
-                                container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
-                                backStack.add(Screen.Radar)
-                            }
+            },
+            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)
                         }
-                        .padding(horizontal = 12.dp, vertical = 6.dp)
-                ) {
-                    Box(
+                        entry<Screen.Passes> {
+                            PassesDestination(
+                                navigateToRadar = { catNum, aosTime ->
+                                    container.setMutualPassData(MutualPassData())
+                                    container.satelliteRepo.selectPass(catNum, aosTime)
+                                    navigateToRadar()
+                                },
+                                navigateToMap = navigateToMap
+                            )
+                        }
+                        entry<Screen.Map> {
+                            MapDestination()
+                        }
+                        entry<Screen.Mutual> {
+                            MutualScreen(
+                                viewModel = mutualViewModel,
+                                navigateToRadar = { catNum, aosTime, pass ->
+                                    container.setMutualPassData(pass ?: MutualPassData())
+                                    container.satelliteRepo.selectPass(catNum, aosTime)
+                                    navigateToRadar()
+                                }
+                            )
+                        }
+                        entry<Screen.AMSAT> { SatStatusDestination() }
+                        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.setMutualPassData(MutualPassData())
+                                    container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
+                                    navigateToRadar()
+                                }
+                            }
+                            .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

@@ -32,10 +32,12 @@ internal class ApplicationPlugin : Plugin<Project> {
             implementation(project(":core:domain"))
             implementation(project(":core:presentation"))
             implementation(project(":feature:map"))
+            implementation(project(":feature:mutual"))
             implementation(project(":feature:passes"))
             implementation(project(":feature:radar"))
             implementation(project(":feature:satellites"))
             implementation(project(":feature:settings"))
+            implementation(project(":feature:status"))
             implementation(libs.androidx.core.splashscreen)
             implementation(libs.compose.material3.adaptive)
             implementation(libs.compose.navigation3)

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

@@ -17,8 +17,10 @@
  */
 package com.rtbishop.look4sat.core.data.framework
 
+import com.rtbishop.look4sat.core.domain.model.Constants
 import com.rtbishop.look4sat.core.domain.repository.IReporter
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -31,18 +33,30 @@ class NetworkReporter(
     private val rotatorServer: String,
     private val rotatorPort: Int,
     private val frequencyServer: String,
-    private val frequencyPort: Int
+    private val frequencyPort: Int,
+    private val frequencyOffsetHz: Long = 0L
 ) : IReporter {
 
     private val writeMutex = Mutex()
+    private val connectionMutex = Mutex()
+    private val frequencyCommands = Channel<String>(Channel.CONFLATED)
 
     private var rotatorSocket: SocketChannel? = null
     private var rotatorConnected = false
-    private var rotatorConnecting = false
 
     private var frequencySocket: SocketChannel? = null
     private var frequencyConnected = false
-    private var frequencyConnecting = false
+
+    init {
+        // Keep only the latest frequency command to avoid stale backlog and effective lag.
+        reporterScope.launch {
+            for (command in frequencyCommands) {
+                ensureFrequencyConnected()
+                if (!frequencyConnected) continue
+                write(frequencySocket, command) { resetFrequencyConnection() }
+            }
+        }
+    }
 
     override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
         reporterScope.launch {
@@ -53,51 +67,48 @@ class NetworkReporter(
                 .replace($$"$AZ", azimuth.toString())
                 .replace($$"$EL", el.toString())
                 .unescapeControlChars()
-            write(rotatorSocket, command) { rotatorConnected = false }
+            write(rotatorSocket, command) { resetRotatorConnection() }
         }
     }
 
     override fun reportFrequency(format: String, frequency: Long) {
-        reporterScope.launch {
-            ensureFrequencyConnected()
-            if (!frequencyConnected) return@launch
-            val command = format
-                .replace($$"$FREQ", frequency.toString())
-                .unescapeControlChars()
-            write(frequencySocket, command) { frequencyConnected = false }
-        }
+        val clampedOffset = frequencyOffsetHz.coerceIn(
+            Constants.FREQ_OFFSET_MIN_HZ,
+            Constants.FREQ_OFFSET_MAX_HZ
+        )
+        val correctedFreq = frequency.coerceAtLeast(0L).safeAdd(clampedOffset).coerceAtLeast(0L)
+        val command = format
+            .replace($$"$FREQ", correctedFreq.toString())
+            .unescapeControlChars()
+        frequencyCommands.trySend(command)
     }
 
-    private fun ensureRotatorConnected() {
-        if (rotatorConnected || rotatorConnecting || rotatorServer.isBlank()) return
-        reporterScope.launch {
+    private suspend fun ensureRotatorConnected() {
+        connectionMutex.withLock {
+            if (rotatorConnected || rotatorServer.isBlank()) return
             try {
-                rotatorConnecting = true
+                resetRotatorConnection()
                 rotatorSocket = SocketChannel.open(InetSocketAddress(rotatorServer, rotatorPort))
                 rotatorConnected = true
                 println("NetworkReporter: Rotator connected to $rotatorServer:$rotatorPort")
             } catch (e: Exception) {
                 println("NetworkReporter rotator connect error: ${e.message}")
-                rotatorConnected = false
-            } finally {
-                rotatorConnecting = false
+                resetRotatorConnection()
             }
         }
     }
 
-    private fun ensureFrequencyConnected() {
-        if (frequencyConnected || frequencyConnecting || frequencyServer.isBlank()) return
-        reporterScope.launch {
+    private suspend fun ensureFrequencyConnected() {
+        connectionMutex.withLock {
+            if (frequencyConnected || frequencyServer.isBlank()) return
             try {
-                frequencyConnecting = true
+                resetFrequencyConnection()
                 frequencySocket = SocketChannel.open(InetSocketAddress(frequencyServer, frequencyPort))
                 frequencyConnected = true
                 println("NetworkReporter: Frequency connected to $frequencyServer:$frequencyPort")
             } catch (e: Exception) {
                 println("NetworkReporter frequency connect error: ${e.message}")
-                frequencyConnected = false
-            } finally {
-                frequencyConnecting = false
+                resetFrequencyConnection()
             }
         }
     }
@@ -106,7 +117,9 @@ class NetworkReporter(
         try {
             writeMutex.withLock {
                 val buffer = ByteBuffer.wrap("$command\n".toByteArray())
-                socket?.write(buffer)
+                while (buffer.hasRemaining()) {
+                    socket?.write(buffer)
+                }
             }
         } catch (e: Exception) {
             println("NetworkReporter write error: ${e.message}")
@@ -114,6 +127,34 @@ class NetworkReporter(
         }
     }
 
+    private fun resetRotatorConnection() {
+        rotatorConnected = false
+        closeQuietly(rotatorSocket)
+        rotatorSocket = null
+    }
+
+    private fun resetFrequencyConnection() {
+        frequencyConnected = false
+        closeQuietly(frequencySocket)
+        frequencySocket = null
+    }
+
+    private fun closeQuietly(socket: SocketChannel?) {
+        try {
+            socket?.close()
+        } catch (_: Exception) {}
+    }
+
+    private fun Long.safeAdd(delta: Long): Long {
+        return when {
+            delta > 0 && this > Long.MAX_VALUE - delta -> Long.MAX_VALUE
+            delta < 0 && this < Long.MIN_VALUE - delta -> Long.MIN_VALUE
+            else -> this + delta
+        }
+    }
+
     private fun String.unescapeControlChars(): String =
-        replace("\\r", "\r").replace("\\n", "\n").replace("\\t", "\t")
+        replace("""\r""", 13.toChar().toString())
+            .replace("""\n""", 10.toChar().toString())
+            .replace("""\t""", 9.toChar().toString())
 }

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 in Settings") }
-            return
-        }
-
-        val tx = Ft817Controller(bluetoothManager, txAddr)
-        val rx = Ft817Controller(bluetoothManager, rxAddr)
-        txController = tx
-        rxController = rx
-
-        _state.update { it.copy(errorMessage = null) }
-        val txOk = if (txAddr.isNotBlank()) tx.connect() else false
-        val rxOk = if (rxAddr.isNotBlank()) rx.connect() else false
-        _state.update {
-            it.copy(
-                txConnected = txOk,
-                rxConnected = rxOk,
-                errorMessage = when {
-                    !txOk && !rxOk -> "Could not connect to TX and RX radios"
-                    !txOk -> "Could not connect to TX radio ($txAddr)"
-                    !rxOk -> "Could not connect to RX radio ($rxAddr)"
-                    else -> null
-                }
-            )
+        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

@@ -26,8 +26,10 @@ 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.AmSatRepository
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
 import com.rtbishop.look4sat.core.data.repository.SatelliteRepo
 import com.rtbishop.look4sat.core.data.repository.SelectionRepo
@@ -39,6 +41,7 @@ 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
@@ -48,6 +51,7 @@ import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
 import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
@@ -59,22 +63,34 @@ import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import okhttp3.OkHttpClient
 
 class MainContainer(private val context: Context) : IMainContainer {
 
     private val localSource = provideLocalSource()
+    private val remoteSource = provideRemoteSource()
     private val mainHandler = CoroutineExceptionHandler { _, error -> println("MainHandler: $error") }
     override val appScope = CoroutineScope(SupervisorJob() + Dispatchers.Default + mainHandler)
     override val settingsRepo = provideSettingsRepo()
     override val selectionRepo = provideSelectionRepo()
     override val satelliteRepo = provideSatelliteRepo()
     override val databaseRepo = provideDatabaseRepo()
+    override val amSatRepo by lazy { AmSatRepository(remoteSource, appScope) }
     override val radioTrackingService: IRadioTrackingService by lazy {
         val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
         RadioTrackingService(appScope, manager, satelliteRepo, settingsRepo)
     }
 
+    private val _mutualPassData = MutableStateFlow(MutualPassData())
+    override val mutualPassData: StateFlow<MutualPassData> = _mutualPassData.asStateFlow()
+
+    override fun setMutualPassData(data: MutualPassData) {
+        _mutualPassData.value = data
+    }
+
     override fun provideAddToCalendar(): IAddToCalendar = AddToCalendar(context)
 
     override fun provideShowToast(): IShowToast = ShowToast(context)
@@ -101,20 +117,31 @@ class MainContainer(private val context: Context) : IMainContainer {
             rc.rotatorAddress,
             rc.rotatorPort.toIntOrNull() ?: 0,
             rc.frequencyAddress,
-            rc.frequencyPort.toIntOrNull() ?: 0
+            rc.frequencyPort.toIntOrNull() ?: 0,
+            rc.frequencyOffsetHz
         )
     }
 
     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 {

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

@@ -0,0 +1,265 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmitResult
+import com.rtbishop.look4sat.core.domain.model.SatDay
+import com.rtbishop.look4sat.core.domain.model.SatReport
+import com.rtbishop.look4sat.core.domain.model.SatSlot
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+import com.rtbishop.look4sat.core.domain.repository.IAmSatRepository
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+/** One report from the AMSAT API (data layer model). */
+private data class ApiReport(
+    val id: String,
+    val name: String,
+    val callsign: String,
+    val report: String,
+    val gridSquare: String,
+    val reportedTimeUtcSec: Long
+)
+
+/** AMSAT status repository using RemoteSource (Clean Architecture: data layer handles HTTP). */
+class AmSatRepository(
+    private val remoteSource: IRemoteSource,
+    private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+) : IAmSatRepository {
+
+    private val statusCacheMutex = Mutex()
+
+    @Volatile
+    private var statusCache: SatStatusPage? = null
+
+    @Volatile
+    private var statusFetchInFlight: Deferred<SatStatusPage?>? = null
+
+    @Volatile
+    private var cacheGeneration = 0
+
+    private val isoUtcFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+    }
+
+    override fun getCachedStatus(): SatStatusPage? = statusCache
+
+    override suspend fun fetchStatus(forceRefresh: Boolean): SatStatusPage? {
+        if (!forceRefresh) statusCache?.let { return it }
+
+        var cachedPage: SatStatusPage? = null
+        val inFlightFetch = statusCacheMutex.withLock {
+            if (!forceRefresh) {
+                val cached = statusCache
+                if (cached != null) {
+                    cachedPage = cached
+                    return@withLock null
+                }
+            }
+
+            statusFetchInFlight ?: scope.async(Dispatchers.IO) {
+                fetchStatusFromRemote(cacheGeneration)
+            }.also { statusFetchInFlight = it }
+        }
+
+        cachedPage?.let { return it }
+        val fetch = inFlightFetch ?: return null
+        return try {
+            fetch.await()
+        } finally {
+            statusCacheMutex.withLock {
+                if (statusFetchInFlight === fetch && fetch.isCompleted) statusFetchInFlight = null
+            }
+        }
+    }
+
+    private suspend fun fetchStatusFromRemote(generation: Int): SatStatusPage? {
+        val nowSec = System.currentTimeMillis() / 1000
+        val catalogJson = remoteSource.getAmSatCatalog() ?: return null
+        // 72h = 3 days; API hard cap is limit=500 regardless of what we send.
+        // 500 records across ~100 catalog satellites ≈ ~1-5 reports/satellite/day — enough for 3 days.
+        // Upgrade path: paginate or request AMSAT to raise the cap if catalog grows beyond ~200 sats.
+        val reportsJson = remoteSource.getAmSatReports(hours = 72, limit = 500) ?: return null
+
+        val names = parseCatalog(catalogJson)
+        val reports = parseReports(reportsJson)
+
+        if (names.isEmpty() && reports.isEmpty()) return null
+
+        val statuses = buildStatuses(names, reports, nowSec)
+        val reportMap = reports.associate { it.id to toSatReport(it) }
+        return SatStatusPage(System.currentTimeMillis(), statuses, reportMap).also { page ->
+            if (generation == cacheGeneration) statusCache = page
+        }
+    }
+
+    override suspend fun prefetchStatus() {
+        fetchStatus(forceRefresh = false)
+    }
+
+    override fun clearStatusCache() {
+        cacheGeneration += 1
+        statusCache = null
+        statusFetchInFlight = null
+    }
+
+    override suspend fun submitReport(submission: AmSatReportSubmission): AmSatReportSubmitResult = withContext(Dispatchers.IO) {
+        val payload = JSONObject().apply {
+            put("name", submission.name)
+            put("report", submission.report)
+            put("callsign", submission.callsign)
+            put("reported_at", isoUtcFormat.format(Date(submission.reportedAtUtcMillis)))
+            if (submission.gridSquare.isNotBlank()) put("grid_square", submission.gridSquare)
+        }
+        val response = remoteSource.submitAmSatReport(payload.toString())
+            ?: return@withContext AmSatReportSubmitResult(success = false, message = "Network request failed")
+        val (code, body) = response
+        val errorMessage = parseSubmitError(body)
+        return@withContext if (code in 200..299 && errorMessage.isBlank()) {
+            AmSatReportSubmitResult(success = true, reportId = parseSubmitReportId(body))
+        } else {
+            AmSatReportSubmitResult(
+                success = false,
+                message = errorMessage.ifBlank { "HTTP $code" }
+            )
+        }
+    }
+
+    private fun parseSubmitError(json: String): String {
+        return try {
+            JSONObject(json).optJSONObject("error")?.optString("message").orEmpty()
+        } catch (_: Exception) {
+            ""
+        }
+    }
+
+    private fun parseSubmitReportId(json: String): String? {
+        return try {
+            val obj = JSONObject(json)
+            obj.optJSONObject("data")?.optString("id")?.takeIf { it.isNotBlank() }
+                ?: obj.optString("id").takeIf { it.isNotBlank() }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    /** Parse catalog JSON to list of satellite names */
+    private fun parseCatalog(json: String): List<String> {
+        return try {
+            val arr = JSONObject(json).getJSONArray("data")
+            (0 until arr.length()).map { arr.getJSONObject(it).getString("name") }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    /** Parse reports JSON to list of ApiReport domain objects */
+    private fun parseReports(json: String): List<ApiReport> {
+        return try {
+            val arr = JSONObject(json).getJSONArray("data")
+            (0 until arr.length()).mapNotNull { i ->
+                val o = arr.getJSONObject(i)
+                val iso = o.optString("reported_time", "")
+                if (iso.isEmpty()) null else ApiReport(
+                    id = o.optString("id", ""),
+                    name = o.optString("name", ""),
+                    callsign = o.optString("callsign", ""),
+                    report = o.optString("report", ""),
+                    gridSquare = o.optString("grid_square", ""),
+                    reportedTimeUtcSec = parseIsoUtcSec(iso)
+                )
+            }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    /** Parse ISO 8601 UTC timestamp to epoch seconds (e.g., "2026-08-05T07:30:00Z") */
+    private fun parseIsoUtcSec(iso: String): Long {
+        return try {
+            (isoUtcFormat.parse(iso)?.time ?: 0L) / 1000
+        } catch (_: Exception) {
+            0L
+        }
+    }
+
+    /** Build one SatStatus (3 days x 12 slots) per catalog satellite, slotting reports by age. */
+    private fun buildStatuses(names: List<String>, reports: List<ApiReport>, nowSec: Long): List<SatStatus> {
+        val byName = reports.groupBy { it.name }
+        val monthAbbr = arrayOf("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+        val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+        val labels = (0 until 3).map { d ->
+            utc.timeInMillis = (nowSec - d * 86400L) * 1000
+            "${monthAbbr[utc.get(Calendar.MONTH)]} ${utc.get(Calendar.DAY_OF_MONTH)}"
+        }
+        return names.map { name ->
+            val slots = (0 until 36).map { slotIdx ->
+                val slotStart = nowSec - (slotIdx + 1) * 7200L
+                val slotEnd = nowSec - slotIdx * 7200L
+                val inSlot = byName[name].orEmpty().filter { it.reportedTimeUtcSec in slotStart until slotEnd }
+                if (inSlot.isEmpty()) {
+                    SatSlot(statusColor = NO_REPORT_GRAY, count = 0)
+                } else {
+                    val newest = inSlot.maxByOrNull { it.reportedTimeUtcSec }!!
+                    SatSlot(
+                        statusColor = statusColorOf(newest.report),
+                        count = inSlot.size,
+                        reportIds = inSlot.map { it.id }
+                    )
+                }
+            }
+            val days = (0 until 3).map { d ->
+                SatDay(dateLabel = labels[d], slots = slots.subList(d * 12, (d + 1) * 12))
+            }
+            SatStatus(name = name, days = days)
+        }
+    }
+
+    private fun toSatReport(r: ApiReport): SatReport {
+        val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+        cal.timeInMillis = r.reportedTimeUtcSec * 1000
+        val hh = cal.get(Calendar.HOUR_OF_DAY).toString().padStart(2, '0')
+        val mm = cal.get(Calendar.MINUTE).toString().padStart(2, '0')
+        val y = cal.get(Calendar.YEAR)
+        val mo = (cal.get(Calendar.MONTH) + 1).toString().padStart(2, '0')
+        val d = cal.get(Calendar.DAY_OF_MONTH).toString().padStart(2, '0')
+        return SatReport(
+            id = r.id,
+            statusText = r.report,
+            call = r.callsign,
+            grid = r.gridSquare,
+            dateUtc = "$y-$mo-$d",
+            timeUtc = "$hh:$mm UTC"
+        )
+    }
+
+    /** Map status text to color value (for UI rendering). */
+    private fun statusColorOf(report: String): Long = when (report.lowercase()) {
+        "heard", "crew active" -> ACTIVE_BLUE
+        "telemetry only" -> TLM_ORANGE
+        "not heard" -> NOT_HEARD_PINK
+        else -> CONFLICT_DEEP_ORANGE
+    }
+
+    companion object {
+        // AMSAT official status colors (from amsat.org/status)
+        private const val ACTIVE_BLUE = 0xFF648FFF
+        private const val TLM_ORANGE = 0xFFFFB000
+        private const val NOT_HEARD_PINK = 0xFFDC267F
+        private const val CONFLICT_DEEP_ORANGE = 0xFFFE6100
+        private const val NO_REPORT_GRAY = 0xFFC0C0C0
+    }
+}

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

@@ -42,46 +42,53 @@ class DatabaseRepo(
 
     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(unwrapIfZipped(uri, stream))
+            val entries = parseSatelliteStream(uri, unwrapIfZipped(uri, stream))
             localSource.insertEntries(entries)
             settingsRepo.setSatelliteTypeIds(customSourceType, entries.map { it.catnum })
+            importedCount = entries.size
         }
         setUpdateSuccessful(System.currentTimeMillis())
+        importedCount
     }
 
-    override suspend fun updateTransceiversFromFile(uri: String) = withContext(dispatcher) {
+    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(customSourceType, dataSourcesSettings.tleUrl)
-        }.filterValues { it.isNotBlank() }
-        val radioUrls = buildMap {
-            putAll(Sources.transceiversDataUrls)
-            if (dataSourcesSettings.useCustomTransceivers) put(customSourceType, dataSourcesSettings.transceiversUrl)
-        }.filterValues { it.isNotBlank() }
+        val settings = settingsRepo.dataSourcesSettings.value
+        val tleUrls = settings.satelliteUrls.filter { it.isNotBlank() }.map(::normalizeUrl).distinct()
+        val radioUrls = settings.transceiversUrls.filter { it.isNotBlank() }.map(::normalizeUrl).distinct()
+        val builtinTypesByUrl = Sources.satelliteDataUrls
+            .filterValues { it.isNotBlank() }
+            .mapValues { normalizeUrl(it.value) }
+            .entries
+            .associate { (type, url) -> url to type }
+        val importedTypeIds = mutableMapOf<String, MutableList<Int>>()
         // launch all network requests concurrently
-        val tleJobs = tleUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
-        val radioJobs = radioUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
-        // parse fetched data concurrently and associate with types
+        val tleJobs = tleUrls.map { url -> async { url to remoteSource.getNetworkStream(url) } }
+        val radioJobs = radioUrls.map { url -> async { url to remoteSource.getNetworkStream(url) } }
+        // parse fetched data concurrently and associate known built-in URLs with existing type filters.
         val importedEntries = tleJobs.awaitAll().flatMap { (url, stream) ->
-            val type = tleUrls.entries.find { it.value == url }?.key ?: customSourceType
-            stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty().also { entries ->
-                settingsRepo.setSatelliteTypeIds(type, entries.map { it.catnum })
-            }
-        }
+            val entries = stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty()
+            val type = builtinTypesByUrl[url] ?: customSourceType
+            importedTypeIds.getOrPut(type) { mutableListOf() }.addAll(entries.map { it.catnum })
+            entries
+        }.distinctBy { it.catnum }
+        importedTypeIds.forEach { (type, ids) -> settingsRepo.setSatelliteTypeIds(type, ids.distinct()) }
         val importedRadios = radioJobs.awaitAll().flatMap { (url, stream) ->
             stream?.let { dataParser.parseJSONStream(unwrapIfZipped(url, it)) }.orEmpty()
-        }
+        }.filter { it.uuid.isNotBlank() }.distinctBy { it.uuid }
         // insert parsed data into the database
         localSource.insertEntries(importedEntries)
         localSource.insertRadios(importedRadios)
@@ -94,9 +101,34 @@ class DatabaseRepo(
         setUpdateSuccessful(0L)
     }
 
-    private suspend fun parseSatelliteStream(url: String, stream: InputStream): List<OrbitalData> = when {
-        url.contains("FORMAT=csv", ignoreCase = true) -> dataParser.parseCSVStream(stream)
-        else -> dataParser.parseTLEStream(stream)
+    private fun normalizeUrl(url: String): String =
+        if (url.startsWith("http", ignoreCase = true)) url else "https://$url"
+
+    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) {

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

@@ -34,8 +34,10 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
+import java.util.TimeZone
 
 class SatelliteRepo(
     private val dispatcher: CoroutineDispatcher,
@@ -62,11 +64,23 @@ class SatelliteRepo(
     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)
-        }
+        combine(
+            settingsRepo.selectedIds,
+            settingsRepo.stationPosition
+        ) { selectedIds, _ -> selectedIds }
+            .collect { selectedIds ->
+                _satellites.update { localStorage.getEntriesWithIds(selectedIds) }
+                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 = settings.selectedModes
+                )
+            }
     }
 
     override suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos {
@@ -105,7 +119,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
@@ -130,7 +152,12 @@ 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)
                     }
                 }
@@ -142,6 +169,23 @@ class SatelliteRepo(
         _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 >= aosStartMinute || aosMinute <= aosEndMinute
+        }
+        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

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

@@ -37,6 +37,10 @@ import com.rtbishop.look4sat.core.domain.utility.round
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
+import org.json.JSONObject
+import java.util.Locale
+import com.rtbishop.look4sat.core.domain.model.Constants
+import com.rtbishop.look4sat.core.domain.source.Sources
 
 class SettingsRepo(
     private val locationManager: LocationManager,
@@ -54,6 +58,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"
@@ -64,6 +71,7 @@ class SettingsRepo(
     private val keyFrequencyAddress = "frequencyAddress"
     private val keyFrequencyPort = "frequencyPort"
     private val keyFrequencyFormat = "frequencyFormat"
+    private val keyFrequencyOffsetHz = "frequencyOffsetHz"
     private val keySelectedIds = "selectedIds"
     private val keySelectedTypes = "selectedTypes"
     private val keySelectedModes = "selectedModes"
@@ -82,11 +90,19 @@ class SettingsRepo(
     private val keyShouldSeeWarning = "shouldSeeWarning"
     private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew_v$appVersionName"
     private val keySstvMode = "sstvMode"
+    private val keyLowElevation = "lowElevation"
+    private val keyHighElevation = "highElevation"
     private val keyUseCustomTle = "useCustomTle"
     private val keyUseCustomTransceivers = "useCustomTransceivers"
     private val keyTleUrl = "tleUrl"
     private val keyTransceiversUrl = "transceiversUrl"
+    private val keySatelliteUrls = "satelliteUrls"
+    private val keyTransceiversUrls = "transceiversUrls"
+    private val keySatnogsTleSourceMigration = "satnogsTleSourceMigration"
     private val separatorComma = ","
+    private val separatorUrl = "\n"
+    private val legacyCelestrakSatnogsUrl =
+        "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv"
 
     //region # Satellites selection settings
     private val _satelliteSelection = MutableStateFlow(getSelectedIds())
@@ -127,6 +143,9 @@ class SettingsRepo(
         putBoolean(keyFilterShowDeepSpace, settings.showDeepSpace)
         putInt(keyFilterHoursAhead, settings.hoursAhead)
         putLong(keyFilterMinElevation, settings.minElevation.toRawBits())
+        putInt(keyFilterAosStartMinute, settings.aosStartMinute)
+        putInt(keyFilterAosEndMinute, settings.aosEndMinute)
+        putBoolean(keyFilterAosInvert, settings.invertAosTimeWindow)
         putString(keySelectedModes, settings.selectedModes.joinToString(separatorComma))
         _passesSettings.value = settings
     }
@@ -135,9 +154,20 @@ 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 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)
         val selectedModesString = preferences.getString(keySelectedModes, null)
         val selectedModes = selectedModesString?.split(separatorComma)?.sorted() ?: emptyList()
-        return PassesSettings(showDeepSpace, hoursAhead, minElevation, selectedModes)
+        return PassesSettings(
+            showDeepSpace,
+            hoursAhead,
+            minElevation,
+            aosStartMinute,
+            aosEndMinute,
+            invertAosTimeWindow,
+            selectedModes
+        )
     }
     //endregion
 
@@ -279,6 +309,10 @@ class SettingsRepo(
     override val rcSettings: StateFlow<RCSettings> = _rcSettings
 
     override fun updateRCSettings(settings: RCSettings) {
+        val clampedFreqOffsetHz = settings.frequencyOffsetHz.coerceIn(
+            Constants.FREQ_OFFSET_MIN_HZ,
+            Constants.FREQ_OFFSET_MAX_HZ
+        )
         preferences.edit {
             putBoolean(keyRotatorState, settings.rotatorState)
             putString(keyRotatorAddress, settings.rotatorAddress)
@@ -288,6 +322,7 @@ class SettingsRepo(
             putString(keyFrequencyAddress, settings.frequencyAddress)
             putString(keyFrequencyPort, settings.frequencyPort)
             putString(keyFrequencyFormat, settings.frequencyFormat)
+            putLong(keyFrequencyOffsetHz, clampedFreqOffsetHz)
             putBoolean(keyBluetoothRotatorState, settings.bluetoothRotatorState)
             putString(keyBluetoothRotatorFormat, settings.bluetoothRotatorFormat)
             putString(keyBluetoothRotatorName, settings.bluetoothRotatorName)
@@ -296,7 +331,7 @@ class SettingsRepo(
             putString(keyBluetoothFrequencyFormat, settings.bluetoothFrequencyFormat)
             putString(keyBluetoothFrequencyAddress, settings.bluetoothFrequencyAddress)
         }
-        _rcSettings.value = settings
+        _rcSettings.value = settings.copy(frequencyOffsetHz = clampedFreqOffsetHz)
     }
 
     private fun getRCSettings(): RCSettings = RCSettings(
@@ -308,6 +343,8 @@ class SettingsRepo(
         frequencyAddress = preferences.getString(keyFrequencyAddress, null) ?: "127.0.0.1",
         frequencyPort = preferences.getString(keyFrequencyPort, null) ?: "4532",
         frequencyFormat = preferences.getString(keyFrequencyFormat, null) ?: $$"F $FREQ",
+        frequencyOffsetHz = preferences.getLong(keyFrequencyOffsetHz, 0L)
+            .coerceIn(Constants.FREQ_OFFSET_MIN_HZ, Constants.FREQ_OFFSET_MAX_HZ),
         bluetoothRotatorState = preferences.getBoolean(keyBluetoothRotatorState, false),
         bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"P $AZ $EL",
         bluetoothRotatorName = preferences.getString(keyBluetoothRotatorName, null) ?: "Default",
@@ -335,6 +372,8 @@ class SettingsRepo(
                 putBoolean(keyShouldSeeWarning, new.shouldSeeWarning)
                 putBoolean(keyShouldSeeWhatsNew, new.shouldSeeWhatsNew)
                 putString(keySstvMode, new.sstvMode)
+                putLong(keyLowElevation, new.lowElevation.toRawBits())
+                putLong(keyHighElevation, new.highElevation.toRawBits())
             }
             new
         }
@@ -349,7 +388,9 @@ class SettingsRepo(
         stateOfNightMode = preferences.getBoolean(keyStateOfNightMode, false),
         shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
         shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
-        sstvMode = preferences.getString(keySstvMode, null) ?: "Auto"
+        sstvMode = preferences.getString(keySstvMode, null) ?: "Auto",
+        lowElevation = Double.fromBits(preferences.getLong(keyLowElevation, 15.0.toRawBits())),
+        highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits()))
     )
     //endregion
 
@@ -359,20 +400,71 @@ class SettingsRepo(
 
     override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
         preferences.edit {
-            putBoolean(keyUseCustomTle, settings.useCustomTLE)
-            putBoolean(keyUseCustomTransceivers, settings.useCustomTransceivers)
-            putString(keyTleUrl, settings.tleUrl)
-            putString(keyTransceiversUrl, settings.transceiversUrl)
+            putString(keySatelliteUrls, settings.satelliteUrls.joinToString(separatorUrl))
+            putString(keyTransceiversUrls, settings.transceiversUrls.joinToString(separatorUrl))
+            putBoolean(keySatnogsTleSourceMigration, true)
         }
         _dataSourcesSettings.value = settings
     }
 
     private fun getDataSourcesSettings(): DataSourcesSettings = DataSourcesSettings(
-        useCustomTLE = preferences.getBoolean(keyUseCustomTle, false),
-        useCustomTransceivers = preferences.getBoolean(keyUseCustomTransceivers, false),
-        tleUrl = preferences.getString(keyTleUrl, "https://example.com/tle.txt") ?: "",
-        transceiversUrl = preferences.getString(keyTransceiversUrl, "https://example.com/radio.json") ?: ""
+        satelliteUrls = getDataSourceUrls(
+            key = keySatelliteUrls,
+            defaultUrls = Sources.satelliteDataUrls.values.filter { it.isNotBlank() },
+            legacyEnabledKey = keyUseCustomTle,
+            legacyUrlKey = keyTleUrl
+        ).migrateSatnogsTleSource(),
+        transceiversUrls = getDataSourceUrls(
+            key = keyTransceiversUrls,
+            defaultUrls = Sources.transceiversDataUrls.values.filter { it.isNotBlank() },
+            legacyEnabledKey = keyUseCustomTransceivers,
+            legacyUrlKey = keyTransceiversUrl
+        )
     )
+
+    private fun getDataSourceUrls(
+        key: String,
+        defaultUrls: List<String>,
+        legacyEnabledKey: String,
+        legacyUrlKey: String
+    ): List<String> {
+        val stored = preferences.getString(key, null)
+            ?.split(separatorUrl)
+            ?.map { it.trim() }
+            ?.filter { it.isNotBlank() }
+        if (stored != null) return stored
+        val legacyCustomUrl = preferences.getString(legacyUrlKey, null)?.trim().orEmpty()
+        return if (preferences.getBoolean(legacyEnabledKey, false) && legacyCustomUrl.isNotBlank()) {
+            (defaultUrls + legacyCustomUrl).distinct()
+        } else {
+            defaultUrls
+        }
+    }
+
+    private fun List<String>.migrateSatnogsTleSource(): List<String> {
+        if (preferences.getBoolean(keySatnogsTleSourceMigration, false)) return this
+        val satnogsTleUrl = Sources.satelliteDataUrls["SatNOGS"].orEmpty()
+        if (satnogsTleUrl.isBlank() || containsSourceUrl(satnogsTleUrl)) return this
+        val celestrakSatnogsIndex = indexOfFirst { isSameSourceUrl(it, legacyCelestrakSatnogsUrl) }
+        if (celestrakSatnogsIndex < 0) return this
+
+        val migrated = toMutableList().apply { add(celestrakSatnogsIndex + 1, satnogsTleUrl) }
+        preferences.edit {
+            putString(keySatelliteUrls, migrated.joinToString(separatorUrl))
+            putBoolean(keySatnogsTleSourceMigration, true)
+        }
+        return migrated
+    }
+
+    private fun List<String>.containsSourceUrl(url: String): Boolean = any { isSameSourceUrl(it, url) }
+
+    private fun isSameSourceUrl(first: String, second: String): Boolean =
+        normalizeSourceUrl(first).equals(normalizeSourceUrl(second), ignoreCase = true)
+
+    private fun normalizeSourceUrl(url: String): String {
+        val trimmed = url.trim()
+        return if (trimmed.startsWith("http", ignoreCase = true)) trimmed else "https://$trimmed"
+    }
     //endregion
 
     //region # Radio control settings
@@ -383,6 +475,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
@@ -396,18 +489,71 @@ 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
+
+    //region # Per-satellite calculator offset settings
+    private val keySatelliteOffsets = "satelliteOffsets"
+    private val keyLegacySatelliteOffsetPrefix = "offset_khz_"
+
+    override fun getSatelliteOffset(catnum: Int): String {
+        val json = preferences.getString(keySatelliteOffsets, "{}") ?: "{}"
+        val stored = try {
+            JSONObject(json).optString(catnum.toString(), "")
+        } catch (_: Exception) {
+            ""
+        }
+        if (stored.isNotEmpty()) return stored
+
+        // Lazy migration from the fork's old UI-layer implementation, which stored
+        // one SharedPreferences entry per satellite directly from TransceiversPage.
+        val legacyKey = "$keyLegacySatelliteOffsetPrefix$catnum"
+        val legacy = preferences.getString(legacyKey, "").orEmpty()
+        if (legacy.isNotEmpty()) {
+            setSatelliteOffset(catnum, legacy)
+        }
+        return legacy
+    }
+
+    override fun setSatelliteOffset(catnum: Int, offset: String) {
+        val json = preferences.getString(keySatelliteOffsets, "{}") ?: "{}"
+        val updated = try {
+            val obj = JSONObject(json)
+            if (offset.isEmpty()) obj.remove(catnum.toString()) else obj.put(catnum.toString(), offset)
+            obj.toString()
+        } catch (_: Exception) {
+            if (offset.isEmpty()) "{}" else """{"$catnum": "$offset"}"""
+        }
+        preferences.edit {
+            putString(keySatelliteOffsets, updated)
+            remove("$keyLegacySatelliteOffsetPrefix$catnum")
+        }
+    }
+    //endregion
+
+    //region # AMSAT status report settings
+    private val keyAmSatCallsign = "amSatCallsign"
+
+    override fun getAmSatCallsign(): String {
+        return preferences.getString(keyAmSatCallsign, "").orEmpty()
+    }
+
+    override fun setAmSatCallsign(callsign: String) {
+        preferences.edit { putString(keyAmSatCallsign, callsign.trim().uppercase(Locale.US)) }
+    }
+    //endregion
 }

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

@@ -22,9 +22,10 @@ import androidx.core.net.toUri
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import java.io.ByteArrayInputStream
+import okhttp3.RequestBody.Companion.toRequestBody
 import java.io.InputStream
 
 class RemoteSource(
@@ -46,13 +47,66 @@ class RemoteSource(
     override suspend fun getNetworkStream(url: String): InputStream? = withContext(dispatcher) {
         try {
             val networkRequest = Request.Builder().url(url).build()
-            httpClient.newCall(networkRequest).execute().use { response ->
-                if (!response.isSuccessful) return@withContext null
-                ByteArrayInputStream(response.body.bytes())
+            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.
+            // Closing the stream returns the connection to OkHttp's pool.
+            response.body.byteStream().buffered()
         } catch (exception: Exception) {
             println("RemoteSource network stream exception: $exception")
             null
         }
     }
+
+    override suspend fun getAmSatCatalog(): String? = withContext(dispatcher) {
+        try {
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/catalog.php")
+                .header("User-Agent", "Look4Sat")
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return@use null
+                response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource getAmSatCatalog exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = withContext(dispatcher) {
+        try {
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/reports.php?hours=$hours&limit=$limit")
+                .header("User-Agent", "Look4Sat")
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return@use null
+                response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource getAmSatReports exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = withContext(dispatcher) {
+        try {
+            val body = payloadJson.toRequestBody("application/json; charset=utf-8".toMediaType())
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/reports.php")
+                .header("User-Agent", "Look4Sat")
+                .post(body)
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                response.code to response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource submitAmSatReport exception: $exception")
+            null
+        }
+    }
 }

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

@@ -0,0 +1,106 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+import java.io.InputStream
+
+class AmSatRepositoryTest {
+
+    @Test
+    fun fetchStatusReturnsSeededCacheUntilCacheIsCleared() = runTest {
+        val remoteSource = FakeAmSatRemoteSource()
+        val repository = AmSatRepository(remoteSource)
+        val cachedPage = SatStatusPage(
+            fetchedAtUtcMs = 123L,
+            statuses = listOf(SatStatus(name = "AO-7", days = emptyList())),
+            reports = emptyMap()
+        )
+        repository.seedStatusCache(cachedPage)
+
+        val firstPage = repository.fetchStatus()
+        val secondPage = repository.fetchStatus()
+
+        assertSame(cachedPage, firstPage)
+        assertSame(cachedPage, secondPage)
+        assertSame(cachedPage, repository.getCachedStatus())
+        assertEquals(0, remoteSource.catalogRequests)
+        assertEquals(0, remoteSource.reportRequests)
+
+        repository.clearStatusCache()
+        assertNull(repository.getCachedStatus())
+        repository.fetchStatus()
+
+        assertEquals(1, remoteSource.catalogRequests)
+        assertEquals(1, remoteSource.reportRequests)
+    }
+
+    @Test
+    fun forceRefreshBypassesCachedPage() = runTest {
+        val remoteSource = FakeAmSatRemoteSource()
+        val repository = AmSatRepository(remoteSource)
+        repository.seedStatusCache(
+            SatStatusPage(
+                fetchedAtUtcMs = 123L,
+                statuses = listOf(SatStatus(name = "AO-7", days = emptyList())),
+                reports = emptyMap()
+            )
+        )
+
+        repository.fetchStatus(forceRefresh = true)
+
+        assertEquals(1, remoteSource.catalogRequests)
+        assertEquals(1, remoteSource.reportRequests)
+    }
+
+    @Test
+    fun fetchStatusSharesStartupPrefetchRequest() = runTest {
+        val remoteSource = FakeAmSatRemoteSource(responseDelayMillis = 50)
+        val repository = AmSatRepository(remoteSource)
+
+        val prefetch = async { repository.prefetchStatus() }
+        val pageFetch = async { repository.fetchStatus() }
+        prefetch.await()
+        val page = pageFetch.await()
+
+        assertSame(page, repository.getCachedStatus())
+        assertEquals(1, remoteSource.catalogRequests)
+        assertEquals(1, remoteSource.reportRequests)
+    }
+}
+
+private fun AmSatRepository.seedStatusCache(page: SatStatusPage) {
+    val cacheField = AmSatRepository::class.java.getDeclaredField("statusCache")
+    cacheField.isAccessible = true
+    cacheField.set(this, page)
+}
+
+private class FakeAmSatRemoteSource(private val responseDelayMillis: Long = 0L) : IRemoteSource {
+    var catalogRequests = 0
+    var reportRequests = 0
+
+    override suspend fun getFileStream(uri: String): InputStream? = null
+
+    override suspend fun getNetworkStream(url: String): InputStream? = null
+
+    override suspend fun getAmSatCatalog(): String? {
+        if (responseDelayMillis > 0L) delay(responseDelayMillis)
+        catalogRequests += 1
+        return """{"data":[{"name":"AO-7"}]}"""
+    }
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? {
+        if (responseDelayMillis > 0L) delay(responseDelayMillis)
+        reportRequests += 1
+        return """{"data":[]}"""
+    }
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = null
+}

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

@@ -0,0 +1,272 @@
+/*
+ * 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.source.Sources
+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)
+        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
+        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(
+                satelliteUrls = listOf(customCsvUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        assertTrue(localSource.insertedEntries.any { it.catnum == 25544 })
+        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
+    }
+
+    @Test
+    fun `remote update imports satellites from real SatNOGS TLE source`() = runTest(dispatcher) {
+        val satnogsUrl = Sources.satelliteDataUrls.getValue("SatNOGS")
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[satnogsUrl] = { jamxTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(satnogsUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        assertTrue(localSource.insertedEntries.any { it.name == "JAMX-0825b" && it.catnum == 98248 })
+        assertEquals(listOf(98248), settingsRepo.satelliteTypeIdsByType["SatNOGS"])
+    }
+
+    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 fun jamxTleStream(): InputStream = """
+        JAMX-0825b
+        1 98248U          26237.16675926  .00015724  00000-0  97477-3 0 00013
+        2 98248 097.5373 310.9694 0011309 278.1232 340.7230 15.09766181000012
+    """.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()
+
+    override suspend fun getAmSatCatalog(): String? = null
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = null
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = null
+}
+
+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 selectedTypes: StateFlow<List<String>> = MutableStateFlow(emptyList())
+
+    override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
+        PassesSettings(hoursAhead = 24, minElevation = 0.0, selectedModes = emptyList())
+    )
+
+    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, "", "", "", 0L, 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)
+    )
+
+    val satelliteTypeIdsByType = mutableMapOf<String, List<Int>>()
+
+    override fun setSelectedIds(ids: List<Int>) = Unit
+
+    override fun setSelectedTypes(types: 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 getSatelliteTypesIds(types: List<String>): List<Int> = emptyList()
+
+    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
+        satelliteTypeIdsByType[type] = ids
+    }
+
+    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
+
+    override fun getSatelliteOffset(catnum: Int): String = ""
+
+    override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
+
+    override fun getAmSatCallsign(): String = ""
+
+    override fun setAmSatCallsign(callsign: String) = Unit
+}
+
+private fun defaultDataSourcesSettings(): DataSourcesSettings {
+    return DataSourcesSettings(
+        satelliteUrls = emptyList(),
+        transceiversUrls = emptyList()
+    )
+}

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

@@ -0,0 +1,17 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** One public AMSAT satellite status report submission. */
+data class AmSatReportSubmission(
+    val name: String,
+    val report: String,
+    val callsign: String,
+    val gridSquare: String,
+    val reportedAtUtcMillis: Long
+)
+
+/** Result of submitting an AMSAT satellite status report. */
+data class AmSatReportSubmitResult(
+    val success: Boolean,
+    val message: String = "",
+    val reportId: String? = null
+)

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

@@ -0,0 +1,23 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.model
+
+object Constants {
+    const val FREQ_OFFSET_MIN_HZ = -50_000L
+    const val FREQ_OFFSET_MAX_HZ = 50_000L
+}

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

@@ -0,0 +1,37 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** One satellite status report (AMSAT site tooltip data) */
+data class SatReport(
+    val id: String,          // 报告 ID(a885153)
+    val statusText: String,  // Heard / Telemetry Only / Not Heard ...
+    val call: String,        // 呼号
+    val grid: String,        // 网格坐标(可为空)
+    val dateUtc: String,     // 2026-08-04
+    val timeUtc: String      // 2:46-:59 UTC
+)
+
+/** State of one 2-hour slot */
+data class SatSlot(
+    val statusColor: Long,   // ARGB 状态色(-1 = 无报告)
+    val count: Int,          // 报告数量(0 = 无)
+    val reportIds: List<String> = emptyList() // 该槽报告 ID 列表
+)
+
+/** One satellite day (12 two-hour slots) */
+data class SatDay(
+    val dateLabel: String,   // "Aug 4"
+    val slots: List<SatSlot> // 12 槽(00-02 ... 22-24)
+)
+
+/** One satellite, 3 days of state */
+data class SatStatus(
+    val name: String,        // "AO-123_[FM]"
+    val days: List<SatDay>   // 3 days (newest first)
+)
+
+/** Overall page parse result */
+data class SatStatusPage(
+    val fetchedAtUtcMs: Long,
+    val statuses: List<SatStatus>,
+    val reports: Map<String, SatReport> // id → 报告
+)

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

@@ -27,6 +27,9 @@ data class PassesSettings(
     val showDeepSpace: Boolean = true,
     val hoursAhead: Int,
     val minElevation: Double,
+    val aosStartMinute: Int = 0,
+    val aosEndMinute: Int = 23 * 60 + 59,
+    val invertAosTimeWindow: Boolean = false,
     val selectedModes: List<String>
 )
 
@@ -39,6 +42,7 @@ data class RCSettings(
     val frequencyAddress: String,
     val frequencyPort: String,
     val frequencyFormat: String,
+    val frequencyOffsetHz: Long = 0L,
     val bluetoothRotatorState: Boolean,
     val bluetoothRotatorFormat: String,
     val bluetoothRotatorName: String,
@@ -57,14 +61,14 @@ data class OtherSettings(
     val stateOfNightMode: Boolean = false,
     val shouldSeeWarning: Boolean,
     val shouldSeeWhatsNew: Boolean,
-    val sstvMode: String = "Auto"
+    val sstvMode: String = "Auto",
+    val lowElevation: Double = 15.0,
+    val highElevation: Double = 45.0
 )
 
 data class DataSourcesSettings(
-    val useCustomTLE: Boolean,
-    val useCustomTransceivers: Boolean,
-    val tleUrl: String,
-    val transceiversUrl: String
+    val satelliteUrls: List<String>,
+    val transceiversUrls: List<String>
 )
 
 data class RadioControlSettings(
@@ -74,12 +78,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

@@ -424,11 +424,15 @@ object CelestialComputer {
         }
         if (sunrise == 0.0) sunrise = daynum
 
-        // Phase 4: fast-forward through the day until sun drops back below threshold
-        daynum = sunrise
+        // Phase 4: fast-forward through the day until sun drops back below threshold.
+        // Start from just after sunrise (small offset) so the sun is clearly above
+        // the threshold. This prevents a bug where Phase 3 converges to a point
+        // slightly below -threshold, causing Phase 4 to skip and Phase 5 to converge
+        // to the same time as sunrise, producing identical sunrise/sunset times.
+        daynum = sunrise + 0.001
         sunPos = getSunPosition(observer, daynumToMillis(daynum))
         guard = 0
-        while (sunPos.elevation > -threshold && guard++ < 500) {
+        while (sunPos.elevation >= -threshold && guard++ < 500) {
             daynum += 0.008
             sunPos = getSunPosition(observer, daynumToMillis(daynum))
         }

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

@@ -0,0 +1,23 @@
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmitResult
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+
+/** AMSAT satellite status data source */
+interface IAmSatRepository {
+    /** Cached AMSAT status page for the current foreground session, if any. */
+    fun getCachedStatus(): SatStatusPage?
+
+    /** Fetch and parse the AMSAT status page; null on failure. */
+    suspend fun fetchStatus(forceRefresh: Boolean = false): SatStatusPage?
+
+    /** Warm the foreground-session cache without forcing a network reload. */
+    suspend fun prefetchStatus()
+
+    /** Clear the foreground-session status cache. */
+    fun clearStatusCache()
+
+    /** Submit a public AMSAT satellite status report. */
+    suspend fun submitReport(submission: AmSatReportSubmission): AmSatReportSubmitResult
+}

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

@@ -16,12 +16,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 package com.rtbishop.look4sat.core.domain.repository
-
+import com.rtbishop.look4sat.core.domain.model.SatRadio
 import com.rtbishop.look4sat.core.domain.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
+import kotlinx.coroutines.flow.StateFlow
 
 interface IMainContainer {
     val appScope: CoroutineScope
@@ -29,7 +30,10 @@ interface IMainContainer {
     val selectionRepo: ISelectionRepo
     val satelliteRepo: ISatelliteRepo
     val databaseRepo: IDatabaseRepo
+    val amSatRepo: IAmSatRepository
     val radioTrackingService: IRadioTrackingService
+    val mutualPassData: StateFlow<MutualPassData>
+    fun setMutualPassData(data: MutualPassData)
     fun provideAddToCalendar(): IAddToCalendar
     fun provideShowToast(): IShowToast
     fun provideBluetoothReporter(): IReporter
@@ -41,6 +45,25 @@ interface IMainContainer {
     fun provideSaveImage(): ISaveImage
 }
 
+data class MutualPassData(
+    val samples: List<Pair<Long, Pair<Double, Double>>> = emptyList(),
+    val trackSamples: List<TrackSampleData> = emptyList(),
+    val startTime: Long = 0L,
+    val endTime: Long = 0L,
+    val maxElev: Double = 10.0,
+    val labelA: String = "你",
+    val labelB: String = "友台"
+)
+
+/** Minimal track sample for cross-module sharing (angles in degrees). */
+data class TrackSampleData(
+    val time: Long = 0L,
+    val azimuthA: Double,
+    val elevationA: Double,
+    val azimuthB: Double,
+    val elevationB: Double
+)
+
 interface IContainerProvider {
     fun getMainContainer(): IMainContainer
 }

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

@@ -44,7 +44,15 @@ interface ISatelliteRepo {
     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/ISettingsRepo.kt

@@ -77,4 +77,14 @@ interface ISettingsRepo {
     val radioControlSettings: StateFlow<RadioControlSettings>
     fun updateRadioControlSettings(settings: RadioControlSettings)
     //endregion
+
+    //region # Per-satellite calculator offset settings
+    fun getSatelliteOffset(catnum: Int): String
+    fun setSatelliteOffset(catnum: Int, offset: String)
+    //endregion
+
+    //region # AMSAT status report settings
+    fun getAmSatCallsign(): String
+    fun setAmSatCallsign(callsign: String)
+    //endregion
 }

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

@@ -22,4 +22,7 @@ import java.io.InputStream
 interface IRemoteSource {
     suspend fun getFileStream(uri: String): InputStream?
     suspend fun getNetworkStream(url: String): InputStream?
+    suspend fun getAmSatCatalog(): String?
+    suspend fun getAmSatReports(hours: Int, limit: Int): String?
+    suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>?
 }

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

@@ -20,6 +20,7 @@ package com.rtbishop.look4sat.core.domain.source
 object Sources {
     val satelliteDataUrls = mapOf(
         "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
+        "SatNOGS" to "https://db.satnogs.org/api/tle/?format=3le",
         "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",
@@ -35,7 +36,7 @@ object Sources {
         "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",
+        "CelesTrak 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",
@@ -46,9 +47,11 @@ object Sources {
         "Classified" to "https://www.mmccants.org/tles/classfd.zip",
         "McCants" to "https://www.mmccants.org/tles/inttles.zip",
         "R4UAB" to "https://r4uab.ru/satonline.txt",
+        "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"
+        "SatNOGS" to "https://db.satnogs.org/api/transmitters/?format=json&status=active",
+        "R4UAB" to "https://r4uab.ru/transmitters.json"
     )
 }

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

@@ -20,39 +20,94 @@ 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 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
+    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)
+    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) {
-        // Normalize to a fixed RMS before processing so that both direct audio
-        // coupling and air-coupled microphone input decode with equal reliability.
-        normalise(samples)
+        // 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()
     }
@@ -62,36 +117,134 @@ class SstvDecoder(
     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
-        _frames.tryEmit(SstvFrame(imagePixels, imageWidth, imageHeight, modeName))
+        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.
-    private val targetRms = 0.25f
+    // 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) {
+    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) {
@@ -197,7 +350,8 @@ internal class DecoderEngine(
     private val scopeBuffer: PixelBuffer,
     private val imageBuffer: PixelBuffer,
     rawName: String,
-    sampleRate: Int
+    sampleRate: Int,
+    lineRecoveryStrategy: LineRecoveryStrategy
 ) {
     private val pixelBuffer = PixelBuffer(800, 2)
     private val detector = SyncPulseDetector(sampleRate)
@@ -237,6 +391,19 @@ internal class DecoderEngine(
     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
@@ -286,6 +453,11 @@ internal class DecoderEngine(
     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) {
@@ -308,20 +480,10 @@ internal class DecoderEngine(
                 }
             }
         } else if (handleHeader()) {
+            predictedStreak = 0
             newLines = true
         } else if (sample > lastSync + (curLineSamples * 5) / 4) {
-            copyLines(
-                currentMode.decodeScanLine(
-                    pixelBuffer,
-                    scratch,
-                    scanLineBuffer,
-                    scopeBuffer.width,
-                    lastSync,
-                    curLineSamples,
-                    lastOffset
-                )
-            )
-            lastSync += curLineSamples; newLines = true
+            newLines = decodePredictedLine()
         }
         return newLines
     }
@@ -337,6 +499,25 @@ internal class DecoderEngine(
         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)
@@ -426,6 +607,29 @@ internal class DecoderEngine(
         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(
@@ -542,6 +746,7 @@ internal class DecoderEngine(
         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]

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/DopplerFrequencyCalculator.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.
+ */
+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.
+ *
+ * The full physical path:
+ *
+ * TX→RX (uplink → downlink):
+ *   ① 地面发射 f_tx
+ *   ② 卫星收到 f_tx × (c - v) / c  （上行多普勒）
+ *   ③ 卫星转发 = passband映射(②)    （在卫星上做映射）
+ *   ④ 地面听到 ③ × (c - v) / c     （下行多普勒）
+ *
+ * RX→TX (downlink → uplink):
+ *   ④ 地面听到 f_rx
+ *   ③ 卫星转发 = f_rx × (c + v) / c  （逆下行多普勒）
+ *   ② 卫星收到 = 逆passband映射(③)
+ *   ① 地面应发射 = ② × (c + v) / c   （逆上行多普勒）
+ *
+ * Addresses GitHub issue #91 (Custom frequency Doppler correction).
+ */
+object DopplerFrequencyCalculator {
+
+    /**
+     * Given a downlink frequency (what the user hears), compute the
+     * uplink frequency the user should transmit.
+     * Full path: ④→③→②→①
+     */
+    fun computeUplinkFromDownlink(
+        downlinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        // ④→③ 逆下行多普勒：卫星转发的频率
+        val satTx = orbitalPos.getUplinkFreq(downlinkHz)
+        // ③→② 逆 passband 映射
+        val satRx = TransponderMapper.mapDownlinkToUplink(satTx, transponder) ?: return null
+        // ②→① 逆上行多普勒：地面应发射的频率
+        return orbitalPos.getUplinkFreq(satRx)
+    }
+
+    /**
+     * Given a downlink frequency (what the user hears), compute the
+     * uplink frequency the user should transmit, with an offset applied
+     * to the downlink (in Hz).
+     * Full path: ④→③→②→①
+     *
+     * The user-entered downlink frequency already includes the offset, so subtract
+     * it before the inverse downlink Doppler.
+     */
+    fun computeUplinkFromDownlinkWithOffset(
+        downlinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos,
+        offsetHz: Long
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        // ④→③ 逆下行多普勒：卫星转发的频率（含 offset）
+        val satTxWithOffset = orbitalPos.getUplinkFreq(downlinkHz)
+        // ③ 去掉 offset（offset 在卫星本地频率域）
+        val satTx = satTxWithOffset - offsetHz
+        // ③→② 逆 passband 映射
+        val satRx = TransponderMapper.mapDownlinkToUplink(satTx, transponder) ?: return null
+        // ②→① 逆上行多普勒：地面应发射的频率
+        return orbitalPos.getUplinkFreq(satRx)
+    }
+
+    /**
+     * Given an uplink frequency (what the user transmits), compute the
+     * downlink frequency the user will hear.
+     * Full path: ①→②→③→④
+     */
+    fun computeDownlinkFromUplink(
+        uplinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        // ①→② 上行多普勒：卫星收到的频率
+        val satRx = orbitalPos.getDownlinkFreq(uplinkHz)
+        // ②→③ passband 映射
+        val satTx = TransponderMapper.mapUplinkToDownlink(satRx, transponder) ?: return null
+        // ③→④ 下行多普勒：地面听到的
+        return orbitalPos.getDownlinkFreq(satTx)
+    }
+
+    /**
+     * Given an uplink frequency (what the user transmits), compute the
+     * downlink frequency the user will hear, with an offset applied
+     * to the downlink (in Hz).
+     * Full path: ①→②→③→④
+     */
+    fun computeDownlinkFromUplinkWithOffset(
+        uplinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos,
+        offsetHz: Long
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        // ①→② 上行多普勒：卫星收到的频率
+        val satRx = orbitalPos.getDownlinkFreq(uplinkHz)
+        // ②→③ passband 映射
+        val satTx = TransponderMapper.mapUplinkToDownlink(satRx, transponder) ?: return null
+        // ③ 加上 offset（offset 在卫星本地频率域）
+        // ③→④ 下行多普勒：地面听到的
+        return orbitalPos.getDownlinkFreq(satTx + 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 the named linear
+     * transponder entry, 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") || info.contains(" lin") || info.startsWith("lin")
+        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) ||
+                (hasLinearName && hasLinearMode)
+    }
+
+    /**
+     * Removes duplicate transponder entries that describe the same physical
+     * transponder with different mode labels (e.g. SatNOGS lists AO-7's Mode A
+     * as both "Lin SSB" and "Lin CW", and JO-97's U/V transponder as both
+     * "CW Transponder" and "SSB Transponder").
+     *
+     * Entries sharing the same uplink/downlink frequency range are considered
+     * the same transponder. The non-CW entry is preferred because its invert
+     * flag is more reliable (e.g. JO-97's CW entry wrongly has invert=false).
+     */
+    fun deduplicateTransponders(radios: List<SatRadio>): List<SatRadio> {
+        return radios.groupBy { radio ->
+            listOf(radio.uplinkLow, radio.uplinkHigh, radio.downlinkLow, radio.downlinkHigh)
+        }.values.map { group ->
+            group.firstOrNull { it.downlinkMode?.equals("CW", ignoreCase = true) != true } ?: group.first()
+        }
+    }
+}

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

@@ -0,0 +1,275 @@
+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.*
+import org.junit.Test
+
+class DopplerFrequencyCalculatorTest {
+
+    private fun linearTransponder(
+        uuid: String = "linear",
+        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 = uuid, 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_returnsTrueForAbbreviatedLinName() {
+        // AO-7 style: "Mode V/A (A) Lin SSB" — "Lin" abbreviation, no "transponder" word
+        val ao7Entry = linearTransponder(info = "Mode V/A (A) Lin SSB", downlinkMode = "USB", uplinkMode = "USB")
+        assertTrue(DopplerFrequencyCalculator.isNamedLinearTransponder(ao7Entry))
+        val ao7CwEntry = linearTransponder(info = "Mode V/A (A) Lin CW", downlinkMode = "CW", uplinkMode = "CW")
+        assertTrue(DopplerFrequencyCalculator.isNamedLinearTransponder(ao7CwEntry))
+        val ao7ModeBEntry = linearTransponder(info = "Mode U/V (B) Lin", downlinkMode = "USB", uplinkMode = "LSB")
+        assertTrue(DopplerFrequencyCalculator.isNamedLinearTransponder(ao7ModeBEntry))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsTrueForLinearWithoutTransponderWord() {
+        // AO-73 style: "Mode U/V Linear" — has "Linear" but no "transponder"
+        val ao73Entry = linearTransponder(info = "Mode U/V Linear", downlinkMode = "USB", uplinkMode = "LSB")
+        assertTrue(DopplerFrequencyCalculator.isNamedLinearTransponder(ao73Entry))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsFalseForDownlinkContainingLinInsideWord() {
+        // "Downlink" contains "lin" but is not a linear-transponder name
+        val downlinkEntry = linearTransponder(info = "Mode U Downlink", downlinkMode = "FM", uplinkMode = "FM")
+        assertFalse(DopplerFrequencyCalculator.isNamedLinearTransponder(downlinkEntry))
+    }
+
+    @Test
+    fun isNamedLinearTransponder_returnsFalseForFmRepeater() {
+        assertFalse(DopplerFrequencyCalculator.isNamedLinearTransponder(fmTransponder()))
+    }
+
+    @Test
+    fun deduplicateTransponders_mergesSameFrequencyRange() {
+        // AO-7's Mode A: same range, SSB and CW entries
+        val ssb = linearTransponder(
+            uuid = "ssb-uuid", info = "Mode V/A (A) Lin SSB",
+            downlinkMode = "USB", uplinkMode = "USB"
+        )
+        val cw = linearTransponder(
+            uuid = "cw-uuid", info = "Mode V/A (A) Lin CW",
+            downlinkMode = "CW", uplinkMode = "CW"
+        )
+        val modeB = linearTransponder(
+            uuid = "modeb-uuid", info = "Mode U/V (B) Lin",
+            upLow = 432_125_000L, upHigh = 432_175_000L,
+            downLow = 145_925_000L, downHigh = 145_975_000L,
+            downlinkMode = "USB", uplinkMode = "LSB"
+        )
+        val result = DopplerFrequencyCalculator.deduplicateTransponders(listOf(ssb, cw, modeB))
+        assertEquals(2, result.size)
+        // SSB entry should be preferred over CW (same range)
+        assertEquals("ssb-uuid", result[0].uuid)
+        assertEquals("modeb-uuid", result[1].uuid)
+    }
+
+    @Test
+    fun deduplicateTransponders_prefersNonCwEntry() {
+        // JO-97: CW entry has invert=false (wrong), SSB has invert=true (correct)
+        val cw = linearTransponder(
+            uuid = "cw-uuid", info = "U/V CW Transponder",
+            downlinkMode = "CW", uplinkMode = "CW",
+            upLow = 435_100_000L, upHigh = 435_120_000L,
+            downLow = 145_855_000L, downHigh = 145_875_000L
+        )
+        val ssb = linearTransponder(
+            uuid = "ssb-uuid", info = "U/V SSB Transponder",
+            downlinkMode = "USB", uplinkMode = "LSB",
+            upLow = 435_100_000L, upHigh = 435_120_000L,
+            downLow = 145_855_000L, downHigh = 145_875_000L,
+            inverted = true
+        )
+        val result = DopplerFrequencyCalculator.deduplicateTransponders(listOf(cw, ssb))
+        assertEquals(1, result.size)
+        assertEquals("ssb-uuid", result[0].uuid)
+        // Verify the correct invert flag is preserved
+        assertTrue(result[0].isInverted)
+    }
+
+    @Test
+    fun deduplicateTransponders_preservesUniqueEntries() {
+        val t1 = linearTransponder(uuid = "t1", upLow = 145_000_000L, upHigh = 145_500_000L,
+            downLow = 435_000_000L, downHigh = 435_500_000L)
+        val t2 = linearTransponder(uuid = "t2", upLow = 435_000_000L, upHigh = 435_500_000L,
+            downLow = 145_000_000L, downHigh = 145_500_000L)
+        val result = DopplerFrequencyCalculator.deduplicateTransponders(listOf(t1, t2))
+        assertEquals(2, result.size)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_linear_noDoppler() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        assertTrue(uplink!! > 0)
+        // With zero Doppler, result equals mapDownlinkToUplink output
+        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)  // ~7 km/s receding
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        // Uplink freq should be Doppler shifted UP (compensating for receding)
+        assertTrue(uplink!! > 145_200_000L)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_fm_transponder_returnsNull() {
+        val orbitalPos = pos()
+        val result = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_600_000L, fmTransponder(), orbitalPos)
+        assertNull(result)
+    }
+
+    @Test
+    fun computeDownlinkFromUplink_fm_transponder_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)
+        // Inverted: offset from high end → maps to high end of uplink
+        assertEquals(145_300_000L, uplink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_roundTrip() {
+        // downlink → uplink → downlink should round-trip
+        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)
+        // Doppler round-trip: small residual due to freq-dependent Doppler
+        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/Components.kt

@@ -39,18 +39,26 @@ 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.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
@@ -64,10 +72,11 @@ 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
@@ -148,16 +157,13 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
                 .padding(start = 6.dp, top = 1.dp, end = 6.dp, bottom = 0.dp)
         ) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "${stringResource(R.string.pass_satId, pass.catNum)} - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
                 Text(
                     text = pass.name,
                     modifier = Modifier
                         .weight(1f)
                         .padding(end = 6.dp)
                         .infiniteMarquee(),
+                    color = MaterialTheme.colorScheme.primary,
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis
@@ -274,59 +280,125 @@ fun getDefaultPass(): OrbitalPass = OrbitalPass(
     altitude = 0, maxElevation = 0.0, orbitalObject = NearEarthObject(defaultOrbitalData), progress = 0f
 )
 
+@Composable
+fun InfoDialog(
+    title: String,
+    onDismiss: () -> Unit,
+    onAccept: () -> Unit,
+    extraAction: (@Composable () -> Unit)? = null,
+    content: @Composable () -> Unit
+) {
+    DialogShell(onDismissRequest = onDismiss) { padding ->
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(start = padding, top = padding, end = padding)
+        ) {
+            Text(
+                text = title,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                modifier = Modifier.weight(1f)
+            )
+            extraAction?.let {
+                it()
+                Spacer(modifier = Modifier.width(8.dp))
+            }
+            CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
+        }
+        content()
+    }
+}
+
 @Composable
 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
+) {
+    DialogShell(onDismissRequest = onDismissRequest) { 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
+    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)
+    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 = onDismissRequest,
+        sheetState = sheetState,
+        dragHandle = null,
+        shape = MaterialTheme.shapes.medium,
+        scrimColor = Color.Black.copy(alpha = 0.64f)
+    ) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(padding),
+            modifier = Modifier
+                .fillMaxWidth()
+                .nestedScroll(stopSheetFling)
+        ) {
+            content(padding)
         }
     }
 }
@@ -391,13 +463,26 @@ fun TopBar(
 
 @Composable
 fun elevationColor(elevation: Double): Color {
+    val thresholds = LocalElevationThresholds.current
     return when {
-        elevation < 15.0 -> Color(0xFFEF5350) // soft red for low elevation
-        elevation < 45.0 -> MaterialTheme.colorScheme.primary // accent yellow for normal
-        else -> Color(0xFF66BB6A) // soft green for high elevation
+        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,

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

@@ -79,6 +79,10 @@ private val lightScheme = lightColorScheme(
     onSecondary = Color(0xFFFFFFFF),
     secondaryContainer = Color(0xFFF1E1BB),
     onSecondaryContainer = Color(0xFF221B04),
+    tertiary = Color(0xFF3C6FE0), // AMSAT Active (darker for light theme)
+    onTertiary = Color(0xFFFFFFFF),
+    tertiaryContainer = Color(0xFFE09800), // AMSAT Telemetry (darker)
+    onTertiaryContainer = Color(0xFF000000),
     background = Color(0xFFFFF8F0),
     onBackground = Color(0xFF1E1B13),
     surface = Color(0xFFFFF8F0),
@@ -101,10 +105,10 @@ private val darkScheme = darkColorScheme(
     onSecondary = Color(0xFF000000),
     secondaryContainer = Color(0xFF404040), // navBar indicator,
     onSecondaryContainer = Color(0xFFE0E0E0), // navBar active icon
-//    tertiary = Color(0xFF121212),
-//    onTertiary = Color(0xFF121212),
-//    tertiaryContainer = Color(0xFF121212),
-//    onTertiaryContainer = Color(0xFF121212),
+    tertiary = Color(0xFF648FFF), // AMSAT Active (from amsat.org/status)
+    onTertiary = Color(0xFF000000),
+    tertiaryContainer = Color(0xFFFFB000), // AMSAT Telemetry
+    onTertiaryContainer = Color(0xFF000000),
     background = Color(0xFF121212),
     onBackground = Color(0xFFE0E0E0),
     surface = Color(0xFF202020), // card background

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

@@ -30,10 +30,13 @@ sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
     data object Passes : Screen(R.drawable.ic_passes, R.string.nav_pass)
 
     @Serializable
-    data object Radar : Screen(R.drawable.ic_radar, R.string.nav_radar)
+    data object Map : Screen(R.drawable.ic_map, R.string.nav_map)
 
     @Serializable
-    data object Map : Screen(R.drawable.ic_map, R.string.nav_map)
+    data object Mutual : Screen(R.drawable.ic_radio_tower, R.string.nav_mutual)
+
+    @Serializable
+    data object AMSAT : Screen(R.drawable.ic_satellite_alt, R.string.nav_amsat)
 
     @Serializable
     data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs)

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

@@ -0,0 +1,3 @@
+<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="M19,13H13V19H11V13H5V11H11V5H13V11H19V13Z" />
+</vector>

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

@@ -0,0 +1,22 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="96"
+    android:viewportHeight="96">
+
+    <path
+        android:fillColor="@android:color/transparent"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="6"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M 8 76 C 8 44, 21 24, 39 24 C 57 24, 70 44, 70 76" />
+
+    <path
+        android:fillColor="@android:color/transparent"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="6"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M 30 76 C 30 54, 44 42, 62 42 C 80 42, 94 54, 94 76" />
+</vector>

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

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<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="#FF000000" android:pathData="M12,10A2,2 0 0,1 14,12C14,12.5 13.82,12.94 13.53,13.29L16.7,22H14.57L12,14.93L9.43,22H7.3L10.47,13.29C10.18,12.94 10,12.5 10,12A2,2 0 0,1 12,10M12,8A4,4 0 0,0 8,12C8,12.5 8.1,13 8.28,13.46L7.4,15.86C6.53,14.81 6,13.47 6,12A6,6 0 0,1 12,6A6,6 0 0,1 18,12C18,13.47 17.47,14.81 16.6,15.86L15.72,13.46C15.9,13 16,12.5 16,12A4,4 0 0,0 12,8M12,4A8,8 0 0,0 4,12C4,14.36 5,16.5 6.64,17.94L5.92,19.94C3.54,18.11 2,15.23 2,12A10,10 0 0,1 12,2A10,10 0 0,1 22,12C22,15.23 20.46,18.11 18.08,19.94L17.36,17.94C19,16.5 20,14.36 20,12A8,8 0 0,0 12,4Z" />
+</vector>

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

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Standard Material refresh icon (24dp viewport), centered geometry -->
+<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="#FF000000"
+        android:pathData="M17.65,6.35C16.2,4.9 14.21,4 12,4c-4.42,0 -7.99,3.58 -7.99,8s3.57,8 7.99,8c3.73,0 6.84,-2.55 7.73,-6h-2.08c-0.82,2.33 -3.04,4 -5.65,4 -3.31,0 -6,-2.69 -6,-6s2.69,-6 6,-6c1.66,0 3.14,0.69 4.22,1.78L13,11h7V4l-2.35,2.35z" />
+</vector>

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

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- AMSAT tab icon provided by rt-bishop (upstream author), original SVG asset -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <group
+        android:scaleX="0.242"
+        android:scaleY="0.242"
+        android:translateX="0.3"
+        android:translateY="-230.5">
+        <path android:fillColor="#FF000000" android:pathData="m 21.275553,967.35933 a 2.0000048,2.0000048 0 0 0 -1.1875,0.59375 l -13.5000003,13.5 a 2.0000048,2.0000048 0 0 0 0,2.8125 l 18.5625003,18.59382 a 2.0000048,2.0000048 0 0 0 1.2813,0.5625 l 5.5312,0.4375 -4.0312,4.0312 a 2.0000048,2.0000048 0 0 0 0,2.8126 l 13.6874,13.7187 a 2.0000048,2.0000048 0 0 0 2.8438,0 l 4.0312,-4.0312 0.4376,5.5312 a 2.0000048,2.0000048 0 0 0 0.5624,1.2813 l 18.5938,18.5625 a 2.0000048,2.0000048 0 0 0 2.8438,0 l 13.468705,-13.4688 a 2.0000048,2.0000048 0 0 0 0,-2.8437 l -18.562505,-18.5938 a 2.0000048,2.0000048 0 0 0 -1.2812,-0.5625 l -5.5313,-0.4375 4.0313,-4.0313 a 2.0000048,2.0000048 0 0 0 0,-2.8437 l -13.6876,-13.68757 a 2.0000048,2.0000048 0 0 0 -2.8437,0 l -4.0313,4.03125 -0.4374,-5.53125 a 2.0000048,2.0000048 0 0 0 -0.5626,-1.28125 l -18.5937,-18.5625 a 2.0000048,2.0000048 0 0 0 -1.4375,-0.59375 2.0000048,2.0000048 0 0 0 -0.1875,0 z m 0.2187,4.8125 16.6563,16.65625 0.5625,7.46875 -3.7812,3.78127 -7.4688,-0.59377 -16.6562,-16.625 z m 34.5626,41.46887 7.4687,0.5937 16.656305,16.625 -10.687605,10.6875 -16.625,-16.6562 -0.5937,-7.4688 z" />
+        <path android:fillColor="#FF000000" android:pathData="m 50.940553,966.18283 a 2.000005,2.000005 0 1 0 0,3.99969 c 7.9999,0 15.9734,3.03851 22.0884,9.15344 6.103605,6.10359 9.143805,14.08909 9.143805,22.07844 a 2.000005,2.000005 0 1 0 3.9994,0 c 0,-9.00692 -3.4462,-18.03775 -10.315,-24.90657 -6.877605,-6.8775 -15.900305,-10.325 -24.916605,-10.325 z" />
+        <path android:fillColor="#FF000000" android:pathData="m 50.940553,958.36533 a 2.000005,2.000005 0 1 0 0,3.99969 c 10.0021,0 19.9781,3.79987 27.613705,11.43562 7.6352,7.63517 11.4357,17.62207 11.4357,27.61376 a 2.000005,2.000005 0 1 0 3.9997,0 c 0,-11.00842 -4.207,-22.04171 -12.6072,-30.44188 -8.399505,-8.3996 -19.424005,-12.60719 -30.441905,-12.60719 z" />
+        <path android:fillColor="#FF000000" android:pathData="m 50.940553,973.94033 a 2.000005,2.000005 0 1 0 0,3.99938 c 6.0191,0 12.0105,2.279 16.6031,6.87156 4.5926,4.59255 6.881605,10.59683 6.881605,16.60313 a 2.000005,2.000005 0 1 0 3.9997,0 c 0,-7.02618 -2.6961,-14.07429 -8.053105,-19.43126 -5.3571,-5.35696 -12.398,-8.04281 -19.4313,-8.04281 z" />
+        <path android:fillColor="#FF000000" android:pathData="m 50.940553,981.77783 a 2.000005,2.000005 0 1 0 0,3.99938 c 4.0058,0 7.9968,1.51836 11.0578,4.57937 3.061,3.06099 4.5794,7.05193 4.5794,11.05782 a 2.000005,2.000005 0 1 0 3.9994,0 c 0,-5.02276 -1.9251,-10.06035 -5.7507,-13.88594 -3.8256,-3.82559 -8.8631,-5.75063 -13.8859,-5.75063 z" />
+    </group>
+</vector>

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

@@ -31,7 +31,10 @@
     <!-- 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_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">Tipo de modulación</string>
     <string name="pass_elevation">Elevación: %.1f°</string>
     <string name="pass_altitude">Altitud: %.0f km</string>
@@ -109,6 +112,13 @@
     <string name="prefs_data_update_success">Actualización completada con éxito</string>
 
     <string name="prefs_data_sources_title">Custom data sources</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_url_title" translatable="false">URL</string>
+    <string name="prefs_data_sources_satellites_label" translatable="false">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_label" translatable="false">Transceivers data</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>
     <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
 
@@ -139,6 +149,12 @@
     <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_switch_night_mode">Activar filtro nocturno rojo</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

@@ -30,7 +30,10 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">Фильтровать пролеты</string>
     <string name="pass_filter_elev">Минимальная элевация</string>
-    <string name="pass_filter_hours">Количество часов</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>
@@ -108,6 +111,13 @@
     <string name="prefs_data_update_success">Обновление прошло успешно</string>
 
     <string name="prefs_data_sources_title">Свои источники данных</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_url_title" translatable="false">URL</string>
+    <string name="prefs_data_sources_satellites_label" translatable="false">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_label" translatable="false">Transceivers data</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>
     <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Custom Transceivers URL</string>
 
@@ -138,6 +148,12 @@
     <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

@@ -31,7 +31,10 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">පසුකිරිම් පිරිපහදුව</string>
     <string name="pass_filter_elev">අවම උත්තෝලනය</string>
-    <string name="pass_filter_hours">ඉදිරි පැය</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>
@@ -109,6 +112,13 @@
     <string name="prefs_data_update_success">යාවත්කාලීනය සම්පූර්ණ කිරීම සාර්ථකයි</string>
 
     <string name="prefs_data_sources_title">Custom data sources</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_url_title" translatable="false">URL</string>
+    <string name="prefs_data_sources_satellites_label" translatable="false">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_label" translatable="false">Transceivers data</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>
     <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
 
@@ -139,6 +149,12 @@
     <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_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

@@ -31,7 +31,10 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">Geçişleri filtrele</string>
     <string name="pass_filter_elev">Minimum yükseklik açısı</string>
-    <string name="pass_filter_hours">Gösterilecek saat aralığı</string>
+    <string name="pass_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_satId" translatable="false">%05d</string>
@@ -140,6 +143,12 @@
     <string name="prefs_data_update_success">Güncelleme başarıyla tamamlandı</string>
 
     <string name="prefs_data_sources_title">Özel veri kaynakları</string>
+    <string name="prefs_data_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_satellites_label" translatable="false">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_label" translatable="false">Transceivers data</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>
     <string name="prefs_data_sources_tle_switch">Özel TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Özel transceiver URL</string>
     <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
@@ -182,6 +191,12 @@
     <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_switch_night_mode">Kırmızı gece filtresini etkinleştir</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">
@@ -190,7 +205,8 @@
         \n• Dave Moten (predict4java)
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)</string>
+        \n• Libre Space Foundation (SatNOGS)
+        \n• BG7NTA (CW decoding feature)</string>
     <string name="prefs_outro_license">Bu uygulama herhangi bir garanti sunmaz</string>
 
 </resources>

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

@@ -30,8 +30,11 @@
 
     <!-- Passes screen -->
     <string name="pass_filter_title">Фільтр прольотів</string>
-    <string name="pass_filter_elev">Мінімальне піднесення</string>
-    <string name="pass_filter_hours">Кількість годин</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>
@@ -66,7 +69,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>
@@ -109,6 +112,13 @@
     <string name="prefs_data_update_success">Оновлення успішне</string>
 
     <string name="prefs_data_sources_title">Custom data sources</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_url_title" translatable="false">URL</string>
+    <string name="prefs_data_sources_satellites_label" translatable="false">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_label" translatable="false">Transceivers data</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>
     <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
 
@@ -139,6 +149,12 @@
     <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

@@ -9,6 +9,7 @@
     <string name="nav_sat">卫星</string>
     <string name="nav_pass">过境</string>
     <string name="nav_radar">雷达</string>
+    <string name="nav_mutual">匹配</string>
     <string name="nav_map">地图</string>
     <string name="nav_prefs">设置</string>
 
@@ -26,7 +27,10 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">筛选过境</string>
     <string name="pass_filter_elev">仰角值</string>
-    <string name="pass_filter_hours">小时数</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>
@@ -35,6 +39,41 @@
     <string name="pass_welcome_title">欢迎来到 Look4Sat\!</string>
     <string name="pass_welcome_message">请务必在设置中通过GPS、经纬度或QTH定位您的位置\n建议至少每周更新一次数据库，以确保预测结果的准确性</string>
 
+    <!-- AMSAT Status screen -->
+    <string name="nav_amsat">AMSAT</string>
+    <string name="amsat_title">AMSAT 卫星状态</string>
+    <string name="amsat_refresh">刷新</string>
+    <string name="amsat_retry">重试</string>
+    <string name="amsat_updated">更新于：</string>
+    <string name="amsat_active">活跃</string>
+    <string name="amsat_tlm">遥测/信标</string>
+    <string name="amsat_not_heard">未听到</string>
+    <string name="amsat_conflict">冲突</string>
+    <string name="amsat_name">名称</string>
+    <string name="amsat_load_failed">加载失败 - 检查网络后重试</string>
+    <string name="amsat_no_reports">此时间段无报告</string>
+    <string name="amsat_close">关闭</string>
+    <string name="amsat_upload">上传</string>
+    <string name="amsat_upload_back">返回</string>
+    <string name="amsat_upload_report">上传报告到 AMSAT</string>
+    <string name="amsat_upload_status">状态</string>
+    <string name="amsat_upload_callsign">呼号</string>
+    <string name="amsat_upload_grid">网格</string>
+    <string name="amsat_upload_time_now">时间：当前 UTC %s</string>
+    <string name="amsat_upload_submit">提交到 AMSAT</string>
+    <string name="amsat_upload_confirm">确认上传</string>
+    <string name="amsat_upload_confirm_title">确认上传到 AMSAT</string>
+    <string name="amsat_upload_confirm_message">这条公开报告将上传到 AMSAT。\n卫星：%1$s\n状态：%2$s\n呼号：%3$s\n网格：%4$s</string>
+    <string name="amsat_upload_grid_none">未填写</string>
+    <string name="amsat_upload_success">报告已上传</string>
+    <string name="amsat_upload_failed">上传失败：%s</string>
+    <string name="amsat_upload_callsign_required">请填写呼号</string>
+    <string name="amsat_upload_grid_invalid">网格应为 4 或 6 位 Maidenhead 定位符</string>
+    <string name="amsat_upload_active">活跃</string>
+    <string name="amsat_upload_tlm">遥测/信标</string>
+    <string name="amsat_upload_not_heard">未听到</string>
+    <string name="amsat_upload_crew_active">ISS 语音</string>
+
     <!-- Radar screen -->
     <string name="radar_back">后退</string>
     <string name="radar_notify">通知</string>
@@ -54,6 +93,12 @@
     <string name="radar_string_yes">是</string>
     <string name="radar_visible">日照中</string>
 
+    <string name="radar_doppler_calc">多普勒频率计算器</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>
+    <string name="radar_doppler_info">线性转发器：输入一个频率即可算出另一个</string>
+
     <!-- Map screen -->
     <string name="map_prev">上一个</string>
     <string name="map_next">下一个</string>
@@ -77,7 +122,7 @@
     <string name="prefs_updated_title">更新：%s</string>
     <string name="prefs_updated_time">yyyy MMM d - HH:mm:ss</string>
 
-    <string name="prefs_loc_title">站位</string>
+    <string name="prefs_loc_title">站点位置</string>
     <string name="prefs_loc_gps_title">GPS 定位</string>
     <string name="prefs_loc_gps_error">检查您的位置权限</string>
     <string name="prefs_loc_input_title">输入位置</string>
@@ -85,11 +130,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_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_locator_text">使用梅登黑德网格设置站点位置</string>
 
     <string name="prefs_data_title">卫星数据更新</string>
     <string name="prefs_data_entries">卫星：%s</string>
@@ -100,13 +145,20 @@
     <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_url_title" translatable="false">URL</string>
+    <string name="prefs_data_sources_satellites_label">卫星数据</string>
+    <string name="prefs_data_sources_transceivers_label">收发器数据</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="prefs_net_rotator_switch">启用方位俯仰角输出</string>
@@ -115,6 +167,8 @@
     <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_net_frequency_offset_hint" translatable="false">频率偏移 (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">范围：-50000 到 50000 Hz。正值提高上报频率，负值降低上报频率。</string>
 
     <string name="prefs_bt_title">蓝牙数据输出</string>
     <string name="prefs_bt_rotator_switch">启用方位俯仰角输出</string>
@@ -126,6 +180,16 @@
     <string name="prefs_bt_perm_error">请检查蓝牙权限</string>
     <string name="prefs_net_perm_error">请检查网络权限</string>
 
+    <!-- Radio Control -->
+    <string name="nav_radiocontrol">电台控制</string>
+    <string name="rc_settings_title">CAT 电台控制</string>
+    <string name="rc_radio_model">电台型号</string>
+    <string name="rc_tx_device_hint">发射电台蓝牙地址</string>
+    <string name="rc_rx_device_hint">接收电台蓝牙地址</string>
+    <string name="rc_tx_name_hint">发射电台名称</string>
+    <string name="rc_rx_name_hint">接收电台名称</string>
+    <string name="rc_enable_switch">启用 CAT 控制</string>
+
     <string name="prefs_other_title">其他设置</string>
     <string name="prefs_other_switch_utc">以 UTC 时间显示</string>
     <string name="prefs_other_switch_update">启用卫星数据自动更新</string>
@@ -133,6 +197,11 @@
     <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 所有用户及贡献者!
@@ -140,7 +209,41 @@
         \n• Dave Moten (predict4java)
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)</string>
+        \n• Libre Space Foundation (SatNOGS)
+        \n• xdsopl 和 Robot36 贡献者!
+        \n• BG7NTA（CW解码功能）</string>
     <string name="prefs_outro_license">该应用程序不提供任何保修.</string>
 
+    <!-- 匹配页 Mutual match page -->
+    <string name="mutual_title">过境匹配</string>
+    <string name="mutual_station_you">你的位置</string>
+    <string name="mutual_station_opposite">友台位置</string>
+    <string name="mutual_label_you">你</string>
+    <string name="mutual_label_opposite">友台</string>
+    <string name="mutual_status_calculating">正在计算双方共同可见窗口…</string>
+    <string name="mutual_status_error">请修正提示后重新查询</string>
+    <string name="mutual_status_matches">找到 %d 个匹配 · 点击卡片展开曲线</string>
+    <string name="mutual_status_none">未找到共同可见窗口，调整时间或仰角后重试</string>
+    <string name="mutual_status_idle">输入双方位置后点击查询</string>
+    <string name="mutual_chip_calculating">计算中</string>
+    <string name="mutual_chip_error">有错误</string>
+    <string name="mutual_chip_matches">%d 个匹配</string>
+    <string name="mutual_chip_none">无匹配</string>
+    <string name="mutual_chip_idle">待查询</string>
+    <string name="mutual_use_current">填入当前位置</string>
+    <string name="mutual_lat">纬度</string>
+    <string name="mutual_lon">经度</string>
+    <string name="mutual_grid">网格</string>
+    <string name="mutual_grid_hint">支持 4/6/8 位 Maidenhead 网格；也可直接输入经纬度</string>
+    <string name="mutual_min_elevation">最小仰角：%d°</string>
+    <string name="mutual_time_range">时间范围</string>
+    <string name="mutual_calculating">计算中…</string>
+    <string name="mutual_query">查询匹配</string>
+    <string name="mutual_elevation_you">你：%d°</string>
+    <string name="mutual_elevation_opposite">友台：%d°</string>
+    <string name="mutual_both_tracks">双方轨迹</string>
+    <string name="mutual_open_radar">查看雷达</string>
+    <string name="mutual_station_a">站点A</string>
+    <string name="mutual_station_b">站点B</string>
+
 </resources>

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

@@ -10,6 +10,7 @@
     <string name="nav_sat">Satellites</string>
     <string name="nav_pass">Passes</string>
     <string name="nav_radar">Radar</string>
+    <string name="nav_mutual">Match</string>
     <string name="nav_map">Map</string>
     <string name="nav_prefs">Settings</string>
 
@@ -31,7 +32,9 @@
     <!-- 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>
@@ -53,6 +56,41 @@
         \n\n* Added ACCESS_LOCAL_NETWORK permission check to support network data output
     </string>
 
+    <!-- AMSAT Status screen -->
+    <string name="nav_amsat">AMSAT</string>
+    <string name="amsat_title">AMSAT Satellite Status</string>
+    <string name="amsat_refresh">Refresh</string>
+    <string name="amsat_retry">Retry</string>
+    <string name="amsat_updated">Updated:</string>
+    <string name="amsat_active">Active</string>
+    <string name="amsat_tlm">TLM/Beacon</string>
+    <string name="amsat_not_heard">Not Heard</string>
+    <string name="amsat_conflict">Conflicting</string>
+    <string name="amsat_name">Name</string>
+    <string name="amsat_load_failed">Load failed - check network and retry</string>
+    <string name="amsat_no_reports">No reports for this period</string>
+    <string name="amsat_close">Close</string>
+    <string name="amsat_upload">Upload</string>
+    <string name="amsat_upload_back">Back</string>
+    <string name="amsat_upload_report">Upload report to AMSAT</string>
+    <string name="amsat_upload_status">Status</string>
+    <string name="amsat_upload_callsign">Callsign</string>
+    <string name="amsat_upload_grid">Grid</string>
+    <string name="amsat_upload_time_now">Time: current UTC %s</string>
+    <string name="amsat_upload_submit">Submit to AMSAT</string>
+    <string name="amsat_upload_confirm">Upload</string>
+    <string name="amsat_upload_confirm_title">Confirm AMSAT upload</string>
+    <string name="amsat_upload_confirm_message">This public report will be uploaded to AMSAT.\nSatellite: %1$s\nStatus: %2$s\nCallsign: %3$s\nGrid: %4$s</string>
+    <string name="amsat_upload_grid_none">Not provided</string>
+    <string name="amsat_upload_success">Report uploaded</string>
+    <string name="amsat_upload_failed">Upload failed: %s</string>
+    <string name="amsat_upload_callsign_required">Callsign is required</string>
+    <string name="amsat_upload_grid_invalid">Grid must be a 4 or 6 character Maidenhead locator</string>
+    <string name="amsat_upload_active">Active</string>
+    <string name="amsat_upload_tlm">TLM/Beacon</string>
+    <string name="amsat_upload_not_heard">Not Heard</string>
+    <string name="amsat_upload_crew_active">Crew Active</string>
+
     <!-- Radar screen -->
     <string name="radar_back">Back</string>
     <string name="radar_notify">Notify</string>
@@ -78,6 +116,11 @@
     <string name="radar_string_no">No</string>
     <string name="radar_string_yes">Yes</string>
     <string name="radar_visible">Visible</string>
+    <string name="radar_doppler_calc">Doppler Frequency Calculator</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>
+    <string name="radar_doppler_info">For linear transponders, type one frequency to see the other</string>
 
     <!-- Map screen -->
     <string name="map_prev">Prev</string>
@@ -136,11 +179,15 @@
     <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_url_title" translatable="false">URL (HTTPS)</string>
+    <string name="prefs_data_sources_satellites_label">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_label">Transceivers data</string>
 
     <string name="prefs_data_output_title">Data output</string>
     <string name="prefs_net_output">Network</string>
@@ -164,6 +211,8 @@
     <string name="prefs_net_frequency_switch">Enable frequency output</string>
     <string name="prefs_net_frequency_address_hint">IP:Port</string>
     <string name="prefs_net_frequency_format_hint">Format</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>
 
     <string name="prefs_bt_title">Bluetooth data output</string>
     <string name="prefs_bt_rotator_switch">Enable rotation output</string>
@@ -182,6 +231,11 @@
     <string name="prefs_other_switch_sensors">Use sensors to rotate radar view</string>
     <string name="prefs_other_switch_night_mode">Enable red night mode filter</string>
 
+    <string name="prefs_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!
@@ -191,7 +245,40 @@
         \n* Dr T.S. Kelso (Celestrak)
         \n* Libre Space Foundation (SatNOGS)
         \n* xdsopl and Robot36 contributors!
+        \n* BG7NTA (CW decoding feature)
     </string>
     <string name="prefs_outro_license">The app comes with no warranty</string>
 
+    <!-- Mutual match page -->
+    <string name="mutual_title">Pass Match</string>
+    <string name="mutual_station_you">Your Station</string>
+    <string name="mutual_station_opposite">Opposite Station</string>
+    <string name="mutual_label_you">You</string>
+    <string name="mutual_label_opposite">Opposite</string>
+    <string name="mutual_status_calculating">Calculating mutual visibility windows…</string>
+    <string name="mutual_status_error">Fix the reported issues and retry</string>
+    <string name="mutual_status_matches">%d matches found · tap a card to expand</string>
+    <string name="mutual_status_none">No mutual windows found. Adjust time or min elevation and retry</string>
+    <string name="mutual_status_idle">Enter both stations, then tap Query</string>
+    <string name="mutual_chip_calculating">Calculating</string>
+    <string name="mutual_chip_error">Error</string>
+    <string name="mutual_chip_matches">%d matches</string>
+    <string name="mutual_chip_none">No matches</string>
+    <string name="mutual_chip_idle">Idle</string>
+    <string name="mutual_use_current">Use current</string>
+    <string name="mutual_lat">Lat</string>
+    <string name="mutual_lon">Lon</string>
+    <string name="mutual_grid">Grid</string>
+    <string name="mutual_grid_hint">Supports 4/6/8-char Maidenhead grid; or enter lat/lon directly</string>
+    <string name="mutual_min_elevation">Min elevation: %d°</string>
+    <string name="mutual_time_range">Time range</string>
+    <string name="mutual_calculating">Calculating…</string>
+    <string name="mutual_query">Query Match</string>
+    <string name="mutual_elevation_you">You: %d°</string>
+    <string name="mutual_elevation_opposite">Opposite: %d°</string>
+    <string name="mutual_both_tracks">Both tracks</string>
+    <string name="mutual_open_radar">Open Radar</string>
+    <string name="mutual_station_a">Station A</string>
+    <string name="mutual_station_b">Station B</string>
+
 </resources>

feature/mutual/build.gradle.kts

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

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/ElevationCurveChart.kt

@@ -0,0 +1,264 @@
+/*
+ * 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.mutual
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.ui.res.stringResource
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.presentation.R
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import kotlin.math.roundToInt
+
+/**
+ * Draggable dual-station elevation curve chart.
+ * Controlled component: [progress] (0..1) and [onProgressChange] are owned by the parent,
+ * so the same time cursor can be shared with the radar track view.
+ */
+@Composable
+fun ElevationCurveChart(
+    samples: List<Pair<Long, Pair<Double, Double>>>,
+    startTime: Long,
+    endTime: Long,
+    maxElev: Double,
+    progress: Float = 0.5f,
+    onProgressChange: (Float) -> Unit = {},
+    modifier: Modifier = Modifier
+) {
+    if (samples.isEmpty()) return
+
+    val colorA = MaterialTheme.colorScheme.primary
+    val colorB = MaterialTheme.colorScheme.tertiary
+    val gridColor = MaterialTheme.colorScheme.outlineVariant
+    val textColor = MaterialTheme.colorScheme.onSurfaceVariant
+    val onSurfaceColor = MaterialTheme.colorScheme.onSurface
+    val colorAArgb = colorA.toArgb()
+    val colorBArgb = colorB.toArgb()
+    val textColorArgb = textColor.toArgb()
+    val onSurfaceArgb = onSurfaceColor.toArgb()
+    val gridColorArgb = gridColor.toArgb()
+    val timeFormat = remember { SimpleDateFormat("HH:mm", Locale.getDefault()) }
+
+    Column(modifier = modifier.fillMaxWidth()) {
+        Canvas(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(200.dp)
+                .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f))
+                .pointerInput(Unit) {
+                    detectTapGestures { offset ->
+                        onProgressChange((offset.x / size.width.toFloat()).coerceIn(0f, 1f))
+                    }
+                }
+                .pointerInput(Unit) {
+                    detectDragGestures { change, _ ->
+                        onProgressChange((change.position.x / size.width.toFloat()).coerceIn(0f, 1f))
+                    }
+                }
+        ) {
+            val chartWidth = size.width
+            val chartHeight = size.height
+            val padding = 40f
+            val plotLeft = padding
+            val plotRight = chartWidth - 10f
+            val plotTop = 10f
+            val plotBottom = chartHeight - padding
+            val plotWidth = plotRight - plotLeft
+            val plotHeight = plotBottom - plotTop
+
+            if (plotWidth <= 0f || plotHeight <= 0f) return@Canvas
+
+            val minTime = startTime
+            val maxTime = endTime
+            val timeRange = (maxTime - minTime).toFloat()
+            if (timeRange <= 0f) return@Canvas
+
+            // Grid lines
+            val gridSteps = 4
+            for (i in 0..gridSteps) {
+                val y = plotBottom - (plotHeight * i / gridSteps)
+                drawLine(gridColor, Offset(plotLeft, y), Offset(plotRight, y), strokeWidth = 1f)
+                val elev = (maxElev * i / gridSteps).roundToInt()
+                drawContext.canvas.nativeCanvas.drawText(
+                    "$elev°", 2f, y + 4f,
+                    android.graphics.Paint().apply {
+                        color = textColorArgb
+                        textSize = 24f
+                        textAlign = android.graphics.Paint.Align.LEFT
+                    }
+                )
+            }
+
+            // Time axis
+            val timeSteps = 4
+            for (i in 0..timeSteps) {
+                val x = plotLeft + (plotWidth * i / timeSteps)
+                val t = startTime + ((endTime - startTime) * i / timeSteps)
+                drawContext.canvas.nativeCanvas.drawText(
+                    timeFormat.format(Date(t)), x - 20f, chartHeight - 2f,
+                    android.graphics.Paint().apply {
+                        color = textColorArgb
+                        textSize = 22f
+                        textAlign = android.graphics.Paint.Align.LEFT
+                    }
+                )
+            }
+
+            // Elevation curves (smooth cubic Bezier)
+            val pathA = Path()
+            val pathB = Path()
+            val ptsA = mutableListOf<Offset>()
+            val ptsB = mutableListOf<Offset>()
+
+            for ((time, elev) in samples) {
+                val x = plotLeft + ((time - minTime).toFloat() / timeRange) * plotWidth
+                val yA = plotBottom - ((elev.first.toFloat() / maxElev.toFloat()) * plotHeight).coerceIn(0f, plotHeight)
+                val yB = plotBottom - ((elev.second.toFloat() / maxElev.toFloat()) * plotHeight).coerceIn(0f, plotHeight)
+                ptsA.add(Offset(x, yA))
+                ptsB.add(Offset(x, yB))
+            }
+
+            if (ptsA.size >= 2) {
+                pathA.moveTo(ptsA[0].x, ptsA[0].y)
+                pathB.moveTo(ptsB[0].x, ptsB[0].y)
+                for (i in 1 until ptsA.size) {
+                    val p0a = ptsA.getOrNull(i - 2) ?: ptsA[i - 1]
+                    val p1a = ptsA[i - 1]
+                    val p2a = ptsA[i]
+                    val p3a = ptsA.getOrNull(i + 1) ?: ptsA[i]
+                    val cp1a = Offset(p1a.x + (p2a.x - p0a.x) / 6f, p1a.y + (p2a.y - p0a.y) / 6f)
+                    val cp2a = Offset(p2a.x - (p3a.x - p1a.x) / 6f, p2a.y - (p3a.y - p1a.y) / 6f)
+                    pathA.cubicTo(cp1a.x, cp1a.y, cp2a.x, cp2a.y, p2a.x, p2a.y)
+
+                    val p0b = ptsB.getOrNull(i - 2) ?: ptsB[i - 1]
+                    val p1b = ptsB[i - 1]
+                    val p2b = ptsB[i]
+                    val p3b = ptsB.getOrNull(i + 1) ?: ptsB[i]
+                    val cp1b = Offset(p1b.x + (p2b.x - p0b.x) / 6f, p1b.y + (p2b.y - p0b.y) / 6f)
+                    val cp2b = Offset(p2b.x - (p3b.x - p1b.x) / 6f, p2b.y - (p3b.y - p1b.y) / 6f)
+                    pathB.cubicTo(cp1b.x, cp1b.y, cp2b.x, cp2b.y, p2b.x, p2b.y)
+                }
+            }
+
+            drawPath(pathA, colorA, style = Stroke(width = 2.5f))
+            drawPath(pathB, colorB, style = Stroke(width = 2.5f))
+
+            // Drag indicator
+            val dragX = plotLeft + progress * plotWidth
+            val dragTime = startTime + (progress * (endTime - startTime)).toLong()
+
+            drawLine(
+                onSurfaceColor,
+                Offset(dragX, plotTop), Offset(dragX, plotBottom),
+                strokeWidth = 2f
+            )
+
+            val dragElev = getElevationAtTime(samples, dragTime)
+            val dragElevA = (dragElev?.first?.let { (it * 10).roundToInt() / 10.0 } ?: 0.0)
+            val dragElevB = (dragElev?.second?.let { (it * 10).roundToInt() / 10.0 } ?: 0.0)
+
+            drawContext.canvas.nativeCanvas.drawText(
+                timeFormat.format(Date(dragTime)),
+                dragX - 24f, plotBottom + 16f,
+                android.graphics.Paint().apply {
+                    color = onSurfaceArgb
+                    textSize = 24f
+                    textAlign = android.graphics.Paint.Align.LEFT
+                }
+            )
+            drawContext.canvas.nativeCanvas.drawText(
+                "A:${dragElevA}°",
+                dragX + 6f, plotTop + 16f,
+                android.graphics.Paint().apply {
+                    color = colorAArgb
+                    textSize = 24f
+                    textAlign = android.graphics.Paint.Align.LEFT
+                }
+            )
+            drawContext.canvas.nativeCanvas.drawText(
+                "B:${dragElevB}°",
+                dragX + 6f, plotTop + 42f,
+                android.graphics.Paint().apply {
+                    color = colorBArgb
+                    textSize = 24f
+                    textAlign = android.graphics.Paint.Align.LEFT
+                }
+            )
+        }
+
+        // Legend
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+            horizontalArrangement = Arrangement.SpaceEvenly
+        ) {
+            Text(stringResource(R.string.mutual_station_a), color = colorA, fontSize = 12.sp)
+            Text(stringResource(R.string.mutual_station_b), color = colorB, fontSize = 12.sp)
+        }
+    }
+}
+
+private fun getElevationAtTime(
+    samples: List<Pair<Long, Pair<Double, Double>>>,
+    time: Long
+): Pair<Double, Double>? {
+    if (samples.isEmpty()) return null
+    if (samples.size == 1) return samples[0].second
+    if (time <= samples[0].first) return samples[0].second
+    if (time >= samples.last().first) return samples.last().second
+
+    var lo = 0
+    var hi = samples.size - 1
+    while (hi - lo > 1) {
+        val mid = (lo + hi) / 2
+        if (samples[mid].first <= time) lo = mid
+        else hi = mid
+    }
+
+    val t0 = samples[lo].first
+    val t1 = samples[hi].first
+    val frac = if (t1 > t0) (time - t0).toFloat() / (t1 - t0).toFloat() else 0f
+
+    val e0 = samples[lo].second
+    val e1 = samples[hi].second
+    return Pair(
+        e0.first + (e1.first - e0.first) * frac,
+        e0.second + (e1.second - e0.second) * frac
+    )
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualPass.kt

@@ -0,0 +1,53 @@
+/*
+ * 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.mutual
+
+/**
+ * A mutual pass where a satellite is visible from two stations simultaneously.
+ *
+ * @param catNum Satellite catalog number
+ * @param name Satellite name
+ * @param startTime Common AOS time (millis)
+ * @param endTime Common LOS time (millis)
+ * @param maxElevationA Peak elevation for station A
+ * @param maxElevationB Peak elevation for station B
+ * @param elevationSamples List of (time, (elevationA, elevationB)) pairs
+ * @param trackSamples List of radar-track samples (azimuth/elevation for both stations, degrees)
+ */
+data class MutualPass(
+    val catNum: Int,
+    val name: String,
+    val startTime: Long,
+    val endTime: Long,
+    val maxElevationA: Double,
+    val maxElevationB: Double,
+    val elevationSamples: List<Pair<Long, Pair<Double, Double>>>,
+    val trackSamples: List<TrackSample> = emptyList()
+)
+
+/**
+ * One radar-track sample: satellite position as seen from both stations.
+ * All angles are in degrees.
+ */
+data class TrackSample(
+    val time: Long,
+    val azimuthA: Double,
+    val elevationA: Double,
+    val azimuthB: Double,
+    val elevationB: Double
+)

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualRadarView.kt

@@ -0,0 +1,223 @@
+/*
+ * 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.mutual
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+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.dp
+import androidx.compose.ui.unit.sp
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.sin
+
+private const val CIRCLES = 3 // 30°, 60°, 90° rings
+private const val STROKE_WIDTH = 2.5f
+
+/**
+ * Polar radar chart showing the satellite track as seen from both stations
+ * on one plot. Station A is drawn solid, station B dashed.
+ * Controlled: [progress] (0..1) and [onProgressChange] are owned by the parent
+ * so the time cursor can be shared with the elevation curve chart.
+ */
+@Composable
+fun MutualRadarView(
+    trackSamples: List<TrackSample>,
+    progress: Float = 0.5f,
+    labelA: String = "Station A",
+    labelB: String = "Station B",
+    modifier: Modifier = Modifier
+) {
+    if (trackSamples.isEmpty()) return
+
+    val colorA = MaterialTheme.colorScheme.primary
+    val colorB = MaterialTheme.colorScheme.tertiary
+    val gridColor = MaterialTheme.colorScheme.outlineVariant
+    val textColor = MaterialTheme.colorScheme.onSurfaceVariant
+    val measurer = rememberTextMeasurer()
+
+    // Current-time samples (both stations' position at the shared cursor)
+    val t0 = trackSamples.first().time
+    val t1 = trackSamples.last().time
+    val selectedTime = t0 + ((t1 - t0) * progress).toLong()
+    val visibleSamples = trackSamples.filter { it.time <= selectedTime }
+    val currentSample = visibleSamples.lastOrNull() ?: trackSamples.first()
+
+    Column(modifier = modifier.fillMaxWidth()) {
+        Canvas(
+            modifier = Modifier
+                .fillMaxWidth()
+                .aspectRatio(1f)
+                .padding(4.dp)
+        ) {
+            val radius = size.minDimension / 2f * 0.92f
+            val center = Offset(size.width / 2f, size.height / 2f)
+
+            // Grid: elevation rings + azimuth spokes + cardinal labels
+            drawRadarGrid(center, radius, gridColor, textColor, measurer)
+
+            // Track paths (only the above-horizon arc, split at the 0/360° azimuth wrap)
+            val pathA = Path()
+            val pathB = Path()
+            var firstVisibleA = true
+            var firstVisibleB = true
+            var lastAzimA: Double? = null
+            var lastAzimB: Double? = null
+            trackSamples.forEach { sample ->
+                if (sample.elevationA > 0f) {
+                    val p = sph2Cart(center, sample.azimuthA, sample.elevationA, radius)
+                    val wrapA = lastAzimA != null && kotlin.math.abs(azimuthDelta(sample.azimuthA - lastAzimA!!)) > 180.0
+                    if (firstVisibleA || wrapA) {
+                        pathA.moveTo(p.x, p.y)
+                        firstVisibleA = false
+                    } else {
+                        pathA.lineTo(p.x, p.y)
+                    }
+                    lastAzimA = sample.azimuthA
+                }
+                if (sample.elevationB > 0f) {
+                    val p = sph2Cart(center, sample.azimuthB, sample.elevationB, radius)
+                    val wrapB = lastAzimB != null && kotlin.math.abs(azimuthDelta(sample.azimuthB - lastAzimB!!)) > 180.0
+                    if (firstVisibleB || wrapB) {
+                        pathB.moveTo(p.x, p.y)
+                        firstVisibleB = false
+                    } else {
+                        pathB.lineTo(p.x, p.y)
+                    }
+                    lastAzimB = sample.azimuthB
+                }
+            }
+
+            // Solid line for station A, dashed for station B
+            drawPath(pathA, colorA, style = Stroke(STROKE_WIDTH))
+            drawPath(
+                pathB, colorB,
+                style = Stroke(STROKE_WIDTH, pathEffect = PathEffect.dashPathEffect(floatArrayOf(14f, 10f)))
+            )
+
+            // AOS / LOS markers on both tracks
+            val first = trackSamples.first()
+            val last = trackSamples.last()
+            val aosA = sph2Cart(center, first.azimuthA, first.elevationA, radius)
+            val aosB = sph2Cart(center, first.azimuthB, first.elevationB, radius)
+            val losA = sph2Cart(center, last.azimuthA, last.elevationA, radius)
+            val losB = sph2Cart(center, last.azimuthB, last.elevationB, radius)
+            // AOS: hollow circle, LOS: filled circle
+            if (first.elevationA > 0f) drawCircle(colorA, 7f, aosA, style = Stroke(2.5f))
+            if (first.elevationB > 0f) drawCircle(colorB, 7f, aosB, style = Stroke(2.5f))
+            if (last.elevationA > 0f) drawCircle(colorA, 5f, losA)
+            if (last.elevationB > 0f) drawCircle(colorB, 5f, losB)
+
+            // Shared time-cursor positions (both stations at selectedTime)
+            val cursorA = sph2Cart(center, currentSample.azimuthA, currentSample.elevationA, radius)
+            val cursorB = sph2Cart(center, currentSample.azimuthB, currentSample.elevationB, radius)
+            drawCircle(colorA, 14f, cursorA, style = Stroke(3f))
+            drawCircle(colorA, 6f, cursorA)
+            drawCircle(colorB, 14f, cursorB, style = Stroke(3f))
+            drawCircle(colorB, 6f, cursorB)
+
+            // Center dot
+            drawCircle(gridColor, 4f, center)
+        }
+
+        // Legend
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+            horizontalArrangement = Arrangement.SpaceEvenly
+        ) {
+            Text("● $labelA", color = colorA, fontSize = 12.sp)
+            Text("- - $labelB", color = colorB, fontSize = 12.sp)
+        }
+    }
+}
+
+private fun DrawScope.drawRadarGrid(
+    center: Offset,
+    radius: Float,
+    color: Color,
+    textColor: Color,
+    measurer: TextMeasurer
+) {
+    // Elevation rings: 30°, 60°, 90°(center) — outer edge is horizon (0°)
+    val step = radius / CIRCLES
+    for (i in 0 until CIRCLES) {
+        drawCircle(color, radius - step * i, center, style = Stroke(1.5f))
+    }
+    // Cardinal spokes
+    drawLine(color, Offset(center.x - radius, center.y), Offset(center.x + radius, center.y), 1.5f)
+    drawLine(color, Offset(center.x, center.y - radius), Offset(center.x, center.y + radius), 1.5f)
+    // Diagonal spokes (lighter)
+    val diag = radius * 0.7071f
+    drawLine(
+        color.copy(alpha = 0.5f),
+        Offset(center.x - diag, center.y - diag), Offset(center.x + diag, center.y + diag), 1f
+    )
+    drawLine(
+        color.copy(alpha = 0.5f),
+        Offset(center.x - diag, center.y + diag), Offset(center.x + diag, center.y - diag), 1f
+    )
+
+    // Elevation ring labels: 30° on the outer ring, 60° on the middle ring, 90° at center
+    // (outer edge is the 0° horizon). Labels sit just above their ring.
+    val style = TextStyle(color = textColor, fontSize = 11.sp)
+    drawText(measurer, "30°", Offset(center.x + 6f, (center.y - (radius - step)) - 24f), style = style)
+    drawText(measurer, "60°", Offset(center.x + 6f, (center.y - (radius - 2 * step)) - 24f), style = style)
+    drawText(measurer, "90°", Offset(center.x + 6f, center.y - 18f), style = style)
+    // Cardinal labels
+    drawText(measurer, "N", Offset(center.x - 8f, center.y - radius - 20f), style = style)
+    drawText(measurer, "E", Offset(center.x + radius + 4f, center.y - 10f), style = style)
+    drawText(measurer, "S", Offset(center.x - 6f, center.y + radius + 2f), style = style)
+    drawText(measurer, "W", Offset(center.x - radius - 24f, center.y - 10f), style = style)
+}
+
+/** Normalize an azimuth delta (degrees) into the [-180, 180] range. */
+private fun azimuthDelta(deltaDeg: Double): Double {
+    var d = deltaDeg % 360.0
+    if (d > 180.0) d -= 360.0
+    if (d < -180.0) d += 360.0
+    return d
+}
+
+/** Convert azimuth (deg, 0=N, clockwise) and elevation (deg) to canvas offset. */
+private fun sph2Cart(center: Offset, azimDeg: Double, elevDeg: Double, r: Float): Offset {
+    val azimRad = azimDeg * PI / 180.0
+    val elevRad = elevDeg * PI / 180.0
+    val radius = r * (PI / 2 - elevRad) / (PI / 2)
+    return Offset(
+        x = center.x + (radius * cos(PI / 2 - azimRad)).toFloat(),
+        y = center.y - (radius * sin(PI / 2 - azimRad)).toFloat()
+    )
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualScreen.kt

@@ -0,0 +1,620 @@
+/*
+ * 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.mutual
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.Button
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.KeyboardType
+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.repository.MutualPassData
+import com.rtbishop.look4sat.core.domain.repository.TrackSampleData
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.ScreenColumn
+import com.rtbishop.look4sat.core.presentation.TopBar
+import com.rtbishop.look4sat.core.presentation.isVerticalLayout
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+@Composable
+fun MutualScreen(
+    viewModel: MutualViewModel,
+    navigateToRadar: (Int, Long, MutualPassData?) -> Unit = { _, _, _ -> },
+    modifier: Modifier = Modifier
+) {
+    val state by viewModel.uiState.collectAsState()
+
+    ScreenColumn(
+        topBar = { isVertical ->
+            TopBar(
+                isVerticalLayout = isVertical,
+                startAction = {},
+                topInfo = {
+                    Text(
+                        text = stringResource(R.string.mutual_title),
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+                },
+                bottomInfo = {
+                    Text(
+                        text = mutualStatusText(state),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                        modifier = Modifier.weight(1f)
+                    )
+                },
+                endAction = {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(6.dp)
+                    ) {
+                        if (state.isCalculating) {
+                            CircularProgressIndicator(
+                                modifier = Modifier
+                                    .height(24.dp)
+                                    .width(24.dp),
+                                strokeWidth = 2.dp
+                            )
+                        }
+                        MutualStatusChip(state)
+                    }
+                }
+            )
+        }
+    ) { isVertical ->
+        MutualContent(
+            state = state,
+            isVertical = isVertical,
+            onQuery = viewModel::queryMutualPasses,
+            onSelectPass = viewModel::onSelectPass,
+            onNavigateToRadar = navigateToRadar,
+            onStationALat = viewModel::onStationALat,
+            onStationALon = viewModel::onStationALon,
+            onStationAGrid = viewModel::onStationAGrid,
+            onStationAMinElev = viewModel::onStationAMinElev,
+            onStationBLat = viewModel::onStationBLat,
+            onStationBLon = viewModel::onStationBLon,
+            onStationBGrid = viewModel::onStationBGrid,
+            onStationBMinElev = viewModel::onStationBMinElev,
+            onUseCurrentPosition = viewModel::onUseCurrentPosition,
+            onHoursAhead = viewModel::onHoursAhead,
+            onClearError = viewModel::clearError
+        )
+    }
+}
+
+@Composable
+private fun MutualContent(
+    state: MutualUiState,
+    isVertical: Boolean,
+    onQuery: () -> Unit,
+    onSelectPass: (Int) -> Unit,
+    onNavigateToRadar: (Int, Long, MutualPassData?) -> Unit,
+    onStationALat: (String) -> Unit,
+    onStationALon: (String) -> Unit,
+    onStationAGrid: (String) -> Unit,
+    onStationAMinElev: (Double) -> Unit,
+    onStationBLat: (String) -> Unit,
+    onStationBLon: (String) -> Unit,
+    onStationBGrid: (String) -> Unit,
+    onStationBMinElev: (Double) -> Unit,
+    onUseCurrentPosition: () -> Unit,
+    onHoursAhead: (Int) -> Unit,
+    onClearError: () -> Unit
+) {
+    val timeFormat = remember { SimpleDateFormat("MM/dd HH:mm", Locale.getDefault()) }
+
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        verticalArrangement = Arrangement.spacedBy(6.dp)
+    ) {
+        // Error message
+        val errorMsg = state.errorMessage
+        if (errorMsg != null) {
+            item {
+                ElevatedCard(
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = CardDefaults.elevatedCardColors(
+                        containerColor = MaterialTheme.colorScheme.errorContainer
+                    )
+                ) {
+                    Text(
+                        text = errorMsg,
+                        color = MaterialTheme.colorScheme.onErrorContainer,
+                        modifier = Modifier.padding(12.dp),
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                }
+            }
+        }
+
+        // Input form
+        item {
+            Column(
+                modifier = Modifier.fillMaxWidth(),
+                verticalArrangement = Arrangement.spacedBy(6.dp)
+            ) {
+                if (isVertical) {
+                    StationInputCard(
+                        title = stringResource(R.string.mutual_station_you),
+                        titleColor = MaterialTheme.colorScheme.primary,
+                        lat = state.stationALat,
+                        lon = state.stationALon,
+                        grid = state.stationAGrid,
+                        minElev = state.stationAMinElev,
+                        latPlaceholder = "39.9042",
+                        lonPlaceholder = "116.4074",
+                        gridPlaceholder = "ON79uj",
+                        onLatChange = onStationALat,
+                        onLonChange = onStationALon,
+                        onGridChange = onStationAGrid,
+                        onMinElevChange = onStationAMinElev,
+                        currentPositionAction = onUseCurrentPosition
+                    )
+                    StationInputCard(
+                        title = stringResource(R.string.mutual_station_opposite),
+                        titleColor = MaterialTheme.colorScheme.tertiary,
+                        lat = state.stationBLat,
+                        lon = state.stationBLon,
+                        grid = state.stationBGrid,
+                        minElev = state.stationBMinElev,
+                        latPlaceholder = "34.0522",
+                        lonPlaceholder = "-118.2437",
+                        gridPlaceholder = "PM01tv",
+                        onLatChange = onStationBLat,
+                        onLonChange = onStationBLon,
+                        onGridChange = onStationBGrid,
+                        onMinElevChange = onStationBMinElev
+                    )
+                } else {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(6.dp)
+                    ) {
+                        StationInputCard(
+                            title = stringResource(R.string.mutual_station_you),
+                            titleColor = MaterialTheme.colorScheme.primary,
+                            lat = state.stationALat,
+                            lon = state.stationALon,
+                            grid = state.stationAGrid,
+                            minElev = state.stationAMinElev,
+                            latPlaceholder = "39.9042",
+                            lonPlaceholder = "116.4074",
+                            gridPlaceholder = "ON79uj",
+                            onLatChange = onStationALat,
+                            onLonChange = onStationALon,
+                            onGridChange = onStationAGrid,
+                            onMinElevChange = onStationAMinElev,
+                            currentPositionAction = onUseCurrentPosition,
+                            modifier = Modifier.weight(1f)
+                        )
+                        StationInputCard(
+                            title = stringResource(R.string.mutual_station_opposite),
+                            titleColor = MaterialTheme.colorScheme.tertiary,
+                            lat = state.stationBLat,
+                            lon = state.stationBLon,
+                            grid = state.stationBGrid,
+                            minElev = state.stationBMinElev,
+                            latPlaceholder = "34.0522",
+                            lonPlaceholder = "-118.2437",
+                            gridPlaceholder = "PM01tv",
+                            onLatChange = onStationBLat,
+                            onLonChange = onStationBLon,
+                            onGridChange = onStationBGrid,
+                            onMinElevChange = onStationBMinElev,
+                            modifier = Modifier.weight(1f)
+                        )
+                    }
+                }
+
+                MatchSearchCard(
+                    hoursAhead = state.hoursAhead,
+                    isCalculating = state.isCalculating,
+                    onHoursAhead = onHoursAhead,
+                    onQuery = onQuery
+                )
+            }
+        }
+
+        // Results
+        itemsIndexed(state.mutualPasses) { index, pass ->
+            val mutualData = MutualPassData(
+                samples = pass.elevationSamples,
+                trackSamples = pass.trackSamples.map {
+                    TrackSampleData(
+                        time = it.time,
+                        azimuthA = it.azimuthA,
+                        elevationA = it.elevationA,
+                        azimuthB = it.azimuthB,
+                        elevationB = it.elevationB
+                    )
+                },
+                startTime = pass.startTime,
+                endTime = pass.endTime,
+                maxElev = maxOf(pass.maxElevationA, pass.maxElevationB, 10.0),
+                labelA = stringResource(R.string.mutual_label_you),
+                labelB = stringResource(R.string.mutual_label_opposite)
+            )
+            MutualPassCard(
+                pass = pass,
+                isExpanded = state.selectedPassIndex == index,
+                timeFormat = timeFormat,
+                minElevA = state.stationAMinElev,
+                minElevB = state.stationBMinElev,
+                onClick = { onSelectPass(if (state.selectedPassIndex == index) -1 else index) },
+                onNavigateToRadar = { onNavigateToRadar(pass.catNum, pass.startTime, mutualData) }
+            )
+        }
+    }
+}
+
+@Composable
+private fun MutualStatusChip(state: MutualUiState) {
+    val colorScheme = MaterialTheme.colorScheme
+    val containerColor = when {
+        state.isCalculating -> colorScheme.primaryContainer
+        state.errorMessage != null -> colorScheme.errorContainer
+        state.mutualPasses.isNotEmpty() -> colorScheme.primary
+        state.hasSearched -> colorScheme.surfaceVariant
+        else -> colorScheme.surfaceVariant
+    }
+    val contentColor = when {
+        state.isCalculating -> colorScheme.onPrimaryContainer
+        state.errorMessage != null -> colorScheme.onErrorContainer
+        state.mutualPasses.isNotEmpty() -> colorScheme.onPrimary
+        else -> colorScheme.onSurfaceVariant
+    }
+    Surface(
+        color = containerColor,
+        contentColor = contentColor,
+        shape = MaterialTheme.shapes.small
+    ) {
+        Text(
+            text = mutualStatusChipText(state),
+            style = MaterialTheme.typography.labelSmall,
+            fontWeight = FontWeight.Medium,
+            maxLines = 1,
+            modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp)
+        )
+    }
+}
+
+@Composable
+private fun mutualStatusText(state: MutualUiState): String = when {
+    state.isCalculating -> stringResource(R.string.mutual_status_calculating)
+    state.errorMessage != null -> stringResource(R.string.mutual_status_error)
+    state.mutualPasses.isNotEmpty() -> stringResource(R.string.mutual_status_matches, state.mutualPasses.size)
+    state.hasSearched -> stringResource(R.string.mutual_status_none)
+    else -> stringResource(R.string.mutual_status_idle)
+}
+
+@Composable
+private fun mutualStatusChipText(state: MutualUiState): String = when {
+    state.isCalculating -> stringResource(R.string.mutual_chip_calculating)
+    state.errorMessage != null -> stringResource(R.string.mutual_chip_error)
+    state.mutualPasses.isNotEmpty() -> stringResource(R.string.mutual_chip_matches, state.mutualPasses.size)
+    state.hasSearched -> stringResource(R.string.mutual_chip_none)
+    else -> stringResource(R.string.mutual_chip_idle)
+}
+
+@Composable
+private fun StationInputCard(
+    title: String,
+    titleColor: androidx.compose.ui.graphics.Color,
+    lat: String,
+    lon: String,
+    grid: String,
+    minElev: Double,
+    latPlaceholder: String,
+    lonPlaceholder: String,
+    gridPlaceholder: String,
+    onLatChange: (String) -> Unit,
+    onLonChange: (String) -> Unit,
+    onGridChange: (String) -> Unit,
+    onMinElevChange: (Double) -> Unit,
+    modifier: Modifier = Modifier,
+    currentPositionAction: (() -> Unit)? = null
+) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Medium,
+                    color = titleColor
+                )
+                if (currentPositionAction != null) {
+                    OutlinedButton(onClick = currentPositionAction) {
+                        Text(stringResource(R.string.mutual_use_current), style = MaterialTheme.typography.bodySmall)
+                    }
+                }
+            }
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                OutlinedTextField(
+                    value = lat,
+                    onValueChange = onLatChange,
+                    label = { Text(stringResource(R.string.mutual_lat)) },
+                    placeholder = { Text(latPlaceholder) },
+                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                    singleLine = true,
+                    modifier = Modifier.weight(1f)
+                )
+                OutlinedTextField(
+                    value = lon,
+                    onValueChange = onLonChange,
+                    label = { Text(stringResource(R.string.mutual_lon)) },
+                    placeholder = { Text(lonPlaceholder) },
+                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                    singleLine = true,
+                    modifier = Modifier.weight(1f)
+                )
+            }
+
+            OutlinedTextField(
+                value = grid,
+                onValueChange = onGridChange,
+                label = { Text(stringResource(R.string.mutual_grid)) },
+                placeholder = { Text(gridPlaceholder) },
+                supportingText = { Text(stringResource(R.string.mutual_grid_hint)) },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth()
+            )
+
+            Text(
+                text = stringResource(R.string.mutual_min_elevation, minElev.toInt()),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            Slider(
+                value = minElev.toFloat(),
+                onValueChange = { onMinElevChange(it.toDouble()) },
+                valueRange = 0f..90f,
+                steps = 17
+            )
+        }
+    }
+}
+
+@Composable
+private fun MatchSearchCard(
+    hoursAhead: Int,
+    isCalculating: Boolean,
+    onHoursAhead: (Int) -> Unit,
+    onQuery: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(10.dp)
+        ) {
+            Text(
+                text = stringResource(R.string.mutual_time_range),
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Medium
+            )
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                listOf(6, 12, 24, 48, 72).forEach { hours ->
+                    FilterChip(
+                        selected = hoursAhead == hours,
+                        onClick = { onHoursAhead(hours) },
+                        label = { Text("${hours}h") }
+                    )
+                }
+            }
+            Button(
+                onClick = onQuery,
+                enabled = !isCalculating,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                if (isCalculating) {
+                    CircularProgressIndicator(
+                        modifier = Modifier
+                            .height(18.dp)
+                            .width(18.dp),
+                        strokeWidth = 2.dp,
+                        color = MaterialTheme.colorScheme.onPrimary
+                    )
+                    Spacer(Modifier.width(8.dp))
+                }
+                Text(if (isCalculating) stringResource(R.string.mutual_calculating) else stringResource(R.string.mutual_query))
+            }
+        }
+    }
+}
+
+@Composable
+private fun MutualPassCard(
+    pass: MutualPass,
+    isExpanded: Boolean,
+    timeFormat: SimpleDateFormat,
+    minElevA: Double,
+    minElevB: Double,
+    onClick: () -> Unit,
+    onNavigateToRadar: () -> Unit
+) {
+    // Shared time cursor: both the elevation curve and the radar track view
+    // are controlled by this single progress value for bidirectional drag sync.
+    var dragProgress by remember(pass) { mutableFloatStateOf(0.5f) }
+
+    // Filter to only show the portion where both stations are above their minElev
+    val visibleSamples = remember(pass, minElevA, minElevB) {
+        pass.elevationSamples.filter { (_, elev) ->
+            elev.first >= minElevA && elev.second >= minElevB
+        }
+    }
+    val visibleTracks = remember(pass, minElevA, minElevB) {
+        pass.trackSamples.filter { it.elevationA >= minElevA && it.elevationB >= minElevB }
+    }
+    val visibleStart = visibleSamples.firstOrNull()?.first ?: pass.startTime
+    val visibleEnd = visibleSamples.lastOrNull()?.first ?: pass.endTime
+    val adjustedMaxElev = maxOf(
+        visibleSamples.maxOfOrNull { (_, elev) -> elev.first } ?: 10.0,
+        visibleSamples.maxOfOrNull { (_, elev) -> elev.second } ?: 10.0,
+        10.0
+    )
+    ElevatedCard(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+    ) {
+        Column(modifier = Modifier.padding(12.dp)) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = pass.name,
+                    style = MaterialTheme.typography.bodyLarge,
+                    fontWeight = FontWeight.Medium,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.weight(1f)
+                )
+                Text(
+                    text = "${timeFormat.format(Date(pass.startTime))} - ${timeFormat.format(Date(pass.endTime))}",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+            Spacer(Modifier.height(4.dp))
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    text = stringResource(R.string.mutual_elevation_you, pass.maxElevationA.toInt()),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.primary
+                )
+                Text(
+                    text = stringResource(R.string.mutual_elevation_opposite, pass.maxElevationB.toInt()),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.tertiary
+                )
+            }
+
+            AnimatedVisibility(
+                visible = isExpanded,
+                enter = expandVertically(),
+                exit = shrinkVertically()
+            ) {
+                Column {
+                    HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+                    // Dual-station radar track (polar plot)
+                    if (visibleTracks.isNotEmpty()) {
+                        Text(
+                            text = stringResource(R.string.mutual_both_tracks),
+                            style = MaterialTheme.typography.titleSmall,
+                            fontWeight = FontWeight.Medium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        MutualRadarView(
+                            trackSamples = visibleTracks,
+                            progress = dragProgress,
+                            labelA = stringResource(R.string.mutual_label_you),
+                            labelB = stringResource(R.string.mutual_label_opposite)
+                        )
+                        Spacer(Modifier.height(8.dp))
+                    }
+                    if (visibleSamples.isNotEmpty()) {
+                        ElevationCurveChart(
+                            samples = visibleSamples,
+                            startTime = visibleStart,
+                            endTime = visibleEnd,
+                            maxElev = adjustedMaxElev,
+                            progress = dragProgress,
+                            onProgressChange = { dragProgress = it }
+                        )
+                    }
+                    Spacer(Modifier.height(8.dp))
+                    OutlinedButton(
+                        onClick = onNavigateToRadar,
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Icon(
+                            painter = painterResource(id = R.drawable.ic_radar),
+                            contentDescription = null,
+                            modifier = Modifier.height(16.dp).width(16.dp)
+                        )
+                        Spacer(Modifier.width(6.dp))
+                        Text(stringResource(R.string.mutual_open_radar))
+                    }
+                }
+            }
+        }
+    }
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualViewModel.kt

@@ -0,0 +1,569 @@
+/*
+ * 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.mutual
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+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.repository.IMainContainer
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.math.PI
+import kotlin.math.floor
+import kotlin.math.roundToInt
+
+data class MutualUiState(
+    val stationALat: String = "",
+    val stationALon: String = "",
+    val stationAGrid: String = "",
+    val stationAMinElev: Double = 10.0,
+    val stationBLat: String = "",
+    val stationBLon: String = "",
+    val stationBGrid: String = "",
+    val stationBMinElev: Double = 10.0,
+    val hoursAhead: Int = 24,
+    val mutualPasses: List<MutualPass> = emptyList(),
+    val isCalculating: Boolean = false,
+    val hasSearched: Boolean = false,
+    val selectedPassIndex: Int = -1,
+    val errorMessage: String? = null
+)
+
+class MutualViewModel(
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(MutualUiState())
+    val uiState: StateFlow<MutualUiState> = _uiState.asStateFlow()
+
+    init {
+        // Pre-fill station A with the user's current station position (as grid),
+        // and default min elevation to the same value used by the main radar passes
+        val pos = settingsRepo.stationPosition.value
+        val grid = latLonToGrid(pos.latitude, pos.longitude)
+        _uiState.update { it.copy(
+            stationAGrid = grid,
+            stationALat = "%.4f".format(pos.latitude),
+            stationALon = "%.4f".format(pos.longitude),
+            stationAMinElev = 0.0,
+            stationBMinElev = 0.0
+        ) }
+    }
+
+    fun onStationALat(value: String) {
+        _uiState.update { it.copy(stationALat = value) }
+        val lat = value.toDoubleOrNull()
+        val lon = _uiState.value.stationALon.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationAGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationALon(value: String) {
+        _uiState.update { it.copy(stationALon = value) }
+        val lat = _uiState.value.stationALat.toDoubleOrNull()
+        val lon = value.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationAGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationAGrid(value: String) {
+        val old = _uiState.value.stationAGrid
+        _uiState.update { it.copy(stationAGrid = value) }
+        if (value.trim().uppercase() == old.trim().uppercase()) return
+        val pos = gridToLatLon(value.trim().uppercase())
+        if (pos != null) {
+            _uiState.update { it.copy(
+                stationALat = "%.4f".format(pos.latitude),
+                stationALon = "%.4f".format(pos.longitude)
+            )}
+        }
+    }
+
+    fun onStationBLat(value: String) {
+        _uiState.update { it.copy(stationBLat = value) }
+        val lat = value.toDoubleOrNull()
+        val lon = _uiState.value.stationBLon.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationBGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationBLon(value: String) {
+        _uiState.update { it.copy(stationBLon = value) }
+        val lat = _uiState.value.stationBLat.toDoubleOrNull()
+        val lon = value.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationBGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationBGrid(value: String) {
+        val old = _uiState.value.stationBGrid
+        _uiState.update { it.copy(stationBGrid = value) }
+        if (value.trim().uppercase() == old.trim().uppercase()) return
+        val pos = gridToLatLon(value.trim().uppercase())
+        if (pos != null) {
+            _uiState.update { it.copy(
+                stationBLat = "%.4f".format(pos.latitude),
+                stationBLon = "%.4f".format(pos.longitude)
+            )}
+        }
+    }
+    fun onStationAMinElev(value: Double) = _uiState.update { it.copy(stationAMinElev = value) }
+    fun onStationBMinElev(value: Double) = _uiState.update { it.copy(stationBMinElev = value) }
+    fun onUseCurrentPosition() {
+        val pos = settingsRepo.stationPosition.value
+        _uiState.update { it.copy(
+            stationALat = "%.4f".format(pos.latitude),
+            stationALon = "%.4f".format(pos.longitude),
+            stationAGrid = latLonToGrid(pos.latitude, pos.longitude)
+        ) }
+    }
+    fun onHoursAhead(value: Int) = _uiState.update { it.copy(hoursAhead = value) }
+    fun onSelectPass(index: Int) = _uiState.update { it.copy(selectedPassIndex = index) }
+
+    fun queryMutualPasses() {
+        val state = _uiState.value
+
+        // Resolve positions from lat/lon or grid
+        var posA = resolvePosition(state.stationALat, state.stationALon, state.stationAGrid)
+        var posB = resolvePosition(state.stationBLat, state.stationBLon, state.stationBGrid)
+
+        if (posA == null || posB == null) {
+            _uiState.update { it.copy(errorMessage = "Please enter valid coordinates or a Maidenhead grid (4/6/8 chars)") }
+            return
+        }
+
+        val satellites = satelliteRepo.satellites.value
+        if (satellites.isEmpty()) {
+            _uiState.update { it.copy(errorMessage = "No satellite data. Select satellites from the list first.") }
+            return
+        }
+
+        _uiState.update {
+            it.copy(
+                isCalculating = true,
+                hasSearched = true,
+                errorMessage = null,
+                mutualPasses = emptyList(),
+                selectedPassIndex = -1
+            )
+        }
+
+        viewModelScope.launch {
+            val time = System.currentTimeMillis()
+            val minElevA = state.stationAMinElev
+            val minElevB = state.stationBMinElev
+            val hours = state.hoursAhead
+
+            val results = withContext(Dispatchers.Default) {
+                findMutualPasses(satellites, posA, posB, minElevA, minElevB, time, hours)
+            }
+
+            val errorMsg = if (results.isEmpty()) {
+                // Debug: check if the main pass list is the culprit
+                val passCount = satelliteRepo.passes.value.size
+                val satCount = satellites.size
+                when {
+                    passCount == 0 -> "Pass list is empty. Select satellites from the list first."
+                    satCount == 0 -> "No satellites selected."
+                    else -> "No mutual passes found (${passCount} passes, ${satCount} satellites)."
+                }
+            } else null
+
+            _uiState.update {
+                it.copy(
+                    mutualPasses = results.sortedBy { mp -> mp.startTime },
+                    isCalculating = false,
+                    errorMessage = errorMsg
+                )
+            }
+        }
+    }
+
+    /** Resolve a position from lat/lon text or grid square text. */
+    private fun resolvePosition(latText: String, lonText: String, gridText: String): GeoPos? {
+        val trimmed = gridText.trim().uppercase()
+        if (trimmed.length in listOf(4, 6, 8) && trimmed.all { it.isLetterOrDigit() }) {
+            return gridToLatLon(trimmed)
+        }
+        val lat = latText.toDoubleOrNull()
+        val lon = lonText.toDoubleOrNull()
+        return if (lat != null && lon != null) GeoPos(lat, lon) else null
+    }
+
+    /** Convert lat/lon to Maidenhead grid (6-char). */
+    private fun latLonToGrid(lat: Double, lon: Double): String {
+        var adjLon = (lon + 180.0) % 360.0
+        var adjLat = (lat + 90.0) % 180.0
+
+        val fieldLon = (adjLon / 20.0).toInt()
+        val fieldLat = (adjLat / 10.0).toInt()
+        adjLon -= fieldLon * 20.0
+        adjLat -= fieldLat * 10.0
+
+        val squareLon = (adjLon / 2.0).toInt()
+        val squareLat = (adjLat / 1.0).toInt()
+        adjLon -= squareLon * 2.0
+        adjLat -= squareLat * 1.0
+
+        val subLon = (adjLon * 60.0 / 5.0).toInt()
+        val subLat = (adjLat * 60.0 / 2.5).toInt()
+
+        return buildString {
+            append('A' + fieldLon)
+            append('A' + fieldLat)
+            append('0' + squareLon)
+            append('0' + squareLat)
+            append('A' + subLon)
+            append('A' + subLat)
+        }
+    }
+
+    /** Convert Maidenhead grid (4, 6, or 8 chars) to lat/lon center of the square. */
+    private fun gridToLatLon(grid: String): GeoPos? {
+        val g = grid.uppercase()
+        if (g.length < 4) return null
+        val lonField = (g[0] - 'A').toDouble() * 20.0
+        val latField = (g[1] - 'A').toDouble() * 10.0
+        if (lonField < 0 || lonField > 340 || latField < 0 || latField > 170) return null
+
+        val lonSquare = (g[2] - '0').toDouble() * 2.0
+        val latSquare = (g[3] - '0').toDouble() * 1.0
+        if (lonSquare < 0 || lonSquare > 18 || latSquare < 0 || latSquare > 9) return null
+
+        var lon = lonField + lonSquare
+        var lat = latField + latSquare
+
+        if (g.length >= 6) {
+            val lonSub = (g[4] - 'A').toDouble() * 5.0 / 60.0
+            val latSub = (g[5] - 'A').toDouble() * 2.5 / 60.0
+            if (lonSub < 0 || lonSub > 115.0 / 60.0 || latSub < 0 || latSub > 57.5 / 60.0) return null
+            lon += lonSub
+            lat += latSub
+
+            if (g.length >= 8) {
+                val lonExt = (g[6] - '0').toDouble() * 30.0 / 3600.0
+                val latExt = (g[7] - '0').toDouble() * 15.0 / 3600.0
+                if (lonExt < 0 || lonExt > 270.0 / 3600.0 || latExt < 0 || latExt > 135.0 / 3600.0) return null
+                lon += lonExt + 15.0 / 3600.0
+                lat += latExt + 7.5 / 3600.0
+            } else {
+                lon += 2.5 / 60.0
+                lat += 1.25 / 60.0
+            }
+        } else {
+            lon += 1.0
+            lat += 0.5
+        }
+
+        lon = lon - 180.0
+        lat = lat - 90.0
+        return GeoPos(lat, lon)
+    }
+
+    private fun findMutualPasses(
+        satellites: List<OrbitalObject>,
+        posA: GeoPos, posB: GeoPos,
+        minElevADeg: Double, minElevBDeg: Double,
+        time: Long, hours: Int
+    ): List<MutualPass> {
+        val endTime = time + hours * 60L * 60L * 1000L
+        val sampleInterval = 5_000L
+
+        // Use the main page's pass list for AOS/LOS times, then sample the curves
+        // using the actual positions. The passes list is already computed by getLeoPass
+        // and its AOS/LOS times match the Passes page exactly.
+        val existingPasses = satelliteRepo.passes.value
+        val results = findMutualPassesFromList(existingPasses, satellites, posA, posB,
+            minElevADeg, minElevBDeg, time, endTime, sampleInterval)
+        if (results.isNotEmpty()) return results
+
+        // Fallback: try the independent search.
+        return findMutualPassesFallback(satellites, posA, posB,
+            minElevADeg, minElevBDeg, time, endTime, sampleInterval)
+    }
+
+    /** Reuse the main page's pass list. Uses AOS/LOS times directly (no refineEdge) */
+    private fun findMutualPassesFromList(
+        existingPasses: List<OrbitalPass>,
+        satellites: List<OrbitalObject>,
+        posA: GeoPos, posB: GeoPos,
+        minElevADeg: Double, minElevBDeg: Double,
+        time: Long, endTime: Long, sampleInterval: Long
+    ): List<MutualPass> {
+        val results = mutableListOf<MutualPass>()
+        for (pass in existingPasses) {
+            if (pass.losTime <= time || pass.aosTime >= endTime) continue
+            if (pass.isDeepSpace) continue
+            if (pass.orbitalObject.data.meanmo < 1e-8) continue
+
+            val sat = pass.orbitalObject
+            // Refine the AOS/LOS to the actual posA/posB (0° horizon).
+            // This ensures the elevation curve starts from ~0°.
+            val refinedAos = refineEdge(sat, posA, posB, pass.aosTime, 1_000L, goingUp = true)
+            val refinedLos = refineEdge(sat, posA, posB, pass.losTime, 1_000L, goingUp = false)
+            if (refinedLos <= refinedAos) continue
+
+            val samples = mutableListOf<Pair<Long, Pair<Double, Double>>>()
+            val tracks = mutableListOf<TrackSample>()
+            var maxElevA = 0.0
+            var maxElevB = 0.0
+
+            var tSample = refinedAos
+            while (tSample <= refinedLos) {
+                // Use getElevation (same function used by getLeoPass) for elevation,
+                // and getFullPosition only for azimuth.
+                val elevA = sat.getElevation(posA, tSample) * 180.0 / PI
+                val elevB = sat.getElevation(posB, tSample) * 180.0 / PI
+                val fullA = sat.getFullPosition(posA, tSample)
+                val fullB = sat.getFullPosition(posB, tSample)
+                if (elevA > maxElevA) maxElevA = elevA
+                if (elevB > maxElevB) maxElevB = elevB
+                samples.add(tSample to (elevA to elevB))
+                tracks.add(
+                    TrackSample(
+                        time = tSample,
+                        azimuthA = fullA.azimuth * 180.0 / PI,
+                        elevationA = elevA,
+                        azimuthB = fullB.azimuth * 180.0 / PI,
+                        elevationB = elevB
+                    )
+                )
+                tSample += sampleInterval
+            }
+
+            // Search uses the 0° horizon as the pass boundary, but the user sliders are
+            // a final visibility filter. Both stations must exceed their own threshold;
+            // otherwise the result would expand to an empty filtered chart.
+            if (maxElevA > minElevADeg && maxElevB > minElevBDeg) {
+                results.add(
+                    MutualPass(
+                        catNum = pass.catNum,
+                        name = pass.orbitalObject.data.name,
+                        startTime = refinedAos,
+                        endTime = refinedLos,
+                        maxElevationA = (maxElevA * 10).roundToInt() / 10.0,
+                        maxElevationB = (maxElevB * 10).roundToInt() / 10.0,
+                        elevationSamples = samples,
+                        trackSamples = tracks
+                    )
+                )
+            }
+        }
+        return results
+    }
+
+    /** Fallback: search passes independently (same logic as original findMutualPasses). */
+    private fun findMutualPassesFallback(
+        satellites: List<OrbitalObject>,
+        posA: GeoPos, posB: GeoPos,
+        minElevADeg: Double, minElevBDeg: Double,
+        time: Long, endTime: Long, sampleInterval: Long
+    ): List<MutualPass> {
+        val results = mutableListOf<MutualPass>()
+        for (sat in satellites) {
+            if (sat.data.meanmo < 1e-8) continue
+            var searchStart = time
+            while (true) {
+                val t = findNextMutualPass(sat, posA, posB, searchStart, endTime)
+                if (t == null) break
+                val (aos, los) = t
+
+                val refinedAos = refineEdge(sat, posA, posB, aos, 1_000L, true)
+                val refinedLos = refineEdge(sat, posA, posB, los, 1_000L, false)
+                if (refinedLos <= refinedAos) continue
+
+                val mutualPass = sampleMutualPass(sat, posA, posB, refinedAos, refinedLos,
+                    minElevADeg, minElevBDeg, sampleInterval)
+                if (mutualPass != null) results.add(mutualPass)
+                searchStart = refinedLos + 120_000L
+            }
+        }
+        return results
+    }
+
+    /** Sample elevation/azimuth data for one mutual pass window. */
+    private fun sampleMutualPass(
+        sat: OrbitalObject, posA: GeoPos, posB: GeoPos,
+        refinedAos: Long, refinedLos: Long,
+        minElevADeg: Double, minElevBDeg: Double,
+        sampleInterval: Long
+    ): MutualPass? {
+        val samples = mutableListOf<Pair<Long, Pair<Double, Double>>>()
+        val tracks = mutableListOf<TrackSample>()
+        var maxElevA = 0.0
+        var maxElevB = 0.0
+
+        var tSample = refinedAos
+        while (tSample <= refinedLos) {
+            // Use getElevation for elevation, matching the main pass predictor; use
+            // getFullPosition only for azimuth needed by the radar plot.
+            val elevA = elevationDeg(sat, posA, tSample)
+            val elevB = elevationDeg(sat, posB, tSample)
+            val fullA = sat.getFullPosition(posA, tSample)
+            val fullB = sat.getFullPosition(posB, tSample)
+            if (elevA > maxElevA) maxElevA = elevA
+            if (elevB > maxElevB) maxElevB = elevB
+            samples.add(tSample to (elevA to elevB))
+            tracks.add(
+                TrackSample(
+                    time = tSample,
+                    azimuthA = fullA.azimuth * 180.0 / PI,
+                    elevationA = elevA,
+                    azimuthB = fullB.azimuth * 180.0 / PI,
+                    elevationB = elevB
+                )
+            )
+            tSample += sampleInterval
+        }
+
+        if (maxElevA > minElevADeg && maxElevB > minElevBDeg) {
+            return MutualPass(
+                catNum = sat.data.catnum,
+                name = sat.data.name,
+                startTime = refinedAos,
+                endTime = refinedLos,
+                maxElevationA = (maxElevA * 10).roundToInt() / 10.0,
+                maxElevationB = (maxElevB * 10).roundToInt() / 10.0,
+                elevationSamples = samples,
+                trackSamples = tracks
+            )
+        }
+        return null
+    }
+
+    /** Refine the AOS (goingUp=true) or LOS (goingUp=false) to ~1s precision at the 0° horizon. */
+    private fun refineEdge(
+        sat: OrbitalObject, posA: GeoPos, posB: GeoPos,
+        approxTime: Long, step: Long, goingUp: Boolean
+    ): Long {
+        if (goingUp) {
+            // AOS: walk backward from approxTime to find the last sample where either is below
+            // the horizon, then AOS is the next step after that.
+            var t = approxTime
+            while (t > approxTime - 70_000L) {
+                val eA = elevationDeg(sat, posA, t)
+                val eB = elevationDeg(sat, posB, t)
+                if (eA > 0.0 && eB > 0.0) {
+                    t -= step
+                } else {
+                    return t + step
+                }
+            }
+            return approxTime - 70_000L + step
+        } else {
+            // LOS: walk forward from approxTime to find the first sample where either drops
+            // below the horizon, then LOS is the step before that.
+            var t = approxTime
+            while (t < approxTime + 70_000L) {
+                val eA = elevationDeg(sat, posA, t)
+                val eB = elevationDeg(sat, posB, t)
+                if (eA > 0.0 && eB > 0.0) {
+                    t += step
+                } else {
+                    return t - step
+                }
+            }
+            return approxTime + 70_000L - step
+        }
+    }
+
+    private fun elevationDeg(sat: OrbitalObject, pos: GeoPos, time: Long): Double {
+        return sat.getElevation(pos, time) * 180.0 / PI
+    }
+
+    private fun findNextMutualPass(
+        sat: OrbitalObject,
+        posA: GeoPos, posB: GeoPos,
+        startTime: Long, endTime: Long
+    ): Pair<Long, Long>? {
+        var t = startTime
+        val step = 60_000L
+
+        // Skip an in-progress mutual window at the search start (same as getLeoPass):
+        // walk forward until either station drops below the horizon, then keep searching.
+        if (elevationDeg(sat, posA, t) > 0.0 && elevationDeg(sat, posB, t) > 0.0) {
+            while (t < endTime) {
+                if (elevationDeg(sat, posA, t) <= 0.0 || elevationDeg(sat, posB, t) <= 0.0) break
+                t += step
+            }
+        }
+
+        while (t < endTime) {
+            val elevA = elevationDeg(sat, posA, t)
+            val elevB = elevationDeg(sat, posB, t)
+
+            if (elevA > 0.0 && elevB > 0.0) {
+                var aos = t
+                var rew = t
+                while (rew > startTime - 600_000L) {
+                    val eA = elevationDeg(sat, posA, rew)
+                    val eB = elevationDeg(sat, posB, rew)
+                    if (eA <= 0.0 || eB <= 0.0) {
+                        aos = rew + step
+                        break
+                    }
+                    rew -= step
+                }
+
+                var los = t
+                var fwd = t
+                while (fwd < endTime + 600_000L) {
+                    val eA = elevationDeg(sat, posA, fwd)
+                    val eB = elevationDeg(sat, posB, fwd)
+                    if (eA <= 0.0 || eB <= 0.0) {
+                        los = fwd
+                        break
+                    }
+                    fwd += step
+                }
+
+                if (los > aos) return Pair(aos, los)
+            }
+            t += step
+        }
+        return null
+    }
+
+    fun clearError() = _uiState.update { it.copy(errorMessage = null) }
+
+    companion object {
+        fun factory(container: IMainContainer) = object : ViewModelProvider.Factory {
+            @Suppress("UNCHECKED_CAST")
+            override fun <T : ViewModel> create(modelClass: Class<T>): T =
+                MutualViewModel(
+                    satelliteRepo = container.satelliteRepo,
+                    settingsRepo = container.settingsRepo
+                ) as T
+        }
+    }
+}

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
@@ -55,7 +59,10 @@ import com.rtbishop.look4sat.core.presentation.LocalSpacing
 import com.rtbishop.look4sat.core.presentation.MainTheme
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.SharedDialog
+import com.rtbishop.look4sat.core.presentation.ElevationHighColor
+import com.rtbishop.look4sat.core.presentation.ElevationLowColor
 import com.rtbishop.look4sat.core.presentation.elevationColor
+import kotlin.math.roundToInt
 
 private val allModes = listOf(
     "AFSK", "AFSK S-Net", "AFSK SALSAT", "AHRPT", "AM", "APT", "BPSK", "BPSK PMT-A3",
@@ -66,33 +73,81 @@ private val allModes = listOf(
 )
 
 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,
@@ -104,24 +159,74 @@ internal fun PassesDialog(
         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,
-    accentColor: Color = MaterialTheme.colorScheme.primary,
-    onChange: (Float) -> Unit
+    trailingContent: @Composable () -> Unit,
+    sliderContent: @Composable () -> Unit
 ) {
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -138,6 +243,26 @@ 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,
@@ -151,10 +276,89 @@ private fun SliderRow(
                 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,
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(20.dp)
+            )
+            Text(
+                text = displayValue,
+                fontSize = 18.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary
+            )
+        }
+    ) {
+        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()
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 private fun RadiosDialogPreview() {

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

@@ -67,11 +67,11 @@ 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
@@ -84,29 +84,50 @@ import java.util.Locale
 import java.util.TimeZone
 
 @Composable
-fun PassesDestination(navigateToRadar: (Int, Long) -> Unit) {
+fun PassesDestination(
+    navigateToRadar: (Int, Long) -> Unit,
+    navigateToMap: () -> Unit
+) {
     val context = LocalContext.current
     val container = (context.applicationContext as IContainerProvider).getMainContainer()
     val viewModel: PassesViewModel = viewModel(factory = PassesViewModel.factory(container))
     val uiState = viewModel.uiState.collectAsStateWithLifecycle().value
-    PassesScreen(uiState, viewModel::onAction, navigateToRadar)
+    PassesScreen(uiState, viewModel::onAction, navigateToRadar, navigateToMap)
 }
 
 @Composable
 private fun PassesScreen(
     uiState: PassesState,
     onAction: (PassesAction) -> Unit,
-    navigateToRadar: (Int, Long) -> Unit
+    navigateToRadar: (Int, Long) -> Unit,
+    navigateToMap: () -> 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(
@@ -117,11 +138,19 @@ 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)
+            )
         }
     }
     ScreenColumn(
@@ -138,7 +167,7 @@ private fun PassesScreen(
                     NextPassRow(pass = uiState.nextPass, isUtc = uiState.isUtc)
                 },
                 endAction = {
-                    IconCard(action = { onAction(PassesAction.ToggleRadiosDialog) }, resId = R.drawable.ic_radios)
+                    IconCard(action = navigateToMap, resId = R.drawable.ic_map)
                 }
             )
         }
@@ -291,13 +320,12 @@ private fun PassItem(
     isVerticalLayout: Boolean = true,
     isUtc: Boolean = false
 ) {
-    val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
     val horizontalPadding = if (isVerticalLayout) 6.dp else 10.dp
     val timeZone = remember(isUtc) {
         if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
     }
     val sdfTime = remember(isUtc) {
-        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", Locale.getDefault()).also { it.timeZone = timeZone }
     }
     val aosTimeStr = remember(pass.aosTime, isUtc) { sdfTime.format(Date(pass.aosTime)) }
     val losTimeStr = remember(pass.losTime, isUtc) { sdfTime.format(Date(pass.losTime)) }
@@ -317,10 +345,6 @@ private fun PassItem(
                 .padding(horizontal = horizontalPadding, vertical = 4.dp)
         ) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "$passSatId - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
                 Text(
                     text = pass.name,
                     modifier = Modifier
@@ -330,7 +354,7 @@ private fun PassItem(
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis,
-                    color = MaterialTheme.colorScheme.onSurface
+                    color = MaterialTheme.colorScheme.primary
                 )
                 val elevColor = elevationColor(pass.maxElevation)
                 Icon(

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

@@ -29,6 +29,11 @@ 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(),
@@ -40,7 +45,16 @@ data class PassesState(
 
 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

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

@@ -23,6 +23,7 @@ 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.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
@@ -38,6 +39,7 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import java.text.SimpleDateFormat
+import java.util.Calendar
 import java.util.Date
 import java.util.Locale
 import java.util.TimeZone
@@ -54,6 +56,11 @@ 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,
             shouldSeeWhatsNew = settingsRepo.otherSettings.value.shouldSeeWhatsNew
@@ -71,7 +78,14 @@ class PassesViewModel(
         // 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) }
+                _uiState.update {
+                    it.copy(
+                        isUtc = settings.stateOfUtc,
+                        shouldSeeWhatsNew = settings.shouldSeeWhatsNew,
+                        lowElevation = settings.lowElevation,
+                        highElevation = settings.highElevation
+                    )
+                }
             }
         }
         // Main tick loop: reacts to new passes, then ticks every second
@@ -107,9 +121,29 @@ class PassesViewModel(
         when (action) {
             PassesAction.DismissWhatsNew -> settingsRepo.setWhatsNewDismissed()
             is PassesAction.FilterPasses ->
-                applyFilter(action.hoursAhead, action.minElevation, action.showDeepSpace, _uiState.value.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,
+                    modes = _uiState.value.modes
+                )
             is PassesAction.FilterRadios ->
-                applyFilter(_uiState.value.hours, _uiState.value.elevation, _uiState.value.showDeepSpace, action.modes)
+                applyFilter(
+                    hoursAhead = _uiState.value.hours,
+                    minElevation = _uiState.value.elevation,
+                    lowElevation = _uiState.value.lowElevation,
+                    highElevation = _uiState.value.highElevation,
+                    aosStartMinute = _uiState.value.aosStartMinute,
+                    aosEndMinute = _uiState.value.aosEndMinute,
+                    invertAosTimeWindow = _uiState.value.invertAosTimeWindow,
+                    showDeepSpace = _uiState.value.showDeepSpace,
+                    modes = action.modes
+                )
             PassesAction.RefreshPasses -> refreshPasses()
             PassesAction.TogglePassesDialog ->
                 _uiState.update { it.copy(isPassesDialogShown = !it.isPassesDialogShown) }
@@ -120,16 +154,30 @@ class PassesViewModel(
         }
     }
 
-    // Computes sunrise/sunset strings for each unique calendar day in the pass list, plus today for DeepSpace
+    /** Returns a locale-appropriate date format for pass grouping headers. */
+    private fun dateFormat(tz: TimeZone): SimpleDateFormat {
+        val pattern = if (Locale.getDefault().language == "zh") {
+            "yyyy'年'M'月'd'日' EEEE"
+        } else {
+            "EEE, dd MMM yyyy"
+        }
+        return SimpleDateFormat(pattern, Locale.getDefault()).also { it.timeZone = tz }
+    }
+
+    // Computes sunrise/sunset strings for each unique calendar day in the pass list, plus today for DeepSpace.
+    // CelestialComputer.findSunRiseSet() returns the next rise/set after the supplied time, so pass
+    // the calendar day's 00:00 in the same timezone used by the visible date group. Passing a pass's
+    // AOS time can jump to the following day's sunrise/sunset when that AOS is after the local event.
+    // For white nights / polar day edge cases, we fall back to searching from the previous day.
     private fun computeSunTimes(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, Pair<String, String>> {
         val stationPos = settingsRepo.stationPosition.value
         val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
-        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
-        val sdfTime = SimpleDateFormat("HH:mm", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfDate = dateFormat(tz)
+        val sdfTime = SimpleDateFormat("HH:mm", Locale.getDefault()).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 riseSet = findTodaySunRiseSet(stationPos, startOfDayMillis(System.currentTimeMillis(), tz))
             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
@@ -138,7 +186,7 @@ class PassesViewModel(
             if (pass.isDeepSpace) continue
             val label = sdfDate.format(Date(pass.aosTime))
             if (label in result) continue
-            val riseSet = CelestialComputer.findSunRiseSet(stationPos, pass.aosTime)
+            val riseSet = findTodaySunRiseSet(stationPos, startOfDayMillis(pass.aosTime, tz))
             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
@@ -146,9 +194,46 @@ class PassesViewModel(
         return result
     }
 
+    /**
+     * Find today's sunrise and sunset by starting from local midnight.
+     * Handles the white nights / polar day edge case where the sun is still above
+     * the -0.8333° threshold at midnight: in that case we search from the previous
+     * day's midnight to find a valid sunrise/sunset pair within the target day.
+     */
+    private fun findTodaySunRiseSet(observer: GeoPos, localMidnightMillis: Long): CelestialComputer.RiseSetTimes {
+        val threshold = 0.8333
+        val sunPos = CelestialComputer.getSunPosition(observer, localMidnightMillis)
+        if (sunPos.elevation > -threshold) {
+            // White nights / polar day: the sun is too high at midnight.
+            // Search from earlier days so the algorithm goes through a full
+            // sunset → sunrise → sunset cycle, landing in the target day.
+            val dayEnd = localMidnightMillis + 86400000L
+            for (offset in 1..3) {
+                val result = CelestialComputer.findSunRiseSet(observer, localMidnightMillis - offset * 86400000L)
+                if (result.riseTimeMillis in localMidnightMillis..dayEnd &&
+                    result.setTimeMillis in localMidnightMillis..dayEnd) {
+                    return result
+                }
+            }
+            // No valid pair found (midnight sun / polar day)
+            return CelestialComputer.RiseSetTimes(0L, 0L)
+        }
+        return CelestialComputer.findSunRiseSet(observer, localMidnightMillis)
+    }
+
+    private fun startOfDayMillis(timeMillis: Long, tz: TimeZone): Long {
+        return Calendar.getInstance(tz, Locale.getDefault()).apply {
+            timeInMillis = timeMillis
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
     private fun groupPasses(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, List<OrbitalPass>> {
         val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
-        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfDate = dateFormat(tz)
         val ordered = LinkedHashMap<String, List<OrbitalPass>>()
         val deepSpace = passes.filter { it.isDeepSpace }
         if (deepSpace.isNotEmpty()) ordered["DeepSpace (period >225min)"] = deepSpace
@@ -198,19 +283,61 @@ class PassesViewModel(
     private fun applyFilter(
         hoursAhead: Int,
         minElevation: Double,
+        lowElevation: Double,
+        highElevation: Double,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean,
         showDeepSpace: Boolean,
         modes: List<String>
     ) = viewModelScope.launch {
-        settingsRepo.setPassesSettings(PassesSettings(showDeepSpace, hoursAhead, minElevation, modes))
+        settingsRepo.setPassesSettings(
+            PassesSettings(
+                showDeepSpace,
+                hoursAhead,
+                minElevation,
+                aosStartMinute,
+                aosEndMinute,
+                invertAosTimeWindow,
+                modes
+            )
+        )
+        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,
+                modes = modes
+            )
         }
-        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
+        satelliteRepo.calculatePasses(
+            time = System.currentTimeMillis(),
+            hoursAhead = hoursAhead,
+            minElevation = minElevation,
+            aosStartMinute = aosStartMinute,
+            aosEndMinute = aosEndMinute,
+            invertAosTimeWindow = 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 = settings.selectedModes
+        )
     }
 
     companion object {

feature/radar/build.gradle.kts

@@ -4,4 +4,4 @@ plugins {
 
 android {
     namespace = "com.rtbishop.look4sat.feature.radar"
-}
+}

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

@@ -45,6 +45,7 @@ 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
@@ -59,6 +60,8 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
+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
@@ -71,18 +74,45 @@ import com.rtbishop.look4sat.core.presentation.getDefaultPass
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import com.rtbishop.look4sat.core.presentation.layoutPadding
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+import kotlin.math.PI
 
 private enum class RadarPage(val title: String) {
     Transceivers("Transceivers"),
+    Calculator("Calculator"),
     Sstv("SSTV")
 }
 
 @Composable
-fun RadarDestination(navigateUp: () -> Unit) {
+fun RadarDestination(navigateUp: () -> Unit, navigateToMap: () -> 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()
+    val mutualData by container.mutualPassData.collectAsStateWithLifecycle()
+    val navigateUpAndClearMutual = {
+        if (container.mutualPassData.value.endTime > 0L) {
+            container.setMutualPassData(MutualPassData())
+        }
+        navigateUp()
+    }
+    val navigateToMapAndClearMutual = {
+        if (container.mutualPassData.value.endTime > 0L) {
+            container.setMutualPassData(MutualPassData())
+        }
+        navigateToMap()
+    }
+    LaunchedEffect(mutualData.endTime) {
+        if (mutualData.endTime <= 0L) return@LaunchedEffect
+        while (true) {
+            val remainingMs = mutualData.endTime - System.currentTimeMillis()
+            if (remainingMs <= 0L) {
+                navigateUpAndClearMutual()
+                return@LaunchedEffect
+            }
+            delay(remainingMs.coerceAtMost(1000L))
+        }
+    }
     // Sync actual permission state on every recomposition so it survives screen re-entry
     val hasPermission = ContextCompat.checkSelfPermission(
         context, Manifest.permission.RECORD_AUDIO
@@ -92,8 +122,10 @@ fun RadarDestination(navigateUp: () -> Unit) {
     }
     val permissionLauncher = rememberLauncherForActivityResult(
         ActivityResultContracts.RequestPermission()
-    ) { granted -> viewModel.onAction(RadarAction.SstvPermissionResult(granted)) }
-    RadarScreen(uiState, viewModel::onAction, navigateUp, requestMicPermission = {
+    ) { granted ->
+        viewModel.onAction(RadarAction.SstvPermissionResult(granted))
+    }
+    RadarScreen(uiState, viewModel::onAction, navigateUpAndClearMutual, navigateToMapAndClearMutual, mutualData, requestMicPermission = {
         permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
     })
 }
@@ -103,12 +135,35 @@ private fun RadarScreen(
     uiState: RadarState,
     onAction: (RadarAction) -> Unit,
     navigateUp: () -> Unit,
+    navigateToMap: () -> Unit,
+    mutualData: MutualPassData,
     requestMicPermission: () -> Unit
 ) {
     val upcomingPass = uiState.currentPass ?: getDefaultPass()
-    val addToCalendar: () -> Unit = {
-        uiState.currentPass?.let { onAction(RadarAction.AddToCalendar(it.name, it.aosTime, it.losTime)) }
+    // Station-B overlay: full track line (only where B's elevation > 0) + live position dot
+    // at the current moment, same display mode as the local station.
+    val trackB = remember(mutualData.trackSamples) {
+        mutualData.trackSamples
+            .filter { it.elevationB > 0.0 }
+            .map {
+                OrbitalPos(
+                    azimuth = it.azimuthB * PI / 180.0,
+                    elevation = it.elevationB * PI / 180.0,
+                    time = it.time
+                )
+            }
     }
+    val timeNow = System.currentTimeMillis()
+    val trackBPosition = mutualData.trackSamples
+        .filter { it.time <= timeNow }
+        .lastOrNull()
+        ?.let {
+            OrbitalPos(
+                azimuth = it.azimuthB * PI / 180.0,
+                elevation = it.elevationB * PI / 180.0,
+                time = it.time
+            )
+        }
     Column(
         modifier = Modifier
             .layoutPadding()
@@ -120,7 +175,7 @@ private fun RadarScreen(
             TopBar {
                 IconCard(action = navigateUp, resId = R.drawable.ic_back)
                 TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
+                IconCard(action = navigateToMap, resId = R.drawable.ic_map)
             }
             TopBar { NextPassRow(pass = upcomingPass, isUtc = uiState.isUtc) }
         } else {
@@ -128,15 +183,15 @@ private fun RadarScreen(
                 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 = addToCalendar, resId = R.drawable.ic_calendar)
+                IconCard(action = navigateToMap, resId = R.drawable.ic_map)
             }
         }
         if (isVertical) {
-            RadarCard(uiState, Modifier.weight(1f))
+            RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
             PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
         } else {
             Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                RadarCard(uiState, Modifier.weight(1f))
+                RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
                 PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
             }
         }
@@ -150,16 +205,31 @@ private fun PagerCard(
     requestMicPermission: () -> Unit,
     modifier: Modifier = Modifier
 ) {
-    val pages = RadarPage.entries
+    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()) {
-            PrimaryTabRow(selectedTabIndex = pagerState.currentPage) {
+            val selectedTabIndex = pagerState.currentPage.coerceIn(0, pages.lastIndex)
+            PrimaryTabRow(selectedTabIndex = selectedTabIndex) {
                 pages.forEachIndexed { index, page ->
                     Tab(
-                        selected = pagerState.currentPage == index,
+                        selected = selectedTabIndex == index,
                         onClick = { coroutineScope.launch { pagerState.animateScrollToPage(index) } },
                         text = { Text(text = page.title, maxLines = 1, overflow = TextOverflow.Ellipsis) }
                     )
@@ -176,6 +246,13 @@ private fun PagerCard(
                         radioControl = uiState.radioControl,
                         onAction = onAction
                     )
+                    RadarPage.Calculator -> CalculatorPage(
+                        transceivers = uiState.transceivers.transmitters,
+                        selectedUuid = uiState.transceivers.selectedUuid,
+                        orbitalPos = uiState.orbitalPos,
+                        calculatorOffsetKHz = uiState.calculatorOffsetKHz,
+                        onAction = onAction
+                    )
                     RadarPage.Sstv -> SstvPage(
                         sstv = uiState.sstv,
                         dopplerFrequency = uiState.transceivers.selectedFrequency?.let { formatFrequency(it) },
@@ -189,7 +266,12 @@ private fun PagerCard(
 }
 
 @Composable
-private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
+private fun RadarCard(
+    uiState: RadarState,
+    trackB: List<OrbitalPos> = emptyList(),
+    trackBPosition: OrbitalPos? = null,
+    modifier: Modifier = Modifier
+) {
     val satellitePos = uiState.orbitalPos
     val shouldAnimateBorder = satellitePos?.aboveHorizon == true && satellitePos.eclipsed
     // Always call these composables unconditionally — conditional composable calls violate
@@ -222,6 +304,8 @@ private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
                 RadarViewCompose(
                     item = position,
                     items = uiState.satTrack,
+                    trackB = trackB.takeIf { it.isNotEmpty() },
+                    trackBPosition = trackBPosition,
                     azimElev = uiState.orientationValues,
                     shouldShowSweep = uiState.shouldShowSweep,
                     shouldUseCompass = uiState.shouldUseCompass,

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

@@ -22,6 +22,7 @@ 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 = "",
@@ -61,7 +62,14 @@ data class RadarState(
     val moonPosition: CelestialComputer.MoonPosition? = null,
     val transceivers: TransceiverSubState = TransceiverSubState(),
     val radioControl: RadioControlSubState = RadioControlSubState(),
-    val sstv: SstvSubState = SstvSubState()
+    val sstv: SstvSubState = SstvSubState(),
+    val mutualSamples: List<Pair<Long, Pair<Double, Double>>> = emptyList(),
+    val mutualStartTime: Long = 0L,
+    val mutualEndTime: Long = 0L,
+    val mutualMaxElev: Double = 10.0,
+    val mutualLabelA: String = "你",
+    val mutualLabelB: String = "友台",
+    val calculatorOffsetKHz: String = ""
 )
 
 enum class SstvStatus { Idle, Recording }
@@ -72,7 +80,8 @@ data class SstvSubState(
     val hasPermission: Boolean = false,
     val selectedMode: String = "Auto",
     val supportedModes: List<String> = emptyList(),
-    val currentFrame: SstvFrame? = null
+    val currentFrame: SstvFrame? = null,
+    val diagnosticsMetrics: SstvQualityMetrics? = null
 )
 
 sealed interface RadarAction {
@@ -94,4 +103,7 @@ sealed interface RadarAction {
     data object SstvReset : RadarAction
     data class SstvSelectMode(val modeName: String) : RadarAction
     data class SstvPermissionResult(val granted: Boolean) : RadarAction
+
+    // Calculator actions
+    data class ChangeCalculatorOffset(val offsetKHz: String) : RadarAction
 }

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

@@ -60,6 +60,8 @@ 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.PI
+import kotlin.math.abs
 import kotlin.math.cos
 import kotlin.math.sin
 
@@ -71,6 +73,9 @@ private const val SWEEP_DURATION_MS = 8_000
 fun RadarViewCompose(
     item: OrbitalPos,
     items: List<OrbitalPos>,
+    trackB: List<OrbitalPos>? = null,
+    trackBColor: Color = MaterialTheme.colorScheme.tertiary,
+    trackBPosition: OrbitalPos? = null,
     azimElev: Pair<Float, Float>,
     shouldShowSweep: Boolean,
     shouldUseCompass: Boolean,
@@ -107,18 +112,27 @@ fun RadarViewCompose(
     var cachedSweepColor by remember { mutableStateOf(Color.Unspecified) }
     var trackPath by remember { mutableStateOf(Path()) }
     var trackEffect by remember { mutableStateOf(PathEffect.cornerPathEffect(0f)) }
+    // Station-B overlay track (dashed, with the same directional arrow stamp as station A)
+    var cachedTrackBRef by remember { mutableStateOf<List<OrbitalPos>?>(null) }
+    var trackBPath by remember { mutableStateOf(Path()) }
+    var trackBEffect 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
         // Rebuild track path and sweep brush when canvas size or track data changes
-        if (radius != cachedRadius || items !== cachedItemsRef) {
+        if (radius != cachedRadius || items !== cachedItemsRef || trackB !== cachedTrackBRef) {
             trackPath = createTrackPath(items, radius)
             trackEffect = createTrackEffect(trackPath)
+            val newTrackBPath = trackB?.let { createTrackPath(it, radius) } ?: Path()
+            trackBPath = newTrackBPath
+            trackBEffect = if (!newTrackBPath.isEmpty) createTrackEffect(newTrackBPath)
+            else PathEffect.cornerPathEffect(0f)
             cachedSweepBrush = makeSweepBrush(center, primaryColor)
             cachedRadius = radius
             cachedItemsRef = items
+            cachedTrackBRef = trackB
             cachedSweepColor = primaryColor
         } else if (primaryColor != cachedSweepColor) {
             // Rebuild brush on theme change without waiting for a size change
@@ -131,6 +145,20 @@ fun RadarViewCompose(
             drawElevationLabels(radius, primaryColor, measurer)
             translate(center.x, center.y) {
                 drawTrack(trackPath, trackEffect, aimColor, primaryColor)
+                // Station-B overlay: full dashed track + directional arrows + live position dot
+                // (same display mode as the local station: track line/arrow + pulsing dot)
+                if (trackB != null && trackB.isNotEmpty() && !trackBPath.isEmpty) {
+                    drawPath(
+                        trackBPath, trackBColor,
+                        style = Stroke(STROKE_WIDTH, pathEffect = PathEffect.dashPathEffect(floatArrayOf(18f, 12f)))
+                    )
+                    drawPath(trackBPath, trackBColor, style = Stroke(pathEffect = trackBEffect))
+                }
+                trackBPosition?.let { posB ->
+                    if (posB.elevation > 0) {
+                        drawPosition(posB, radius, animScale, trackBColor)
+                    }
+                }
                 if (item.elevation > 0) {
                     drawPosition(item, radius, animScale, primaryColor)
                 }
@@ -205,13 +233,25 @@ private fun DrawScope.drawSweep(center: Offset, degrees: Float, radius: Float, b
 
 private fun createTrackPath(positions: List<OrbitalPos>, radius: Float): Path {
     val trackPath = Path()
+    var lastAzim: Double? = null
     positions.forEachIndexed { index, pos ->
         val offset = sph2Cart(pos.azimuth, pos.elevation, radius.toDouble())
-        if (index == 0) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
+        // Split the path when azimuth wraps 0°/360° to avoid a line across the plot
+        val wrap = lastAzim != null && abs(azimuthDeltaRad(pos.azimuth - lastAzim!!)) > PI
+        if (index == 0 || wrap) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
+        lastAzim = pos.azimuth
     }
     return trackPath
 }
 
+/** Normalize an azimuth delta (radians) into the [-PI, PI] range. */
+private fun azimuthDeltaRad(deltaRad: Double): Double {
+    var d = deltaRad % (2 * PI)
+    if (d > PI) d -= 2 * PI
+    if (d < -PI) d += 2 * PI
+    return d
+}
+
 private fun createTrackEffect(trackPath: Path): PathEffect {
     val shapeRadius = 24f
     val angle = 120.0.toRadians()

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

@@ -32,6 +32,7 @@ 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
@@ -135,6 +136,8 @@ class RadarViewModel(
         val passes = satelliteRepo.passes.value
         val (catNum, aosTime) = satelliteRepo.selectedPass.value
         return passes.find { it.catNum == catNum && it.aosTime == aosTime }
+            ?: passes.find { it.catNum == catNum && aosTime in it.aosTime..it.losTime }
+            ?: passes.find { it.catNum == catNum }
             ?: passes.firstOrNull()
     }
 
@@ -145,7 +148,13 @@ class RadarViewModel(
         transponders = allRadios.filter { it.downlinkLow != null }
         if (allRadios.isNotEmpty()) {
             val firstUuid = allRadios.first().uuid
-            _uiState.update { it.copy(transceivers = it.transceivers.copy(selectedUuid = firstUuid)) }
+            val offsetKHz = allRadios.first().catnum?.let { settingsRepo.getSatelliteOffset(it) } ?: ""
+            _uiState.update {
+                it.copy(
+                    transceivers = it.transceivers.copy(selectedUuid = firstUuid),
+                    calculatorOffsetKHz = offsetKHz
+                )
+            }
             transponders.find { it.uuid == firstUuid }?.let { trackingService.setTransponder(it) }
         }
         if (!pass.isDeepSpace) {
@@ -213,7 +222,6 @@ class RadarViewModel(
 
     override fun onCleared() {
         sensorsRepo.disableSensor()
-        super.onCleared()
     }
 
     fun onAction(action: RadarAction) {
@@ -223,7 +231,16 @@ class RadarViewModel(
                 // 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)) }
+                val offsetKHz = if (!isTogglingOff) {
+                    transponders.find { it.uuid == action.uuid }
+                        ?.catnum?.let { settingsRepo.getSatelliteOffset(it) } ?: ""
+                } else ""
+                _uiState.update {
+                    it.copy(
+                        transceivers = it.transceivers.copy(selectedUuid = newUuid),
+                        calculatorOffsetKHz = offsetKHz
+                    )
+                }
                 // Only update the tracking service when selecting a different transponder to
                 // avoid resetting a user-adjusted TX base on re-expand
                 if (!isTogglingOff) {
@@ -272,6 +289,16 @@ class RadarViewModel(
                 sstvDecoder?.clearPixels()
                 _uiState.update { it.copy(sstv = it.sstv.copy(currentFrame = null)) }
             }
+
+            is RadarAction.ChangeCalculatorOffset -> {
+                val catnum = _uiState.value.transceivers.selectedUuid?.let { uuid ->
+                    transponders.find { it.uuid == uuid }?.catnum
+                }
+                if (catnum != null) {
+                    settingsRepo.setSatelliteOffset(catnum, action.offsetKHz)
+                }
+                _uiState.update { it.copy(calculatorOffsetKHz = action.offsetKHz) }
+            }
         }
     }
 
@@ -344,13 +371,32 @@ class RadarViewModel(
 
     private fun initSstvDecoder() {
         if (sstvDecoder == null) {
-            val decoder = SstvDecoder(sampleRate = audioCapture.sampleRate)
+            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 ->
-                    _uiState.update { it.copy(sstv = it.sstv.copy(currentFrame = 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)) }
+                    }
                 }
             }
         }
@@ -374,6 +420,39 @@ class RadarViewModel(
     }
 
     companion object {
+        // 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.40f  // 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.Look4SatLimited
+
+        // 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,

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

@@ -53,11 +53,12 @@ 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 androidx.compose.ui.window.Dialog
 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(
@@ -94,53 +95,44 @@ internal fun SstvPage(
 
     if (showModeDialog.value) {
         val allModes = remember(sstv.supportedModes) { listOf("Auto") + sstv.supportedModes }
-        Dialog(onDismissRequest = { showModeDialog.value = false }) {
-            ElevatedCard {
-                Column(
-                    horizontalAlignment = Alignment.CenterHorizontally,
-                    modifier = Modifier.padding(vertical = 16.dp)
-                ) {
-                    Text(
-                        text = "SSTV Mode",
-                        fontSize = 16.sp,
-                        fontWeight = FontWeight.Medium,
-                        color = MaterialTheme.colorScheme.primary,
-                        modifier = Modifier.padding(bottom = 12.dp)
-                    )
-                    LazyColumn(
+        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
-                            .fillMaxHeight(0.5f)
-                            .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)
-                                )
+                            .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)
+                        )
                     }
                 }
             }
@@ -181,6 +173,19 @@ internal fun SstvPage(
                 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
@@ -198,6 +203,15 @@ internal fun SstvPage(
                 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),

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

@@ -21,14 +21,20 @@ import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.expandVertically
 import androidx.compose.animation.shrinkVertically
 import androidx.compose.foundation.background
+import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.IntrinsicSize
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
@@ -39,27 +45,46 @@ 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.layout.PaddingValues
+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.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Slider
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.CardDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+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.drawBehind
 import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextStyle
 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
@@ -104,6 +129,70 @@ fun TransceiversPage(
     }
 }
 
+@Composable
+fun CalculatorPage(
+    transceivers: List<SatRadio>,
+    selectedUuid: String?,
+    orbitalPos: OrbitalPos?,
+    calculatorOffsetKHz: String = "",
+    onAction: (RadarAction) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val calculatorTransceivers = remember(transceivers) {
+        transceivers.filter(DopplerFrequencyCalculator::isNamedLinearTransponder)
+            .let(DopplerFrequencyCalculator::deduplicateTransponders)
+    }
+    val selectedTransceiver = remember(calculatorTransceivers, selectedUuid) {
+        calculatorTransceivers.firstOrNull { it.uuid == selectedUuid }
+            ?: calculatorTransceivers.firstOrNull()
+    }
+
+    if (selectedTransceiver == null) {
+        EmptyTransceiversContent(modifier)
+        return
+    }
+
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .verticalScroll(rememberScrollState()),
+        verticalArrangement = Arrangement.spacedBy(10.dp)
+    ) {
+        if (calculatorTransceivers.size > 1) {
+            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
+                            )
+                        }
+                    )
+                }
+            }
+        }
+
+        DopplerFrequencyCalculator(
+            transponder = selectedTransceiver,
+            orbitalPos = orbitalPos,
+            offsetKHz = calculatorOffsetKHz,
+            onOffsetChange = { onAction(RadarAction.ChangeCalculatorOffset(it)) },
+            modifier = Modifier.fillMaxWidth()
+        )
+
+    }
+}
+
 @Composable
 private fun EmptyTransceiversContent(modifier: Modifier = Modifier) {
     Box(contentAlignment = Alignment.Center, modifier = modifier.fillMaxSize()) {
@@ -173,11 +262,8 @@ private fun TransceiverItem(
                     )
                 }
                 // Title with mode
-                val title = if (radio.isInverted) "INV: ${radio.info}" else radio.info
-                val mode = "${radio.downlinkMode ?: "--"}/${radio.uplinkMode ?: "--"}"
-                val fullTitle = "$title ($mode)"
                 Text(
-                    text = fullTitle,
+                    text = transceiverTitle(radio),
                     textAlign = TextAlign.Center,
                     color = MaterialTheme.colorScheme.onSurface,
                     maxLines = 1,
@@ -296,7 +382,7 @@ private fun UnifiedFrequencyRow(
 private fun ExpandedRadioControl(
     radio: SatRadio,
     radioControl: RadioControlSubState,
-    onAction: (RadarAction) -> Unit
+    onAction: (RadarAction) -> Unit,
 ) {
     Column(
         modifier = Modifier
@@ -436,6 +522,365 @@ private fun ExpandedRadioControl(
     }
 }
 
+private enum class EditedField { TX, PASSBAND, RX }
+
+@Composable
+private fun DopplerFrequencyCalculator(
+    transponder: SatRadio,
+    orbitalPos: OrbitalPos?,
+    offsetKHz: String = "",
+    onOffsetChange: (String) -> Unit = {},
+    modifier: Modifier = Modifier
+) {
+    if (orbitalPos == null || !DopplerFrequencyCalculator.isLinearTransponder(transponder)) return
+
+    var lastEditedField by rememberSaveable(transponder.uuid) { mutableStateOf(EditedField.TX) }
+    var txFrequencyHz by rememberSaveable(transponder.uuid) { mutableStateOf(0L) }
+    var rxFrequencyHz by rememberSaveable(transponder.uuid) { mutableStateOf(0L) }
+    var passbandPosition by rememberSaveable(transponder.uuid) { mutableStateOf(0.5f) }
+    var stepSizeKHz by remember { mutableIntStateOf(1) }
+
+    val offsetHz = offsetKHz.toDoubleOrNull()?.let { it * 1000 }?.toLong() ?: 0L
+
+    val txLow = transponder.uplinkLow ?: return
+    val txHigh = transponder.uplinkHigh ?: return
+    val rxLow = transponder.downlinkLow ?: return
+    val rxHigh = transponder.downlinkHigh ?: return
+    val txRange = txHigh - txLow
+    val rxRange = rxHigh - rxLow
+    if (txRange <= 0L || rxRange <= 0L) return
+
+    // 原始转发器值（逆转多普勒），用于 passband 映射计算
+    val rawTxLow = orbitalPos.getDownlinkFreq(txLow)
+    val rawTxHigh = orbitalPos.getDownlinkFreq(txHigh)
+    val rawRxLow = orbitalPos.getUplinkFreq(rxLow)
+    val rawRxHigh = orbitalPos.getUplinkFreq(rxHigh)
+    val rawTxRange = rawTxHigh - rawTxLow
+    val rawRxRange = rawRxHigh - rawRxLow
+    val rawTransponder = transponder.copy(
+        uplinkLow = rawTxLow, uplinkHigh = rawTxHigh,
+        downlinkLow = rawRxLow, downlinkHigh = rawRxHigh
+    )
+
+    // 初始化
+    LaunchedEffect(Unit) {
+        if (txFrequencyHz == 0L) {
+            txFrequencyHz = txLow + txRange / 2
+            rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+            ) ?: (rxLow + rxRange / 2)
+        }
+    }
+
+    // 实时重算：卫星移动时，锚点侧不变，重算另一侧
+    LaunchedEffect(orbitalPos) {
+        if (lastEditedField == EditedField.TX) {
+            // TX 是锚点，不变；重算 RX
+            rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+            ) ?: rxFrequencyHz
+        } else if (lastEditedField == EditedField.RX) {
+            // RX 是锚点，不变；重算 TX
+            txFrequencyHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                rxFrequencyHz, rawTransponder, orbitalPos, offsetHz
+            ) ?: txFrequencyHz
+        } else if (lastEditedField == EditedField.PASSBAND) {
+            // 相对位置不变（passbandPosition），TX 用地面频率，RX 经 Transceiver 完整路径计算
+            txFrequencyHz = txLow + (passbandPosition * txRange).toLong()
+            rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+            ) ?: rxFrequencyHz
+        }
+    }
+
+    val txSliderValue = if (lastEditedField == EditedField.PASSBAND) {
+        passbandPosition
+    } else {
+        ((txFrequencyHz - txLow).toFloat() / txRange).coerceIn(0f, 1f)
+    }
+    val rxSliderValue = if (lastEditedField == EditedField.PASSBAND) {
+        ((rxFrequencyHz - rxLow).toFloat() / rxRange).coerceIn(0f, 1f)
+    } else {
+        ((rxFrequencyHz - rxLow).toFloat() / rxRange).coerceIn(0f, 1f)
+    }
+
+    fun updateTx(newTxHz: Long) {
+        when (lastEditedField) {
+            EditedField.PASSBAND -> {
+                // Passband 模式：滑块位置 → passbandPosition → 地面频率，RX 经 Transceiver 计算
+                val pos = ((newTxHz - txLow).toFloat() / txRange).coerceIn(0f, 1f)
+                passbandPosition = pos
+                txFrequencyHz = txLow + (pos * txRange).toLong()
+                rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                    txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                ) ?: rxFrequencyHz
+            }
+            else -> {
+                txFrequencyHz = newTxHz.coerceIn(txLow, txHigh)
+                rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                    txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                ) ?: rxFrequencyHz
+            }
+        }
+    }
+
+    fun updateRx(newRxHz: Long) {
+        when (lastEditedField) {
+            EditedField.PASSBAND -> {
+                // Passband 模式：从 RX 经完整往返路径（含多普勒补偿）反推 TX 位置
+                val txFromRx = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                    newRxHz, rawTransponder, orbitalPos, offsetHz
+                )
+                passbandPosition = if (txFromRx != null) {
+                    ((txFromRx - txLow).toFloat() / txRange).coerceIn(0f, 1f)
+                } else {
+                    ((rxFrequencyHz - rxLow).toFloat() / rxRange).coerceIn(0f, 1f)
+                }
+                txFrequencyHz = txLow + (passbandPosition * txRange).toLong()
+                rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                    txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                ) ?: rxFrequencyHz
+            }
+            else -> {
+                rxFrequencyHz = newRxHz.coerceIn(rxLow, rxHigh)
+                txFrequencyHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                    rxFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                ) ?: txFrequencyHz
+            }
+        }
+    }
+
+    Column(
+        modifier = modifier.fillMaxWidth().padding(top = 16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp)
+    ) {
+            Row(
+                modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(6.dp)
+            ) {
+                // 左半边: TX + RX 按钮
+                Row(
+                    modifier = Modifier.weight(1f),
+                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    FilterChip(
+                        selected = lastEditedField == EditedField.TX,
+                        onClick = {
+                            when (lastEditedField) {
+                                EditedField.TX -> {
+                                    passbandPosition = ((txFrequencyHz - txLow).toFloat() / txRange).coerceIn(0f, 1f)
+                                    lastEditedField = EditedField.PASSBAND
+                                    rxFrequencyHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                                        txFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                                    ) ?: rxFrequencyHz
+                                }
+                                EditedField.PASSBAND -> { lastEditedField = EditedField.TX }
+                                else -> { lastEditedField = EditedField.TX }
+                            }
+                        },
+                        label = {
+                            Text("TX", fontSize = 13.sp, textAlign = TextAlign.Center,
+                                modifier = Modifier.fillMaxWidth())
+                        },
+                        modifier = Modifier.weight(1f).fillMaxHeight()
+                    )
+                    FilterChip(
+                        selected = lastEditedField == EditedField.RX,
+                        onClick = {
+                            when (lastEditedField) {
+                                EditedField.RX -> {
+                                    txFrequencyHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                                        rxFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                                    ) ?: txFrequencyHz
+                                    passbandPosition = ((txFrequencyHz - txLow).toFloat() / txRange).coerceIn(0f, 1f)
+                                    lastEditedField = EditedField.PASSBAND
+                                }
+                                EditedField.PASSBAND -> {
+                                    lastEditedField = EditedField.RX
+                                    txFrequencyHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                                        rxFrequencyHz, rawTransponder, orbitalPos, offsetHz
+                                    ) ?: txFrequencyHz
+                                }
+                                else -> { lastEditedField = EditedField.RX }
+                            }
+                        },
+                        label = {
+                            Text("RX", fontSize = 13.sp, textAlign = TextAlign.Center,
+                                modifier = Modifier.fillMaxWidth())
+                        },
+                        modifier = Modifier.weight(1f).fillMaxHeight()
+                    )
+                }
+                // 右半边: Offset 输入框（带细线边框）
+                Box(
+                    modifier = Modifier
+                        .weight(1f)
+                        .height(48.dp)
+                        .border(1.dp, MaterialTheme.colorScheme.outline, MaterialTheme.shapes.small),
+                    contentAlignment = Alignment.Center
+                ) {
+                    BasicTextField(
+                        value = offsetKHz,
+                        onValueChange = onOffsetChange,
+                        singleLine = true,
+                        textStyle = TextStyle(
+                            fontSize = 16.sp,
+                            textAlign = TextAlign.Center,
+                            color = MaterialTheme.colorScheme.onSurface
+                        ),
+                        decorationBox = { innerTextField ->
+                            if (offsetKHz.isEmpty()) {
+                                Text(
+                                    text = "Offset (kHz)",
+                                    fontSize = 16.sp,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
+                            innerTextField()
+                        }
+                    )
+                }
+            }
+
+            // TX 行
+            Column(modifier = Modifier.fillMaxWidth()) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    OutlinedButton(
+                        onClick = { updateTx(txFrequencyHz - stepSizeKHz * 1000L) },
+                        modifier = Modifier.width(32.dp).height(28.dp),
+                        contentPadding = PaddingValues(0.dp),
+                        shape = MaterialTheme.shapes.extraSmall
+                    ) { Text("−", fontSize = 14.sp) }
+
+                    Slider(
+                        value = txSliderValue,
+                        onValueChange = { norm ->
+                            val rawFreq = txLow + (txRange * norm).toLong()
+                            val snapped = ((rawFreq + 500) / 1000L) * 1000L
+                            updateTx(snapped.coerceIn(txLow, txHigh))
+                        },
+                        valueRange = 0f..1f,
+                        modifier = Modifier.weight(1f).height(20.dp).padding(horizontal = 4.dp)
+                    )
+
+                    OutlinedButton(
+                        onClick = { updateTx(txFrequencyHz + stepSizeKHz * 1000L) },
+                        modifier = Modifier.width(32.dp).height(28.dp),
+                        contentPadding = PaddingValues(0.dp),
+                        shape = MaterialTheme.shapes.extraSmall
+                    ) { Text("+", fontSize = 14.sp) }
+                }
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = String.format(Locale.ENGLISH, "%.4f", txLow / 1_000_000.0),
+                        fontSize = 12.sp,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.weight(1f)
+                    )
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.Center
+                    ) {
+                        Text(
+                            text = String.format(Locale.ENGLISH, "%.6f", txFrequencyHz / 1_000_000.0),
+                            fontSize = 20.sp,
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                        Text(
+                            text = " MHz",
+                            fontSize = 20.sp,
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                    }
+                    Text(
+                        text = String.format(Locale.ENGLISH, "%.4f", txHigh / 1_000_000.0),
+                        fontSize = 12.sp,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.weight(1f),
+                        textAlign = TextAlign.End
+                    )
+                }
+            }
+
+            HorizontalDivider(
+                thickness = 0.5.dp,
+                color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
+            )
+
+            // RX 行
+            Column(modifier = Modifier.fillMaxWidth()) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    OutlinedButton(
+                        onClick = { updateRx(rxFrequencyHz - stepSizeKHz * 1000L) },
+                        modifier = Modifier.width(32.dp).height(28.dp),
+                        contentPadding = PaddingValues(0.dp),
+                        shape = MaterialTheme.shapes.extraSmall
+                    ) { Text("−", fontSize = 14.sp) }
+
+                    Slider(
+                        value = rxSliderValue,
+                        onValueChange = { norm ->
+                            val rawFreq = rxLow + (rxRange * norm).toLong()
+                            val snapped = ((rawFreq + 500) / 1000L) * 1000L
+                            updateRx(snapped.coerceIn(rxLow, rxHigh))
+                        },
+                        valueRange = 0f..1f,
+                        modifier = Modifier.weight(1f).height(20.dp).padding(horizontal = 4.dp)
+                    )
+
+                    OutlinedButton(
+                        onClick = { updateRx(rxFrequencyHz + stepSizeKHz * 1000L) },
+                        modifier = Modifier.width(32.dp).height(28.dp),
+                        contentPadding = PaddingValues(0.dp),
+                        shape = MaterialTheme.shapes.extraSmall
+                    ) { Text("+", fontSize = 14.sp) }
+                }
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = String.format(Locale.ENGLISH, "%.4f", rxLow / 1_000_000.0),
+                        fontSize = 12.sp,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.weight(1f)
+                    )
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.Center
+                    ) {
+                        Text(
+                            text = String.format(Locale.ENGLISH, "%.6f", rxFrequencyHz / 1_000_000.0),
+                            fontSize = 20.sp,
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                        Text(
+                            text = " MHz",
+                            fontSize = 20.sp,
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                    }
+                    Text(
+                        text = String.format(Locale.ENGLISH, "%.4f", rxHigh / 1_000_000.0),
+                        fontSize = 12.sp,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.weight(1f),
+                        textAlign = TextAlign.End
+                    )
+                }
+            }
+        }
+}
+
 @Composable
 private fun FrequencyText(frequency: Long?, modifier: Modifier = Modifier) {
     val text = frequency?.let {
@@ -451,5 +896,11 @@ private fun FrequencyText(frequency: Long?, modifier: 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/satellites/src/main/java/com/rtbishop/look4sat/feature/satellites/SatellitesScreen.kt

@@ -62,10 +62,10 @@ import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.presentation.CardLoadingIndicator
 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.PrimaryIconCard
 import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
 import com.rtbishop.look4sat.core.presentation.TopBar
 import com.rtbishop.look4sat.core.presentation.infiniteMarquee
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
@@ -95,11 +95,19 @@ private fun SatellitesScreen(
         )
     }
     if (uiState.shouldSeeWarning) {
-        InfoDialog(
-            stringResource(R.string.sat_warning_title),
-            stringResource(R.string.sat_warning_message)
-        ) {
-            onAction(SatellitesAction.DismissWarning)
+        val dismiss = { onAction(SatellitesAction.DismissWarning) }
+        SharedDialog(
+            title = stringResource(R.string.sat_warning_title),
+            onDismissRequest = dismiss,
+            onAccept = dismiss,
+            titleFontSize = 18
+        ) { padding ->
+            Text(
+                text = stringResource(R.string.sat_warning_message),
+                fontSize = 16.sp,
+                color = MaterialTheme.colorScheme.onSurface,
+                modifier = Modifier.padding(horizontal = padding)
+            )
         }
     }
 
@@ -282,14 +290,17 @@ private fun Satellite(
                 .background(MaterialTheme.colorScheme.surface)
                 .padding(start = 14.dp, top = 8.dp, end = 12.dp, bottom = 8.dp)
         ) {
-            Text(text = "$passSatId - ", color = MaterialTheme.colorScheme.primary)
+            Text(
+                text = "$passSatId - ",
+                color = MaterialTheme.colorScheme.primary
+            )
             Text(
                 text = item.name,
                 modifier = Modifier.weight(1f),
                 fontWeight = FontWeight.Medium,
                 maxLines = 1,
                 overflow = TextOverflow.Ellipsis,
-                color = MaterialTheme.colorScheme.onSurface
+                color = MaterialTheme.colorScheme.primary
             )
             Checkbox(
                 checked = item.isSelected,

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

@@ -22,11 +22,14 @@ import android.content.Context
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 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.material3.FilterChip
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
@@ -38,6 +41,7 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
@@ -48,6 +52,21 @@ import com.rtbishop.look4sat.core.presentation.LocalSpacing
 import com.rtbishop.look4sat.core.presentation.MainTheme
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.SharedDialog
+import androidx.compose.animation.core.spring
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.toMutableStateList
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.res.painterResource
+import com.rtbishop.look4sat.core.domain.model.Constants
+import com.rtbishop.look4sat.core.presentation.IconCard
 
 @Preview(showBackground = true)
 @Composable
@@ -65,13 +84,16 @@ fun PositionDialog(lat: Double, lon: Double, dismiss: () -> Unit, save: (Double,
         OutlinedTextField(
             value = latValue.value,
             onValueChange = { latValue.value = it },
-            label = { Text(text = stringResource(id = R.string.prefs_station_lat_text)) }
+            label = { Text(text = stringResource(id = R.string.prefs_station_lat_text)) },
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
         )
         OutlinedTextField(
             value = lonValue.value,
             onValueChange = { lonValue.value = it },
-            label = { Text(text = stringResource(id = R.string.prefs_station_lon_text)) }
+            label = { Text(text = stringResource(id = R.string.prefs_station_lon_text)) },
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
         )
+        Spacer(modifier = Modifier.height(0.dp))
     }
 }
 
@@ -97,8 +119,10 @@ fun LocatorDialog(qthLocator: String, dismiss: () -> Unit, save: (String) -> Uni
         OutlinedTextField(
             value = locator.value,
             onValueChange = { locator.value = it },
-            label = { Text(text = stringResource(id = R.string.prefs_locator_text)) }
+            label = { Text(text = stringResource(id = R.string.prefs_locator_text)) },
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
         )
+        Spacer(modifier = Modifier.height(0.dp))
     }
 }
 
@@ -107,107 +131,150 @@ fun LocatorDialog(qthLocator: String, dismiss: () -> Unit, save: (String) -> Uni
 private fun TransceiversDialogPreview() {
     MainTheme {
         DataSourcesDialog(
-            useCustomTle = true,
-            useCustomTransceivers = true,
-            tleUrl = "https://example.com/tle.txt",
-            transceiversUrl = "https://example.com/tx.json",
+            satelliteUrls = listOf(
+                "celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
+                "amsat.org/tle/current/nasabare.txt"
+            ),
+            transceiversUrls = listOf(
+                "db.satnogs.org/api/transmitters/?format=json&status=active"
+            ),
             onImportTle = {},
             onImportTransceivers = {},
             onDismiss = {},
-            onSave = { _, _, _, _ -> }
+            onSave = { _, _ -> }
         )
     }
 }
 
 @Composable
 fun DataSourcesDialog(
-    useCustomTle: Boolean,
-    useCustomTransceivers: Boolean,
-    tleUrl: String,
-    transceiversUrl: String,
+    satelliteUrls: List<String>,
+    transceiversUrls: List<String>,
     onImportTle: () -> Unit,
     onImportTransceivers: () -> Unit,
     onDismiss: () -> Unit,
-    onSave: (Boolean, Boolean, String, String) -> Unit
+    onSave: (List<String>, List<String>) -> Unit
 ) {
     val padding = LocalSpacing.current.large
-    val isEnabledCustomTle = rememberSaveable { mutableStateOf(useCustomTle) }
-    val isEnabledCustomTransceivers = rememberSaveable { mutableStateOf(useCustomTransceivers) }
-    val urlTle = rememberSaveable { mutableStateOf(tleUrl) }
-    val urlTransceivers = rememberSaveable { mutableStateOf(transceiversUrl) }
+    // Stable Long IDs avoid key collisions when several entries are empty or duplicated.
+    val nextId = remember { mutableLongStateOf((satelliteUrls.size + transceiversUrls.size).toLong()) }
+    val satUrls = remember {
+        satelliteUrls.mapIndexed { i, url -> i.toLong() to url }.toMutableStateList()
+    }
+    val txUrls = remember {
+        transceiversUrls.mapIndexed { i, url -> (satelliteUrls.size + i).toLong() to url }.toMutableStateList()
+    }
     val onAccept = {
-        onSave(isEnabledCustomTle.value, isEnabledCustomTransceivers.value, urlTle.value, urlTransceivers.value)
+        onSave(
+            satUrls.map { it.second.trim() }.filter { it.isNotBlank() },
+            txUrls.map { it.second.trim() }.filter { it.isNotBlank() }
+        )
         onDismiss()
     }
-    val onCancel = { onDismiss() }
     SharedDialog(
         title = stringResource(id = R.string.prefs_data_sources_title),
-        onCancel = onCancel,
+        onCancel = onDismiss,
         onAccept = onAccept,
     ) {
-        Column(modifier = Modifier.padding(horizontal = padding)) {
-            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                CardButton(
-                    onClick = {
-                        onImportTle()
-                        onDismiss()
-                    },
-                    text = "TLE (3LE)\nR4UAB (.txt)",
-                    modifier = Modifier.weight(1f)
-                )
-                CardButton(
-                    onClick = {
-                        onImportTransceivers()
-                        onDismiss()
-                    },
-                    text = "Transceivers\nSatNOGS (.json)",
-                    modifier = Modifier.weight(1f)
-                )
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxHeight(0.84f)
+                .padding(horizontal = padding),
+            verticalArrangement = Arrangement.spacedBy(4.dp),
+            contentPadding = PaddingValues(vertical = 6.dp)
+        ) {
+            item {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(6.dp),
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    CardButton(
+                        onClick = { onImportTle(); onDismiss() },
+                        text = "TLE/3LE (.txt)\nOMM (.csv)",
+                        modifier = Modifier.weight(1f)
+                    )
+                    CardButton(
+                        onClick = { onImportTransceivers(); onDismiss() },
+                        text = "Transceivers\nSatNOGS (.json)",
+                        modifier = Modifier.weight(1f)
+                    )
+                }
             }
-            Spacer(modifier = Modifier.height(6.dp))
-            Row(
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Text(text = stringResource(id = R.string.prefs_data_sources_tle_switch))
-                Switch(
-                    checked = isEnabledCustomTle.value,
-                    onCheckedChange = { isEnabledCustomTle.value = it }
-                )
-            }
-            OutlinedTextField(
-                value = urlTle.value,
-                onValueChange = { urlTle.value = it },
-                label = { Text(text = stringResource(id = R.string.prefs_data_sources_url_title)) },
-                singleLine = true,
-                modifier = Modifier.fillMaxWidth(),
-                enabled = isEnabledCustomTle.value,
+            sourceSection(
+                sectionKey = "sat",
+                labelResId = R.string.prefs_data_sources_satellites_label,
+                urls = satUrls,
+                onAdd = { satUrls.add(nextId.longValue++ to "") },
+                onMoveUp = { i -> if (i > 0) satUrls.add(i - 1, satUrls.removeAt(i)) },
+                onRemove = { i -> satUrls.removeAt(i) },
+                onUrlChange = { i, v -> satUrls[i] = satUrls[i].first to v }
             )
-            Spacer(modifier = Modifier.height(6.dp))
-            Row(
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Text(text = stringResource(id = R.string.prefs_data_sources_transceivers_switch))
-                Switch(
-                    checked = isEnabledCustomTransceivers.value,
-                    onCheckedChange = { isEnabledCustomTransceivers.value = it }
-                )
-            }
-            OutlinedTextField(
-                value = urlTransceivers.value,
-                onValueChange = { urlTransceivers.value = it },
-                label = { Text(text = stringResource(id = R.string.prefs_data_sources_url_title)) },
-                singleLine = true,
-                modifier = Modifier.fillMaxWidth(),
-                enabled = isEnabledCustomTransceivers.value,
+            sourceSection(
+                sectionKey = "tx",
+                labelResId = R.string.prefs_data_sources_transceivers_label,
+                urls = txUrls,
+                onAdd = { txUrls.add(nextId.longValue++ to "") },
+                onMoveUp = { i -> if (i > 0) txUrls.add(i - 1, txUrls.removeAt(i)) },
+                onRemove = { i -> txUrls.removeAt(i) },
+                onUrlChange = { i, v -> txUrls[i] = txUrls[i].first to v }
             )
         }
     }
 }
 
+private fun LazyListScope.sourceSection(
+    sectionKey: String,
+    labelResId: Int,
+    urls: List<Pair<Long, String>>,
+    onAdd: () -> Unit,
+    onMoveUp: (Int) -> Unit,
+    onRemove: (Int) -> Unit,
+    onUrlChange: (Int, String) -> Unit
+) {
+    item {
+        Spacer(modifier = Modifier.height(6.dp))
+        Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
+            Text(
+                text = stringResource(labelResId),
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.weight(1f)
+            )
+            IconCard(action = onAdd, resId = R.drawable.ic_add)
+        }
+    }
+    itemsIndexed(urls, key = { _, entry -> "$sectionKey-${entry.first}" }) { index, (_, url) ->
+        val enabledTint = MaterialTheme.colorScheme.onSurfaceVariant
+        OutlinedTextField(
+            value = url,
+            onValueChange = { onUrlChange(index, it) },
+            label = { Text(stringResource(R.string.prefs_data_sources_url_title)) },
+            leadingIcon = {
+                IconButton(onClick = { onMoveUp(index) }, enabled = index > 0) {
+                    Icon(
+                        painter = painterResource(R.drawable.ic_arrow),
+                        contentDescription = null,
+                        tint = if (index > 0) enabledTint else enabledTint.copy(alpha = 0.32f),
+                        modifier = Modifier.rotate(270f)
+                    )
+                }
+            },
+            trailingIcon = {
+                IconButton(onClick = { onRemove(index) }) {
+                    Icon(
+                        painter = painterResource(R.drawable.ic_delete),
+                        contentDescription = null
+                    )
+                }
+            },
+            singleLine = true,
+            modifier = Modifier
+                .fillMaxWidth()
+                .animateItem(fadeInSpec = spring(), fadeOutSpec = spring())
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 fun PreviewNetworkOutputDialog() {
@@ -222,6 +289,7 @@ fun PreviewNetworkOutputDialog() {
                 frequencyAddress = "127.0.0.1",
                 frequencyPort = "4532",
                 frequencyFormat = $$"F $FREQ",
+                frequencyOffsetHz = 0L,
                 bluetoothRotatorState = false,
                 bluetoothRotatorFormat = $$"P $AZ $EL",
                 bluetoothRotatorName = "Default",
@@ -231,7 +299,7 @@ fun PreviewNetworkOutputDialog() {
                 bluetoothFrequencyFormat = $$"F $FREQ"
             ),
             onDismiss = {},
-            onSave = { _, _, _, _, _, _, _, _ -> }
+            onSave = { _, _, _, _, _, _, _, _, _ -> }
         )
     }
 }
@@ -242,7 +310,7 @@ fun NetworkOutputDialog(
     onDismiss: () -> Unit,
     onSave: (
         Boolean, String, String, String,
-        Boolean, String, String, String
+        Boolean, String, String, String, Long
     ) -> Unit
 ) {
     val padding = LocalSpacing.current.large
@@ -256,12 +324,15 @@ fun NetworkOutputDialog(
         mutableStateOf("${initialSettings.frequencyAddress}:${initialSettings.frequencyPort}")
     }
     val frequencyFormat = rememberSaveable { mutableStateOf(initialSettings.frequencyFormat) }
+    val frequencyOffsetHz = rememberSaveable { mutableStateOf(initialSettings.frequencyOffsetHz.toString()) }
     val onAccept = {
         val (rotIp, rotPort) = splitAddress(rotatorAddress.value)
         val (freqIp, freqPort) = splitAddress(frequencyAddress.value)
+        val offsetHz = (frequencyOffsetHz.value.trim().toLongOrNull() ?: 0L)
+            .coerceIn(Constants.FREQ_OFFSET_MIN_HZ, Constants.FREQ_OFFSET_MAX_HZ)
         onSave(
             rotatorState.value, rotIp, rotPort, rotatorFormat.value,
-            frequencyState.value, freqIp, freqPort, frequencyFormat.value
+            frequencyState.value, freqIp, freqPort, frequencyFormat.value, offsetHz
         )
         onDismiss()
     }
@@ -294,6 +365,25 @@ fun NetworkOutputDialog(
                 onFormatChange = { frequencyFormat.value = it },
                 formatLabel = stringResource(R.string.prefs_net_frequency_format_hint)
             )
+            Spacer(modifier = Modifier.height(6.dp))
+            OutlinedTextField(
+                value = frequencyOffsetHz.value,
+                onValueChange = { frequencyOffsetHz.value = it },
+                singleLine = true,
+                label = { Text(stringResource(R.string.prefs_net_frequency_offset_hint)) },
+                supportingText = { Text(stringResource(R.string.prefs_net_frequency_offset_help)) },
+                trailingIcon = {
+                    IconButton(
+                        onClick = { frequencyOffsetHz.value = "0" },
+                        enabled = frequencyState.value && frequencyOffsetHz.value != "0"
+                    ) {
+                        Icon(painter = painterResource(R.drawable.ic_close), contentDescription = null)
+                    }
+                },
+                modifier = Modifier.fillMaxWidth(),
+                enabled = frequencyState.value
+            )
+            Spacer(modifier = Modifier.height(12.dp))
         }
     }
 }
@@ -321,6 +411,7 @@ fun PreviewBluetoothOutputDialog() {
                 frequencyAddress = "127.0.0.1",
                 frequencyPort = "4532",
                 frequencyFormat = $$"F $FREQ",
+                frequencyOffsetHz = 0L,
                 bluetoothRotatorState = false,
                 bluetoothRotatorFormat = $$"P $AZ $EL",
                 bluetoothRotatorName = "Default",
@@ -387,6 +478,7 @@ fun BluetoothOutputDialog(
                 onFormatChange = { frequencyFormat.value = it },
                 formatLabel = stringResource(R.string.prefs_bt_frequency_output_hint)
             )
+            Spacer(modifier = Modifier.height(12.dp))
         }
     }
 }
@@ -438,114 +530,164 @@ private fun OutputChannelSection(
     }
 }
 
+@OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun RadioControlDialog(
     initialSettings: RadioControlSettings,
     onDismiss: () -> Unit,
     onSave: (RadioControlSettings) -> Unit
 ) {
-    val context = androidx.compose.ui.platform.LocalContext.current
-    val padding = LocalSpacing.current.large
-    val baudRates = listOf(4800, 9600, 38400)
-    val enabled = rememberSaveable { mutableStateOf(initialSettings.enabled) }
+    val context    = androidx.compose.ui.platform.LocalContext.current
+    val padding    = LocalSpacing.current.large
+    val enabled    = rememberSaveable { mutableStateOf(initialSettings.enabled) }
     val radioModel = rememberSaveable { mutableStateOf(initialSettings.radioModel) }
-    val txAddress = rememberSaveable { mutableStateOf(initialSettings.txRadioAddress) }
-    val rxAddress = rememberSaveable { mutableStateOf(initialSettings.rxRadioAddress) }
-    val txName = rememberSaveable { mutableStateOf(initialSettings.txRadioName) }
-    val rxName = rememberSaveable { mutableStateOf(initialSettings.rxRadioName) }
-    val baudRate = rememberSaveable { mutableIntStateOf(initialSettings.baudRate) }
+    val splitMode  = rememberSaveable { mutableStateOf(initialSettings.splitMode) }
+    val txAddress  = rememberSaveable { mutableStateOf(initialSettings.txRadioAddress) }
+    val rxAddress  = rememberSaveable { mutableStateOf(initialSettings.rxRadioAddress) }
+    val txName     = rememberSaveable { mutableStateOf(initialSettings.txRadioName) }
+    val rxName     = rememberSaveable { mutableStateOf(initialSettings.rxRadioName) }
+    val baudRate   = rememberSaveable { mutableIntStateOf(initialSettings.baudRate) }
     val selectingFor = rememberSaveable { mutableStateOf("") } // "tx", "rx", or ""
 
-    val pairedDevices = remember {
-        try {
-            val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-            manager.adapter?.bondedDevices?.map { Pair(it.name ?: "Unknown", it.address) } ?: emptyList()
-        } catch (_: SecurityException) {
-            emptyList()
+    val isIcom = radioModel.value == RadioControlSettings.MODEL_ICOM_IC705
+    val isSingleRadio = isIcom && splitMode.value
+
+    // Reset split mode when switching away from IC-705
+    if (!isIcom && splitMode.value) splitMode.value = false
+
+    val baudRates = if (isIcom) RadioControlSettings.BAUD_RATES_ICOM
+                   else         RadioControlSettings.BAUD_RATES_YAESU
+
+    // If current baud rate is not in the new list, default to the first available
+    if (baudRate.intValue !in baudRates) baudRate.intValue = baudRates.first()
+
+    val pairedDevices: List<Pair<String, String>> = remember {
+        buildList {
+            try {
+                val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+                manager.adapter?.bondedDevices?.forEach {
+                    add(Pair(it.name ?: "Unknown", it.address ?: ""))
+                }
+            } catch (_: SecurityException) { }
         }
     }
 
     val onAccept = {
         onSave(
             RadioControlSettings(
-                enabled = enabled.value,
-                radioModel = radioModel.value,
+                enabled        = enabled.value,
+                radioModel     = radioModel.value,
                 txRadioAddress = txAddress.value,
-                rxRadioAddress = rxAddress.value,
-                txRadioName = txName.value,
-                rxRadioName = rxName.value,
-                baudRate = baudRate.intValue
+                rxRadioAddress = if (isSingleRadio) "" else rxAddress.value,
+                txRadioName    = txName.value,
+                rxRadioName    = if (isSingleRadio) "" else rxName.value,
+                baudRate       = baudRate.intValue,
+                splitMode      = splitMode.value
             )
         )
         onDismiss()
     }
+
     SharedDialog(
-        title = stringResource(R.string.rc_settings_title),
+        title    = stringResource(R.string.rc_settings_title),
         onCancel = onDismiss,
         onAccept = onAccept
     ) {
         Column(modifier = Modifier.padding(horizontal = padding)) {
+
+            // Enable switch
             Row(
                 horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.fillMaxWidth()
+                verticalAlignment     = Alignment.CenterVertically,
+                modifier              = Modifier.fillMaxWidth()
             ) {
                 Text(stringResource(R.string.rc_enable_switch))
                 Switch(checked = enabled.value, onCheckedChange = { enabled.value = it })
             }
             Spacer(modifier = Modifier.height(6.dp))
 
-            // Radio model selection
+            // Radio model — FlowRow so chips wrap on small screens
             Text(
-                stringResource(R.string.rc_radio_model),
-                fontWeight = androidx.compose.ui.text.font.FontWeight.Medium,
-                color = androidx.compose.material3.MaterialTheme.colorScheme.primary
+                text       = stringResource(R.string.rc_radio_model),
+                fontWeight = FontWeight.Medium,
+                color      = androidx.compose.material3.MaterialTheme.colorScheme.primary
             )
-            Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
                 RadioControlSettings.SUPPORTED_RADIOS.forEach { model ->
-                    androidx.compose.material3.FilterChip(
+                    FilterChip(
                         selected = radioModel.value == model,
-                        onClick = { radioModel.value = model },
-                        label = { Text(model, fontSize = 12.sp) },
-                        enabled = enabled.value
+                        onClick  = { radioModel.value = model },
+                        label    = { Text(model, fontSize = 12.sp) },
+                        enabled  = enabled.value
                     )
                 }
             }
             Spacer(modifier = Modifier.height(6.dp))
 
-            // TX Radio selection
-            Text("TX Radio (Uplink)", fontWeight = androidx.compose.ui.text.font.FontWeight.Medium)
+            // IC-705 split-mode toggle (only shown for IC-705)
+            if (isIcom) {
+                Row(
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment     = Alignment.CenterVertically,
+                    modifier              = Modifier.fillMaxWidth()
+                ) {
+                    Column(modifier = Modifier.weight(1f)) {
+                        Text("Split mode (single radio)", fontWeight = FontWeight.Medium)
+                        Text(
+                            text     = "Use VFO-A/B split on one IC-705 instead of two radios",
+                            fontSize = 12.sp,
+                            color    = androidx.compose.material3.MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                    Switch(
+                        checked         = splitMode.value,
+                        onCheckedChange = { splitMode.value = it },
+                        enabled         = enabled.value
+                    )
+                }
+                Spacer(modifier = Modifier.height(6.dp))
+            }
+
+            // TX Radio (always shown; in split mode this is the single IC-705)
+            val txLabel = if (isSingleRadio) "Radio (IC-705)" else "TX Radio (Uplink)"
+            Text(txLabel, fontWeight = FontWeight.Medium)
             if (txAddress.value.isNotBlank()) {
-                Text("${txName.value} - ${txAddress.value}", fontSize = 13.sp)
+                Text("${txName.value} — ${txAddress.value}", fontSize = 13.sp)
             }
             CardButton(
-                onClick = { selectingFor.value = "tx" },
-                text = "Select TX Device",
+                onClick  = { selectingFor.value = "tx" },
+                text     = if (isSingleRadio) "Select Device" else "Select TX Device",
                 modifier = Modifier.fillMaxWidth()
             )
             Spacer(modifier = Modifier.height(6.dp))
 
-            // RX Radio selection
-            Text("RX Radio (Downlink)", fontWeight = androidx.compose.ui.text.font.FontWeight.Medium)
-            if (rxAddress.value.isNotBlank()) {
-                Text("${rxName.value} - ${rxAddress.value}", fontSize = 13.sp)
-            }
-            CardButton(
-                onClick = { selectingFor.value = "rx" },
-                text = "Select RX Device",
-                modifier = Modifier.fillMaxWidth()
-            )
-
-            // Paired devices list (shown when selecting)
-            if (selectingFor.value.isNotBlank()) {
-                Spacer(modifier = Modifier.height(6.dp))
-                Text(
-                    text = "Paired Bluetooth Devices:",
-                    fontWeight = androidx.compose.ui.text.font.FontWeight.Medium,
-                    color = androidx.compose.material3.MaterialTheme.colorScheme.primary
+            // RX Radio (hidden in split mode — the same radio handles both)
+            if (!isSingleRadio) {
+                Text("RX Radio (Downlink)", fontWeight = FontWeight.Medium)
+                if (rxAddress.value.isNotBlank()) {
+                    Text("${rxName.value} — ${rxAddress.value}", fontSize = 13.sp)
+                }
+                CardButton(
+                    onClick  = { selectingFor.value = "rx" },
+                    text     = "Select RX Device",
+                    modifier = Modifier.fillMaxWidth()
                 )
+                Spacer(modifier = Modifier.height(6.dp))
+            }
+
+            // Paired device picker (inline, shown while selecting)
+            if (selectingFor.value.isNotBlank()) {
+                Text(
+                    text       = "Paired Bluetooth Devices:",
+                    fontWeight = FontWeight.Medium,
+                    color      = androidx.compose.material3.MaterialTheme.colorScheme.primary
+                )
+                Spacer(modifier = Modifier.height(2.dp))
                 if (pairedDevices.isEmpty()) {
-                    Text("No paired devices found. Pair your BT adapter in Android Bluetooth settings first.")
+                    Text(
+                        "No paired devices found. Pair your BT adapter in Android Bluetooth settings first.",
+                        fontSize = 13.sp
+                    )
                 } else {
                     pairedDevices.forEach { (name, address) ->
                         androidx.compose.material3.Surface(
@@ -554,17 +696,17 @@ fun RadioControlDialog(
                                 .clickable {
                                     if (selectingFor.value == "tx") {
                                         txAddress.value = address
-                                        txName.value = name
+                                        txName.value    = name
                                     } else {
                                         rxAddress.value = address
-                                        rxName.value = name
+                                        rxName.value    = name
                                     }
                                     selectingFor.value = ""
                                 }
                                 .padding(vertical = 4.dp)
                         ) {
                             Row(
-                                modifier = Modifier.fillMaxWidth(),
+                                modifier              = Modifier.fillMaxWidth(),
                                 horizontalArrangement = Arrangement.SpaceBetween
                             ) {
                                 Text(name, modifier = Modifier.weight(1f))
@@ -573,25 +715,22 @@ fun RadioControlDialog(
                         }
                     }
                 }
+                Spacer(modifier = Modifier.height(6.dp))
             }
 
-            Spacer(modifier = Modifier.height(6.dp))
-            Row(
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Text("Baud Rate:")
-                Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
-                    baudRates.forEach { rate ->
-                        CardButton(
-                            onClick = { baudRate.intValue = rate },
-                            text = if (rate == baudRate.intValue) "[$rate]" else rate.toString(),
-                            modifier = Modifier
-                        )
-                    }
+            // Baud rate — FlowRow so all chips fit on narrow screens
+            Text("Baud Rate:", fontWeight = FontWeight.Medium)
+            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+                baudRates.forEach { rate ->
+                    FilterChip(
+                        selected = rate == baudRate.intValue,
+                        onClick  = { baudRate.intValue = rate },
+                        label    = { Text(rate.toString(), fontSize = 12.sp) },
+                        enabled  = enabled.value
+                    )
                 }
             }
+            Spacer(modifier = Modifier.height(6.dp))
         }
     }
 }

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

@@ -61,6 +61,7 @@ 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.DataSourcesSettings
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
@@ -89,10 +90,22 @@ fun SettingsDestination() {
 @Composable
 private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) -> Unit) {
     val dialogs = rememberDialogVisibility()
+    val pendingCustomSourcesGrant = remember { mutableStateOf<(() -> Unit)?>(null) }
+    val pendingCustomSourcesDeny = remember { mutableStateOf<(() -> Unit)?>(null) }
     val permissions = rememberSettingsPermissions(
         sendAction = onAction,
         onBluetoothGranted = { dialogs.bluetooth = true },
-        onNetworkGranted = { dialogs.network = true }
+        onNetworkGranted = { dialogs.network = true },
+        onCustomSourcesPermissionGranted = {
+            pendingCustomSourcesGrant.value?.invoke()
+            pendingCustomSourcesGrant.value = null
+            pendingCustomSourcesDeny.value = null
+        },
+        onCustomSourcesPermissionDenied = {
+            pendingCustomSourcesDeny.value?.invoke()
+            pendingCustomSourcesGrant.value = null
+            pendingCustomSourcesDeny.value = null
+        }
     )
 
     // Dialogs
@@ -113,23 +126,15 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
     }
     if (dialogs.dataSources) {
         DataSourcesDialog(
-            useCustomTle = uiState.dataSourcesSettings.useCustomTLE,
-            useCustomTransceivers = uiState.dataSourcesSettings.useCustomTransceivers,
-            tleUrl = uiState.dataSourcesSettings.tleUrl,
-            transceiversUrl = uiState.dataSourcesSettings.transceiversUrl,
+            satelliteUrls = uiState.dataSourcesSettings.satelliteUrls,
+            transceiversUrls = uiState.dataSourcesSettings.transceiversUrls,
             onImportTle = { permissions.launchTleImport(); dialogs.dataSources = false },
             onImportTransceivers = { permissions.launchTransceiverImport(); dialogs.dataSources = false },
             onDismiss = { dialogs.dataSources = false },
-            onSave = { useCustomTle, useCustomTransceivers, tleUrl, transceiversUrl ->
-                val current = uiState.dataSourcesSettings
-                val newSettings = current.copy(
-                    useCustomTLE = if (!useCustomTle || tleUrl.isNotBlank()) useCustomTle else current.useCustomTLE,
-                    tleUrl = if (!useCustomTle || tleUrl.isNotBlank()) tleUrl else current.tleUrl,
-                    useCustomTransceivers = if (!useCustomTransceivers || transceiversUrl.isNotBlank()) useCustomTransceivers else current.useCustomTransceivers,
-                    transceiversUrl = if (!useCustomTransceivers || transceiversUrl.isNotBlank()) transceiversUrl else current.transceiversUrl
-                )
-                if (newSettings != current) onAction(SettingsAction.UpdateDataSources(newSettings))
-                if (useCustomTle || useCustomTransceivers) onAction(SettingsAction.UpdateFromWeb)
+            onSave = { satUrls, txUrls ->
+                val newSettings = DataSourcesSettings(satelliteUrls = satUrls, transceiversUrls = txUrls)
+                if (newSettings != uiState.dataSourcesSettings) onAction(SettingsAction.UpdateDataSources(newSettings))
+                onAction(SettingsAction.UpdateFromWeb)
             }
         )
     }
@@ -137,14 +142,15 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
         NetworkOutputDialog(
             initialSettings = uiState.rcSettings,
             onDismiss = { dialogs.network = false },
-            onSave = { rotState, rotAddr, rotPort, rotFmt, freqState, freqAddr, freqPort, freqFmt ->
+            onSave = { rotState, rotAddr, rotPort, rotFmt, freqState, freqAddr, freqPort, freqFmt, freqOffsetHz ->
                 onAction(
                     SettingsAction.UpdateRC(
                         uiState.rcSettings.copy(
                             rotatorState = rotState, rotatorAddress = rotAddr,
                             rotatorPort = rotPort, rotatorFormat = rotFmt,
                             frequencyState = freqState, frequencyAddress = freqAddr,
-                            frequencyPort = freqPort, frequencyFormat = freqFmt
+                            frequencyPort = freqPort, frequencyFormat = freqFmt,
+                            frequencyOffsetHz = freqOffsetHz
                         )
                     )
                 )
@@ -357,7 +363,7 @@ private fun LocationCard(
 @Composable
 private fun DataCardPreview() = MainTheme {
     val settings = DataSettings(true, 5000, 2500, 0L)
-    DataCard(settings = settings, {}, {}, {})
+    DataCard(settings = settings, updateFromWeb = {}, clearAllData = {}, showDataSourcesDialog = {})
 }
 
 @Composable
@@ -653,14 +659,17 @@ private class SettingsPermissions(
     val launchTleImport: () -> Unit,
     val launchTransceiverImport: () -> Unit,
     val launchBluetooth: () -> Unit,
-    val launchNetwork: () -> Unit
+    val launchNetwork: () -> Unit,
+    val launchCustomSourcesPermission: () -> Unit
 )
 
 @Composable
 private fun rememberSettingsPermissions(
     sendAction: (SettingsAction) -> Unit,
     onBluetoothGranted: () -> Unit,
-    onNetworkGranted: () -> Unit
+    onNetworkGranted: () -> Unit,
+    onCustomSourcesPermissionGranted: () -> Unit,
+    onCustomSourcesPermissionDenied: () -> Unit
 ): SettingsPermissions {
     val locationError = stringResource(R.string.prefs_loc_gps_error)
     val locationRequest = rememberLauncherForActivityResult(
@@ -672,12 +681,15 @@ private fun rememberSettingsPermissions(
         else sendAction(SettingsAction.ShowToast(locationError))
     }
 
+    val satellitesImportError = stringResource(R.string.prefs_data_import_satellites_error)
+    val transceiversImportError = stringResource(R.string.prefs_data_import_transceivers_error)
+
     val tleRequest = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
-        uri?.let { sendAction(SettingsAction.UpdateTLEFromFile(it.toString())) }
+        uri?.let { sendAction(SettingsAction.UpdateTLEFromFile(it.toString(), satellitesImportError)) }
     }
 
     val transceiversRequest = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
-        uri?.let { sendAction(SettingsAction.UpdateTransceiversFromFile(it.toString())) }
+        uri?.let { sendAction(SettingsAction.UpdateTransceiversFromFile(it.toString(), transceiversImportError)) }
     }
 
     val bluetoothError = stringResource(R.string.prefs_bt_perm_error)
@@ -694,6 +706,15 @@ private fun rememberSettingsPermissions(
         else sendAction(SettingsAction.ShowToast(networkError))
     }
 
+    val customSourcesRequest = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+        if (granted) {
+            onCustomSourcesPermissionGranted()
+        } else {
+            onCustomSourcesPermissionDenied()
+            sendAction(SettingsAction.ShowToast(networkError))
+        }
+    }
+
     return remember {
         SettingsPermissions(
             launchLocation = {
@@ -710,6 +731,13 @@ private fun rememberSettingsPermissions(
                 } else {
                     onNetworkGranted()
                 }
+            },
+            launchCustomSourcesPermission = {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CINNAMON_BUN) {
+                    customSourcesRequest.launch(Manifest.permission.ACCESS_LOCAL_NETWORK)
+                } else {
+                    onCustomSourcesPermissionGranted()
+                }
             }
         )
     }

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

@@ -28,7 +28,10 @@ data class PositionSettings(
 )
 
 data class DataSettings(
-    val isUpdating: Boolean, val entriesTotal: Int, val radiosTotal: Int, val timestamp: Long
+    val isUpdating: Boolean,
+    val entriesTotal: Int,
+    val radiosTotal: Int,
+    val timestamp: Long
 )
 
 data class SettingsState(
@@ -50,8 +53,8 @@ sealed interface SettingsAction {
 
     // Data
     data object UpdateFromWeb : SettingsAction
-    data class UpdateTLEFromFile(val uri: String) : SettingsAction
-    data class UpdateTransceiversFromFile(val uri: String) : SettingsAction
+    data class UpdateTLEFromFile(val uri: String, val invalidFileMessage: String) : SettingsAction
+    data class UpdateTransceiversFromFile(val uri: String, val invalidFileMessage: String) : SettingsAction
     data object ClearAllData : SettingsAction
 
     // Toggles

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

@@ -65,11 +65,11 @@ class SettingsViewModel(
             settingsRepo.databaseState.collect { state ->
                 _uiState.update {
                     it.copy(
-                        dataSettings = DataSettings(
-                            false,
-                            state.numberOfSatellites,
-                            state.numberOfRadios,
-                            state.updateTimestamp
+                        dataSettings = it.dataSettings.copy(
+                            isUpdating = false,
+                            entriesTotal = state.numberOfSatellites,
+                            radiosTotal = state.numberOfRadios,
+                            timestamp = state.updateTimestamp
                         )
                     )
                 }
@@ -107,11 +107,11 @@ class SettingsViewModel(
             SettingsAction.DismissPosMessages -> dismissPosMessage()
             // Data
             SettingsAction.UpdateFromWeb -> runDataUpdate { databaseRepo.updateFromRemote() }
-            is SettingsAction.UpdateTLEFromFile -> runDataUpdate { databaseRepo.updateTLEFromFile(action.uri) }
-            is SettingsAction.UpdateTransceiversFromFile -> runDataUpdate {
-                databaseRepo.updateTransceiversFromFile(
-                    action.uri
-                )
+            is SettingsAction.UpdateTLEFromFile -> runManualImport(action.invalidFileMessage) {
+                databaseRepo.updateTLEFromFile(action.uri)
+            }
+            is SettingsAction.UpdateTransceiversFromFile -> runManualImport(action.invalidFileMessage) {
+                databaseRepo.updateTransceiversFromFile(action.uri)
             }
             SettingsAction.ClearAllData -> viewModelScope.launch { databaseRepo.clearAllData() }
             // Toggles
@@ -184,9 +184,23 @@ class SettingsViewModel(
         }
     }
 
+    private fun runManualImport(importErrorMessage: String, block: suspend () -> Int) {
+        viewModelScope.launch {
+            try {
+                _uiState.update { it.copy(dataSettings = it.dataSettings.copy(isUpdating = true)) }
+                if (block() == 0) showToast(importErrorMessage)
+            } catch (exception: Exception) {
+                _uiState.update { it.copy(dataSettings = it.dataSettings.copy(isUpdating = false)) }
+                println(exception)
+            }
+        }
+    }
+
+
     // endregion
 
     companion object {
+
         fun factory(container: IMainContainer) = viewModelFactory {
             initializer {
                 SettingsViewModel(

feature/status/build.gradle.kts

@@ -0,0 +1,17 @@
+import com.android.build.api.dsl.LibraryExtension
+
+plugins {
+    alias(libs.plugins.convention.featurePlugin)
+}
+
+android {
+    namespace = "com.rtbishop.look4sat.feature.status"
+    compileOptions {
+        encoding = "UTF-8"
+    }
+}
+
+dependencies {
+    implementation(project(":core:domain"))
+    implementation(project(":core:presentation"))
+}

feature/status/src/main/java/com/rtbishop/look4sat/feature/status/SatStatusScreen.kt

@@ -0,0 +1,624 @@
+package com.rtbishop.look4sat.feature.status
+
+import androidx.compose.animation.AnimatedVisibility
+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.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.heightIn
+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.items
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.FilterChipDefaults
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+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.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+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
+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.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.rtbishop.look4sat.core.domain.model.SatDay
+import com.rtbishop.look4sat.core.domain.model.SatReport
+import com.rtbishop.look4sat.core.domain.model.SatSlot
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.presentation.CardButton
+import com.rtbishop.look4sat.core.presentation.InfoDialog
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.layoutPadding
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+/** Fixed width per day tile — tablet-safe; name column absorbs remaining space. */
+private val TILE_WIDTH: Dp = 64.dp
+
+private data class UploadOption(
+    val apiValue: String,
+    val labelResId: Int,
+    val color: Color
+)
+
+private val UPLOAD_OPTIONS = listOf(
+    UploadOption(AMSAT_REPORT_HEARD, R.string.amsat_upload_active, Color(0xFF648FFF)),
+    UploadOption(AMSAT_REPORT_TELEMETRY_ONLY, R.string.amsat_upload_tlm, Color(0xFFFFB000)),
+    UploadOption(AMSAT_REPORT_NOT_HEARD, R.string.amsat_upload_not_heard, Color(0xFFDC267F)),
+    UploadOption(AMSAT_REPORT_CREW_ACTIVE, R.string.amsat_upload_crew_active, Color(0xFFFE6100))
+)
+
+/**
+ * Map AMSAT status text to Material3 colorScheme colors.
+ * Addresses PR #233 review: use colorScheme instead of hardcoded Color() constants.
+ */
+@Composable
+private fun statusColorOf(statusText: String): Color {
+    return when {
+        statusText.contains("Heard", ignoreCase = true) && !statusText.contains("Not", ignoreCase = true) ->
+            MaterialTheme.colorScheme.tertiary
+        statusText.contains("Telemetry", ignoreCase = true) || statusText.contains("Beacon", ignoreCase = true) ->
+            MaterialTheme.colorScheme.tertiaryContainer
+        statusText.contains("Not Heard", ignoreCase = true) ->
+            Color(0xFFDC267F)
+        else ->
+            MaterialTheme.colorScheme.error
+    }
+}
+
+@Composable
+fun SatStatusDestination() {
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val viewModel: SatStatusViewModel = viewModel(factory = SatStatusViewModel.factory(container))
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    DisposableEffect(lifecycleOwner, viewModel) {
+        var skipInitialStart = true
+        val observer = LifecycleEventObserver { _, event ->
+            if (event == Lifecycle.Event.ON_START) {
+                if (skipInitialStart) {
+                    skipInitialStart = false
+                } else {
+                    viewModel.fetch()
+                }
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
+    }
+    SatStatusScreen(
+        uiState = uiState,
+        refresh = viewModel::refresh,
+        onToggleUpload = viewModel::toggleUploadPanel,
+        onUploadReportChange = viewModel::setUploadReport,
+        onUploadCallsignChange = viewModel::setUploadCallsign,
+        onUploadGridChange = viewModel::setUploadGrid,
+        onRequestSubmitUpload = viewModel::requestSubmitConfirmation,
+        onConfirmSubmitUpload = viewModel::confirmSubmitReport,
+        onDismissSubmitConfirmation = viewModel::dismissSubmitConfirmation,
+        onDismissUpload = viewModel::collapseUploadPanel
+    )
+}
+
+@Composable
+private fun SatStatusScreen(
+    uiState: SatStatusUiState,
+    refresh: () -> Unit,
+    onToggleUpload: () -> Unit,
+    onUploadReportChange: (String) -> Unit,
+    onUploadCallsignChange: (String) -> Unit,
+    onUploadGridChange: (String) -> Unit,
+    onRequestSubmitUpload: () -> Unit,
+    onConfirmSubmitUpload: (String) -> Unit,
+    onDismissSubmitConfirmation: () -> Unit,
+    onDismissUpload: () -> Unit
+) {
+    var selectedDay by remember { mutableStateOf<Pair<SatStatus, SatDay>?>(null) }
+    Column(modifier = Modifier.fillMaxSize().layoutPadding()) {
+        StatusHeader(fetchedAtUtcMs = uiState.fetchedAtUtcMs, isRefreshing = uiState.isRefreshing, onRefresh = refresh)
+        LegendRow()
+
+        when {
+            uiState.isLoading -> {
+                Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator()
+                }
+            }
+            uiState.error != null && uiState.statuses.isEmpty() -> {
+                Column(
+                    modifier = Modifier.fillMaxSize(),
+                    verticalArrangement = Arrangement.Center,
+                    horizontalAlignment = Alignment.CenterHorizontally
+                ) {
+                    Text(text = stringResource(id = R.string.amsat_load_failed), color = MaterialTheme.colorScheme.error)
+                    TextButton(onClick = refresh) { Text(text = stringResource(id = R.string.amsat_retry)) }
+                }
+            }
+            else -> {
+                HeaderRow(statuses = uiState.statuses)
+                HorizontalDivider(thickness = 1.dp)
+                LazyColumn(modifier = Modifier.fillMaxSize()) {
+                    items(uiState.statuses, key = { it.name }) { status ->
+                        StatusRow(status = status, onClickDay = { day -> selectedDay = status to day })
+                    }
+                }
+            }
+        }
+    }
+
+    selectedDay?.let { (status, day) ->
+        ReportDialog(
+            statusName = status.name,
+            day = day,
+            reports = uiState.reports,
+            upload = uiState.upload,
+            onToggleUpload = onToggleUpload,
+            onReportChange = onUploadReportChange,
+            onCallsignChange = onUploadCallsignChange,
+            onGridChange = onUploadGridChange,
+            onRequestSubmitReport = onRequestSubmitUpload,
+            onConfirmSubmitReport = { onConfirmSubmitUpload(status.name) },
+            onDismissSubmitConfirmation = onDismissSubmitConfirmation,
+            onDismiss = {
+                selectedDay = null
+                onDismissUpload()
+            }
+        )
+    }
+}
+
+/** Top: update time + refresh button (spinner while loading) */
+@Composable
+private fun StatusHeader(fetchedAtUtcMs: Long, isRefreshing: Boolean, onRefresh: () -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = if (fetchedAtUtcMs > 0)
+                stringResource(id = R.string.amsat_updated) + " " + formatFetchedAt(fetchedAtUtcMs)
+            else
+                stringResource(id = R.string.amsat_title),
+            fontSize = 14.sp,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.weight(1f)
+        )
+        Box(
+            modifier = Modifier
+                .size(32.dp)
+                .clip(CircleShape)
+                .background(MaterialTheme.colorScheme.surfaceVariant)
+                .clickable(onClick = onRefresh),
+            contentAlignment = Alignment.Center
+        ) {
+            if (isRefreshing) {
+                CircularProgressIndicator(modifier = Modifier.size(16.dp), strokeWidth = 2.dp)
+            } else {
+                Image(
+                    painter = painterResource(id = R.drawable.ic_refresh),
+                    contentDescription = stringResource(id = R.string.amsat_refresh),
+                    modifier = Modifier.size(16.dp),
+                    colorFilter = ColorFilter.tint(MaterialTheme.colorScheme.primary)
+                )
+            }
+        }
+    }
+}
+
+/** Legend: FlowRow of colored chips — wraps to two lines on narrow screens, stays one line when wide. */
+@Composable
+private fun LegendRow() {
+    val legend = listOf(
+        stringResource(id = R.string.amsat_active) to Color(0xFF648FFF),
+        stringResource(id = R.string.amsat_tlm) to Color(0xFFFFB000),
+        stringResource(id = R.string.amsat_not_heard) to Color(0xFFDC267F),
+        stringResource(id = R.string.amsat_conflict) to Color(0xFFFE6100)
+    )
+    FlowRow(
+        modifier = Modifier.fillMaxWidth().padding(bottom = 6.dp),
+        horizontalArrangement = Arrangement.spacedBy(6.dp),
+        verticalArrangement = Arrangement.spacedBy(6.dp)
+    ) {
+        legend.forEach { (label, color) ->
+            val alphaColor = color.copy(alpha = 0.25f)
+            Row(
+                modifier = Modifier
+                    .clip(RoundedCornerShape(32.dp))
+                    .background(alphaColor)
+                    .padding(horizontal = 12.dp, vertical = 4.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Box(
+                    modifier = Modifier
+                        .size(8.dp)
+                        .clip(RoundedCornerShape(4.dp))
+                        .background(color)
+                )
+                Spacer(modifier = Modifier.width(6.dp))
+                Text(
+                    text = label,
+                    fontSize = 14.sp,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}
+
+/** Header: satellite name column + fixed-width date labels aligned to tiles. */
+@Composable
+private fun HeaderRow(statuses: List<SatStatus>) {
+    val dates = statuses.firstOrNull()?.days?.map { it.dateLabel } ?: emptyList()
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = stringResource(id = R.string.amsat_name),
+            fontSize = 12.sp,
+            fontWeight = FontWeight.Medium,
+            color = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.weight(1f).padding(start = 4.dp)
+        )
+        dates.forEach { date ->
+            Text(
+                text = date,
+                fontSize = 12.sp,
+                fontWeight = FontWeight.Medium,
+                textAlign = TextAlign.Center,
+                color = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.width(TILE_WIDTH)
+            )
+        }
+    }
+}
+
+/** Satellite row: name takes remaining width; day tiles are fixed-width (tablet-safe). */
+@Composable
+private fun StatusRow(status: SatStatus, onClickDay: (SatDay) -> Unit) {
+    val noReportGray = 0xFFC0C0C0L
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = status.name,
+            fontSize = 14.sp,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            modifier = Modifier.weight(1f).padding(end = 4.dp)
+        )
+        status.days.forEach { day ->
+            val slot = day.slots.firstOrNull { it.statusColor != noReportGray } ?: day.slots.first()
+            DayCell(
+                slot = slot,
+                modifier = Modifier.width(TILE_WIDTH).padding(horizontal = 2.dp),
+                onClick = { onClickDay(day) }
+            )
+        }
+    }
+}
+
+/** Day block: newest reported status among the day's 12 slots; gray when none. */
+@Composable
+private fun DayCell(slot: SatSlot, modifier: Modifier, onClick: () -> Unit) {
+    val color = Color(slot.statusColor)
+    Box(
+        modifier = modifier
+            .height(28.dp)
+            .clip(RoundedCornerShape(4.dp))
+            .background(color)
+            .clickable(onClick = onClick),
+        contentAlignment = Alignment.Center
+    ) {
+        if (slot.count > 0) {
+            Text(text = slot.count.toString(), fontSize = 13.sp, fontWeight = FontWeight.Bold, color = Color.White)
+        }
+    }
+}
+
+/** Report detail dialog (callsign / date / time / grid) */
+@Composable
+private fun ReportDialog(
+    statusName: String,
+    day: SatDay,
+    reports: Map<String, SatReport>,
+    upload: AmSatUploadUiState,
+    onToggleUpload: () -> Unit,
+    onReportChange: (String) -> Unit,
+    onCallsignChange: (String) -> Unit,
+    onGridChange: (String) -> Unit,
+    onRequestSubmitReport: () -> Unit,
+    onConfirmSubmitReport: () -> Unit,
+    onDismissSubmitConfirmation: () -> Unit,
+    onDismiss: () -> Unit
+) {
+    val dayReports = day.slots.flatMap { it.reportIds }.mapNotNull { reports[it] }
+    InfoDialog(
+        title = "$statusName · ${day.dateLabel}",
+        onDismiss = onDismiss,
+        onAccept = onDismiss,
+        extraAction = {
+            CardButton(
+                onClick = onToggleUpload,
+                text = stringResource(if (upload.isExpanded) R.string.amsat_upload_back else R.string.amsat_upload)
+            )
+        }
+    ) {
+        AnimatedVisibility(visible = upload.isExpanded) {
+            AmSatUploadPanel(
+                statusName = statusName,
+                upload = upload,
+                onReportChange = onReportChange,
+                onCallsignChange = onCallsignChange,
+                onGridChange = onGridChange,
+                onRequestSubmitReport = onRequestSubmitReport
+            )
+        }
+        if (upload.isConfirmingSubmit) {
+            AmSatUploadConfirmDialog(
+                statusName = statusName,
+                upload = upload,
+                onConfirm = onConfirmSubmitReport,
+                onDismiss = onDismissSubmitConfirmation
+            )
+        }
+        if (dayReports.isEmpty()) {
+            Text(
+                text = stringResource(id = R.string.amsat_no_reports),
+                modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+            )
+            Spacer(modifier = Modifier.height(8.dp))
+        } else {
+            LazyColumn(modifier = Modifier.heightIn(max = 480.dp)) {
+                items(dayReports) { report ->
+                    Column(modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)) {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Box(
+                                modifier = Modifier
+                                    .size(8.dp)
+                                    .clip(CircleShape)
+                                    .background(statusColorOf(report.statusText))
+                            )
+                            Spacer(modifier = Modifier.width(6.dp))
+                            Text(text = report.statusText, fontSize = 14.sp, fontWeight = FontWeight.Bold)
+                        }
+                        Text(
+                            text = "${report.call}  ${report.dateUtc}  ${report.timeUtc}" +
+                                if (report.grid.isNotBlank() && report.grid != "-") "  ${report.grid}" else "",
+                            fontSize = 14.sp,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                    HorizontalDivider(thickness = 0.5.dp)
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AmSatUploadPanel(
+    statusName: String,
+    upload: AmSatUploadUiState,
+    onReportChange: (String) -> Unit,
+    onCallsignChange: (String) -> Unit,
+    onGridChange: (String) -> Unit,
+    onRequestSubmitReport: () -> Unit
+) {
+    val options = remember(statusName) {
+        if (statusName.startsWith("ISS")) UPLOAD_OPTIONS else UPLOAD_OPTIONS.filter { it.apiValue != AMSAT_REPORT_CREW_ACTIVE }
+    }
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp, vertical = 8.dp)
+            .clip(RoundedCornerShape(16.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f))
+            .padding(12.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp)
+    ) {
+        Text(
+            text = stringResource(R.string.amsat_upload_report),
+            fontSize = 16.sp,
+            fontWeight = FontWeight.Medium,
+            color = MaterialTheme.colorScheme.primary
+        )
+        Text(
+            text = stringResource(R.string.amsat_upload_time_now, formatUtcNowForUpload(System.currentTimeMillis())),
+            fontSize = 12.sp,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+        Text(
+            text = stringResource(R.string.amsat_upload_status),
+            fontSize = 12.sp,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+        FlowRow(
+            horizontalArrangement = Arrangement.spacedBy(6.dp),
+            verticalArrangement = Arrangement.spacedBy(4.dp)
+        ) {
+            options.forEach { option ->
+                val selected = upload.selectedReport == option.apiValue
+                FilterChip(
+                    selected = selected,
+                    onClick = { onReportChange(option.apiValue) },
+                    label = {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Box(
+                                modifier = Modifier
+                                    .size(8.dp)
+                                    .clip(CircleShape)
+                                    .background(if (selected) Color.White else option.color)
+                            )
+                            Spacer(modifier = Modifier.width(6.dp))
+                            Text(stringResource(option.labelResId), maxLines = 1)
+                        }
+                    },
+                    colors = FilterChipDefaults.filterChipColors(
+                        containerColor = option.color.copy(alpha = 0.10f),
+                        labelColor = MaterialTheme.colorScheme.onSurface,
+                        selectedContainerColor = option.color,
+                        selectedLabelColor = Color.White
+                    ),
+                    border = FilterChipDefaults.filterChipBorder(
+                        enabled = true,
+                        selected = selected,
+                        borderColor = option.color.copy(alpha = 0.60f),
+                        selectedBorderColor = option.color
+                    )
+                )
+            }
+        }
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth()) {
+            OutlinedTextField(
+                value = upload.callsign,
+                onValueChange = onCallsignChange,
+                label = { Text(stringResource(R.string.amsat_upload_callsign)) },
+                singleLine = true,
+                modifier = Modifier.weight(1f)
+            )
+            OutlinedTextField(
+                value = upload.gridSquare,
+                onValueChange = onGridChange,
+                label = { Text(stringResource(R.string.amsat_upload_grid)) },
+                singleLine = true,
+                modifier = Modifier.weight(1f)
+            )
+        }
+        Button(
+            onClick = onRequestSubmitReport,
+            enabled = !upload.isSubmitting && upload.callsign.isNotBlank(),
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            if (upload.isSubmitting) {
+                CircularProgressIndicator(modifier = Modifier.size(16.dp), strokeWidth = 2.dp)
+            } else {
+                Text(stringResource(R.string.amsat_upload_submit))
+            }
+        }
+        upload.message?.let { message ->
+            if (message == UPLOAD_MESSAGE_SUCCESS) {
+                Text(
+                    text = stringResource(R.string.amsat_upload_success),
+                    fontSize = 12.sp,
+                    color = MaterialTheme.colorScheme.primary
+                )
+            }
+        }
+        upload.error?.let { error ->
+            Text(
+                text = uploadErrorText(error),
+                fontSize = 12.sp,
+                color = MaterialTheme.colorScheme.error
+            )
+        }
+    }
+}
+
+@Composable
+private fun AmSatUploadConfirmDialog(
+    statusName: String,
+    upload: AmSatUploadUiState,
+    onConfirm: () -> Unit,
+    onDismiss: () -> Unit
+) {
+    val option = UPLOAD_OPTIONS.firstOrNull { it.apiValue == upload.selectedReport } ?: UPLOAD_OPTIONS.first()
+    val statusLabel = stringResource(option.labelResId)
+    val grid = upload.gridSquare.ifBlank { stringResource(R.string.amsat_upload_grid_none) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.amsat_upload_confirm_title)) },
+        text = {
+            Text(
+                text = stringResource(
+                    R.string.amsat_upload_confirm_message,
+                    statusName,
+                    statusLabel,
+                    upload.callsign,
+                    grid
+                )
+            )
+        },
+        confirmButton = {
+            TextButton(onClick = onConfirm, enabled = !upload.isSubmitting) {
+                Text(stringResource(R.string.amsat_upload_confirm))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss, enabled = !upload.isSubmitting) {
+                Text(stringResource(R.string.btn_cancel))
+            }
+        }
+    )
+}
+
+@Composable
+private fun uploadErrorText(error: String): String {
+    return when (error) {
+        UPLOAD_ERROR_CALLSIGN_REQUIRED -> stringResource(R.string.amsat_upload_callsign_required)
+        UPLOAD_ERROR_GRID_INVALID -> stringResource(R.string.amsat_upload_grid_invalid)
+        else -> stringResource(R.string.amsat_upload_failed, error)
+    }
+}
+
+private val MONTH_ABBR = arrayOf("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+
+private fun formatFetchedAt(utcMs: Long): String {
+    val cal = Calendar.getInstance()
+    cal.timeInMillis = utcMs
+    val day = cal.get(Calendar.DAY_OF_MONTH)
+    val month = MONTH_ABBR[cal.get(Calendar.MONTH)]
+    val year = cal.get(Calendar.YEAR)
+    val hh = cal.get(Calendar.HOUR_OF_DAY).toString().padStart(2, '0')
+    val mm = cal.get(Calendar.MINUTE).toString().padStart(2, '0')
+    val ss = cal.get(Calendar.SECOND).toString().padStart(2, '0')
+    return "$day$month $year - $hh:$mm:$ss"
+}
+
+private fun formatUtcNowForUpload(utcMs: Long): String {
+    val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+    }
+    return formatter.format(Date(utcMs))
+}

feature/status/src/main/java/com/rtbishop/look4sat/feature/status/SatStatusViewModel.kt

@@ -0,0 +1,294 @@
+package com.rtbishop.look4sat.feature.status
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.SatReport
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+import com.rtbishop.look4sat.core.domain.repository.IAmSatRepository
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import java.util.Locale
+
+const val AMSAT_REPORT_HEARD = "Heard"
+const val AMSAT_REPORT_TELEMETRY_ONLY = "Telemetry Only"
+const val AMSAT_REPORT_NOT_HEARD = "Not Heard"
+const val AMSAT_REPORT_CREW_ACTIVE = "Crew Active"
+
+const val UPLOAD_ERROR_CALLSIGN_REQUIRED = "callsign_required"
+const val UPLOAD_ERROR_GRID_INVALID = "grid_invalid"
+const val UPLOAD_MESSAGE_SUCCESS = "success"
+
+data class AmSatUploadUiState(
+    val isExpanded: Boolean = false,
+    val selectedReport: String = AMSAT_REPORT_HEARD,
+    val callsign: String = "",
+    val gridSquare: String = "",
+    val isSubmitting: Boolean = false,
+    val isConfirmingSubmit: Boolean = false,
+    val message: String? = null,
+    val error: String? = null
+)
+
+data class SatStatusUiState(
+    val isLoading: Boolean = false,
+    val isRefreshing: Boolean = false,
+    val statuses: List<SatStatus> = emptyList(),
+    val reports: Map<String, SatReport> = emptyMap(),
+    val fetchedAtUtcMs: Long = 0L,
+    val error: String? = null,
+    val upload: AmSatUploadUiState = AmSatUploadUiState()
+)
+
+class SatStatusViewModel(
+    private val amSatRepo: IAmSatRepository,
+    private val settingsRepo: ISettingsRepo
+) : ViewModel() {
+
+    private val cachedStatusPage = amSatRepo.getCachedStatus()
+    private val _uiState = MutableStateFlow(cachedStatusPage?.toUiState() ?: SatStatusUiState(isLoading = true))
+    val uiState: StateFlow<SatStatusUiState> = _uiState
+
+    init {
+        if (cachedStatusPage == null) fetch()
+    }
+
+    fun fetch() {
+        amSatRepo.getCachedStatus()?.let { page ->
+            applyStatusPage(page)
+            return
+        }
+        viewModelScope.launch {
+            _uiState.update { it.copy(isLoading = true, error = null) }
+            try {
+                val page = amSatRepo.fetchStatus()
+                if (page != null && page.statuses.isNotEmpty()) {
+                    applyStatusPage(page)
+                } else {
+                    _uiState.update {
+                        it.copy(isLoading = false, isRefreshing = false, error = "fetch_failed")
+                    }
+                }
+            } catch (exception: Exception) {
+                _uiState.update {
+                    it.copy(isLoading = false, isRefreshing = false, error = exception.message ?: "fetch_failed")
+                }
+            }
+        }
+    }
+
+    fun refresh() {
+        if (_uiState.value.isRefreshing) return
+        _uiState.update { it.copy(isRefreshing = true, error = null) }
+        viewModelScope.launch {
+            try {
+                val page = amSatRepo.fetchStatus(forceRefresh = true)
+                if (page != null && page.statuses.isNotEmpty()) {
+                    applyStatusPage(page)
+                } else {
+                    _uiState.update { it.copy(isRefreshing = false, error = "fetch_failed") }
+                }
+            } catch (exception: Exception) {
+                _uiState.update { it.copy(isRefreshing = false, error = exception.message ?: "fetch_failed") }
+            }
+        }
+    }
+
+    private fun applyStatusPage(page: SatStatusPage) {
+        _uiState.update {
+            it.copy(
+                isLoading = false,
+                isRefreshing = false,
+                statuses = page.statuses,
+                reports = page.reports,
+                fetchedAtUtcMs = page.fetchedAtUtcMs,
+                error = null
+            )
+        }
+    }
+
+    fun toggleUploadPanel() {
+        val storedCallsign = settingsRepo.getAmSatCallsign()
+        val defaultGrid = defaultGridSquare()
+        _uiState.update { state ->
+            val upload = state.upload
+            val expanded = !upload.isExpanded
+            state.copy(
+                upload = if (expanded) {
+                    upload.copy(
+                        isExpanded = true,
+                        callsign = upload.callsign.ifBlank { storedCallsign },
+                        gridSquare = upload.gridSquare.ifBlank { defaultGrid },
+                        message = null,
+                        error = null
+                    )
+                } else {
+                    upload.copy(isExpanded = false, isConfirmingSubmit = false, message = null, error = null)
+                }
+            )
+        }
+    }
+
+    fun collapseUploadPanel() {
+        _uiState.update { it.copy(upload = it.upload.copy(isExpanded = false, isConfirmingSubmit = false, message = null, error = null)) }
+    }
+
+    fun setUploadReport(report: String) {
+        _uiState.update { it.copy(upload = it.upload.copy(selectedReport = report, isConfirmingSubmit = false, message = null, error = null)) }
+    }
+
+    fun setUploadCallsign(callsign: String) {
+        val normalized = callsign.trim().uppercase(Locale.US)
+        settingsRepo.setAmSatCallsign(normalized)
+        _uiState.update { it.copy(upload = it.upload.copy(callsign = normalized, isConfirmingSubmit = false, message = null, error = null)) }
+    }
+
+    fun setUploadGrid(grid: String) {
+        val normalized = grid.trim().uppercase(Locale.US)
+        _uiState.update { it.copy(upload = it.upload.copy(gridSquare = normalized, isConfirmingSubmit = false, message = null, error = null)) }
+    }
+
+    fun requestSubmitConfirmation() {
+        val prepared = validateUpload(_uiState.value.upload) ?: return
+        _uiState.update {
+            it.copy(
+                upload = it.upload.copy(
+                    callsign = prepared.callsign,
+                    gridSquare = prepared.grid,
+                    isConfirmingSubmit = true,
+                    message = null,
+                    error = null
+                )
+            )
+        }
+    }
+
+    fun dismissSubmitConfirmation() {
+        _uiState.update { it.copy(upload = it.upload.copy(isConfirmingSubmit = false)) }
+    }
+
+    fun confirmSubmitReport(satelliteName: String) {
+        val upload = _uiState.value.upload
+        if (upload.isSubmitting) return
+        val prepared = validateUpload(upload) ?: return
+
+        settingsRepo.setAmSatCallsign(prepared.callsign)
+        _uiState.update {
+            it.copy(
+                upload = it.upload.copy(
+                    callsign = prepared.callsign,
+                    gridSquare = prepared.grid,
+                    isSubmitting = true,
+                    isConfirmingSubmit = false,
+                    error = null,
+                    message = null
+                )
+            )
+        }
+        viewModelScope.launch {
+            val result = amSatRepo.submitReport(
+                AmSatReportSubmission(
+                    name = satelliteName,
+                    report = prepared.report,
+                    callsign = prepared.callsign,
+                    gridSquare = prepared.grid,
+                    reportedAtUtcMillis = System.currentTimeMillis()
+                )
+            )
+            if (result.success) {
+                _uiState.update {
+                    it.copy(
+                        upload = it.upload.copy(
+                            isSubmitting = false,
+                            callsign = prepared.callsign,
+                            gridSquare = prepared.grid,
+                            message = UPLOAD_MESSAGE_SUCCESS,
+                            error = null
+                        )
+                    )
+                }
+                refresh()
+            } else {
+                _uiState.update {
+                    it.copy(
+                        upload = it.upload.copy(
+                            isSubmitting = false,
+                            message = null,
+                            error = result.message.ifBlank { "Upload failed" }
+                        )
+                    )
+                }
+            }
+        }
+    }
+
+    private fun validateUpload(upload: AmSatUploadUiState): PreparedUpload? {
+        val callsign = upload.callsign.trim().uppercase(Locale.US)
+        val grid = upload.gridSquare.trim().uppercase(Locale.US)
+        return when {
+            callsign.isBlank() -> {
+                _uiState.update {
+                    it.copy(
+                        upload = it.upload.copy(
+                            isConfirmingSubmit = false,
+                            error = UPLOAD_ERROR_CALLSIGN_REQUIRED,
+                            message = null
+                        )
+                    )
+                }
+                null
+            }
+            grid.isNotBlank() && !MAIDENHEAD_GRID.matches(grid) -> {
+                _uiState.update {
+                    it.copy(
+                        upload = it.upload.copy(
+                            isConfirmingSubmit = false,
+                            error = UPLOAD_ERROR_GRID_INVALID,
+                            message = null
+                        )
+                    )
+                }
+                null
+            }
+            else -> PreparedUpload(
+                report = upload.selectedReport,
+                callsign = callsign,
+                grid = grid
+            )
+        }
+    }
+
+    private fun defaultGridSquare(): String {
+        val grid = settingsRepo.stationPosition.value.qthLocator.trim().uppercase(Locale.US)
+        return grid.takeUnless { it == "JJ00AA" }.orEmpty()
+    }
+
+    companion object {
+        fun factory(container: IMainContainer) = viewModelFactory {
+            initializer {
+                SatStatusViewModel(container.amSatRepo, container.settingsRepo)
+            }
+        }
+    }
+}
+
+private fun SatStatusPage.toUiState() = SatStatusUiState(
+    statuses = statuses,
+    reports = reports,
+    fetchedAtUtcMs = fetchedAtUtcMs
+)
+
+private data class PreparedUpload(
+    val report: String,
+    val callsign: String,
+    val grid: String
+)
+
+private val MAIDENHEAD_GRID = Regex("^[A-R]{2}[0-9]{2}([A-X]{2})?$")

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
 [versions]
 #noinspection UnusedVersionCatalogEntry
-appVersionCode = "443"
+appVersionCode = "450"
 #noinspection UnusedVersionCatalogEntry
-appVersionName = "4.4.3"
+appVersionName = "4.4.6-ba7opf.6"
 #noinspection UnusedVersionCatalogEntry
 compileSdk = "37"
 #noinspection UnusedVersionCatalogEntry
@@ -12,20 +12,20 @@ jdkVersion = "21"
 #noinspection UnusedVersionCatalogEntry
 packageName = "com.rtbishop.look4sat"
 
-android-gradle-plugin = "9.2.1"
+android-gradle-plugin = "9.3.1"
 
 androidx-core-ktx = "1.19.0"
 androidx-core-splashscreen = "1.2.0"
 androidx-room = "2.8.4"
 
-compose-bom = "2026.06.00"
+compose-bom = "2026.06.01"
 compose-activity = "1.13.0"
 compose-lifecycle = "2.11.0"
-compose-navigation3 = "1.1.3"
+compose-navigation3 = "1.1.5"
 
-google-ksp = "2.3.8"
+google-ksp = "2.3.10"
 
-kotlin = "2.4.0"
+kotlin = "2.4.10"
 kotlin-coroutines = "1.11.0"
 kotlin-serialization = "1.11.0"
 

settings.gradle.kts

@@ -22,8 +22,10 @@ include(
 )
 include(
     ":feature:map",
+    ":feature:mutual",
     ":feature:passes",
     ":feature:radar",
     ":feature:satellites",
-    ":feature:settings"
+    ":feature:settings",
+    ":feature:status"
 )