fix(settings): drag-reorder tracks live position; grip becomes a single dot

Two drag issues from user testing:
1. Only adjacent swaps worked - the drag gesture could not move an
   item past multiple positions. Root cause: the pointerInput closure
   kept the index captured at composition; after the live swap
   (items.add(target, removeAt(index))) the closure's index was
   stale, so subsequent targets were computed from the wrong origin
   and the saved order got corrupted (also made previously moved
   items snap back).
   Fix: track the dragged item's live position via draggingIndex -
   onDragStart resolves it with items.indexOf(screen), onDrag computes
   the target from draggingIndex and updates it after each swap.
2. The six-dot grip icon was ugly; replaced with a single 8dp themed
   dot (Box + CircleShape inside the 48dp touch area, onSurfaceVariant
   color). ic_drag.xml removed.

What's-new rewritten in en/zh/tr with ONLY this release's changes
(user rule: replace, never append history). Version stays 4.4.9
(覆盖 per user). Verified: settings + app compile, check_strings.py
clean.

.github/workflows/release.yml

@@ -4,10 +4,15 @@ on:
   push:
     tags:
       - v**
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'Release tag name (e.g. v4.4.3)'
+        required: false
+        default: ''
 
 env:
-  TAG_NAME: ${{ github.ref_name }}
-  GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+  TAG_NAME: ${{ github.event.inputs.tag_name || github.ref_name }}
 
 jobs:
   release:
@@ -16,66 +21,40 @@ jobs:
       contents: write
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v4
 
       - name: Setup Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6
+        uses: gradle/actions/setup-gradle@v4
 
-      - name: Assemble Artifacts
-        run: ./gradlew assembleRelease bundleRelease
+      - name: Assemble APK
+        run: ./gradlew assembleRelease
 
       - name: Sign APK
         run: |
           echo "${{ secrets.KEY_STORE }}" | base64 -d > keystore.jks
           APK=$(find app/build/outputs/apk/release -name "*.apk" | head -1)
