Add TianDiTu

.gitignore

@@ -1,9 +1,6 @@
 # Built application files
 *.ap_
 
-# Hermes AI plans and metadata
-.hermes/
-
 # Files for the ART/Dalvik VM
 *.dex
 

app/proguard-rules.pro

@@ -0,0 +1,3 @@
+-keep class org.osmdroid.** { *; }
+-keep class com.rtbishop.look4sat.feature.map.*TiandituTileSource* { *; }
+-dontwarn org.osmdroid.**

app/src/main/AndroidManifest.xml

@@ -15,7 +15,7 @@
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
 
     <application
-        android:name=".MainApplication"
+        android:name="cn.bh2vsq.look4sat.MainApplication"
         android:allowBackup="false"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -23,9 +23,8 @@
         android:roundIcon="@mipmap/ic_launcher_round">
 
         <activity
-            android:name=".MainActivity"
+            android:name="cn.bh2vsq.look4sat.MainActivity"
             android:exported="true"
-            android:screenOrientation="portrait"
             android:theme="@style/Theme.Look4Sat.SplashScreen">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
@@ -43,7 +42,7 @@
 
         <meta-data
             android:name="android.telephony.PROPERTY_SATELLITE_DATA_OPTIMIZED"
-            android:value="com.rtbishop.look4sat" />
+            android:value="cn.bh2vsq.look4sat" />
 
     </application>
 </manifest>

app/src/main/java/cn/bh2vsq/look4sat/MainActivity.kt

@@ -15,7 +15,7 @@
  * 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
+package cn.bh2vsq.look4sat
 
 import android.content.Context
 import android.content.res.Configuration

app/src/main/java/cn/bh2vsq/look4sat/MainApplication.kt

@@ -15,7 +15,7 @@
  * 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
+package cn.bh2vsq.look4sat
 
 import android.app.Application
 import com.rtbishop.look4sat.core.data.injection.MainContainer

app/src/main/java/cn/bh2vsq/look4sat/MainScreen.kt

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

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

@@ -1,283 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat
-
-import androidx.compose.animation.core.LinearEasing
-import androidx.compose.animation.core.RepeatMode
-import androidx.compose.animation.core.animateFloat
-import androidx.compose.animation.core.infiniteRepeatable
-import androidx.compose.animation.core.rememberInfiniteTransition
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
-import androidx.compose.animation.slideInHorizontally
-import androidx.compose.animation.slideOutHorizontally
-import androidx.compose.animation.togetherWith
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteDefaults
-import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold
-import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteType
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.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
-
-@Composable
-fun NavRoot(deeplink: String? = null) {
-    val rootBackStack = rememberNavBackStack(Screen.Passes)
-    val deeplinkResolver = DeeplinkResolver()
-    LaunchedEffect(deeplink) {
-        deeplink?.let {
-            val destination = deeplinkResolver.resolve(it) // rootBackStack.clear()
-            rootBackStack.add(destination)
-        }
-    }
-    val navigateBack: () -> Unit = { rootBackStack.removeLastOrNull() }
-    val slideInTransition = slideInHorizontally(initialOffsetX = { it }) togetherWith scaleOut(targetScale = 0.9f)
-    val slideOutTransition = scaleIn(initialScale = 0.9f) togetherWith slideOutHorizontally(targetOffsetX = { it })
-    NavDisplay(
-        modifier = Modifier.fillMaxSize(),
-        backStack = rootBackStack,
-        onBack = navigateBack,
-        transitionSpec = { slideInTransition },
-        popTransitionSpec = { slideOutTransition },
-        predictivePopTransitionSpec = { slideOutTransition },
-        entryDecorators = listOf(
-            rememberSaveableStateHolderNavEntryDecorator(), // Required for saving Compose state per entry
-            rememberViewModelStoreNavEntryDecorator() // Required for ViewModel scoping per entry
-        ),
-        entryProvider = entryProvider {
-            entry<Screen.Passes> { MainScreen(navigateToRadar = { rootBackStack.add(RadarDestination) }) }
-            entry<RadarDestination> {
-                Scaffold { innerPadding ->
-                    RadarDestination(navigateUp = navigateBack)
-                    innerPadding.calculateTopPadding()
-                }
-            }
-        }
-    )
-}
-
-@Composable
-fun MainScreen(navigateToRadar: () -> Unit = {}) {
-    val backStack = rememberNavBackStack(Screen.Passes)
-    val currentKey = backStack.lastOrNull()
-    val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
-    val fadeTransition = fadeIn(animationSpec = tween(350)) togetherWith fadeOut(animationSpec = tween(350))
-    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Mutual, Screen.Map, Screen.Settings)
-
-    val context = LocalContext.current
-    val container = (context.applicationContext as IContainerProvider).getMainContainer()
-    val trackingState by container.radioTrackingService.state.collectAsStateWithLifecycle()
-    val otherSettings by container.settingsRepo.otherSettings.collectAsStateWithLifecycle()
-    // 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)
-    )
-
-    CompositionLocalProvider(
-        LocalElevationThresholds provides ElevationThresholds(
-            low = otherSettings.lowElevation,
-            high = otherSettings.highElevation
-        )
-    ) {
-        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.Mutual -> screen is Screen.Mutual
-                        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
-            }
-        ) {
-            Column {
-                NavDisplay(
-                    backStack = backStack,
-                    modifier = Modifier.weight(1f),
-                    onBack = navigateBack,
-                    transitionSpec = { fadeTransition },
-                    popTransitionSpec = { fadeTransition },
-                    predictivePopTransitionSpec = { fadeTransition },
-                    entryDecorators = listOf(
-                        // Required for saving Compose state per entry
-                        rememberSaveableStateHolderNavEntryDecorator(),
-                        // Required for ViewModel scoping per entry
-                        rememberViewModelStoreNavEntryDecorator()
-                    ),
-                    entryProvider = entryProvider {
-                        entry<Screen.Satellites> {
-                            SatellitesDestination(navigateUp = navigateBack)
-                        }
-                        entry<Screen.Passes> {
-                            PassesDestination { catNum, aosTime ->
-                                container.setMutualPassData(MutualPassData())
-                                container.satelliteRepo.selectPass(catNum, aosTime)
-                                backStack.add(Screen.Radar)
-//                            navigateToRadar()
-                            }
-                        }
-                        entry<Screen.Radar> {
-                            RadarDestination(navigateUp = navigateBack)
-                        }
-                        entry<Screen.Map> {
-                            MapDestination()
-                        }
-                        entry<Screen.Mutual> {
-                            MutualScreen(
-                                viewModel = mutualViewModel,
-                                navigateUp = navigateBack,
-                                navigateToRadar = { catNum, aosTime, pass ->
-                                    container.setMutualPassData(pass ?: MutualPassData())
-                                    container.satelliteRepo.selectPass(catNum, aosTime)
-                                    backStack.add(Screen.Radar)
-                                }
-                            )
-                        }
-                        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.setMutualPassData(MutualPassData())
-                                    container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
-                                    backStack.add(Screen.Radar)
-                                }
-                            }
-                            .padding(horizontal = 12.dp, vertical = 6.dp)
-                    ) {
-                        Box(
-                            modifier = Modifier
-                                .size(8.dp)
-                                .clip(CircleShape)
-                                .background(Color(0xFF4CAF50).copy(alpha = alpha))
-                        )
-                        Spacer(modifier = Modifier.width(8.dp))
-                        Text(
-                            text = "Tracking: ${trackingState.currentPass?.name ?: ""}",
-                            fontSize = 13.sp,
-                            fontWeight = FontWeight.Medium,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer,
-                            modifier = Modifier.weight(1f)
-                        )
-                        val txOk = if (trackingState.txConnected) "TX" else ""
-                        val rxOk = if (trackingState.rxConnected) "RX" else ""
-                        Text(
-                            text = listOf(txOk, rxOk).filter { it.isNotBlank() }.joinToString("/"),
-                            fontSize = 12.sp,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer
-                        )
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <network-security-config>
-    <base-config cleartextTrafficPermitted="true" />
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="true">tianditu.gov.cn</domain>
+    </domain-config>
 </network-security-config>

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

@@ -32,7 +32,6 @@ 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"))

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

@@ -69,7 +69,7 @@ internal fun Project.setupAndroidApp() {
             release {
                 isMinifyEnabled = true
                 isShrinkResources = true
-                proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+                proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
             }
         }
         androidResources {

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

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

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

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

@@ -19,10 +19,8 @@ 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
@@ -31,7 +29,6 @@ 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
@@ -47,8 +44,6 @@ 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
 
@@ -56,427 +51,227 @@ 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 isIcom     = rcSettings.radioModel == RadioControlSettings.MODEL_ICOM_IC705
-        val isSplit    = isIcom && rcSettings.splitMode
+        val txAddr = rcSettings.txRadioAddress
+        val rxAddr = rcSettings.rxRadioAddress
 
-        Log.i(tag, "connectRadios model=${rcSettings.radioModel} split=$isSplit TX=$txAddr RX=$rxAddr")
+        Log.i(tag, "Connecting TX=$txAddr RX=$rxAddr")
 
-        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")
+        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
+                }
+            )
         }
     }
 
-    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()
-
-        val rcSettings = settingsRepo.radioControlSettings.value
-        val isIcom     = rcSettings.radioModel == RadioControlSettings.MODEL_ICOM_IC705
-        val isSplit    = isIcom && rcSettings.splitMode
-
-        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)
+        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")
             }
-
-        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)
+            if (rx != null && rx.isConnected && rxMode != null) {
+                rx.setMode(rxMode)
+                Log.i(tag, "RX mode set to $rxMode")
             }
-        }
-        _state.update { it.copy(txMode = txMode, rxMode = 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   = ""
-        var lastReadFreq  = 0L
-        var stableCount   = 0
+            var lastSetTxFreq = 0.0
+            var lastSetRxFreq = 0.0
+            var tuningRadio = "" // "", "tx", or "rx" - which radio the user is tuning
+            var lastReadFreq = 0L
+            var stableCount = 0
 
-        while (currentCoroutineContext().isActive) {
-            val currentState = _state.value
-            if (!currentState.isActive) break
+            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 pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, System.currentTimeMillis())
-            val txNow = txController
-            val rxNow = rxController
-            val v = pos.distanceRate * 1000.0
+                val satPass = currentState.currentPass ?: break
+                val xpdr = currentState.selectedTransponder ?: break
+                var txBaseFreq = currentState.txBaseFrequencyHz
+                val stationPos = settingsRepo.stationPosition.value
+                val timeNow = System.currentTimeMillis()
 
-            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")
-                                }
+                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)")
                             }
-                            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)")
+
+                // 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()
                     }
                 }
-                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()
+                _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
+                    )
                 }
-                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)
             }
-            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
@@ -493,6 +288,7 @@ 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)
@@ -506,17 +302,21 @@ class RadioTrackingService(
             transponder.uplinkLow != null -> transponder.uplinkLow!!
             else -> null
         }
+        // Show nominal frequencies immediately
         val rxNominal = if (txCenter != null) {
             TransponderMapper.mapUplinkToDownlink(txCenter, transponder)
-        } else transponder.downlinkLow
+        } else {
+            // Downlink-only transponder (beacon etc.) - use downlink directly
+            transponder.downlinkLow
+        }
         _state.update {
             it.copy(
                 selectedTransponder = transponder,
-                txBaseFrequencyHz   = txCenter,
-                txFrequencyHz       = txCenter,
-                rxFrequencyHz       = rxNominal,
-                txMode              = transponder.uplinkMode,
-                rxMode              = transponder.downlinkMode
+                txBaseFrequencyHz = txCenter,
+                txFrequencyHz = txCenter,
+                rxFrequencyHz = rxNominal,
+                txMode = transponder.uplinkMode,
+                rxMode = transponder.downlinkMode
                     ?: transponder.uplinkMode?.let { m ->
                         TransponderMapper.mapUplinkModeToDownlinkMode(m, transponder.isInverted)
                     }
@@ -553,4 +353,5 @@ class RadioTrackingService(
         }
         _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
     }
+
 }

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

@@ -26,7 +26,6 @@ import androidx.room.Room
 import com.rtbishop.look4sat.core.data.database.Look4SatDb
 import com.rtbishop.look4sat.core.data.framework.BluetoothReporter
 import com.rtbishop.look4sat.core.data.framework.Ft817Controller