+          VERSION=${TAG_NAME#v}
+          SIGNED_APK="app/build/outputs/apk/release/Look4Sat-Pro-${VERSION}.apk"
           BUILD_TOOLS=$(ls -d ${ANDROID_HOME}/build-tools/*/ | sort -V | tail -1)
           ${BUILD_TOOLS}apksigner sign \
             --ks keystore.jks \
             --ks-pass pass:${{ secrets.KEY_STORE_PASSWORD }} \
             --ks-key-alias ${{ secrets.KEY_ALIAS }} \
             --key-pass pass:${{ secrets.KEY_PASSWORD }} \
-            --out app/build/outputs/apk/release/look4sat.apk \
+            --out "$SIGNED_APK" \
             "$APK"
           rm keystore.jks
-
-      - name: Sign Bundle
-        run: |
-          echo "${{ secrets.KEY_STORE }}" | base64 -d > keystore.jks
-          AAB=$(find app/build/outputs/bundle/release -name "*.aab" | head -1)
-          jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256 \
-            -keystore keystore.jks \
-            -storepass ${{ secrets.KEY_STORE_PASSWORD }} \
-            -keypass ${{ secrets.KEY_PASSWORD }} \
-            "$AAB" ${{ secrets.KEY_ALIAS }}
-          rm keystore.jks
-
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: '3.4'
-
-      - name: Deploy Bundle to Google Play
-        run: |
-          gem install multi_json
-          gem install fastlane --no-document
-          AAB=$(find app/build/outputs/bundle/release -name "*.aab" | head -1)
-          echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
-          fastlane supply \
-            --aab "$AAB" \
-            --json_key service_account.json \
-            --package_name com.rtbishop.look4sat \
-            --track production \
-            --skip_upload_images true \
-            --skip_upload_screenshots true \
-          rm service_account.json
+          echo "SIGNED_APK=$SIGNED_APK" >> "$GITHUB_ENV"
 
       - name: Create Release
+        env:
+          GH_TOKEN: ${{ github.token }}
         run: |
           gh release create $TAG_NAME --title=$TAG_NAME --generate-notes
-          gh release upload $TAG_NAME app/build/outputs/apk/release/look4sat.apk
+          gh release upload $TAG_NAME "$SIGNED_APK"

.gitignore

@@ -1,6 +1,9 @@
 # Built application files
 *.ap_
 
+# Hermes AI plans and metadata
+.hermes/
+
 # Files for the ART/Dalvik VM
 *.dex
 
@@ -36,8 +39,7 @@ captures/
 .idea/
 
 # Keystore files
-# Uncomment the following line if you do not want to check your keystore files in.
-#*.jks
+*.jks
 /*.properties
 /keystore.properties
 /app/keystore.jks

app/build.gradle.kts

@@ -1,3 +1,29 @@
+import java.util.Properties
+
 plugins {
     alias(libs.plugins.convention.applicationPlugin)
 }
+
+// Load signing config from keystore.properties (gitignored, never commit credentials)
+val keystoreProperties = Properties().apply {
+    val propsFile = rootProject.file("keystore.properties")
+    if (propsFile.exists()) propsFile.inputStream().use { load(it) }
+}
+
+android {
+    signingConfigs {
+        if (keystoreProperties["storeFile"] != null) {
+            create("release") {
+                storeFile = rootProject.file(keystoreProperties["storeFile"] as String)
+                storePassword = keystoreProperties["storePassword"] as String
+                keyAlias = keystoreProperties["keyAlias"] as String
+                keyPassword = keystoreProperties["keyPassword"] as String
+            }
+        }
+    }
+    buildTypes {
+        release {
+            signingConfig = signingConfigs.findByName("release")
+        }
+    }
+}

app/src/main/AndroidManifest.xml

@@ -25,6 +25,7 @@
         <activity
             android:name=".MainActivity"
             android:exported="true"
+            android:screenOrientation="portrait"
             android:theme="@style/Theme.Look4Sat.SplashScreen">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
@@ -42,7 +43,7 @@
 
         <meta-data
             android:name="android.telephony.PROPERTY_SATELLITE_DATA_OPTIMIZED"
-            android:value="com.rtbishop.look4sat" />
+            android:value="com.rtbishop.look4sat.bg7nta" />
 
     </application>
 </manifest>

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

@@ -63,13 +63,16 @@ 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
@@ -78,8 +81,11 @@ 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.roaming.RoamingScreen
 import com.rtbishop.look4sat.feature.satellites.SatellitesDestination
 import com.rtbishop.look4sat.feature.settings.SettingsDestination
 
@@ -125,12 +131,22 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
     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()
     val otherSettings by container.settingsRepo.otherSettings.collectAsStateWithLifecycle()
+    // UI 设置: 按 screenOrder 排序(空 = 默认顺序), 再按 hiddenScreens 过滤(设置页固定保留)
+    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Mutual, Screen.Roaming, Screen.Map, Screen.Settings)
+        .sortedBy { screen ->
+            val idx = otherSettings.screenOrder.indexOf(screen.screenId)
+            if (idx == -1) Int.MAX_VALUE else idx
+        }
+        .filter { it.screenId !in otherSettings.hiddenScreens || it is Screen.Settings }
+    // 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(
@@ -145,6 +161,7 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                         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
@@ -190,6 +207,7 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                         }
                         entry<Screen.Passes> {
                             PassesDestination { catNum, aosTime ->
+                                container.setMutualPassData(MutualPassData())
                                 container.satelliteRepo.selectPass(catNum, aosTime)
                                 backStack.add(Screen.Radar)
 //                            navigateToRadar()
@@ -201,6 +219,20 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                         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.Roaming> {
+                            RoamingScreen()
+                        }
                         entry<Screen.Settings> {
                             SettingsDestination()
                         }
@@ -224,6 +256,7 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                             .clickable {
                                 val pass = trackingState.currentPass
                                 if (pass != null) {
+                                    container.setMutualPassData(MutualPassData())
                                     container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
                                     backStack.add(Screen.Radar)
                                 }

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

@@ -32,8 +32,10 @@ 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:roaming"))
             implementation(project(":feature:satellites"))
             implementation(project(":feature:settings"))
             implementation(libs.androidx.core.splashscreen)

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

@@ -57,7 +57,7 @@ internal fun Project.setupAndroidApp() {
         namespace = libs.versions.packageName.get()
         compileSdk = libs.versions.compileSdk.get().toInt()
         defaultConfig {
-            applicationId = libs.versions.packageName.get()
+            applicationId = libs.versions.applicationId.get()
             minSdk = libs.versions.minSdk.get().toInt()
             versionCode = libs.versions.appVersionCode.get().toInt()
             versionName = libs.versions.appVersionName.get()

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

@@ -50,6 +50,7 @@ import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
 import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
@@ -61,6 +62,9 @@ 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 {
@@ -77,6 +81,13 @@ 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)

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

@@ -69,11 +69,14 @@ class DatabaseRepo(
         val dataSourcesSettings = settingsRepo.dataSourcesSettings.value
         val tleUrls = buildMap {
             putAll(Sources.satelliteDataUrls)
-            if (dataSourcesSettings.useCustomTLE) put(customSourceType, dataSourcesSettings.tleUrl)
+            // 开关开且 URL 非空 -> All 用自定义 URL;否则用默认 URL(在线更新默认源)
+            put("All", if (dataSourcesSettings.useCustomTLE && dataSourcesSettings.tleUrl.isNotBlank())
+                dataSourcesSettings.tleUrl else Sources.defaultTleUrl)
         }.filterValues { it.isNotBlank() }
         val radioUrls = buildMap {
             putAll(Sources.transceiversDataUrls)
-            if (dataSourcesSettings.useCustomTransceivers) put(customSourceType, dataSourcesSettings.transceiversUrl)
+            put("SatNOGS", if (dataSourcesSettings.useCustomTransceivers && dataSourcesSettings.transceiversUrl.isNotBlank())
+                dataSourcesSettings.transceiversUrl else Sources.defaultTransceiversUrl)
         }.filterValues { it.isNotBlank() }
         // launch all network requests concurrently
         val tleJobs = tleUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }

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

@@ -95,14 +95,8 @@ class SatelliteRepo(
         }
     }
 
-    override suspend fun getRadios(
-        sat: OrbitalObject,
-        pos: GeoPos,
-        radios: List<SatRadio>,
-        time: Long
-    ): List<SatRadio> {
+    override suspend fun getRadios(satPos: OrbitalPos, radios: List<SatRadio>): List<SatRadio> {
         return withContext(dispatcher) {
-            val satPos = sat.getPosition(pos, time)
             radios.map { transmitter ->
                 transmitter.copy(
                     downlinkLow = transmitter.downlinkLow?.let { satPos.getDownlinkFreq(it) },
@@ -242,13 +236,16 @@ class SatelliteRepo(
             if (elevation > maxElevation) maxElevation = elevation
         } while (elevation < 0.0)
 
-        // refine AOS to ~500ms precision
-        calendarTimeMillis -= 60L * 1000L
-        do {
-            calendarTimeMillis += 500L
-            elevation = sat.getElevation(pos, calendarTimeMillis)
-            if (elevation > maxElevation) maxElevation = elevation
-        } while (elevation < 0.0)
+        // refine AOS to ~500ms precision via binary search.
+        // Elevation is monotonic across the horizon crossing, so binary search
+        // finds the crossing in ~8 SGP4 calls instead of up to 120 linear steps.
+        var aosLo = calendarTimeMillis - 60L * 1000L // elevation < 0 (below horizon)
+        var aosHi = calendarTimeMillis // elevation >= 0 (above horizon)
+        while (aosHi - aosLo > 500L) {
+            val mid = (aosLo + aosHi) / 2
+            if (sat.getElevation(pos, mid) < 0.0) aosLo = mid else aosHi = mid
+        }
+        calendarTimeMillis = aosHi
 
         // Get full position for AOS data (azimuth, altitude)
         val aosPos = sat.getFullPosition(pos, calendarTimeMillis)
@@ -262,13 +259,14 @@ class SatelliteRepo(
             if (elevation > maxElevation) maxElevation = elevation
         } while (elevation > 0.0)
 
-        // refine LOS to ~500ms precision
-        calendarTimeMillis -= 30L * 1000L
-        do {
-            calendarTimeMillis += 500L
-            elevation = sat.getElevation(pos, calendarTimeMillis)
-            if (elevation > maxElevation) maxElevation = elevation
-        } while (elevation > 0.0)
+        // refine LOS to ~500ms precision via binary search (same monotonic argument)
+        var losLo = calendarTimeMillis - 30L * 1000L // elevation > 0 (above horizon)
+        var losHi = calendarTimeMillis // elevation <= 0 (below horizon)
+        while (losHi - losLo > 500L) {
+            val mid = (losLo + losHi) / 2
+            if (sat.getElevation(pos, mid) > 0.0) losLo = mid else losHi = mid
+        }
+        calendarTimeMillis = losHi
 
         // Get full position for LOS data (azimuth, altitude)
         val losPos = sat.getFullPosition(pos, calendarTimeMillis)

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

@@ -29,6 +29,7 @@ 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.source.Sources
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
@@ -76,6 +77,8 @@ class SettingsRepo(
     private val keyStateOfUtc = "stateOfUtc"
     private val keyStateOfLightTheme = "stateOfLightTheme"
     private val keyStateOfNightMode = "stateOfNightMode"
+    private val keyHiddenScreens = "hiddenScreens"
+    private val keyScreenOrder = "screenOrder"
     private val keyStationAltitude = "stationAltitude"
     private val keyStationLatitude = "stationLatitude"
     private val keyStationLongitude = "stationLongitude"
@@ -213,8 +216,8 @@ class SettingsRepo(
     }
 
     private fun setStationPosition(latitude: Double, longitude: Double, altitude: Double, locator: String) {
-        val newLat = latitude.round(4)
-        val newLon = longitude.round(4)
+        val newLat = latitude.round(5)
+        val newLon = longitude.round(5)
         val newAlt = altitude.round(1)
         val timestamp = System.currentTimeMillis()
         println("Received new Position($newLat, $newLon, $newAlt) & Locator $locator")
@@ -356,6 +359,8 @@ class SettingsRepo(
                 putString(keySstvMode, new.sstvMode)
                 putLong(keyLowElevation, new.lowElevation.toRawBits())
                 putLong(keyHighElevation, new.highElevation.toRawBits())
+                putStringSet(keyHiddenScreens, new.hiddenScreens.toSet())
+                putString(keyScreenOrder, new.screenOrder.joinToString(","))
             }
             new
         }
@@ -371,6 +376,8 @@ class SettingsRepo(
         shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
         shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
         sstvMode = preferences.getString(keySstvMode, null) ?: "Auto",
+        hiddenScreens = preferences.getStringSet(keyHiddenScreens, emptySet())?.toList() ?: emptyList(),
+        screenOrder = preferences.getString(keyScreenOrder, null)?.split(",")?.filter { it.isNotBlank() } ?: emptyList(),
         lowElevation = Double.fromBits(preferences.getLong(keyLowElevation, 15.0.toRawBits())),
         highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits()))
     )
@@ -390,12 +397,20 @@ class SettingsRepo(
         _dataSourcesSettings.value = settings
     }
 
-    private fun getDataSourcesSettings(): DataSourcesSettings = DataSourcesSettings(
-        useCustomTLE = preferences.getBoolean(keyUseCustomTle, false),
-        useCustomTransceivers = preferences.getBoolean(keyUseCustomTransceivers, false),
-        tleUrl = preferences.getString(keyTleUrl, "https://example.com/tle.txt") ?: "",
-        transceiversUrl = preferences.getString(keyTransceiversUrl, "https://example.com/radio.json") ?: ""
-    )
+    private fun getDataSourcesSettings(): DataSourcesSettings {
+        // 4.4.8 修复: 旧版 example.com 占位 URL 视为未配置 -> 替换为真实默认 URL 且开关强制关闭,
+        // 否则在线更新的 All/SatNOGS 源会指向错误地址导致更新失败
+        val storedTleUrl = preferences.getString(keyTleUrl, Sources.defaultTleUrl) ?: Sources.defaultTleUrl
+        val storedTxUrl = preferences.getString(keyTransceiversUrl, Sources.defaultTransceiversUrl) ?: Sources.defaultTransceiversUrl
+        val tleUrl = if (storedTleUrl == "https://example.com/tle.txt") Sources.defaultTleUrl else storedTleUrl
+        val txUrl = if (storedTxUrl == "https://example.com/radio.json") Sources.defaultTransceiversUrl else storedTxUrl
+        return DataSourcesSettings(
+            useCustomTLE = preferences.getBoolean(keyUseCustomTle, false) && tleUrl != Sources.defaultTleUrl,
+            useCustomTransceivers = preferences.getBoolean(keyUseCustomTransceivers, false) && txUrl != Sources.defaultTransceiversUrl,
+            tleUrl = tleUrl,
+            transceiversUrl = txUrl
+        )
+    }
     //endregion
 
     //region # Radio control settings

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

@@ -102,7 +102,8 @@ class DatabaseRepoTest {
         repository.updateFromRemote()
 
         assertTrue(localSource.insertedEntries.any { it.catnum == 25544 })
-        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
+        // 新语义: 开关开 + URL 非空 -> All 源用自定义 URL, 数据归入 All 类型
+        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["All"])
     }
 
     private fun validCsvStream(): InputStream = """

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

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

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

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

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

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

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

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

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

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

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

@@ -62,7 +62,11 @@ data class OtherSettings(
     val shouldSeeWhatsNew: Boolean,
     val sstvMode: String = "Auto",
     val lowElevation: Double = 15.0,
-    val highElevation: Double = 45.0
+    val highElevation: Double = 45.0,
+    // UI 设置: 底部导航栏隐藏的页面(Screen simpleName 列表, 默认空 = 全部显示)
+    val hiddenScreens: List<String> = emptyList(),
+    // UI 设置: 页面顺序(空 = 默认顺序: 卫星/过境/雷达/匹配/漫游/地图/设置)
+    val screenOrder: List<String> = emptyList()
 )
 
 data class DataSourcesSettings(

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

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

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

@@ -61,7 +61,7 @@ interface ISatelliteRepo {
     suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos>
 
     /** Get Doppler-shifted radio frequencies for a satellite at the given time. */
-    suspend fun getRadios(sat: OrbitalObject, pos: GeoPos, radios: List<SatRadio>, time: Long): List<SatRadio>
+    suspend fun getRadios(satPos: OrbitalPos, radios: List<SatRadio>): List<SatRadio>
 
     /** Fetch radio transceivers for a satellite by its catalog number. */
     suspend fun getRadiosWithId(id: Int): List<SatRadio>

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

@@ -18,6 +18,10 @@
 package com.rtbishop.look4sat.core.domain.source
 
 object Sources {
+    // 在线更新的默认 URL(用户可通过"自定义URL"对话框修改/重置)
+    val defaultTleUrl = "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv"
+    val defaultTransceiversUrl = "https://db.satnogs.org/api/transmitters/?format=json&status=active"
+
     val satelliteDataUrls = mapOf(
         "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
         "Amateur" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=csv",

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

@@ -0,0 +1,98 @@
+/* 
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+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/main/java/com/rtbishop/look4sat/core/domain/utility/QthConverter.kt

@@ -19,31 +19,78 @@ package com.rtbishop.look4sat.core.domain.utility
 
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 
+/**
+ * Converts a Maidenhead locator (QTH grid square) to a GeoPos.
+ * Supports 6-char (3 pair), 8-char (4 pair) and 10-char (5 pair) locators.
+ * The returned position is the center of the finest cell encoded by the locator:
+ *  - 6 char: 5' lon x 2.5' lat cell center
+ *  - 8 char: 30" lon x 15" lat cell center
+ *  - 10 char: 1.25" lon x 0.625" lat cell center
+ */
 fun qthToPosition(locator: String): GeoPos? {
-    val trimmedQth = locator.take(6)
+    val trimmedQth = locator.trim().uppercase()
     if (!isValidLocator(trimmedQth)) return null
-    val lonFirst = (trimmedQth[0].uppercaseChar().code - 65) * 20
-    val latFirst = (trimmedQth[1].uppercaseChar().code - 65) * 10
+    val lonFirst = (trimmedQth[0].code - 65) * 20
+    val latFirst = (trimmedQth[1].code - 65) * 10
     val lonSecond = trimmedQth[2].toString().toInt() * 2
     val latSecond = trimmedQth[3].toString().toInt()
-    val lonThird = (((trimmedQth[4].lowercaseChar().code - 97) / 12.0) + (1.0 / 24.0)) - 180
-    val latThird = (((trimmedQth[5].lowercaseChar().code - 97) / 24.0) + (1.0 / 48.0)) - 90
-    val longitude = (lonFirst + lonSecond + lonThird).round(4)
-    val latitude = (latFirst + latSecond + latThird).round(4)
-    return GeoPos(latitude, longitude)
+    val lonThird = (trimmedQth[4].lowercaseChar().code - 97) / 12.0
+    val latThird = (trimmedQth[5].lowercaseChar().code - 97) / 24.0
+    var longitude = lonFirst + lonSecond + lonThird - 180
+    var latitude = latFirst + latSecond + latThird - 90
+    // 8-char extension: 4th pair, digits, 30" lon x 15" lat cells
+    if (trimmedQth.length >= 8) {
+        longitude += trimmedQth[6].toString().toInt() / 120.0
+        latitude += trimmedQth[7].toString().toInt() / 240.0
+    }
+    // 10-char extension: 5th pair, letters, 1.25" lon x 0.625" lat cells
+    if (trimmedQth.length >= 10) {
+        longitude += (trimmedQth[8].lowercaseChar().code - 97) / 2880.0
+        latitude += (trimmedQth[9].lowercaseChar().code - 97) / 5760.0
+    }
+    // Offset to the center of the finest encoded cell
+    when (trimmedQth.length) {
+        8 -> {
+            longitude += 1.0 / 240.0
+            latitude += 1.0 / 480.0
+        }
+        10 -> {
+            longitude += 1.0 / 5760.0
+            latitude += 1.0 / 11520.0
+        }
+        else -> {
+            longitude += 1.0 / 24.0
+            latitude += 1.0 / 48.0
+        }
+    }
+    return GeoPos(latitude.round(6), longitude.round(6))
 }
 
-fun positionToQth(latitude: Double, longitude: Double): String? {
+/**
+ * Converts a GeoPos to a Maidenhead locator (QTH grid square).
+ * Default precision is 8 characters (4 pairs) giving 30" lon x 15" lat resolution,
+ * matching common 8-char grid square tools. Pass precision = 6 for the classic
+ * 5' x 2.5' resolution, or precision = 10 for the finest 1.25" x 0.625" resolution.
+ */
+fun positionToQth(latitude: Double, longitude: Double, precision: Int = 8): String? {
     if (!isValidPosition(latitude, longitude)) return null
-    val newLongitude = if (longitude > 180.0) longitude else longitude + 180
+    val newLongitude = longitude + 180
     val newLatitude = latitude + 90
-    val lonFirst = (65 + (newLongitude / 20)).toInt().toChar()
-    val latFirst = (65 + (newLatitude / 10)).toInt().toChar()
-    val lonSecond = ((newLongitude / 2) % 10).toInt()
+    val lonFirst = (65 + (newLongitude / 20).toInt().coerceIn(0, 17)).toChar()
+    val latFirst = (65 + (newLatitude / 10).toInt().coerceIn(0, 17)).toChar()
+    val lonSecond = ((newLongitude % 20) / 2).toInt()
     val latSecond = (newLatitude % 10).toInt()
     val lonThird = (65 + (newLongitude % 2) * 12).toInt().toChar().lowercaseChar()
     val latThird = (65 + (newLatitude % 1) * 24).toInt().toChar().lowercaseChar()
-    return "$lonFirst$latFirst$lonSecond$latSecond$lonThird$latThird"
+    val qth = "$lonFirst$latFirst$lonSecond$latSecond$lonThird$latThird"
+    if (precision < 8) return qth
+    val lonFourth = ((newLongitude % (1.0 / 12.0)) * 120).toInt()
+    val latFourth = ((newLatitude % (1.0 / 24.0)) * 240).toInt()
+    val qth8 = "$qth$lonFourth$latFourth"
+    if (precision < 10) return qth8
+    val lonFifth = (65 + (newLongitude % (1.0 / 120.0)) * 2880).toInt().toChar().lowercaseChar()
+    val latFifth = (65 + (newLatitude % (1.0 / 240.0)) * 5760).toInt().toChar().lowercaseChar()
+    return "$qth8$lonFifth$latFifth"
 }
 
 private fun isValidPosition(lat: Double, lon: Double): Boolean {
@@ -51,5 +98,49 @@ private fun isValidPosition(lat: Double, lon: Double): Boolean {
 }
 
 private fun isValidLocator(locator: String): Boolean {
-    return locator.matches("[a-xA-X][a-xA-X]\\d\\d[a-xA-X][a-xA-X]".toRegex())
+    return locator.matches("[a-xA-X]{2}\\d{2}[a-xA-X]{2}(?:\\d{2}(?:[a-xA-X]{2})?)?".toRegex())
 }
+
+/**
+ * Returns the 4-char field+square part of a locator, e.g. "OL42ih45" -> "OL42".
+ * A 4-char input is returned as-is when valid.
+ */
+fun qthToSquare(locator: String): String {
+    val upper = locator.trim().uppercase()
+    return when {
+        upper.length >= 4 && isValidLocator(upper) -> upper.take(4)
+        upper.length == 4 && upper.matches("[a-xA-X]{2}\\d{2}".toRegex()) -> upper
+        else -> "----"
+    }
+}
+
+/**
+ * Builds the 3x3 grid of 4-char squares surrounding [square] (e.g. "OL42").
+ * Row 0 = north (lat +1), col 0 = west (lon -1). Handles field/square carry
+ * at boundaries (e.g. "AA00" wraps to "RR99" at the south-west corner).
+ * Mirrors the neighbor logic decompiled from the QTH定位器 app.
+ */
+fun qthNeighbors(square: String): List<String> {
+    if (square.length != 4) return emptyList()
+    val lonField = (square[0].uppercaseChar().code - 65).coerceIn(0, 17)
+    val latField = (square[1].uppercaseChar().code - 65).coerceIn(0, 17)
+    val lonSquare = square[2].digitToCharOrNull() ?: return emptyList()
+    val latSquare = square[3].digitToCharOrNull() ?: return emptyList()
+    val result = mutableListOf<String>()
+    for (dLat in 1 downTo -1) {          // north -> south
+        for (dLon in -1..1) {            // west -> east
+            var lf = lonField
+            var tf = latField
+            var ls = lonSquare + dLon
+            var ts = latSquare + dLat
+            if (ls < 0) { lf -= 1; ls = 9 } else if (ls > 9) { lf += 1; ls = 0 }
+            if (ts < 0) { tf -= 1; ts = 9 } else if (ts > 9) { tf += 1; ts = 0 }
+            lf = (lf + 18) % 18
+            tf = (tf + 18) % 18
+            result += "${('A' + lf).toChar()}${('A' + tf).toChar()}$ls$ts"
+        }
+    }
+    return result
+}
+
+private fun Char.digitToCharOrNull(): Int? = digitToIntOrNull()

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

@@ -0,0 +1,120 @@
+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/QthConverterTest.kt

@@ -18,7 +18,9 @@
 package com.rtbishop.look4sat.core.domain
 
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
+import com.rtbishop.look4sat.core.domain.utility.qthNeighbors
 import com.rtbishop.look4sat.core.domain.utility.qthToPosition
+import com.rtbishop.look4sat.core.domain.utility.qthToSquare
 import org.junit.Test
 
 class QthConverterTest {
@@ -26,21 +28,36 @@ class QthConverterTest {
     @Test
     fun `Given valid QTH returns correct POS`() {
         var result = qthToPosition("io91VL39FX")
-        assert(result?.latitude == 51.4792 && result.longitude == -0.2083)
+        assert(result?.latitude == 51.499913 && result.longitude == -0.22309)
         result = qthToPosition("gf15vc")
-        assert(result?.latitude == -34.8958 && result.longitude == -56.2083)
+        assert(result?.latitude == -34.895833 && result.longitude == -56.208333)
+        // 8-char locators: finer 30" x 15" cell center
+        result = qthToPosition("io91vl47")
+        assert(result?.latitude == 51.489583 && result.longitude == -0.2125)
+        result = qthToPosition("jn58td25")
+        assert(result?.latitude == 48.147917 && result.longitude == 11.604167)
     }
 
     @Test
     fun `Given invalid QTH returns null`() {
         assert(qthToPosition("ZZ00zz") == null)
         assert(qthToPosition("JN58") == null)
+        assert(qthToPosition("io9") == null)
+        assert(qthToPosition("IO91VL7") == null)
+        assert(qthToPosition("IO91VL4X") == null)
     }
 
     @Test
     fun `Given valid POS returns correct QTH`() {
-        assert(positionToQth(51.4878, -0.2146) == "IO91vl")
-        assert(positionToQth(48.1466, 11.6083) == "JN58td")
+        // default precision is 8 chars
+        assert(positionToQth(51.4878, -0.2146) == "IO91vl47")
+        assert(positionToQth(48.1466, 11.6083) == "JN58td25")
+        // 6-char precision still available for backwards compatibility
+        assert(positionToQth(51.4878, -0.2146, 6) == "IO91vl")
+        assert(positionToQth(48.1466, 11.6083, 6) == "JN58td")
+        // 10-char precision
+        assert(positionToQth(51.4878, -0.2146, 10) == "IO91vl47fb")
+        assert(positionToQth(48.1466, 11.6083, 10) == "JN58td25xe")
     }
 
     @Test
@@ -48,4 +65,61 @@ class QthConverterTest {
         assert(positionToQth(91.0542, -170.1142) == null)
         assert(positionToQth(89.0542, -240.1142) == null)
     }
+
+    @Test
+    fun `Given boundary POS stays in valid grid`() {
+        // antipodal / edge cases must not overflow the A-R / 0-9 / a-x alphabet
+        assert(positionToQth(-90.0, -180.0, 8) == "AA00aa00")
+        assert(positionToQth(90.0, 180.0, 8) == "RR00aa00")
+        assert(positionToQth(0.0, 0.0, 8) == "JJ00aa00")
+        // roundtrip stability: 8-char roundtrip is stable across a sample of positions
+        val positions = listOf(
+            Pair(51.4878, -0.2146), Pair(48.1466, 11.6083), Pair(-33.8688, 151.2093),
+            Pair(39.9042, 116.4074), Pair(35.6895, 139.6917), Pair(41.714, -72.727)
+        )
+        positions.forEach { (lat, lon) ->
+            val qth = positionToQth(lat, lon, 8)
+            val pos = qthToPosition(qth!!)
+            val qth2 = positionToQth(pos!!.latitude, pos.longitude, 8)
+            assert(qth == qth2) { "Roundtrip failed for ($lat, $lon): $qth -> $qth2" }
+        }
+    }
+
+    @Test
+    fun `Given square returns correct 3x3 neighbors`() {
+        // Reference grid from the QTH定位器 screenshot: OL42
+        val neighbors = qthNeighbors("OL42")
+        assert(neighbors == listOf(
+            "OL33", "OL43", "OL53",
+            "OL32", "OL42", "OL52",
+            "OL31", "OL41", "OL51"
+        )) { "OL42 grid mismatch: $neighbors" }
+        // Center cell must be the input itself
+        assert(neighbors[4] == "OL42")
+        // 9 cells, all distinct
+        assert(neighbors.size == 9 && neighbors.toSet().size == 9)
+    }
+
+    @Test
+    fun `Given boundary square wraps fields correctly`() {
+        // South-west corner: AA00 neighbors wrap to RR99 / RA90 etc.
+        val sw = qthNeighbors("AA00")
+        assert(sw.size == 9 && sw.toSet().size == 9)
+        assert(sw[0] == "RA91" && sw[4] == "AA00" && sw[6] == "RR99" && sw[8] == "AR19")
+        // North-east corner: RR99 wraps to AA00
+        val ne = qthNeighbors("RR99")
+        assert(ne.size == 9 && ne.toSet().size == 9)
+        assert(ne[0] == "RA80" && ne[4] == "RR99" && ne[8] == "AR08")
+        // Field boundary: IO91's east neighbors cross into J field
+        val london = qthNeighbors("IO91")
+        assert(london[2] == "JO02" && london[5] == "JO01")
+    }
+
+    @Test
+    fun `Given full locator returns square part`() {
+        assert(qthToSquare("OL42ih45") == "OL42")
+        assert(qthToSquare("io91VL39FX") == "IO91")
+        assert(qthToSquare("JN58") == "JN58")
+        assert(qthToSquare("garbage!!") == "----")
+    }
 }

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/cw/CwDecoderTest.kt

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

@@ -157,16 +157,13 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
                 .padding(start = 6.dp, top = 1.dp, end = 6.dp, bottom = 0.dp)
         ) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "${stringResource(R.string.pass_satId, pass.catNum)} - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
                 Text(
                     text = pass.name,
                     modifier = Modifier
                         .weight(1f)
                         .padding(end = 6.dp)
                         .infiniteMarquee(),
+                    color = MaterialTheme.colorScheme.primary,
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis

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

@@ -21,24 +21,33 @@ import androidx.navigation3.runtime.NavKey
 import kotlinx.serialization.Serializable
 
 @Serializable
-sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
+sealed class Screen(val iconResId: Int, val titleResId: Int, val screenId: String) : NavKey {
 
     @Serializable
-    data object Satellites : Screen(R.drawable.ic_satellites, R.string.nav_sat)
+    data object Satellites : Screen(R.drawable.ic_satellites, R.string.nav_sat, "Satellites")
 
     @Serializable
-    data object Passes : Screen(R.drawable.ic_passes, R.string.nav_pass)
+    data object Passes : Screen(R.drawable.ic_passes, R.string.nav_pass, "Passes")
 
     @Serializable
-    data object Radar : Screen(R.drawable.ic_radar, R.string.nav_radar)
+    data object Radar : Screen(R.drawable.ic_radar, R.string.nav_radar, "Radar")
 
     @Serializable
-    data object Map : Screen(R.drawable.ic_map, R.string.nav_map)
+    data object Map : Screen(R.drawable.ic_map, R.string.nav_map, "Map")
 
     @Serializable
-    data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs)
+    data object Mutual : Screen(R.drawable.ic_match, R.string.nav_mutual, "Mutual")
+
+    @Serializable
+    data object Roaming : Screen(R.drawable.ic_roaming, R.string.nav_roaming, "Roaming")
+
+    @Serializable
+    data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs, "Settings")
 }
 
+// UI 设置: 默认页面顺序(与 MainScreen navItems 一致)
+val defaultScreenOrder = listOf("Satellites", "Passes", "Radar", "Mutual", "Roaming", "Map", "Settings")
+
 @Serializable
 data object RadarDestination : NavKey
 

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

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

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

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M12,6v3l4,-4 -4,-4v3c-4.42,0 -8,3.58 -8,8 0,1.57 0.46,3.03 1.24,4.26L6.7,14.8c-0.45,-0.83 -0.7,-1.79 -0.7,-2.8 0,-3.31 2.69,-6 6,-6zM18.76,7.74L17.3,9.2c0.44,0.84 0.7,1.79 0.7,2.8 0,3.31 -2.69,6 -6,6v-3l-4,4 4,4v-3c4.42,0 8,-3.58 8,-8 0,-1.57 -0.46,-3.03 -1.24,-4.26z" />
+</vector>

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

@@ -0,0 +1,25 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="96"
+    android:viewportHeight="96">
+
+    <!-- Crosshair / grid-locator style icon: concentric rings + center dot -->
+    <path
+        android:fillColor="@android:color/transparent"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="6"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M 48 12 L 48 84 M 12 48 L 84 48" />
+
+    <path
+        android:fillColor="@android:color/transparent"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="6"
+        android:pathData="M 48 26 A 22 22 0 1 0 48.1 26" />
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M 44 44 L 52 44 L 52 52 L 44 52 Z" />
+</vector>

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

@@ -51,12 +51,8 @@
         \n\nDoğru tahminler alabilmek için veritabanını en az haftada bir güncelleyin.</string>
     <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat</string>
     <string name="pass_whatsnew_message" translatable="false">
-        * Switched to short-form commands in NetworkReporter, by theojalba
-        \n* Added CAT radio control for full-duplex SAT operation, by jcmerg
-        \n* Added normalized time for passes AOS/LOS, fixed refresh state bug
-        \n* Added multiple performance tweaks, improved passes calculation
-        \n* Fixed UTC pass time problem mentioned in issue #201
-    </string>
+        * Ayarlar sayfasında kaydırırken oluşan çökme düzeltildi
+        * Sayfa sırası: tek hareketle birden fazla konum atlanabilir; tutamaç tek nokta oldu</string>
 
     <!-- Radar screen -->
     <string name="radar_back">Geri</string>
@@ -103,7 +99,7 @@
     <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_title" translatable="false">Look4Sat Pro v%s</string>
     <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=com.rtbishop.look4sat</string>
     <string name="prefs_donate_title">Bağış yap</string>
     <string name="prefs_donate_url" translatable="false">https://ko-fi.com/rt_bishop</string>
@@ -137,7 +133,7 @@
     <string name="prefs_data_entries">Uydular: %s</string>
     <string name="prefs_data_radios">Transceiver\'lar: %s</string>
     <string name="prefs_data_update">Güncelle</string>
-    <string name="prefs_data_import">İçe aktar</string>
+    <string name="prefs_data_import">Özel URL</string>
     <string name="prefs_data_clear">Temizle</string>
     <string name="prefs_data_clear_success">Veriler başarıyla temizlendi</string>
     <string name="prefs_data_update_success">Güncelleme başarıyla tamamlandı</string>
@@ -146,6 +142,7 @@
     <string name="prefs_data_sources_tle_switch">Özel TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Özel transceiver URL</string>
     <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
+    <string name="prefs_data_reset_url">Varsayılan URL\'ye sıfırla</string>
 
     <string name="prefs_data_output_title">Veri aktarımı</string>
     <string name="prefs_net_output">Ağ</string>
@@ -181,6 +178,9 @@
     <string name="prefs_net_perm_error">Ağ izninizi kontrol edin</string>
 
     <string name="prefs_other_title">Diğer ayarlar</string>
+    <string name="prefs_ui_title">UI Ayarları</string>
+    <string name="prefs_ui_order_title">Sayfa sırası</string>
+    <string name="prefs_ui_order_reset">Sıralamayı sıfırla</string>
     <string name="prefs_other_switch_utc">Geçiş saatini UTC olarak göster</string>
     <string name="prefs_other_switch_update">Otomatik veri güncellemeyi etkinleştir</string>
     <string name="prefs_other_switch_sweep">Radar taramasını etkinleştir</string>
@@ -192,14 +192,16 @@
     <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_title">BG7NTA ve orijinal yazar teşekkür eder</string>
     <string name="prefs_outro_thanks" translatable="false">
         • Look4Sat users and contributors!
         \n• David A. B. Johnson (predict4java)
         \n• Dave Moten (predict4java)
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)</string>
+        \n• Libre Space Foundation (SatNOGS)
+        \n• BA7OPF (pass matching feature)
+        \n• BG7NTA</string>
     <string name="prefs_outro_license">Bu uygulama herhangi bir garanti sunmaz</string>
 
 </resources>

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

@@ -9,6 +9,8 @@
     <string name="nav_sat">卫星</string>
     <string name="nav_pass">过境</string>
     <string name="nav_radar">雷达</string>
+    <string name="nav_mutual">匹配</string>
+    <string name="nav_roaming">漫游</string>
     <string name="nav_map">地图</string>
     <string name="nav_prefs">设置</string>
 
@@ -37,6 +39,10 @@
     <string name="pass_error_message">没有即将过境的卫星</string>
     <string name="pass_welcome_title">欢迎来到 Look4Sat\!</string>
     <string name="pass_welcome_message">请务必在设置中通过GPS、经纬度或QTH定位您的位置\n建议至少每周更新一次数据库，以确保预测结果的准确性</string>
+    <string name="pass_whatsnew_title">Look4Sat Pro 更新内容</string>
+    <string name="pass_whatsnew_message" translatable="false">
+        * 修复设置页滑动时闪退的问题
+        * 页面顺序：可一次拖动越过多个位置；拖拽手柄改为小圆点</string>
 
     <!-- Radar screen -->
     <string name="radar_back">后退</string>
@@ -57,6 +63,17 @@
     <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>
@@ -98,11 +115,14 @@
     <string name="prefs_data_entries">卫星：%s</string>
     <string name="prefs_data_radios">收发器：%s</string>
     <string name="prefs_data_update">在线更新</string>
-    <string name="prefs_data_import">导入文件</string>
+    <string name="prefs_data_import">自定义URL</string>
     <string name="prefs_data_clear">清空</string>
     <string name="prefs_data_clear_success">数据清空成功</string>
     <string name="prefs_data_update_success">更新成功</string>
 
+    <string name="prefs_data_import_satellites_error">未导入卫星。请选择有效的 TLE/3LE (.txt) 或 OMM (.csv) 文件。</string>
+    <string name="prefs_data_import_transceivers_error">未导入收发器。请选择有效的 SatNOGS (.json) 文件。</string>
+
     <string name="prefs_data_sources_title">自定义数据源</string>
     <string name="prefs_data_sources_tle_switch">自定义TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">自定义收发器URL</string>
@@ -110,6 +130,7 @@
     <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>
@@ -129,7 +150,20 @@
     <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_ui_title">UI设置</string>
+    <string name="prefs_ui_order_title">页面顺序</string>
+    <string name="prefs_ui_order_reset">重置顺序</string>
     <string name="prefs_other_switch_utc">以 UTC 时间显示</string>
     <string name="prefs_other_switch_update">启用卫星数据自动更新</string>
     <string name="prefs_other_switch_sweep">启用雷达扫描动画</string>
@@ -141,14 +175,17 @@
     <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_title">BG7NTA 与原作者感谢：</string>
     <string name="prefs_outro_thanks" translatable="false">
         • Look4Sat 所有用户及贡献者!
         \n• David A. B. Johnson (predict4java)
         \n• Dave Moten (predict4java)
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)</string>
+        \n• Libre Space Foundation (SatNOGS)
+        \n• xdsopl 和 Robot36 贡献者!
+        \n• BA7OPF(过境匹配功能)
+        \n• BG7NTA</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 Pro</string>
     <string name="btn_accept">Accept</string>
     <string name="btn_cancel">Cancel</string>
     <string name="empty_list_message">No data to show</string>
@@ -10,6 +10,8 @@
     <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_roaming">Roaming</string>
     <string name="nav_map">Map</string>
     <string name="nav_prefs">Settings</string>
 
@@ -51,9 +53,8 @@
         \n\nPlease update the database at least weekly to get accurate predictions.</string>
     <string name="pass_whatsnew_title" translatable="false">What\'s new in Look4Sat</string>
     <string name="pass_whatsnew_message" translatable="false">
-        * Added required tweaks to support Android 17 (API 37)
-        \n\n* Added ACCESS_LOCAL_NETWORK permission check to support network data output
-    </string>
+        * Fixed a crash when scrolling the Settings page
+        * Page order: drag a page past multiple positions in one gesture; grip is now a single dot</string>
 
     <!-- Radar screen -->
     <string name="radar_back">Back</string>
@@ -80,6 +81,16 @@
     <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>
@@ -100,7 +111,7 @@
     <string name="map_visible">Visible</string>
 
     <!-- Settings screen -->
-    <string name="prefs_app_title" translatable="false">Look4Sat v%s</string>
+    <string name="prefs_app_title" translatable="false">Look4Sat Pro v%s</string>
     <string name="prefs_app_url" translatable="false">https://play.google.com/store/apps/details?id=com.rtbishop.look4sat</string>
     <string name="prefs_donate_title">Donate</string>
     <string name="prefs_donate_url" translatable="false">https://ko-fi.com/rt_bishop</string>
@@ -134,7 +145,7 @@
     <string name="prefs_data_entries">Satellites: %s</string>
     <string name="prefs_data_radios">Transceivers: %s</string>
     <string name="prefs_data_update">Update</string>
-    <string name="prefs_data_import">Import</string>
+    <string name="prefs_data_import">Custom URL</string>
     <string name="prefs_data_clear">Clear</string>
     <string name="prefs_data_clear_success">Data was cleared successfully</string>
     <string name="prefs_data_update_success">Update completed successfully</string>
@@ -145,6 +156,7 @@
     <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
     <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
+    <string name="prefs_data_reset_url">Reset to default URL</string>
 
     <string name="prefs_data_output_title">Data output</string>
     <string name="prefs_net_output">Network</string>
@@ -180,6 +192,9 @@
     <string name="prefs_net_perm_error">Check your network permission</string>
 
     <string name="prefs_other_title">Other settings</string>
+    <string name="prefs_ui_title">UI Settings</string>
+    <string name="prefs_ui_order_title">Page order</string>
+    <string name="prefs_ui_order_reset">Reset order</string>
     <string name="prefs_other_switch_utc">Show pass time in UTC</string>
     <string name="prefs_other_switch_update">Enable automatic data update</string>
     <string name="prefs_other_switch_sweep">Enable radar sweep animation</string>
@@ -191,7 +206,7 @@
     <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_title">BG7NTA &amp; the original author would like to thank</string>
     <string name="prefs_outro_thanks" translatable="false">
         * Look4Sat users and contributors!
         \n* David A. B. Johnson (predict4java)
@@ -200,6 +215,8 @@
         \n* Dr T.S. Kelso (Celestrak)
         \n* Libre Space Foundation (SatNOGS)
         \n* xdsopl and Robot36 contributors!
+        \n* BA7OPF (pass matching feature)
+        \n* BG7NTA
     </string>
     <string name="prefs_outro_license">The app comes with no warranty</string>
 

feature/mutual/build.gradle.kts

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

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

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

@@ -0,0 +1,53 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.mutual
+
+/**
+ * A mutual pass where a satellite is visible from two stations simultaneously.
+ *
+ * @param catNum Satellite catalog number
+ * @param name Satellite name
+ * @param startTime Common AOS time (millis)
+ * @param endTime Common LOS time (millis)
+ * @param maxElevationA Peak elevation for station A
+ * @param maxElevationB Peak elevation for station B
+ * @param elevationSamples List of (time, (elevationA, elevationB)) pairs
+ * @param trackSamples List of radar-track samples (azimuth/elevation for both stations, degrees)
+ */
+data class MutualPass(
+    val catNum: Int,
+    val name: String,
+    val startTime: Long,
+    val endTime: Long,
+    val maxElevationA: Double,
+    val maxElevationB: Double,
+    val elevationSamples: List<Pair<Long, Pair<Double, Double>>>,
+    val trackSamples: List<TrackSample> = emptyList()
+)
+
+/**
+ * One radar-track sample: satellite position as seen from both stations.
+ * All angles are in degrees.
+ */
+data class TrackSample(
+    val time: Long,
+    val azimuthA: Double,
+    val elevationA: Double,
+    val azimuthB: Double,
+    val elevationB: Double
+)

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

@@ -0,0 +1,223 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.mutual
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.text.TextMeasurer
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.sin
+
+private const val CIRCLES = 3 // 30°, 60°, 90° rings
+private const val STROKE_WIDTH = 2.5f
+
+/**
+ * Polar radar chart showing the satellite track as seen from both stations
+ * on one plot. Station A is drawn solid, station B dashed.
+ * Controlled: [progress] (0..1) and [onProgressChange] are owned by the parent
+ * so the time cursor can be shared with the elevation curve chart.
+ */
+@Composable
+fun MutualRadarView(
+    trackSamples: List<TrackSample>,
+    progress: Float = 0.5f,
+    labelA: String = "站点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

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

@@ -0,0 +1,560 @@
+/*
+ * 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/PassesScreen.kt

@@ -316,13 +316,12 @@ private fun PassItem(
     isVerticalLayout: Boolean = true,
     isUtc: Boolean = false
 ) {
-    val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
     val horizontalPadding = if (isVerticalLayout) 6.dp else 10.dp
     val timeZone = remember(isUtc) {
         if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
     }
     val sdfTime = remember(isUtc) {
-        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", Locale.getDefault()).also { it.timeZone = timeZone }
     }
     val aosTimeStr = remember(pass.aosTime, isUtc) { sdfTime.format(Date(pass.aosTime)) }
     val losTimeStr = remember(pass.losTime, isUtc) { sdfTime.format(Date(pass.losTime)) }
@@ -342,10 +341,6 @@ private fun PassItem(
                 .padding(horizontal = horizontalPadding, vertical = 4.dp)
         ) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "$passSatId - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
                 Text(
                     text = pass.name,
                     modifier = Modifier
@@ -355,7 +350,7 @@ private fun PassItem(
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis,
-                    color = MaterialTheme.colorScheme.onSurface
+                    color = MaterialTheme.colorScheme.primary
                 )
                 val elevColor = elevationColor(pass.maxElevation)
                 Icon(

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

@@ -152,12 +152,22 @@ 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 = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
-        val sdfTime = SimpleDateFormat("HH:mm", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfDate = dateFormat(tz)
+        val sdfTime = SimpleDateFormat("HH:mm", Locale.getDefault()).also { it.timeZone = tz }
         val result = LinkedHashMap<String, Pair<String, String>>()
         // DeepSpace group always shows today's sun times
         if (passes.any { it.isDeepSpace }) {
@@ -180,7 +190,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 = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfDate = dateFormat(tz)
         val ordered = LinkedHashMap<String, List<OrbitalPass>>()
         val deepSpace = passes.filter { it.isDeepSpace }
         if (deepSpace.isNotEmpty()) ordered["DeepSpace (period >225min)"] = deepSpace

feature/radar/build.gradle.kts

@@ -5,3 +5,7 @@ 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,6 +45,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -59,6 +60,7 @@ 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
@@ -71,6 +73,8 @@ 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"),
@@ -83,17 +87,39 @@ 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)) }
-    RadarScreen(uiState, viewModel::onAction, navigateUp, requestMicPermission = {
+    ) { granted ->
+        viewModel.onAction(RadarAction.SstvPermissionResult(granted))
+        viewModel.onAction(RadarAction.CwPermissionResult(granted))
+    }
+    RadarScreen(uiState, viewModel::onAction, navigateUpAndClearMutual, mutualData, requestMicPermission = {
         permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
     })
 }
@@ -103,12 +129,37 @@ 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()
@@ -132,11 +183,11 @@ private fun RadarScreen(
             }
         }
         if (isVertical) {
-            RadarCard(uiState, Modifier.weight(1f))
+            RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
             PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
         } else {
             Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                RadarCard(uiState, Modifier.weight(1f))
+                RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
                 PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
             }
         }
@@ -171,11 +222,14 @@ private fun PagerCard(
             ) { pageIndex ->
                 when (pages[pageIndex]) {
                     RadarPage.Transceivers -> TransceiversPage(
-                        transceivers = uiState.transceivers.transmitters,
-                        selectedUuid = uiState.transceivers.selectedUuid,
-                        radioControl = uiState.radioControl,
-                        onAction = onAction
-                    )
+                                    transceivers = uiState.transceivers.transmitters,
+                                    selectedUuid = uiState.transceivers.selectedUuid,
+                                    orbitalPos = uiState.orbitalPos,
+                                    cw = uiState.cw,
+                                    radioControl = uiState.radioControl,
+                                    onAction = onAction,
+                                    requestMicPermission = requestMicPermission
+                                )
                     RadarPage.Sstv -> SstvPage(
                         sstv = uiState.sstv,
                         dopplerFrequency = uiState.transceivers.selectedFrequency?.let { formatFrequency(it) },
@@ -189,7 +243,12 @@ private fun PagerCard(
 }
 
 @Composable
-private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
+private fun RadarCard(
+    uiState: RadarState,
+    trackB: List<OrbitalPos> = emptyList(),
+    trackBPosition: OrbitalPos? = null,
+    modifier: Modifier = Modifier
+) {
     val satellitePos = uiState.orbitalPos
     val shouldAnimateBorder = satellitePos?.aboveHorizon == true && satellitePos.eclipsed
     // Always call these composables unconditionally — conditional composable calls violate
@@ -222,6 +281,8 @@ private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
                 RadarViewCompose(
                     item = position,
                     items = uiState.satTrack,
+                    trackB = trackB.takeIf { it.isNotEmpty() },
+                    trackBPosition = trackBPosition,
                     azimElev = uiState.orientationValues,
                     shouldShowSweep = uiState.shouldShowSweep,
                     shouldUseCompass = uiState.shouldUseCompass,

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

@@ -62,7 +62,14 @@ data class RadarState(
     val moonPosition: CelestialComputer.MoonPosition? = null,
     val transceivers: TransceiverSubState = TransceiverSubState(),
     val radioControl: RadioControlSubState = RadioControlSubState(),
-    val sstv: SstvSubState = SstvSubState()
+    val sstv: SstvSubState = SstvSubState(),
+    val 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 = "友台"
 )
 
 enum class SstvStatus { Idle, Recording }
@@ -77,6 +84,19 @@ data class SstvSubState(
     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
+)
+
 sealed interface RadarAction {
     data class AddToCalendar(val name: String, val aosTime: Long, val losTime: Long) : RadarAction
     data class SelectTransmitter(val uuid: String) : RadarAction
@@ -96,4 +116,12 @@ 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,6 +60,8 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import com.rtbishop.look4sat.core.domain.predict.PI_2
 import com.rtbishop.look4sat.core.domain.utility.toRadians
 import com.rtbishop.look4sat.core.presentation.R
+import kotlin.math.PI
+import kotlin.math.abs
 import kotlin.math.cos
 import kotlin.math.sin
 
@@ -71,6 +73,9 @@ private const val SWEEP_DURATION_MS = 8_000
 fun RadarViewCompose(
     item: OrbitalPos,
     items: List<OrbitalPos>,
+    trackB: List<OrbitalPos>? = null,
+    trackBColor: Color = MaterialTheme.colorScheme.tertiary,
+    trackBPosition: OrbitalPos? = null,
     azimElev: Pair<Float, Float>,
     shouldShowSweep: Boolean,
     shouldUseCompass: Boolean,
@@ -89,14 +94,21 @@ fun RadarViewCompose(
         animationSpec = infiniteRepeatable(tween(1000)),
         label = "animScale"
     )
-    // Drive the sweep from the animation framework to eliminate state mutation inside the draw block
-    val sweepTransition = rememberInfiniteTransition(label = "sweep")
-    val sweepDegrees by sweepTransition.animateFloat(
-        initialValue = 0f,
-        targetValue = 360f,
-        animationSpec = infiniteRepeatable(tween(SWEEP_DURATION_MS, easing = LinearEasing)),
-        label = "sweepDegrees"
-    )
+    // Drive the sweep from the animation framework to eliminate state mutation inside the draw block.
+    // Only create the infinite transition when the sweep is enabled — otherwise the canvas would
+    // be invalidated every frame for an effect that isn't visible, wasting GPU and battery.
+    val sweepDegrees = if (shouldShowSweep) {
+        val sweepTransition = rememberInfiniteTransition(label = "sweep")
+        val animatedSweep by sweepTransition.animateFloat(
+            initialValue = 0f,
+            targetValue = 360f,
+            animationSpec = infiniteRepeatable(tween(SWEEP_DURATION_MS, easing = LinearEasing)),
+            label = "sweepDegrees"
+        )
+        animatedSweep
+    } else {
+        0f
+    }
     val measurer = rememberTextMeasurer()
     val sunPainter = painterResource(R.drawable.ic_sun)
     val moonPainter = painterResource(R.drawable.ic_moon)
@@ -107,18 +119,27 @@ fun RadarViewCompose(
     var cachedSweepColor by remember { mutableStateOf(Color.Unspecified) }
     var trackPath by remember { mutableStateOf(Path()) }
     var trackEffect by remember { mutableStateOf(PathEffect.cornerPathEffect(0f)) }
+    // Station-B overlay track (dashed, with the same directional arrow stamp as station A)
+    var cachedTrackBRef by remember { mutableStateOf<List<OrbitalPos>?>(null) }
+    var trackBPath by remember { mutableStateOf(Path()) }
+    var trackBEffect by remember { mutableStateOf(PathEffect.cornerPathEffect(0f)) }
     // ShaderBrush is cached to avoid allocating a new GPU shader object every frame
     var cachedSweepBrush by remember { mutableStateOf<ShaderBrush?>(null) }
 
     Canvas(modifier = modifier.aspectRatio(1f)) {
         val radius = size.minDimension / 2f * 0.95f
         // Rebuild track path and sweep brush when canvas size or track data changes
-        if (radius != cachedRadius || items !== cachedItemsRef) {
+        if (radius != cachedRadius || items !== cachedItemsRef || trackB !== cachedTrackBRef) {
             trackPath = createTrackPath(items, radius)
             trackEffect = createTrackEffect(trackPath)
+            val newTrackBPath = trackB?.let { createTrackPath(it, radius) } ?: Path()
+            trackBPath = newTrackBPath
+            trackBEffect = if (!newTrackBPath.isEmpty) createTrackEffect(newTrackBPath)
+            else PathEffect.cornerPathEffect(0f)
             cachedSweepBrush = makeSweepBrush(center, primaryColor)
             cachedRadius = radius
             cachedItemsRef = items
+            cachedTrackBRef = trackB
             cachedSweepColor = primaryColor
         } else if (primaryColor != cachedSweepColor) {
             // Rebuild brush on theme change without waiting for a size change
@@ -131,6 +152,20 @@ fun RadarViewCompose(
             drawElevationLabels(radius, primaryColor, measurer)
             translate(center.x, center.y) {
                 drawTrack(trackPath, trackEffect, aimColor, primaryColor)
+                // Station-B overlay: full dashed track + directional arrows + live position dot
+                // (same display mode as the local station: track line/arrow + pulsing dot)
+                if (trackB != null && trackB.isNotEmpty() && !trackBPath.isEmpty) {
+                    drawPath(
+                        trackBPath, trackBColor,
+                        style = Stroke(STROKE_WIDTH, pathEffect = PathEffect.dashPathEffect(floatArrayOf(18f, 12f)))
+                    )
+                    drawPath(trackBPath, trackBColor, style = Stroke(pathEffect = trackBEffect))
+                }
+                trackBPosition?.let { posB ->
+                    if (posB.elevation > 0) {
+                        drawPosition(posB, radius, animScale, trackBColor)
+                    }
+                }
                 if (item.elevation > 0) {
                     drawPosition(item, radius, animScale, primaryColor)
                 }
@@ -205,13 +240,25 @@ private fun DrawScope.drawSweep(center: Offset, degrees: Float, radius: Float, b
 
 private fun createTrackPath(positions: List<OrbitalPos>, radius: Float): Path {
     val trackPath = Path()
+    var lastAzim: Double? = null
     positions.forEachIndexed { index, pos ->
         val offset = sph2Cart(pos.azimuth, pos.elevation, radius.toDouble())
-        if (index == 0) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
+        // Split the path when azimuth wraps 0°/360° to avoid a line across the plot
+        val wrap = lastAzim != null && abs(azimuthDeltaRad(pos.azimuth - lastAzim!!)) > PI
+        if (index == 0 || wrap) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
+        lastAzim = pos.azimuth
     }
     return trackPath
 }
 
+/** Normalize an azimuth delta (radians) into the [-PI, PI] range. */
+private fun azimuthDeltaRad(deltaRad: Double): Double {
+    var d = deltaRad % (2 * PI)
+    if (d > PI) d -= 2 * PI
+    if (d < -PI) d += 2 * PI
+    return d
+}
+
 private fun createTrackEffect(trackPath: Path): PathEffect {
     val shapeRadius = 24f
     val angle = 120.0.toRadians()

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

@@ -34,6 +34,7 @@ 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
@@ -70,6 +71,8 @@ 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
@@ -136,6 +139,8 @@ class RadarViewModel(
         val passes = satelliteRepo.passes.value
         val (catNum, aosTime) = satelliteRepo.selectedPass.value
         return passes.find { it.catNum == catNum && it.aosTime == aosTime }
+            ?: passes.find { it.catNum == catNum && aosTime in it.aosTime..it.losTime }
+            ?: passes.find { it.catNum == catNum }
             ?: passes.firstOrNull()
     }
 
@@ -176,7 +181,7 @@ class RadarViewModel(
                 orbitalPos = pos, sunPosition = cachedSunPos, moonPosition = cachedMoonPos
             )
         }
-        processRadios(allRadios, pass.orbitalObject, timeNow)
+        processRadios(allRadios, pos)
         sendPassData(pos)
     }
 
@@ -272,6 +277,25 @@ 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)) }
+            }
         }
     }
 
@@ -318,8 +342,8 @@ class RadarViewModel(
         }
     }
 
-    private suspend fun processRadios(radios: List<SatRadio>, orbitalObject: OrbitalObject, time: Long) {
-        val transmitters = satelliteRepo.getRadios(orbitalObject, stationPos, radios, time)
+    private suspend fun processRadios(radios: List<SatRadio>, satPos: OrbitalPos) {
+        val transmitters = satelliteRepo.getRadios(satPos, radios)
         _uiState.update { state ->
             val freq = if (state.transceivers.selectedUuid != null) {
                 val selectedRadio = transmitters.firstOrNull { it.uuid == state.transceivers.selectedUuid }
@@ -392,6 +416,52 @@ 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
         // ==============================

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

@@ -39,14 +39,22 @@ 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
@@ -55,11 +63,14 @@ 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
@@ -71,8 +82,11 @@ 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()) {
@@ -95,8 +109,11 @@ fun TransceiversPage(
                 TransceiverItem(
                     radio = radio,
                     isExpanded = isExpanded,
+                    orbitalPos = orbitalPos,
+                    cw = cw,
                     radioControl = radioControl,
                     onAction = onAction,
+                    requestMicPermission = requestMicPermission,
                     onToggle = { onAction(RadarAction.SelectTransmitter(radio.uuid)) }
                 )
             }
@@ -131,8 +148,11 @@ 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
@@ -225,8 +245,11 @@ private fun TransceiverItem(
         ) {
             ExpandedRadioControl(
                 radio = radio,
+                orbitalPos = orbitalPos,
+                cw = cw,
                 radioControl = radioControl,
-                onAction = onAction
+                onAction = onAction,
+                requestMicPermission = requestMicPermission
             )
         }
 
@@ -295,8 +318,11 @@ private fun UnifiedFrequencyRow(
 @Composable
 private fun ExpandedRadioControl(
     radio: SatRadio,
+    orbitalPos: OrbitalPos?,
+    cw: CwSubState,
     radioControl: RadioControlSubState,
-    onAction: (RadarAction) -> Unit
+    onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit = {},
 ) {
     Column(
         modifier = Modifier
@@ -405,6 +431,23 @@ 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) {
@@ -436,6 +479,266 @@ 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/roaming/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    alias(libs.plugins.convention.featurePlugin)
+}
+
+android {
+    namespace = "com.rtbishop.look4sat.feature.roaming"
+}
+
+dependencies {
+    implementation(project(":core:data"))
+}

feature/roaming/src/main/java/com/rtbishop/look4sat/feature/roaming/RoamingScreen.kt

@@ -0,0 +1,791 @@
+/*
+ * 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.roaming
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.Bundle
+import android.provider.Settings
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.shape.CircleShape
+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.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.windowInsetsPadding
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+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.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.core.content.ContextCompat
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * 漫游页 —— 原样照搬自 QTH定位器 2.0 (com.us1pm.gridsquarelocator)。
+ * UI: res/layout/main.xml (结构/尺寸/颜色逐项照搬, 不做任何更改)
+ * 逻辑: MainActivity.showLocation() / checkEnabled() / GPS 实时监听
+ * 红线: UI 与逻辑均不更改, 与成品截图逐像素对齐。
+ */
+@Composable
+fun RoamingScreen() {
+    val context = LocalContext.current
+    var state by remember { mutableStateOf(RoamingState()) }
+    // 照搬 onCreate: 日期固定文本 + 小时前缀(定位时拼接分钟)
+    val dateText = remember { SimpleDateFormat("dd MMM yyyy", Locale.getDefault()).format(Date()) }
+    var hourPrefix by remember { mutableStateOf("") }
+    // 照搬 onCreate: 初始 checkEnabled() -> 红点+设置按钮, 日期隐藏
+    var hasPermission by remember { mutableStateOf(false) }
+    val permissionLauncher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestMultiplePermissions()
+    ) { }
+    LaunchedEffect(Unit) {
+        hourPrefix = SimpleDateFormat("HH:mm", Locale.getDefault()).format(Date()).substring(0, 3)
+        val fine = ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED
+        val coarse = ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED
+        hasPermission = fine || coarse
+        if (!hasPermission) {
+            permissionLauncher.launch(
+                arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION)
+            )
+        } else {
+            // 照搬 onResume: 绿点+进度条+提示+日期显示, 红点/按钮隐藏
+            state = state.copy(gpsOn = true, gpsOff = false, showSettings = false, showProgress = true, showNotice = true, showDate = true)
+        }
+    }
+    // 照搬 onResume/onPause: GPS + network 监听, 10 秒 / 10 米
+    val locationManager = remember { context.getSystemService(Context.LOCATION_SERVICE) as LocationManager }
+    DisposableEffect(locationManager, hasPermission) {
+        if (hasPermission) {
+            @SuppressLint("MissingPermission")
+            val listener = object : LocationListener {
+                override fun onLocationChanged(location: Location) {
+                    // 照搬 showLocation 开头: 只接受 gps / network provider
+                    if (location.provider != "gps" && location.provider != "network") return
+                    state = roamingStateFromLocation(location.latitude, location.longitude, location.time, hourPrefix)
+                        .copy(date = dateText)
+                }
+
+                override fun onProviderDisabled(provider: String) {
+                    // 照搬 checkEnabled: 红点+按钮, 日期隐藏
+                    state = state.copy(gpsOn = false, gpsOff = true, showSettings = true, showProgress = false, showNotice = false, showDate = false)
+                }
+
+                override fun onProviderEnabled(provider: String) {
+                    state = state.copy(gpsOn = true, gpsOff = false, showSettings = false, showProgress = true, showNotice = true, showDate = true)
+                }
+
+                @Deprecated("Deprecated in Java")
+                override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) = Unit
+            }
+            try {
+                locationManager.requestLocationUpdates("gps", 10_000L, 10f, listener)
+                locationManager.requestLocationUpdates("network", 10_000L, 10f, listener)
+            } catch (_: SecurityException) {
+            }
+            onDispose { locationManager.removeUpdates(listener) }
+        } else {
+            onDispose { }
+        }
+    }
+    // 照搬 res/layout/main.xml: 浅色页面, 蓝色信息区, 43sp 定位码, 3x3 九宫格, 底部版权
+    // 按用户要求: 上下往内缩进系统栏安全区, 避免内容被状态栏/导航栏遮挡
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.background)
+            .windowInsetsPadding(WindowInsets.systemBars)
+    ) {
+        // relativeLayout7: 顶部 GPS 状态条, 25dp 高, holo_blue_bright
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(2.dp)
+                .height(25.dp)
+                .background(MaterialTheme.colorScheme.surfaceVariant)
+        ) {
+            Row(modifier = Modifier.fillMaxSize(), verticalAlignment = Alignment.CenterVertically) {
+                // tvTitleGPS: "GPS" 14sp 黑, 左 8dp
+                Text(
+                    text = "GPS",
+                    fontSize = 14.sp,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.padding(start = 8.dp)
+                )
+                // imGps: toRightOf tvTitleGPS + marginLeft 15dp (成品 main.xml)
+                Spacer(modifier = Modifier.width(15.dp))
+                // imGps: 绿点 (15dp, 主题色 primary -> 夜间滤镜下可见)
+                if (state.gpsOn) {
+                    Box(
+                        modifier = Modifier
+                            .size(15.dp)
+                            .background(MaterialTheme.colorScheme.primary, CircleShape)
+                    )
+                }
+                // imGpsOff: 红点叠层 (15dp, 主题色 error)
+                if (state.gpsOff) {
+                    Box(
+                        modifier = Modifier
+                            .size(15.dp)
+                            .background(MaterialTheme.colorScheme.error, CircleShape)
+                    )
+                }
+                Spacer(modifier = Modifier.weight(1f))
+                // tvDate: 14sp 黑, 居中
+                if (state.showDate) {
+                    Text(text = state.date.ifEmpty { dateText }, fontSize = 14.sp, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                }
+                Spacer(modifier = Modifier.weight(1f))
+                // tvTime: 14sp 黑, 右对齐
+                Text(
+                    text = state.time,
+                    fontSize = 14.sp,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.padding(end = 8.dp)
+                )
+            }
+            // btnLocationSettings: 黄色按钮, 居中
+            // btnLocationSettings: 成品 #faf8f54a 半透明黄, 14sp 黑字, 居中
+            if (state.showSettings) {
+                Box(
+                    modifier = Modifier
+                        .align(Alignment.Center)
+                        .background(MaterialTheme.colorScheme.primary)
+                        .clickable { context.startActivity(Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)) }
+                        .padding(horizontal = 5.dp),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Text(text = "设置启用GPS", fontSize = 14.sp, color = MaterialTheme.colorScheme.onPrimary)
+                }
+            }
+        }
+        // linearLayout4: 经纬度区, holo_blue_bright
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 2.dp)
+                .background(MaterialTheme.colorScheme.surfaceVariant)
+        ) {
+            // 纬度行: tvLati 16sp 黑 左 8dp | tvLat 右对齐 3dp
+            Row(modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp), verticalAlignment = Alignment.CenterVertically) {
+                Text(text = state.latLabel, fontSize = 16.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 8.dp))
+                Spacer(modifier = Modifier.weight(1f))
+                Text(text = state.latValue, fontSize = 14.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(end = 3.dp))
+            }
+            // 经度行
+            Row(modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp), verticalAlignment = Alignment.CenterVertically) {
+                Text(text = state.lonLabel, fontSize = 16.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 8.dp))
+                Spacer(modifier = Modifier.weight(1f))
+                Text(text = state.lonValue, fontSize = 14.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(end = 3.dp))
+            }
+        }
+        // relativeLayout6: 定位码区, 43sp bold 黑居中
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(2.dp)
+                .background(MaterialTheme.colorScheme.surfaceVariant)
+        ) {
+            Text(
+                text = state.loc,
+                fontSize = 43.sp,
+                fontWeight = FontWeight.Bold,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = TextAlign.Center,
+                modifier = Modifier.fillMaxWidth()
+            )
+            // progressBar: 加载中, 居中
+            if (state.showProgress) {
+                CircularProgressIndicator(
+                    modifier = Modifier.size(24.dp).align(Alignment.Center),
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    strokeWidth = 2.dp
+                )
+            }
+            // tvNotice: 提示文字, 居中顶部
+            if (state.showNotice) {
+                Text(
+                    text = "请稍等，加载可能需要几分钟的时间。",
+                    fontSize = 16.sp,
+                    fontStyle = androidx.compose.ui.text.font.FontStyle.Italic,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.align(Alignment.TopCenter).padding(top = 2.dp)
+                )
+            }
+        }
+        // relativeLayout: 九宫格, 占满剩余, 底部 15dp
+        // 用 Box 等价 RelativeLayout 布局: 左格贴左 / 中格水平居中 / 右格贴右 (成品 main.xml)
+        Column(modifier = Modifier.fillMaxWidth().weight(1f).padding(bottom = 15.dp)) {
+            // 行1: relativeLayout5 (上排: 纬度 +1)
+            Box(modifier = Modifier.fillMaxWidth().weight(1f)) {
+                GridCell(text = state.grids[0], modifier = Modifier.width(80.dp).fillMaxHeight().align(Alignment.CenterStart))
+                GridCell(text = state.grids[1], modifier = Modifier.width(200.dp).fillMaxHeight().align(Alignment.Center))
+                GridCell(text = state.grids[2], modifier = Modifier.width(80.dp).fillMaxHeight().align(Alignment.CenterEnd))
+            }
+            // 行2: relativeLayout4, 205dp 高 (中排: 中央)
+            Box(modifier = Modifier.fillMaxWidth().height(205.dp)) {
+                GridCell(text = state.grids[3], modifier = Modifier.width(80.dp).fillMaxHeight().align(Alignment.CenterStart))
+                // 中央列: tv22 (100x80dp centerInParent) 叠在 linearLayout3 (200x200dp) 之上
+                Box(modifier = Modifier.width(200.dp).fillMaxHeight().align(Alignment.Center)) {
+                    // linearLayout3: 200x200dp, marginTop 2dp, holo_blue_bright
+                    Box(
+                        modifier = Modifier
+                            .align(Alignment.TopCenter)
+                            .offset(y = 2.dp)
+                            .size(width = 200.dp, height = 200.dp)
+                            .background(MaterialTheme.colorScheme.surfaceVariant)
+                    ) {
+                        // iv: 红点 10x10dp, top|left, leftMargin/topMargin 查表绝对定位
+                        Image(
+                            painter = painterResource(R.drawable.roam_pnt),
+                            contentDescription = null,
+                            modifier = Modifier
+                                .size(10.dp)
+                                .offset(x = state.markerLeft.dp, y = state.markerTop.dp)
+                        )
+                    }
+                    // tv22: 100x80dp centerInParent, 30sp bold, textColorHighlight(白)
+                    Text(
+                        text = state.grids[4],
+                        fontSize = 30.sp,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        textAlign = TextAlign.Center,
+                        modifier = Modifier
+                            .size(width = 100.dp, height = 80.dp)
+                            .align(Alignment.Center)
+                    )
+                }
+                GridCell(text = state.grids[5], modifier = Modifier.width(80.dp).fillMaxHeight().align(Alignment.CenterEnd))
+            }
+            // 行3: relativeLayout3 (下排: 纬度 -1)
+            Box(modifier = Modifier.fillMaxWidth().weight(1f)) {
+                GridCell(text = state.grids[6], modifier = Modifier.width(80.dp).fillMaxHeight().align(Alignment.CenterStart))
+                GridCell(text = state.grids[7], modifier = Modifier.width(200.dp).fillMaxHeight().align(Alignment.Center))
+                GridCell(text = state.grids[8], modifier = Modifier.width(80.dp).fillMaxHeight().align(Alignment.CenterEnd))
+            }
+        }
+        // tv4: 底部版权, 10sp 黑 (往上拉, 底部预留空间避免被导航栏遮挡)
+        Text(
+            text = "制作：US1PM  汉化：BA7LCE",
+            fontSize = 10.sp,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+            modifier = Modifier.fillMaxWidth().padding(bottom = 10.dp)
+        )
+    }
+}
+
+// 周边格: 60/200/60dp, #0BACF1, bold 居中, 2dp margin (照搬 tv11/tv13/tv21/tv23/tv31/tv33)
+@Composable
+private fun GridCell(text: String, modifier: Modifier) {
+    Box(
+        modifier = modifier
+            .padding(2.dp)
+            .background(MaterialTheme.colorScheme.surface),
+        contentAlignment = Alignment.Center
+    ) {
+        Text(
+            text = text,
+            fontSize = 14.sp,
+            fontWeight = FontWeight.Bold,
+            color = MaterialTheme.colorScheme.onSurface,
+            textAlign = TextAlign.Center
+        )
+    }
+}
+
+/**
+ * 照搬 MainActivity.showLocation() 的状态。
+ * 网格/九宫格/红点查表与成品逐行一致。
+ */
+data class RoamingState(
+    val date: String = "",
+    val time: String = "",
+    val latLabel: String = "纬度",
+    val latValue: String = "",
+    val lonLabel: String = "经度",
+    val lonValue: String = "",
+    val loc: String = "",
+    val grids: List<String> = List(9) { "" },
+    /** 红点 leftMargin(dp), 经度第 3 对字符查表 */
+    val markerLeft: Int = 0,
+    /** 红点 topMargin(dp), 纬度第 3 对字符查表(屏幕 Y 反转) */
+    val markerTop: Int = 0,
+    val gpsOn: Boolean = false,
+    val gpsOff: Boolean = true,
+    val showSettings: Boolean = true,
+    val showProgress: Boolean = false,
+    val showNotice: Boolean = false,
+    val showDate: Boolean = false
+)
+
+/**
+ * 照搬 showLocation() 的完整计算: 时间/经纬度 DMS/8 位网格/九宫格/红点查表。
+ */
+fun roamingStateFromLocation(lat: Double, lon: Double, fixTime: Long, hourPrefix: String): RoamingState {
+    // 照搬: tvTime = 缓存小时前缀 + 定位时间分钟
+    val minute = SimpleDateFormat("mm", Locale.getDefault()).format(Date(fixTime))
+    val time = hourPrefix + minute
+    // 方向字符
+    val ew = if (lon >= 0.0) "E" else "W"
+    val ns = if (lat >= 0.0) "N" else "S"
+    // 照搬: 纬度 DMS (String.valueOf 无补零)
+    val latAbs = if (lat < 0.0) -lat else lat
+    val latDeg = latAbs.toInt()
+    val latMinFull = (latAbs - latDeg) * 60.0
+    val latMin = latMinFull.toInt()
+    val latSec = ((latMinFull - latMin) * 60.0).toInt()
+    val latLabel = "纬度  $latDeg° $latMin' $latSec\" $ns"
+    val latValue = "$lat° "
+    // 照搬: 经度 DMS
+    val lonAbs = if (lon < 0.0) -lon else lon
+    val lonDeg = lonAbs.toInt()
+    val lonMinFull = (lonAbs - lonDeg) * 60.0
+    val lonMin = lonMinFull.toInt()
+    val lonSec = ((lonMinFull - lonMin) * 60.0).toInt()
+    val lonLabel = "经度 $lonDeg° $lonMin' $lonSec\" $ew"
+    val lonValue = "$lon° "
+    // 照搬: 8 位网格编码 (区间查表)
+    val (str, str2, str3, str4) = encodeLon(lon)
+    val (str5, str6, str38, str9) = encodeLat(lat)
+    val loc = str + str5 + str2 + str6 + str3 + str38 + str4 + str9
+    // 照搬: 九宫格 parseInt3 五分支
+    val grids = buildGrids(str, str5, str2, str6, str3, str38)
+    // 照搬: 红点查表 (第 3 对字符)
+    val markerLeft = lonMargin[str3.firstOrNull()] ?: 0
+    val markerTop = latMargin[str38.firstOrNull()] ?: 0
+    return RoamingState(
+        time = time,
+        latLabel = latLabel,
+        latValue = latValue,
+        lonLabel = lonLabel,
+        lonValue = lonValue,
+        loc = loc,
+        grids = grids,
+        markerLeft = markerLeft,
+        markerTop = markerTop,
+        gpsOn = true,
+        gpsOff = false,
+        showSettings = false,
+        showProgress = false,
+        showNotice = false,
+        showDate = true
+    )
+}
+
+// 红点 leftMargin 查表 (MainActivity 1286-1386 行): 经度第 3 对 a..x -> -2..190 dp
+private val lonMargin = mapOf(
+    'a' to -2, 'b' to 8, 'c' to 16, 'd' to 24, 'e' to 32, 'f' to 40, 'g' to 48, 'h' to 56,
+    'i' to 65, 'j' to 74, 'k' to 83, 'l' to 92, 'm' to 101, 'n' to 110, 'o' to 119, 'p' to 128,
+    'q' to 137, 'r' to 146, 's' to 155, 't' to 163, 'u' to 171, 'v' to 179, 'w' to 184, 'x' to 190
+)
+
+// 红点 topMargin 查表 (MainActivity 1315-1363 行): 纬度第 3 对 a..x -> 190..-2 dp (屏幕 Y 反转)
+private val latMargin = mapOf(
+    'a' to 190, 'b' to 182, 'c' to 174, 'd' to 169, 'e' to 163, 'f' to 155, 'g' to 146, 'h' to 137,
+    'i' to 128, 'j' to 119, 'k' to 110, 'l' to 101, 'm' to 92, 'n' to 83, 'o' to 74, 'p' to 65,
+    'q' to 56, 'r' to 48, 's' to 40, 't' to 32, 'u' to 24, 'v' to 16, 'w' to 8, 'x' to -2
+)
+
+// 照搬 311-611 行: 经度 -> (20°区字母, 2°数字, 2'字母, 30"数字)
+private fun encodeLon(inputLon: Double): List<String> {
+    var longitude = inputLon
+    var d = 0.0
+    val str = when {
+        (longitude >= -180.0) && (longitude <= -160.0) -> { longitude += 180.0; "A" }
+        (longitude >= -160.0) && (longitude <= -140.0) -> { longitude += 160.0; "B" }
+        (longitude >= -140.0) && (longitude <= -120.0) -> { longitude += 140.0; "C" }
+        (longitude >= -120.0) && (longitude <= -100.0) -> { longitude += 120.0; "D" }
+        (longitude >= -100.0) && (longitude <= -80.0) -> { longitude += 100.0; "E" }
+        (longitude >= -80.0) && (longitude <= -60.0) -> { longitude += 80.0; "F" }
+        (longitude >= -60.0) && (longitude <= -40.0) -> { longitude += 60.0; "G" }
+        (longitude >= -40.0) && (longitude <= -20.0) -> { longitude += 40.0; "H" }
+        (longitude >= -20.0) && (longitude <= 0.0) -> { longitude += 20.0; "I" }
+        (longitude >= 0.0) && (longitude <= 20.0) -> "J"
+        (longitude >= 20.0) && (longitude <= 40.0) -> { longitude -= 20.0; "K" }
+        (longitude >= 40.0) && (longitude <= 60.0) -> { longitude -= 40.0; "L" }
+        (longitude >= 60.0) && (longitude <= 80.0) -> { longitude -= 60.0; "M" }
+        (longitude >= 80.0) && (longitude <= 100.0) -> { longitude -= 80.0; "N" }
+        (longitude >= 100.0) && (longitude <= 120.0) -> { longitude -= 100.0; "O" }
+        (longitude >= 120.0) && (longitude <= 140.0) -> { longitude -= 120.0; "P" }
+        (longitude >= 140.0) && (longitude <= 160.0) -> { longitude -= 140.0; "Q" }
+        (longitude >= 160.0) && (longitude <= 180.0) -> { longitude -= 160.0; "R" }
+        else -> { longitude = 0.0; " " }
+    }
+    val str2 = when {
+        ((longitude >= 0.0) && (longitude <= 2.0)) || ((longitude >= -20.0) && (longitude <= -18.0)) -> { d = longitude * 60.0; "0" }
+        ((longitude >= 2.0) && (longitude <= 4.0)) || ((longitude >= -18.0) && (longitude <= -16.0)) -> { d = (longitude - 2.0) * 60.0; "1" }
+        ((longitude >= 4.0) && (longitude <= 6.0)) || ((longitude >= -16.0) && (longitude <= -14.0)) -> { d = (longitude - 4.0) * 60.0; "2" }
+        ((longitude >= 6.0) && (longitude <= 8.0)) || ((longitude >= -14.0) && (longitude <= -12.0)) -> { d = (longitude - 6.0) * 60.0; "3" }
+        ((longitude >= 8.0) && (longitude <= 10.0)) || ((longitude >= -12.0) && (longitude <= -10.0)) -> { d = (longitude - 8.0) * 60.0; "4" }
+        ((longitude >= 10.0) && (longitude <= 12.0)) || ((longitude >= -10.0) && (longitude <= -8.0)) -> { d = (longitude - 10.0) * 60.0; "5" }
+        ((longitude >= 12.0) && (longitude <= 14.0)) || ((longitude >= -8.0) && (longitude <= -6.0)) -> { d = (longitude - 12.0) * 60.0; "6" }
+        ((longitude >= 14.0) && (longitude <= 16.0)) || ((longitude >= -6.0) && (longitude <= -4.0)) -> { d = (longitude - 14.0) * 60.0; "7" }
+        ((longitude >= 16.0) && (longitude <= 18.0)) || ((longitude >= -4.0) && (longitude <= -2.0)) -> { d = (longitude - 16.0) * 60.0; "8" }
+        ((longitude >= 18.0) && (longitude <= 20.0)) || ((longitude >= -2.0) && (longitude <= 0.0)) -> { d = (longitude - 18.0) * 60.0; "9" }
+        else -> { d = 0.0; " " }
+    }
+    val str3 = when {
+        ((d >= 0.0) && (d <= 5.0)) || ((d >= -120.0) && (d <= -115.0)) -> { longitude = d * 60.0; "a" }
+        ((d >= 5.0) && (d <= 10.0)) || ((d >= -115.0) && (d <= -110.0)) -> { longitude = (d - 5.0) * 60.0; "b" }
+        ((d >= 10.0) && (d <= 15.0)) || ((d >= -110.0) && (d <= -105.0)) -> { longitude = (d - 10.0) * 60.0; "c" }
+        ((d >= 15.0) && (d <= 20.0)) || ((d >= -105.0) && (d <= -100.0)) -> { longitude = (d - 15.0) * 60.0; "d" }
+        ((d >= 20.0) && (d <= 25.0)) || ((d >= -100.0) && (d <= -95.0)) -> { longitude = (d - 20.0) * 60.0; "e" }
+        ((d >= 25.0) && (d <= 30.0)) || ((d >= -95.0) && (d <= -90.0)) -> { longitude = (d - 25.0) * 60.0; "f" }
+        ((d >= 30.0) && (d <= 35.0)) || ((d >= -90.0) && (d <= -85.0)) -> { longitude = (d - 30.0) * 60.0; "g" }
+        ((d >= 35.0) && (d <= 40.0)) || ((d >= -85.0) && (d <= -80.0)) -> { longitude = (d - 35.0) * 60.0; "h" }
+        ((d >= 40.0) && (d <= 45.0)) || ((d >= -80.0) && (d <= -75.0)) -> { longitude = (d - 40.0) * 60.0; "i" }
+        ((d >= 45.0) && (d <= 50.0)) || ((d >= -75.0) && (d <= -70.0)) -> { longitude = (d - 45.0) * 60.0; "j" }
+        ((d >= 50.0) && (d <= 55.0)) || ((d >= -70.0) && (d <= -65.0)) -> { longitude = (d - 50.0) * 60.0; "k" }
+        ((d >= 55.0) && (d <= 60.0)) || ((d >= -65.0) && (d <= -60.0)) -> { longitude = (d - 55.0) * 60.0; "l" }
+        ((d >= 60.0) && (d <= 65.0)) || ((d >= -60.0) && (d <= -55.0)) -> { longitude = (d - 60.0) * 60.0; "m" }
+        ((d >= 65.0) && (d <= 70.0)) || ((d >= -55.0) && (d <= -50.0)) -> { longitude = (d - 65.0) * 60.0; "n" }
+        ((d >= 70.0) && (d <= 75.0)) || ((d >= -50.0) && (d <= -45.0)) -> { longitude = (d - 70.0) * 60.0; "o" }
+        ((d >= 75.0) && (d <= 80.0)) || ((d >= -45.0) && (d <= -40.0)) -> { longitude = (d - 75.0) * 60.0; "p" }
+        ((d >= 80.0) && (d <= 85.0)) || ((d >= -40.0) && (d <= -35.0)) -> { longitude = (d - 80.0) * 60.0; "q" }
+        ((d >= 85.0) && (d <= 90.0)) || ((d >= -35.0) && (d <= -30.0)) -> { longitude = (d - 85.0) * 60.0; "r" }
+        ((d >= 90.0) && (d <= 95.0)) || ((d >= -30.0) && (d <= -25.0)) -> { longitude = (d - 90.0) * 60.0; "s" }
+        ((d >= 95.0) && (d <= 100.0)) || ((d >= -25.0) && (d <= -20.0)) -> { longitude = (d - 95.0) * 60.0; "t" }
+        ((d >= 100.0) && (d <= 105.0)) || ((d >= -20.0) && (d <= -15.0)) -> { longitude = (d - 100.0) * 60.0; "u" }
+        ((d >= 105.0) && (d <= 110.0)) || ((d >= -15.0) && (d <= -10.0)) -> { longitude = (d - 105.0) * 60.0; "v" }
+        ((d >= 110.0) && (d <= 115.0)) || ((d >= -10.0) && (d <= -5.0)) -> { longitude = (d - 110.0) * 60.0; "w" }
+        ((d >= 115.0) && (d <= 120.0)) || ((d >= -5.0) && (d <= 0.0)) -> { longitude = (d - 115.0) * 60.0; "x" }
+        else -> { longitude = 0.0; " " }
+    }
+    val str4 = when {
+        ((longitude >= 0.0) && (longitude <= 30.0)) || ((longitude >= -300.0) && (longitude <= -270.0)) -> "0"
+        ((longitude >= 30.0) && (longitude <= 60.0)) || ((longitude >= -270.0) && (longitude <= -240.0)) -> "1"
+        ((longitude >= 60.0) && (longitude <= 90.0)) || ((longitude >= -240.0) && (longitude <= -210.0)) -> "2"
+        ((longitude >= 90.0) && (longitude <= 120.0)) || ((longitude >= -210.0) && (longitude <= -180.0)) -> "3"
+        ((longitude >= 120.0) && (longitude <= 150.0)) || ((longitude >= -180.0) && (longitude <= -150.0)) -> "4"
+        ((longitude >= 150.0) && (longitude <= 180.0)) || ((longitude >= -150.0) && (longitude <= -120.0)) -> "5"
+        ((longitude >= 180.0) && (longitude <= 210.0)) || ((longitude >= -120.0) && (longitude <= -90.0)) -> "6"
+        ((longitude >= 210.0) && (longitude <= 240.0)) || ((longitude >= -90.0) && (longitude <= -60.0)) -> "7"
+        ((longitude >= 240.0) && (longitude <= 270.0)) || ((longitude >= -60.0) && (longitude <= -30.0)) -> "8"
+        ((longitude >= 270.0) && (longitude <= 300.0)) || ((longitude >= -30.0) && (longitude <= 0.0)) -> "9"
+        else -> " "
+    }
+    return listOf(str, str2, str3, str4)
+}
+
+// 照搬 612-914 行: 纬度 -> (10°区字母, 1°数字, 1'字母, 15"数字)
+private fun encodeLat(inputLat: Double): List<String> {
+    var latitude = inputLat
+    var d2 = 0.0
+    var d3 = 0.0
+    val str5 = when {
+        (latitude >= -90.0) && (latitude <= -80.0) -> { d2 = latitude + 90.0; "A" }
+        (latitude >= -80.0) && (latitude <= -70.0) -> { d2 = latitude + 80.0; "B" }
+        (latitude >= -70.0) && (latitude <= -60.0) -> { d2 = latitude + 70.0; "C" }
+        (latitude >= -60.0) && (latitude <= -50.0) -> { d2 = latitude + 60.0; "D" }
+        (latitude >= -50.0) && (latitude <= -40.0) -> { d2 = latitude + 50.0; "E" }
+        (latitude >= -40.0) && (latitude <= -30.0) -> { d2 = latitude + 40.0; "F" }
+        (latitude >= -30.0) && (latitude <= -20.0) -> { d2 = latitude + 30.0; "G" }
+        (latitude >= -20.0) && (latitude <= -10.0) -> { d2 = latitude + 20.0; "H" }
+        (latitude >= -10.0) && (latitude <= 0.0) -> { d2 = latitude + 10.0; "I" }
+        (latitude >= 0.0) && (latitude <= 10.0) -> { d2 = latitude; "J" }
+        (latitude >= 10.0) && (latitude <= 20.0) -> { d2 = latitude - 10.0; "K" }
+        (latitude >= 20.0) && (latitude <= 30.0) -> { d2 = latitude - 20.0; "L" }
+        (latitude >= 30.0) && (latitude <= 40.0) -> { d2 = latitude - 30.0; "M" }
+        (latitude >= 40.0) && (latitude <= 50.0) -> { d2 = latitude - 40.0; "N" }
+        (latitude >= 50.0) && (latitude <= 60.0) -> { d2 = latitude - 50.0; "O" }
+        (latitude >= 60.0) && (latitude <= 70.0) -> { d2 = latitude - 60.0; "P" }
+        (latitude >= 70.0) && (latitude <= 80.0) -> { d2 = latitude - 70.0; "Q" }
+        (latitude >= 80.0) && (latitude <= 90.0) -> { d2 = latitude - 80.0; "R" }
+        else -> { d2 = 0.0; " " }
+    }
+    var str6 = " "
+    when {
+        ((d2 >= 0.0) && (d2 <= 1.0)) || ((d2 >= -10.0) && (d2 <= -9.0)) -> { d3 = d2 * 60.0; str6 = "0" }
+        ((d2 >= 1.0) && (d2 <= 2.0)) || ((d2 >= -9.0) && (d2 <= -8.0)) -> { d3 = (d2 - 1.0) * 60.0; str6 = "1" }
+        ((d2 >= 2.0) && (d2 <= 3.0)) || ((d2 >= -8.0) && (d2 <= -7.0)) -> { d3 = (d2 - 2.0) * 60.0; str6 = "2" }
+        ((d2 >= 3.0) && (d2 <= 4.0)) || ((d2 >= -7.0) && (d2 <= -6.0)) -> { d3 = (d2 - 3.0) * 60.0; str6 = "3" }
+        ((d2 >= 4.0) && (d2 <= 5.0)) || ((d2 >= -6.0) && (d2 <= -5.0)) -> { d3 = (d2 - 4.0) * 60.0; str6 = "4" }
+        ((d2 >= 5.0) && (d2 <= 6.0)) || ((d2 >= -5.0) && (d2 <= -4.0)) -> { d3 = (d2 - 5.0) * 60.0; str6 = "5" }
+        ((d2 >= 6.0) && (d2 <= 7.0)) || ((d2 >= -4.0) && (d2 <= -3.0)) -> { d3 = (d2 - 6.0) * 60.0; str6 = "6" }
+        ((d2 >= 7.0) && (d2 <= 8.0)) || ((d2 >= -3.0) && (d2 <= -2.0)) -> { d3 = (d2 - 7.0) * 60.0; str6 = "7" }
+        ((d2 >= 8.0) && (d2 <= 9.0)) || ((d2 >= -2.0) && (d2 <= -1.0)) -> { d3 = (d2 - 8.0) * 60.0; str6 = "8" }
+        ((d2 >= 9.0) && (d2 <= 10.0)) || ((d2 >= -1.0) && (d2 <= 0.0)) -> { d3 = (d2 - 9.0) * 60.0; str6 = "9" }
+    }
+    val str38 = when {
+        ((d3 >= 0.0) && (d3 <= 2.5)) || ((d3 >= -60.0) && (d3 <= -57.5)) -> { d2 = d3 * 60.0; "a" }
+        ((d3 >= 2.5) && (d3 <= 5.0)) || ((d3 >= -57.5) && (d3 <= -55.0)) -> { d2 = (d3 - 2.5) * 60.0; "b" }
+        ((d3 >= 5.0) && (d3 <= 7.5)) || ((d3 >= -55.0) && (d3 <= -52.5)) -> { d2 = (d3 - 5.0) * 60.0; "c" }
+        ((d3 >= 7.5) && (d3 <= 10.0)) || ((d3 >= -52.5) && (d3 <= -50.0)) -> { d2 = (d3 - 7.5) * 60.0; "d" }
+        ((d3 >= 10.0) && (d3 <= 12.5)) || ((d3 >= -50.0) && (d3 <= -47.5)) -> { d2 = (d3 - 10.0) * 60.0; "e" }
+        ((d3 >= 12.5) && (d3 <= 15.0)) || ((d3 >= -47.5) && (d3 <= -45.0)) -> { d2 = (d3 - 12.5) * 60.0; "f" }
+        ((d3 >= 15.0) && (d3 <= 17.5)) || ((d3 >= -45.0) && (d3 <= -42.5)) -> { d2 = (d3 - 15.0) * 60.0; "g" }
+        ((d3 >= 17.5) && (d3 <= 20.0)) || ((d3 >= -42.5) && (d3 <= -40.0)) -> { d2 = (d3 - 17.5) * 60.0; "h" }
+        ((d3 >= 20.0) && (d3 <= 22.5)) || ((d3 >= -40.0) && (d3 <= -37.5)) -> { d2 = (d3 - 20.0) * 60.0; "i" }
+        ((d3 >= 22.5) && (d3 <= 25.0)) || ((d3 >= -37.5) && (d3 <= -35.0)) -> { d2 = (d3 - 22.5) * 60.0; "j" }
+        ((d3 >= 25.0) && (d3 <= 27.5)) || ((d3 >= -35.0) && (d3 <= -32.5)) -> { d2 = (d3 - 25.0) * 60.0; "k" }
+        ((d3 >= 27.5) && (d3 <= 30.0)) || ((d3 >= -32.5) && (d3 <= -30.0)) -> { d2 = (d3 - 27.5) * 60.0; "l" }
+        ((d3 >= 30.0) && (d3 <= 32.5)) || ((d3 >= -30.0) && (d3 <= -27.5)) -> { d2 = (d3 - 30.0) * 60.0; "m" }
+        ((d3 >= 32.5) && (d3 <= 35.0)) || ((d3 >= -27.5) && (d3 <= -25.0)) -> { d2 = (d3 - 32.5) * 60.0; "n" }
+        ((d3 >= 35.0) && (d3 <= 37.5)) || ((d3 >= -25.0) && (d3 <= -22.5)) -> { d2 = (d3 - 35.0) * 60.0; "o" }
+        ((d3 >= 37.5) && (d3 <= 40.0)) || ((d3 >= -22.5) && (d3 <= -20.0)) -> { d2 = (d3 - 37.5) * 60.0; "p" }
+        ((d3 >= 40.0) && (d3 <= 42.5)) || ((d3 >= -20.0) && (d3 <= -17.5)) -> { d2 = (d3 - 40.0) * 60.0; "q" }
+        ((d3 >= 42.5) && (d3 <= 45.0)) || ((d3 >= -17.5) && (d3 <= -15.0)) -> { d2 = (d3 - 42.5) * 60.0; "r" }
+        ((d3 >= 45.0) && (d3 <= 47.5)) || ((d3 >= -15.0) && (d3 <= -12.5)) -> { d2 = (d3 - 45.0) * 60.0; "s" }
+        ((d3 >= 47.5) && (d3 <= 50.0)) || ((d3 >= -12.5) && (d3 <= -10.0)) -> { d2 = (d3 - 47.5) * 60.0; "t" }
+        ((d3 >= 50.0) && (d3 <= 52.5)) || ((d3 >= -10.0) && (d3 <= -7.5)) -> { d2 = (d3 - 50.0) * 60.0; "u" }
+        ((d3 >= 52.5) && (d3 <= 55.0)) || ((d3 >= -7.5) && (d3 <= -5.0)) -> { d2 = (d3 - 52.5) * 60.0; "v" }
+        ((d3 >= 55.0) && (d3 <= 57.5)) || ((d3 >= -5.0) && (d3 <= -2.5)) -> { d2 = (d3 - 55.0) * 60.0; "w" }
+        ((d3 >= 57.5) && (d3 <= 60.0)) || ((d3 >= -2.5) && (d3 <= 0.0)) -> { d2 = (d3 - 57.5) * 60.0; "x" }
+        else -> { d2 = 0.0; " " }
+    }
+    val str9 = when {
+        ((d2 >= 0.0) && (d2 <= 15.0)) || ((d2 >= -150.0) && (d2 <= -135.0)) -> "0"
+        ((d2 >= 15.0) && (d2 <= 30.0)) || ((d2 >= -135.0) && (d2 <= -120.0)) -> "1"
+        ((d2 >= 30.0) && (d2 <= 45.0)) || ((d2 >= -120.0) && (d2 <= -105.0)) -> "2"
+        ((d2 >= 45.0) && (d2 <= 60.0)) || ((d2 >= -105.0) && (d2 <= -90.0)) -> "3"
+        ((d2 >= 60.0) && (d2 <= 75.0)) || ((d2 >= -90.0) && (d2 <= -75.0)) -> "4"
+        ((d2 >= 75.0) && (d2 <= 90.0)) || ((d2 >= -75.0) && (d2 <= -60.0)) -> "5"
+        ((d2 >= 90.0) && (d2 <= 105.0)) || ((d2 >= -60.0) && (d2 <= -45.0)) -> "6"
+        ((d2 >= 105.0) && (d2 <= 120.0)) || ((d2 >= -45.0) && (d2 <= -30.0)) -> "7"
+        ((d2 >= 120.0) && (d2 <= 135.0)) || ((d2 >= -30.0) && (d2 <= -15.0)) -> "8"
+        ((d2 >= 135.0) && (d2 <= 150.0)) || ((d2 >= -15.0) && (d2 <= 0.0)) -> "9"
+        else -> " "
+    }
+    return listOf(str5, str6, str38, str9)
+}
+
+/**
+ * 照搬 917-1283 行: 九宫格 parseInt3 五分支(内部/西界/东界/北界/南界 + 四角)。
+ * 返回 9 格文本: [上左, 上中, 上右, 左中, 中央, 右中, 下左, 下中, 下右]。
+ */
+private fun buildGrids(str: String, str5: String, str2: String, str6: String, str3: String, str38: String): List<String> {
+    val parseInt = str2.toInt()
+    val parseInt2 = str6.toInt()
+    val str39 = str + str5
+    val str40 = str2 + str6
+    val parseInt3 = str40.toInt()
+    val str41 = str39 + str40
+    val g = MutableList(9) { "" }
+    fun fmt2(n: Int) = if (n <= 9) "0$n" else n.toString()
+    if ((parseInt > 0) && (parseInt < 9) && (parseInt2 > 0) && (parseInt2 < 9)) {
+        // 内部: 数字对 ±1
+        val i7 = parseInt3 + 1
+        val i8 = i7 - 10
+        val valueOf9 = fmt2(i8)
+        val str11 = i7.toString()
+        val valueOf18 = (i7 + 10).toString()
+        val i9 = parseInt3 - 10
+        val valueOf10 = fmt2(i9)
+        val valueOf19 = (parseInt3 + 10).toString()
+        val i10 = parseInt3 - 1
+        val i11 = i10 - 10
+        val valueOf11 = fmt2(i11)
+        val str14 = i10.toString()
+        val str15 = (i10 + 10).toString()
+        g[0] = str39 + valueOf9
+        g[1] = str39 + str11
+        g[2] = str39 + valueOf18
+        g[3] = str39 + valueOf10
+        g[4] = str41
+        g[5] = str39 + valueOf19
+        g[6] = str39 + valueOf11
+        g[7] = str39 + str14
+        g[8] = str39 + str15
+    } else if ((parseInt == 0) && (parseInt2 > 0) && (parseInt2 < 9)) {
+        // 西边界: 经度 0 -> 9, 经度字母 -1
+        val str43 = (str[0] - 1).toString() + str5
+        val str44 = "9" + (parseInt2 + 1)
+        val i12 = parseInt3 + 1
+        val valueOf7 = fmt2(i12)
+        val str12 = (i12 + 10).toString()
+        val sb4 = "9" + parseInt2
+        val valueOf20 = (parseInt3 + 10).toString()
+        val str46 = "9" + (parseInt2 - 1)
+        val i13 = parseInt3 - 1
+        val valueOf8 = fmt2(i13)
+        val str15 = (i13 + 10).toString()
+        g[0] = str43 + str44
+        g[1] = str39 + valueOf7
+        g[2] = str39 + str12
+        g[3] = str43 + sb4
+        g[4] = str41
+        g[5] = str39 + valueOf20
+        g[6] = str43 + str46
+        g[7] = str39 + valueOf8
+        g[8] = str39 + str15
+    } else if ((parseInt == 9) && (parseInt2 > 0) && (parseInt2 < 9)) {
+        // 东边界: 经度 9 -> 0, 经度字母 +1
+        val str47 = (str[0] + 1).toString() + str5
+        val i14 = parseInt3 + 1
+        val valueOf21 = (i14 - 10).toString()
+        val valueOf22 = i14.toString()
+        val str48 = "0" + (parseInt2 + 1)
+        val valueOf23 = (parseInt3 - 10).toString()
+        val str49 = "0" + parseInt2
+        val i15 = parseInt3 - 1
+        val valueOf24 = (i15 - 10).toString()
+        val valueOf25 = i15.toString()
+        val str15 = "0" + (parseInt2 - 1)
+        g[0] = str39 + valueOf21
+        g[1] = str39 + valueOf22
+        g[2] = str47 + str48
+        g[3] = str39 + valueOf23
+        g[4] = str41
+        g[5] = str47 + str49
+        g[6] = str39 + valueOf24
+        g[7] = str39 + valueOf25
+        g[8] = str47 + str15
+    } else if ((parseInt < 9) && (parseInt > 0) && (parseInt2 == 9)) {
+        // 北边界: 纬度 9 -> 0, 纬度字母 +1
+        val str50 = str + (str5[0] + 1).toString()
+        val i16 = parseInt3 - 9
+        val i17 = i16 - 10
+        val valueOf4 = fmt2(i17)
+        val valueOf26 = i16.toString()
+        val valueOf27 = (i16 + 10).toString()
+        val i18 = parseInt3 - 10
+        val valueOf5 = fmt2(i18)
+        val valueOf28 = (parseInt3 + 10).toString()
+        val i19 = parseInt3 - 1
+        val i20 = i19 - 10
+        val valueOf6 = fmt2(i20)
+        val str14 = i19.toString()
+        val str15 = (i19 + 10).toString()
+        g[0] = str39 + valueOf4
+        g[1] = str50 + valueOf26
+        g[2] = str39 + valueOf27
+        g[3] = str39 + valueOf5
+        g[4] = str41
+        g[5] = str39 + valueOf28
+        g[6] = str39 + valueOf6
+        g[7] = str39 + str14
+        g[8] = str39 + str15
+    } else if ((parseInt < 9) && (parseInt > 0) && (parseInt2 == 0)) {
+        // 南边界: 纬度 0 -> 9, 纬度字母 -1
+        val str52 = str + (str5[0] - 1).toString()
+        val i21 = parseInt3 + 1
+        val i22 = i21 - 10
+        val valueOf = fmt2(i22)
+        val valueOf29 = i21.toString()
+        val valueOf30 = (i21 + 10).toString()
+        val i23 = parseInt3 - 10
+        val valueOf2 = fmt2(i23)
+        val valueOf31 = (parseInt3 + 10).toString()
+        val i24 = parseInt3 - 1
+        val valueOf3 = fmt2(i24)
+        val str14 = (i24 + 10).toString()
+        val str15 = (i24 + 20).toString()
+        g[0] = str39 + valueOf
+        g[1] = str39 + valueOf29
+        g[2] = str39 + valueOf30
+        g[3] = str39 + valueOf2
+        g[4] = str41
+        g[5] = str39 + valueOf31
+        g[6] = str52 + valueOf3
+        g[7] = str52 + str14
+        g[8] = str52 + str15
+    } else if (parseInt3 == 0) {
+        // 四角 00: 经纬度数字均 -1 进位
+        val v32 = (str[0] - 1).toString()
+        val v33 = (str5[0] - 1).toString()
+        g[0] = v32 + str5 + "91"
+        g[1] = str39 + "01"
+        g[2] = str39 + "11"
+        g[3] = v32 + str5 + "90"
+        g[4] = str41
+        g[5] = v32 + str5 + "10"
+        g[6] = v32 + v33 + "99"
+        g[7] = str + v33 + "09"
+        g[8] = str + v33 + "19"
+    } else if (parseInt3 == 9) {
+        // 四角 09: 经度 -1, 纬度 +1
+        val v34 = (str[0] - 1).toString()
+        val v35 = (str5[0] + 1).toString()
+        g[0] = v34 + v35 + "90"
+        g[1] = str + v35 + "00"
+        g[2] = str + v35 + "10"
+        g[3] = v34 + str5 + "99"
+        g[4] = str41
+        g[5] = v34 + str5 + "19"
+        g[6] = v34 + str5 + "98"
+        g[7] = v34 + str5 + "08"
+        g[8] = v34 + str5 + "18"
+    } else if (parseInt3 == 99) {
+        // 四角 99: 经纬度数字均 +1 进位
+        val v36 = (str[0] + 1).toString()
+        val v37 = (str5[0] + 1).toString()
+        g[0] = str + v37 + "80"
+        g[1] = str + v37 + "90"
+        g[2] = v36 + v37 + "00"
+        g[3] = str39 + "89"
+        g[4] = str41
+        g[5] = v36 + str5 + "09"
+        g[6] = str39 + "88"
+        g[7] = str39 + "98"
+        g[8] = v36 + str5 + "08"
+    } else if (parseInt3 == 90) {
+        // 四角 90: 经度 +1, 纬度 -1
+        val v38 = (str[0] + 1).toString()
+        val v39 = (str5[0] - 1).toString()
+        g[0] = str39 + "81"
+        g[1] = str39 + "91"
+        g[2] = v38 + str5 + "01"
+        g[3] = str39 + "80"
+        g[4] = str41
+        g[5] = v38 + str5 + "00"
+        g[6] = str + v39 + "89"
+        g[7] = str + v39 + "99"
+        g[8] = v38 + v39 + "09"
+    }
+    return g
+}