-import com.rtbishop.look4sat.core.data.framework.Ic705Controller
 import com.rtbishop.look4sat.core.data.framework.NetworkReporter
 import com.rtbishop.look4sat.core.data.framework.RadioTrackingService
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
@@ -40,7 +39,6 @@ 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
@@ -50,7 +48,6 @@ 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
@@ -62,9 +59,6 @@ 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 {
@@ -81,13 +75,6 @@ class MainContainer(private val context: Context) : IMainContainer {
         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)
@@ -119,25 +106,15 @@ class MainContainer(private val context: Context) : IMainContainer {
     }
 
     override fun provideTxRadioController(): IRadioController {
-        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)
-        }
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val address = settingsRepo.radioControlSettings.value.txRadioAddress
+        return Ft817Controller(manager, address)
     }
 
     override fun provideRxRadioController(): IRadioController {
-        val manager  = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-        val settings = settingsRepo.radioControlSettings.value
-        val address  = settings.rxRadioAddress
-        return if (settings.radioModel == RadioControlSettings.MODEL_ICOM_IC705) {
-            Ic705Controller(manager, address)
-        } else {
-            Ft817Controller(manager, address)
-        }
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val address = settingsRepo.radioControlSettings.value.rxRadioAddress
+        return Ft817Controller(manager, address)
     }
 
     override fun provideSensorsRepo(): ISensorsRepo {

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

@@ -42,27 +42,21 @@ class DatabaseRepo(
 
     private val customSourceType = "Other"
 
-    override suspend fun updateTLEFromFile(uri: String): Int = withContext(dispatcher) {
-        var importedCount = 0
+    override suspend fun updateTLEFromFile(uri: String) = withContext(dispatcher) {
         remoteSource.getFileStream(uri)?.let { stream ->
-            val entries = parseSatelliteStream(uri, unwrapIfZipped(uri, stream))
+            val entries = dataParser.parseTLEStream(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): Int = withContext(dispatcher) {
-        var importedCount = 0
+    override suspend fun updateTransceiversFromFile(uri: String) = withContext(dispatcher) {
         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) {
@@ -100,31 +94,9 @@ class DatabaseRepo(
         setUpdateSuccessful(0L)
     }
 
-    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 parseSatelliteStream(url: String, stream: InputStream): List<OrbitalData> = when {
+        url.contains("FORMAT=csv", ignoreCase = true) -> dataParser.parseCSVStream(stream)
+        else -> dataParser.parseTLEStream(stream)
     }
 
     private suspend fun setUpdateSuccessful(timestamp: Long) {

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

@@ -36,7 +36,6 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
-import java.util.TimeZone
 
 class SatelliteRepo(
     private val dispatcher: CoroutineDispatcher,
@@ -65,16 +64,8 @@ class SatelliteRepo(
     override suspend fun initRepository() = withContext(dispatcher) {
         settingsRepo.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
-            )
+            val (_, hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
+            calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
         }
     }
 
@@ -114,15 +105,7 @@ class SatelliteRepo(
         }
     }
 
-    override suspend fun calculatePasses(
-        time: Long,
-        hoursAhead: Int,
-        minElevation: Double,
-        aosStartMinute: Int,
-        aosEndMinute: Int,
-        invertAosTimeWindow: Boolean,
-        modes: List<String>
-    ) {
+    override suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, 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
@@ -147,12 +130,7 @@ class SatelliteRepo(
             val newPasses = ArrayList<OrbitalPass>()
             for (list in passLists) {
                 for (pass in list) {
-                    if (
-                        pass.losTime > time
-                        && pass.aosTime < timeFuture
-                        && pass.maxElevation > minElevation
-                        && (pass.isDeepSpace || isAosInRange(pass.aosTime, aosStartMinute, aosEndMinute, invertAosTimeWindow))
-                    ) {
+                    if (pass.losTime > time && pass.aosTime < timeFuture && pass.maxElevation > minElevation) {
                         newPasses.add(pass)
                     }
                 }
@@ -164,23 +142,6 @@ 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

@@ -25,6 +25,7 @@ import androidx.core.location.LocationListenerCompat
 import androidx.core.location.LocationManagerCompat
 import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
 import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.MapSource
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
@@ -54,9 +55,6 @@ 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"
@@ -85,8 +83,8 @@ 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 keyMapSource = "mapSource"
+    private val keyTiandituKey = "tiandituKey"
     private val keyUseCustomTle = "useCustomTle"
     private val keyUseCustomTransceivers = "useCustomTransceivers"
     private val keyTleUrl = "tleUrl"
@@ -132,9 +130,6 @@ 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
     }
@@ -143,20 +138,9 @@ 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,
-            aosStartMinute,
-            aosEndMinute,
-            invertAosTimeWindow,
-            selectedModes
-        )
+        return PassesSettings(showDeepSpace, hoursAhead, minElevation, selectedModes)
     }
     //endregion
 
@@ -354,8 +338,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())
+                putString(keyMapSource, MapSource.normalize(new.mapSource))
+                putString(keyTiandituKey, new.tiandituKey)
             }
             new
         }
@@ -371,8 +355,8 @@ class SettingsRepo(
         shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
         shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
         sstvMode = preferences.getString(keySstvMode, null) ?: "Auto",
-        lowElevation = Double.fromBits(preferences.getLong(keyLowElevation, 15.0.toRawBits())),
-        highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits()))
+        mapSource = MapSource.normalize(preferences.getString(keyMapSource, null) ?: MapSource.TIANDITU_VECTOR),
+        tiandituKey = preferences.getString(keyTiandituKey, null) ?: ""
     )
     //endregion
 
@@ -406,7 +390,6 @@ 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
@@ -420,20 +403,18 @@ 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) ?: RadioControlSettings.MODEL_YAESU_FT817,
+        radioModel = preferences.getString(keyRadioModel, null) ?: "Yaesu FT-817/818",
         txRadioAddress = preferences.getString(keyTxRadioAddress, null) ?: "",
         rxRadioAddress = preferences.getString(keyRxRadioAddress, null) ?: "",
         txRadioName = preferences.getString(keyTxRadioName, null) ?: "TX Radio",
         rxRadioName = preferences.getString(keyRxRadioName, null) ?: "RX Radio",
-        baudRate = preferences.getInt(keyRadioBaudRate, 4800),
-        splitMode = preferences.getBoolean(keyRadioSplitMode, false)
+        baudRate = preferences.getInt(keyRadioBaudRate, 4800)
     )
     //endregion
 }

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

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

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

@@ -1,234 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.data.repository
-
-import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
-import com.rtbishop.look4sat.core.domain.model.DatabaseState
-import com.rtbishop.look4sat.core.domain.model.OtherSettings
-import com.rtbishop.look4sat.core.domain.model.PassesSettings
-import com.rtbishop.look4sat.core.domain.model.RCSettings
-import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
-import com.rtbishop.look4sat.core.domain.model.SatItem
-import com.rtbishop.look4sat.core.domain.model.SatRadio
-import com.rtbishop.look4sat.core.domain.predict.GeoPos
-import com.rtbishop.look4sat.core.domain.predict.OrbitalData
-import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
-import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.core.domain.source.ILocalSource
-import com.rtbishop.look4sat.core.domain.source.IRemoteSource
-import com.rtbishop.look4sat.core.domain.utility.DataParser
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.test.StandardTestDispatcher
-import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import java.io.InputStream
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class DatabaseRepoTest {
-
-    private val dispatcher = StandardTestDispatcher()
-    private val dataParser = DataParser(dispatcher)
-
-    @Test
-    fun `manual satellite import parses csv stream from content uri`() = runTest(dispatcher) {
-        val uri = "content://look4sat/import/satellites"
-        val localSource = FakeLocalSource()
-        val remoteSource = FakeRemoteSource().apply {
-            fileStreams[uri] = { validCsvStream() }
-        }
-        val settingsRepo = FakeSettingsRepo()
-        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
-
-        repository.updateTLEFromFile(uri)
-
-        assertEquals(1, localSource.insertedEntries.size)
-        assertEquals(25544, localSource.insertedEntries.first().catnum)
-        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(
-                useCustomTLE = true,
-                useCustomTransceivers = false,
-                tleUrl = customCsvUrl,
-                transceiversUrl = ""
-            )
-        )
-        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
-
-        repository.updateFromRemote()
-
-        assertTrue(localSource.insertedEntries.any { it.catnum == 25544 })
-        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
-    }
-
-    private fun validCsvStream(): InputStream = """
-        OBJECT_NAME,OBJECT_ID,EPOCH,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY,EPHEMERIS_TYPE,CLASSIFICATION_TYPE,NORAD_CAT_ID,ELEMENT_SET_NO,REV_AT_EPOCH,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION_DDOT
-        ISS (ZARYA),1998-067A,2021-11-16T12:28:09.322176,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
-    """.trimIndent().byteInputStream()
-
-    private fun validTleStream(): InputStream = """
-        ISS (ZARYA)
-        1 25544U 98067A   21320.51955234  .00001288  00000+0  31985-4 0  9990
-        2 25544  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
-    """.trimIndent().byteInputStream()
-}
-
-private class FakeRemoteSource : IRemoteSource {
-    val fileStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
-    val networkStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
-
-    override suspend fun getFileStream(uri: String): InputStream? = fileStreams[uri]?.invoke()
-
-    override suspend fun getNetworkStream(url: String): InputStream? = networkStreams[url]?.invoke()
-}
-
-private class FakeLocalSource : ILocalSource {
-    val insertedEntries = mutableListOf<OrbitalData>()
-    private val insertedRadios = mutableListOf<SatRadio>()
-
-    override suspend fun getEntriesTotal(): Int = insertedEntries.size
-
-    override suspend fun getEntriesList(): List<SatItem> = emptyList()
-
-    override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
-
-    override suspend fun insertEntries(entries: List<OrbitalData>) {
-        insertedEntries += entries
-    }
-
-    override suspend fun deleteEntries() {
-        insertedEntries.clear()
-    }
-
-    override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
-
-    override suspend fun getRadiosTotal(): Int = insertedRadios.size
-
-    override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()
-
-    override suspend fun insertRadios(radios: List<SatRadio>) {
-        insertedRadios += radios
-    }
-
-    override suspend fun deleteRadios() {
-        insertedRadios.clear()
-    }
-}
-
-private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSourcesSettings()) : ISettingsRepo {
-
-    override val appVersionName: String = "test"
-
-    override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
-
-    override val 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, "", "", "", 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
-}
-
-private fun defaultDataSourcesSettings(): DataSourcesSettings {
-    return DataSourcesSettings(
-        useCustomTLE = false,
-        useCustomTransceivers = false,
-        tleUrl = "",
-        transceiversUrl = ""
-    )
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwBayesianDecoder.kt

@@ -1,154 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Bayesian Morse timing decoder.
- * Replaces hard thresholds with probability-based decision making.
- *
- * Inspired by VE3NEA's CW Skimmer approach:
- * "Instead of making a hard decision at every input sample whether the signal
- * is present or not, compute the probability that the signal is present."
- *
- * Uses Gaussian probability density centered on expected durations:
- *   P(dit | duration) = exp(-(duration - dotMs)^2 / (2 * variance^2))
- *   P(dash | duration) = exp(-(duration - 3*dotMs)^2 / (2 * variance^2))
- */
-internal class CwBayesianDecoder {
-
-    // Morse timing parameters
-    private var dotDurationMs = 60f // initial 20 WPM
-    private var speedWpm = 20f
-
-    // Current symbol being accumulated
-    private var currentSymbol = StringBuilder()
-    private var textBuffer = StringBuilder()
-
-    // Recent dit lengths for speed estimation
-    private val recentDits = mutableListOf<Float>()
-
-    // Output
-    private var _decodedText = ""
-    val decodedText: String get() = _decodedText
-
-    /** Gaussian probability. */
-    private fun gaussianProb(durationMs: Float, expectedMs: Float, varianceMs: Float): Float {
-        if (varianceMs <= 0f) return 0f
-        val diff = durationMs - expectedMs
-        return kotlin.math.exp(-(diff * diff) / (2 * varianceMs * varianceMs))
-    }
-
-    /** Process a tone duration. Returns the symbol type with highest probability. */
-    fun processTone(durationMs: Float): ToneResult {
-        val ditProb = gaussianProb(durationMs, dotDurationMs, dotDurationMs * 0.4f)
-        val dashProb = gaussianProb(durationMs, dotDurationMs * 3f, dotDurationMs * 0.6f)
-
-        return if (ditProb > dashProb && ditProb > 0.05f) {
-            currentSymbol.append('0')
-            recentDits.add(durationMs)
-            updateSpeed()
-            ToneResult('0', ditProb)
-        } else if (dashProb > 0.05f) {
-            currentSymbol.append('1')
-            ToneResult('1', dashProb)
-        } else {
-            ToneResult(null, 0f)
-        }
-    }
-
-    /** Process a gap duration. Returns decoded character or null. */
-    fun processGap(durationMs: Float): Char? {
-        if (currentSymbol.isEmpty()) {
-            val wordProb = gaussianProb(durationMs, dotDurationMs * 7f, dotDurationMs * 1.2f)
-            if (wordProb > 0.2f) {
-                textBuffer.append(' ')
-                _decodedText = textBuffer.toString()
-                return ' '
-            }
-            return null
-        }
-
-        val interCharProb = gaussianProb(durationMs, dotDurationMs * 3f, dotDurationMs * 0.6f)
-        val wordProb = gaussianProb(durationMs, dotDurationMs * 7f, dotDurationMs * 1.2f)
-
-        if (wordProb > interCharProb && wordProb > 0.2f) {
-            val char = flushSymbol()
-            textBuffer.append(' ')
-            _decodedText = textBuffer.toString()
-            return char
-        }
-        if (interCharProb > 0.15f) {
-            val char = flushSymbol()
-            _decodedText = textBuffer.toString()
-            return char
-        }
-        return null
-    }
-
-    private fun flushSymbol(): Char? {
-        if (currentSymbol.isEmpty()) return null
-        val morse = currentSymbol.toString()
-        currentSymbol.clear()
-        val char = morseToChar(morse)
-        if (char != null) textBuffer.append(char)
-        return char
-    }
-
-    private fun updateSpeed() {
-        if (recentDits.size < 3) return
-        val sorted = recentDits.sorted()
-        val median = sorted[sorted.size / 2]
-        if (median > 0f) {
-            dotDurationMs = dotDurationMs * 0.7f + median * 0.3f
-            val wpm = 60.0f / (50.0f * dotDurationMs / 1000.0f)
-            if (wpm in 5f..55f) speedWpm = wpm
-        }
-    }
-
-    fun getSpeed(): Float = speedWpm
-
-    fun reset() {
-        dotDurationMs = 60f
-        speedWpm = 20f
-        recentDits.clear()
-        currentSymbol.clear()
-        textBuffer.clear()
-        _decodedText = ""
-    }
-
-    companion object {
-        private val MORSE_TABLE = mapOf(
-            "01" to 'A', "1000" to 'B', "1010" to 'C', "100" to 'D', "0" to 'E',
-            "0010" to 'F', "110" to 'G', "0000" to 'H', "00" to 'I', "0111" to 'J',
-            "101" to 'K', "0100" to 'L', "11" to 'M', "10" to 'N', "111" to 'O',
-            "0110" to 'P', "1101" to 'Q', "010" to 'R', "000" to 'S', "1" to 'T',
-            "001" to 'U', "0001" to 'V', "011" to 'W', "1001" to 'X', "1011" to 'Y',
-            "1100" to 'Z', "01111" to '1', "00111" to '2', "00011" to '3',
-            "00001" to '4', "00000" to '5', "10000" to '6', "11000" to '7',
-            "11100" to '8', "11110" to '9', "11111" to '0',
-            "010101" to '.', "110011" to ',', "001100" to '?', "011110" to '\'',
-            "101011" to '!', "10010" to '/', "10110" to '(', "101101" to ')',
-            "01000" to '&', "111000" to ':', "101010" to ';', "10001" to '=',
-            "01010" to '+', "100001" to '-', "001101" to '_', "010010" to '"',
-            "0001001" to '$', "011010" to '@'
-        )
-        fun morseToChar(morse: String): Char? = MORSE_TABLE[morse]
-    }
-}
-
-data class ToneResult(val symbol: Char?, val probability: Float)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwChannelTracker.kt

@@ -1,114 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Multi-channel CW signal tracker.
- * Monitors the spectrogram for active frequency bins and extracts
- * energy envelopes for each detected signal.
- *
- * Inspired by CW Skimmer's multi-channel approach:
- * tracks all active signals in the passband simultaneously,
- * selects the best one for decoded output.
- */
-internal class CwChannelTracker(
-    private val spectrogram: CwSpectrogram,
-    private val maxChannels: Int = 3
-) {
-    data class Channel(
-        val bin: Int,
-        val frequency: Float,
-        var active: Boolean = false,
-        var energy: Float = 0f,
-        val history: MutableList<Float> = mutableListOf(),
-        var confidence: Float = 0f
-    )
-
-    private val channels = Array(maxChannels) { Channel(0, 0f) }
-
-    /** Scan the current spectrogram column and update channel tracking. */
-    fun update(): List<Channel> {
-        val col = spectrogram.getCurrentColumn()
-        val peaks = findPeaks(col, threshold = 0.3f, minDistance = 2)
-
-        // Update existing channels
-        for (ch in channels) {
-            if (ch.active) {
-                if (peaks.contains(ch.bin)) {
-                    ch.energy = col[ch.bin]
-                    ch.history.add(ch.energy)
-                    if (ch.history.size > 40) ch.history.removeAt(0)
-                    ch.confidence = computeConfidence(ch.history)
-                } else {
-                    // Signal lost — decay confidence
-                    ch.history.add(0f)
-                    if (ch.history.size > 40) ch.history.removeAt(0)
-                    ch.confidence *= 0.9f
-                    if (ch.confidence < 0.1f) ch.active = false
-                }
-            }
-        }
-
-        // Assign new peaks to inactive channels
-        var peakIdx = 0
-        for (ch in channels) {
-            if (!ch.active && peakIdx < peaks.size) {
-                val bin = peaks[peakIdx]
-                val freq = spectrogram.binToFreq(bin)
-                // Re-initialize channel
-                channels[peakIdx] = Channel(bin, freq, true, col[bin], mutableListOf(), 0.5f)
-                peakIdx++
-            }
-        }
-
-        return channels.filter { it.active }
-    }
-
-    /** Find peak bins in the spectrum. */
-    private fun findPeaks(spectrum: FloatArray, threshold: Float, minDistance: Int): List<Int> {
-        val peaks = mutableListOf<Int>()
-        for (i in 1 until spectrum.size - 1) {
-            if (spectrum[i] > spectrum[i - 1] && spectrum[i] > spectrum[i + 1] && spectrum[i] > threshold) {
-                if (peaks.isEmpty() || i - peaks.last() >= minDistance) {
-                    peaks.add(i)
-                }
-            }
-        }
-        return peaks.sortedByDescending { spectrum[it] }
-    }
-
-    /** Compute confidence from energy history. Lower variance = higher confidence. */
-    private fun computeConfidence(history: List<Float>): Float {
-        if (history.size < 10) return 0.3f
-        val recent = history.takeLast(10)
-        val mean = recent.average().toFloat()
-        val variance = recent.map { (it - mean) * (it - mean) }.average().toFloat()
-        return if (mean > 0f) (mean / (mean + variance + 0.1f)).coerceIn(0f, 1f) else 0f
-    }
-
-    /** Get the channel with highest confidence. */
-    fun getBestChannel(): Channel? {
-        return channels.filter { it.active }.maxByOrNull { it.confidence }
-    }
-
-    fun reset() {
-        for (i in channels.indices) {
-            channels[i] = Channel(0, 0f)
-        }
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDecoder.kt

@@ -1,165 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-
-/**
- * CW (Morse code) decoder v3 — Spectrogram-based multi-channel Bayesian decoder.
- *
- * Architecture inspired by Morse Expert / CW Skimmer (VE3NEA):
- *   1. FFT spectrogram creates a frequency×time matrix
- *   2. Multi-channel peak detector finds all active signals
- *   3. Per-channel energy envelope extraction
- *   4. Bayesian probability for symbol timing (Gaussian likelihood)
- *   5. Best channel selected for output
- *
- * Timing analysis is performed per spectrogram column (hop).
- * Each column represents hopSize/sampleRate seconds of audio.
- */
-class CwDecoder(
-    val sampleRate: Int = 8000,
-    cwToneFreq: Float = -1f // ignored in v3 (auto-detect via spectrogram)
-) {
-    companion object {
-        private const val FFT_SIZE = 256
-        private const val HOP_SIZE = 64
-    }
-
-    private val spectrogram = CwSpectrogram(
-        fftSize = FFT_SIZE,
-        hopSize = HOP_SIZE,
-        sampleRate = sampleRate,
-        minBin = 6,
-        maxBin = 38,
-        historyCols = 40
-    )
-    private val channelTracker = CwChannelTracker(spectrogram, maxChannels = 3)
-    private val bayesianDecoder = CwBayesianDecoder()
-
-    // Timing state per channel
-    private data class ChannelTiming(
-        var isSignal: Boolean = false,
-        var toneTicks: Int = 0,
-        var gapTicks: Int = 0
-    )
-    private val timingStates = Array(3) { ChannelTiming() }
-
-    // Time per spectrogram column in milliseconds
-    private val tickMs = 1000f * HOP_SIZE / sampleRate
-
-    // Output flows
-    private val _decodedTextFlow = MutableStateFlow("")
-    val decodedTextFlow: StateFlow<String> = _decodedTextFlow
-
-    private val _signalStrength = MutableStateFlow(0f)
-    val signalStrength: StateFlow<Float> = _signalStrength
-
-    private val _estimatedPitch = MutableStateFlow<Float?>(null)
-    val estimatedPitch: StateFlow<Float?> = _estimatedPitch
-
-    private val _estimatedSpeed = MutableStateFlow<Float?>(null)
-    val estimatedSpeed: StateFlow<Float?> = _estimatedSpeed
-
-    private var frameCount = 0
-
-    init {
-        if (cwToneFreq > 0f) {
-            _estimatedPitch.value = cwToneFreq
-        }
-    }
-
-    fun processBuffer(buffer: FloatArray) {
-        // 1. Feed samples to spectrogram
-        spectrogram.addSamples(buffer)
-
-        // 2. Get number of new columns generated
-        val newCols = spectrogram.getNewColumns()
-        if (newCols == 0) return
-
-        // 3. Update channel tracker (uses latest column for peak detection)
-        val activeChannels = channelTracker.update()
-
-        // 4. Process each new column for timing analysis
-        //    Columns are indexed 0..historyCols-1, where historyCols-1 is the newest
-        val baseIdx = (spectrogram.historyCols - newCols).coerceAtLeast(0)
-        for (colOffset in 0 until newCols) {
-            val col = spectrogram.getColumn(baseIdx + colOffset)
-
-            for ((idx, channel) in activeChannels.withIndex()) {
-                if (idx >= timingStates.size) break
-                val state = timingStates[idx]
-                val energy = if (channel.bin in col.indices) col[channel.bin] else 0f
-
-                // Adaptive threshold
-                val threshold = 0.3f + (energy - 0.3f) * 0.3f
-
-                if (energy > threshold) {
-                    if (!state.isSignal) {
-                        if (state.gapTicks > 0) {
-                            val gapMs = state.gapTicks * tickMs
-                            bayesianDecoder.processGap(gapMs)
-                        }
-                        state.gapTicks = 0
-                        state.isSignal = true
-                    }
-                    state.toneTicks++
-                } else {
-                    if (state.isSignal) {
-                        if (state.toneTicks > 0) {
-                            val toneMs = state.toneTicks * tickMs
-                            bayesianDecoder.processTone(toneMs)
-                        }
-                        state.toneTicks = 0
-                        state.isSignal = false
-                    }
-                    state.gapTicks++
-                }
-            }
-        }
-
-        // 5. Update outputs
-        frameCount++
-        if (frameCount % 5 == 0) {
-            val bestChannel = channelTracker.getBestChannel()
-            if (bestChannel != null) {
-                _estimatedPitch.value = bestChannel.frequency
-                _signalStrength.value = bestChannel.confidence
-                _estimatedSpeed.value = bayesianDecoder.getSpeed()
-            }
-            _decodedTextFlow.value = bayesianDecoder.decodedText
-        }
-    }
-
-    fun resetDecoder() {
-        spectrogram.reset()
-        channelTracker.reset()
-        bayesianDecoder.reset()
-        for (state in timingStates) {
-            state.isSignal = false
-            state.toneTicks = 0
-            state.gapTicks = 0
-        }
-        frameCount = 0
-        _decodedTextFlow.value = ""
-        _signalStrength.value = 0f
-        _estimatedPitch.value = null
-        _estimatedSpeed.value = null
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDsp.kt

@@ -1,102 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.PI
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-/**
- * DSP utilities for CW (Morse code) decoding.
- * Pure Kotlin, no NDK required.
- */
-internal object CwDsp {
-
-    /**
-     * Design a simple bandpass FIR filter coefficients using windowed sinc method.
-     * @param lowCutoff  lower cutoff frequency (Hz) as fraction of sampleRate
-     * @param highCutoff upper cutoff frequency (Hz) as fraction of sampleRate
-     * @param taps       filter length (must be odd)
-     */
-    fun bandpassFir(lowCutoff: Double, highCutoff: Double, taps: Int): FloatArray {
-        val n = if (taps % 2 == 0) taps + 1 else taps
-        val half = n / 2
-        val coeffs = FloatArray(n)
-        for (i in 0 until n) {
-            val idx = i - half
-            if (idx == 0) {
-                coeffs[i] = (2.0 * (highCutoff - lowCutoff)).toFloat()
-            } else {
-                val x = PI * idx
-                coeffs[i] = ((sin(2 * highCutoff * x) - sin(2 * lowCutoff * x)) / x).toFloat()
-            }
-            // Hamming window
-            coeffs[i] = (coeffs[i] * (0.54 - 0.46 * cos(2 * PI * i / (n - 1)))).toFloat()
-        }
-        // Normalize
-        val sum = coeffs.sum()
-        if (sum != 0f) for (i in 0 until n) coeffs[i] /= sum
-        return coeffs
-    }
-
-    /** Apply FIR filter to a buffer. */
-    fun applyFir(buffer: FloatArray, coeffs: FloatArray): FloatArray {
-        val out = FloatArray(buffer.size)
-        for (i in buffer.indices) {
-            var sum = 0f
-            for (j in coeffs.indices) {
-                val idx = i - j
-                if (idx >= 0) sum += buffer[idx] * coeffs[j]
-            }
-            out[i] = sum
-        }
-        return out
-    }
-
-    /** Simple envelope detector: abs + low-pass smoothing. */
-    fun envelope(signal: FloatArray, alpha: Float = 0.1f): FloatArray {
-        val env = FloatArray(signal.size)
-        var s = 0f
-        for (i in signal.indices) {
-            s = alpha * kotlin.math.abs(signal[i]) + (1 - alpha) * s
-            env[i] = s
-        }
-        return env
-    }
-
-    /** Estimate noise floor from envelope for adaptive thresholding. */
-    fun noiseFloor(env: FloatArray, fraction: Float = 0.3f): Float {
-        val sorted = env.sortedArray()
-        val median = sorted[sorted.size / 2]
-        return median + (sorted[sorted.size * 9 / 10] - median) * fraction
-    }
-
-    /** Simple Goertzel to detect a specific tone frequency. */
-    fun goertzel(buffer: FloatArray, targetFreq: Float, sampleRate: Int): Float {
-        val omega = 2.0 * PI * targetFreq / sampleRate
-        val coeff = 2.0 * cos(omega)
-        var s0 = 0.0; var s1 = 0.0; var s2 = 0.0
-        for (sample in buffer) {
-            s0 = sample.toDouble() + coeff * s1 - s2
-            s2 = s1; s1 = s0
-        }
-        val power = s2 * s2 + s1 * s1 - coeff * s1 * s2
-        return sqrt(kotlin.math.abs(power)).toFloat()
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwFFT.kt

@@ -1,87 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.cos
-import kotlin.math.sqrt
-
-/**
- * Radix-2 FFT for real-valued input.
- * Produces magnitude spectrum for the first N/2+1 bins.
- * Used by CwSpectrogram for time-frequency analysis.
- */
-internal class CwFFT(private val n: Int) {
-    init {
-        require(n > 0 && n and (n - 1) == 0) { "FFT size must be power of 2, got $n" }
-    }
-
-    private val cosTable = FloatArray(n / 2)
-    private val sinTable = FloatArray(n / 2)
-
-    init {
-        for (i in 0 until n / 2) {
-            val angle = -2.0 * kotlin.math.PI * i / n
-            cosTable[i] = cos(angle).toFloat()
-            sinTable[i] = kotlin.math.sin(angle).toFloat()
-        }
-    }
-
-    /** Compute magnitude spectrum for real input. Returns array of size n/2+1. */
-    fun magnitudeSpectrum(input: FloatArray): FloatArray {
-        require(input.size == n) { "Input size must be $n, got ${input.size}" }
-
-        val real = input.copyOf()
-        val imag = FloatArray(n)
-
-        // Bit-reversal permutation
-        var j = 0
-        for (i in 1 until n) {
-            var bit = n shr 1
-            while (j and bit != 0) { j = j xor bit; bit = bit shr 1 }
-            j = j xor bit
-            if (i < j) {
-                var tmp = real[i]; real[i] = real[j]; real[j] = tmp
-            }
-        }
-
-        // Radix-2 Cooley-Tukey FFT
-        var len = 2
-        while (len <= n) {
-            val half = len / 2
-            val step = n / len
-            for (i in 0 until n step len) {
-                for (k in 0 until half) {
-                    val tReal = real[i + k + half] * cosTable[k * step] - imag[i + k + half] * sinTable[k * step]
-                    val tImag = real[i + k + half] * sinTable[k * step] + imag[i + k + half] * cosTable[k * step]
-                    real[i + k + half] = real[i + k] - tReal
-                    imag[i + k + half] = imag[i + k] - tImag
-                    real[i + k] += tReal
-                    imag[i + k] += tImag
-                }
-            }
-            len = len shl 1
-        }
-
-        // Magnitude spectrum (first N/2+1 bins)
-        val mag = FloatArray(n / 2 + 1)
-        for (i in 0..n / 2) {
-            mag[i] = sqrt(real[i] * real[i] + imag[i] * imag[i]) / n
-        }
-        return mag
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwFilter.kt

@@ -1,48 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * First-order IIR filters.
- * Ported from ggmorse/src/filter.h
- */
-internal class CwFilter {
-    private var z1 = 0f
-
-    companion object {
-        private const val PI_F = 3.141592653589793f
-    }
-
-    fun highPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
-        val rc = 1.0f / (2f * PI_F * cutoffHz)
-        val dt = 1.0f / sampleRate
-        val alpha = dt / (rc + dt)
-        z1 = alpha * (z1 + sample - z1)
-        return sample - z1
-    }
-
-    fun lowPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
-        val rc = 1.0f / (2f * PI_F * cutoffHz)
-        val dt = 1.0f / sampleRate
-        val alpha = dt / (rc + dt)
-        z1 += alpha * (sample - z1)
-        return z1
-    }
-
-    fun reset() { z1 = 0f }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwGoertzel.kt

@@ -1,54 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.cos
-import kotlin.math.sqrt
-
-/**
- * Running Goertzel filter for CW tone detection.
- * Tracks a specific frequency over time with a sliding window.
- * Ported from ggmorse/src/goertzel.h
- */
-internal class CwGoertzel {
-    private var s1 = 0.0
-    private var s2 = 0.0
-    private var coeff = 0.0
-
-    fun init(sampleRate: Float, targetFreq: Float) {
-        val omega = 2.0 * kotlin.math.PI * targetFreq / sampleRate
-        coeff = 2.0 * cos(omega)
-        s1 = 0.0
-        s2 = 0.0
-    }
-
-    fun process(sample: Float) {
-        val s0 = sample.toDouble() + coeff * s1 - s2
-        s2 = s1
-        s1 = s0
-    }
-
-    fun getPower(): Float {
-        return sqrt(s2 * s2 + s1 * s1 - coeff * s1 * s2).toFloat()
-    }
-
-    fun reset() {
-        s1 = 0.0
-        s2 = 0.0
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwResampler.kt

@@ -1,53 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Simple linear resampler.
- * Downsamples from input sample rate to output sample rate.
- * Ported from ggmorse/src/resampler.h
- */
-internal class CwResampler(private val inputRate: Float, private val outputRate: Float) {
-    private val ratio = inputRate / outputRate
-    private var lastSample = 0f
-
-    fun process(input: FloatArray): FloatArray {
-        if (ratio <= 0f || input.isEmpty()) return input
-        val outputLen = (input.size / ratio).toInt() + 1
-        val output = FloatArray(outputLen)
-        var idx = 0f
-        for (i in output.indices) {
-            val intIdx = idx.toInt()
-            val frac = idx - intIdx
-            if (intIdx + 1 < input.size) {
-                output[i] = input[intIdx] * (1 - frac) + input[intIdx + 1] * frac
-            } else if (intIdx < input.size) {
-                output[i] = input[intIdx] * (1 - frac) + lastSample * frac
-            } else {
-                output[i] = lastSample
-            }
-            idx += ratio
-        }
-        lastSample = input.lastOrNull() ?: lastSample
-        return output
-    }
-
-    fun reset() {
-        lastSample = 0f
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwSTFFT.kt

@@ -1,61 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-/**
- * Lightweight pitch detector using DFT at specific frequency bins.
- * Only scans [200, 1200] Hz in configurable steps — much faster than full FFT.
- * Ported from ggmorse/src/stfft.h (simplified for CW use case).
- */
-internal class CwPitchDetector(
-    private val sampleRate: Float,
-    private val minFreq: Float = 200f,
-    private val maxFreq: Float = 1200f,
-    private val stepHz: Float = 10f
-) {
-    /**
-     * Find the dominant pitch frequency in the buffer.
-     * Returns null if no significant pitch found.
-     */
-    fun findPitch(buffer: FloatArray): Float? {
-        if (buffer.isEmpty()) return null
-        var bestFreq = 0f
-        var bestPower = 0f
-        var freq = minFreq
-        while (freq <= maxFreq) {
-            var real = 0.0
-            var imag = 0.0
-            val omega = 2.0 * kotlin.math.PI * freq / sampleRate
-            for (i in buffer.indices) {
-                real += buffer[i] * cos(omega * i)
-                imag += buffer[i] * -sin(omega * i)
-            }
-            val power = (real * real + imag * imag).toFloat()
-            if (power > bestPower) {
-                bestPower = power
-                bestFreq = freq
-            }
-            freq += stepHz
-        }
-        return if (bestPower > 0.001f) bestFreq else null
-    }
-}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwSpectrogram.kt

@@ -1,170 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Sliding-window spectrogram for CW decoding.
- * Maintains a time-frequency matrix updated with each audio frame.
- *
- * FFT size: 256, hop size: 64, sample rate: 4000 (or native)
- * Frequency bins: 6..38 (187-1187 Hz, covers typical CW range)
- * History: 40 columns (320 ms window)
- * Time resolution: 64/4000 = 16 ms, Frequency resolution: 4000/256 = 15.625 Hz
- */
-internal class CwSpectrogram(
-    private val fftSize: Int = 256,
-    private val hopSize: Int = 64,
-    private val sampleRate: Int = 4000,
-    private val minBin: Int = 6,
-    private val maxBin: Int = 38,
-    val historyCols: Int = 40
-) {
-    private val fft = CwFFT(fftSize)
-    val numBins: Int get() = maxBin - minBin + 1
-
-    // Hanning window
-    private val hanning = FloatArray(fftSize) {
-        (0.5 - 0.5 * kotlin.math.cos(2.0 * kotlin.math.PI * it / (fftSize - 1))).toFloat()
-    }
-
-    // Spectrogram data: [timeCol][freqBin]
-    private val spectrogram = Array(historyCols) { FloatArray(numBins) }
-    private var currentCol = 0
-    private var samplesBuffered = 0
-    private val buffer = FloatArray(fftSize)
-
-    // Per-bin running energy for normalization
-    private val binEnergy = FloatArray(numBins) { 1f }
-    private val alpha = 0.95f
-
-    // Counter for new columns generated since last check
-    private var newColumnCount = 0
-
-    /** Add audio samples, compute FFTs for each complete hop. */
-    fun addSamples(samples: FloatArray) {
-        var offset = 0
-        while (offset < samples.size) {
-            val needed = fftSize - samplesBuffered
-            val copyLen = minOf(needed, samples.size - offset)
-            System.arraycopy(samples, offset, buffer, samplesBuffered, copyLen)
-            samplesBuffered += copyLen
-            offset += copyLen
-
-            if (samplesBuffered >= fftSize) {
-                processFrame()
-                newColumnCount++
-                // Shift buffer: keep last (fftSize - hopSize) samples
-                System.arraycopy(buffer, hopSize, buffer, 0, fftSize - hopSize)
-                samplesBuffered = fftSize - hopSize
-            }
-        }
-    }
-
-    /** Get number of new columns generated since the last call to this method. */
-    fun getNewColumns(): Int {
-        val count = newColumnCount
-        newColumnCount = 0
-        return count
-    }
-
-    private fun processFrame() {
-        // Apply Hanning window
-        val windowed = FloatArray(fftSize) { buffer[it] * hanning[it] }
-
-        // Compute FFT magnitude spectrum
-        val mag = fft.magnitudeSpectrum(windowed)
-
-        // Update spectrogram column
-        val col = spectrogram[currentCol]
-        for (b in 0 until numBins) {
-            val binIdx = minBin + b
-            val rawMag = mag[binIdx]
-            // Running energy normalization
-            binEnergy[b] = alpha * binEnergy[b] + (1 - alpha) * rawMag
-            col[b] = if (binEnergy[b] > 1e-6f) rawMag / binEnergy[b] else 0f
-        }
-
-        currentCol = (currentCol + 1) % historyCols
-    }
-
-    /** Get the current spectrogram as a 2D array in chronological order. */
-    fun getSpectrogram(): Array<FloatArray> {
-        val result = Array(historyCols) { i ->
-            val srcIdx = (currentCol + i) % historyCols
-            spectrogram[srcIdx].copyOf()
-        }
-        return result
-    }
-
-    /** Get the most recent column (current energy across all frequencies). */
-    fun getCurrentColumn(): FloatArray {
-        val prevCol = (currentCol - 1 + historyCols) % historyCols
-        return spectrogram[prevCol].copyOf()
-    }
-
-    /** Get a column by index from the history (0 = oldest, historyCols-1 = newest). */
-    fun getColumn(index: Int): FloatArray {
-        val clamped = index.coerceIn(0, historyCols - 1)
-        val srcIdx = (currentCol - historyCols + clamped + historyCols) % historyCols
-        return spectrogram[srcIdx].copyOf()
-    }
-
-    /** Find the frequency bin with peak energy. Returns -1 if no significant signal. */
-    fun findPeakBin(): Int {
-        val col = getCurrentColumn()
-        var maxBin = -1
-        var maxVal = 0f
-        for (i in col.indices) {
-            if (col[i] > maxVal) {
-                maxVal = col[i]
-                maxBin = i
-            }
-        }
-        return if (maxVal > 0.3f) maxBin else -1
-    }
-
-    /** Get energy at a specific bin over the last N columns in chronological order. */
-    fun getBinEnergy(bin: Int, numCols: Int): FloatArray {
-        val clamped = minOf(numCols, historyCols)
-        val result = FloatArray(clamped)
-        for (i in 0 until clamped) {
-            val colIdx = (currentCol - clamped + i + historyCols) % historyCols
-            result[i] = spectrogram[colIdx][bin]
-        }
-        return result
-    }
-
-    /** Get the bin index for a frequency in Hz. */
-    fun freqToBin(freqHz: Float): Int {
-        val bin = (freqHz * fftSize / sampleRate).toInt()
-        return (bin - minBin).coerceIn(0, numBins - 1)
-    }
-
-    /** Get the center frequency for a bin. */
-    fun binToFreq(bin: Int): Float {
-        return (minBin + bin).toFloat() * sampleRate / fftSize
-    }
-
-    fun reset() {
-        for (col in spectrogram) col.fill(0f)
-        currentCol = 0
-        samplesBuffered = 0
-        buffer.fill(0f)
-        binEnergy.fill(1f)
-    }
-}

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

@@ -27,9 +27,6 @@ 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>
 )
 
@@ -61,10 +58,23 @@ data class OtherSettings(
     val shouldSeeWarning: Boolean,
     val shouldSeeWhatsNew: Boolean,
     val sstvMode: String = "Auto",
-    val lowElevation: Double = 15.0,
-    val highElevation: Double = 45.0
+    val mapSource: String = MapSource.TIANDITU_VECTOR,
+    val tiandituKey: String = ""
 )
 
+object MapSource {
+    const val OSM = "osm"
+    const val TIANDITU = "tianditu"
+    const val TIANDITU_VECTOR = "tianditu_vector"
+    const val TIANDITU_IMAGE = "tianditu_image"
+
+    fun normalize(source: String): String = when (source) {
+        TIANDITU -> TIANDITU_VECTOR
+        OSM, TIANDITU_VECTOR, TIANDITU_IMAGE -> source
+        else -> TIANDITU_VECTOR
+    }
+}
+
 data class DataSourcesSettings(
     val useCustomTLE: Boolean,
     val useCustomTransceivers: Boolean,
@@ -79,20 +89,12 @@ data class RadioControlSettings(
     val rxRadioAddress: String,
     val txRadioName: String,
     val rxRadioName: String,
-    val baudRate: Int,
-    /** IC-705 only: use single-radio split-VFO mode instead of two radios. */
-    val splitMode: Boolean = false
+    val baudRate: Int
 ) {
     companion object {
-        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)
+        val SUPPORTED_RADIOS = listOf(
+            "Yaesu FT-817/818",
+            "Yaesu FT-857/897"
+        )
     }
 }

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): Int
-    suspend fun updateTransceiversFromFile(uri: String): Int
+    suspend fun updateTLEFromFile(uri: String)
+    suspend fun updateTransceiversFromFile(uri: String)
     suspend fun updateFromRemote()
     suspend fun clearAllData()
 }

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

@@ -16,13 +16,12 @@
  * 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
@@ -31,8 +30,6 @@ interface IMainContainer {
     val satelliteRepo: ISatelliteRepo
     val databaseRepo: IDatabaseRepo
     val radioTrackingService: IRadioTrackingService
-    val mutualPassData: StateFlow<MutualPassData>
-    fun setMutualPassData(data: MutualPassData)
     fun provideAddToCalendar(): IAddToCalendar
     fun provideShowToast(): IShowToast
     fun provideBluetoothReporter(): IReporter
@@ -44,25 +41,6 @@ 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,51 +38,4 @@ 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,15 +44,7 @@ interface ISatelliteRepo {
     suspend fun initRepository()
 
     /** Recalculate passes with the given filter parameters. */
-    suspend fun calculatePasses(
-        time: Long,
-        hoursAhead: Int,
-        minElevation: Double,
-        aosStartMinute: Int,
-        aosEndMinute: Int,
-        invertAosTimeWindow: Boolean,
-        modes: List<String>
-    )
+    suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>)
 
     /** Get the current position of a single satellite. */
     suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos

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

@@ -20,94 +20,39 @@ package com.rtbishop.look4sat.core.domain.sstv
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.withContext
-import kotlin.math.PI
 import kotlin.math.abs
 import kotlin.math.round
 import kotlin.math.sqrt
 
 class SstvFrame(
-    val scopePixels: IntArray?,
-    val scopeWidth: Int,
-    val scopeHeight: Int,
     val imagePixels: IntArray?,
     val imageWidth: Int,
     val imageHeight: Int,
-    val modeName: String,
-    val imageComplete: Boolean,
-    val inputRms: Float,
-    val appliedGain: Float,
-    val syncHitRate: Float,
-    val predictedLineBursts: Int,
-    val maxPredictedStreak: Int,
-    val timingErrorSamples: Int
-)
-
-/**
- * Decoder quality metrics for diagnostics and logging. Useful for profiling decode
- * performance on noisy recordings.
- */
-data class SstvQualityMetrics(
-    val syncHitRate: Float,
-    val predictedLineBursts: Int,
-    val maxPredictedStreak: Int,
-    val timingErrorSamples: Int
-)
-
-enum class LineRecoveryStrategy {
-    Look4SatLimited,
-    Robot36Compatible
-}
-
-class SstvDiagnosticsHandle internal constructor(
-    val enabled: Boolean,
-    val metrics: StateFlow<SstvQualityMetrics?>
+    val modeName: String
 )
 
 class SstvDecoder(
     sampleRate: Int = 44100,
     scopeWidth: Int = 320,
     scopeHeight: Int = 256,
-    private val channelSelect: Int = 0,
-    targetRmsLevel: Float = 0.25f,
-    private val includeScopeData: Boolean = false,
-    private val enableRmsNormalization: Boolean = true,
-    preFilterCutoffHz: Double = 500.0,
-    enablePreFilter: Boolean = true,
-    private val enableDiagnosticsHandle: Boolean = false,
-    lineRecoveryStrategy: LineRecoveryStrategy = LineRecoveryStrategy.Look4SatLimited
+    private val channelSelect: Int = 0
 ) {
     private val scopeBuffer = PixelBuffer(scopeWidth, scopeHeight * 2)
     private val imageBuffer = PixelBuffer(scopeWidth, scopeHeight)
-    private val decoder = DecoderEngine(scopeBuffer, imageBuffer, "Raw", sampleRate, lineRecoveryStrategy)
+    private val decoder = DecoderEngine(scopeBuffer, imageBuffer, "Raw", sampleRate)
     private val _frames = MutableSharedFlow<SstvFrame>(
         replay = 1,
         onBufferOverflow = BufferOverflow.DROP_OLDEST
     )
-    private var lastInputRms = 0f
-    private var lastAppliedGain = 1f
-    private val _qualityMetrics = MutableStateFlow<SstvQualityMetrics?>(null)
-    private val preFilter = if (enablePreFilter) HighPassFilter(preFilterCutoffHz, sampleRate.toDouble()) else null
-    private val diagnosticsHandle = SstvDiagnosticsHandle(enableDiagnosticsHandle, _qualityMetrics)
     val frames: SharedFlow<SstvFrame> = _frames
     val supportedModes: List<String> = decoder.allModes.map { it.name }
 
     suspend fun feedSamples(samples: FloatArray) = withContext(Dispatchers.Default) {
-        // Optional pre-filtering: remove DC offset and subsonic noise that can mask
-        // weak signals and corrupt the RMS normalization baseline.
-        preFilter?.apply(samples)
-
-        // Optional RMS normalization: bring input to a consistent level so the
-        // FM demodulator operates in a predictable region. However, this amplifies
-        // noise proportionally. Aggressive RMS targets (e.g., 0.25) can hurt weak
-        // signals by boosting noise floor. Safer defaults: 0.35-0.50 for noisy inputs.
-        // Disable entirely for direct line-level inputs (e.g., receiver discriminator).
-        val gain = if (enableRmsNormalization) normalise(samples) else GainInfo(0f, 1f)
-        lastInputRms = gain.inputRms
-        lastAppliedGain = gain.appliedGain
+        // Normalize to a fixed RMS before processing so that both direct audio
+        // coupling and air-coupled microphone input decode with equal reliability.
+        normalise(samples)
         val hasNewLines = decoder.process(samples, channelSelect)
         if (hasNewLines) emitFrame()
     }
@@ -117,134 +62,36 @@ 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
-        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
-            )
-        )
+        _frames.tryEmit(SstvFrame(imagePixels, imageWidth, imageHeight, modeName))
     }
 
     // Target RMS level for the normalizer. 0.25 leaves headroom while keeping the
     // FM demodulator well above its noise floor regardless of input gain.
-    // 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
-    )
+    private val targetRms = 0.25f
 
     // Bring the buffer to a fixed RMS so that microphone and direct-coupled inputs
     // both decode reliably. The guard prevents amplifying pure silence into noise.
-    private fun normalise(buffer: FloatArray): GainInfo {
+    private fun normalise(buffer: FloatArray) {
         var sumSq = 0f
         for (s in buffer) sumSq += s * s
         val rms = sqrt(sumSq / buffer.size)
         if (rms > 1e-6f) {
             val gain = targetRms / rms
             for (i in buffer.indices) buffer[i] *= gain
-            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) {
@@ -350,8 +197,7 @@ internal class DecoderEngine(
     private val scopeBuffer: PixelBuffer,
     private val imageBuffer: PixelBuffer,
     rawName: String,
-    sampleRate: Int,
-    lineRecoveryStrategy: LineRecoveryStrategy
+    sampleRate: Int
 ) {
     private val pixelBuffer = PixelBuffer(800, 2)
     private val detector = SyncPulseDetector(sampleRate)
@@ -391,19 +237,6 @@ 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
@@ -453,11 +286,6 @@ 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) {
@@ -480,10 +308,20 @@ internal class DecoderEngine(
                 }
             }
         } else if (handleHeader()) {
-            predictedStreak = 0
             newLines = true
         } else if (sample > lastSync + (curLineSamples * 5) / 4) {
-            newLines = decodePredictedLine()
+            copyLines(
+                currentMode.decodeScanLine(
+                    pixelBuffer,
+                    scratch,
+                    scanLineBuffer,
+                    scopeBuffer.width,
+                    lastSync,
+                    curLineSamples,
+                    lastOffset
+                )
+            )
+            lastSync += curLineSamples; newLines = true
         }
         return newLines
     }
@@ -499,25 +337,6 @@ 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)
@@ -607,29 +426,6 @@ 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(
@@ -746,7 +542,6 @@ 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

@@ -1,98 +0,0 @@
-/* 
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- */
-package com.rtbishop.look4sat.core.domain.utility
-
-import com.rtbishop.look4sat.core.domain.model.SatRadio
-import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
-
-/**
- * Computes Doppler-corrected reciprocal frequencies for linear transponders.
- *
- * For a linear (passband) transponder, uplink and downlink frequencies are
- * related by a fixed passband offset. When the satellite moves, both are
- * Doppler-shifted. Given one, we compute the other:
- *
- *   downlink → uplink: mapDownlinkToUplink (passband) → getUplinkFreq (Doppler)
- *   uplink → downlink: mapUplinkToDownlink (passband) → getDownlinkFreq (Doppler)
- *
- * Addresses GitHub issue #91 (Custom frequency Doppler correction).
- */
-object DopplerFrequencyCalculator {
-
-    /**
-     * Given a downlink frequency, compute the Doppler-corrected uplink frequency.
-     * Returns null if the transponder is not a linear passband type.
-     */
-    fun computeUplinkFromDownlink(
-        downlinkHz: Long,
-        transponder: SatRadio,
-        orbitalPos: OrbitalPos
-    ): Long? {
-        if (!isLinearTransponder(transponder)) return null
-        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz, transponder) ?: return null
-        return orbitalPos.getUplinkFreq(baseUplink)
-    }
-
-    /**
-     * Given a downlink frequency, compute the Doppler-corrected uplink frequency
-     * with an offset applied to the downlink (in Hz).
-     * Returns null if the transponder is not a linear passband type.
-     */
-    fun computeUplinkFromDownlinkWithOffset(
-        downlinkHz: Long,
-        transponder: SatRadio,
-        orbitalPos: OrbitalPos,
-        offsetHz: Long
-    ): Long? {
-        if (!isLinearTransponder(transponder)) return null
-        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz + offsetHz, transponder) ?: return null
-        return orbitalPos.getUplinkFreq(baseUplink)
-    }
-
-    /**
-     * Given an uplink frequency, compute the Doppler-corrected downlink frequency.
-     * Returns null if the transponder is not a linear passband type.
-     */
-    fun computeDownlinkFromUplink(
-        uplinkHz: Long,
-        transponder: SatRadio,
-        orbitalPos: OrbitalPos
-    ): Long? {
-        if (!isLinearTransponder(transponder)) return null
-        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
-        return orbitalPos.getDownlinkFreq(baseDownlink)
-    }
-
-    /**
-     * Given an uplink frequency, compute the Doppler-corrected downlink frequency
-     * with an offset applied to the downlink (in Hz).
-     * Returns null if the transponder is not a linear passband type.
-     */
-    fun computeDownlinkFromUplinkWithOffset(
-        uplinkHz: Long,
-        transponder: SatRadio,
-        orbitalPos: OrbitalPos,
-        offsetHz: Long
-    ): Long? {
-        if (!isLinearTransponder(transponder)) return null
-        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
-        return orbitalPos.getDownlinkFreq(baseDownlink + offsetHz)
-    }
-
-    /** True if this transponder supports linear passband mapping. */
-    fun isLinearTransponder(transponder: SatRadio): Boolean {
-        val upLow = transponder.uplinkLow
-        val upHigh = transponder.uplinkHigh
-        val downLow = transponder.downlinkLow
-        val downHigh = transponder.downlinkHigh
-        return upLow != null && upHigh != null && downLow != null && downHigh != null
-                && upLow != upHigh && downLow != downHigh
-    }
-}

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

@@ -1,120 +0,0 @@
-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(
-        upLow: Long = 145_000_000L,
-        upHigh: Long = 145_500_000L,
-        downLow: Long = 435_000_000L,
-        downHigh: Long? = 435_500_000L,
-        inverted: Boolean = false
-    ) = SatRadio(
-        uuid = "linear", info = "Linear Transponder", isAlive = true,
-        downlinkLow = downLow, downlinkHigh = downHigh,
-        downlinkMode = "USB", uplinkLow = upLow, uplinkHigh = upHigh,
-        uplinkMode = "LSB", 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 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 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/domain/src/test/java/com/rtbishop/look4sat/core/domain/cw/CwDecoderTest.kt

@@ -1,301 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import org.junit.Assert.*
-import org.junit.Test
-import kotlin.math.PI
-import kotlin.math.sin
-
-class CwDecoderTest {
-
-    // --- Morse table ---
-
-    @Test
-    fun morseToChar_basicLetters() {
-        assertEquals('A', CwBayesianDecoder.morseToChar("01"))
-        assertEquals('S', CwBayesianDecoder.morseToChar("000"))
-        assertEquals('O', CwBayesianDecoder.morseToChar("111"))
-    }
-
-    @Test
-    fun morseToChar_numbers() {
-        assertEquals('1', CwBayesianDecoder.morseToChar("01111"))
-        assertEquals('0', CwBayesianDecoder.morseToChar("11111"))
-    }
-
-    @Test
-    fun morseToChar_unknown_returnsNull() {
-        assertNull(CwBayesianDecoder.morseToChar("......."))
-        assertNull(CwBayesianDecoder.morseToChar(""))
-    }
-
-    // --- FFT ---
-
-    @Test
-    fun fft_magnitudeSpectrum_detectsTone() {
-        val fft = CwFFT(256)
-        val sampleRate = 8000f
-        val freq = 700f
-        val buffer = FloatArray(256) { (sin(2.0 * PI * freq * it / sampleRate)).toFloat() }
-        val mag = fft.magnitudeSpectrum(buffer)
-        // Peak should be at bin around 700 * 256 / 8000 ≈ 22.4
-        var maxBin = 0
-        var maxVal = 0f
-        for (i in mag.indices) {
-            if (mag[i] > maxVal) { maxVal = mag[i]; maxBin = i }
-        }
-        assertTrue("Peak bin $maxBin should be near 22", maxBin in 18..26)
-        assertTrue("Peak value $maxVal should be positive", maxVal > 0.01f)
-    }
-
-    @Test
-    fun fft_magnitudeSpectrum_silence_isFlat() {
-        val fft = CwFFT(256)
-        val buffer = FloatArray(256) { 0f }
-        val mag = fft.magnitudeSpectrum(buffer)
-        for (v in mag) assertEquals("Silence spectrum should be 0, got $v", 0f, v, 1e-6f)
-    }
-
-    @Test
-    fun fft_rejectsWrongSize() {
-        assertThrows(IllegalArgumentException::class.java) { CwFFT(100) }
-    }
-
-    // --- Spectrogram ---
-
-    @Test
-    fun spectrogram_addSamples_updatesEnergy() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val freq = 700f
-        // Feed multiple frames to stabilize energy normalization
-        for (i in 0..5) {
-            val buffer = FloatArray(256) { (sin(2.0 * PI * freq * it / 8000.0)).toFloat() }
-            spec.addSamples(buffer)
-        }
-        val col = spec.getCurrentColumn()
-        val peakBin = spec.findPeakBin()
-        assertTrue("Peak bin $peakBin should be >= 0", peakBin >= 0)
-    }
-
-    @Test
-    fun spectrogram_findPeakBin_returnsValidBin() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        // Add multiple frames of 700 Hz tone
-        for (i in 0..5) {
-            val buffer = FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() }
-            spec.addSamples(buffer)
-        }
-        val peakBin = spec.findPeakBin()
-        assertTrue("Peak bin should be >= 0, got $peakBin", peakBin >= 0)
-    }
-
-    @Test
-    fun spectrogram_freqToBin_roundtrip() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val freq = 700f
-        val bin = spec.freqToBin(freq)
-        val backFreq = spec.binToFreq(bin)
-        assertTrue("Freq $freq → bin $bin → freq $backFreq", backFreq > 600f && backFreq < 800f)
-    }
-
-    @Test
-    fun spectrogram_getBinEnergy_returnsCorrectLength() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val energy = spec.getBinEnergy(0, 10)
-        assertEquals(10, energy.size)
-    }
-
-    @Test
-    fun spectrogram_reset() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        spec.addSamples(FloatArray(256) { 1f })
-        spec.reset()
-        assertEquals(-1, spec.findPeakBin())
-    }
-
-    // --- Bayesian decoder ---
-
-    @Test
-    fun bayesian_processTone_dit() {
-        val decoder = CwBayesianDecoder()
-        // At 20 WPM, dot = 60 ms
-        val result = decoder.processTone(60f)
-        assertEquals('0', result.symbol)
-        assertTrue("Dit probability should be positive", result.probability > 0.1f)
-    }
-
-    @Test
-    fun bayesian_processTone_dash() {
-        val decoder = CwBayesianDecoder()
-        // Dash = 3 * dot = 180 ms
-        val result = decoder.processTone(180f)
-        assertEquals('1', result.symbol)
-        assertTrue("Dash probability should be positive", result.probability > 0.1f)
-    }
-
-    @Test
-    fun bayesian_processTone_unknown_returnsNull() {
-        val decoder = CwBayesianDecoder()
-        // Very long tone — low probability for both dit and dash
-        val result = decoder.processTone(5000f)
-        assertNull(result.symbol)
-    }
-
-    @Test
-    fun bayesian_processGap_interChar_returnsChar() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f) // dit
-        decoder.processTone(60f) // dit
-        decoder.processTone(60f) // dit
-        // 3 dots = "000" = 'S'
-        val char = decoder.processGap(180f) // 3 * dot = inter-char gap
-        assertEquals('S', char)
-    }
-
-    @Test
-    fun bayesian_processGap_wordGap_addsSpace() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f) // dit = 'E'
-        decoder.processGap(180f) // inter-char gap
-        // Now word gap
-        val space = decoder.processGap(420f) // 7 * dot
-        assertEquals(' ', space)
-    }
-
-    @Test
-    fun bayesian_decodedText_accumulates() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f) // dit = 'E'
-        decoder.processGap(180f) // inter-char
-        assertTrue(decoder.decodedText.isNotEmpty())
-    }
-
-    @Test
-    fun bayesian_reset() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f)
-        decoder.reset()
-        assertEquals("", decoder.decodedText)
-    }
-
-    @Test
-    fun bayesian_getSpeed() {
-        val decoder = CwBayesianDecoder()
-        // Send 3 dits at 20 WPM (60 ms each)
-        decoder.processTone(60f)
-        decoder.processTone(60f)
-        decoder.processTone(60f)
-        val speed = decoder.getSpeed()
-        assertTrue("Speed should be ~20 WPM, got $speed", speed > 15f && speed < 30f)
-    }
-
-    // --- Channel tracker ---
-
-    @Test
-    fun channelTracker_initialState() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val tracker = CwChannelTracker(spec)
-        val channels = tracker.update()
-        assertTrue("No channels should be active initially", channels.isEmpty())
-    }
-
-    @Test
-    fun channelTracker_detectsTone() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        // Feed a tone
-        for (i in 0..5) {
-            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        val tracker = CwChannelTracker(spec)
-        val channels = tracker.update()
-        assertTrue("Should detect at least 1 channel", channels.isNotEmpty())
-    }
-
-    @Test
-    fun channelTracker_bestChannel() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        for (i in 0..5) {
-            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        val tracker = CwChannelTracker(spec)
-        tracker.update()
-        val best = tracker.getBestChannel()
-        assertNotNull("Best channel should exist", best)
-        if (best != null) assertTrue(best.frequency in 600f..800f)
-    }
-
-    @Test
-    fun channelTracker_reset() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        for (i in 0..5) {
-            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        val tracker = CwChannelTracker(spec)
-        tracker.update()
-        tracker.reset()
-        assertNull(tracker.getBestChannel())
-    }
-
-    // --- Full decoder ---
-
-    @Test
-    fun decoder_initialState() {
-        val decoder = CwDecoder()
-        assertEquals("", decoder.decodedTextFlow.value)
-        assertEquals(0f, decoder.signalStrength.value, 0.001f)
-    }
-
-    @Test
-    fun decoder_processSilence_doesNotCrash() {
-        val decoder = CwDecoder()
-        decoder.processBuffer(FloatArray(256) { 0f })
-        assertEquals("", decoder.decodedTextFlow.value)
-    }
-
-    @Test
-    fun decoder_processNoise_doesNotCrash() {
-        val decoder = CwDecoder()
-        decoder.processBuffer(FloatArray(256) { (Math.random() * 2 - 1).toFloat() * 0.1f })
-        assertNotNull(decoder.decodedTextFlow.value)
-    }
-
-    @Test
-    fun decoder_processTone_doesNotCrash() {
-        val decoder = CwDecoder()
-        for (i in 0..20) {
-            decoder.processBuffer(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        assertNotNull(decoder.decodedTextFlow.value)
-    }
-
-    @Test
-    fun decoder_reset() {
-        val decoder = CwDecoder()
-        decoder.processBuffer(FloatArray(256) { 1f })
-        decoder.resetDecoder()
-        assertEquals("", decoder.decodedTextFlow.value)
-        assertEquals(0f, decoder.signalStrength.value, 0.001f)
-    }
-
-    @Test
-    fun decoder_withFixedPitch() {
-        val decoder = CwDecoder(sampleRate = 8000, cwToneFreq = 700f)
-        assertEquals(700f, decoder.estimatedPitch.value)
-    }
-}

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

@@ -39,26 +39,18 @@ 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
@@ -72,11 +64,10 @@ 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
@@ -157,13 +148,16 @@ 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
@@ -284,87 +278,55 @@ fun getDefaultPass(): OrbitalPass = OrbitalPass(
 fun SharedDialog(
     title: String, onCancel: () -> Unit, onAccept: () -> Unit, content: @Composable () -> Unit
 ) {
-    SharedDialog(title = title, onDismissRequest = onCancel, onCancel = onCancel, onAccept = onAccept) { _ ->
+    DialogShell(title = title, titleFontSize = 16, onDismissRequest = onCancel) {
         content()
+        Row(modifier = Modifier.padding(start = it, bottom = it, end = it)) {
+            CardButton(onClick = onCancel, text = stringResource(R.string.btn_cancel))
+            Spacer(modifier = Modifier.weight(1f))
+            CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
+        }
     }
 }
 
 @Composable
-fun 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))
-            }
+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))
         }