feature/roaming/src/test/java/com/rtbishop/look4sat/feature/roaming/RoamingStateTest.kt

@@ -0,0 +1,124 @@
+/*
+ * 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.roaming
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class RoamingStateTest {
+
+    // 用户实测坐标 (QTH定位器 2.0 成品截图): 22.314066 / 108.706575
+    private fun stateOf(lat: Double, lon: Double) =
+        roamingStateFromLocation(lat, lon, System.currentTimeMillis(), "21:")
+
+    @Test
+    fun `user coordinates produce OL42ih45`() {
+        val state = stateOf(22.314066, 108.706575)
+        assertEquals("OL42ih45", state.loc)
+    }
+
+    @Test
+    fun `red marker from ih pair matches reference lookup`() {
+        val state = stateOf(22.314066, 108.706575)
+        // 成品查表: 经度第3对 'i' -> leftMargin 65dp, 纬度第3对 'h' -> topMargin 137dp
+        assertEquals(65, state.markerLeft)
+        assertEquals(137, state.markerTop)
+    }
+
+    @Test
+    fun `grid nine from OL42 matches reference`() {
+        val state = stateOf(22.314066, 108.706575)
+        val expected = listOf(
+            "OL33", "OL43", "OL53",
+            "OL32", "OL42", "OL52",
+            "OL31", "OL41", "OL51"
+        )
+        assertEquals(expected, state.grids)
+    }
+
+    @Test
+    fun `latitude dms formatting matches reference`() {
+        val state = stateOf(22.314066, 108.706575)
+        assertEquals("纬度  22° 18' 50\" N", state.latLabel)
+        assertEquals("22.314066° ", state.latValue)
+        assertEquals("经度 108° 42' 23\" E", state.lonLabel)
+        assertEquals("108.706575° ", state.lonValue)
+    }
+
+    @Test
+    fun `time is hour prefix plus fix minutes`() {
+        // fixTime = 2026-08-03 21:12:13 UTC+8 -> minutes 12
+        val fix = 1785820333000L // 2026-08-03 21:12:13 +0800
+        val state = roamingStateFromLocation(22.314066, 108.706575, fix, "21:")
+        assertEquals("21:12", state.time)
+    }
+
+    @Test
+    fun `west edge borrows lon letter`() {
+        // 经度 0.5 纬度 22.314066: 数字对 02, 西边界 parseInt==0
+        val state = stateOf(22.314066, 0.5)
+        assertEquals(8, state.loc.length)
+        // 左列经度 0->9, 经度字母 J-1=I: IL92
+        assertEquals("IL92", state.grids[3])
+    }
+
+    @Test
+    fun `north edge carries lat letter`() {
+        // 纬度 29.5 经度 108.706575: 数字对 49? -> 纬度数字 9 -> 北边界
+        val state = stateOf(29.5, 108.706575)
+        assertEquals(8, state.loc.length)
+        // 上排纬度 +1 -> 0, 纬度字母 +1 (M)
+        assertEquals("OM40", state.grids[1])
+    }
+
+    @Test
+    fun `east edge carries lon letter`() {
+        // 经度 119.5 纬度 22.314066: 经度数字 9 -> 东边界
+        val state = stateOf(22.314066, 119.5)
+        assertEquals(8, state.loc.length)
+        // 右上 经度 9->0, 经度字母 O+1=P, 纬度 2+1=3: PL03
+        assertEquals("PL03", state.grids[2])
+    }
+
+    @Test
+    fun `south edge borrows lat letter`() {
+        // 纬度 0.5 经度 108.706575: 纬度数字 0 -> 南边界
+        val state = stateOf(0.5, 108.706575)
+        assertEquals(8, state.loc.length)
+        // 下中 纬度 0->9, 纬度字母 J-1=I: OI49
+        assertEquals("OI49", state.grids[7])
+    }
+
+    @Test
+    fun `boundary values wrap like reference`() {
+        // (90, 180) -> RR99xx99 (成品区间查表行为)
+        val state = stateOf(90.0, 180.0)
+        assertEquals("RR99xx99", state.loc)
+    }
+
+    @Test
+    fun `gps state after fix matches showLocation`() {
+        val state = stateOf(22.314066, 108.706575)
+        assertEquals(true, state.gpsOn)
+        assertEquals(false, state.gpsOff)
+        assertEquals(false, state.showSettings)
+        assertEquals(false, state.showProgress)
+        assertEquals(false, state.showNotice)
+        assertEquals(true, state.showDate)
+    }
+}

feature/satellites/src/main/java/com/rtbishop/look4sat/feature/satellites/SatellitesScreen.kt

@@ -290,14 +290,17 @@ private fun Satellite(
                 .background(MaterialTheme.colorScheme.surface)
                 .padding(start = 14.dp, top = 8.dp, end = 12.dp, bottom = 8.dp)
         ) {
-            Text(text = "$passSatId - ", color = MaterialTheme.colorScheme.primary)
+            Text(
+                text = "$passSatId - ",
+                color = MaterialTheme.colorScheme.primary
+            )
             Text(
                 text = item.name,
                 modifier = Modifier.weight(1f),
                 fontWeight = FontWeight.Medium,
                 maxLines = 1,
                 overflow = TextOverflow.Ellipsis,
-                color = MaterialTheme.colorScheme.onSurface
+                color = MaterialTheme.colorScheme.primary
             )
             Checkbox(
                 checked = item.isSelected,

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

@@ -30,6 +30,8 @@ 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.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
@@ -41,11 +43,13 @@ 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.res.painterResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.source.Sources
 import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
 import com.rtbishop.look4sat.core.presentation.CardButton
 import com.rtbishop.look4sat.core.presentation.LocalSpacing
@@ -203,6 +207,17 @@ fun DataSourcesDialog(
                 singleLine = true,
                 modifier = Modifier.fillMaxWidth(),
                 enabled = isEnabledCustomTle.value,
+                trailingIcon = {
+                    IconButton(
+                        onClick = { urlTle.value = Sources.defaultTleUrl },
+                        enabled = isEnabledCustomTle.value
+                    ) {
+                        Icon(
+                            painter = painterResource(id = R.drawable.ic_reset),
+                            contentDescription = stringResource(id = R.string.prefs_data_reset_url)
+                        )
+                    }
+                },
             )
             Spacer(modifier = Modifier.height(6.dp))
             Row(
@@ -232,6 +247,17 @@ fun DataSourcesDialog(
                 singleLine = true,
                 modifier = Modifier.fillMaxWidth(),
                 enabled = isEnabledCustomTransceivers.value,
+                trailingIcon = {
+                    IconButton(
+                        onClick = { urlTransceivers.value = Sources.defaultTransceiversUrl },
+                        enabled = isEnabledCustomTransceivers.value
+                    ) {
+                        Icon(
+                            painter = painterResource(id = R.drawable.ic_reset),
+                            contentDescription = stringResource(id = R.string.prefs_data_reset_url)
+                        )
+                    }
+                },
             )
             Spacer(modifier = Modifier.height(12.dp))
         }

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

@@ -22,15 +22,26 @@ import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.GridItemSpan
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
@@ -40,15 +51,28 @@ import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
+import kotlin.math.roundToInt
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
+import androidx.compose.ui.zIndex
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.LocalContext
@@ -299,6 +323,15 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
                 )
             }
             item { OtherCard(uiState.otherSettings, onAction) }
+            item {
+                UiSettingsCard(
+                    hiddenScreens = uiState.otherSettings.hiddenScreens,
+                    screenOrder = uiState.otherSettings.screenOrder,
+                    onToggle = { name -> onAction(SettingsAction.ToggleScreen(name)) },
+                    onReorder = { order -> onAction(SettingsAction.ReorderScreens(order)) },
+                    onResetOrder = { onAction(SettingsAction.ResetScreenOrder) }
+                )
+            }
             item { CardCredits() }
         }
     }
@@ -339,6 +372,8 @@ private fun LocationCard(
             Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
                 Text(text = "Lat: ${settings.stationPos.latitude}°")
                 Text(text = "Lon: ${settings.stationPos.longitude}°")
+            }
+            Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
                 Text(text = "Qth: ${settings.stationPos.qthLocator}")
             }
             Spacer(modifier = Modifier.height(1.dp))
@@ -484,11 +519,12 @@ private fun OtherCardPreview() = MainTheme {
 @Composable
 private fun OtherCard(settings: OtherSettings, onAction: (SettingsAction) -> Unit) {
     ElevatedCard(
-        modifier = Modifier
-            .fillMaxWidth()
-            .height(268.dp)
+        modifier = Modifier.fillMaxWidth()
     ) {
-        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
+        Column(
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
+            verticalArrangement = Arrangement.spacedBy(4.dp)
+        ) {
             Text(
                 text = stringResource(id = R.string.prefs_other_title),
                 color = MaterialTheme.colorScheme.primary
@@ -512,8 +548,146 @@ private fun OtherCard(settings: OtherSettings, onAction: (SettingsAction) -> Uni
     }
 }
 
+/**
+ * UI 设置卡片: 控制底部菜单栏各页面显示/隐藏。
+ * 顺序固定(卫星/过境/雷达/匹配/漫游/地图/设置), 关闭后其余自动靠拢;
+ * "设置"页固定显示(防止失去设置入口)。
+ */
 @Composable