-        content(padding)
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun DialogShell(
+    title: String,
+    titleFontSize: Int,
     onDismissRequest: () -> Unit,
-    content: @Composable (padding: Dp) -> Unit
+    content: @Composable (padding: androidx.compose.ui.unit.Dp) -> Unit
 ) {
     val padding = LocalSpacing.current.large
-    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
-    val stopSheetFling = remember {
-        object : NestedScrollConnection {
-            override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
-                return available
+    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)
             }
-
-            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)
         }
     }
 }
@@ -429,26 +391,13 @@ fun TopBar(
 
 @Composable
 fun elevationColor(elevation: Double): Color {
-    val thresholds = LocalElevationThresholds.current
     return when {
-        elevation < thresholds.low -> ElevationLowColor // soft red for low elevation
-        elevation < thresholds.high -> MaterialTheme.colorScheme.primary // accent yellow for normal
-        else -> ElevationHighColor // soft green for high elevation
+        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
     }
 }
 
-/** 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/Navigation.kt

@@ -35,9 +35,6 @@ sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
     @Serializable
     data object Map : Screen(R.drawable.ic_map, R.string.nav_map)
 
-    @Serializable
-    data object Mutual : Screen(R.drawable.ic_match, R.string.nav_mutual)
-
     @Serializable
     data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs)
 }

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

@@ -1,22 +0,0 @@
-<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/values-es/strings.xml

@@ -31,17 +31,14 @@
     <!-- 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">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_filter_hours">Horas por delante</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>
     <string name="pass_empty_list_message">
         Asegúrate de que tus filtros sean correctos y hayas seleccionado satélites</string>
     <string name="pass_error_message">No hay pases de satélite próximos para mostrar</string>
-    <string name="pass_welcome_title">Bienvenido a Look4Sat\!</string>
+    <string name="pass_welcome_title">Bienvenido a Look4Sat-CNMap\!</string>
     <string name="pass_welcome_message">
         Asegúrate de configurar tu posición mediante GPS, Latitud/Longitud o QTH en Configuración.
         \n\nActualiza la base de datos al menos una vez por semana para obtener predicciones precisas.</string>
@@ -142,12 +139,6 @@
     <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,17 +30,14 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">Фильтровать пролеты</string>
     <string name="pass_filter_elev">Минимальная элевация</string>
-    <string name="pass_filter_hours">Период расчёта</string>
-    <string name="pass_filter_aos_time">Окно AOS</string>
-    <string name="pass_filter_invert_time">Инвертировать окно AOS</string>
-    <string name="pass_filter_deep_space">DeepSpace (период &gt;225мин)</string>
+    <string name="pass_filter_hours">Количество часов</string>
     <string name="pass_modes_title">Выберите тип модуляции</string>
     <string name="pass_elevation">Элевация: %.1f°</string>
     <string name="pass_altitude">Высота: %d км</string>
     <string name="pass_empty_list_message">
         Убедитесь, что ваши фильтры настроены правильно и вы выбрали спутники</string>
     <string name="pass_error_message">Нет предстоящих пролётов спутников</string>
-    <string name="pass_welcome_title">Добро пожаловать в Look4Sat\!</string>
+    <string name="pass_welcome_title">Добро пожаловать в Look4Sat-CNMap\!</string>
     <string name="pass_welcome_message">
         Обязательно укажите свое местоположение по GPS, широте/долготе или QTH в настройках.
         \n\nПожалуйста, обновляйте базу данных как минимум раз в неделю, чтобы получать точные прогнозы.</string>
@@ -141,12 +138,6 @@
     <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,17 +31,14 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">පසුකිරිම් පිරිපහදුව</string>
     <string name="pass_filter_elev">අවම උත්තෝලනය</string>
-    <string name="pass_filter_hours">ඉදිරි කාලය</string>
-    <string name="pass_filter_aos_time">AOS කවුළුව</string>
-    <string name="pass_filter_invert_time">AOS කවුළුව ප්‍රතිවිරුද්ධ කරන්න</string>
-    <string name="pass_filter_deep_space">DeepSpace (කාලය &gt;225min)</string>
+    <string name="pass_filter_hours">ඉදිරි පැය</string>
     <string name="pass_modes_title">මූර්ජන ආකාරය තෝරන්න</string>
     <string name="pass_elevation">උත්තෝලනය: %.1f°</string>
     <string name="pass_altitude">උන්නතාශය: %d km</string>
     <string name="pass_empty_list_message">
         ඔබගේ පෙරහන් නිවැරදි බවත් ඔබ චන්ද්‍රිකා තෝරාගෙන ඇති බවත් සහතික කර ගන්න</string>
     <string name="pass_error_message">ප්‍රදර්ශනය කිරීමට ඉදිරියට එන චන්ද්‍රිකා පසුකර යෑම් නැත.</string>
-    <string name="pass_welcome_title">Look4Sat වෙත සාදරයෙන් පිළිගනිමු\!</string>
+    <string name="pass_welcome_title">Look4Sat-CNMap වෙත සාදරයෙන් පිළිගනිමු\!</string>
     <string name="pass_welcome_message">
         සැකසුම් තුළ GPS, Lat/Lon හෝ QTH හරහා ඔබේ ස්ථානය සැකසීමට වග බලා ගන්න.
         \n\nනිවැරදි අනාවැකි ලබා ගැනීම සඳහා අවම වශයෙන් සතිපතා දත්ත සමුදාය යාවත්කාලීන කරන්න.</string>
@@ -142,12 +139,6 @@
     <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

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
     <!-- Commmon -->
-    <string name="app_name" translatable="false">Look4Sat</string>
+    <string name="app_name" translatable="false">Look4Sat-CNMap</string>
     <string name="btn_accept">Kabul et</string>
     <string name="btn_cancel">İptal</string>
     <string name="empty_list_message">Gösterilecek veri bulunamadı</string>
@@ -31,10 +31,7 @@
     <!-- 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 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_filter_hours">Gösterilecek saat aralığı</string>
     <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
     <string name="pass_modes_title">Modulasyon türü seçin</string>
     <string name="pass_satId" translatable="false">%05d</string>
@@ -45,11 +42,11 @@
     <string name="pass_empty_list_message">
         Filtrelerinizin doğru olduğundan ve uydu seçtiğinizden emin olun</string>
     <string name="pass_error_message">Gösterilecek yaklaşan uydu geçişi bulunmuyor</string>
-    <string name="pass_welcome_title">Look4Sat\'a hoş geldiniz\!</string>
+    <string name="pass_welcome_title">Look4Sat-CNMap\'a hoş geldiniz\!</string>
     <string name="pass_welcome_message">
         Ayarlar\'dan GPS, Enlem/Boylam veya QTH kullanarak konumunuzu belirlediğinizden emin olun.
         \n\nDoğru tahminler alabilmek için veritabanını en az haftada bir güncelleyin.</string>
-    <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat</string>
+    <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat-CNMap</string>
     <string name="pass_whatsnew_message" translatable="false">
         * Switched to short-form commands in NetworkReporter, by theojalba
         \n* Added CAT radio control for full-duplex SAT operation, by jcmerg
@@ -87,7 +84,8 @@
     <!-- Map screen -->
     <string name="map_prev">Önceki</string>
     <string name="map_next">Sonraki</string>
-    <string name="map_copyright" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_osm" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_tianditu" translatable="false">© Tianditu</string>
     <string name="map_azimuth">Azimut: %.1f°</string>
     <string name="map_elevation">Yükseklik açısı: %.1f°</string>
     <string name="map_altitude">İrtifa: %.0f km</string>
@@ -103,12 +101,12 @@
     <string name="map_visible">Görünür</string>
 
     <!-- Settings screen -->
-    <string name="prefs_app_title" translatable="false">Look4Sat v%s</string>
-    <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=com.rtbishop.look4sat</string>
+    <string name="prefs_app_title" translatable="false">Look4Sat-CNMap v%s</string>
+    <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=cn.bh2vsq.look4sat</string>
     <string name="prefs_donate_title">Bağış yap</string>
     <string name="prefs_donate_url" translatable="false">https://ko-fi.com/rt_bishop</string>
     <string name="prefs_fdroid_title" translatable="false">F-Droid</string>
-    <string name="prefs_fdroid_url" translatable="false">https://f-droid.org/en/packages/com.rtbishop.look4sat/</string>
+    <string name="prefs_fdroid_url" translatable="false">https://f-droid.org/en/packages/cn.bh2vsq.look4sat/</string>
     <string name="prefs_github_title" translatable="false">GitHub</string>
     <string name="prefs_github_url" translatable="false">https://github.com/rt-bishop/Look4Sat/</string>
     <string name="prefs_license_title" translatable="false">GPLv3</string>
@@ -185,12 +183,6 @@
     <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">

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

@@ -30,18 +30,15 @@
 
     <!-- Passes screen -->
     <string name="pass_filter_title">Фільтр прольотів</string>
-    <string name="pass_filter_elev">Мінімальне піднесень</string>
-    <string name="pass_filter_hours">Час вперед</string>
-    <string name="pass_filter_aos_time">Вікно AOS</string>
-    <string name="pass_filter_invert_time">Інвертувати вікно AOS</string>
-    <string name="pass_filter_deep_space">DeepSpace (період &gt;225хв)</string>
+    <string name="pass_filter_elev">Мінімальне піднесення</string>
+    <string name="pass_filter_hours">Кількість годин</string>
     <string name="pass_modes_title">Виберіть тип модуляції</string>
     <string name="pass_elevation">Піднес.: %.1f°</string>
     <string name="pass_altitude">Висота: %.0f км</string>
     <string name="pass_empty_list_message">
         Переконайтеся, що ваші фільтри правильні, і ви вибрали супутники</string>
     <string name="pass_error_message">Немає майбутніх прольотів супутників</string>
-    <string name="pass_welcome_title">Ласкаво просимо до Look4Sat\!</string>
+    <string name="pass_welcome_title">Ласкаво просимо до Look4Sat-CNMap\!</string>
     <string name="pass_welcome_message">
         Обов’язково встановіть своє місцезнаходження за допомогою GPS, широти/довготи або QTH у налаштуваннях.
         \n\nБудь ласка, оновлюйте базу даних принаймні раз на тиждень, щоб отримувати точні прогнози.</string>
@@ -69,7 +66,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>
@@ -142,12 +139,6 @@
     <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,7 +9,6 @@
     <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>
 
@@ -27,16 +26,13 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">筛选过境</string>
     <string name="pass_filter_elev">仰角值</string>
-    <string name="pass_filter_hours">提前时间</string>
-    <string name="pass_filter_aos_time">AOS 时间段</string>
-    <string name="pass_filter_invert_time">反选 AOS 时间段</string>
-    <string name="pass_filter_deep_space">DeepSpace（周期 &gt;225分钟）</string>
+    <string name="pass_filter_hours">小时数</string>
     <string name="pass_modes_title">选择调制类型</string>
     <string name="pass_elevation">仰角：%.1f°</string>
     <string name="pass_altitude">高度：%d km</string>
     <string name="pass_empty_list_message">请确保您的过滤器设置正确，并且已选择卫星</string>
     <string name="pass_error_message">没有即将过境的卫星</string>
-    <string name="pass_welcome_title">欢迎来到 Look4Sat\!</string>
+    <string name="pass_welcome_title">欢迎来到 Look4Sat-CNMap\!</string>
     <string name="pass_welcome_message">请务必在设置中通过GPS、经纬度或QTH定位您的位置\n建议至少每周更新一次数据库，以确保预测结果的准确性</string>
 
     <!-- Radar screen -->
@@ -58,17 +54,6 @@
     <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>
-
-    <string name="radar_cw_decoder">CW 解码器</string>
-    <string name="radar_cw_start">开始</string>
-    <string name="radar_cw_stop">停止</string>
-    <string name="radar_cw_reset">清空</string>
-
     <!-- Map screen -->
     <string name="map_prev">上一个</string>
     <string name="map_next">下一个</string>
@@ -115,9 +100,6 @@
     <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>
@@ -125,7 +107,6 @@
     <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>
@@ -145,16 +126,6 @@
     <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>
@@ -162,11 +133,6 @@
     <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 所有用户及贡献者!
@@ -174,8 +140,7 @@
         \n• Dave Moten (predict4java)
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)
-        \n• xdsopl 和 Robot36 贡献者!</string>
+        \n• Libre Space Foundation (SatNOGS)</string>
     <string name="prefs_outro_license">该应用程序不提供任何保修.</string>
 
 </resources>

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

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
     <!-- Commmon -->
-    <string name="app_name" translatable="false">Look4Sat</string>
+    <string name="app_name" translatable="false">Look4Sat-CNMap</string>
     <string name="btn_accept">Accept</string>
     <string name="btn_cancel">Cancel</string>
     <string name="empty_list_message">No data to show</string>
@@ -10,7 +10,6 @@
     <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>
 
@@ -32,9 +31,7 @@
     <!-- Passes screen -->
     <string name="pass_filter_title">Filter passes</string>
     <string name="pass_filter_elev">Minimal elevation</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_hours">Hours ahead</string>
     <string name="pass_filter_deep_space">DeepSpace (period >225min)</string>
     <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
     <string name="pass_modes_title">Select modulation type</string>
@@ -46,11 +43,11 @@
     <string name="pass_empty_list_message">
         Make sure your filters are correct and you have selected satellites</string>
     <string name="pass_error_message">There are no upcoming satellite passes to display</string>
-    <string name="pass_welcome_title">Welcome to Look4Sat\!</string>
+    <string name="pass_welcome_title">Welcome to Look4Sat-CNMap\!</string>
     <string name="pass_welcome_message">
         Make sure to set your position via GPS, Lat/Lon or QTH in Settings.
         \n\nPlease update the database at least weekly to get accurate predictions.</string>
-    <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat</string>
+    <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat-CNMap</string>
     <string name="pass_whatsnew_message" translatable="false">
         * Added required tweaks to support Android 17 (API 37)
         \n\n* Added ACCESS_LOCAL_NETWORK permission check to support network data output
@@ -81,21 +78,12 @@
     <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>
-
-    <string name="radar_cw_decoder">CW Decoder</string>
-    <string name="radar_cw_start">Start</string>
-    <string name="radar_cw_stop">Stop</string>
-    <string name="radar_cw_reset">Clear</string>
 
     <!-- Map screen -->
     <string name="map_prev">Prev</string>
     <string name="map_next">Next</string>
-    <string name="map_copyright" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_osm" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_tianditu" translatable="false">© Tianditu</string>
     <string name="map_azimuth">Azimuth: %.1f°</string>
     <string name="map_elevation">Elevation: %.1f°</string>
     <string name="map_altitude">Altitude: %.0f km</string>
@@ -111,12 +99,12 @@
     <string name="map_visible">Visible</string>
 
     <!-- Settings screen -->
-    <string name="prefs_app_title" translatable="false">Look4Sat v%s</string>
-    <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=com.rtbishop.look4sat</string>
+    <string name="prefs_app_title" translatable="false">Look4Sat-CNMap v%s</string>
+    <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=cn.bh2vsq.look4sat</string>
     <string name="prefs_donate_title">Donate</string>
     <string name="prefs_donate_url" translatable="false">https://ko-fi.com/rt_bishop</string>
     <string name="prefs_fdroid_title" translatable="false">F-Droid</string>
-    <string name="prefs_fdroid_url" translatable="false">https://f-droid.org/en/packages/com.rtbishop.look4sat/</string>
+    <string name="prefs_fdroid_url" translatable="false">https://f-droid.org/en/packages/cn.bh2vsq.look4sat/</string>
     <string name="prefs_github_title" translatable="false">GitHub</string>
     <string name="prefs_github_url" translatable="false">https://github.com/rt-bishop/Look4Sat/</string>
     <string name="prefs_license_title" translatable="false">GPLv3</string>
@@ -149,8 +137,6 @@
     <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>
@@ -162,6 +148,13 @@
     <string name="prefs_bt_output">Bluetooth</string>
     <string name="prefs_cat_output">CAT</string>
 
+    <string name="prefs_map_title">Map settings</string>
+    <string name="prefs_map_source_osm" translatable="false">OSM</string>
+    <string name="prefs_map_source_tianditu_vector" translatable="false">天地图-矢量</string>
+    <string name="prefs_map_source_tianditu_image" translatable="false">天地图-影像</string>
+    <string name="prefs_map_tianditu_key" translatable="false">天地图密钥</string>
+    <string name="prefs_map_save_key">保存密钥</string>
+
     <!-- Radio Control -->
     <string name="nav_radiocontrol">Radio Control</string>
     <string name="rc_settings_title">CAT Radio Control</string>
@@ -197,11 +190,6 @@
     <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!

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

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

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

@@ -60,6 +60,7 @@ 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.MapSource
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
@@ -71,37 +72,56 @@ import com.rtbishop.look4sat.core.presentation.TimerRow
 import com.rtbishop.look4sat.core.presentation.TopBar
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import com.rtbishop.look4sat.core.presentation.layoutPadding
+import org.osmdroid.config.Configuration
+import org.osmdroid.tileprovider.MapTileProviderBasic
+import org.osmdroid.tileprovider.tilesource.OnlineTileSourceBase
+import org.osmdroid.tileprovider.tilesource.TileSourceFactory
 import org.osmdroid.tileprovider.tilesource.XYTileSource
 import org.osmdroid.util.GeoPoint
+import org.osmdroid.util.MapTileIndex
 import org.osmdroid.views.CustomZoomButtonsController
 import org.osmdroid.views.MapView
 import org.osmdroid.views.overlay.FolderOverlay
 import org.osmdroid.views.overlay.Marker
 import org.osmdroid.views.overlay.Polyline
+import org.osmdroid.views.overlay.TilesOverlay
+import java.io.File
+import java.net.URLEncoder
 
 // Overlay indices
-private const val OVERLAY_STATION = 0
-private const val OVERLAY_TRACK = 1
-private const val OVERLAY_FOOTPRINT = 2
-private const val OVERLAY_POSITIONS = 3
-private const val OVERLAY_TERMINATOR = 4
+private const val OVERLAY_TDT_LABELS = 0
+private const val OVERLAY_STATION = 1
+private const val OVERLAY_TRACK = 2
+private const val OVERLAY_FOOTPRINT = 3
+private const val OVERLAY_POSITIONS = 4
 private const val OVERLAY_SUN = 5
 private const val OVERLAY_MOON = 6
 private const val OVERLAY_COUNT = 7
 
 private val minLat = MapView.getTileSystem().minLatitude
 private val maxLat = MapView.getTileSystem().maxLatitude
+private val offlineTileSource = XYTileSource("tiles", 0, 6, 256, ".webp", emptyArray<String>())
+private const val OFFLINE_MAX_ZOOM = 7.0
+private const val OSM_MAX_ZOOM = 19.0
+private const val TIANDITU_MAX_ZOOM = 18.0
+private const val TILE_CACHE_MAX_BYTES = 1024L * 1024L * 1024L
+private const val TILE_CACHE_TRIM_BYTES = 900L * 1024L * 1024L
+private const val TILE_REFRESH_DELAY_MS = 250L
+private const val TILE_SOURCE_OSM = "osm"
+private const val TILE_USER_AGENT = "Look4Sat-CNMap"
 private val trackPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-    strokeWidth = 3f
+    strokeWidth = 4f
     style = Paint.Style.STROKE
-    color = Color.RED
+    color = "#1565C0".toColorInt()
     strokeCap = Paint.Cap.ROUND
     strokeJoin = Paint.Join.ROUND
 }
-private val footprintPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-    strokeWidth = 3f
-    style = Paint.Style.FILL_AND_STROKE
-    color = "#FFE082".toColorInt()
+private val footprintOutlinePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    strokeWidth = 4f
+    style = Paint.Style.STROKE
+    color = "#00897B".toColorInt()
+    strokeCap = Paint.Cap.ROUND
+    strokeJoin = Paint.Join.ROUND
 }
 private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
     textSize = 36f
@@ -134,11 +154,17 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
     val rotateMod = Modifier.rotate(180f)
     val timeString = uiState.mapData?.aosTime ?: "00:00:00"
     val isTimeAos = uiState.mapData?.isTimeAos ?: true
+    val usesTianditu = tiandituLayers(uiState.mapSource) != null && uiState.tiandituKey.isNotBlank()
+    val copyrightResId = if (usesTianditu) R.string.map_copyright_tianditu
+    else R.string.map_copyright_osm
 
     LaunchedEffect(uiState.track) {
         val firstPos = uiState.track?.firstOrNull()?.firstOrNull() ?: return@LaunchedEffect
         mapView.controller.animateTo(GeoPoint(firstPos.latitude, firstPos.longitude))
     }
+    LaunchedEffect(uiState.mapSource, uiState.tiandituKey) {
+        configureTileSources(mapView, uiState.mapSource, uiState.tiandituKey)
+    }
     Column(modifier = Modifier.layoutPadding(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
         val isVertical = isVerticalLayout()
         if (isVertical) {
@@ -163,13 +189,12 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
                     uiState.track?.let { setSatelliteTrack(it, view) }
                     uiState.footprint?.let { setFootprint(it, view) }
                     uiState.positions?.let { setPositions(it, view) { item -> onAction(MapAction.SelectItem(item)) } }
-                    setTerminator(uiState.sunLatDeg, uiState.sunLonDeg, view)
                     setSubSolarPoint(uiState.sunLatDeg, uiState.sunLonDeg, view)
                     setMoonPosition(uiState.moonLatDeg, uiState.moonLonDeg, view)
                     view.invalidate()
                 }
                 uiState.mapData?.let { mapData ->
-                    if (isVertical) MapDataCard(mapData) else MapDataCards(mapData)
+                    if (isVertical) MapDataCard(mapData, copyrightResId) else MapDataCards(mapData, copyrightResId)
                 }
             }
         }
@@ -178,11 +203,11 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
 
 // region Map data composables
 @Composable
-private fun MapDataCard(data: MapData) {
+private fun MapDataCard(data: MapData, copyrightResId: Int) {
     val textColor = MaterialTheme.colorScheme.primary
     val cardColors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLowest)
     Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        Text(text = stringResource(R.string.map_copyright), fontSize = 14.sp)
+        Text(text = stringResource(copyrightResId), fontSize = 14.sp)
         Card(colors = cardColors) {
             Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
                 MapDataRow(
@@ -220,7 +245,7 @@ private fun MapDataRow(
 }
 
 @Composable
-private fun MapDataCards(data: MapData) {
+private fun MapDataCards(data: MapData, copyrightResId: Int) {
     val cardColors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLowest)
     val paddingMod = Modifier
         .padding(horizontal = 8.dp, vertical = 4.dp)
@@ -246,7 +271,7 @@ private fun MapDataCards(data: MapData) {
             }
         }
         Text(
-            text = stringResource(R.string.map_copyright),
+            text = stringResource(copyrightResId),
             fontSize = 14.sp,
             modifier = Modifier.align(Alignment.BottomCenter)
         )
@@ -260,6 +285,114 @@ private fun MapDataCards(data: MapData) {
 }
 // endregion
 
+// region Tile sources
+private var configuredTileMapView: MapView? = null
+private var configuredTileSource: String? = null
+
+private fun configureTileSources(mapView: MapView, mapSource: String, tiandituKey: String) {
+    val key = tiandituKey.trim()
+    val layers = tiandituLayers(mapSource)
+    val tileSourceKey = if (layers == null || key.isBlank()) {
+        TILE_SOURCE_OSM
+    } else {
+        "tianditu:${layers.base}:${layers.label}:$key"
+    }
+    if (configuredTileMapView === mapView && configuredTileSource == tileSourceKey) {
+        requestTileRefresh(mapView)
+        return
+    }
+    configuredTileMapView = mapView
+    configuredTileSource = tileSourceKey
+
+    if (layers == null || key.isBlank()) {
+        mapView.setUseDataConnection(true)
+        mapView.setTileProvider(MapTileProviderBasic(mapView.context, TileSourceFactory.MAPNIK))
+        mapView.maxZoomLevel = OSM_MAX_ZOOM
+        mapView.overlayManager.tilesOverlay.applyTileOverlayDefaults()
+        mapView.overlays[OVERLAY_TDT_LABELS] = FolderOverlay()
+        requestTileRefresh(mapView)
+        return
+    }
+    mapView.setUseDataConnection(true)
+    mapView.setTileProvider(MapTileProviderBasic(mapView.context, TiandituTileSource(layer = layers.base, key = key)))
+    mapView.maxZoomLevel = TIANDITU_MAX_ZOOM
+    mapView.overlayManager.tilesOverlay.applyTileOverlayDefaults()
+    mapView.overlays[OVERLAY_TDT_LABELS] = TilesOverlay(
+        MapTileProviderBasic(mapView.context, TiandituTileSource(layer = layers.label, key = key)),
+        mapView.context
+    ).apply {
+        applyTileOverlayDefaults()
+        setUseDataConnection(true)
+    }
+    requestTileRefresh(mapView)
+}
+
+private data class TiandituLayers(val base: String, val label: String)
+
+private fun tiandituLayers(mapSource: String): TiandituLayers? = when (MapSource.normalize(mapSource)) {
+    MapSource.TIANDITU_VECTOR -> TiandituLayers(base = "vec", label = "cva")
+    MapSource.TIANDITU_IMAGE -> TiandituLayers(base = "img", label = "cia")
+    else -> null
+}
+
+private fun TilesOverlay.applyTileOverlayDefaults() {
+    setColorFilter(null)
+    setLoadingBackgroundColor(Color.TRANSPARENT)
+    setLoadingLineColor(Color.TRANSPARENT)
+}
+
+private fun requestTileRefresh(mapView: MapView) {
+    mapView.post {
+        mapView.requestLayout()
+        mapView.invalidate()
+        mapView.postInvalidate()
+    }
+    mapView.postDelayed({
+        mapView.invalidate()
+        mapView.postInvalidate()
+    }, TILE_REFRESH_DELAY_MS)
+}
+
+private fun buildTiandituWmtsUrl(
+    baseUrl: String,
+    layer: String,
+    zoom: Int,
+    row: Int,
+    col: Int,
+    encodedKey: String
+): String = "$baseUrl?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=$layer" +
+    "&STYLE=default&TILEMATRIXSET=w&FORMAT=tiles&TILEMATRIX=$zoom&TILEROW=$row&TILECOL=$col&tk=$encodedKey"
+
+private class TiandituTileSource(
+    private val layer: String,
+    private val key: String
+) : OnlineTileSourceBase(
+    "tianditu-wmts-https-$layer",
+    1,
+    18,
+    256,
+    ".png",
+    Array(8) { index -> "https://t$index.tianditu.gov.cn/${layer}_w/wmts" },
+    "Tianditu"
+) {
+    private val encodedKey = URLEncoder.encode(key, Charsets.UTF_8.name())
+
+    override fun getTileURLString(pMapTileIndex: Long): String {
+        val zoom = MapTileIndex.getZoom(pMapTileIndex)
+        val row = MapTileIndex.getY(pMapTileIndex)
+        val col = MapTileIndex.getX(pMapTileIndex)
+        return buildTiandituWmtsUrl(
+            baseUrl = getBaseUrl(),
+            layer = layer,
+            zoom = zoom,
+            row = row,
+            col = col,
+            encodedKey = encodedKey
+        )
+    }
+}
+// endregion
+
 // region Map overlay helpers
 private fun setStationPosition(stationPos: GeoPos, mapView: MapView) {
     try {
@@ -282,6 +415,8 @@ private fun setStationPosition(stationPos: GeoPos, mapView: MapView) {
 /** Pool of reusable Marker objects keyed by satellite name, to avoid re-creation every frame */
 private val markerPool = HashMap<String, Marker>()
 private var lastMapView: MapView? = null
+private var lastSatelliteTrack: List<List<GeoPos>>? = null
+private var satelliteTrackOverlay: FolderOverlay? = null
 
 private fun setPositions(
     posMap: Map<OrbitalObject, GeoPos>,
@@ -294,8 +429,9 @@ private fun setPositions(
             lastMapView = mapView
             markerPool.clear()
             iconCache.evictAll()
-            footprintPolyline = null
-            footprintPoints = null
+            lastSatelliteTrack = null
+            satelliteTrackOverlay = null
+            footprintOverlay = null
         }
         // Reuse the existing FolderOverlay — creating a new one and replacing it
         // causes osmdroid to detach shared Marker objects, making them invisible.
@@ -357,6 +493,10 @@ private fun getCachedTextIcon(name: String, mapView: MapView): Drawable {
 }
 
 private fun setSatelliteTrack(satTrack: List<List<GeoPos>>, mapView: MapView) {
+    val cachedOverlay = satelliteTrackOverlay
+    if (lastSatelliteTrack === satTrack && cachedOverlay != null && mapView.overlays[OVERLAY_TRACK] === cachedOverlay) {
+        return
+    }
     val trackOverlay = FolderOverlay()
     try {
         satTrack.forEach { track ->
@@ -366,61 +506,76 @@ private fun setSatelliteTrack(satTrack: List<List<GeoPos>>, mapView: MapView) {
                 trackOverlay.add(this)
             }
         }
+        lastSatelliteTrack = satTrack
+        satelliteTrackOverlay = trackOverlay
         mapView.overlays[OVERLAY_TRACK] = trackOverlay
     } catch (e: Exception) {
         println(e)
     }
 }
 
-/** Reusable footprint Polyline — created once, points updated in-place each frame */
-private var footprintPolyline: Polyline? = null
-private var footprintPoints: ArrayList<GeoPoint>? = null
+/** Reusable footprint overlay - split at the date line so wrapped maps don't drop the circle. */
+private var footprintOverlay: FolderOverlay? = null
 
 private fun setFootprint(orbitalPos: OrbitalPos, mapView: MapView) {
     try {
         val rangeCircle = orbitalPos.getRangeCircle()
-        var pts = footprintPoints
-        if (pts == null || pts.size != rangeCircle.size) {
-            pts = ArrayList(rangeCircle.size)
-            for (gp in rangeCircle) pts.add(GeoPoint(gp.latitude, gp.longitude))
-            footprintPoints = pts
-        } else {
-            for (i in rangeCircle.indices) {
-                pts[i].latitude = rangeCircle[i].latitude
-                pts[i].longitude = rangeCircle[i].longitude
+        val overlay = footprintOverlay ?: FolderOverlay().also { footprintOverlay = it }
+        overlay.items.clear()
+        splitClosedPathOnDateLine(rangeCircle).forEach { segment ->
+            if (segment.size > 1) {
+                overlay.add(
+                    Polyline().apply {
+                        setPoints(segment.map { GeoPoint(it.latitude, it.longitude) })
+                        outlinePaint.set(footprintOutlinePaint)
+                    }
+                )
             }
         }
-        val polyline = footprintPolyline ?: Polyline().apply {
-            outlinePaint.set(footprintPaint)
-            footprintPolyline = this
-        }
-        polyline.setPoints(pts)
-        mapView.overlays[OVERLAY_FOOTPRINT] = polyline
+        mapView.overlays[OVERLAY_FOOTPRINT] = overlay
     } catch (e: Exception) {
         println(e)
     }
 }
 
-/**
- * Update the NightOverlay with the current sub-solar position.
- * The overlay is created once and kept in OVERLAY_TERMINATOR; only its
- * sunLatDeg/sunLonDeg fields are updated each tick so osmdroid redraws it.
- */
-private fun setTerminator(sunLatDeg: Double, sunLonDeg: Double, mapView: MapView) {
-    try {
-        val overlay = mapView.overlays[OVERLAY_TERMINATOR]
-        if (overlay is MapNightOverlay) {
-            overlay.sunLatDeg = sunLatDeg
-            overlay.sunLonDeg = sunLonDeg
-        } else {
-            mapView.overlays[OVERLAY_TERMINATOR] = MapNightOverlay().apply {
-                this.sunLatDeg = sunLatDeg
-                this.sunLonDeg = sunLonDeg
+private fun splitClosedPathOnDateLine(points: List<GeoPos>): List<List<GeoPos>> {
+    if (points.isEmpty()) return emptyList()
+    val segments = mutableListOf<List<GeoPos>>()
+    val segment = mutableListOf<GeoPos>()
+    var previous = points.first()
+    segment.add(previous)
+    (points.drop(1) + points.first()).forEach { current ->
+        when {
+            previous.longitude < -170.0 && current.longitude > 170.0 -> {
+                val edgeLatitude = getDateLineLatitude(previous, current, -180.0)
+                segment.add(GeoPos(edgeLatitude, -180.0))
+                segments.add(segment.toList())
+                segment.clear()
+                segment.add(GeoPos(edgeLatitude, 180.0))
+            }
+            previous.longitude > 170.0 && current.longitude < -170.0 -> {
+                val edgeLatitude = getDateLineLatitude(previous, current, 180.0)
+                segment.add(GeoPos(edgeLatitude, 180.0))
+                segments.add(segment.toList())
+                segment.clear()
+                segment.add(GeoPos(edgeLatitude, -180.0))
             }
         }
-    } catch (e: Exception) {
-        println(e)
+        segment.add(current)
+        previous = current
     }
+    if (segment.size > 1) segments.add(segment)
+    return segments
+}
+
+private fun getDateLineLatitude(previous: GeoPos, current: GeoPos, edgeLongitude: Double): Double {
+    val currentLongitude = when {
+        previous.longitude < -170.0 && current.longitude > 170.0 -> current.longitude - 360.0
+        previous.longitude > 170.0 && current.longitude < -170.0 -> current.longitude + 360.0
+        else -> current.longitude
+    }
+    val fraction = (edgeLongitude - previous.longitude) / (currentLongitude - previous.longitude)
+    return previous.latitude + (current.latitude - previous.latitude) * fraction
 }
 
 /** Place an ic_sun icon marker at the sub-solar point. */
@@ -482,40 +637,62 @@ private fun setMoonPosition(moonLatDeg: Double, moonLonDeg: Double, mapView: Map
 // region MapView lifecycle
 @Composable
 private fun rememberMapViewWithLifecycle(): MapView {
-    val tileSource = XYTileSource("tiles", 0, 6, 256, ".webp", emptyArray<String>())
     val context = LocalContext.current
     val isVertical = isVerticalLayout()
     val mapView = remember {
+        configureOsmdroidCache(context)
         MapView(context).apply {
             setMultiTouchControls(true)
             setUseDataConnection(false)
-            setTileSource(tileSource)
+            setTileSource(offlineTileSource)
             minZoomLevel = getMinZoom(resources.displayMetrics.heightPixels, isVertical)
-            maxZoomLevel = 7.0
+            maxZoomLevel = OFFLINE_MAX_ZOOM
             controller.setCenter(GeoPoint(48.8575, 6.3514))
             controller.setZoom(minZoomLevel + 2)
             zoomController.setVisibility(CustomZoomButtonsController.Visibility.NEVER)
             overlayManager.tilesOverlay.loadingBackgroundColor = Color.TRANSPARENT
             overlayManager.tilesOverlay.loadingLineColor = Color.TRANSPARENT
             overlayManager.tilesOverlay.setColorFilter(createColorFilter())
+            setHorizontalMapRepetitionEnabled(true)
+            setVerticalMapRepetitionEnabled(false)
             setScrollableAreaLimitLatitude(maxLat, minLat, 0)
             overlays.addAll(Array(OVERLAY_COUNT) { FolderOverlay() })
+            addOnFirstLayoutListener { _, _, _, _, _ -> requestTileRefresh(this) }
         }
     }
     val lifecycleObserver = rememberMapViewLifecycleObserver(mapView)
     val lifecycle = LocalLifecycleOwner.current.lifecycle
     DisposableEffect(lifecycle) {
         lifecycle.addObserver(lifecycleObserver)
+        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
+            mapView.onResume()
+            requestTileRefresh(mapView)
+        }
         onDispose { lifecycle.removeObserver(lifecycleObserver) }
     }
     return mapView
 }
 
+private fun configureOsmdroidCache(context: android.content.Context) {
+    val cacheRoot = File(context.filesDir, "osmdroid")
+    val tileCache = File(cacheRoot, "tiles")
+    Configuration.getInstance().apply {
+        setUserAgentValue(TILE_USER_AGENT)
+        setOsmdroidBasePath(cacheRoot)
+        setOsmdroidTileCache(tileCache)
+        setTileFileSystemCacheMaxBytes(TILE_CACHE_MAX_BYTES)
+        setTileFileSystemCacheTrimBytes(TILE_CACHE_TRIM_BYTES)
+    }
+}
+
 @Composable
 private fun rememberMapViewLifecycleObserver(mapView: MapView) = remember(mapView) {
     LifecycleEventObserver { _, event ->
         when (event) {
-            Lifecycle.Event.ON_RESUME -> mapView.onResume()
+            Lifecycle.Event.ON_RESUME -> {
+                mapView.onResume()
+                requestTileRefresh(mapView)
+            }
             Lifecycle.Event.ON_PAUSE -> mapView.onPause()
             else -> {}
         }

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

@@ -26,6 +26,8 @@ data class MapState(
     val mapData: MapData? = null,
     val isLightUi: Boolean = false,
     val isUtc: Boolean = false,
+    val mapSource: String = "",
+    val tiandituKey: String = "",
     val stationPosition: GeoPos? = null,
     val orbitalPass: OrbitalPass,
     val track: List<List<GeoPos>>? = null,

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

@@ -61,6 +61,8 @@ class MapViewModel(
         MapState(
             isLightUi = settingsRepo.otherSettings.value.stateOfLightTheme,
             isUtc = settingsRepo.otherSettings.value.stateOfUtc,
+            mapSource = settingsRepo.otherSettings.value.mapSource,
+            tiandituKey = settingsRepo.otherSettings.value.tiandituKey,
             orbitalPass = defaultPass
         )
     )
@@ -74,7 +76,13 @@ class MapViewModel(
     init {
         viewModelScope.launch {
             settingsRepo.otherSettings.collectLatest { settings ->
-                _uiState.update { it.copy(isUtc = settings.stateOfUtc) }
+                _uiState.update {
+                    it.copy(
+                        isUtc = settings.stateOfUtc,
+                        mapSource = settings.mapSource,
+                        tiandituKey = settings.tiandituKey
+                    )
+                }
             }
         }
         val (selectedCatNum, _) = satelliteRepo.selectedPass.value
@@ -269,29 +277,45 @@ class MapViewModel(
         val satTracks = mutableListOf<List<GeoPos>>()
         val currentTrack = mutableListOf<GeoPos>()
         val endDate = Date(date.time + (orbitalObject.data.orbitalPeriod * 2.4 * 60000L).toLong())
-        var oldLongitude = 0.0
+        var previousPosition: GeoPos? = null
         satelliteRepo.getTrack(orbitalObject, pos, date.time, endDate.time).forEach { satPos ->
             val currentPosition = satPos.toMapGeoPos()
-            if (oldLongitude < -170.0 && currentPosition.longitude > 170.0) {
+            val previous = previousPosition
+            if (previous != null && previous.longitude < -170.0 && currentPosition.longitude > 170.0) {
                 // adding left terminal position
-                currentTrack.add(GeoPos(currentPosition.latitude, -180.0))
+                val edgeLatitude = getDateLineLatitude(previous, currentPosition)
+                currentTrack.add(GeoPos(edgeLatitude, -180.0))
                 val finishedTrack = mutableListOf<GeoPos>().apply { addAll(currentTrack) }
                 satTracks.add(finishedTrack)
                 currentTrack.clear()
-            } else if (oldLongitude > 170.0 && currentPosition.longitude < -170.0) {
+                currentTrack.add(GeoPos(edgeLatitude, 180.0))
+            } else if (previous != null && previous.longitude > 170.0 && currentPosition.longitude < -170.0) {
                 // adding right terminal position
-                currentTrack.add(GeoPos(currentPosition.latitude, 180.0))
+                val edgeLatitude = getDateLineLatitude(previous, currentPosition)
+                currentTrack.add(GeoPos(edgeLatitude, 180.0))
                 val finishedTrack = mutableListOf<GeoPos>().apply { addAll(currentTrack) }
                 satTracks.add(finishedTrack)
                 currentTrack.clear()
+                currentTrack.add(GeoPos(edgeLatitude, -180.0))
             }
-            oldLongitude = currentPosition.longitude
+            previousPosition = currentPosition
             currentTrack.add(currentPosition)
         }
         satTracks.add(currentTrack)
         _uiState.update { it.copy(track = satTracks) }
     }
 
+    private fun getDateLineLatitude(previous: GeoPos, current: GeoPos): Double {
+        val currentLon = if (previous.longitude < 0.0 && current.longitude > 0.0) {
+            current.longitude - 360.0
+        } else {
+            current.longitude + 360.0
+        }
+        val edgeLon = if (previous.longitude < 0.0) -180.0 else 180.0
+        val fraction = (edgeLon - previous.longitude) / (currentLon - previous.longitude)
+        return previous.latitude + (current.latitude - previous.latitude) * fraction
+    }
+
     companion object {
         /** Number of parallel chunks for satellite position computation */
         private const val PARALLEL_CHUNKS = 4

feature/mutual/build.gradle.kts

@@ -1,7 +0,0 @@
-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

@@ -1,262 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.feature.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.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 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("● 站点A", color = colorA, fontSize = 12.sp)
-            Text("● 站点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

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

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

@@ -1,590 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.feature.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.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.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.IconCard
-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,
-    navigateUp: () -> Unit = {},
-    navigateToRadar: (Int, Long, MutualPassData?) -> Unit = { _, _, _ -> },
-    modifier: Modifier = Modifier
-) {
-    val state by viewModel.uiState.collectAsState()
-
-    ScreenColumn(
-        topBar = { isVertical ->
-            TopBar(
-                isVerticalLayout = isVertical,
-                startAction = {
-                    IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                },
-                topInfo = {
-                    Text(
-                        text = "过境匹配",
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
-                    )
-                },
-                bottomInfo = {
-                    if (state.mutualPasses.isNotEmpty()) {
-                        Text(
-                            text = "找到 ${state.mutualPasses.size} 个匹配",
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
-                        )
-                    }
-                },
-                endAction = {
-                    if (state.isCalculating) {
-                        CircularProgressIndicator(
-                            modifier = Modifier
-                                .height(24.dp)
-                                .width(24.dp),
-                            strokeWidth = 2.dp
-                        )
-                    }
-                }
-            )
-        }
-    ) { 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)
-            ) {
-                MatchIntroCard()
-
-                if (isVertical) {
-                    StationInputCard(
-                        title = "你的位置",
-                        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 = "友台位置",
-                        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 = "你的位置",
-                            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 = "友台位置",
-                            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 = "你",
-                labelB = "友台"
-            )
-            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 MatchIntroCard(modifier: Modifier = Modifier) {
-    ElevatedCard(modifier = modifier.fillMaxWidth()) {
-        Column(
-            modifier = Modifier.padding(12.dp),
-            verticalArrangement = Arrangement.spacedBy(4.dp)
-        ) {
-            Text(
-                text = "位置匹配",
-                style = MaterialTheme.typography.titleSmall,
-                fontWeight = FontWeight.Medium,
-                color = MaterialTheme.colorScheme.primary
-            )
-            Text(
-                text = "输入双方位置，查找共同可见的卫星过境窗口",
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-    }
-}
-
-@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("填入当前位置", style = MaterialTheme.typography.bodySmall)
-                    }
-                }
-            }
-
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                OutlinedTextField(
-                    value = lat,
-                    onValueChange = onLatChange,
-                    label = { Text("纬度") },
-                    placeholder = { Text(latPlaceholder) },
-                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
-                    singleLine = true,
-                    modifier = Modifier.weight(1f)
-                )
-                OutlinedTextField(
-                    value = lon,
-                    onValueChange = onLonChange,
-                    label = { Text("经度") },
-                    placeholder = { Text(lonPlaceholder) },
-                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
-                    singleLine = true,
-                    modifier = Modifier.weight(1f)
-                )
-            }
-
-            OutlinedTextField(
-                value = grid,
-                onValueChange = onGridChange,
-                label = { Text("网格") },
-                placeholder = { Text(gridPlaceholder) },
-                supportingText = { Text("支持 4/6/8 位 Maidenhead 网格；也可直接输入经纬度") },
-                singleLine = true,
-                modifier = Modifier.fillMaxWidth()
-            )
-
-            Text(
-                text = "最小仰角：${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 = "时间范围",
-                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) "计算中..." else "查询匹配")
-            }
-        }
-    }
-}
-
-@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 = "你: ${pass.maxElevationA}°",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.primary
-                )
-                Text(
-                    text = "友台: ${pass.maxElevationB}°",
-                    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 = "双方轨迹",
-                            style = MaterialTheme.typography.titleSmall,
-                            fontWeight = FontWeight.Medium,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
-                        )
-                        MutualRadarView(
-                            trackSamples = visibleTracks,
-                            progress = dragProgress,
-                            labelA = "你",
-                            labelB = "友台"
-                        )
-                        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("查看雷达")
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,560 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.feature.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 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 = "请输入有效的位置坐标或网格（4/6/8位）") }
-            return
-        }
-
-        val satellites = satelliteRepo.satellites.value
-        if (satellites.isEmpty()) {
-            _uiState.update { it.copy(errorMessage = "没有卫星数据，请先在卫星列表中选择卫星") }
-            return
-        }
-
-        _uiState.update { it.copy(isCalculating = true, errorMessage = null, mutualPasses = emptyList()) }
-
-        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 -> "过境列表为空，请先在卫星列表中选择卫星"
-                    satCount == 0 -> "没有已选中的卫星"
-                    else -> "未找到共同过境（${passCount}个过境，${satCount}颗卫星）"
-                }
-            } 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,11 +21,8 @@ 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
@@ -34,7 +31,6 @@ 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
@@ -59,10 +55,7 @@ import com.rtbishop.look4sat.core.presentation.LocalSpacing
 import com.rtbishop.look4sat.core.presentation.MainTheme
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.SharedDialog
-import com.rtbishop.look4sat.core.presentation.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",
@@ -73,81 +66,33 @@ 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 {
-        PassesFilterDialog(
-            hours = 24,
-            elevation = 16.0,
-            lowElevation = 16.0,
-            highElevation = 65.0,
-            aosStartMinute = 0,
-            aosEndMinute = 23 * 60 + 59,
-            invertAosTimeWindow = false,
-            showDeepSpace = true,
-            cancel = {},
-            accept = {}
-        )
-    }
+    MainTheme { PassesDialog(24, 16.0, true, {}) { _, _, _ -> } }
 }
 
 @Composable
-internal fun PassesFilterDialog(
+internal fun PassesDialog(
     hours: Int,
     elevation: Double,
-    lowElevation: Double,
-    highElevation: Double,
-    aosStartMinute: Int,
-    aosEndMinute: Int,
-    invertAosTimeWindow: Boolean,
     showDeepSpace: Boolean,
     cancel: () -> Unit,
-    accept: (PassFilterParams) -> Unit
+    accept: (Int, Double, Boolean) -> 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(
-            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()
+        accept(hourSteps[hoursIndex.intValue], elevationValueNew.doubleValue, deepSpaceEnabled).also { cancel() }
     }
     SharedDialog(title = stringResource(R.string.pass_filter_title), onCancel = cancel, onAccept = onAccept) {
+        ToggleRow(
+            title = stringResource(R.string.pass_filter_deep_space),
+            checked = deepSpaceEnabled,
+            onCheckedChange = { deepSpaceEnabled = it }
+        )
         SliderRow(
             title = stringResource(R.string.pass_filter_elev),
             value = elevationValueNew.doubleValue,
@@ -159,74 +104,24 @@ internal fun PassesFilterDialog(
         SliderRow(
             title = stringResource(R.string.pass_filter_hours),
             value = hoursIndex.intValue.toDouble(),
-            displayValue = formatHoursLabel(hourSteps[hoursIndex.intValue]),
+            displayValue = "${hourSteps[hoursIndex.intValue]}h",
             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 SliderSection(
+private fun SliderRow(
     title: String,
-    trailingContent: @Composable () -> Unit,
-    sliderContent: @Composable () -> Unit
+    value: Double,
+    displayValue: String,
+    valueResId: Int,
+    valueRange: ClosedFloatingPointRange<Float>,
+    steps: Int = 0,
+    accentColor: Color = MaterialTheme.colorScheme.primary,
+    onChange: (Float) -> Unit
 ) {
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -243,26 +138,6 @@ private fun SliderSection(
                 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,
@@ -276,89 +151,10 @@ 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
@@ -99,31 +99,14 @@ private fun PassesScreen(
     navigateToRadar: (Int, Long) -> Unit
 ) {
     if (uiState.isPassesDialogShown) {
-        PassesFilterDialog(
+        PassesDialog(
             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) },
-            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
-                    )
-                )
-            }
-        )
+            cancel = { onAction(PassesAction.TogglePassesDialog) }
+        ) { hours, elevation, showDeepSpace ->
+            onAction(PassesAction.FilterPasses(hours, elevation, showDeepSpace))
+        }
     }
     if (uiState.isRadiosDialogShown) {
         RadiosDialog(
@@ -134,19 +117,11 @@ private fun PassesScreen(
         }
     }
     if (uiState.shouldSeeWhatsNew) {
-        val dismiss = { onAction(PassesAction.DismissWhatsNew) }
-        SharedDialog(
+        InfoDialog(
             title = stringResource(R.string.pass_whatsnew_title),
-            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)
-            )
+            text = stringResource(R.string.pass_whatsnew_message)
+        ) {
+            onAction(PassesAction.DismissWhatsNew)
         }
     }
     ScreenColumn(
@@ -316,12 +291,13 @@ 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.getDefault()).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
     }
     val aosTimeStr = remember(pass.aosTime, isUtc) { sdfTime.format(Date(pass.aosTime)) }
     val losTimeStr = remember(pass.losTime, isUtc) { sdfTime.format(Date(pass.losTime)) }
@@ -341,6 +317,10 @@ 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
@@ -350,7 +330,7 @@ private fun PassItem(
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis,
-                    color = MaterialTheme.colorScheme.primary
+                    color = MaterialTheme.colorScheme.onSurface
                 )
                 val elevColor = elevationColor(pass.maxElevation)
                 Icon(

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

@@ -29,11 +29,6 @@ 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(),
@@ -45,16 +40,7 @@ data class PassesState(
 
 sealed interface PassesAction {
     data object DismissWhatsNew : 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 FilterPasses(val hoursAhead: Int, val minElevation: Double, val showDeepSpace: Boolean) : PassesAction
     data class FilterRadios(val modes: List<String>) : PassesAction
     data object RefreshPasses : PassesAction
     data object TogglePassesDialog : PassesAction

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

@@ -54,11 +54,6 @@ 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
@@ -76,14 +71,7 @@ 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,
-                        lowElevation = settings.lowElevation,
-                        highElevation = settings.highElevation
-                    )
-                }
+                _uiState.update { it.copy(isUtc = settings.stateOfUtc, shouldSeeWhatsNew = settings.shouldSeeWhatsNew) }
             }
         }
         // Main tick loop: reacts to new passes, then ticks every second
@@ -119,29 +107,9 @@ class PassesViewModel(
         when (action) {
             PassesAction.DismissWhatsNew -> settingsRepo.setWhatsNewDismissed()
             is PassesAction.FilterPasses ->
-                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
-                )
+                applyFilter(action.hoursAhead, action.minElevation, action.showDeepSpace, _uiState.value.modes)
             is PassesAction.FilterRadios ->
-                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
-                )
+                applyFilter(_uiState.value.hours, _uiState.value.elevation, _uiState.value.showDeepSpace, action.modes)
             PassesAction.RefreshPasses -> refreshPasses()
             PassesAction.TogglePassesDialog ->
                 _uiState.update { it.copy(isPassesDialogShown = !it.isPassesDialogShown) }
@@ -152,22 +120,12 @@ class PassesViewModel(
         }
     }
 
-    /** 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
     private fun computeSunTimes(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, Pair<String, String>> {
         val stationPos = settingsRepo.stationPosition.value
         val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
-        val sdfDate = dateFormat(tz)
-        val sdfTime = SimpleDateFormat("HH:mm", Locale.getDefault()).also { it.timeZone = tz }
+        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfTime = SimpleDateFormat("HH:mm", Locale.ENGLISH).also { it.timeZone = tz }
         val result = LinkedHashMap<String, Pair<String, String>>()
         // DeepSpace group always shows today's sun times
         if (passes.any { it.isDeepSpace }) {
@@ -190,7 +148,7 @@ class PassesViewModel(
 
     private fun groupPasses(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, List<OrbitalPass>> {
         val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
-        val sdfDate = dateFormat(tz)
+        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
         val ordered = LinkedHashMap<String, List<OrbitalPass>>()
         val deepSpace = passes.filter { it.isDeepSpace }
         if (deepSpace.isNotEmpty()) ordered["DeepSpace (period >225min)"] = deepSpace
@@ -240,61 +198,19 @@ 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,
-                aosStartMinute,
-                aosEndMinute,
-                invertAosTimeWindow,
-                modes
-            )
-        )
-        settingsRepo.updateOtherSettings { it.copy(lowElevation = lowElevation, highElevation = highElevation) }
+        settingsRepo.setPassesSettings(PassesSettings(showDeepSpace, hoursAhead, minElevation, modes))
         _uiState.update {
-            it.copy(
-                hours = hoursAhead,
-                elevation = minElevation,
-                lowElevation = lowElevation,
-                highElevation = highElevation,
-                aosStartMinute = aosStartMinute,
-                aosEndMinute = aosEndMinute,
-                invertAosTimeWindow = invertAosTimeWindow,
-                showDeepSpace = showDeepSpace,
-                modes = modes
-            )
+            it.copy(hours = hoursAhead, elevation = minElevation, showDeepSpace = showDeepSpace, modes = modes)
         }
-        satelliteRepo.calculatePasses(
-            time = System.currentTimeMillis(),
-            hoursAhead = hoursAhead,
-            minElevation = minElevation,
-            aosStartMinute = aosStartMinute,
-            aosEndMinute = aosEndMinute,
-            invertAosTimeWindow = invertAosTimeWindow,
-            modes = modes
-        )
+        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
     }
 
     private fun refreshPasses() = viewModelScope.launch {
-        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
-        )
+        val (_, hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
+        satelliteRepo.calculatePasses(System.currentTimeMillis(), hoursAhead, minElevation, modes)
     }
 
     companion object {

feature/radar/build.gradle.kts

@@ -5,7 +5,3 @@ plugins {
 android {
     namespace = "com.rtbishop.look4sat.feature.radar"
 }
-
-dependencies {
-    implementation(project(":feature:mutual"))
-}

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

@@ -45,7 +45,6 @@ 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
@@ -60,7 +59,6 @@ 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.toDegrees
 import com.rtbishop.look4sat.core.presentation.EmptyListCard
 import com.rtbishop.look4sat.core.presentation.IconCard
@@ -73,8 +71,6 @@ 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"),
@@ -87,39 +83,17 @@ fun RadarDestination(navigateUp: () -> Unit) {
     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()
-    }
-    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
     ) == PackageManager.PERMISSION_GRANTED
     LaunchedEffect(hasPermission) {
         viewModel.onAction(RadarAction.SstvPermissionResult(hasPermission))
-        viewModel.onAction(RadarAction.CwPermissionResult(hasPermission))
     }
     val permissionLauncher = rememberLauncherForActivityResult(
         ActivityResultContracts.RequestPermission()
-    ) { granted ->
-        viewModel.onAction(RadarAction.SstvPermissionResult(granted))
-        viewModel.onAction(RadarAction.CwPermissionResult(granted))
-    }
-    RadarScreen(uiState, viewModel::onAction, navigateUpAndClearMutual, mutualData, requestMicPermission = {
+    ) { granted -> viewModel.onAction(RadarAction.SstvPermissionResult(granted)) }
+    RadarScreen(uiState, viewModel::onAction, navigateUp, requestMicPermission = {
         permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
     })
 }
@@ -129,37 +103,12 @@ private fun RadarScreen(
     uiState: RadarState,
     onAction: (RadarAction) -> Unit,
     navigateUp: () -> 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()
@@ -183,11 +132,11 @@ private fun RadarScreen(
             }
         }
         if (isVertical) {
-            RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
+            RadarCard(uiState, Modifier.weight(1f))
             PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
         } else {
             Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
+                RadarCard(uiState, Modifier.weight(1f))
                 PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
             }
         }
@@ -222,14 +171,11 @@ private fun PagerCard(
             ) { pageIndex ->
                 when (pages[pageIndex]) {
                     RadarPage.Transceivers -> TransceiversPage(
-                                    transceivers = uiState.transceivers.transmitters,
-                                    selectedUuid = uiState.transceivers.selectedUuid,
-                                    orbitalPos = uiState.orbitalPos,
-                                    cw = uiState.cw,
-                                    radioControl = uiState.radioControl,
-                                    onAction = onAction,
-                                    requestMicPermission = requestMicPermission
-                                )
+                        transceivers = uiState.transceivers.transmitters,
+                        selectedUuid = uiState.transceivers.selectedUuid,
+                        radioControl = uiState.radioControl,
+                        onAction = onAction
+                    )
                     RadarPage.Sstv -> SstvPage(
                         sstv = uiState.sstv,
                         dopplerFrequency = uiState.transceivers.selectedFrequency?.let { formatFrequency(it) },
@@ -243,12 +189,7 @@ private fun PagerCard(
 }
 
 @Composable
-private fun RadarCard(
-    uiState: RadarState,
-    trackB: List<OrbitalPos> = emptyList(),
-    trackBPosition: OrbitalPos? = null,
-    modifier: Modifier = Modifier
-) {
+private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
     val satellitePos = uiState.orbitalPos
     val shouldAnimateBorder = satellitePos?.aboveHorizon == true && satellitePos.eclipsed
     // Always call these composables unconditionally — conditional composable calls violate
@@ -281,8 +222,6 @@ private fun RadarCard(
                 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,7 +22,6 @@ 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 = "",
@@ -62,14 +61,7 @@ data class RadarState(
     val moonPosition: CelestialComputer.MoonPosition? = null,
     val transceivers: TransceiverSubState = TransceiverSubState(),
     val radioControl: RadioControlSubState = RadioControlSubState(),
-    val sstv: SstvSubState = SstvSubState(),
-    val cw: CwSubState = CwSubState(),
-    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 sstv: SstvSubState = SstvSubState()
 )
 
 enum class SstvStatus { Idle, Recording }
@@ -80,21 +72,7 @@ data class SstvSubState(
     val hasPermission: Boolean = false,
     val selectedMode: String = "Auto",
     val supportedModes: List<String> = emptyList(),
-    val currentFrame: SstvFrame? = null,
-    val diagnosticsMetrics: SstvQualityMetrics? = null
-)
-
-// --- CW Decoder ---
-
-enum class CwStatus { Idle, Listening }
-
-data class CwSubState(
-    val status: CwStatus = CwStatus.Idle,
-    val hasPermission: Boolean = false,
-    val decodedText: String = "",
-    val cwToneFreq: Float = 700f,
-    val isExpanded: Boolean = false,
-    val signalStrength: Float = 0f
+    val currentFrame: SstvFrame? = null
 )
 
 sealed interface RadarAction {
@@ -116,12 +94,4 @@ sealed interface RadarAction {
     data object SstvReset : RadarAction
     data class SstvSelectMode(val modeName: String) : RadarAction
     data class SstvPermissionResult(val granted: Boolean) : RadarAction
-
-    // CW actions
-    data object CwStartListening : RadarAction
-    data object CwStopListening : RadarAction
-    data object CwReset : RadarAction
-    data class CwSetToneFreq(val freq: Float) : RadarAction
-    data class CwToggleExpanded(val expanded: Boolean) : RadarAction
-    data class CwPermissionResult(val granted: Boolean) : RadarAction
 }

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

@@ -60,8 +60,6 @@ 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
 
@@ -73,9 +71,6 @@ 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,
@@ -112,23 +107,18 @@ 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)
-    var cachedTrackBRef by remember { mutableStateOf<List<OrbitalPos>?>(null) }
-    var trackBPath by remember { mutableStateOf(Path()) }
     // 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 || trackB !== cachedTrackBRef) {
+        if (radius != cachedRadius || items !== cachedItemsRef) {
             trackPath = createTrackPath(items, radius)
             trackEffect = createTrackEffect(trackPath)
-            trackBPath = trackB?.let { createTrackPath(it, radius) } ?: Path()
             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
@@ -141,19 +131,6 @@ fun RadarViewCompose(
             drawElevationLabels(radius, primaryColor, measurer)
             translate(center.x, center.y) {
                 drawTrack(trackPath, trackEffect, aimColor, primaryColor)
-                // Station-B overlay: full dashed track + live position dot
-                // (same display mode as the local station: track line + pulsing dot)
-                if (trackB != null && trackB.isNotEmpty() && !trackBPath.isEmpty) {
-                    drawPath(
-                        trackBPath, trackBColor,
-                        style = Stroke(STROKE_WIDTH, pathEffect = PathEffect.dashPathEffect(floatArrayOf(18f, 12f)))
-                    )
-                }
-                trackBPosition?.let { posB ->
-                    if (posB.elevation > 0) {
-                        drawPosition(posB, radius, animScale, trackBColor)
-                    }
-                }
                 if (item.elevation > 0) {
                     drawPosition(item, radius, animScale, primaryColor)
                 }
@@ -228,25 +205,13 @@ 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())
-        // 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
+        if (index == 0) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
     }
     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,9 +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.cw.CwDecoder
 import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
 import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
@@ -71,8 +69,6 @@ class RadarViewModel(
     private var transponders: List<SatRadio> = emptyList()
     private var sstvDecoder: SstvDecoder? = null
     private var sstvRecordingJob: Job? = null
-    private var cwDecoder: CwDecoder? = null
-    private var cwListeningJob: Job? = null
 
     // Celestial positions change slowly, recompute at most once per minute
     private var lastCelestialUpdateMs = 0L
@@ -139,8 +135,6 @@ 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()
     }
 
@@ -219,6 +213,7 @@ class RadarViewModel(
 
     override fun onCleared() {
         sensorsRepo.disableSensor()
+        super.onCleared()
     }
 
     fun onAction(action: RadarAction) {
@@ -277,25 +272,6 @@ class RadarViewModel(
                 sstvDecoder?.clearPixels()
                 _uiState.update { it.copy(sstv = it.sstv.copy(currentFrame = null)) }
             }
-
-            // CW actions
-            is RadarAction.CwPermissionResult -> {
-                _uiState.update { it.copy(cw = it.cw.copy(hasPermission = action.granted)) }
-                if (action.granted) initCwDecoder()
-            }
-            RadarAction.CwStartListening -> startCwListening()
-            RadarAction.CwStopListening -> stopCwListening()
-            RadarAction.CwReset -> {
-                cwDecoder?.resetDecoder()
-                _uiState.update { it.copy(cw = it.cw.copy(decodedText = "")) }
-            }
-            is RadarAction.CwSetToneFreq -> {
-                _uiState.update { it.copy(cw = it.cw.copy(cwToneFreq = action.freq)) }
-                cwDecoder = CwDecoder(sampleRate = audioCapture.sampleRate, cwToneFreq = action.freq)
-            }
-            is RadarAction.CwToggleExpanded -> {
-                _uiState.update { it.copy(cw = it.cw.copy(isExpanded = action.expanded)) }
-            }
         }
     }
 
@@ -368,32 +344,13 @@ class RadarViewModel(
 
     private fun initSstvDecoder() {
         if (sstvDecoder == null) {
-            val decoder = SstvDecoder(
-                sampleRate = audioCapture.sampleRate,
-                targetRmsLevel = SSTV_TARGET_RMS,
-                includeScopeData = SSTV_INCLUDE_SCOPE,
-                enableRmsNormalization = SSTV_ENABLE_RMS_NORMALIZATION,
-                preFilterCutoffHz = SSTV_PREFILTER_CUTOFF_HZ,
-                enablePreFilter = SSTV_ENABLE_PREFILTER,
-                enableDiagnosticsHandle = SSTV_ENABLE_DIAGNOSTICS_HANDLE,
-                lineRecoveryStrategy = SSTV_LINE_RECOVERY_STRATEGY
-            )
+            val decoder = SstvDecoder(sampleRate = audioCapture.sampleRate)
             sstvDecoder = decoder
             decoder.lockMode(_uiState.value.sstv.selectedMode)
             _uiState.update { it.copy(sstv = it.sstv.copy(supportedModes = decoder.supportedModes)) }
             viewModelScope.launch {
                 decoder.frames.collect { frame ->
-                    val metrics = decoder.getQualityMetrics()
-                    _uiState.update {
-                        it.copy(sstv = it.sstv.copy(currentFrame = frame, diagnosticsMetrics = metrics))
-                    }
-                }
-            }
-            decoder.getDiagnosticsHandle()?.let { handle ->
-                viewModelScope.launch {
-                    handle.metrics.collectLatest { metrics ->
-                        _uiState.update { it.copy(sstv = it.sstv.copy(diagnosticsMetrics = metrics)) }
-                    }
+                    _uiState.update { it.copy(sstv = it.sstv.copy(currentFrame = frame)) }
                 }
             }
         }
@@ -416,86 +373,7 @@ class RadarViewModel(
         _uiState.update { it.copy(sstv = it.sstv.copy(status = SstvStatus.Idle)) }
     }
 
-    private fun initCwDecoder() {
-        if (cwDecoder == null) {
-            cwDecoder = CwDecoder(
-                sampleRate = audioCapture.sampleRate,
-                cwToneFreq = _uiState.value.cw.cwToneFreq
-            )
-        }
-    }
-
-    private fun startCwListening() {
-        if (cwListeningJob?.isActive == true) return
-        if (!_uiState.value.cw.hasPermission) {
-            // Permission not yet granted — request it (launcher handles the result)
-            return
-        }
-        // Stop SSTV if running (audio capture is shared)
-        stopSstvRecording()
-        initCwDecoder()
-        cwDecoder?.resetDecoder()
-        _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Listening)) }
-        cwListeningJob = viewModelScope.launch {
-            // Collect decoded text flow
-            launch {
-                cwDecoder?.decodedTextFlow?.collect { text ->
-                    _uiState.update { it.copy(cw = it.cw.copy(decodedText = text)) }
-                }
-            }
-            // Collect signal strength
-            launch {
-                cwDecoder?.signalStrength?.collect { strength ->
-                    _uiState.update { it.copy(cw = it.cw.copy(signalStrength = strength)) }
-                }
-            }
-            // Capture audio and feed to decoder
-            audioCapture.audioFlow().collect { buffer ->
-                cwDecoder?.processBuffer(buffer)
-            }
-        }
-    }
-
-    private fun stopCwListening() {
-        cwListeningJob?.cancel()
-        cwListeningJob = null
-        _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Idle)) }
-    }
-
     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,12 +53,11 @@ 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(
@@ -95,44 +94,53 @@ internal fun SstvPage(
 
     if (showModeDialog.value) {
         val allModes = remember(sstv.supportedModes) { listOf("Auto") + sstv.supportedModes }
-        val dismiss = { showModeDialog.value = false }
-        SharedDialog(
-            title = "SSTV Mode",
-            onDismissRequest = dismiss,
-            onAccept = dismiss
-        ) { _ ->
-            LazyColumn(
-                modifier = Modifier
-                    .fillMaxHeight(0.7f)
-                    .background(MaterialTheme.colorScheme.background),
-                verticalArrangement = Arrangement.spacedBy(1.dp)
-            ) {
-                items(allModes) { mode ->
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically,
+        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(
                         modifier = Modifier
-                            .fillMaxWidth()
-                            .background(MaterialTheme.colorScheme.surface)
-                            .clickable {
-                                onAction(RadarAction.SstvSelectMode(mode))
-                                showModeDialog.value = false
-                            }
+                            .fillMaxHeight(0.5f)
+                            .background(MaterialTheme.colorScheme.background),
+                        verticalArrangement = Arrangement.spacedBy(1.dp)
                     ) {
-                        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)
-                        )
+                        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)
+                                )
+                            }
+                        }
                     }
                 }
             }
@@ -173,19 +181,6 @@ 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
@@ -203,15 +198,6 @@ 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

@@ -39,22 +39,14 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material3.Button
-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.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -63,14 +55,11 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.rtbishop.look4sat.core.domain.model.SatRadio
-import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
-import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
 import com.rtbishop.look4sat.core.presentation.CardButton
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.formatFrequency
@@ -82,11 +71,8 @@ import kotlin.time.Duration.Companion.milliseconds
 fun TransceiversPage(
     transceivers: List<SatRadio>,
     selectedUuid: String?,
-    orbitalPos: OrbitalPos?,
-    cw: CwSubState,
     radioControl: RadioControlSubState,
     onAction: (RadarAction) -> Unit,
-    requestMicPermission: () -> Unit = {},
     modifier: Modifier = Modifier
 ) {
     if (transceivers.isEmpty()) {
@@ -109,11 +95,8 @@ fun TransceiversPage(
                 TransceiverItem(
                     radio = radio,
                     isExpanded = isExpanded,
-                    orbitalPos = orbitalPos,
-                    cw = cw,
                     radioControl = radioControl,
                     onAction = onAction,
-                    requestMicPermission = requestMicPermission,
                     onToggle = { onAction(RadarAction.SelectTransmitter(radio.uuid)) }
                 )
             }
@@ -148,11 +131,8 @@ private fun EmptyTransceiversContent(modifier: Modifier = Modifier) {
 private fun TransceiverItem(
     radio: SatRadio,
     isExpanded: Boolean,
-    orbitalPos: OrbitalPos?,
-    cw: CwSubState,
     radioControl: RadioControlSubState,
     onAction: (RadarAction) -> Unit,
-    requestMicPermission: () -> Unit,
     onToggle: () -> Unit
 ) {
     val bgColor = if (isExpanded) MaterialTheme.colorScheme.surfaceContainerHighest
@@ -245,11 +225,8 @@ private fun TransceiverItem(
         ) {
             ExpandedRadioControl(
                 radio = radio,
-                orbitalPos = orbitalPos,
-                cw = cw,
                 radioControl = radioControl,
-                onAction = onAction,
-                requestMicPermission = requestMicPermission
+                onAction = onAction
             )
         }
 
@@ -318,11 +295,8 @@ private fun UnifiedFrequencyRow(
 @Composable
 private fun ExpandedRadioControl(
     radio: SatRadio,
-    orbitalPos: OrbitalPos?,
-    cw: CwSubState,
     radioControl: RadioControlSubState,
-    onAction: (RadarAction) -> Unit,
-    requestMicPermission: () -> Unit = {},
+    onAction: (RadarAction) -> Unit
 ) {
     Column(
         modifier = Modifier
@@ -431,23 +405,6 @@ private fun ExpandedRadioControl(
             }
         }
 
-        // Doppler frequency calculator (linear transponders only)
-        DopplerFrequencyCalculator(
-            transponder = radio,
-            orbitalPos = orbitalPos,
-            modifier = Modifier.fillMaxWidth()
-        )
-
-        // CW decoder panel (linear transponders only)
-        if (DopplerFrequencyCalculator.isLinearTransponder(radio)) {
-            CwDecoderPanel(
-                cw = cw,
-                onAction = onAction,
-                requestMicPermission = requestMicPermission,
-                modifier = Modifier.fillMaxWidth()
-            )
-        }
-
         // Control buttons
         Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
             if (!radioControl.txPanel.isConnected && !radioControl.rxPanel.isConnected) {
@@ -479,266 +436,6 @@ private fun ExpandedRadioControl(
     }
 }
 
-@Composable
-private fun DopplerFrequencyCalculator(
-    transponder: SatRadio,
-    orbitalPos: OrbitalPos?,
-    modifier: Modifier = Modifier
-) {
-    if (orbitalPos == null || !DopplerFrequencyCalculator.isLinearTransponder(transponder)) return
-
-    var txInputMHz by remember { mutableStateOf("") }
-    var rxInputMHz by remember { mutableStateOf("") }
-    var offsetKHz by remember { mutableStateOf("") }
-    var lastEditedBy by remember { mutableStateOf(EditedField.TX) }
-
-    val offsetHz = offsetKHz.toDoubleOrNull()?.let { it * 1000 }?.toLong() ?: 0L
-
-    // Real-time refresh: when orbitalPos changes (1Hz), recompute the opposite field
-    LaunchedEffect(orbitalPos) {
-        if (lastEditedBy == EditedField.TX) {
-            val txMHz = txInputMHz.toDoubleOrNull()
-            if (txMHz != null && txMHz > 0) {
-                val txHz = (txMHz * 1_000_000).toLong()
-                val rxHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
-                    txHz, transponder, orbitalPos, offsetHz
-                )
-                if (rxHz != null) {
-                    rxInputMHz = String.format(Locale.ENGLISH, "%.6f", rxHz / 1_000_000.0)
-                }
-            }
-        } else {
-            val rxMHz = rxInputMHz.toDoubleOrNull()
-            if (rxMHz != null && rxMHz > 0) {
-                val rxHz = (rxMHz * 1_000_000).toLong()
-                val txHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
-                    rxHz, transponder, orbitalPos, offsetHz
-                )
-                if (txHz != null) {
-                    txInputMHz = String.format(Locale.ENGLISH, "%.6f", txHz / 1_000_000.0)
-                }
-            }
-        }
-    }
-
-    Column(
-        modifier = modifier,
-        verticalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-        Text(
-            text = stringResource(R.string.radar_doppler_calc),
-            fontSize = 14.sp,
-            fontWeight = FontWeight.Medium,
-            color = MaterialTheme.colorScheme.primary
-        )
-        Text(
-            text = stringResource(R.string.radar_doppler_info),
-            fontSize = 12.sp,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-
-        // Offset input
-        OutlinedTextField(
-            value = offsetKHz,
-            onValueChange = { newVal ->
-                offsetKHz = newVal
-                // Trigger recompute based on last edited field
-                if (lastEditedBy == EditedField.TX) {
-                    val txMHz = txInputMHz.toDoubleOrNull()
-                    if (txMHz != null && txMHz > 0) {
-                        val txHz = (txMHz * 1_000_000).toLong()
-                        val rxHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
-                            txHz, transponder, orbitalPos, offsetHz
-                        )
-                        rxInputMHz = if (rxHz != null) String.format(Locale.ENGLISH, "%.6f", rxHz / 1_000_000.0) else ""
-                    }
-                } else {
-                    val rxMHz = rxInputMHz.toDoubleOrNull()
-                    if (rxMHz != null && rxMHz > 0) {
-                        val rxHz = (rxMHz * 1_000_000).toLong()
-                        val txHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
-                            rxHz, transponder, orbitalPos, offsetHz
-                        )
-                        txInputMHz = if (txHz != null) String.format(Locale.ENGLISH, "%.6f", txHz / 1_000_000.0) else ""
-                    }
-                }
-            },
-            label = { Text(stringResource(R.string.radar_doppler_offset_hint)) },
-            singleLine = true,
-            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
-            modifier = Modifier.fillMaxWidth()
-        )
-
-        // TX and RX inputs on the same row
-        Row(
-            horizontalArrangement = Arrangement.spacedBy(8.dp),
-            modifier = Modifier.fillMaxWidth()
-        ) {
-            // TX input → compute RX
-            OutlinedTextField(
-                value = txInputMHz,
-                onValueChange = { newVal ->
-                    txInputMHz = newVal
-                    lastEditedBy = EditedField.TX
-                    val mhz = newVal.toDoubleOrNull()
-                    if (mhz != null && mhz > 0) {
-                        val txHz = (mhz * 1_000_000).toLong()
-                        val rxHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
-                            txHz, transponder, orbitalPos, offsetHz
-                        )
-                        rxInputMHz = if (rxHz != null) String.format(Locale.ENGLISH, "%.6f", rxHz / 1_000_000.0) else ""
-                    } else if (newVal.isEmpty()) {
-                        rxInputMHz = ""
-                    }
-                },
-                label = { Text(stringResource(R.string.radar_doppler_tx_hint)) },
-                singleLine = true,
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
-                modifier = Modifier.weight(1f)
-            )
-
-            // RX input → compute TX
-            OutlinedTextField(
-                value = rxInputMHz,
-                onValueChange = { newVal ->
-                    rxInputMHz = newVal
-                    lastEditedBy = EditedField.RX
-                    val mhz = newVal.toDoubleOrNull()
-                    if (mhz != null && mhz > 0) {
-                        val rxHz = (mhz * 1_000_000).toLong()
-                        val txHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
-                            rxHz, transponder, orbitalPos, offsetHz
-                        )
-                        txInputMHz = if (txHz != null) String.format(Locale.ENGLISH, "%.6f", txHz / 1_000_000.0) else ""
-                    } else if (newVal.isEmpty()) {
-                        txInputMHz = ""
-                    }
-                },
-                label = { Text(stringResource(R.string.radar_doppler_rx_hint)) },
-                singleLine = true,
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
-                modifier = Modifier.weight(1f)
-            )
-        }
-    }
-}
-
-private enum class EditedField { TX, RX }
-
-@Composable
-private fun CwDecoderPanel(
-    cw: CwSubState,
-    onAction: (RadarAction) -> Unit,
-    requestMicPermission: () -> Unit = {},
-    modifier: Modifier = Modifier
-) {
-    Column(
-        modifier = modifier,
-        verticalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-        // Header row: expand/collapse toggle
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .clickable { onAction(RadarAction.CwToggleExpanded(!cw.isExpanded)) },
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Text(
-                text = stringResource(R.string.radar_cw_decoder),
-                fontSize = 14.sp,
-                fontWeight = FontWeight.Medium,
-                color = MaterialTheme.colorScheme.primary
-            )
-            Icon(
-                painter = painterResource(id = R.drawable.ic_arrow),
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier
-                    .size(20.dp)
-                    .rotate(if (cw.isExpanded) 270f else 90f)
-            )
-        }
-
-        AnimatedVisibility(visible = cw.isExpanded) {
-            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                // Control buttons row
-                Row(
-                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    if (cw.status == CwStatus.Idle) {
-                        Button(
-                            onClick = {
-                                if (!cw.hasPermission) {
-                                    requestMicPermission()
-                                } else {
-                                    onAction(RadarAction.CwStartListening)
-                                }
-                            },
-                            modifier = Modifier.weight(1f)
-                        ) {
-                            Text(stringResource(R.string.radar_cw_start))
-                        }
-                    } else {
-                        Button(
-                            onClick = { onAction(RadarAction.CwStopListening) },
-                            modifier = Modifier.weight(1f)
-                        ) {
-                            Text(stringResource(R.string.radar_cw_stop))
-                        }
-                    }
-                    OutlinedButton(
-                        onClick = { onAction(RadarAction.CwReset) },
-                        modifier = Modifier.weight(1f)
-                    ) {
-                        Text(stringResource(R.string.radar_cw_reset))
-                    }
-                }
-
-                // Signal strength indicator
-                if (cw.status == CwStatus.Listening && cw.signalStrength > 0f) {
-                    val strengthPct = (cw.signalStrength * 100).toInt()
-                    Text(
-                        text = "Signal: $strengthPct%",
-                        fontSize = 12.sp,
-                        color = if (cw.signalStrength > 0.5f) Color(0xFF4CAF50)
-                        else if (cw.signalStrength > 0.2f) Color(0xFFFFC107)
-                        else MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-
-                // Decoded text output
-                ElevatedCard(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .height(120.dp)
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(8.dp)
-                    ) {
-                        Text(
-                            text = "Decoded:",
-                            fontSize = 12.sp,
-                            fontWeight = FontWeight.Bold,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
-                        )
-                        Spacer(modifier = Modifier.height(4.dp))
-                        Text(
-                            text = cw.decodedText.ifEmpty { "Waiting for CW signal..." },
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            color = MaterialTheme.colorScheme.onSurface
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
-
 @Composable
 private fun FrequencyText(frequency: Long?, modifier: Modifier = Modifier) {
     val text = frequency?.let {

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,19 +95,11 @@ private fun SatellitesScreen(
         )
     }
     if (uiState.shouldSeeWarning) {
-        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)
-            )
+        InfoDialog(
+            stringResource(R.string.sat_warning_title),
+            stringResource(R.string.sat_warning_message)
+        ) {
+            onAction(SatellitesAction.DismissWarning)
         }
     }
 
@@ -290,17 +282,14 @@ 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.primary
+                color = MaterialTheme.colorScheme.onSurface
             )
             Checkbox(
                 checked = item.isSelected,

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

@@ -22,14 +22,11 @@ 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
@@ -41,7 +38,6 @@ 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
@@ -69,16 +65,13 @@ 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)) },
-            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+            label = { Text(text = stringResource(id = R.string.prefs_station_lat_text)) }
         )
         OutlinedTextField(
             value = lonValue.value,
             onValueChange = { lonValue.value = it },
-            label = { Text(text = stringResource(id = R.string.prefs_station_lon_text)) },
-            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+            label = { Text(text = stringResource(id = R.string.prefs_station_lon_text)) }
         )
-        Spacer(modifier = Modifier.height(0.dp))
     }
 }
 
@@ -104,10 +97,8 @@ 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)) },
-            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+            label = { Text(text = stringResource(id = R.string.prefs_locator_text)) }
         )
-        Spacer(modifier = Modifier.height(0.dp))
     }
 }
 
@@ -120,7 +111,6 @@ private fun TransceiversDialogPreview() {
             useCustomTransceivers = true,
             tleUrl = "https://example.com/tle.txt",
             transceiversUrl = "https://example.com/tx.json",
-            requestCustomSourcesPermission = { onGranted, _ -> onGranted() },
             onImportTle = {},
             onImportTransceivers = {},
             onDismiss = {},
@@ -135,7 +125,6 @@ fun DataSourcesDialog(
     useCustomTransceivers: Boolean,
     tleUrl: String,
     transceiversUrl: String,
-    requestCustomSourcesPermission: (onGranted: () -> Unit, onDenied: () -> Unit) -> Unit,
     onImportTle: () -> Unit,
     onImportTransceivers: () -> Unit,
     onDismiss: () -> Unit,
@@ -163,7 +152,7 @@ fun DataSourcesDialog(
                         onImportTle()
                         onDismiss()
                     },
-                    text = "TLE/3LE (.txt)\nOMM (.csv)",
+                    text = "TLE (3LE)\nR4UAB (.txt)",
                     modifier = Modifier.weight(1f)
                 )
                 CardButton(
@@ -184,16 +173,7 @@ fun DataSourcesDialog(
                 Text(text = stringResource(id = R.string.prefs_data_sources_tle_switch))
                 Switch(
                     checked = isEnabledCustomTle.value,
-                    onCheckedChange = { enabled ->
-                        if (!enabled) {
-                            isEnabledCustomTle.value = false
-                        } else {
-                            requestCustomSourcesPermission(
-                                { isEnabledCustomTle.value = true },
-                                { isEnabledCustomTle.value = false }
-                            )
-                        }
-                    }
+                    onCheckedChange = { isEnabledCustomTle.value = it }
                 )
             }
             OutlinedTextField(
@@ -213,16 +193,7 @@ fun DataSourcesDialog(
                 Text(text = stringResource(id = R.string.prefs_data_sources_transceivers_switch))
                 Switch(
                     checked = isEnabledCustomTransceivers.value,
-                    onCheckedChange = { enabled ->
-                        if (!enabled) {
-                            isEnabledCustomTransceivers.value = false
-                        } else {
-                            requestCustomSourcesPermission(
-                                { isEnabledCustomTransceivers.value = true },
-                                { isEnabledCustomTransceivers.value = false }
-                            )
-                        }
-                    }
+                    onCheckedChange = { isEnabledCustomTransceivers.value = it }
                 )
             }
             OutlinedTextField(
@@ -233,7 +204,6 @@ fun DataSourcesDialog(
                 modifier = Modifier.fillMaxWidth(),
                 enabled = isEnabledCustomTransceivers.value,
             )
-            Spacer(modifier = Modifier.height(12.dp))
         }
     }
 }
@@ -324,7 +294,6 @@ fun NetworkOutputDialog(
                 onFormatChange = { frequencyFormat.value = it },
                 formatLabel = stringResource(R.string.prefs_net_frequency_format_hint)
             )
-            Spacer(modifier = Modifier.height(12.dp))
         }
     }
 }
@@ -418,7 +387,6 @@ fun BluetoothOutputDialog(
                 onFormatChange = { frequencyFormat.value = it },
                 formatLabel = stringResource(R.string.prefs_bt_frequency_output_hint)
             )
-            Spacer(modifier = Modifier.height(12.dp))
         }
     }
 }
@@ -470,164 +438,114 @@ 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 enabled    = rememberSaveable { mutableStateOf(initialSettings.enabled) }
+    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 radioModel = rememberSaveable { mutableStateOf(initialSettings.radioModel) }
-    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 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 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 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 onAccept = {
         onSave(
             RadioControlSettings(
-                enabled        = enabled.value,
-                radioModel     = radioModel.value,
+                enabled = enabled.value,
+                radioModel = radioModel.value,
                 txRadioAddress = txAddress.value,
-                rxRadioAddress = if (isSingleRadio) "" else rxAddress.value,
-                txRadioName    = txName.value,
-                rxRadioName    = if (isSingleRadio) "" else rxName.value,
-                baudRate       = baudRate.intValue,
-                splitMode      = splitMode.value
+                rxRadioAddress = rxAddress.value,
+                txRadioName = txName.value,
+                rxRadioName = rxName.value,
+                baudRate = baudRate.intValue
             )
         )
         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 — FlowRow so chips wrap on small screens
+            // Radio model selection
             Text(
-                text       = stringResource(R.string.rc_radio_model),
-                fontWeight = FontWeight.Medium,
-                color      = androidx.compose.material3.MaterialTheme.colorScheme.primary
+                stringResource(R.string.rc_radio_model),
+                fontWeight = androidx.compose.ui.text.font.FontWeight.Medium,
+                color = androidx.compose.material3.MaterialTheme.colorScheme.primary
             )
-            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+            Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
                 RadioControlSettings.SUPPORTED_RADIOS.forEach { model ->
-                    FilterChip(
+                    androidx.compose.material3.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))
 
-            // 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)
+            // TX Radio selection
+            Text("TX Radio (Uplink)", fontWeight = androidx.compose.ui.text.font.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     = if (isSingleRadio) "Select Device" else "Select TX Device",
+                onClick = { selectingFor.value = "tx" },
+                text = "Select TX Device",
                 modifier = Modifier.fillMaxWidth()
             )
             Spacer(modifier = Modifier.height(6.dp))
 
-            // 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))
+            // 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 device picker (inline, shown while selecting)
+            // Paired devices list (shown when selecting)
             if (selectingFor.value.isNotBlank()) {
+                Spacer(modifier = Modifier.height(6.dp))
                 Text(
-                    text       = "Paired Bluetooth Devices:",
-                    fontWeight = FontWeight.Medium,
-                    color      = androidx.compose.material3.MaterialTheme.colorScheme.primary
+                    text = "Paired Bluetooth Devices:",
+                    fontWeight = androidx.compose.ui.text.font.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.",
-                        fontSize = 13.sp
-                    )
+                    Text("No paired devices found. Pair your BT adapter in Android Bluetooth settings first.")
                 } else {
                     pairedDevices.forEach { (name, address) ->
                         androidx.compose.material3.Surface(
@@ -636,17 +554,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))
@@ -655,22 +573,25 @@ fun RadioControlDialog(
                         }
                     }
                 }
-                Spacer(modifier = Modifier.height(6.dp))
             }
 
-            // 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))
+            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
+                        )
+                    }
                 }
             }
-            Spacer(modifier = Modifier.height(6.dp))
         }
     }
 }

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

@@ -34,10 +34,14 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.GridItemSpan
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ElevatedButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -56,11 +60,13 @@ import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
+import com.rtbishop.look4sat.core.domain.model.MapSource
 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,22 +95,10 @@ 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 },
-        onCustomSourcesPermissionGranted = {
-            pendingCustomSourcesGrant.value?.invoke()
-            pendingCustomSourcesGrant.value = null
-            pendingCustomSourcesDeny.value = null
-        },
-        onCustomSourcesPermissionDenied = {
-            pendingCustomSourcesDeny.value?.invoke()
-            pendingCustomSourcesGrant.value = null
-            pendingCustomSourcesDeny.value = null
-        }
+        onNetworkGranted = { dialogs.network = true }
     )
 
     // Dialogs
@@ -129,11 +123,6 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
             useCustomTransceivers = uiState.dataSourcesSettings.useCustomTransceivers,
             tleUrl = uiState.dataSourcesSettings.tleUrl,
             transceiversUrl = uiState.dataSourcesSettings.transceiversUrl,
-            requestCustomSourcesPermission = { onGranted, onDenied ->
-                pendingCustomSourcesGrant.value = onGranted
-                pendingCustomSourcesDeny.value = onDenied
-                permissions.launchCustomSourcesPermission()
-            },
             onImportTle = { permissions.launchTleImport(); dialogs.dataSources = false },
             onImportTransceivers = { permissions.launchTransceiverImport(); dialogs.dataSources = false },
             onDismiss = { dialogs.dataSources = false },
@@ -146,9 +135,7 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
                     transceiversUrl = if (!useCustomTransceivers || transceiversUrl.isNotBlank()) transceiversUrl else current.transceiversUrl
                 )
                 if (newSettings != current) onAction(SettingsAction.UpdateDataSources(newSettings))
-                if (newSettings.useCustomTLE || newSettings.useCustomTransceivers) {
-                    onAction(SettingsAction.UpdateFromWeb)
-                }
+                if (useCustomTle || useCustomTransceivers) onAction(SettingsAction.UpdateFromWeb)
             }
         )
     }
@@ -299,6 +286,7 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
                 )
             }
             item { OtherCard(uiState.otherSettings, onAction) }
+            item { MapSettingsCard(uiState.otherSettings, onAction) }
             item { CardCredits() }
         }
     }
@@ -376,7 +364,7 @@ private fun LocationCard(
 @Composable
 private fun DataCardPreview() = MainTheme {
     val settings = DataSettings(true, 5000, 2500, 0L)
-    DataCard(settings = settings, updateFromWeb = {}, clearAllData = {}, showDataSourcesDialog = {})
+    DataCard(settings = settings, {}, {}, {})
 }
 
 @Composable
@@ -481,6 +469,106 @@ private fun OtherCardPreview() = MainTheme {
     OtherCard(settings = values) {}
 }
 
+@Composable
+private fun MapSettingsCard(settings: OtherSettings, onAction: (SettingsAction) -> Unit) {
+    var keyValue by remember(settings.tiandituKey) { mutableStateOf(settings.tiandituKey) }
+    LaunchedEffect(keyValue) {
+        kotlinx.coroutines.delay(400)
+        if (keyValue.trim() != settings.tiandituKey) {
+            onAction(SettingsAction.SetTiandituKey(keyValue))
+        }
+    }
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
+        ) {
+            Text(
+                text = stringResource(id = R.string.prefs_map_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            val currentMapSource = MapSource.normalize(settings.mapSource)
+            MapSourceRow(
+                currentMapSource = currentMapSource,
+                firstSource = MapSource.OSM,
+                firstTitle = stringResource(id = R.string.prefs_map_source_osm),
+                secondSource = MapSource.TIANDITU_VECTOR,
+                secondTitle = stringResource(id = R.string.prefs_map_source_tianditu_vector),
+                onAction = onAction
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            MapSourceRow(
+                currentMapSource = currentMapSource,
+                firstSource = MapSource.TIANDITU_IMAGE,
+                firstTitle = stringResource(id = R.string.prefs_map_source_tianditu_image),
+                onAction = onAction
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            OutlinedTextField(
+                value = keyValue,
+                onValueChange = { keyValue = it },
+                label = { Text(text = stringResource(id = R.string.prefs_map_tianditu_key)) },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth()
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            CardButton(
+                onClick = { onAction(SettingsAction.SetTiandituKey(keyValue)) },
+                text = stringResource(id = R.string.prefs_map_save_key),
+                modifier = Modifier.fillMaxWidth()
+            )
+        }
+    }
+}
+
+@Composable
+private fun MapSourceRow(
+    currentMapSource: String,
+    firstSource: String,
+    firstTitle: String,
+    secondSource: String? = null,
+    secondTitle: String? = null,
+    onAction: (SettingsAction) -> Unit
+) {
+    Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+        MapSourceButton(
+            onClick = { onAction(SettingsAction.SetMapSource(firstSource)) },
+            text = firstTitle,
+            selected = currentMapSource == firstSource,
+            modifier = Modifier.weight(1f)
+        )
+        if (secondSource != null && secondTitle != null) {
+            MapSourceButton(
+                onClick = { onAction(SettingsAction.SetMapSource(secondSource)) },
+                text = secondTitle,
+                selected = currentMapSource == secondSource,
+                modifier = Modifier.weight(1f)
+            )
+        } else {
+            Spacer(modifier = Modifier.weight(1f))
+        }
+    }
+}
+
+@Composable
+private fun MapSourceButton(onClick: () -> Unit, text: String, selected: Boolean, modifier: Modifier = Modifier) {
+    ElevatedButton(
+        onClick = onClick,
+        colors = ButtonDefaults.buttonColors(
+            containerColor = if (selected) MaterialTheme.colorScheme.primary
+            else MaterialTheme.colorScheme.surfaceVariant,
+            contentColor = if (selected) MaterialTheme.colorScheme.onPrimary
+            else MaterialTheme.colorScheme.onSurfaceVariant
+        ),
+        shape = MaterialTheme.shapes.small,
+        modifier = modifier,
+        contentPadding = PaddingValues(horizontal = 8.dp, vertical = 8.dp)
+    ) {
+        Text(text = text, fontSize = 16.sp, textAlign = TextAlign.Center)
+    }
+}
+
 @Composable
 private fun OtherCard(settings: OtherSettings, onAction: (SettingsAction) -> Unit) {
     ElevatedCard(
@@ -672,17 +760,14 @@ private class SettingsPermissions(
     val launchTleImport: () -> Unit,
     val launchTransceiverImport: () -> Unit,
     val launchBluetooth: () -> Unit,
-    val launchNetwork: () -> Unit,
-    val launchCustomSourcesPermission: () -> Unit
+    val launchNetwork: () -> Unit
 )
 
 @Composable
 private fun rememberSettingsPermissions(
     sendAction: (SettingsAction) -> Unit,
     onBluetoothGranted: () -> Unit,
-    onNetworkGranted: () -> Unit,
-    onCustomSourcesPermissionGranted: () -> Unit,
-    onCustomSourcesPermissionDenied: () -> Unit
+    onNetworkGranted: () -> Unit
 ): SettingsPermissions {
     val locationError = stringResource(R.string.prefs_loc_gps_error)
     val locationRequest = rememberLauncherForActivityResult(
@@ -694,15 +779,12 @@ 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(), satellitesImportError)) }
+        uri?.let { sendAction(SettingsAction.UpdateTLEFromFile(it.toString())) }
     }
 
     val transceiversRequest = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
-        uri?.let { sendAction(SettingsAction.UpdateTransceiversFromFile(it.toString(), transceiversImportError)) }
+        uri?.let { sendAction(SettingsAction.UpdateTransceiversFromFile(it.toString())) }
     }
 
     val bluetoothError = stringResource(R.string.prefs_bt_perm_error)
@@ -719,15 +801,6 @@ 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 = {
@@ -744,13 +817,6 @@ 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,10 +28,7 @@ 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(
@@ -53,8 +50,8 @@ sealed interface SettingsAction {
 
     // Data
     data object UpdateFromWeb : SettingsAction
-    data class UpdateTLEFromFile(val uri: String, val invalidFileMessage: String) : SettingsAction
-    data class UpdateTransceiversFromFile(val uri: String, val invalidFileMessage: String) : SettingsAction
+    data class UpdateTLEFromFile(val uri: String) : SettingsAction
+    data class UpdateTransceiversFromFile(val uri: String) : SettingsAction
     data object ClearAllData : SettingsAction
 
     // Toggles
@@ -64,6 +61,8 @@ sealed interface SettingsAction {
     data class ToggleSensor(val value: Boolean) : SettingsAction
     data class ToggleLightTheme(val value: Boolean) : SettingsAction
     data class ToggleNightMode(val value: Boolean) : SettingsAction
+    data class SetMapSource(val value: String) : SettingsAction
+    data class SetTiandituKey(val value: String) : SettingsAction
 
     // Remote control
     data class UpdateRC(val settings: RCSettings) : SettingsAction

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 = it.dataSettings.copy(
-                            isUpdating = false,
-                            entriesTotal = state.numberOfSatellites,
-                            radiosTotal = state.numberOfRadios,
-                            timestamp = state.updateTimestamp
+                        dataSettings = DataSettings(
+                            false,
+                            state.numberOfSatellites,
+                            state.numberOfRadios,
+                            state.updateTimestamp
                         )
                     )
                 }
@@ -107,11 +107,11 @@ class SettingsViewModel(
             SettingsAction.DismissPosMessages -> dismissPosMessage()
             // Data
             SettingsAction.UpdateFromWeb -> runDataUpdate { databaseRepo.updateFromRemote() }
-            is SettingsAction.UpdateTLEFromFile -> runManualImport(action.invalidFileMessage) {
-                databaseRepo.updateTLEFromFile(action.uri)
-            }
-            is SettingsAction.UpdateTransceiversFromFile -> runManualImport(action.invalidFileMessage) {
-                databaseRepo.updateTransceiversFromFile(action.uri)
+            is SettingsAction.UpdateTLEFromFile -> runDataUpdate { databaseRepo.updateTLEFromFile(action.uri) }
+            is SettingsAction.UpdateTransceiversFromFile -> runDataUpdate {
+                databaseRepo.updateTransceiversFromFile(
+                    action.uri
+                )
             }
             SettingsAction.ClearAllData -> viewModelScope.launch { databaseRepo.clearAllData() }
             // Toggles
@@ -121,6 +121,8 @@ class SettingsViewModel(
             is SettingsAction.ToggleSensor -> settingsRepo.updateOtherSettings { it.copy(stateOfSensors = action.value) }
             is SettingsAction.ToggleLightTheme -> settingsRepo.updateOtherSettings { it.copy(stateOfLightTheme = action.value) }
             is SettingsAction.ToggleNightMode -> settingsRepo.updateOtherSettings { it.copy(stateOfNightMode = action.value) }
+            is SettingsAction.SetMapSource -> settingsRepo.updateOtherSettings { it.copy(mapSource = action.value) }
+            is SettingsAction.SetTiandituKey -> settingsRepo.updateOtherSettings { it.copy(tiandituKey = action.value.trim()) }
             // Remote control & data sources
             is SettingsAction.UpdateRC -> settingsRepo.updateRCSettings(action.settings)
             is SettingsAction.UpdateRadioControl -> settingsRepo.updateRadioControlSettings(action.settings)
@@ -184,23 +186,9 @@ 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(

gradle.properties

@@ -3,3 +3,6 @@ org.gradle.caching=true
 org.gradle.jvmargs=-Xmx6g -XX:MaxMetaspaceSize=1g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
 org.gradle.parallel=true
 org.gradle.workers.max=4
+
+# Enabled parallel sync for Gradle 9.4+
+org.gradle.tooling.parallel=true

gradle/libs.versions.toml

@@ -10,22 +10,22 @@ minSdk = "24"
 #noinspection UnusedVersionCatalogEntry
 jdkVersion = "21"
 #noinspection UnusedVersionCatalogEntry
-packageName = "com.rtbishop.look4sat"
+packageName = "cn.bh2vsq.look4sat"
 
-android-gradle-plugin = "9.3.1"
+android-gradle-plugin = "9.2.1"
 
 androidx-core-ktx = "1.19.0"
 androidx-core-splashscreen = "1.2.0"
 androidx-room = "2.8.4"
 
-compose-bom = "2026.06.01"
+compose-bom = "2026.06.00"
 compose-activity = "1.13.0"
 compose-lifecycle = "2.11.0"
-compose-navigation3 = "1.1.5"
+compose-navigation3 = "1.1.3"
 
 google-ksp = "2.3.8"
 
-kotlin = "2.4.10"
+kotlin = "2.4.0"
 kotlin-coroutines = "1.11.0"
 kotlin-serialization = "1.11.0"
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,7 @@
 #Sat Jun 27 12:51:12 BST 2026
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.1-bin.zip
+distributionUrl=https\://mirrors.aliyun.com/gradle/distributions/v9.6.1/gradle-9.6.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

settings.gradle.kts

@@ -22,7 +22,6 @@ include(
 )
 include(
     ":feature:map",
-    ":feature:mutual",
     ":feature:passes",
     ":feature:radar",
     ":feature:satellites",