-private fun SwitchRow(labelResId: Int, checked: Boolean, onCheckedChange: (Boolean) -> Unit) {
+private fun UiSettingsCard(
+    hiddenScreens: List<String>,
+    screenOrder: List<String>,
+    onToggle: (String) -> Unit,
+    onReorder: (List<String>) -> Unit,
+    onResetOrder: () -> Unit
+) {
+    val screens = listOf(
+        R.string.nav_sat to "Satellites",
+        R.string.nav_pass to "Passes",
+        R.string.nav_radar to "Radar",
+        R.string.nav_mutual to "Mutual",
+        R.string.nav_roaming to "Roaming",
+        R.string.nav_map to "Map",
+        R.string.nav_prefs to "Settings"
+    ) // name 必须与 Screen.screenId 一致 (R8 安全)
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
+            verticalArrangement = Arrangement.spacedBy(4.dp)
+        ) {
+            Text(
+                text = stringResource(id = R.string.prefs_ui_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            screens.forEach { (labelRes, name) ->
+                if (name == "Settings") {
+                    // 设置页固定显示, 开关禁用
+                    SwitchRow(labelRes, true, null)
+                } else {
+                    SwitchRow(labelRes, name !in hiddenScreens) {
+                        onToggle(name)
+                    }
+                }
+            }
+            Text(
+                text = stringResource(id = R.string.prefs_ui_order_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            DragOrderList(screens = screens, screenOrder = screenOrder, onReorder = onReorder)
+            TextButton(onClick = onResetOrder) {
+                Text(text = stringResource(id = R.string.prefs_ui_order_reset))
+            }
+        }
+    }
+}
+
+/** 页面顺序拖拽列表: 每行右侧抓手, 按住上下拖动实时换位, 松手持久化 */
+@Composable
+private fun DragOrderList(
+    screens: List<Pair<Int, String>>,
+    screenOrder: List<String>,
+    onReorder: (List<String>) -> Unit
+) {
+    val itemHeight = 48.dp
+    val itemHeightPx = with(LocalDensity.current) { itemHeight.toPx() }
+    // 按 screenOrder 排序(空 = 默认顺序); remember 以 screens 参数为 key, 持久化后重组
+    val ordered = remember(screens, screenOrder) {
+        screens.sortedBy { (_, name) ->
+            screenOrder.indexOf(name).let { if (it == -1) Int.MAX_VALUE else it }
+        }
+    }
+    val listState = rememberLazyListState()
+    val items = remember(ordered) { mutableStateListOf<Pair<Int, String>>().apply { addAll(ordered) } }
+    var draggingIndex by remember { mutableIntStateOf(-1) }
+    var dragOffset by remember { mutableStateOf(0f) }
+
+    // 固定高度: 嵌套在 LazyVerticalGrid 内必须给有界高度, 否则无限高度约束崩溃
+    LazyColumn(
+        state = listState,
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(itemHeight * items.size)
+    ) {
+        itemsIndexed(items, key = { _, s -> s.second }) { index, screen ->
+            val isDragging = draggingIndex == index
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(itemHeight)
+                    .zIndex(if (isDragging) 1f else 0f)
+                    .graphicsLayer { translationY = if (isDragging) dragOffset else 0f }
+                    .animateItem()
+            ) {
+                Text(
+                    text = stringResource(id = screen.first),
+                    modifier = Modifier.weight(1f)
+                )
+                Box(
+                    modifier = Modifier
+                        .size(48.dp)
+                        .padding(20.dp)
+                        .pointerInput(screen.second) {
+                            detectDragGestures(
+                                onDragStart = { draggingIndex = items.indexOf(screen) },
+                                onDrag = { change, dragAmount ->
+                                    change.consume()
+                                    dragOffset += dragAmount.y
+                                    val currentIndex = draggingIndex
+                                    val target = (currentIndex + (dragOffset / itemHeightPx).roundToInt())
+                                        .coerceIn(0, items.size - 1)
+                                    if (target != currentIndex) {
+                                        items.add(target, items.removeAt(currentIndex))
+                                        dragOffset += (currentIndex - target) * itemHeightPx
+                                        draggingIndex = target
+                                    }
+                                },
+                                onDragEnd = {
+                                    onReorder(items.map { it.second })
+                                    draggingIndex = -1
+                                    dragOffset = 0f
+                                },
+                                onDragCancel = {
+                                    draggingIndex = -1
+                                    dragOffset = 0f
+                                }
+                            )
+                        }
+                ) {
+                    // 小圆点手柄(触控区 padding 20dp 居中 -> 8dp 圆点)
+                    Box(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .background(MaterialTheme.colorScheme.onSurfaceVariant, CircleShape)
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun SwitchRow(labelResId: Int, checked: Boolean, onCheckedChange: ((Boolean) -> Unit)?) {
     Row(
         horizontalArrangement = Arrangement.SpaceBetween,
         verticalAlignment = Alignment.CenterVertically,
@@ -556,15 +730,11 @@ private fun CardCreditsPreview() = MainTheme { CardCredits() }
 @Composable
 private fun CardCredits(modifier: Modifier = Modifier) {
     ElevatedCard(
-        modifier = modifier
-            .fillMaxWidth()
-            .height(268.dp)
+        modifier = modifier.fillMaxWidth()
     ) {
         Column(
-            verticalArrangement = Arrangement.SpaceBetween,
-            modifier = Modifier
-                .padding(horizontal = 8.dp, vertical = 4.dp)
-                .fillMaxHeight()
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
         ) {
             Text(
                 text = stringResource(id = R.string.prefs_outro_title),
@@ -573,6 +743,8 @@ private fun CardCredits(modifier: Modifier = Modifier) {
             Text(
                 text = stringResource(id = R.string.prefs_outro_thanks)
             )
+            // 感谢列表与保修声明之间保留约两行间距 (用户要求)
+            Spacer(modifier = Modifier.height(24.dp))
             Text(
                 text = stringResource(id = R.string.prefs_outro_license),
                 color = MaterialTheme.colorScheme.primary
@@ -588,7 +760,7 @@ private fun TopCard(onClick: () -> Unit, modifier: Modifier = Modifier, version:
             horizontalArrangement = Arrangement.spacedBy(12.dp),
             verticalAlignment = Alignment.CenterVertically,
             modifier = Modifier
-                .height(48.dp)
+                .heightIn(min = 48.dp)
                 .clickable { onClick() }) {
             Spacer(Modifier)
             Icon(
@@ -603,7 +775,6 @@ private fun TopCard(onClick: () -> Unit, modifier: Modifier = Modifier, version:
                 modifier = Modifier
                     .weight(1f)
                     .padding(end = 6.dp)
-                    .infiniteMarquee()
             )
         }
     }

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

@@ -64,6 +64,12 @@ sealed interface SettingsAction {
     data class ToggleSensor(val value: Boolean) : SettingsAction
     data class ToggleLightTheme(val value: Boolean) : SettingsAction
     data class ToggleNightMode(val value: Boolean) : SettingsAction
+    // UI 设置: 切换底部导航栏页面的隐藏状态(Screen simpleName)
+    data class ToggleScreen(val screenName: String) : SettingsAction
+    // UI 设置: 更新页面顺序
+    data class ReorderScreens(val order: List<String>) : SettingsAction
+    // UI 设置: 重置为默认顺序
+    data object ResetScreenOrder : SettingsAction
 
     // Remote control
     data class UpdateRC(val settings: RCSettings) : SettingsAction

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

@@ -121,6 +121,13 @@ 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.ToggleScreen -> settingsRepo.updateOtherSettings { current ->
+                val hidden = current.hiddenScreens.toMutableList()
+                if (action.screenName in hidden) hidden.remove(action.screenName) else hidden.add(action.screenName)
+                current.copy(hiddenScreens = hidden)
+            }
+            is SettingsAction.ReorderScreens -> settingsRepo.updateOtherSettings { it.copy(screenOrder = action.order) }
+            SettingsAction.ResetScreenOrder -> settingsRepo.updateOtherSettings { it.copy(screenOrder = emptyList()) }
             // Remote control & data sources
             is SettingsAction.UpdateRC -> settingsRepo.updateRCSettings(action.settings)
             is SettingsAction.UpdateRadioControl -> settingsRepo.updateRadioControlSettings(action.settings)

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
 [versions]
 #noinspection UnusedVersionCatalogEntry
-appVersionCode = "443"
+appVersionCode = "449"
 #noinspection UnusedVersionCatalogEntry
-appVersionName = "4.4.3"
+appVersionName = "4.4.9"
 #noinspection UnusedVersionCatalogEntry
 compileSdk = "37"
 #noinspection UnusedVersionCatalogEntry
@@ -11,6 +11,11 @@ minSdk = "24"
 jdkVersion = "21"
 #noinspection UnusedVersionCatalogEntry
 packageName = "com.rtbishop.look4sat"
+# Fork application ID: official app uses com.rtbishop.look4sat with a different
+# signing cert. Installing a fork with the same applicationId would conflict
+# with the official build (signature mismatch / cannot overwrite), so the fork
+# ships under its own applicationId suffix.
+applicationId = "com.rtbishop.look4sat.bg7nta"
 
 android-gradle-plugin = "9.3.1"
 

settings.gradle.kts

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