fix: apply elevation color thresholds on radar page

LocalElevationThresholds was provided inside MainScreen, but RadarDestination is a root-level sibling entry in NavRoot's NavDisplay, so the radar page's top bar fell outside the CompositionLocal scope and always used the default 15/45 thresholds instead of the user-configured ones. Hoist the CompositionLocalProvider to NavRoot so both the tab content and the root-level RadarDestination read the user's low/high elevation thresholds, and drop the now-redundant provider from MainScreen.
v4.4.7 - Data import overhaul, AMSAT reports, Map tweaks
2026-10-02 19:17:21 +00:00 · 2026-09-16 04:17:52 +08:00 · 2026-09-13 20:26:27 +01:00 · 2026-09-13 17:29:38 +01:00 · 2026-09-13 15:19:23 +01:00 · 2026-09-12 11:40:59 +01:00
177 changed files with 5936 additions and 17218 deletions
@@ -4,3 +4,7 @@ updates:
    directory: "/"
    schedule:
      interval: "weekly"
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "never"
@@ -19,7 +19,7 @@ jobs:
        uses: actions/checkout@v7

      - name: Setup Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v6
        with:
          distribution: 'temurin'
          java-version: '21'
@@ -1,9 +1,6 @@
 # Built application files
 *.ap_

-# Hermes AI plans and metadata
-.hermes/
-
 # Files for the ART/Dalvik VM
 *.dex

@@ -18,7 +15,6 @@ out/
 # Gradle files
 .gradle/
 build/
-.cxx/

 # Local configuration file (sdk path, etc)
 local.properties
@@ -68,3 +64,4 @@ fastlane/readme.md
 /app/release/output-metadata.json
 /app/release/
 /.kotlin/sessions/
+.hermes/
@@ -8,16 +8,15 @@ All assistant-specific files (`CLAUDE.md`, `.github/copilot-instructions.md`) po
 ## Project Overview

 Look4Sat is an open-source, fully offline Android satellite tracker and pass predictor. It tracks 9000+ active
-satellites using TLE/OMM data from Celestrak/SatNOGS, calculates orbital positions via SGP4/SDP4 models, and displays
-passes relative to the user's location. Features include polar radar visualization, SSTV image decoding, satellite
-ground track mapping, and pass predictions up to 10 days ahead. No ads, no tracking, no network required after initial
-data download.
+satellites using Celestrak/SatNOGS orbital data, calculates positions via SGP4/SDP4, and predicts passes relative to
+the user's location. Features include polar radar visualization, SSTV image decoding, and ground track mapping. No ads,
+no tracking, no network required after initial data download.

-## Architecture
+## Architecture & Design

 **MVI (Model-View-Intent)** with unidirectional data flow:
- `State` data class → exposed via `StateFlow` from ViewModel
- `Action` sealed interface → user intents dispatched to ViewModel's `onAction()`
+- `State` data class (named `<Feature>State`) exposed via `StateFlow` from ViewModel
+- `Action` sealed interface (named `<Feature>Action`) dispatched to ViewModel's `onAction()`
 - Jetpack Compose UI observes state and recomposes reactively

 **Clean Architecture layers:**
@@ -34,9 +33,11 @@ data download.
 | `feature:satellites` | Satellite list, filtering, selection                                |
 | `feature:settings`   | User preferences                                                    |

- `feature:*` modules depend only on `core:domain` + `core:presentation`. Features never depend on each other.
+**Feature isolation:**
+- `feature:*` modules depend only on `core:domain` and `core:presentation`.
+- No feature-to-feature dependencies; cross-feature communication goes through core layers.

-## Build & Run
+## Build & Platform

 ```shell
 # Debug build
@@ -50,54 +51,55 @@ data download.
 ```

 - **Min SDK**: 24 | **Target SDK**: 36 | **JDK**: 17
- **Gradle**: Uses version catalog (`gradle/libs.versions.toml`) + convention plugins in `build-logic/`
+- **Gradle**: Version catalog in `gradle/libs.versions.toml` + convention plugins in `build-logic/`

-## Key Libraries
+## Tech Stack

 - **Compose** (BOM 2026.05.01) + Material3 Adaptive
- **Navigation3** (type-safe, uses `@Serializable` NavKeys)
- **Room** (KSP code generation) for local satellite/TLE storage
- **OkHttp** 5.x for TLE downloads
+- **Navigation3**: Type-safe navigation with `@Serializable` nav keys
+- **Room** (KSP code generation) for local satellite/orbital storage
+- **OkHttp** 5.x for data downloads
 - **OSMDroid** for map rendering
- **Kotlin Serialization** for navigation args and data parsing
+- **Kotlin Serialization** for navigation args and parsing
 - **Coroutines** + `StateFlow` for async/reactive patterns
-
-## Conventions
-
- **Minimal dependencies**: Avoid adding libraries when a simple manual solution exists. Fewer deps = less maintenance.
- **DI**: Manual — ViewModels use companion `factory()` methods with `IMainContainer` interface.
- **Navigation**: Type-safe Compose Navigation3 with `@Serializable` data classes as nav keys.
- **State naming**: `<Feature>State` data class + `<Feature>Action` sealed interface per feature.
- **No feature-to-feature deps**: All cross-feature communication goes through core layers.
- **Localization**: 7 languages (en, es, ru, si, tr, uk, zh).
+- **Localization**: 7 languages (en, es, ru, si, tr, uk, zh)

 ## Data Formats & Migration

-**TLE vs. OMM/CSV format:**
+Look4Sat supports both TLE and OMM (Orbit Mean-Elements Message) CSV formats:

-Look4Sat supports both TLE and OMM (Orbit Mean-Elements Message) formats for backward compatibility:
+- **TLE format**: Legacy 3-line element format limited by 5-digit NORAD IDs
+- **OMM/CSV format**: Successor format with ISO 8601 timestamps and larger NORAD ID support
+- New 5-digit NORAD IDs are exhausted; TLE is officially deprecated and OMM/CSV is the clear default
+- `DataParser.kt` supports both via `parseTLEStream()` and `parseCSVStream()`
+- Downloads auto-detect format; both produce identical `OrbitalData` objects
+- Existing code already supports transparent source transition without feature changes
+- Refresh orbital data weekly for accurate pass prediction (orbital decay)

- **TLE format**: Traditional 3-line element format (deprecated). NORAD catalog numbers are 5-digit integers, which
-  are running out of space. Celestrak has signaled that TLE format will eventually be phased out.
- **OMM/CSV format**: The future standard. CSV files contain the same orbital parameters as TLE but use ISO 8601
-  timestamps and support larger NORAD IDs. Celestrak and SatNOGS already provide OMM data in CSV format.
+## Engineering Heuristics (Lazy = Efficient)

-**Current implementation:**
- `DataParser.kt` handles both `parseTLEStream()` and `parseCSVStream()` seamlessly
- TLE data is downloaded from configured sources and stored in Room database
- When downloading satellite data, the app automatically detects format and parses accordingly
- Both formats produce identical `OrbitalData` objects, ensuring transparent format switching
+- Treat "lazy" as efficient, not careless: the best code is the code never written.
+- First understand the task and trace the real flow end-to-end, then climb this ladder:
+  1. Does this need to be built now? (YAGNI)
+  2. Does it already exist in this codebase? Reuse helpers/patterns before rewriting.
+  3. Does Kotlin/Java stdlib already solve it?
+  4. Does the Android/platform API already solve it?
+  5. Does an already-installed dependency solve it?
+  6. Can this be simpler (including one-liner simple)?
+  7. Only then: write the minimum code that works.
+- Prefer deletion to addition, boring over clever, and the fewest touched files.
+- Avoid new abstractions, dependencies, and boilerplate unless explicitly requested.
+- Manual DI only: ViewModels use companion `factory()` methods with `IMainContainer`.
+- Release builds use ProGuard: avoid reflection-heavy libraries unless explicitly approved.
+- When two options are similar in size, choose the edge-case-correct one.
+- If you keep a deliberate simplification (for example O(n^2) scan or global lock), leave a short comment with the ceiling and upgrade path.
+- For complex asks, challenge scope when appropriate: "Do you need X, or does Y already cover it?"

-**Migration path:**
-As NORAD catalog space becomes constrained, OMM/CSV will become the primary format. Look4Sat is already positioned
-to handle this transition without code changes — existing users can continue using TLE files while new sources
-transition to OMM/CSV automatically.
+## Bug-Fix Policy

-## Code Style
-
- Prefer **short, focused functions** — single responsibility, easy to read.
- **Exceptions**: Composable functions and math-heavy algorithms (SGP4/SDP4) may be longer.
- Strict code style — no dead code, no unused imports, consistent formatting.
+- Fix root cause, not just the reported symptom.
+- If touching a shared function, inspect callers and prefer one shared fix over per-caller patches.
+- The smallest correct diff wins only after behavior is understood.

 ## Roadmap

@@ -105,12 +107,9 @@ transition to OMM/CSV automatically.

 ## Gotchas

- Orbital math lives in `core:domain/predict/` — it's dense vector math (SGP4/SDP4). Tread carefully.
- TLE/OMM data must be refreshed weekly for accurate predictions (satellite orbits decay). TLE format is legacy and
-  will eventually be deprecated in favor of OMM/CSV as NORAD catalog numbers approach the 5-digit limit.
+- Orbital math lives in `core:domain/predict/` — dense vector math (SGP4/SDP4). Tread carefully.
 - SSTV decoding in `feature:radar` is experimental; image quality depends on signal strength during satellite pass.
- `build-logic/convention/` contains all shared Gradle configuration — edit there, not in individual modules.
- ProGuard is enabled for release builds — don't add reflection-based libs or any other dependencies without asking.
+- `build-logic/convention/` contains shared Gradle configuration — edit there, not in individual modules.

 ## Copilot Working Mode: Code-Only

@@ -1,26 +1,45 @@
-# Look4Sat-BA7OPF
+# Look4Sat: Satellite tracker

-[![Release](https://img.shields.io/github/v/release/atsunatsu/Look4Sat)](https://github.com/atsunatsu/Look4Sat/releases)
+[![Look4Sat CI](https://github.com/rt-bishop/Look4Sat/actions/workflows/release.yml/badge.svg)](https://github.com/rt-bishop/Look4Sat/actions/workflows/release.yml)

-**BA7OPF 定制版** — 基于 [rt-bishop/Look4Sat](https://github.com/rt-bishop/Look4Sat) 的业余无线电卫星追踪器，增加了线性卫星频率计算器等功能。
+[<img src="https://play.google.com/intl/en_gb/badges/static/images/badges/en_badge_web_generic.png" alt="Get it on Google Play" height="80">](https://play.google.com/store/apps/details?id=com.rtbishop.look4sat)
+[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="80">](https://f-droid.org/packages/com.rtbishop.look4sat/)

-## 本仓库特色功能
+### Radio satellite tracker and pass predictor for Android, inspired by Gpredict

- **线性卫星转发器频率计算器** — 在雷达页的 Calculator 标签页中，支持 TX/RX 双向多普勒频率计算，以及下行频率偏移（offset）输入，方便操作带偏移的线性卫星
- **CW 解码器** — 集成 Morse Expert 解码引擎，支持瀑布图、实时解码文本
- **Passband 模式** — 支持通过位置滑块（Passband）自动计算 TX/RX 频率，避免切换时跳变
- **中文界面优化** — 翻译修正、UI 布局调整
+<p float="left">
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/1.png" width="192"/>
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/2.png" width="192"/>
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/3.png" width="192"/>
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/4.png" width="192">
+</p>

-## 上游仓库
+### Track satellite passes with ease!

-本仓库是 [rt-bishop/Look4Sat](https://github.com/rt-bishop/Look4Sat) 的分支，上游仓库的原始功能包括：
+Thanks to [Celestrak](https://celestrak.com/) and [SatNOGS](https://satnogs.org/) you have access to over 9000 active satellites.\
+You can search the entire database by NORAD Catalog Number or the satellite's name.

- 基于 Celestrak / SatNOGS 数据的 9000+ 活跃卫星追踪
- SGP4/SDP4 轨道预测，10 天过境预报
- 极坐标雷达图、地面轨迹图
- SSTV 图像解码
- 无广告、无跟踪、完全离线
+Orbital positions and passes are calculated relative to your location.\
+To get reliable data make sure to set the station position via the app Settings.

-## 许可证
+The application is built using Kotlin, Coroutines, Jetpack Compose and Navigation.\
+It is now and always will be completely ad-free and open-source.

-GNU General Public License v3.0。详见 [LICENSE](LICENSE)。
+## Main features:
+
+*  Predicting satellite positions and passes for up to 10 days
+*  Showing the list of currently active and upcoming satellite passes
+*  Showing the active pass progress, polar trajectory and transceivers info
+*  Showing the satellite positional data, footprint and ground track on the map
+*  Custom TLE satellite data import is available via Three Line Element .txt files
+*  Offline first: calculations are made offline. Weekly TLE data update is recommended.
+
+## Star History
+
+<a href="https://star-history.dera.page/#rt-bishop/Look4Sat&type=timeline&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://star-history.dera.page/svg?repos=rt-bishop/Look4Sat&type=timeline&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://star-history.dera.page/svg?repos=rt-bishop/Look4Sat&type=timeline&legend=top-left" />
+   <img alt="Star History Chart" src="https://star-history.dera.page/svg?repos=rt-bishop/Look4Sat&type=timeline&legend=top-left" />
+ </picture>
+</a>
@@ -1,24 +1,3 @@
 plugins {
    alias(libs.plugins.convention.applicationPlugin)
 }
-
-android {
-    namespace = libs.versions.packageName.get()
-    defaultConfig {
-        applicationId = "cn.ba7opf.look4sat"
-        ndk { abiFilters.add("armeabi-v7a") }
-    }
-    signingConfigs {
-        create("release") {
-            storeFile = file(System.getProperty("user.home") + "/my-release-key.jks")
-            storePassword = "look4sat123"
-            keyAlias = "look4sat"
-            keyPassword = "look4sat123"
-        }
-    }
-    buildTypes {
-        release {
-            signingConfig = signingConfigs.getByName("release")
-        }
-    }
-}
@@ -25,7 +25,6 @@
        <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" />
@@ -49,7 +49,7 @@ class MainActivity : ComponentActivity() {
        super.onCreate(savedInstanceState)
        observeNightFilterState()
        setContent {
-            MainTheme(isDarkTheme = true) { MainScreen() }
+            MainTheme(isDarkTheme = true) { NavRoot() }
        }
    }

@@ -25,8 +25,6 @@ import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
 import androidx.compose.animation.slideInHorizontally
 import androidx.compose.animation.slideOutHorizontally
 import androidx.compose.animation.togetherWith
@@ -44,7 +42,7 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteDefaults
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold
@@ -63,16 +61,15 @@ 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.R
+import com.rtbishop.look4sat.core.domain.repository.RadioTrackingState
 import com.rtbishop.look4sat.core.presentation.DeeplinkResolver
 import com.rtbishop.look4sat.core.presentation.ElevationThresholds
 import com.rtbishop.look4sat.core.presentation.LocalElevationThresholds
@@ -81,203 +78,200 @@ import com.rtbishop.look4sat.core.presentation.Screen
 import com.rtbishop.look4sat.core.presentation.hasEnoughHeight
 import com.rtbishop.look4sat.core.presentation.hasEnoughWidth
 import com.rtbishop.look4sat.feature.map.MapDestination
-import com.rtbishop.look4sat.feature.mutual.MutualScreen
-import com.rtbishop.look4sat.feature.mutual.MutualViewModel
 import com.rtbishop.look4sat.feature.passes.PassesDestination
 import com.rtbishop.look4sat.feature.radar.RadarDestination
 import com.rtbishop.look4sat.feature.satellites.SatellitesDestination
 import com.rtbishop.look4sat.feature.settings.SettingsDestination
+import com.rtbishop.look4sat.feature.status.SatStatusDestination

@Composable
 fun NavRoot(deeplink: String? = null) {
    val rootBackStack = rememberNavBackStack(Screen.Passes)
    val deeplinkResolver = DeeplinkResolver()
    LaunchedEffect(deeplink) {
-        deeplink?.let {
-            val destination = deeplinkResolver.resolve(it) // rootBackStack.clear()
-            rootBackStack.add(destination)
-        }
+        deeplink?.let { rootBackStack.add(deeplinkResolver.resolve(it)) }
    }
    val navigateBack: () -> Unit = { rootBackStack.removeLastOrNull() }
-    val slideInTransition = slideInHorizontally(initialOffsetX = { it }) togetherWith scaleOut(targetScale = 0.9f)
-    val slideOutTransition = scaleIn(initialScale = 0.9f) togetherWith slideOutHorizontally(targetOffsetX = { it })
-    NavDisplay(
-        modifier = Modifier.fillMaxSize(),
-        backStack = rootBackStack,
-        onBack = navigateBack,
-        transitionSpec = { slideInTransition },
-        popTransitionSpec = { slideOutTransition },
-        predictivePopTransitionSpec = { slideOutTransition },
-        entryDecorators = listOf(
-            rememberSaveableStateHolderNavEntryDecorator(), // Required for saving Compose state per entry
-            rememberViewModelStoreNavEntryDecorator() // Required for ViewModel scoping per entry
-        ),
-        entryProvider = entryProvider {
-            entry<Screen.Passes> { MainScreen(navigateToRadar = { rootBackStack.add(RadarDestination) }) }
-            entry<RadarDestination> {
-                Scaffold { innerPadding ->
-                    RadarDestination(navigateUp = navigateBack)
-                    innerPadding.calculateTopPadding()
-                }
-            }
-        }
-    )
-}
-
-@Composable
-fun MainScreen(navigateToRadar: () -> Unit = {}) {
-    val backStack = rememberNavBackStack(Screen.Passes)
-    val currentKey = backStack.lastOrNull()
-    val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
-    val fadeTransition = fadeIn(animationSpec = tween(350)) togetherWith fadeOut(animationSpec = tween(350))
-    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Mutual, Screen.Map, Screen.Settings)
-
+    val navigateToRadar: () -> Unit = { rootBackStack.add(RadarDestination) }
+    // Incoming screen slides in from the right, outgoing drifts left at 1/3 speed (API35+ style)
+    val pushTransition = slideInHorizontally(tween(300)) { it } togetherWith
+        slideOutHorizontally(tween(300)) { -it / 3 }
+    // Reverse: outgoing slides out to the right, incoming drifts in from the left
+    val popTransition = slideInHorizontally(tween(300)) { -it / 3 } togetherWith
+        slideOutHorizontally(tween(300)) { it }
+    // Elevation color thresholds must be provided at the root level so that BOTH
+    // the tab content (MainScreen) and the root-level RadarDestination see the
+    // user's custom thresholds. RadarDestination is a sibling entry of MainScreen
+    // in this NavDisplay, so a provider inside MainScreen never reaches it.
    val context = LocalContext.current
    val container = (context.applicationContext as IContainerProvider).getMainContainer()
-    val trackingState by container.radioTrackingService.state.collectAsStateWithLifecycle()
    val otherSettings by container.settingsRepo.otherSettings.collectAsStateWithLifecycle()
-    // Activity-scoped so the mutual query results survive navigation to Radar and back
-    val mutualViewModel: MutualViewModel = viewModel(
-        viewModelStoreOwner = context as ViewModelStoreOwner,
-        factory = MutualViewModel.factory(container)
-    )
-
    CompositionLocalProvider(
        LocalElevationThresholds provides ElevationThresholds(
            low = otherSettings.lowElevation,
            high = otherSettings.highElevation
        )
    ) {
-        NavigationSuiteScaffold(
-            navigationSuiteItems = {
-                navItems.forEach { screen ->
-                    val isSelected = when (currentKey) {
-                        is Screen.Satellites -> screen is Screen.Satellites
-                        is Screen.Passes -> screen is Screen.Passes
-                        is Screen.Radar -> screen is Screen.Radar
-                        is Screen.Mutual -> screen is Screen.Mutual
-                        is Screen.Map -> screen is Screen.Map
-                        is Screen.Settings -> screen is Screen.Settings
-                        else -> false
-                    }
-                    item(
-                        icon = { Icon(painterResource(screen.iconResId), stringResource(screen.titleResId)) },
-                        label = { Text(stringResource(screen.titleResId)) },
-                        selected = isSelected,
-                        onClick = {
-                            if (isSelected) return@item
-                            while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
-                            if (screen !is Screen.Passes) backStack.add(screen)
-                        }
-                    )
-                }
-            },
-            navigationSuiteColors = NavigationSuiteDefaults.colors(
-                navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
+        NavDisplay(
+            modifier = Modifier.fillMaxSize(),
+            backStack = rootBackStack,
+            onBack = navigateBack,
+            transitionSpec = { pushTransition },
+            popTransitionSpec = { popTransition },
+            predictivePopTransitionSpec = { popTransition },
+            entryDecorators = listOf(
+                rememberSaveableStateHolderNavEntryDecorator(),
+                rememberViewModelStoreNavEntryDecorator()
            ),
-            layoutType = when {
-                !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
-                !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
-                else -> NavigationSuiteType.ShortNavigationBarMedium
+            entryProvider = entryProvider {
+                entry<Screen.Passes> { MainScreen(navigateToRadar = navigateToRadar) }
+                entry<RadarDestination> {
+                    Surface(
+                        modifier = Modifier.fillMaxSize(),
+                        color = MaterialTheme.colorScheme.background
+                    ) {
+                        RadarDestination(navigateUp = navigateBack)
+                    }
+                }
            }
-        ) {
-            Column {
-                NavDisplay(
-                    backStack = backStack,
-                    modifier = Modifier.weight(1f),
-                    onBack = navigateBack,
-                    transitionSpec = { fadeTransition },
-                    popTransitionSpec = { fadeTransition },
-                    predictivePopTransitionSpec = { fadeTransition },
-                    entryDecorators = listOf(
-                        // Required for saving Compose state per entry
-                        rememberSaveableStateHolderNavEntryDecorator(),
-                        // Required for ViewModel scoping per entry
-                        rememberViewModelStoreNavEntryDecorator()
-                    ),
-                    entryProvider = entryProvider {
-                        entry<Screen.Satellites> {
-                            SatellitesDestination(navigateUp = navigateBack)
+        )
+    }
+}
+
+@Composable
+private fun MainScreen(navigateToRadar: () -> Unit = {}) {
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val trackingState by container.radioTrackingService.state.collectAsStateWithLifecycle()
+
+    val backStack = rememberNavBackStack(Screen.Passes)
+    val currentKey = backStack.lastOrNull()
+    val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
+    val fadeTransition = fadeIn(animationSpec = tween(300)) togetherWith
+        fadeOut(animationSpec = tween(300))
+    val navItems =
+        listOf(Screen.Satellites, Screen.Passes, Screen.Status, Screen.Map, Screen.Settings)
+
+    NavigationSuiteScaffold(
+        navigationSuiteItems = {
+            navItems.forEach { screen ->
+                val isSelected = when (currentKey) {
+                    is Screen.Satellites -> screen is Screen.Satellites
+                    is Screen.Passes -> screen is Screen.Passes
+                    is Screen.Status -> screen is Screen.Status
+                    is Screen.Map -> screen is Screen.Map
+                    is Screen.Settings -> screen is Screen.Settings
+                    else -> false
+                }
+                item(
+                    icon = {
+                        Icon(
+                            painter = painterResource(screen.iconResId),
+                            contentDescription = stringResource(screen.titleResId)
+                        )
+                    },
+                    label = { Text(stringResource(screen.titleResId)) },
+                    selected = isSelected,
+                    onClick = {
+                        if (isSelected) return@item
+                        while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+                        if (screen !is Screen.Passes) backStack.add(screen)
+                    }
+                )
+            }
+        },
+        navigationSuiteColors = NavigationSuiteDefaults.colors(
+            navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
+        ),
+        layoutType = when {
+            !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
+            !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
+            else -> NavigationSuiteType.ShortNavigationBarMedium
+        }
+    ) {
+        Column {
+            NavDisplay(
+                backStack = backStack,
+                modifier = Modifier.weight(1f),
+                onBack = navigateBack,
+                transitionSpec = { fadeTransition },
+                popTransitionSpec = { fadeTransition },
+                predictivePopTransitionSpec = { fadeTransition },
+                entryDecorators = listOf(
+                    rememberSaveableStateHolderNavEntryDecorator(),
+                    rememberViewModelStoreNavEntryDecorator()
+                ),
+                entryProvider = entryProvider {
+                    entry<Screen.Satellites> {
+                        SatellitesDestination(navigateUp = navigateBack)
+                    }
+                    entry<Screen.Passes> {
+                        PassesDestination { catNum, aosTime ->
+                            container.satelliteRepo.selectPass(catNum, aosTime)
+                            navigateToRadar()
                        }
-                        entry<Screen.Passes> {
-                            PassesDestination { catNum, aosTime ->
-                                container.setMutualPassData(MutualPassData())
-                                container.satelliteRepo.selectPass(catNum, aosTime)
-                                backStack.add(Screen.Radar)
-//                            navigateToRadar()
-                            }
-                        }
-                        entry<Screen.Radar> {
-                            RadarDestination(navigateUp = navigateBack)
-                        }
-                        entry<Screen.Map> {
-                            MapDestination()
-                        }
-                        entry<Screen.Mutual> {
-                            MutualScreen(
-                                viewModel = mutualViewModel,
-                                navigateUp = navigateBack,
-                                navigateToRadar = { catNum, aosTime, pass ->
-                                    container.setMutualPassData(pass ?: MutualPassData())
-                                    container.satelliteRepo.selectPass(catNum, aosTime)
-                                    backStack.add(Screen.Radar)
-                                }
-                            )
-                        }
-                        entry<Screen.Settings> {
-                            SettingsDestination()
+                    }
+                    entry<Screen.Status> { SatStatusDestination() }
+                    entry<Screen.Map> { MapDestination() }
+                    entry<Screen.Settings> { SettingsDestination() }
+                }
+            )
+            if (trackingState.isActive) {
+                TrackingBanner(
+                    state = trackingState,
+                    onClick = {
+                        val pass = trackingState.currentPass
+                        if (pass != null) {
+                            container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
+                            navigateToRadar()
                        }
                    }
                )
-                // Radio tracking status banner
-                if (trackingState.isActive) {
-                    val infiniteTransition = rememberInfiniteTransition(label = "trackingPulse")
-                    val alpha by infiniteTransition.animateFloat(
-                        initialValue = 1f, targetValue = 0.4f,
-                        animationSpec = infiniteRepeatable(
-                            animation = tween(1000, easing = LinearEasing),
-                            repeatMode = RepeatMode.Reverse
-                        ), label = "pulseAlpha"
-                    )
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .background(MaterialTheme.colorScheme.primaryContainer)
-                            .clickable {
-                                val pass = trackingState.currentPass
-                                if (pass != null) {
-                                    container.setMutualPassData(MutualPassData())
-                                    container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
-                                    backStack.add(Screen.Radar)
-                                }
-                            }
-                            .padding(horizontal = 12.dp, vertical = 6.dp)
-                    ) {
-                        Box(
-                            modifier = Modifier
-                                .size(8.dp)
-                                .clip(CircleShape)
-                                .background(Color(0xFF4CAF50).copy(alpha = alpha))
-                        )
-                        Spacer(modifier = Modifier.width(8.dp))
-                        Text(
-                            text = "Tracking: ${trackingState.currentPass?.name ?: ""}",
-                            fontSize = 13.sp,
-                            fontWeight = FontWeight.Medium,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer,
-                            modifier = Modifier.weight(1f)
-                        )
-                        val txOk = if (trackingState.txConnected) "TX" else ""
-                        val rxOk = if (trackingState.rxConnected) "RX" else ""
-                        Text(
-                            text = listOf(txOk, rxOk).filter { it.isNotBlank() }.joinToString("/"),
-                            fontSize = 12.sp,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer
-                        )
-                    }
-                }
            }
        }
    }
 }
+
+@Composable
+private fun TrackingBanner(state: RadioTrackingState, onClick: () -> Unit) {
+    val infiniteTransition = rememberInfiniteTransition(label = "trackingPulse")
+    val alpha by infiniteTransition.animateFloat(
+        initialValue = 1f,
+        targetValue = 0.4f,
+        animationSpec = infiniteRepeatable(
+            animation = tween(1000, easing = LinearEasing), repeatMode = RepeatMode.Reverse
+        ),
+        label = "pulseAlpha"
+    )
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(MaterialTheme.colorScheme.primaryContainer)
+            .clickable(onClick = onClick)
+            .padding(horizontal = 12.dp, vertical = 6.dp)
+    ) {
+        Box(
+            modifier = Modifier
+                .size(8.dp)
+                .clip(CircleShape)
+                .background(Color(0xFF4CAF50).copy(alpha = alpha))
+        )
+        Spacer(modifier = Modifier.width(8.dp))
+        Text(
+            text = stringResource(R.string.tracking_format, state.currentPass?.name ?: ""),
+            fontSize = 13.sp,
+            fontWeight = FontWeight.Medium,
+            color = MaterialTheme.colorScheme.onPrimaryContainer,
+            modifier = Modifier.weight(1f)
+        )
+        val connections = listOfNotNull(
+            "TX".takeIf { state.txConnected }, "RX".takeIf { state.rxConnected }
+        )
+        Text(
+            text = connections.joinToString("/"),
+            fontSize = 12.sp,
+            color = MaterialTheme.colorScheme.onPrimaryContainer
+        )
+    }
+}
@@ -32,11 +32,11 @@ internal class ApplicationPlugin : Plugin<Project> {
            implementation(project(":core:domain"))
            implementation(project(":core:presentation"))
            implementation(project(":feature:map"))
-            implementation(project(":feature:mutual"))
            implementation(project(":feature:passes"))
            implementation(project(":feature:radar"))
            implementation(project(":feature:satellites"))
            implementation(project(":feature:settings"))
+            implementation(project(":feature:status"))
            implementation(libs.androidx.core.splashscreen)
            implementation(libs.compose.material3.adaptive)
            implementation(libs.compose.navigation3)
@@ -5,6 +5,46 @@ plugins {
    alias(libs.plugins.google.ksp) apply false
    alias(libs.plugins.kotlin.jvm) apply false
    alias(libs.plugins.kotlin.serialization) apply false
+    alias(libs.plugins.other.detekt)
+}
+
+val detektCheck = tasks.register<io.gitlab.arturbosch.detekt.Detekt>("detektCheck") {
+    description = "Checks that source code satisfies detekt rules."
+    autoCorrect = false
+}
+
+val detektApply = tasks.register<io.gitlab.arturbosch.detekt.Detekt>("detektApply") {
+    description = "Applies code formatting rules to source code in-place."
+    autoCorrect = true
+}
+
+configure(listOf(detektCheck, detektApply)) {
+    configure {
+        group = "verification"
+        parallel = true
+        ignoreFailures = false
+        setSource(file(rootDir))
+
+        // Custom detekt config
+        config.setFrom("$projectDir/config/detekt/detekt.yml")
+
+        // Use default configuration on top of custom config
+        // (new detect rules will work out of the box after upgrading detekt version)
+        buildUponDefaultConfig = true
+
+        // Runs detekt for all files in the Gradle project and all subprojects without
+        // a need to configure detekt plugin in every subproject.
+        include("**/*.kt", "**/*.kts")
+        exclude("**/resources/**", "**/build/**", "**/generated/**", "**/testing/**")
+
+        reports {
+            html.required.set(true)
+            xml.required.set(true)
+        }
+    }
+    dependencies {
+        detektPlugins(libs.other.detekt.formatting)
+    }
 }

 tasks.register("clean", Delete::class.java) {
@@ -0,0 +1,808 @@
+build:
+  maxIssues: 0
+  excludeCorrectable: false
+  weights:
+  # complexity: 2
+  # LongParameterList: 1
+  # style: 1
+  # comments: 1
+
+config:
+  validation: true
+  warningsAsErrors: false
+  checkExhaustiveness: false
+  # when writing own rules with new properties, exclude the property path e.g.: 'my_rule_set,.*>.*>[my_property]'
+  excludes: ''
+
+processors:
+  active: true
+  exclude:
+    - 'DetektProgressListener'
+  # - 'KtFileCountProcessor'
+  # - 'PackageCountProcessor'
+  # - 'ClassCountProcessor'
+  # - 'FunctionCountProcessor'
+  # - 'PropertyCountProcessor'
+  # - 'ProjectComplexityProcessor'
+  # - 'ProjectCognitiveComplexityProcessor'
+  # - 'ProjectLLOCProcessor'
+  # - 'ProjectCLOCProcessor'
+  # - 'ProjectLOCProcessor'
+  # - 'ProjectSLOCProcessor'
+  # - 'LicenseHeaderLoaderExtension'
+
+console-reports:
+  active: true
+  exclude:
+    - 'ProjectStatisticsReport'
+    - 'ComplexityReport'
+    - 'NotificationReport'
+    - 'FindingsReport'
+    - 'FileBasedFindingsReport'
+  #  - 'LiteFindingsReport'
+
+output-reports:
+  active: true
+  exclude:
+  # - 'TxtOutputReport'
+  # - 'XmlOutputReport'
+   - 'HtmlOutputReport'
+  # - 'MdOutputReport'
+  # - 'SarifOutputReport'
+
+comments:
+  active: true
+  AbsentOrWrongFileLicense:
+    active: false
+    licenseTemplateFile: 'license.template'
+    licenseTemplateIsRegex: false
+  CommentOverPrivateFunction:
+    active: false
+  CommentOverPrivateProperty:
+    active: false
+  DeprecatedBlockTag:
+    active: false
+  EndOfSentenceFormat:
+    active: false
+    endOfSentenceFormat: '([.?!][ \t\n\r\f<])|([.?!:]$)'
+  KDocReferencesNonPublicProperty:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+  OutdatedDocumentation:
+    active: false
+    matchTypeParameters: true
+    matchDeclarationsOrder: true
+    allowParamOnConstructorProperties: false
+  UndocumentedPublicClass:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    searchInNestedClass: true
+    searchInInnerClass: true
+    searchInInnerObject: true
+    searchInInnerInterface: true
+    searchInProtectedClass: false
+  UndocumentedPublicFunction:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    searchProtectedFunction: false
+  UndocumentedPublicProperty:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    searchProtectedProperty: false
+
+complexity:
+  active: true
+  CognitiveComplexMethod:
+    active: false
+    threshold: 15
+  ComplexCondition:
+    active: true
+    threshold: 4
+  ComplexInterface:
+    active: false
+    threshold: 10
+    includeStaticDeclarations: false
+    includePrivateDeclarations: false
+    ignoreOverloaded: false
+  CyclomaticComplexMethod:
+    active: true
+    threshold: 15
+    ignoreSingleWhenExpression: false
+    ignoreSimpleWhenEntries: false
+    ignoreNestingFunctions: false
+    nestingFunctions:
+      - 'also'
+      - 'apply'
+      - 'forEach'
+      - 'isNotNull'
+      - 'ifNull'
+      - 'let'
+      - 'run'
+      - 'use'
+      - 'with'
+    # Composables describe UI trees declaratively and naturally accumulate more branches than
+    # regular functions. Exclude them here and rely on code review + decomposition instead.
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*Screen.kt', '**/*Slots.kt' ]
+  LabeledExpression:
+    active: false
+    ignoredLabels: [ ]
+  LargeClass:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*Screen.kt', '**/*Slots.kt' ]
+    threshold: 600
+  LongMethod:
+    active: true
+    # Composable UI functions are declarative trees; 60 lines is too strict for them.
+    # Screen/Slots files are excluded — keep them reasonable via code review.
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*Screen.kt', '**/*Slots.kt' ]
+    threshold: 60
+  LongParameterList:
+    active: false
+    functionThreshold: 6
+    constructorThreshold: 7
+    ignoreDefaultParameters: false
+    ignoreDataClasses: true
+    ignoreAnnotatedParameter: [ ]
+  MethodOverloading:
+    active: false
+    threshold: 6
+  NamedArguments:
+    active: false
+    threshold: 3
+    ignoreArgumentsMatchingNames: false
+  NestedBlockDepth:
+    active: true
+    threshold: 4
+  NestedScopeFunctions:
+    active: false
+    threshold: 1
+    functions:
+      - 'kotlin.apply'
+      - 'kotlin.run'
+      - 'kotlin.with'
+      - 'kotlin.let'
+      - 'kotlin.also'
+  ReplaceSafeCallChainWithRun:
+    active: false
+  StringLiteralDuplication:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    threshold: 3
+    ignoreAnnotation: true
+    excludeStringsWithLessThan5Characters: true
+    ignoreStringsRegex: '$^'
+  TooManyFunctions:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    thresholdInFiles: 11
+    thresholdInClasses: 11
+    thresholdInInterfaces: 11
+    thresholdInObjects: 11
+    thresholdInEnums: 11
+    ignoreDeprecated: false
+    ignorePrivate: false
+    ignoreOverridden: false
+
+coroutines:
+  active: true
+  GlobalCoroutineUsage:
+    active: false
+  InjectDispatcher:
+    active: true
+    dispatcherNames:
+      - 'IO'
+      - 'Default'
+      - 'Unconfined'
+  RedundantSuspendModifier:
+    active: true
+  SleepInsteadOfDelay:
+    active: true
+  SuspendFunSwallowedCancellation:
+    active: false
+  SuspendFunWithCoroutineScopeReceiver:
+    active: false
+  SuspendFunWithFlowReturnType:
+    active: true
+
+empty-blocks:
+  active: true
+  EmptyCatchBlock:
+    active: true
+    allowedExceptionNameRegex: '_|(ignore|expected).*'
+  EmptyClassBlock:
+    active: true
+  EmptyDefaultConstructor:
+    active: true
+  EmptyDoWhileBlock:
+    active: true
+  EmptyElseBlock:
+    active: true
+  EmptyFinallyBlock:
+    active: true
+  EmptyForBlock:
+    active: true
+  EmptyFunctionBlock:
+    active: true
+    ignoreOverridden: true
+  EmptyIfBlock:
+    active: true
+  EmptyInitBlock:
+    active: true
+  EmptyKtFile:
+    active: true
+  EmptySecondaryConstructor:
+    active: true
+  EmptyTryBlock:
+    active: true
+  EmptyWhenBlock:
+    active: true
+  EmptyWhileBlock:
+    active: true
+
+exceptions:
+  active: true
+  ExceptionRaisedInUnexpectedLocation:
+    active: true
+    methodNames:
+      - 'equals'
+      - 'finalize'
+      - 'hashCode'
+      - 'toString'
+  InstanceOfCheckForException:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+  NotImplementedDeclaration:
+    active: false
+  ObjectExtendsThrowable:
+    active: false
+  PrintStackTrace:
+    active: true
+  RethrowCaughtException:
+    active: true
+  ReturnFromFinally:
+    active: true
+    ignoreLabeled: false
+  SwallowedException:
+    active: true
+    ignoredExceptionTypes:
+      - 'InterruptedException'
+      - 'MalformedURLException'
+      - 'NumberFormatException'
+      - 'ParseException'
+    allowedExceptionNameRegex: '_|(ignore|expected).*'
+  ThrowingExceptionFromFinally:
+    active: true
+  ThrowingExceptionInMain:
+    active: false
+  ThrowingExceptionsWithoutMessageOrCause:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    exceptions:
+      - 'ArrayIndexOutOfBoundsException'
+      - 'Exception'
+      - 'IllegalArgumentException'
+      - 'IllegalMonitorStateException'
+      - 'IllegalStateException'
+      - 'IndexOutOfBoundsException'
+      - 'NullPointerException'
+      - 'RuntimeException'
+      - 'Throwable'
+  ThrowingNewInstanceOfSameException:
+    active: true
+  TooGenericExceptionCaught:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    exceptionNames:
+      - 'ArrayIndexOutOfBoundsException'
+      - 'Error'
+      - 'Exception'
+      - 'IllegalMonitorStateException'
+      - 'IndexOutOfBoundsException'
+      - 'NullPointerException'
+      - 'RuntimeException'
+      - 'Throwable'
+    allowedExceptionNameRegex: '_|(ignore|expected).*'
+  TooGenericExceptionThrown:
+    active: true
+    exceptionNames:
+      - 'Error'
+      - 'Exception'
+      - 'RuntimeException'
+      - 'Throwable'
+
+formatting:
+  active: true
+  ArgumentListWrapping:
+    active: false
+  ParameterListWrapping:
+    active: false
+  NoWildcardImports:
+    active: false
+  MaximumLineLength:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+
+naming:
+  active: true
+  BooleanPropertyNaming:
+    active: false
+    allowedPattern: '^(is|has|are)'
+  ClassNaming:
+    active: true
+    classPattern: '[A-Z][a-zA-Z0-9_]*'
+  ConstructorParameterNaming:
+    active: true
+    parameterPattern: '[a-z][A-Za-z0-9]*'
+    privateParameterPattern: '[a-z][A-Za-z0-9]*'
+    excludeClassPattern: '$^'
+  EnumNaming:
+    active: true
+    enumEntryPattern: '[A-Z][_a-zA-Z0-9]*'
+  ForbiddenClassName:
+    active: false
+    forbiddenName: [ ]
+  FunctionMaxLength:
+    active: false
+    maximumFunctionNameLength: 30
+  FunctionMinLength:
+    active: false
+    minimumFunctionNameLength: 3
+  FunctionNaming:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    functionPattern: '[a-zA-Z][a-zA-Z0-9]*'
+    excludeClassPattern: '$^'
+  FunctionParameterNaming:
+    active: true
+    parameterPattern: '[a-zA-Z][A-Za-z0-9]*'
+    excludeClassPattern: '$^'
+  InvalidPackageDeclaration:
+    active: true
+    rootPackage: ''
+    requireRootInDeclaration: false
+  LambdaParameterNaming:
+    active: false
+    parameterPattern: '[a-z][A-Za-z0-9]*|_'
+  MatchingDeclarationName:
+    active: false
+    mustBeFirst: false
+  MemberNameEqualsClassName:
+    active: true
+    ignoreOverridden: true
+  NoNameShadowing:
+    active: true
+  NonBooleanPropertyPrefixedWithIs:
+    active: false
+  ObjectPropertyNaming:
+    active: true
+    constantPattern: '[A-Za-z][_A-Za-z0-9]*'
+    propertyPattern: '[A-Za-z][_A-Za-z0-9]*'
+    privatePropertyPattern: '(_)?[A-Za-z][_A-Za-z0-9]*'
+  PackageNaming:
+    active: true
+    packagePattern: '[a-z]+(\.[a-z][A-Za-z0-9]*)*'
+  TopLevelPropertyNaming:
+    active: true
+    constantPattern: '[A-Z][_A-Z0-9]*'
+    propertyPattern: '[A-Za-z][_A-Za-z0-9]*'
+    privatePropertyPattern: '_?[A-Za-z][_A-Za-z0-9]*'
+  VariableMaxLength:
+    active: false
+    maximumVariableNameLength: 64
+  VariableMinLength:
+    active: false
+    minimumVariableNameLength: 1
+  VariableNaming:
+    active: true
+    variablePattern: '[a-zA-Z][A-Za-z0-9]*'
+    privateVariablePattern: '(_)?[a-zA-Z][A-Za-z0-9]*'
+    excludeClassPattern: '$^'
+
+performance:
+  active: true
+  ArrayPrimitive:
+    active: true
+  CouldBeSequence:
+    active: false
+    threshold: 3
+  ForEachOnRange:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+  SpreadOperator:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+  UnnecessaryPartOfBinaryExpression:
+    active: false
+  UnnecessaryTemporaryInstantiation:
+    active: true
+
+potential-bugs:
+  active: true
+  AvoidReferentialEquality:
+    active: true
+    forbiddenTypePatterns:
+      - 'kotlin.String'
+  CastNullableToNonNullableType:
+    active: false
+  CastToNullableType:
+    active: false
+  Deprecation:
+    active: false
+  DontDowncastCollectionTypes:
+    active: false
+  DoubleMutabilityForCollection:
+    active: true
+    mutableTypes:
+      - 'kotlin.collections.MutableList'
+      - 'kotlin.collections.MutableMap'
+      - 'kotlin.collections.MutableSet'
+      - 'java.util.ArrayList'
+      - 'java.util.LinkedHashSet'
+      - 'java.util.HashSet'
+      - 'java.util.LinkedHashMap'
+      - 'java.util.HashMap'
+  ElseCaseInsteadOfExhaustiveWhen:
+    active: false
+    ignoredSubjectTypes: [ ]
+  EqualsAlwaysReturnsTrueOrFalse:
+    active: true
+  EqualsWithHashCodeExist:
+    active: true
+  ExitOutsideMain:
+    active: false
+  ExplicitGarbageCollectionCall:
+    active: true
+  HasPlatformType:
+    active: true
+  IgnoredReturnValue:
+    active: true
+    restrictToConfig: true
+    returnValueAnnotations:
+      - 'CheckResult'
+      - '*.CheckResult'
+      - 'CheckReturnValue'
+      - '*.CheckReturnValue'
+    ignoreReturnValueAnnotations:
+      - 'CanIgnoreReturnValue'
+      - '*.CanIgnoreReturnValue'
+    returnValueTypes:
+      - 'kotlin.sequences.Sequence'
+      - 'kotlinx.coroutines.flow.*Flow'
+      - 'java.util.stream.*Stream'
+    ignoreFunctionCall: [ ]
+  ImplicitDefaultLocale:
+    active: true
+  ImplicitUnitReturnType:
+    active: false
+    allowExplicitReturnType: true
+  InvalidRange:
+    active: true
+  IteratorHasNextCallsNextMethod:
+    active: true
+  IteratorNotThrowingNoSuchElementException:
+    active: true
+  LateinitUsage:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+    ignoreOnClassesPattern: ''
+  MapGetWithNotNullAssertionOperator:
+    active: true
+  MissingPackageDeclaration:
+    active: false
+    excludes: [ '**/*.kts' ]
+  NullCheckOnMutableProperty:
+    active: false
+  NullableToStringCall:
+    active: false
+  PropertyUsedBeforeDeclaration:
+    active: false
+  UnconditionalJumpStatementInLoop:
+    active: false
+  UnnecessaryNotNullCheck:
+    active: false
+  UnnecessaryNotNullOperator:
+    active: true
+  UnnecessarySafeCall:
+    active: true
+  UnreachableCatchBlock:
+    active: true
+  UnreachableCode:
+    active: true
+  UnsafeCallOnNullableType:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**' ]
+  UnsafeCast:
+    active: true
+  UnusedUnaryOperator:
+    active: true
+  UselessPostfixExpression:
+    active: true
+  WrongEqualsTypeParameter:
+    active: true
+
+style:
+  active: true
+  AlsoCouldBeApply:
+    active: false
+  BracesOnIfStatements:
+    active: false
+    singleLine: 'never'
+    multiLine: 'always'
+  BracesOnWhenStatements:
+    active: false
+    singleLine: 'necessary'
+    multiLine: 'consistent'
+  CanBeNonNullable:
+    active: false
+  CascadingCallWrapping:
+    active: false
+    includeElvis: true
+  ClassOrdering:
+    active: false
+  CollapsibleIfStatements:
+    active: false
+  DataClassContainsFunctions:
+    active: false
+    conversionFunctionPrefix:
+      - 'to'
+    allowOperators: false
+  DataClassShouldBeImmutable:
+    active: false
+  DestructuringDeclarationWithTooManyEntries:
+    active: true
+    maxDestructuringEntries: 3
+  DoubleNegativeLambda:
+    active: false
+    negativeFunctions:
+      - reason: 'Use `takeIf` instead.'
+        value: 'takeUnless'
+      - reason: 'Use `all` instead.'
+        value: 'none'
+    negativeFunctionNameParts:
+      - 'not'
+      - 'non'
+  EqualsNullCall:
+    active: true
+  EqualsOnSignatureLine:
+    active: false
+  ExplicitCollectionElementAccessMethod:
+    active: false
+  ExplicitItLambdaParameter:
+    active: true
+  ExpressionBodySyntax:
+    active: false
+    includeLineWrapping: false
+  ForbiddenAnnotation:
+    active: false
+    annotations:
+      - reason: 'it is a java annotation. Use `Suppress` instead.'
+        value: 'java.lang.SuppressWarnings'
+      - reason: 'it is a java annotation. Use `kotlin.Deprecated` instead.'
+        value: 'java.lang.Deprecated'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.MustBeDocumented` instead.'
+        value: 'java.lang.annotation.Documented'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Target` instead.'
+        value: 'java.lang.annotation.Target'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Retention` instead.'
+        value: 'java.lang.annotation.Retention'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Repeatable` instead.'
+        value: 'java.lang.annotation.Repeatable'
+      - reason: 'Kotlin does not support @Inherited annotation, see https://youtrack.jetbrains.com/issue/KT-22265'
+        value: 'java.lang.annotation.Inherited'
+  ForbiddenComment:
+    active: true
+    comments:
+      - reason: 'Forbidden FIXME todo marker in comment, please fix the problem.'
+        value: 'FIXME:'
+      - reason: 'Forbidden STOPSHIP todo marker in comment, please address the problem before shipping the code.'
+        value: 'STOPSHIP:'
+      - reason: 'Forbidden TODO todo marker in comment, please do the changes.'
+        value: 'TODO:'
+    allowedPatterns: ''
+  ForbiddenImport:
+    active: false
+    imports: [ ]
+    forbiddenPatterns: ''
+  ForbiddenMethodCall:
+    active: false
+    methods:
+      - reason: 'print does not allow you to configure the output stream. Use a logger instead.'
+        value: 'kotlin.io.print'
+      - reason: 'println does not allow you to configure the output stream. Use a logger instead.'
+        value: 'kotlin.io.println'
+  ForbiddenSuppress:
+    active: false
+    rules: [ ]
+  ForbiddenVoid:
+    active: true
+    ignoreOverridden: false
+    ignoreUsageInGenerics: false
+  FunctionOnlyReturningConstant:
+    active: true
+    ignoreOverridableFunction: true
+    ignoreActualFunction: true
+    excludedFunctions: [ ]
+  LoopWithTooManyJumpStatements:
+    active: true
+    maxJumpCount: 1
+  MagicNumber:
+    active: false
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*.kts' ]
+    ignoreNumbers:
+      - '-1'
+      - '0'
+      - '1'
+      - '2'
+    ignoreHashCodeFunction: true
+    ignorePropertyDeclaration: false
+    ignoreLocalVariableDeclaration: false
+    ignoreConstantDeclaration: true
+    ignoreCompanionObjectPropertyDeclaration: true
+    ignoreAnnotation: false
+    ignoreNamedArgument: true
+    ignoreEnums: false
+    ignoreRanges: false
+    ignoreExtensionFunctions: true
+  MandatoryBracesLoops:
+    active: false
+  MaxChainedCallsOnSameLine:
+    active: false
+    maxChainedCalls: 5
+  MaxLineLength:
+    active: true
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*.kts' ]
+    maxLineLength: 120
+    excludePackageStatements: true
+    excludeImportStatements: true
+    excludeCommentStatements: true
+    excludeRawStrings: true
+  MayBeConst:
+    active: true
+  ModifierOrder:
+    active: true
+  MultilineLambdaItParameter:
+    active: false
+  MultilineRawStringIndentation:
+    active: false
+    indentSize: 4
+    trimmingMethods:
+      - 'trimIndent'
+      - 'trimMargin'
+  NestedClassesVisibility:
+    active: true
+  NewLineAtEndOfFile:
+    active: true
+  NoTabs:
+    active: false
+  NullableBooleanCheck:
+    active: false
+  ObjectLiteralToLambda:
+    active: true
+  OptionalAbstractKeyword:
+    active: true
+  OptionalUnit:
+    active: false
+  OptionalWhenBraces:
+    active: false
+  PreferToOverPairSyntax:
+    active: false
+  ProtectedMemberInFinalClass:
+    active: true
+  RedundantExplicitType:
+    active: false
+  RedundantHigherOrderMapUsage:
+    active: true
+  RedundantVisibilityModifierRule:
+    active: false
+  ReturnCount:
+    active: true
+    max: 3
+    excludedFunctions:
+      - 'equals'
+    excludeLabeled: false
+    excludeReturnFromLambda: true
+    # Guard clauses (early returns for preconditions) are idiomatic Kotlin and should not
+    # count toward the return limit. E.g. `if (x == null) return null` at function top.
+    excludeGuardClauses: true
+  SafeCast:
+    active: true
+  SerialVersionUIDInSerializableClass:
+    active: true
+  SpacingBetweenPackageAndImports:
+    active: false
+  StringShouldBeRawString:
+    active: false
+    maxEscapedCharacterCount: 2
+    ignoredCharacters: [ ]
+  ThrowsCount:
+    active: true
+    max: 2
+    excludeGuardClauses: false
+  TrailingWhitespace:
+    active: false
+  TrimMultilineRawString:
+    active: false
+    trimmingMethods:
+      - 'trimIndent'
+      - 'trimMargin'
+  UnderscoresInNumericLiterals:
+    active: false
+    acceptableLength: 4
+    allowNonStandardGrouping: false
+  UnnecessaryAbstractClass:
+    active: true
+  UnnecessaryAnnotationUseSiteTarget:
+    active: false
+  UnnecessaryApply:
+    active: true
+  UnnecessaryBackticks:
+    active: false
+  UnnecessaryBracesAroundTrailingLambda:
+    active: false
+  UnnecessaryFilter:
+    active: true
+  UnnecessaryInheritance:
+    active: true
+  UnnecessaryInnerClass:
+    active: false
+  UnnecessaryLet:
+    active: false
+  UnnecessaryParentheses:
+    active: false
+    allowForUnclearPrecedence: false
+  UntilInsteadOfRangeTo:
+    active: false
+  UnusedImports:
+    active: false
+  UnusedParameter:
+    active: true
+    allowedNames: 'ignored|expected'
+  UnusedPrivateClass:
+    active: true
+  UnusedPrivateMember:
+    active: true
+    allowedNames: '[A-Z][a-zA-Z0-9]*Preview'
+  UnusedPrivateProperty:
+    active: true
+    allowedNames: '_|ignored|expected|serialVersionUID'
+  UseAnyOrNoneInsteadOfFind:
+    active: true
+  UseArrayLiteralsInAnnotations:
+    active: true
+  UseCheckNotNull:
+    active: true
+  UseCheckOrError:
+    active: true
+  UseDataClass:
+    active: false
+    allowVars: false
+  UseEmptyCounterpart:
+    active: false
+  UseIfEmptyOrIfBlank:
+    active: false
+  UseIfInsteadOfWhen:
+    active: false
+    ignoreWhenContainingVariableDeclaration: false
+  UseIsNullOrEmpty:
+    active: true
+  UseLet:
+    active: false
+  UseOrEmpty:
+    active: true
+  UseRequire:
+    active: true
+  UseRequireNotNull:
+    active: true
+  UseSumOfInsteadOfFlatMapSize:
+    active: false
+  UselessCallOnNotNull:
+    active: true
+  UtilityClassWithPublicConstructor:
+    active: true
+  VarCouldBeVal:
+    active: true
+    ignoreLateinitVar: false
+  WildcardImport:
+    active: false
+    excludeImports:
+      - 'java.util.*'
@@ -19,6 +19,7 @@ package com.rtbishop.look4sat.core.data.database

 import androidx.room.Dao
 import androidx.room.Insert
+import androidx.room.MapColumn
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import androidx.room.Transaction
@@ -39,13 +40,30 @@ interface Look4SatDao {
    @Query("SELECT * FROM entries WHERE catnum IN (:selectedIds)")
    suspend fun getEntriesWithIds(selectedIds: List<Int>): List<SatEntry>

+    @Query("SELECT catnum, epoch FROM entries")
+    suspend fun getEntriesEpochs(): Map<@MapColumn("catnum") Int, @MapColumn("epoch") Double>
+
+    @Query("SELECT catnum, name FROM entries")
+    suspend fun getEntriesNames(): Map<@MapColumn("catnum") Int, @MapColumn("name") String>
+
+    @Query("UPDATE entries SET name = :name WHERE catnum = :catnum")
+    suspend fun renameEntry(catnum: Int, name: String)
+
+    @Query("DELETE FROM entries WHERE catnum IN (:ids)")
+    suspend fun deleteEntriesWithIds(ids: List<Int>)
+
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertEntries(entries: List<SatEntry>)

    @Query("DELETE FROM entries")
    suspend fun deleteEntries()

-    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes)")
+    @Query(
+        """
+        SELECT DISTINCT catnum FROM radios WHERE isAlive = 1
+        AND (downlinkMode IN (:modes) OR uplinkMode IN (:modes))
+        """
+    )
    suspend fun getIdsWithModes(modes: List<String>): List<Int>

    @Query("SELECT COUNT(*) FROM radios")
@@ -60,4 +78,7 @@ interface Look4SatDao {

    @Query("DELETE FROM radios")
    suspend fun deleteRadios()
+
+    @Query("DELETE FROM radios WHERE isCustom = 0")
+    suspend fun deleteManagedRadios()
 }
@@ -19,19 +19,23 @@ package com.rtbishop.look4sat.core.data.database

 import androidx.room.Database
 import androidx.room.RoomDatabase
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
 import com.rtbishop.look4sat.core.data.database.entity.SatEntry
 import com.rtbishop.look4sat.core.data.database.entity.SatRadio

-@Database(entities = [SatEntry::class, SatRadio::class], version = 1, exportSchema = false)
+const val DATABASE_NAME = "Look4SatDBv400"
+
+@Database(entities = [SatEntry::class, SatRadio::class], version = 2, exportSchema = false)
 abstract class Look4SatDb : RoomDatabase() {
    abstract fun look4SatDao(): Look4SatDao
 }

-//val MIGRATION_1_2 = object : Migration(1, 2) {
-//    override fun migrate(database: SupportSQLiteDatabase) {
-//        database.execSQL("CREATE TABLE entries_backup (name TEXT NOT NULL, epoch REAL NOT NULL, meanmo REAL NOT NULL, eccn REAL NOT NULL, incl REAL NOT NULL, raan REAL NOT NULL, argper REAL NOT NULL, meanan REAL NOT NULL, catnum INTEGER NOT NULL, bstar REAL NOT NULL, xincl REAL NOT NULL, xnodeo REAL NOT NULL, omegao REAL NOT NULL, xmo REAL NOT NULL, xno REAL NOT NULL, orbitalPeriod REAL NOT NULL, isDeepSpace INTEGER NOT NULL, comment TEXT, PRIMARY KEY(catnum))")
-//        database.execSQL("INSERT INTO entries_backup (name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar, xincl, xnodeo, omegao, xmo, xno, orbitalPeriod, isDeepSpace, comment) SELECT name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar, xincl, xnodeo, omegao, xmo, xno, 1440 / meanmo, 1440 / meanmo >= 225.0, comment FROM entries")
-//        database.execSQL("DROP TABLE entries")
-//        database.execSQL("ALTER TABLE entries_backup RENAME TO entries")
-//    }
-//}
+/** Adds the mean motion derivative, needed to tell decayed satellites apart, and marks the
+ * transceivers that were imported from a file, so that remote updates leave them alone. */
+val MIGRATION_1_2 = object : Migration(1, 2) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("ALTER TABLE entries ADD COLUMN ndot REAL NOT NULL DEFAULT 0.0")
+        db.execSQL("ALTER TABLE radios ADD COLUMN isCustom INTEGER NOT NULL DEFAULT 0")
+    }
+}
@@ -30,5 +30,6 @@ data class SatEntry(
    val argper: Double,
    val meanan: Double,
    val catnum: Int,
-    val bstar: Double
+    val bstar: Double,
+    val ndot: Double = 0.0
 )
@@ -32,5 +32,7 @@ data class SatRadio(
    val uplinkHigh: Long?,
    val uplinkMode: String?,
    val isInverted: Boolean,
-    val catnum: Int?
+    val catnum: Int?,
+    /** Set for manually imported transceivers, which remote updates must not replace. */
+    val isCustom: Boolean = false
 )
@@ -17,8 +17,10 @@
 */
 package com.rtbishop.look4sat.core.data.framework

+import com.rtbishop.look4sat.core.domain.model.Constants
 import com.rtbishop.look4sat.core.domain.repository.IReporter
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -31,18 +33,30 @@ class NetworkReporter(
    private val rotatorServer: String,
    private val rotatorPort: Int,
    private val frequencyServer: String,
-    private val frequencyPort: Int
+    private val frequencyPort: Int,
+    private val frequencyOffsetHz: Long = 0L
 ) : IReporter {

    private val writeMutex = Mutex()
+    private val connectionMutex = Mutex()
+    private val frequencyCommands = Channel<String>(Channel.CONFLATED)

    private var rotatorSocket: SocketChannel? = null
    private var rotatorConnected = false
-    private var rotatorConnecting = false

    private var frequencySocket: SocketChannel? = null
    private var frequencyConnected = false
-    private var frequencyConnecting = false
+
+    init {
+        // Keep only the latest frequency command to avoid stale backlog and effective lag.
+        reporterScope.launch {
+            for (command in frequencyCommands) {
+                ensureFrequencyConnected()
+                if (!frequencyConnected) continue
+                write(frequencySocket, command) { resetFrequencyConnection() }
+            }
+        }
+    }

    override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
        reporterScope.launch {
@@ -58,46 +72,43 @@ class NetworkReporter(
    }

    override fun reportFrequency(format: String, frequency: Long) {
-        reporterScope.launch {
-            ensureFrequencyConnected()
-            if (!frequencyConnected) return@launch
-            val command = format
-                .replace($$"$FREQ", frequency.toString())
-                .unescapeControlChars()
-            write(frequencySocket, command) { frequencyConnected = false }
-        }
+        val clampedOffset = frequencyOffsetHz.coerceIn(
+            Constants.FREQ_OFFSET_MIN_HZ,
+            Constants.FREQ_OFFSET_MAX_HZ
+        )
+        val correctedFreq = frequency.coerceAtLeast(0L).safeAdd(clampedOffset).coerceAtLeast(0L)
+        val command = format
+            .replace($$"$FREQ", correctedFreq.toString())
+            .unescapeControlChars()
+        frequencyCommands.trySend(command)
    }

-    private fun ensureRotatorConnected() {
-        if (rotatorConnected || rotatorConnecting || rotatorServer.isBlank()) return
-        reporterScope.launch {
+    private suspend fun ensureRotatorConnected() {
+        connectionMutex.withLock {
+            if (rotatorConnected || rotatorServer.isBlank()) return
            try {
-                rotatorConnecting = true
+                resetRotatorConnection()
                rotatorSocket = SocketChannel.open(InetSocketAddress(rotatorServer, rotatorPort))
                rotatorConnected = true
                println("NetworkReporter: Rotator connected to $rotatorServer:$rotatorPort")
            } catch (e: Exception) {
                println("NetworkReporter rotator connect error: ${e.message}")
-                rotatorConnected = false
-            } finally {
-                rotatorConnecting = false
+                resetRotatorConnection()
            }
        }
    }

-    private fun ensureFrequencyConnected() {
-        if (frequencyConnected || frequencyConnecting || frequencyServer.isBlank()) return
-        reporterScope.launch {
+    private suspend fun ensureFrequencyConnected() {
+        connectionMutex.withLock {
+            if (frequencyConnected || frequencyServer.isBlank()) return
            try {
-                frequencyConnecting = true
+                resetFrequencyConnection()
                frequencySocket = SocketChannel.open(InetSocketAddress(frequencyServer, frequencyPort))
                frequencyConnected = true
                println("NetworkReporter: Frequency connected to $frequencyServer:$frequencyPort")
            } catch (e: Exception) {
                println("NetworkReporter frequency connect error: ${e.message}")
-                frequencyConnected = false
-            } finally {
-                frequencyConnecting = false
+                resetFrequencyConnection()
            }
        }
    }
@@ -106,7 +117,9 @@ class NetworkReporter(
        try {
            writeMutex.withLock {
                val buffer = ByteBuffer.wrap("$command\n".toByteArray())
-                socket?.write(buffer)
+                while (buffer.hasRemaining()) {
+                    socket?.write(buffer)
+                }
            }
        } catch (e: Exception) {
            println("NetworkReporter write error: ${e.message}")
@@ -114,6 +127,32 @@ class NetworkReporter(
        }
    }

+    private fun resetRotatorConnection() {
+        rotatorConnected = false
+        closeQuietly(rotatorSocket)
+        rotatorSocket = null
+    }
+
+    private fun resetFrequencyConnection() {
+        frequencyConnected = false
+        closeQuietly(frequencySocket)
+        frequencySocket = null
+    }
+
+    private fun closeQuietly(socket: SocketChannel?) {
+        try {
+            socket?.close()
+        } catch (_: Exception) {}
+    }
+
+    private fun Long.safeAdd(delta: Long): Long {
+        return when {
+            delta > 0 && this > Long.MAX_VALUE - delta -> Long.MAX_VALUE
+            delta < 0 && this < Long.MIN_VALUE - delta -> Long.MIN_VALUE
+            else -> this + delta
+        }
+    }
+
    private fun String.unescapeControlChars(): String =
        replace("\\r", "\r").replace("\\n", "\n").replace("\\t", "\t")
 }
@@ -22,13 +22,17 @@ import android.content.Context
 import android.hardware.SensorManager
 import android.hardware.display.DisplayManager
 import android.location.LocationManager
+import androidx.core.content.pm.PackageInfoCompat
 import androidx.room.Room
+import com.rtbishop.look4sat.core.data.database.DATABASE_NAME
+import com.rtbishop.look4sat.core.data.database.MIGRATION_1_2
 import com.rtbishop.look4sat.core.data.database.Look4SatDb
 import com.rtbishop.look4sat.core.data.framework.BluetoothReporter
 import com.rtbishop.look4sat.core.data.framework.Ft817Controller
 import com.rtbishop.look4sat.core.data.framework.Ic705Controller
 import com.rtbishop.look4sat.core.data.framework.NetworkReporter
 import com.rtbishop.look4sat.core.data.framework.RadioTrackingService
+import com.rtbishop.look4sat.core.data.repository.AmSatRepository
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
 import com.rtbishop.look4sat.core.data.repository.SatelliteRepo
 import com.rtbishop.look4sat.core.data.repository.SelectionRepo
@@ -50,7 +54,6 @@ import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
 import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
@@ -62,32 +65,24 @@ import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 import okhttp3.OkHttpClient

 class MainContainer(private val context: Context) : IMainContainer {

    private val localSource = provideLocalSource()
+    private val remoteSource = provideRemoteSource()
    private val mainHandler = CoroutineExceptionHandler { _, error -> println("MainHandler: $error") }
    override val appScope = CoroutineScope(SupervisorJob() + Dispatchers.Default + mainHandler)
    override val settingsRepo = provideSettingsRepo()
    override val selectionRepo = provideSelectionRepo()
    override val satelliteRepo = provideSatelliteRepo()
    override val databaseRepo = provideDatabaseRepo()
+    override val amSatRepo by lazy { AmSatRepository(remoteSource) }
    override val radioTrackingService: IRadioTrackingService by lazy {
        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
        RadioTrackingService(appScope, manager, satelliteRepo, settingsRepo)
    }

-    private val _mutualPassData = MutableStateFlow(MutualPassData())
-    override val mutualPassData: StateFlow<MutualPassData> = _mutualPassData.asStateFlow()
-
-    override fun setMutualPassData(data: MutualPassData) {
-        _mutualPassData.value = data
-    }
-
    override fun provideAddToCalendar(): IAddToCalendar = AddToCalendar(context)

    override fun provideShowToast(): IShowToast = ShowToast(context)
@@ -114,7 +109,8 @@ class MainContainer(private val context: Context) : IMainContainer {
            rc.rotatorAddress,
            rc.rotatorPort.toIntOrNull() ?: 0,
            rc.frequencyAddress,
-            rc.frequencyPort.toIntOrNull() ?: 0
+            rc.frequencyPort.toIntOrNull() ?: 0,
+            rc.frequencyOffsetHz
        )
    }

@@ -146,21 +142,34 @@ class MainContainer(private val context: Context) : IMainContainer {
        return SensorsRepo(manager, displayManager)
    }

+    override fun providePairedBluetoothDevices(): List<Pair<String, String>> = buildList {
+        try {
+            val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+            manager.adapter?.bondedDevices?.forEach { add(Pair(it.name ?: "Unknown", it.address ?: "")) }
+        } catch (_: SecurityException) {}
+    }
+
    private fun provideDatabaseRepo(): IDatabaseRepo {
        val dbDispatcher = Dispatchers.Default
        val dataParser = DataParser(dbDispatcher)
-        val remoteSource = provideRemoteSource()
        return DatabaseRepo(dbDispatcher, dataParser, localSource, remoteSource, settingsRepo)
    }

    private fun provideLocalSource(): ILocalSource {
-        val builder = Room.databaseBuilder(context, Look4SatDb::class.java, "Look4SatDBv400")
-        val database = builder.fallbackToDestructiveMigration(false).build()
+        val builder = Room.databaseBuilder(context, Look4SatDb::class.java, DATABASE_NAME)
+        val database = builder.addMigrations(MIGRATION_1_2).fallbackToDestructiveMigration(false).build()
        return LocalSource(database.look4SatDao())
    }

    private fun provideRemoteSource(): IRemoteSource {
-        return RemoteSource(Dispatchers.IO, context.contentResolver, OkHttpClient.Builder().build())
+        val version = context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "4.0.4"
+        val userAgent = "Look4Sat/$version (+https://github.com/rt-bishop/Look4Sat)"
+        // Data providers ask clients to identify themselves, so that they can reach out to the
+        // developer instead of silently blocking every user of the app behind a misbehaving request
+        val client = OkHttpClient.Builder().addInterceptor { chain ->
+            chain.proceed(chain.request().newBuilder().header("User-Agent", userAgent).build())
+        }.build()
+        return RemoteSource(Dispatchers.IO, context.contentResolver, client)
    }

    private fun provideSatelliteRepo(): ISatelliteRepo {
@@ -175,7 +184,9 @@ class MainContainer(private val context: Context) : IMainContainer {
        val manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
        val appPrefsFileName = "${context.packageName}_preferences"
        val appPreferences = context.getSharedPreferences(appPrefsFileName, Context.MODE_PRIVATE)
-        val appVersionName = context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "4.0.4"
-        return SettingsRepo(manager, appPreferences, appVersionName)
+        val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+        val appVersionName = packageInfo.versionName ?: "4.0.4"
+        val appVersionCode = PackageInfoCompat.getLongVersionCode(packageInfo)
+        return SettingsRepo(manager, appPreferences, appVersionName, appVersionCode)
    }
 }
@@ -0,0 +1,209 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmitResult
+import com.rtbishop.look4sat.core.domain.model.SatDay
+import com.rtbishop.look4sat.core.domain.model.SatReport
+import com.rtbishop.look4sat.core.domain.model.SatSlot
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+import com.rtbishop.look4sat.core.domain.repository.IAmSatRepository
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+/** One report from the AMSAT API (data layer model). */
+private data class ApiReport(
+    val id: String,
+    val name: String,
+    val callsign: String,
+    val report: String,
+    val gridSquare: String,
+    val reportedTimeUtcSec: Long
+)
+
+/** AMSAT status repository using RemoteSource (Clean Architecture: data layer handles HTTP). */
+class AmSatRepository(private val remoteSource: IRemoteSource) : IAmSatRepository {
+
+    private val isoUtcFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+    }
+
+    override suspend fun fetchStatus(): SatStatusPage? = withContext(Dispatchers.IO) {
+        val nowSec = System.currentTimeMillis() / 1000
+        val catalogJson = remoteSource.getAmSatCatalog() ?: return@withContext null
+        // 72h = 3 days; API hard cap is limit=500 regardless of what we send.
+        // 500 records across ~100 catalog satellites ≈ ~1-5 reports/satellite/day — enough for 3 days.
+        // Upgrade path: paginate or request AMSAT to raise the cap if catalog grows beyond ~200 sats.
+        val reportsJson = remoteSource.getAmSatReports(hours = 72, limit = 500) ?: return@withContext null
+        val names = parseCatalog(catalogJson)
+        val reports = parseReports(reportsJson)
+
+        if (names.isEmpty() && reports.isEmpty()) return@withContext null
+
+        val statuses = buildStatuses(names, reports, nowSec)
+        val reportMap = reports.associate { it.id to toSatReport(it) }
+        SatStatusPage(System.currentTimeMillis(), statuses, reportMap)
+    }
+
+    override suspend fun submitReport(submission: AmSatReportSubmission): AmSatReportSubmitResult = withContext(Dispatchers.IO) {
+        val payload = JSONObject().apply {
+            put("name", submission.name)
+            put("report", submission.report)
+            put("callsign", submission.callsign)
+            put("reported_at", isoUtcFormat.format(Date(submission.reportedAtUtcMillis)))
+            if (submission.gridSquare.isNotBlank()) put("grid_square", submission.gridSquare)
+        }
+        val response = remoteSource.submitAmSatReport(payload.toString())
+            ?: return@withContext AmSatReportSubmitResult(success = false, message = "Network request failed")
+        val (code, body) = response
+        val errorMessage = parseSubmitError(body)
+        return@withContext if (code in 200..299 && errorMessage.isBlank()) {
+            AmSatReportSubmitResult(success = true, reportId = parseSubmitReportId(body))
+        } else {
+            AmSatReportSubmitResult(
+                success = false,
+                message = errorMessage.ifBlank { "HTTP $code" }
+            )
+        }
+    }
+
+    private fun parseSubmitError(json: String): String {
+        return try {
+            JSONObject(json).optJSONObject("error")?.optString("message").orEmpty()
+        } catch (_: Exception) {
+            ""
+        }
+    }
+
+    private fun parseSubmitReportId(json: String): String? {
+        return try {
+            val obj = JSONObject(json)
+            obj.optJSONObject("data")?.optString("id")?.takeIf { it.isNotBlank() }
+                ?: obj.optString("id").takeIf { it.isNotBlank() }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    /** Parse catalog JSON to list of satellite names */
+    private fun parseCatalog(json: String): List<String> {
+        return try {
+            val arr = JSONObject(json).getJSONArray("data")
+            (0 until arr.length()).map { arr.getJSONObject(it).getString("name") }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    /** Parse reports JSON to list of ApiReport domain objects */
+    private fun parseReports(json: String): List<ApiReport> {
+        return try {
+            val arr = JSONObject(json).getJSONArray("data")
+            (0 until arr.length()).mapNotNull { i ->
+                val o = arr.getJSONObject(i)
+                val iso = o.optString("reported_time", "")
+                if (iso.isEmpty()) null else ApiReport(
+                    id = o.optString("id", ""),
+                    name = o.optString("name", ""),
+                    callsign = o.optString("callsign", ""),
+                    report = o.optString("report", ""),
+                    gridSquare = o.optString("grid_square", ""),
+                    reportedTimeUtcSec = parseIsoUtcSec(iso)
+                )
+            }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    /** Parse ISO 8601 UTC timestamp to epoch seconds (e.g., "2026-08-05T07:30:00Z") */
+    private fun parseIsoUtcSec(iso: String): Long {
+        return try {
+            (isoUtcFormat.parse(iso)?.time ?: 0L) / 1000
+        } catch (_: Exception) {
+            0L
+        }
+    }
+
+    /** Build one SatStatus (5 days x 12 slots) per catalog satellite, slotting reports by age. */
+    private fun buildStatuses(names: List<String>, reports: List<ApiReport>, nowSec: Long): List<SatStatus> {
+        val byName = reports.groupBy { it.name }
+        val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+        val labels = (0 until 3).map { d ->
+            utc.timeInMillis = (nowSec - d * 86400L) * 1000
+            formatDayLabel(utc)
+        }
+        return names.map { name ->
+            val slots = (0 until 36).map { slotIdx ->
+                val slotStart = nowSec - (slotIdx + 1) * 7200L
+                val slotEnd = nowSec - slotIdx * 7200L
+                val inSlot = byName[name].orEmpty().filter { it.reportedTimeUtcSec in slotStart until slotEnd }
+                if (inSlot.isEmpty()) {
+                    SatSlot(statusColor = NO_REPORT_GRAY, count = 0)
+                } else {
+                    val newest = inSlot.maxByOrNull { it.reportedTimeUtcSec }!!
+                    SatSlot(
+                        statusColor = statusColorOf(newest.report),
+                        count = inSlot.size,
+                        reportIds = inSlot.map { it.id }
+                    )
+                }
+            }
+            val days = (0 until 3).map { d ->
+                SatDay(dateLabel = labels[d], slots = slots.subList(d * 12, (d + 1) * 12))
+            }
+            SatStatus(name = name, days = days)
+        }
+    }
+
+    private fun formatDayLabel(calendar: Calendar): String {
+        return if (Locale.getDefault().language == Locale.CHINESE.language) {
+            "${calendar.get(Calendar.MONTH) + 1}月${calendar.get(Calendar.DAY_OF_MONTH)}日"
+        } else {
+            val monthAbbr = arrayOf("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+            "${monthAbbr[calendar.get(Calendar.MONTH)]} ${calendar.get(Calendar.DAY_OF_MONTH)}"
+        }
+    }
+
+    private fun toSatReport(r: ApiReport): SatReport {
+        val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+        cal.timeInMillis = r.reportedTimeUtcSec * 1000
+        val hh = cal.get(Calendar.HOUR_OF_DAY).toString().padStart(2, '0')
+        val mm = cal.get(Calendar.MINUTE).toString().padStart(2, '0')
+        val y = cal.get(Calendar.YEAR)
+        val mo = (cal.get(Calendar.MONTH) + 1).toString().padStart(2, '0')
+        val d = cal.get(Calendar.DAY_OF_MONTH).toString().padStart(2, '0')
+        return SatReport(
+            id = r.id,
+            statusText = r.report,
+            call = r.callsign,
+            grid = r.gridSquare,
+            dateUtc = "$y-$mo-$d",
+            timeUtc = "$hh:$mm UTC"
+        )
+    }
+
+    /** Map status text to color value (for UI rendering). */
+    private fun statusColorOf(report: String): Long = when (report.lowercase()) {
+        "heard", "crew active" -> ACTIVE_BLUE
+        "telemetry only" -> TLM_ORANGE
+        "not heard" -> NOT_HEARD_PINK
+        else -> CONFLICT_DEEP_ORANGE
+    }
+
+    companion object {
+        // AMSAT official status colors (from amsat.org/status)
+        private const val ACTIVE_BLUE = 0xFF648FFF
+        private const val TLM_ORANGE = 0xFFFFB000
+        private const val NOT_HEARD_PINK = 0xFFDC267F
+        private const val CONFLICT_DEEP_ORANGE = 0xFFFE6100
+        private const val NO_REPORT_GRAY = 0xFFC0C0C0
+    }
+}
@@ -23,7 +23,6 @@ import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
-import com.rtbishop.look4sat.core.domain.source.Sources
 import com.rtbishop.look4sat.core.domain.utility.DataParser
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.async
@@ -40,14 +39,13 @@ class DatabaseRepo(
    private val settingsRepo: ISettingsRepo
 ) : IDatabaseRepo {

-    private val customSourceType = "Other"

    override suspend fun updateTLEFromFile(uri: String): Int = withContext(dispatcher) {
        var importedCount = 0
        remoteSource.getFileStream(uri)?.let { stream ->
-            val entries = parseSatelliteStream(uri, unwrapIfZipped(uri, stream))
-            localSource.insertEntries(entries)
-            settingsRepo.setSatelliteTypeIds(customSourceType, entries.map { it.catnum })
+            val entries = mergeEntries(listOf(parseSatelliteStream(uri, unwrapIfZipped(uri, stream))))
+            insertFresherEntries(entries)
+            // report what the file contained: a valid file holding only stale data is not an error
            importedCount = entries.size
        }
        setUpdateSuccessful(System.currentTimeMillis())
@@ -58,7 +56,7 @@ class DatabaseRepo(
        var importedCount = 0
        remoteSource.getFileStream(uri)?.let { stream ->
            val transceivers = dataParser.parseJSONStream(unwrapIfZipped(uri, stream))
-            localSource.insertRadios(transceivers)
+            localSource.insertRadios(transceivers, isCustom = true)
            importedCount = transceivers.size
        }
        setUpdateSuccessful(System.currentTimeMillis())
@@ -66,32 +64,40 @@ class DatabaseRepo(
    }

    override suspend fun updateFromRemote() = withContext(dispatcher) {
-        val dataSourcesSettings = settingsRepo.dataSourcesSettings.value
-        val tleUrls = buildMap {
-            putAll(Sources.satelliteDataUrls)
-            if (dataSourcesSettings.useCustomTLE) put(customSourceType, dataSourcesSettings.tleUrl)
-        }.filterValues { it.isNotBlank() }
-        val radioUrls = buildMap {
-            putAll(Sources.transceiversDataUrls)
-            if (dataSourcesSettings.useCustomTransceivers) put(customSourceType, dataSourcesSettings.transceiversUrl)
-        }.filterValues { it.isNotBlank() }
-        // launch all network requests concurrently
-        val tleJobs = tleUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
-        val radioJobs = radioUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
-        // parse fetched data concurrently and associate with types
-        val importedEntries = tleJobs.awaitAll().flatMap { (url, stream) ->
-            val type = tleUrls.entries.find { it.value == url }?.key ?: customSourceType
-            stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty().also { entries ->
-                settingsRepo.setSatelliteTypeIds(type, entries.map { it.catnum })
-            }
-        }
-        val importedRadios = radioJobs.awaitAll().flatMap { (url, stream) ->
-            stream?.let { dataParser.parseJSONStream(unwrapIfZipped(url, it)) }.orEmpty()
+        val settings = settingsRepo.dataSourcesSettings.value
+        fun normalizeUrl(url: String) = if (url.startsWith("http")) url else "https://$url"
+        val tleUrls = settings.satelliteUrls.filterIndexed { i, url -> url.isNotBlank() && settings.isSatelliteEnabled(i) }
+        val radioUrls = settings.transceiversUrls.filterIndexed { i, url -> url.isNotBlank() && settings.isTransceiverEnabled(i) }
+        // launch all network requests concurrently, keeping the raw url as key for status reporting
+        val tleJobs = tleUrls.map { url -> async { url to remoteSource.getNetworkStream(normalizeUrl(url)) } }
+        val radioJobs = radioUrls.map { url -> async { url to remoteSource.getNetworkStream(normalizeUrl(url)) } }
+        val tleResults = tleJobs.awaitAll()
+        val radioResults = radioJobs.awaitAll()
+        // report the HTTP status code of every source (200, 404, ...)
+        settingsRepo.updateDataSourcesStatus(
+            (tleResults + radioResults).associate { (url, result) -> url to result.code }
+        )
+        // parse fetched data concurrently, merging satellites by freshness instead of source order
+        val parsedPerSource = tleResults.map { (url, result) ->
+            result.stream?.let { val nUrl = normalizeUrl(url); parseSatelliteStream(nUrl, unwrapIfZipped(nUrl, it)) }.orEmpty()
        }
+        val importedRadios = radioResults.flatMap { (url, result) ->
+            result.stream?.let { val nUrl = normalizeUrl(url); dataParser.parseJSONStream(unwrapIfZipped(nUrl, it)) }.orEmpty()
+        }.filter { it.uuid.isNotBlank() }.distinctBy { it.uuid }
        // insert parsed data into the database
-        localSource.insertEntries(importedEntries)
-        localSource.insertRadios(importedRadios)
-        setUpdateSuccessful(System.currentTimeMillis())
+        insertFresherEntries(mergeEntries(parsedPerSource))
+        // transceivers are a full snapshot: sources publish active entries only, so a retired
+        // transceiver simply disappears from the feed and has to be dropped locally as well.
+        // Imported ones are kept: no source can refresh them, so nothing would bring them back
+        if (importedRadios.isNotEmpty()) {
+            localSource.deleteManagedRadios()
+            localSource.insertRadios(importedRadios, isCustom = false)
+        }
+        // keep the previous timestamp when every source failed, so the next launch retries
+        val hasFetchedData = parsedPerSource.any { entries -> entries.isNotEmpty() } || importedRadios.isNotEmpty()
+        val previousTimestamp = settingsRepo.databaseState.value.updateTimestamp
+        if (hasFetchedData) pruneStaleEntries()
+        setUpdateSuccessful(if (hasFetchedData) System.currentTimeMillis() else previousTimestamp)
    }

    override suspend fun clearAllData() = withContext(dispatcher) {
@@ -127,6 +133,62 @@ class DatabaseRepo(
            line.count { it == ',' } >= 4
    }

+    /**
+     * Merges the data of every source: orbital elements always come from the set with the newest
+     * epoch, while the name comes from the first source that provides it. Source order is thus a
+     * naming preference only, which also keeps names stable when sources leapfrog each other.
+     */
+    private fun mergeEntries(sourceEntries: List<List<OrbitalData>>): List<OrbitalData> {
+        val preferredNames = mutableMapOf<Int, String>()
+        val freshestEntries = mutableMapOf<Int, OrbitalData>()
+        sourceEntries.forEach { entries ->
+            entries.forEach { entry ->
+                val name = entry.name.trim()
+                if (name.isNotBlank()) preferredNames.getOrPut(entry.catnum) { name }
+                val current = freshestEntries[entry.catnum]
+                if (current == null || entry.epochDaynum > current.epochDaynum) {
+                    freshestEntries[entry.catnum] = entry
+                }
+            }
+        }
+        return freshestEntries.values.map { entry ->
+            val name = preferredNames[entry.catnum]
+            if (name == null || name == entry.name) entry else entry.copy(name = name)
+        }
+    }
+
+    /** Stores the entries that are newer than the ones already saved, renaming the rest in place. */
+    private suspend fun insertFresherEntries(entries: List<OrbitalData>) {
+        val storedEpochs = localSource.getEntriesEpochs()
+        val (fresherEntries, staleEntries) = entries.partition { entry ->
+            val storedEpoch = storedEpochs[entry.catnum]
+            storedEpoch == null || entry.epochDaynum > OrbitalData.epochToDaynum(storedEpoch)
+        }
+        localSource.insertEntries(fresherEntries)
+        // a reordered source list has to rename satellites right away, even the ones holding
+        // elements that are newer than the ones just parsed
+        if (staleEntries.isNotEmpty()) {
+            val storedNames = localSource.getEntriesNames()
+            val renamedEntries = staleEntries.filter { entry -> entry.name != storedNames[entry.catnum] }
+            if (renamedEntries.isNotEmpty()) {
+                localSource.renameEntries(renamedEntries.associate { it.catnum to it.name })
+            }
+        }
+    }
+
+    /**
+     * Drops satellites that no enabled source has refreshed for a month: they either decayed or
+     * disappeared from every catalog. Manually imported data ages out the same way, and every
+     * source republishes active satellites well within that window.
+     */
+    private suspend fun pruneStaleEntries() {
+        val currentDaynum = OrbitalData.timeToDaynum(System.currentTimeMillis())
+        val staleIds = localSource.getEntriesEpochs()
+            .filterValues { epoch -> currentDaynum - OrbitalData.epochToDaynum(epoch) > 30.0 }
+            .keys.toList()
+        if (staleIds.isNotEmpty()) localSource.deleteEntriesWithIds(staleIds)
+    }
+
    private suspend fun setUpdateSuccessful(timestamp: Long) {
        settingsRepo.updateDatabaseState(
            DatabaseState(localSource.getRadiosTotal(), localSource.getEntriesTotal(), timestamp)
@@ -38,6 +38,7 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
 import java.util.TimeZone
+import kotlin.time.Duration.Companion.milliseconds

 class SatelliteRepo(
    private val dispatcher: CoroutineDispatcher,
@@ -78,7 +79,7 @@ class SatelliteRepo(
                    aosStartMinute = settings.aosStartMinute,
                    aosEndMinute = settings.aosEndMinute,
                    invertAosTimeWindow = settings.invertAosTimeWindow,
-                    modes = settings.selectedModes
+                    modes = settingsRepo.selectedSatModes.value
                )
            }
    }
@@ -163,7 +164,7 @@ class SatelliteRepo(
                }
            }
            newPasses.sortBy { it.aosTime }
-            delay(1000) // Simulate loading time for better UX
+            delay(1000.milliseconds) // Simulate loading time for better UX
            _passes.update { newPasses }
        }
        _isCalculating.value = false
@@ -181,7 +182,7 @@ class SatelliteRepo(
        val inRange = if (aosStartMinute <= aosEndMinute) {
            aosMinute in aosStartMinute..aosEndMinute
        } else {
-            aosMinute >= aosStartMinute || aosMinute <= aosEndMinute
+            aosMinute !in (aosEndMinute + 1)..<aosStartMinute
        }
        return if (invertAosTimeWindow) !inRange else inRange
    }
@@ -38,16 +38,16 @@ class SelectionRepo(
 ) : ISelectionRepo {

    private val currentItems = MutableStateFlow<List<SatItem>>(emptyList())
-    private val currentTypes = MutableStateFlow(settingsRepo.selectedTypes.value)
    private val currentQuery = MutableStateFlow("")

-    // Resolve type IDs once when types change, then filter items reactively.
+    // Resolve sat IDs once when modes change, then filter items reactively.
    // The HashSet gives O(1) catnum lookups instead of O(n) with a List.
-    private val itemsWithTypes = currentTypes.flatMapLatest { types: List<String> ->
-        val catnumSet: Set<Int>? = if (types.isEmpty()) {
+    // Directly observe settingsRepo.selectedSatModes to ensure real-time sync across screens.
+    private val itemsWithModes = settingsRepo.selectedSatModes.flatMapLatest { list: List<String> ->
+        val catnumSet: Set<Int>? = if (list.isEmpty()) {
            null // null = no filtering
        } else {
-            val ids = settingsRepo.getSatelliteTypesIds(types)
+            val ids = localSource.getIdsWithModes(list)
            if (ids.isEmpty()) null else ids.toHashSet()
        }
        currentItems.map { items ->
@@ -56,14 +56,18 @@ class SelectionRepo(
    }

    private val itemsWithQuery = currentQuery.flatMapLatest { query ->
-        itemsWithTypes.map { items -> filterByQuery(items, query) }
+        itemsWithModes.map { items ->
+            filterByQuery(items, query).sortedWith(
+                compareByDescending<SatItem> { it.isSelected }
+                    .thenBy { it.name }
+                    .thenBy { it.catnum }
+            )
+        }
    }

-    override fun getCurrentTypes() = currentTypes.value
+    override fun getCurrentModes() = settingsRepo.selectedSatModes.value

-    override fun getTypesList() = Sources.satelliteDataUrls.keys.sorted().toMutableList().apply {
-        removeAt(0)
-    }
+    override fun getModesList() = Sources.satelliteModes

    override suspend fun getEntriesFlow() = withContext(dispatcher) {
        val selectedIds = settingsRepo.selectedIds.value.toHashSet()
@@ -73,9 +77,8 @@ class SelectionRepo(
        return@withContext itemsWithQuery
    }

-    override suspend fun setTypes(types: List<String>) {
-        currentTypes.value = types
-        settingsRepo.setSelectedTypes(types)
+    override suspend fun setModes(modes: List<String>) {
+        settingsRepo.setSelectedSatModes(modes)
    }

    override suspend fun setQuery(query: String) {
@@ -29,19 +29,24 @@ import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
 import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.Constants
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.Sources
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
 import com.rtbishop.look4sat.core.domain.utility.qthToPosition
 import com.rtbishop.look4sat.core.domain.utility.round
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
+import org.json.JSONObject
+import java.util.Locale

 class SettingsRepo(
    private val locationManager: LocationManager,
    private val preferences: SharedPreferences,
-    override val appVersionName: String
+    override val appVersionName: String,
+    override val appVersionCode: Long,
 ) : ISettingsRepo, LocationListenerCompat {

    private val keyBluetoothRotatorAddress = "bluetoothAddress"
@@ -67,9 +72,9 @@ class SettingsRepo(
    private val keyFrequencyAddress = "frequencyAddress"
    private val keyFrequencyPort = "frequencyPort"
    private val keyFrequencyFormat = "frequencyFormat"
+    private val keyFrequencyOffsetHz = "frequencyOffsetHz"
    private val keySelectedIds = "selectedIds"
-    private val keySelectedTypes = "selectedTypes"
-    private val keySelectedModes = "selectedModes"
+    private val keySelectedSatModes = "selectedSatModes"
    private val keyStateOfAutoUpdate = "stateOfAutoUpdate"
    private val keyStateOfSensors = "stateOfSensors"
    private val keyStateOfSweep = "stateOfSweep"
@@ -83,21 +88,38 @@ class SettingsRepo(
    private val keyStationTimestamp = "stationTimestamp"
    private val keyUpdateTimestamp = "updateTimestamp"
    private val keyShouldSeeWarning = "shouldSeeWarning"
-    private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew_v$appVersionName"
+    private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew"
    private val keySstvMode = "sstvMode"
    private val keyLowElevation = "lowElevation"
    private val keyHighElevation = "highElevation"
-    private val keyUseCustomTle = "useCustomTle"
-    private val keyUseCustomTransceivers = "useCustomTransceivers"
-    private val keyTleUrl = "tleUrl"
-    private val keyTransceiversUrl = "transceiversUrl"
+    private val keyRadarCompassOffset = "radarCompassOffset"
+    private val keyRadarCompassOffsetElev = "radarCompassOffsetElev"
+    private val keySatellitesUrls = "satellitesUrls"
+    private val keyTransceiversUrls = "transceiversUrls"
+    private val keySatellitesUrlsEnabled = "satellitesUrlsEnabled"
+    private val keyTransceiversUrlsEnabled = "transceiversUrlsEnabled"
+    private val keySettingsVersion = "settingsVersion"
    private val separatorComma = ","
+    private val separatorUrl = "\n"
+
+    init {
+        // The meaning of the data source order changed, so the stored lists are dropped and the defaults
+        // are applied again. The update timestamp is cleared as well, to refresh the migrated data
+        // on the first launch instead of waiting up to 48 hours for the automatic update.
+        if (preferences.getInt(keySettingsVersion, 0) < appVersionCode) {
+            preferences.edit {
+                listOf(keyShouldSeeWhatsNew, keySatellitesUrls, keyTransceiversUrls, keyUpdateTimestamp)
+                    .forEach { key -> remove(key) }
+                putInt(keySettingsVersion, appVersionCode.toInt())
+            }
+        }
+    }

    //region # Satellites selection settings
    private val _satelliteSelection = MutableStateFlow(getSelectedIds())
-    private val _typesSelection = MutableStateFlow(getSelectedTypes())
+    private val _satelliteModeSelection = MutableStateFlow(getSelectedSatModes())
    override val selectedIds: StateFlow<List<Int>> = _satelliteSelection
-    override val selectedTypes: StateFlow<List<String>> = _typesSelection
+    override val selectedSatModes: StateFlow<List<String>> = _satelliteModeSelection

    override fun setSelectedIds(ids: List<Int>) {
        val selectionString = ids.joinToString(separatorComma)
@@ -105,10 +127,10 @@ class SettingsRepo(
        _satelliteSelection.value = ids
    }

-    override fun setSelectedTypes(types: List<String>) {
-        val typesString = types.joinToString(separatorComma)
-        preferences.edit { putString(keySelectedTypes, typesString) }
-        _typesSelection.value = types
+    override fun setSelectedSatModes(modes: List<String>) {
+        val modesString = modes.joinToString(separatorComma)
+        preferences.edit { putString(keySelectedSatModes, modesString) }
+        _satelliteModeSelection.value = modes
    }

    private fun getSelectedIds(): List<Int> {
@@ -117,10 +139,10 @@ class SettingsRepo(
        return selectionString.split(separatorComma).map { it.toInt() }
    }

-    private fun getSelectedTypes(): List<String> {
-        val typesString = preferences.getString(keySelectedTypes, "Amateur")
-        if (typesString.isNullOrEmpty()) return emptyList()
-        return typesString.split(separatorComma)
+    private fun getSelectedSatModes(): List<String> {
+        val modesString = preferences.getString(keySelectedSatModes, null)
+        if (modesString.isNullOrEmpty()) return emptyList()
+        return modesString.split(separatorComma).sorted()
    }
    //endregion

@@ -135,7 +157,6 @@ class SettingsRepo(
        putInt(keyFilterAosStartMinute, settings.aosStartMinute)
        putInt(keyFilterAosEndMinute, settings.aosEndMinute)
        putBoolean(keyFilterAosInvert, settings.invertAosTimeWindow)
-        putString(keySelectedModes, settings.selectedModes.joinToString(separatorComma))
        _passesSettings.value = settings
    }

@@ -146,16 +167,13 @@ class SettingsRepo(
        val aosStartMinute = preferences.getInt(keyFilterAosStartMinute, 0).coerceIn(0, 23 * 60 + 59)
        val aosEndMinute = preferences.getInt(keyFilterAosEndMinute, 23 * 60 + 59).coerceIn(0, 23 * 60 + 59)
        val invertAosTimeWindow = preferences.getBoolean(keyFilterAosInvert, false)
-        val selectedModesString = preferences.getString(keySelectedModes, null)
-        val selectedModes = selectedModesString?.split(separatorComma)?.sorted() ?: emptyList()
        return PassesSettings(
            showDeepSpace,
            hoursAhead,
            minElevation,
            aosStartMinute,
            aosEndMinute,
-            invertAosTimeWindow,
-            selectedModes
+            invertAosTimeWindow
        )
    }
    //endregion
@@ -235,25 +253,6 @@ class SettingsRepo(
    private val _databaseState = MutableStateFlow(getDatabaseState())
    override val databaseState: StateFlow<DatabaseState> = _databaseState

-    override fun getSatelliteTypesIds(types: List<String>): List<Int> {
-        val idsSet = mutableSetOf<Int>()
-        types.forEach { type ->
-            val typeString = preferences.getString("type$type", null)
-            val typeIds = if (typeString.isNullOrBlank()) {
-                emptyList()
-            } else {
-                typeString.split(separatorComma).map { it.toInt() }
-            }
-            idsSet.addAll(typeIds)
-        }
-        return idsSet.toList()
-    }
-
-    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
-        if (type == "All") return
-        val typesString = ids.joinToString(separatorComma)
-        preferences.edit { putString("type$type", typesString) }
-    }

    override fun updateDatabaseState(state: DatabaseState) = preferences.edit {
        putInt(keyNumberOfSatellites, state.numberOfSatellites)
@@ -298,6 +297,10 @@ class SettingsRepo(
    override val rcSettings: StateFlow<RCSettings> = _rcSettings

    override fun updateRCSettings(settings: RCSettings) {
+        val clampedFreqOffsetHz = settings.frequencyOffsetHz.coerceIn(
+            Constants.FREQ_OFFSET_MIN_HZ,
+            Constants.FREQ_OFFSET_MAX_HZ
+        )
        preferences.edit {
            putBoolean(keyRotatorState, settings.rotatorState)
            putString(keyRotatorAddress, settings.rotatorAddress)
@@ -307,6 +310,7 @@ class SettingsRepo(
            putString(keyFrequencyAddress, settings.frequencyAddress)
            putString(keyFrequencyPort, settings.frequencyPort)
            putString(keyFrequencyFormat, settings.frequencyFormat)
+            putLong(keyFrequencyOffsetHz, clampedFreqOffsetHz)
            putBoolean(keyBluetoothRotatorState, settings.bluetoothRotatorState)
            putString(keyBluetoothRotatorFormat, settings.bluetoothRotatorFormat)
            putString(keyBluetoothRotatorName, settings.bluetoothRotatorName)
@@ -315,7 +319,7 @@ class SettingsRepo(
            putString(keyBluetoothFrequencyFormat, settings.bluetoothFrequencyFormat)
            putString(keyBluetoothFrequencyAddress, settings.bluetoothFrequencyAddress)
        }
-        _rcSettings.value = settings
+        _rcSettings.value = settings.copy(frequencyOffsetHz = clampedFreqOffsetHz)
    }

    private fun getRCSettings(): RCSettings = RCSettings(
@@ -327,6 +331,8 @@ class SettingsRepo(
        frequencyAddress = preferences.getString(keyFrequencyAddress, null) ?: "127.0.0.1",
        frequencyPort = preferences.getString(keyFrequencyPort, null) ?: "4532",
        frequencyFormat = preferences.getString(keyFrequencyFormat, null) ?: $$"F $FREQ",
+        frequencyOffsetHz = preferences.getLong(keyFrequencyOffsetHz, 0L)
+            .coerceIn(Constants.FREQ_OFFSET_MIN_HZ, Constants.FREQ_OFFSET_MAX_HZ),
        bluetoothRotatorState = preferences.getBoolean(keyBluetoothRotatorState, false),
        bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"P $AZ $EL",
        bluetoothRotatorName = preferences.getString(keyBluetoothRotatorName, null) ?: "Default",
@@ -356,6 +362,8 @@ class SettingsRepo(
                putString(keySstvMode, new.sstvMode)
                putLong(keyLowElevation, new.lowElevation.toRawBits())
                putLong(keyHighElevation, new.highElevation.toRawBits())
+                putFloat(keyRadarCompassOffset, new.radarCompassOffset)
+                putFloat(keyRadarCompassOffsetElev, new.radarCompassOffsetElev)
            }
            new
        }
@@ -372,7 +380,9 @@ class SettingsRepo(
        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
        sstvMode = preferences.getString(keySstvMode, null) ?: "Auto",
        lowElevation = Double.fromBits(preferences.getLong(keyLowElevation, 15.0.toRawBits())),
-        highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits()))
+        highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits())),
+        radarCompassOffset = preferences.getFloat(keyRadarCompassOffset, 0f),
+        radarCompassOffsetElev = preferences.getFloat(keyRadarCompassOffsetElev, 0f)
    )
    //endregion

@@ -381,21 +391,73 @@ class SettingsRepo(
    override val dataSourcesSettings: StateFlow<DataSourcesSettings> = _dataSourcesSettings

    override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
+        // Normalize the enabled lists so they are positionally aligned with the URL lists.
+        // Missing entries default to enabled (true), keeping the persisted "one flag per URL"
+        // invariant intact even when a default empty list is used to construct the model.
+        val normalized = settings.copy(
+            satelliteEnabled = alignFlags(settings.satelliteUrls, settings.satelliteEnabled),
+            transceiversEnabled = alignFlags(settings.transceiversUrls, settings.transceiversEnabled)
+        )
        preferences.edit {
-            putBoolean(keyUseCustomTle, settings.useCustomTLE)
-            putBoolean(keyUseCustomTransceivers, settings.useCustomTransceivers)
-            putString(keyTleUrl, settings.tleUrl)
-            putString(keyTransceiversUrl, settings.transceiversUrl)
+            putString(keySatellitesUrls, normalized.satelliteUrls.joinToString(separatorUrl))
+            putString(keyTransceiversUrls, normalized.transceiversUrls.joinToString(separatorUrl))
+            putString(keySatellitesUrlsEnabled, normalized.satelliteEnabled.joinToString(separatorComma))
+            putString(keyTransceiversUrlsEnabled, normalized.transceiversEnabled.joinToString(separatorComma))
        }
-        _dataSourcesSettings.value = settings
+        _dataSourcesSettings.value = normalized
    }

-    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 {
+        val (satUrls, satEnabled) = parseSources(
+            preferences.getString(keySatellitesUrls, null),
+            preferences.getString(keySatellitesUrlsEnabled, null),
+            Sources.satelliteDataUrls
+        )
+        val (txUrls, txEnabled) = parseSources(
+            preferences.getString(keyTransceiversUrls, null),
+            preferences.getString(keyTransceiversUrlsEnabled, null),
+            Sources.transceiversDataUrls
+        )
+        return DataSourcesSettings(
+            satelliteUrls = satUrls,
+            transceiversUrls = txUrls,
+            satelliteEnabled = satEnabled,
+            transceiversEnabled = txEnabled
+        )
+    }
+
+    private fun parseSources(
+        storedUrls: String?,
+        storedEnabled: String?,
+        defaults: List<String>
+    ): Pair<List<String>, List<Boolean>> {
+        if (storedUrls == null) return defaults to defaults.map { true }
+        val urls = storedUrls.split(separatorUrl)
+        val flags = if (storedEnabled.isNullOrEmpty()) emptyList() else storedEnabled.split(separatorComma)
+        val filteredUrls = mutableListOf<String>()
+        val filteredFlags = mutableListOf<Boolean>()
+        urls.forEachIndexed { index, url ->
+            if (url.isNotBlank()) {
+                filteredUrls.add(url)
+                filteredFlags.add(flags.getOrNull(index)?.toBoolean() ?: true)
+            }
+        }
+        return filteredUrls to filteredFlags
+    }
+
+    private fun alignFlags(urls: List<String>, flags: List<Boolean>): List<Boolean> {
+        if (flags.size >= urls.size) return flags.take(urls.size)
+        return flags + List(urls.size - flags.size) { true }
+    }
+    //endregion
+
+    //region # Data sources status
+    private val _dataSourcesStatus = MutableStateFlow<Map<String, Int>>(emptyMap())
+    override val dataSourcesStatus: StateFlow<Map<String, Int>> = _dataSourcesStatus
+
+    override fun updateDataSourcesStatus(status: Map<String, Int>) {
+        _dataSourcesStatus.value = status
+    }
    //endregion

    //region # Radio control settings
@@ -435,5 +497,39 @@ class SettingsRepo(
        baudRate = preferences.getInt(keyRadioBaudRate, 4800),
        splitMode = preferences.getBoolean(keyRadioSplitMode, false)
    )
+
+    private val keySatelliteOffsets = "satelliteOffsets"
+
+    override fun getSatelliteOffset(catnum: Int): String {
+        val json = preferences.getString(keySatelliteOffsets, "{}") ?: "{}"
+        return try {
+            JSONObject(json).optString(catnum.toString(), "")
+        } catch (_: Exception) {
+            ""
+        }
+    }
+
+    override fun setSatelliteOffset(catnum: Int, offset: String) {
+        val json = preferences.getString(keySatelliteOffsets, "{}") ?: "{}"
+        val updated = try {
+            val obj = JSONObject(json)
+            if (offset.isEmpty()) obj.remove(catnum.toString()) else obj.put(catnum.toString(), offset)
+            obj.toString()
+        } catch (_: Exception) {
+            """{"$catnum": "$offset"}"""
+        }
+        preferences.edit { putString(keySatelliteOffsets, updated) }
+    }
+
+    //region # AMSAT status report settings
+    private val keyAmSatCallsign = "amSatCallsign"
+
+    override fun getAmSatCallsign(): String {
+        return preferences.getString(keyAmSatCallsign, "").orEmpty()
+    }
+
+    override fun setAmSatCallsign(callsign: String) {
+        preferences.edit { putString(keyAmSatCallsign, callsign.trim().uppercase(Locale.US)) }
+    }
    //endregion
 }
@@ -43,6 +43,16 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
        return selectedOrbitalObjects
    }

+    override suspend fun getEntriesEpochs() = look4SatDao.getEntriesEpochs()
+
+    override suspend fun getEntriesNames() = look4SatDao.getEntriesNames()
+
+    override suspend fun renameEntries(names: Map<Int, String>) =
+        names.forEach { (catnum, name) -> look4SatDao.renameEntry(catnum, name) }
+
+    override suspend fun deleteEntriesWithIds(ids: List<Int>) =
+        ids.chunked(999).forEach { idsPart -> look4SatDao.deleteEntriesWithIds(idsPart) }
+
    override suspend fun insertEntries(entries: List<OrbitalData>) = look4SatDao.insertEntries(entries.toEntity())

    override suspend fun deleteEntries() = look4SatDao.deleteEntries()
@@ -51,12 +61,12 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {

    private fun FrameworkEntry.toDomain() = OrbitalData(
        this.name, this.epoch, this.meanmo, this.eccn, this.incl,
-        this.raan, this.argper, this.meanan, this.catnum, this.bstar
+        this.raan, this.argper, this.meanan, this.catnum, this.bstar, this.ndot
    )

    private fun OrbitalData.toEntity() = FrameworkEntry(
        this.name, this.epoch, this.meanmo, this.eccn, this.incl,
-        this.raan, this.argper, this.meanan, this.catnum, this.bstar
+        this.raan, this.argper, this.meanan, this.catnum, this.bstar, this.ndot
    )

    private fun List<OrbitalData>.toEntity() = this.map { item -> item.toEntity() }
@@ -73,15 +83,17 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
        return look4SatDao.getRadiosWithId(id).toDomainRadios()
    }

-    override suspend fun insertRadios(radios: List<SatRadio>) {
-        look4SatDao.insertRadios(radios.toFrameworkRadios())
+    override suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean) {
+        look4SatDao.insertRadios(radios.map { radio -> radio.toFramework(isCustom) })
    }

    override suspend fun deleteRadios() = look4SatDao.deleteRadios()

-    private fun DomainRadio.toFramework() = FrameworkRadio(
+    override suspend fun deleteManagedRadios() = look4SatDao.deleteManagedRadios()
+
+    private fun DomainRadio.toFramework(isCustom: Boolean = false) = FrameworkRadio(
        this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
-        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum, isCustom
    )

    private fun FrameworkRadio.toDomain() = DomainRadio(
@@ -89,8 +101,6 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum
    )

-    private fun List<DomainRadio>.toFrameworkRadios() = this.map { radio -> radio.toFramework() }
-
    private fun List<FrameworkRadio>.toDomainRadios() = this.map { radio -> radio.toDomain() }

    //endregion
@@ -20,11 +20,13 @@ package com.rtbishop.look4sat.core.data.source
 import android.content.ContentResolver
 import androidx.core.net.toUri
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.source.NetworkResult
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import java.io.ByteArrayInputStream
+import okhttp3.RequestBody.Companion.toRequestBody
 import java.io.InputStream

 class RemoteSource(
@@ -43,15 +45,74 @@ class RemoteSource(
        }
    }

-    override suspend fun getNetworkStream(url: String): InputStream? = withContext(dispatcher) {
+    override suspend fun getNetworkStream(url: String): NetworkResult = withContext(dispatcher) {
        try {
            val networkRequest = Request.Builder().url(url).build()
-            httpClient.newCall(networkRequest).execute().use { response ->
-                if (!response.isSuccessful) return@withContext null
-                ByteArrayInputStream(response.body.bytes())
+            val response = httpClient.newCall(networkRequest).execute()
+            if (!response.isSuccessful) {
+                val code = response.code
+                response.close()
+                return@withContext NetworkResult(code, null)
            }
+            // Return the body stream directly as the caller is responsible for closing it
+            // That returns the connection to OkHttp's pool
+            val body = response.body
+            if (body == null) {
+                response.close()
+                return@withContext NetworkResult(response.code, null)
+            }
+            NetworkResult(response.code, body.byteStream().buffered())
        } catch (exception: Exception) {
            println("RemoteSource network stream exception: $exception")
+            NetworkResult(NetworkResult.CONNECTION_ERROR, null)
+        }
+    }
+
+    override suspend fun getAmSatCatalog(): String? = withContext(dispatcher) {
+        try {
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/catalog.php")
+                .header("User-Agent", "Look4Sat")
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return@use null
+                response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource getAmSatCatalog exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = withContext(dispatcher) {
+        try {
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/reports.php?hours=$hours&limit=$limit")
+                .header("User-Agent", "Look4Sat")
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return@use null
+                response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource getAmSatReports exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = withContext(dispatcher) {
+        try {
+            val body = payloadJson.toRequestBody("application/json; charset=utf-8".toMediaType())
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/reports.php")
+                .header("User-Agent", "Look4Sat")
+                .post(body)
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                response.code to response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource submitAmSatReport exception: $exception")
            null
        }
    }
@@ -31,6 +31,7 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.source.NetworkResult
 import com.rtbishop.look4sat.core.domain.utility.DataParser
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -41,6 +42,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
 import java.io.InputStream
+import java.time.LocalDate

@OptIn(ExperimentalCoroutinesApi::class)
 class DatabaseRepoTest {
@@ -48,6 +50,10 @@ class DatabaseRepoTest {
    private val dispatcher = StandardTestDispatcher()
    private val dataParser = DataParser(dispatcher)

+    // fixtures carry a current epoch: stale entries are pruned on every remote update
+    private val todayEpoch = LocalDate.now().let { "%02d%03d".format(it.year % 100, it.dayOfYear) }
+    private val fresherEpoch = "$todayEpoch.71955234".toDouble()
+
    @Test
    fun `manual satellite import parses csv stream from content uri`() = runTest(dispatcher) {
        val uri = "content://look4sat/import/satellites"
@@ -62,7 +68,6 @@ class DatabaseRepoTest {

        assertEquals(1, localSource.insertedEntries.size)
        assertEquals(25544, localSource.insertedEntries.first().catnum)
-        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
        assertTrue(settingsRepo.databaseState.value.numberOfSatellites > 0)
    }

@@ -91,10 +96,8 @@ class DatabaseRepoTest {
        }
        val settingsRepo = FakeSettingsRepo(
            dataSources = DataSourcesSettings(
-                useCustomTLE = true,
-                useCustomTransceivers = false,
-                tleUrl = customCsvUrl,
-                transceiversUrl = ""
+                satelliteUrls = listOf(customCsvUrl),
+                transceiversUrls = emptyList()
            )
        )
        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
@@ -102,33 +105,200 @@ class DatabaseRepoTest {
        repository.updateFromRemote()

        assertTrue(localSource.insertedEntries.any { it.catnum == 25544 })
-        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
+    }
+
+    @Test
+    fun `remote update takes the freshest elements and the preferred name`() = runTest(dispatcher) {
+        val primaryUrl = "https://example.com/primary.txt"
+        val secondaryUrl = "https://example.com/secondary.txt"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[primaryUrl] = { validTleStream() }
+            networkStreams[secondaryUrl] = { fresherTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(primaryUrl, secondaryUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        val entry = localSource.insertedEntries.single { it.catnum == 25544 }
+        assertEquals("ISS (ZARYA)", entry.name)
+        assertEquals(fresherEpoch, entry.epoch, 1e-8)
+    }
+
+    @Test
+    fun `manual satellite import does not overwrite fresher data`() = runTest(dispatcher) {
+        val freshUri = "content://look4sat/import/fresh"
+        val staleUri = "content://look4sat/import/stale"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            fileStreams[freshUri] = { fresherTleStream() }
+            fileStreams[staleUri] = { validTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo()
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        assertEquals(1, repository.updateTLEFromFile(freshUri))
+        assertEquals(1, repository.updateTLEFromFile(staleUri))
+        assertEquals(fresherEpoch, localSource.insertedEntries.single().epoch, 1e-8)
+    }
+
+    @Test
+    fun `remote update drops transceivers that are no longer published`() = runTest(dispatcher) {
+        val radioUrl = "https://example.com/transmitters.json"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource()
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = emptyList(),
+                transceiversUrls = listOf(radioUrl)
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        remoteSource.networkStreams[radioUrl] = { twoRadiosStream() }
+        repository.updateFromRemote()
+        assertEquals(2, localSource.insertedRadios.size)
+
+        remoteSource.networkStreams[radioUrl] = { singleRadioStream() }
+        repository.updateFromRemote()
+        assertEquals(listOf("uuid-alive"), localSource.insertedRadios.map { it.uuid })
+    }
+
+    @Test
+    fun `remote update renames satellites even when their elements are not newer`() = runTest(dispatcher) {
+        val preferredUrl = "https://example.com/preferred.txt"
+        val freshUrl = "https://example.com/fresh.txt"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[freshUrl] = { fresherTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(freshUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+        repository.updateFromRemote()
+        assertEquals("ISS", localSource.insertedEntries.single().name)
+
+        // the user moves a source with older elements, but a better name, to the top of the list
+        remoteSource.networkStreams[preferredUrl] = { validTleStream() }
+        settingsRepo.dataSourcesSettings.value = DataSourcesSettings(
+            satelliteUrls = listOf(preferredUrl, freshUrl),
+            transceiversUrls = emptyList()
+        )
+        repository.updateFromRemote()
+
+        val entry = localSource.insertedEntries.single()
+        assertEquals("ISS (ZARYA)", entry.name)
+        assertEquals(fresherEpoch, entry.epoch, 1e-8)
+    }
+
+    @Test
+    fun `failed remote update records the attempt without claiming success`() = runTest(dispatcher) {
+        val failingUrl = "https://example.com/offline.txt"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource()
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(failingUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        settingsRepo.databaseState.value = DatabaseState(0, 0, 1_000L)
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+        repository.updateFromRemote()
+
+        // the update timestamp stays put so the data is not presented as fresh, while the recorded
+        // attempt keeps the next app launch from hammering a source that is already failing
+        assertEquals(1_000L, settingsRepo.databaseState.value.updateTimestamp)
+    }
+
+    @Test
+    fun `remote update keeps the transceivers imported from a file`() = runTest(dispatcher) {
+        val radioUri = "content://imported.json"
+        val radioUrl = "https://example.com/transmitters.json"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            fileStreams[radioUri] = { customRadioStream() }
+            networkStreams[radioUrl] = { singleRadioStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = emptyList(),
+                transceiversUrls = listOf(radioUrl)
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+        repository.updateTransceiversFromFile(radioUri)
+        repository.updateFromRemote()
+
+        // the remote snapshot replaces what the sources publish, the imported entry stays put
+        assertEquals(setOf("uuid-custom", "uuid-alive"), localSource.insertedRadios.map { it.uuid }.toSet())
    }

    private fun validCsvStream(): InputStream = """
        OBJECT_NAME,OBJECT_ID,EPOCH,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY,EPHEMERIS_TYPE,CLASSIFICATION_TYPE,NORAD_CAT_ID,ELEMENT_SET_NO,REV_AT_EPOCH,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION_DDOT
-        ISS (ZARYA),1998-067A,2021-11-16T12:28:09.322176,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
+        ISS (ZARYA),1998-067A,${LocalDate.now()}T12:28:09.322176,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
    """.trimIndent().byteInputStream()

    private fun validTleStream(): InputStream = """
        ISS (ZARYA)
-        1 25544U 98067A   21320.51955234  .00001288  00000+0  31985-4 0  9990
+        1 25544U 98067A   $todayEpoch.51955234  .00001288  00000+0  31985-4 0  9990
        2 25544  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
    """.trimIndent().byteInputStream()
+
+    private fun fresherTleStream(): InputStream = """
+        ISS
+        1 25544U 98067A   $todayEpoch.71955234  .00001288  00000+0  31985-4 0  9990
+        2 25544  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
+    """.trimIndent().byteInputStream()
+
+    private fun twoRadiosStream(): InputStream = """
+        [$radioAlive,{"uuid":"uuid-retired","description":"Retired","alive":true,"downlink_low":437800000,
+        "mode":"FM","invert":false,"norad_cat_id":25544}]
+    """.trimIndent().byteInputStream()
+
+    private fun singleRadioStream(): InputStream = "[$radioAlive]".byteInputStream()
+
+    private fun customRadioStream(): InputStream = """
+        [{"uuid":"uuid-custom","description":"Local beacon","alive":true,"downlink_low":144800000,
+        "mode":"FM","invert":false,"norad_cat_id":25544}]
+    """.trimIndent().byteInputStream()
 }

+private const val radioAlive = """{"uuid":"uuid-alive","description":"Voice repeater","alive":true,
+    "downlink_low":145800000,"mode":"FM","invert":false,"norad_cat_id":25544}"""
+
 private class FakeRemoteSource : IRemoteSource {
    val fileStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
    val networkStreams: MutableMap<String, () -> InputStream> = mutableMapOf()

    override suspend fun getFileStream(uri: String): InputStream? = fileStreams[uri]?.invoke()

-    override suspend fun getNetworkStream(url: String): InputStream? = networkStreams[url]?.invoke()
+    override suspend fun getNetworkStream(url: String): NetworkResult {
+        val stream = networkStreams[url]?.invoke()
+        return if (stream != null) NetworkResult(200, stream) else NetworkResult(404, null)
+    }
+
+    override suspend fun getAmSatCatalog(): String? = null
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = null
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = null
 }

 private class FakeLocalSource : ILocalSource {
    val insertedEntries = mutableListOf<OrbitalData>()
-    private val insertedRadios = mutableListOf<SatRadio>()
+    val insertedRadios = mutableListOf<SatRadio>()
+    private val customRadios = mutableListOf<String>()

    override suspend fun getEntriesTotal(): Int = insertedEntries.size

@@ -136,6 +306,21 @@ private class FakeLocalSource : ILocalSource {

    override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()

+    override suspend fun getEntriesEpochs(): Map<Int, Double> =
+        insertedEntries.associate { entry -> entry.catnum to entry.epoch }
+
+    override suspend fun getEntriesNames(): Map<Int, String> =
+        insertedEntries.associate { entry -> entry.catnum to entry.name }
+
+    override suspend fun renameEntries(names: Map<Int, String>) = names.forEach { (catnum, name) ->
+        val index = insertedEntries.indexOfFirst { entry -> entry.catnum == catnum }
+        if (index >= 0) insertedEntries[index] = insertedEntries[index].copy(name = name)
+    }
+
+    override suspend fun deleteEntriesWithIds(ids: List<Int>) {
+        insertedEntries.removeAll { entry -> entry.catnum in ids }
+    }
+
    override suspend fun insertEntries(entries: List<OrbitalData>) {
        insertedEntries += entries
    }
@@ -150,25 +335,34 @@ private class FakeLocalSource : ILocalSource {

    override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()

-    override suspend fun insertRadios(radios: List<SatRadio>) {
+    override suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean) {
+        insertedRadios.removeAll { stored -> radios.any { radio -> radio.uuid == stored.uuid } }
        insertedRadios += radios
+        if (isCustom) customRadios += radios.map { radio -> radio.uuid }
+        else customRadios -= radios.map { radio -> radio.uuid }.toSet()
    }

    override suspend fun deleteRadios() {
        insertedRadios.clear()
+        customRadios.clear()
+    }
+
+    override suspend fun deleteManagedRadios() {
+        insertedRadios.removeAll { radio -> radio.uuid !in customRadios }
    }
 }

 private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSourcesSettings()) : ISettingsRepo {

    override val appVersionName: String = "test"
+    override val appVersionCode: Long = 1L

    override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())

-    override val selectedTypes: StateFlow<List<String>> = MutableStateFlow(emptyList())
+    override val selectedSatModes: StateFlow<List<String>> = MutableStateFlow(emptyList())

    override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
-        PassesSettings(hoursAhead = 24, minElevation = 0.0, selectedModes = emptyList())
+        PassesSettings(hoursAhead = 24, minElevation = 0.0)
    )

    override val stationPosition: StateFlow<GeoPos> = MutableStateFlow(GeoPos(0.0, 0.0))
@@ -176,7 +370,7 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou
    override val databaseState: MutableStateFlow<DatabaseState> = MutableStateFlow(DatabaseState(0, 0, 0L))

    override val rcSettings: StateFlow<RCSettings> = MutableStateFlow(
-        RCSettings(false, "", "", "", false, "", "", "", false, "", "", "", false, "", "")
+        RCSettings(false, "", "", "", false, "", "", "", 0L, false, "", "", "", false, "", "")
    )

    override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
@@ -185,15 +379,15 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou

    override val dataSourcesSettings: MutableStateFlow<DataSourcesSettings> = MutableStateFlow(dataSources)

+    override val dataSourcesStatus: MutableStateFlow<Map<String, Int>> = MutableStateFlow(emptyMap())
+
    override val radioControlSettings: StateFlow<RadioControlSettings> = MutableStateFlow(
        RadioControlSettings(false, RadioControlSettings.MODEL_YAESU_FT817, "", "", "", "", 9600)
    )

-    val satelliteTypeIdsByType = mutableMapOf<String, List<Int>>()
-
    override fun setSelectedIds(ids: List<Int>) = Unit

-    override fun setSelectedTypes(types: List<String>) = Unit
+    override fun setSelectedSatModes(modes: List<String>) = Unit

    override fun setPassesSettings(settings: PassesSettings) = Unit

@@ -203,11 +397,6 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou

    override fun setStationPosition(locator: String): Boolean = true

-    override fun getSatelliteTypesIds(types: List<String>): List<Int> = emptyList()
-
-    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
-        satelliteTypeIdsByType[type] = ids
-    }

    override fun updateDatabaseState(state: DatabaseState) {
        databaseState.value = state
@@ -221,14 +410,24 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou
        dataSourcesSettings.value = settings
    }

+    override fun updateDataSourcesStatus(status: Map<String, Int>) {
+        dataSourcesStatus.value = status
+    }
+
    override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
+
+    override fun getSatelliteOffset(catnum: Int): String = ""
+
+    override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
+
+    override fun getAmSatCallsign(): String = ""
+
+    override fun setAmSatCallsign(callsign: String) = Unit
 }

 private fun defaultDataSourcesSettings(): DataSourcesSettings {
    return DataSourcesSettings(
-        useCustomTLE = false,
-        useCustomTransceivers = false,
-        tleUrl = "",
-        transceiversUrl = ""
+        satelliteUrls = emptyList(),
+        transceiversUrls = emptyList()
    )
 }
@@ -0,0 +1,194 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SelectionRepoTest {
+
+    private val dispatcher = StandardTestDispatcher()
+
+    @Test
+    fun `unknown mode values do not crash and do not filter out entries`() = runTest(dispatcher) {
+        val localSource = FakeLocalSource(
+            entries = listOf(
+                SatItem(25544, "ISS (ZARYA)", false),
+                SatItem(40967, "TIANGONG", false)
+            )
+        )
+        val settingsRepo = FakeSettingsRepo(selectedModes = listOf("REMOVED_MODE"))
+        val repository = SelectionRepo(dispatcher, localSource, settingsRepo)
+
+        val flow = repository.getEntriesFlow()
+        repository.setModes(listOf("REMOVED_MODE"))
+
+        val items = flow.first()
+
+        assertEquals(listOf(25544, 40967), items.map { it.catnum })
+        assertEquals(listOf("REMOVED_MODE"), repository.getCurrentModes())
+    }
+
+    @Test
+    fun `selected satellites are shown first`() = runTest(dispatcher) {
+        val localSource = FakeLocalSource(
+            entries = listOf(
+                SatItem(44444, "Zeta", false),
+                SatItem(25544, "Alpha", false),
+                SatItem(40967, "Beta", false)
+            )
+        )
+        val settingsRepo = FakeSettingsRepo(selectedModes = emptyList())
+        val repository = SelectionRepo(dispatcher, localSource, settingsRepo)
+
+        val flow = repository.getEntriesFlow()
+        repository.setSelection(listOf(40967), true)
+
+        val items = flow.first()
+
+        assertEquals(listOf(40967, 25544, 44444), items.map { it.catnum })
+        assertEquals(listOf(true, false, false), items.map { it.isSelected })
+    }
+
+    private class FakeLocalSource(
+        private val entries: List<SatItem>
+    ) : ILocalSource {
+        override suspend fun getEntriesTotal(): Int = entries.size
+
+        override suspend fun getEntriesList(): List<SatItem> = entries
+
+        override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
+
+        override suspend fun getEntriesEpochs(): Map<Int, Double> = emptyMap()
+
+        override suspend fun getEntriesNames(): Map<Int, String> = emptyMap()
+
+        override suspend fun renameEntries(names: Map<Int, String>) = Unit
+
+        override suspend fun deleteEntriesWithIds(ids: List<Int>) = Unit
+
+        override suspend fun insertEntries(entries: List<com.rtbishop.look4sat.core.domain.predict.OrbitalData>) = Unit
+
+        override suspend fun deleteEntries() = Unit
+
+        override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+
+        override suspend fun getRadiosTotal(): Int = 0
+
+        override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()
+
+        override suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean) = Unit
+
+        override suspend fun deleteRadios() = Unit
+
+        override suspend fun deleteManagedRadios() = Unit
+    }
+
+    private class FakeSettingsRepo(
+        selectedModes: List<String>
+    ) : ISettingsRepo {
+
+        override val appVersionName: String = "test"
+        override val appVersionCode: Long = 1L
+
+        override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
+
+        override val selectedSatModes: MutableStateFlow<List<String>> = MutableStateFlow(selectedModes)
+
+        override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
+            PassesSettings(hoursAhead = 24, minElevation = 0.0)
+        )
+
+        override val stationPosition: StateFlow<GeoPos> = MutableStateFlow(GeoPos(0.0, 0.0))
+
+        override val databaseState: MutableStateFlow<DatabaseState> = MutableStateFlow(DatabaseState(0, 0, 0L))
+
+        override val rcSettings: StateFlow<RCSettings> = MutableStateFlow(
+            RCSettings(false, "", "", "", false, "", "", "", 0L, false, "", "", "", false, "", "")
+        )
+
+        override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
+            OtherSettings(false, false, false, false, false, false, false, false)
+        )
+
+        override val dataSourcesSettings: StateFlow<DataSourcesSettings> = MutableStateFlow(
+            DataSourcesSettings(emptyList(), emptyList())
+        )
+
+        override val dataSourcesStatus: StateFlow<Map<String, Int>> = MutableStateFlow(emptyMap())
+
+        override val radioControlSettings: StateFlow<RadioControlSettings> = MutableStateFlow(
+            RadioControlSettings(false, RadioControlSettings.MODEL_YAESU_FT817, "", "", "", "", 9600)
+        )
+
+        override fun setSelectedIds(ids: List<Int>) = Unit
+
+        override fun setSelectedSatModes(modes: List<String>) {
+            selectedSatModes.value = modes
+        }
+
+        override fun setPassesSettings(settings: PassesSettings) = Unit
+
+        override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean = true
+
+        override fun setStationPosition(): Boolean = true
+
+        override fun setStationPosition(locator: String): Boolean = true
+
+        override fun updateDatabaseState(state: DatabaseState) {
+            databaseState.value = state
+        }
+
+        override fun updateRCSettings(settings: RCSettings) = Unit
+
+        override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) = Unit
+
+        override fun updateDataSourcesSettings(settings: DataSourcesSettings) = Unit
+
+        override fun updateDataSourcesStatus(status: Map<String, Int>) = Unit
+
+        override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
+
+        override fun getSatelliteOffset(catnum: Int): String = ""
+
+        override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
+
+        override fun getAmSatCallsign(): String = ""
+
+        override fun setAmSatCallsign(callsign: String) = Unit
+    }
+}
@@ -1,154 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Bayesian Morse timing decoder.
- * Replaces hard thresholds with probability-based decision making.
- *
- * Inspired by VE3NEA's CW Skimmer approach:
- * "Instead of making a hard decision at every input sample whether the signal
- * is present or not, compute the probability that the signal is present."
- *
- * Uses Gaussian probability density centered on expected durations:
- *   P(dit | duration) = exp(-(duration - dotMs)^2 / (2 * variance^2))
- *   P(dash | duration) = exp(-(duration - 3*dotMs)^2 / (2 * variance^2))
- */
-internal class CwBayesianDecoder {
-
-    // Morse timing parameters
-    private var dotDurationMs = 60f // initial 20 WPM
-    private var speedWpm = 20f
-
-    // Current symbol being accumulated
-    private var currentSymbol = StringBuilder()
-    private var textBuffer = StringBuilder()
-
-    // Recent dit lengths for speed estimation
-    private val recentDits = mutableListOf<Float>()
-
-    // Output
-    private var _decodedText = ""
-    val decodedText: String get() = _decodedText
-
-    /** Gaussian probability. */
-    private fun gaussianProb(durationMs: Float, expectedMs: Float, varianceMs: Float): Float {
-        if (varianceMs <= 0f) return 0f
-        val diff = durationMs - expectedMs
-        return kotlin.math.exp(-(diff * diff) / (2 * varianceMs * varianceMs))
-    }
-
-    /** Process a tone duration. Returns the symbol type with highest probability. */
-    fun processTone(durationMs: Float): ToneResult {
-        val ditProb = gaussianProb(durationMs, dotDurationMs, dotDurationMs * 0.4f)
-        val dashProb = gaussianProb(durationMs, dotDurationMs * 3f, dotDurationMs * 0.6f)
-
-        return if (ditProb > dashProb && ditProb > 0.05f) {
-            currentSymbol.append('0')
-            recentDits.add(durationMs)
-            updateSpeed()
-            ToneResult('0', ditProb)
-        } else if (dashProb > 0.05f) {
-            currentSymbol.append('1')
-            ToneResult('1', dashProb)
-        } else {
-            ToneResult(null, 0f)
-        }
-    }
-
-    /** Process a gap duration. Returns decoded character or null. */
-    fun processGap(durationMs: Float): Char? {
-        if (currentSymbol.isEmpty()) {
-            val wordProb = gaussianProb(durationMs, dotDurationMs * 7f, dotDurationMs * 1.2f)
-            if (wordProb > 0.2f) {
-                textBuffer.append(' ')
-                _decodedText = textBuffer.toString()
-                return ' '
-            }
-            return null
-        }
-
-        val interCharProb = gaussianProb(durationMs, dotDurationMs * 3f, dotDurationMs * 0.6f)
-        val wordProb = gaussianProb(durationMs, dotDurationMs * 7f, dotDurationMs * 1.2f)
-
-        if (wordProb > interCharProb && wordProb > 0.2f) {
-            val char = flushSymbol()
-            textBuffer.append(' ')
-            _decodedText = textBuffer.toString()
-            return char
-        }
-        if (interCharProb > 0.15f) {
-            val char = flushSymbol()
-            _decodedText = textBuffer.toString()
-            return char
-        }
-        return null
-    }
-
-    private fun flushSymbol(): Char? {
-        if (currentSymbol.isEmpty()) return null
-        val morse = currentSymbol.toString()
-        currentSymbol.clear()
-        val char = morseToChar(morse)
-        if (char != null) textBuffer.append(char)
-        return char
-    }
-
-    private fun updateSpeed() {
-        if (recentDits.size < 3) return
-        val sorted = recentDits.sorted()
-        val median = sorted[sorted.size / 2]
-        if (median > 0f) {
-            dotDurationMs = dotDurationMs * 0.7f + median * 0.3f
-            val wpm = 60.0f / (50.0f * dotDurationMs / 1000.0f)
-            if (wpm in 5f..55f) speedWpm = wpm
-        }
-    }
-
-    fun getSpeed(): Float = speedWpm
-
-    fun reset() {
-        dotDurationMs = 60f
-        speedWpm = 20f
-        recentDits.clear()
-        currentSymbol.clear()
-        textBuffer.clear()
-        _decodedText = ""
-    }
-
-    companion object {
-        private val MORSE_TABLE = mapOf(
-            "01" to 'A', "1000" to 'B', "1010" to 'C', "100" to 'D', "0" to 'E',
-            "0010" to 'F', "110" to 'G', "0000" to 'H', "00" to 'I', "0111" to 'J',
-            "101" to 'K', "0100" to 'L', "11" to 'M', "10" to 'N', "111" to 'O',
-            "0110" to 'P', "1101" to 'Q', "010" to 'R', "000" to 'S', "1" to 'T',
-            "001" to 'U', "0001" to 'V', "011" to 'W', "1001" to 'X', "1011" to 'Y',
-            "1100" to 'Z', "01111" to '1', "00111" to '2', "00011" to '3',
-            "00001" to '4', "00000" to '5', "10000" to '6', "11000" to '7',
-            "11100" to '8', "11110" to '9', "11111" to '0',
-            "010101" to '.', "110011" to ',', "001100" to '?', "011110" to '\'',
-            "101011" to '!', "10010" to '/', "10110" to '(', "101101" to ')',
-            "01000" to '&', "111000" to ':', "101010" to ';', "10001" to '=',
-            "01010" to '+', "100001" to '-', "001101" to '_', "010010" to '"',
-            "0001001" to '$', "011010" to '@'
-        )
-        fun morseToChar(morse: String): Char? = MORSE_TABLE[morse]
-    }
-}
-
-data class ToneResult(val symbol: Char?, val probability: Float)
@@ -1,114 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Multi-channel CW signal tracker.
- * Monitors the spectrogram for active frequency bins and extracts
- * energy envelopes for each detected signal.
- *
- * Inspired by CW Skimmer's multi-channel approach:
- * tracks all active signals in the passband simultaneously,
- * selects the best one for decoded output.
- */
-internal class CwChannelTracker(
-    private val spectrogram: CwSpectrogram,
-    private val maxChannels: Int = 3
-) {
-    data class Channel(
-        val bin: Int,
-        val frequency: Float,
-        var active: Boolean = false,
-        var energy: Float = 0f,
-        val history: MutableList<Float> = mutableListOf(),
-        var confidence: Float = 0f
-    )
-
-    private val channels = Array(maxChannels) { Channel(0, 0f) }
-
-    /** Scan the current spectrogram column and update channel tracking. */
-    fun update(): List<Channel> {
-        val col = spectrogram.getCurrentColumn()
-        val peaks = findPeaks(col, threshold = 0.3f, minDistance = 2)
-
-        // Update existing channels
-        for (ch in channels) {
-            if (ch.active) {
-                if (peaks.contains(ch.bin)) {
-                    ch.energy = col[ch.bin]
-                    ch.history.add(ch.energy)
-                    if (ch.history.size > 40) ch.history.removeAt(0)
-                    ch.confidence = computeConfidence(ch.history)
-                } else {
-                    // Signal lost — decay confidence
-                    ch.history.add(0f)
-                    if (ch.history.size > 40) ch.history.removeAt(0)
-                    ch.confidence *= 0.9f
-                    if (ch.confidence < 0.1f) ch.active = false
-                }
-            }
-        }
-
-        // Assign new peaks to inactive channels
-        var peakIdx = 0
-        for (ch in channels) {
-            if (!ch.active && peakIdx < peaks.size) {
-                val bin = peaks[peakIdx]
-                val freq = spectrogram.binToFreq(bin)
-                // Re-initialize channel
-                channels[peakIdx] = Channel(bin, freq, true, col[bin], mutableListOf(), 0.5f)
-                peakIdx++
-            }
-        }
-
-        return channels.filter { it.active }
-    }
-
-    /** Find peak bins in the spectrum. */
-    private fun findPeaks(spectrum: FloatArray, threshold: Float, minDistance: Int): List<Int> {
-        val peaks = mutableListOf<Int>()
-        for (i in 1 until spectrum.size - 1) {
-            if (spectrum[i] > spectrum[i - 1] && spectrum[i] > spectrum[i + 1] && spectrum[i] > threshold) {
-                if (peaks.isEmpty() || i - peaks.last() >= minDistance) {
-                    peaks.add(i)
-                }
-            }
-        }
-        return peaks.sortedByDescending { spectrum[it] }
-    }
-
-    /** Compute confidence from energy history. Lower variance = higher confidence. */
-    private fun computeConfidence(history: List<Float>): Float {
-        if (history.size < 10) return 0.3f
-        val recent = history.takeLast(10)
-        val mean = recent.average().toFloat()
-        val variance = recent.map { (it - mean) * (it - mean) }.average().toFloat()
-        return if (mean > 0f) (mean / (mean + variance + 0.1f)).coerceIn(0f, 1f) else 0f
-    }
-
-    /** Get the channel with highest confidence. */
-    fun getBestChannel(): Channel? {
-        return channels.filter { it.active }.maxByOrNull { it.confidence }
-    }
-
-    fun reset() {
-        for (i in channels.indices) {
-            channels[i] = Channel(0, 0f)
-        }
-    }
-}
@@ -1,165 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-
-/**
- * CW (Morse code) decoder v3 — Spectrogram-based multi-channel Bayesian decoder.
- *
- * Architecture inspired by Morse Expert / CW Skimmer (VE3NEA):
- *   1. FFT spectrogram creates a frequency×time matrix
- *   2. Multi-channel peak detector finds all active signals
- *   3. Per-channel energy envelope extraction
- *   4. Bayesian probability for symbol timing (Gaussian likelihood)
- *   5. Best channel selected for output
- *
- * Timing analysis is performed per spectrogram column (hop).
- * Each column represents hopSize/sampleRate seconds of audio.
- */
-class CwDecoder(
-    val sampleRate: Int = 8000,
-    cwToneFreq: Float = -1f // ignored in v3 (auto-detect via spectrogram)
-) {
-    companion object {
-        private const val FFT_SIZE = 256
-        private const val HOP_SIZE = 64
-    }
-
-    private val spectrogram = CwSpectrogram(
-        fftSize = FFT_SIZE,
-        hopSize = HOP_SIZE,
-        sampleRate = sampleRate,
-        minBin = 6,
-        maxBin = 38,
-        historyCols = 40
-    )
-    private val channelTracker = CwChannelTracker(spectrogram, maxChannels = 3)
-    private val bayesianDecoder = CwBayesianDecoder()
-
-    // Timing state per channel
-    private data class ChannelTiming(
-        var isSignal: Boolean = false,
-        var toneTicks: Int = 0,
-        var gapTicks: Int = 0
-    )
-    private val timingStates = Array(3) { ChannelTiming() }
-
-    // Time per spectrogram column in milliseconds
-    private val tickMs = 1000f * HOP_SIZE / sampleRate
-
-    // Output flows
-    private val _decodedTextFlow = MutableStateFlow("")
-    val decodedTextFlow: StateFlow<String> = _decodedTextFlow
-
-    private val _signalStrength = MutableStateFlow(0f)
-    val signalStrength: StateFlow<Float> = _signalStrength
-
-    private val _estimatedPitch = MutableStateFlow<Float?>(null)
-    val estimatedPitch: StateFlow<Float?> = _estimatedPitch
-
-    private val _estimatedSpeed = MutableStateFlow<Float?>(null)
-    val estimatedSpeed: StateFlow<Float?> = _estimatedSpeed
-
-    private var frameCount = 0
-
-    init {
-        if (cwToneFreq > 0f) {
-            _estimatedPitch.value = cwToneFreq
-        }
-    }
-
-    fun processBuffer(buffer: FloatArray) {
-        // 1. Feed samples to spectrogram
-        spectrogram.addSamples(buffer)
-
-        // 2. Get number of new columns generated
-        val newCols = spectrogram.getNewColumns()
-        if (newCols == 0) return
-
-        // 3. Update channel tracker (uses latest column for peak detection)
-        val activeChannels = channelTracker.update()
-
-        // 4. Process each new column for timing analysis
-        //    Columns are indexed 0..historyCols-1, where historyCols-1 is the newest
-        val baseIdx = (spectrogram.historyCols - newCols).coerceAtLeast(0)
-        for (colOffset in 0 until newCols) {
-            val col = spectrogram.getColumn(baseIdx + colOffset)
-
-            for ((idx, channel) in activeChannels.withIndex()) {
-                if (idx >= timingStates.size) break
-                val state = timingStates[idx]
-                val energy = if (channel.bin in col.indices) col[channel.bin] else 0f
-
-                // Adaptive threshold
-                val threshold = 0.3f + (energy - 0.3f) * 0.3f
-
-                if (energy > threshold) {
-                    if (!state.isSignal) {
-                        if (state.gapTicks > 0) {
-                            val gapMs = state.gapTicks * tickMs
-                            bayesianDecoder.processGap(gapMs)
-                        }
-                        state.gapTicks = 0
-                        state.isSignal = true
-                    }
-                    state.toneTicks++
-                } else {
-                    if (state.isSignal) {
-                        if (state.toneTicks > 0) {
-                            val toneMs = state.toneTicks * tickMs
-                            bayesianDecoder.processTone(toneMs)
-                        }
-                        state.toneTicks = 0
-                        state.isSignal = false
-                    }
-                    state.gapTicks++
-                }
-            }
-        }
-
-        // 5. Update outputs
-        frameCount++
-        if (frameCount % 5 == 0) {
-            val bestChannel = channelTracker.getBestChannel()
-            if (bestChannel != null) {
-                _estimatedPitch.value = bestChannel.frequency
-                _signalStrength.value = bestChannel.confidence
-                _estimatedSpeed.value = bayesianDecoder.getSpeed()
-            }
-            _decodedTextFlow.value = bayesianDecoder.decodedText
-        }
-    }
-
-    fun resetDecoder() {
-        spectrogram.reset()
-        channelTracker.reset()
-        bayesianDecoder.reset()
-        for (state in timingStates) {
-            state.isSignal = false
-            state.toneTicks = 0
-            state.gapTicks = 0
-        }
-        frameCount = 0
-        _decodedTextFlow.value = ""
-        _signalStrength.value = 0f
-        _estimatedPitch.value = null
-        _estimatedSpeed.value = null
-    }
-}
@@ -1,102 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.PI
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-/**
- * DSP utilities for CW (Morse code) decoding.
- * Pure Kotlin, no NDK required.
- */
-internal object CwDsp {
-
-    /**
-     * Design a simple bandpass FIR filter coefficients using windowed sinc method.
-     * @param lowCutoff  lower cutoff frequency (Hz) as fraction of sampleRate
-     * @param highCutoff upper cutoff frequency (Hz) as fraction of sampleRate
-     * @param taps       filter length (must be odd)
-     */
-    fun bandpassFir(lowCutoff: Double, highCutoff: Double, taps: Int): FloatArray {
-        val n = if (taps % 2 == 0) taps + 1 else taps
-        val half = n / 2
-        val coeffs = FloatArray(n)
-        for (i in 0 until n) {
-            val idx = i - half
-            if (idx == 0) {
-                coeffs[i] = (2.0 * (highCutoff - lowCutoff)).toFloat()
-            } else {
-                val x = PI * idx
-                coeffs[i] = ((sin(2 * highCutoff * x) - sin(2 * lowCutoff * x)) / x).toFloat()
-            }
-            // Hamming window
-            coeffs[i] = (coeffs[i] * (0.54 - 0.46 * cos(2 * PI * i / (n - 1)))).toFloat()
-        }
-        // Normalize
-        val sum = coeffs.sum()
-        if (sum != 0f) for (i in 0 until n) coeffs[i] /= sum
-        return coeffs
-    }
-
-    /** Apply FIR filter to a buffer. */
-    fun applyFir(buffer: FloatArray, coeffs: FloatArray): FloatArray {
-        val out = FloatArray(buffer.size)
-        for (i in buffer.indices) {
-            var sum = 0f
-            for (j in coeffs.indices) {
-                val idx = i - j
-                if (idx >= 0) sum += buffer[idx] * coeffs[j]
-            }
-            out[i] = sum
-        }
-        return out
-    }
-
-    /** Simple envelope detector: abs + low-pass smoothing. */
-    fun envelope(signal: FloatArray, alpha: Float = 0.1f): FloatArray {
-        val env = FloatArray(signal.size)
-        var s = 0f
-        for (i in signal.indices) {
-            s = alpha * kotlin.math.abs(signal[i]) + (1 - alpha) * s
-            env[i] = s
-        }
-        return env
-    }
-
-    /** Estimate noise floor from envelope for adaptive thresholding. */
-    fun noiseFloor(env: FloatArray, fraction: Float = 0.3f): Float {
-        val sorted = env.sortedArray()
-        val median = sorted[sorted.size / 2]
-        return median + (sorted[sorted.size * 9 / 10] - median) * fraction
-    }
-
-    /** Simple Goertzel to detect a specific tone frequency. */
-    fun goertzel(buffer: FloatArray, targetFreq: Float, sampleRate: Int): Float {
-        val omega = 2.0 * PI * targetFreq / sampleRate
-        val coeff = 2.0 * cos(omega)
-        var s0 = 0.0; var s1 = 0.0; var s2 = 0.0
-        for (sample in buffer) {
-            s0 = sample.toDouble() + coeff * s1 - s2
-            s2 = s1; s1 = s0
-        }
-        val power = s2 * s2 + s1 * s1 - coeff * s1 * s2
-        return sqrt(kotlin.math.abs(power)).toFloat()
-    }
-}
@@ -1,87 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.cos
-import kotlin.math.sqrt
-
-/**
- * Radix-2 FFT for real-valued input.
- * Produces magnitude spectrum for the first N/2+1 bins.
- * Used by CwSpectrogram for time-frequency analysis.
- */
-internal class CwFFT(private val n: Int) {
-    init {
-        require(n > 0 && n and (n - 1) == 0) { "FFT size must be power of 2, got $n" }
-    }
-
-    private val cosTable = FloatArray(n / 2)
-    private val sinTable = FloatArray(n / 2)
-
-    init {
-        for (i in 0 until n / 2) {
-            val angle = -2.0 * kotlin.math.PI * i / n
-            cosTable[i] = cos(angle).toFloat()
-            sinTable[i] = kotlin.math.sin(angle).toFloat()
-        }
-    }
-
-    /** Compute magnitude spectrum for real input. Returns array of size n/2+1. */
-    fun magnitudeSpectrum(input: FloatArray): FloatArray {
-        require(input.size == n) { "Input size must be $n, got ${input.size}" }
-
-        val real = input.copyOf()
-        val imag = FloatArray(n)
-
-        // Bit-reversal permutation
-        var j = 0
-        for (i in 1 until n) {
-            var bit = n shr 1
-            while (j and bit != 0) { j = j xor bit; bit = bit shr 1 }
-            j = j xor bit
-            if (i < j) {
-                var tmp = real[i]; real[i] = real[j]; real[j] = tmp
-            }
-        }
-
-        // Radix-2 Cooley-Tukey FFT
-        var len = 2
-        while (len <= n) {
-            val half = len / 2
-            val step = n / len
-            for (i in 0 until n step len) {
-                for (k in 0 until half) {
-                    val tReal = real[i + k + half] * cosTable[k * step] - imag[i + k + half] * sinTable[k * step]
-                    val tImag = real[i + k + half] * sinTable[k * step] + imag[i + k + half] * cosTable[k * step]
-                    real[i + k + half] = real[i + k] - tReal
-                    imag[i + k + half] = imag[i + k] - tImag
-                    real[i + k] += tReal
-                    imag[i + k] += tImag
-                }
-            }
-            len = len shl 1
-        }
-
-        // Magnitude spectrum (first N/2+1 bins)
-        val mag = FloatArray(n / 2 + 1)
-        for (i in 0..n / 2) {
-            mag[i] = sqrt(real[i] * real[i] + imag[i] * imag[i]) / n
-        }
-        return mag
-    }
-}
@@ -1,48 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * First-order IIR filters.
- * Ported from ggmorse/src/filter.h
- */
-internal class CwFilter {
-    private var z1 = 0f
-
-    companion object {
-        private const val PI_F = 3.141592653589793f
-    }
-
-    fun highPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
-        val rc = 1.0f / (2f * PI_F * cutoffHz)
-        val dt = 1.0f / sampleRate
-        val alpha = dt / (rc + dt)
-        z1 = alpha * (z1 + sample - z1)
-        return sample - z1
-    }
-
-    fun lowPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
-        val rc = 1.0f / (2f * PI_F * cutoffHz)
-        val dt = 1.0f / sampleRate
-        val alpha = dt / (rc + dt)
-        z1 += alpha * (sample - z1)
-        return z1
-    }
-
-    fun reset() { z1 = 0f }
-}
@@ -1,54 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.cos
-import kotlin.math.sqrt
-
-/**
- * Running Goertzel filter for CW tone detection.
- * Tracks a specific frequency over time with a sliding window.
- * Ported from ggmorse/src/goertzel.h
- */
-internal class CwGoertzel {
-    private var s1 = 0.0
-    private var s2 = 0.0
-    private var coeff = 0.0
-
-    fun init(sampleRate: Float, targetFreq: Float) {
-        val omega = 2.0 * kotlin.math.PI * targetFreq / sampleRate
-        coeff = 2.0 * cos(omega)
-        s1 = 0.0
-        s2 = 0.0
-    }
-
-    fun process(sample: Float) {
-        val s0 = sample.toDouble() + coeff * s1 - s2
-        s2 = s1
-        s1 = s0
-    }
-
-    fun getPower(): Float {
-        return sqrt(s2 * s2 + s1 * s1 - coeff * s1 * s2).toFloat()
-    }
-
-    fun reset() {
-        s1 = 0.0
-        s2 = 0.0
-    }
-}
@@ -1,53 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Simple linear resampler.
- * Downsamples from input sample rate to output sample rate.
- * Ported from ggmorse/src/resampler.h
- */
-internal class CwResampler(private val inputRate: Float, private val outputRate: Float) {
-    private val ratio = inputRate / outputRate
-    private var lastSample = 0f
-
-    fun process(input: FloatArray): FloatArray {
-        if (ratio <= 0f || input.isEmpty()) return input
-        val outputLen = (input.size / ratio).toInt() + 1
-        val output = FloatArray(outputLen)
-        var idx = 0f
-        for (i in output.indices) {
-            val intIdx = idx.toInt()
-            val frac = idx - intIdx
-            if (intIdx + 1 < input.size) {
-                output[i] = input[intIdx] * (1 - frac) + input[intIdx + 1] * frac
-            } else if (intIdx < input.size) {
-                output[i] = input[intIdx] * (1 - frac) + lastSample * frac
-            } else {
-                output[i] = lastSample
-            }
-            idx += ratio
-        }
-        lastSample = input.lastOrNull() ?: lastSample
-        return output
-    }
-
-    fun reset() {
-        lastSample = 0f
-    }
-}
@@ -1,61 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-/**
- * Lightweight pitch detector using DFT at specific frequency bins.
- * Only scans [200, 1200] Hz in configurable steps — much faster than full FFT.
- * Ported from ggmorse/src/stfft.h (simplified for CW use case).
- */
-internal class CwPitchDetector(
-    private val sampleRate: Float,
-    private val minFreq: Float = 200f,
-    private val maxFreq: Float = 1200f,
-    private val stepHz: Float = 10f
-) {
-    /**
-     * Find the dominant pitch frequency in the buffer.
-     * Returns null if no significant pitch found.
-     */
-    fun findPitch(buffer: FloatArray): Float? {
-        if (buffer.isEmpty()) return null
-        var bestFreq = 0f
-        var bestPower = 0f
-        var freq = minFreq
-        while (freq <= maxFreq) {
-            var real = 0.0
-            var imag = 0.0
-            val omega = 2.0 * kotlin.math.PI * freq / sampleRate
-            for (i in buffer.indices) {
-                real += buffer[i] * cos(omega * i)
-                imag += buffer[i] * -sin(omega * i)
-            }
-            val power = (real * real + imag * imag).toFloat()
-            if (power > bestPower) {
-                bestPower = power
-                bestFreq = freq
-            }
-            freq += stepHz
-        }
-        return if (bestPower > 0.001f) bestFreq else null
-    }
-}
@@ -1,170 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-/**
- * Sliding-window spectrogram for CW decoding.
- * Maintains a time-frequency matrix updated with each audio frame.
- *
- * FFT size: 256, hop size: 64, sample rate: 4000 (or native)
- * Frequency bins: 6..38 (187-1187 Hz, covers typical CW range)
- * History: 40 columns (320 ms window)
- * Time resolution: 64/4000 = 16 ms, Frequency resolution: 4000/256 = 15.625 Hz
- */
-internal class CwSpectrogram(
-    private val fftSize: Int = 256,
-    private val hopSize: Int = 64,
-    private val sampleRate: Int = 4000,
-    private val minBin: Int = 6,
-    private val maxBin: Int = 38,
-    val historyCols: Int = 40
-) {
-    private val fft = CwFFT(fftSize)
-    val numBins: Int get() = maxBin - minBin + 1
-
-    // Hanning window
-    private val hanning = FloatArray(fftSize) {
-        (0.5 - 0.5 * kotlin.math.cos(2.0 * kotlin.math.PI * it / (fftSize - 1))).toFloat()
-    }
-
-    // Spectrogram data: [timeCol][freqBin]
-    private val spectrogram = Array(historyCols) { FloatArray(numBins) }
-    private var currentCol = 0
-    private var samplesBuffered = 0
-    private val buffer = FloatArray(fftSize)
-
-    // Per-bin running energy for normalization
-    private val binEnergy = FloatArray(numBins) { 1f }
-    private val alpha = 0.95f
-
-    // Counter for new columns generated since last check
-    private var newColumnCount = 0
-
-    /** Add audio samples, compute FFTs for each complete hop. */
-    fun addSamples(samples: FloatArray) {
-        var offset = 0
-        while (offset < samples.size) {
-            val needed = fftSize - samplesBuffered
-            val copyLen = minOf(needed, samples.size - offset)
-            System.arraycopy(samples, offset, buffer, samplesBuffered, copyLen)
-            samplesBuffered += copyLen
-            offset += copyLen
-
-            if (samplesBuffered >= fftSize) {
-                processFrame()
-                newColumnCount++
-                // Shift buffer: keep last (fftSize - hopSize) samples
-                System.arraycopy(buffer, hopSize, buffer, 0, fftSize - hopSize)
-                samplesBuffered = fftSize - hopSize
-            }
-        }
-    }
-
-    /** Get number of new columns generated since the last call to this method. */
-    fun getNewColumns(): Int {
-        val count = newColumnCount
-        newColumnCount = 0
-        return count
-    }
-
-    private fun processFrame() {
-        // Apply Hanning window
-        val windowed = FloatArray(fftSize) { buffer[it] * hanning[it] }
-
-        // Compute FFT magnitude spectrum
-        val mag = fft.magnitudeSpectrum(windowed)
-
-        // Update spectrogram column
-        val col = spectrogram[currentCol]
-        for (b in 0 until numBins) {
-            val binIdx = minBin + b
-            val rawMag = mag[binIdx]
-            // Running energy normalization
-            binEnergy[b] = alpha * binEnergy[b] + (1 - alpha) * rawMag
-            col[b] = if (binEnergy[b] > 1e-6f) rawMag / binEnergy[b] else 0f
-        }
-
-        currentCol = (currentCol + 1) % historyCols
-    }
-
-    /** Get the current spectrogram as a 2D array in chronological order. */
-    fun getSpectrogram(): Array<FloatArray> {
-        val result = Array(historyCols) { i ->
-            val srcIdx = (currentCol + i) % historyCols
-            spectrogram[srcIdx].copyOf()
-        }
-        return result
-    }
-
-    /** Get the most recent column (current energy across all frequencies). */
-    fun getCurrentColumn(): FloatArray {
-        val prevCol = (currentCol - 1 + historyCols) % historyCols
-        return spectrogram[prevCol].copyOf()
-    }
-
-    /** Get a column by index from the history (0 = oldest, historyCols-1 = newest). */
-    fun getColumn(index: Int): FloatArray {
-        val clamped = index.coerceIn(0, historyCols - 1)
-        val srcIdx = (currentCol - historyCols + clamped + historyCols) % historyCols
-        return spectrogram[srcIdx].copyOf()
-    }
-
-    /** Find the frequency bin with peak energy. Returns -1 if no significant signal. */
-    fun findPeakBin(): Int {
-        val col = getCurrentColumn()
-        var maxBin = -1
-        var maxVal = 0f
-        for (i in col.indices) {
-            if (col[i] > maxVal) {
-                maxVal = col[i]
-                maxBin = i
-            }
-        }
-        return if (maxVal > 0.3f) maxBin else -1
-    }
-
-    /** Get energy at a specific bin over the last N columns in chronological order. */
-    fun getBinEnergy(bin: Int, numCols: Int): FloatArray {
-        val clamped = minOf(numCols, historyCols)
-        val result = FloatArray(clamped)
-        for (i in 0 until clamped) {
-            val colIdx = (currentCol - clamped + i + historyCols) % historyCols
-            result[i] = spectrogram[colIdx][bin]
-        }
-        return result
-    }
-
-    /** Get the bin index for a frequency in Hz. */
-    fun freqToBin(freqHz: Float): Int {
-        val bin = (freqHz * fftSize / sampleRate).toInt()
-        return (bin - minBin).coerceIn(0, numBins - 1)
-    }
-
-    /** Get the center frequency for a bin. */
-    fun binToFreq(bin: Int): Float {
-        return (minBin + bin).toFloat() * sampleRate / fftSize
-    }
-
-    fun reset() {
-        for (col in spectrogram) col.fill(0f)
-        currentCol = 0
-        samplesBuffered = 0
-        buffer.fill(0f)
-        binEnergy.fill(1f)
-    }
-}
@@ -0,0 +1,17 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** One public AMSAT satellite status report submission. */
+data class AmSatReportSubmission(
+    val name: String,
+    val report: String,
+    val callsign: String,
+    val gridSquare: String,
+    val reportedAtUtcMillis: Long
+)
+
+/** Result of submitting an AMSAT satellite status report. */
+data class AmSatReportSubmitResult(
+    val success: Boolean,
+    val message: String = "",
+    val reportId: String? = null
+)
@@ -0,0 +1,23 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.model
+
+object Constants {
+    const val FREQ_OFFSET_MIN_HZ = -50_000L
+    const val FREQ_OFFSET_MAX_HZ = 50_000L
+}
@@ -20,17 +20,19 @@ package com.rtbishop.look4sat.core.domain.model
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable

+/** Only the uuid is mandatory: third party sources rarely publish the full SatNOGS schema, and a
+ *  missing optional field should not cost the whole transceiver. */
@Serializable
 data class SatRadio(
    @SerialName("uuid") val uuid: String,
-    @SerialName("description") val info: String,
-    @SerialName("alive") val isAlive: Boolean,
-    @SerialName("downlink_low") val downlinkLow: Long?,
-    @SerialName("downlink_high") val downlinkHigh: Long?,
-    @SerialName("mode") val downlinkMode: String?,
-    @SerialName("uplink_low") val uplinkLow: Long?,
-    @SerialName("uplink_high") val uplinkHigh: Long?,
-    @SerialName("uplink_mode") val uplinkMode: String?,
-    @SerialName("invert") val isInverted: Boolean,
-    @SerialName("norad_cat_id") val catnum: Int?
+    @SerialName("description") val info: String = "",
+    @SerialName("alive") val isAlive: Boolean = true,
+    @SerialName("downlink_low") val downlinkLow: Long? = null,
+    @SerialName("downlink_high") val downlinkHigh: Long? = null,
+    @SerialName("mode") val downlinkMode: String? = null,
+    @SerialName("uplink_low") val uplinkLow: Long? = null,
+    @SerialName("uplink_high") val uplinkHigh: Long? = null,
+    @SerialName("uplink_mode") val uplinkMode: String? = null,
+    @SerialName("invert") val isInverted: Boolean = false,
+    @SerialName("norad_cat_id") val catnum: Int? = null
 )
@@ -0,0 +1,37 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** One satellite status report (AMSAT site tooltip data) */
+data class SatReport(
+    val id: String,          // 报告 ID(a885153)
+    val statusText: String,  // Heard / Telemetry Only / Not Heard ...
+    val call: String,        // 呼号
+    val grid: String,        // 网格坐标(可为空)
+    val dateUtc: String,     // 2026-08-04
+    val timeUtc: String      // 2:46-:59 UTC
+)
+
+/** State of one 2-hour slot */
+data class SatSlot(
+    val statusColor: Long,   // ARGB 状态色(-1 = 无报告)
+    val count: Int,          // 报告数量(0 = 无)
+    val reportIds: List<String> = emptyList() // 该槽报告 ID 列表
+)
+
+/** One satellite day (12 two-hour slots) */
+data class SatDay(
+    val dateLabel: String,   // "Aug 4"
+    val slots: List<SatSlot> // 12 槽(00-02 ... 22-24)
+)
+
+/** One satellite, 5 days of state */
+data class SatStatus(
+    val name: String,        // "AO-123_[FM]"
+    val days: List<SatDay>   // 5 天(新→旧)
+)
+
+/** Overall page parse result */
+data class SatStatusPage(
+    val fetchedAtUtcMs: Long,
+    val statuses: List<SatStatus>,
+    val reports: Map<String, SatReport> // id → 报告
+)
@@ -29,8 +29,7 @@ data class PassesSettings(
    val minElevation: Double,
    val aosStartMinute: Int = 0,
    val aosEndMinute: Int = 23 * 60 + 59,
-    val invertAosTimeWindow: Boolean = false,
-    val selectedModes: List<String>
+    val invertAosTimeWindow: Boolean = false
 )

 data class RCSettings(
@@ -42,6 +41,7 @@ data class RCSettings(
    val frequencyAddress: String,
    val frequencyPort: String,
    val frequencyFormat: String,
+    val frequencyOffsetHz: Long = 0L,
    val bluetoothRotatorState: Boolean,
    val bluetoothRotatorFormat: String,
    val bluetoothRotatorName: String,
@@ -62,15 +62,26 @@ 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,
+    val radarCompassOffset: Float = 0f,
+    val radarCompassOffsetElev: Float = 0f
 )

+/**
+ * Data source URLs (TLE / transceivers) and their per-source enabled flags.
+ * [satelliteEnabled] and [transceiversEnabled] must be positionally aligned with the
+ * corresponding URL list: the flag at index [i] applies to the URL at index [i].
+ * Missing flags are treated as enabled (see [isSatelliteEnabled]/[isTransceiverEnabled]).
+ */
 data class DataSourcesSettings(
-    val useCustomTLE: Boolean,
-    val useCustomTransceivers: Boolean,
-    val tleUrl: String,
-    val transceiversUrl: String
-)
+    val satelliteUrls: List<String>,
+    val transceiversUrls: List<String>,
+    val satelliteEnabled: List<Boolean> = emptyList(),
+    val transceiversEnabled: List<Boolean> = emptyList()
+) {
+    fun isSatelliteEnabled(index: Int): Boolean = satelliteEnabled.getOrElse(index) { true }
+    fun isTransceiverEnabled(index: Int): Boolean = transceiversEnabled.getOrElse(index) { true }
+}

 data class RadioControlSettings(
    val enabled: Boolean,
@@ -424,8 +424,12 @@ object CelestialComputer {
        }
        if (sunrise == 0.0) sunrise = daynum

-        // Phase 4: fast-forward through the day until sun drops back below threshold
-        daynum = sunrise
+        // Phase 4: fast-forward through the day until sun drops back below threshold.
+        // Start from just after sunrise (small offset) so the sun is clearly above
+        // the threshold. This prevents a bug where Phase 3 converges to a point
+        // slightly below -threshold, causing Phase 4 to skip and Phase 5 to converge
+        // to the same time as sunrise, producing identical sunrise/sunset times.
+        daynum = sunrise + 0.001
        sunPos = getSunPosition(observer, daynumToMillis(daynum))
        guard = 0
        while (sunPos.elevation > -threshold && guard++ < 500) {
@@ -37,30 +37,42 @@ data class OrbitalData(
    val xno: Double = meanmo * TWO_PI / MIN_PER_DAY
    val orbitalPeriod: Double = MIN_PER_DAY / meanmo
    val isDeepSpace: Boolean = orbitalPeriod >= 225.0 // NearEarth (period < 225 min) or DeepSpace (period >= 225 min)
+
+    /** Absolute age of this element set, used to pick the freshest data among several sources. */
+    val epochDaynum: Double = epochToDaynum(epoch)
+
    fun getObject(): OrbitalObject = if (isDeepSpace) DeepSpaceObject(this) else NearEarthObject(this)

    /** Check if satellite has likely decayed by the given time. */
    fun hasDecayed(currentTimeMillis: Long): Boolean {
        if (ndot == 0.0) return false
-        val currentDaynum = (currentTimeMillis - 315446400000L) / 86400000.0
-        val epochDaynum = epochToDaynum(epoch)
-        return CelestialComputer.hasDecayed(meanmo, ndot, epochDaynum, currentDaynum)
+        return CelestialComputer.hasDecayed(meanmo, ndot, epochDaynum, timeToDaynum(currentTimeMillis))
    }

-    private fun epochToDaynum(epoch: Double): Double {
-        var year = kotlin.math.floor(epoch * 1E-3)
-        val day = (epoch * 1E-3 - year) * 1000.0
-        year = if (year < 57) year + 2000 else year + 1900
-        // daynum = days since 31 Dec 1979, Julian date of 31Dec79 = 2444238.5
-        val jan1Jd = julianDateOfYear(year)
-        return jan1Jd + day - 2444238.5
-    }
+    companion object {
+        /** Days since 31 Dec 1979, the reference point every daynum in the app is based on. */
+        fun timeToDaynum(timeMillis: Long): Double = (timeMillis - 315446400000L) / 86400000.0

-    private fun julianDateOfYear(theYear: Double): Double {
-        val aYear = theYear - 1
-        val a = kotlin.math.floor(aYear / 100).toLong()
-        val b = 2 - a + a / 4
-        val i = kotlin.math.floor(365.25 * aYear).toLong()
-        return i + (30.6001 * 14).toLong() + 1720994.5 + b
+        /**
+         * Days since 31 Dec 1979 for a TLE style YYDDD.ffffffff epoch. Raw epochs are not
+         * comparable across decades (a 1999 epoch reads as 99xxx, a 2026 one as 26xxx), so
+         * freshness checks must always go through this conversion.
+         */
+        fun epochToDaynum(epoch: Double): Double {
+            var year = kotlin.math.floor(epoch * 1E-3)
+            val day = (epoch * 1E-3 - year) * 1000.0
+            year = if (year < 57) year + 2000 else year + 1900
+            // daynum = days since 31 Dec 1979, Julian date of 31Dec79 = 2444238.5
+            val jan1Jd = julianDateOfYear(year)
+            return jan1Jd + day - 2444238.5
+        }
+
+        private fun julianDateOfYear(theYear: Double): Double {
+            val aYear = theYear - 1
+            val a = kotlin.math.floor(aYear / 100).toLong()
+            val b = 2 - a + a / 4
+            val i = kotlin.math.floor(365.25 * aYear).toLong()
+            return i + (30.6001 * 14).toLong() + 1720994.5 + b
+        }
    }
 }
@@ -0,0 +1,14 @@
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmitResult
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+
+/** AMSAT satellite status data source */
+interface IAmSatRepository {
+    /** Fetch and parse the AMSAT status page; null on failure */
+    suspend fun fetchStatus(): SatStatusPage?
+
+    /** Submit a public AMSAT satellite status report. */
+    suspend fun submitReport(submission: AmSatReportSubmission): AmSatReportSubmitResult
+}
@@ -16,13 +16,12 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package com.rtbishop.look4sat.core.domain.repository
-import com.rtbishop.look4sat.core.domain.model.SatRadio
+
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
 import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
 import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
 import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.StateFlow

 interface IMainContainer {
    val appScope: CoroutineScope
@@ -30,9 +29,8 @@ interface IMainContainer {
    val selectionRepo: ISelectionRepo
    val satelliteRepo: ISatelliteRepo
    val databaseRepo: IDatabaseRepo
+    val amSatRepo: IAmSatRepository
    val radioTrackingService: IRadioTrackingService
-    val mutualPassData: StateFlow<MutualPassData>
-    fun setMutualPassData(data: MutualPassData)
    fun provideAddToCalendar(): IAddToCalendar
    fun provideShowToast(): IShowToast
    fun provideBluetoothReporter(): IReporter
@@ -42,27 +40,9 @@ interface IMainContainer {
    fun provideRxRadioController(): IRadioController
    fun provideAudioCapture(): IAudioCapture
    fun provideSaveImage(): ISaveImage
+    fun providePairedBluetoothDevices(): List<Pair<String, String>>
 }

-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
 }
@@ -21,10 +21,10 @@ import com.rtbishop.look4sat.core.domain.model.SatItem
 import kotlinx.coroutines.flow.Flow

 interface ISelectionRepo {
-    fun getCurrentTypes(): List<String>
-    fun getTypesList(): List<String>
+    fun getCurrentModes(): List<String>
+    fun getModesList(): List<String>
    suspend fun getEntriesFlow(): Flow<List<SatItem>>
-    suspend fun setTypes(types: List<String>)
+    suspend fun setModes(modes: List<String>)
    suspend fun setQuery(query: String)
    suspend fun setSelection(selectAll: Boolean)
    suspend fun setSelection(ids: List<Int>, isTicked: Boolean)
@@ -29,12 +29,13 @@ import kotlinx.coroutines.flow.StateFlow
 interface ISettingsRepo {

    val appVersionName: String
+    val appVersionCode: Long

    //region # Satellites selection settings
    val selectedIds: StateFlow<List<Int>>
-    val selectedTypes: StateFlow<List<String>>
+    val selectedSatModes: StateFlow<List<String>>
    fun setSelectedIds(ids: List<Int>)
-    fun setSelectedTypes(types: List<String>)
+    fun setSelectedSatModes(modes: List<String>)
    //endregion

    //region # Passes filter settings
@@ -51,8 +52,6 @@ interface ISettingsRepo {

    //region # Database update settings
    val databaseState: StateFlow<DatabaseState>
-    fun getSatelliteTypesIds(types: List<String>): List<Int>
-    fun setSatelliteTypeIds(type: String, ids: List<Int>)
    fun updateDatabaseState(state: DatabaseState)
    //endregion

@@ -73,8 +72,23 @@ interface ISettingsRepo {
    fun updateDataSourcesSettings(settings: DataSourcesSettings)
    //endregion

+    //region # Data sources status
+    val dataSourcesStatus: StateFlow<Map<String, Int>>
+    fun updateDataSourcesStatus(status: Map<String, Int>)
+    //endregion
+
    //region # Radio control settings
    val radioControlSettings: StateFlow<RadioControlSettings>
    fun updateRadioControlSettings(settings: RadioControlSettings)
    //endregion
+
+    //region # Per-satellite calculator offset settings
+    fun getSatelliteOffset(catnum: Int): String
+    fun setSatelliteOffset(catnum: Int, offset: String)
+    //endregion
+
+    //region # AMSAT status report settings
+    fun getAmSatCallsign(): String
+    fun setAmSatCallsign(callsign: String)
+    //endregion
 }
@@ -26,11 +26,18 @@ interface ILocalSource {
    suspend fun getEntriesTotal(): Int
    suspend fun getEntriesList(): List<SatItem>
    suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject>
+    suspend fun getEntriesEpochs(): Map<Int, Double>
+    suspend fun getEntriesNames(): Map<Int, String>
+    suspend fun renameEntries(names: Map<Int, String>)
+    suspend fun deleteEntriesWithIds(ids: List<Int>)
    suspend fun insertEntries(entries: List<OrbitalData>)
    suspend fun deleteEntries()
    suspend fun getIdsWithModes(modes: List<String>): List<Int>
    suspend fun getRadiosTotal(): Int
    suspend fun getRadiosWithId(id: Int): List<SatRadio>
-    suspend fun insertRadios(radios: List<SatRadio>)
+    suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean)
    suspend fun deleteRadios()
+
+    /** Drops the transceivers provided by the remote sources, keeping the imported ones. */
+    suspend fun deleteManagedRadios()
 }
@@ -19,7 +19,18 @@ package com.rtbishop.look4sat.core.domain.source

 import java.io.InputStream

+/** Result of a network download: the HTTP status code and the response body stream. */
+data class NetworkResult(val code: Int, val stream: InputStream?) {
+    companion object {
+        /** Code used when a request fails before any HTTP response is received. */
+        const val CONNECTION_ERROR = -1
+    }
+}
+
 interface IRemoteSource {
    suspend fun getFileStream(uri: String): InputStream?
-    suspend fun getNetworkStream(url: String): InputStream?
+    suspend fun getNetworkStream(url: String): NetworkResult
+    suspend fun getAmSatCatalog(): String?
+    suspend fun getAmSatReports(hours: Int, limit: Int): String?
+    suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>?
 }
@@ -18,37 +18,27 @@
 package com.rtbishop.look4sat.core.domain.source

 object Sources {
-    val satelliteDataUrls = mapOf(
-        "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
-        "Amateur" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=csv",
-        "Brightest" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=visual&FORMAT=csv",
-        "Cubesat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=cubesat&FORMAT=csv",
-        "Education" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=education&FORMAT=csv",
-        "Engineer" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=engineering&FORMAT=csv",
-        "Geostationary" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=geo&FORMAT=csv",
-        "Globalstar" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=globalstar&FORMAT=csv",
-        "GNSS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=gnss&FORMAT=csv",
-        "Intelsat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=intelsat&FORMAT=csv",
-        "Iridium" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=iridium-NEXT&FORMAT=csv",
-        "Military" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=military&FORMAT=csv",
-        "New" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=last-30-days&FORMAT=csv",
-        "OneWeb" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=oneweb&FORMAT=csv",
-        "Orbcomm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=orbcomm&FORMAT=csv",
-        "Resource" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=resource&FORMAT=csv",
-        "SatNOGS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv",
-        "Science" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=science&FORMAT=csv",
-        "Spire" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=spire&FORMAT=csv",
-        "Starlink" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=starlink&FORMAT=csv",
-        "Swarm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=swarm&FORMAT=csv",
-        "Weather" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=weather&FORMAT=csv",
-        "X-Comm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=x-comm&FORMAT=csv",
-        "Amsat" to "https://amsat.org/tle/current/nasabare.txt",
-        "Classified" to "https://www.mmccants.org/tles/classfd.zip",
-        "McCants" to "https://www.mmccants.org/tles/inttles.zip",
-        "R4UAB" to "https://r4uab.ru/satonline.txt",
-        "Other" to "" // key for sats filter
+    // Ordered from the most specific to the most generic source: the first source that knows a
+    // satellite gets to name it, with the full catalog acting as the fallback.
+    val satelliteDataUrls = listOf(
+        "live.ariss.org/iss.txt",
+        "r4uab.ru/satonline.txt",
+        "mmccants.org/tles/classfd.zip",
+        "amsat.org/tle/current/nasabare.txt",
+        "celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
+        "db.satnogs.org/api/tle/?format=3le"
    )
-    val transceiversDataUrls = mapOf(
-        "SatNOGS" to "https://db.satnogs.org/api/transmitters/?format=json&status=active"
+    val transceiversDataUrls = listOf(
+        "r4uab.ru/transmitters.json",
+        "db.satnogs.org/api/transmitters/?format=json&status=active"
+    )
+    val satelliteModes = listOf(
+        "4FSK", "64-QAM", "AFSK", "AFSK TUBiX10", "AHRPT", "AM", "APT", "ASK", "BPSK",
+        "BPSK PMT-A3", "CERTO", "CW", "DATV", "DBPSK", "DOKA", "DPSK", "DQPSK", "DSB", "DSTAR",
+        "DUV", "DVB-S2", "FFSK", "FM", "FMN", "FSK", "FSK AX.100 Mode 5", "FSK AX.100 Mode 6",
+        "FSK AX.25 G3RUH", "FT8", "GENESIS FSK", "GFSK", "GFSK Pkst", "GFSK Rktr", "GFSK/BPSK",
+        "GMSK", "GMSK USP", "HRPT", "LoRa", "LRPT", "LSB", "MFSK", "MSK", "MSK AX.100 Mode 5",
+        "MSK AX.100 Mode 6", "OFDM", "OQPSK", "PPM", "PSK", "PSK31", "PSK63", "QPSK", "QPSK31",
+        "QPSK63", "SIDLOC", "SQPSK", "SSDV", "SSTV", "UNKNOWN", "USB", "WSJT"
    )
 }
@@ -33,10 +33,19 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
        ignoreUnknownKeys = true
        coerceInputValues = true
    }
+    private val alpha5Alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ"
+    private val celestrakCSVColumns = mapOf(
+        "OBJECT_NAME" to 0, "EPOCH" to 2, "MEAN_MOTION" to 3, "ECCENTRICITY" to 4,
+        "INCLINATION" to 5, "RA_OF_ASC_NODE" to 6, "ARG_OF_PERICENTER" to 7,
+        "MEAN_ANOMALY" to 8, "NORAD_CAT_ID" to 11, "BSTAR" to 14, "MEAN_MOTION_DOT" to 15
+    )

    suspend fun parseCSVStream(stream: InputStream): List<OrbitalData> = withContext(dispatcher) {
        stream.bufferedReader().useLines { lines ->
-            lines.drop(1).mapNotNull { parseCSV(it.split(",")) }.toList()
+            val iterator = lines.iterator()
+            if (!iterator.hasNext()) return@useLines emptyList()
+            val columns = parseCSVColumns(iterator.next())
+            iterator.asSequence().mapNotNull { line -> parseCSV(line.split(","), columns) }.toList()
        }
    }

@@ -58,40 +67,68 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
        }.getOrDefault(emptyList())
    }

-    private fun parseCSV(values: List<String>): OrbitalData? = runCatching {
-        val name = values[0]
-        val timestamp = values[2]
-        val year = timestamp.substring(0, 4)
-        val month = timestamp.substring(5, 7).toInt()
-        val dayOfMonth = timestamp.substring(8, 10).toInt()
-        val dayInt = getDayOfYear(year.toInt(), month, dayOfMonth)
-        val day = dayInt.toString().padStart(3, '0')
-        val hour = timestamp.substring(11, 13).toInt() * 3600000
-        val min = timestamp.substring(14, 16).toInt() * 60000
-        val sec = timestamp.substring(17, 19).toInt() * 1000
-        val ms = timestamp.substring(20, 26).toInt() / 1000.0
-        val frac = ((hour + min + sec + ms) / 86400000.0).toString().substring(1)
-        val epoch = "${year.substring(2)}$day$frac".toDouble()
+    private fun parseCSV(values: List<String>, columns: Map<String, Int>): OrbitalData? = runCatching {
+        fun value(column: String) = values[columns.getValue(column)].trim()
+        fun optionalValue(column: String) =
+            columns[column]?.let { index -> values.getOrNull(index) }?.trim()?.toDoubleOrNull() ?: 0.0
        OrbitalData(
-            name = name,
-            epoch = epoch,
-            meanmo = values[3].toDouble(),
-            eccn = values[4].toDouble(),
-            incl = values[5].toDouble(),
-            raan = values[6].toDouble(),
-            argper = values[7].toDouble(),
-            meanan = values[8].toDouble(),
-            catnum = values[11].toInt(),
-            bstar = values[14].toDouble(),
-            ndot = values[15].toDouble()
+            name = value("OBJECT_NAME"),
+            epoch = parseTimestamp(value("EPOCH")),
+            meanmo = value("MEAN_MOTION").toDouble(),
+            eccn = value("ECCENTRICITY").toDouble(),
+            incl = value("INCLINATION").toDouble(),
+            raan = value("RA_OF_ASC_NODE").toDouble(),
+            argper = value("ARG_OF_PERICENTER").toDouble(),
+            meanan = value("MEAN_ANOMALY").toDouble(),
+            catnum = parseCatnum(value("NORAD_CAT_ID")),
+            bstar = optionalValue("BSTAR"),
+            ndot = optionalValue("MEAN_MOTION_DOT")
        )
    }.onFailure { println("CSV parsing exception: $it") }.getOrNull()

+    /**
+     * OMM columns are located by name, as providers agree on the names but not on the order.
+     * Falls back to the Celestrak layout when the header is missing or unrecognized.
+     */
+    private fun parseCSVColumns(header: String): Map<String, Int> {
+        val columns = header.split(",").withIndex().associate { (index, name) ->
+            name.trim().trim('"').uppercase() to index
+        }
+        return if (columns.containsKey("NORAD_CAT_ID")) columns else celestrakCSVColumns
+    }
+
+    /**
+     * ISO 8601 timestamp as a TLE style YYDDD.ffffffff epoch. Fractional seconds are optional and
+     * a trailing timezone marker is ignored, as not every provider formats the epoch alike.
+     */
+    private fun parseTimestamp(timestamp: String): Double {
+        val year = timestamp.substring(0, 4).toInt()
+        val month = timestamp.substring(5, 7).toInt()
+        val dayOfMonth = timestamp.substring(8, 10).toInt()
+        val hours = timestamp.substring(11, 13).toInt()
+        val minutes = timestamp.substring(14, 16).toInt()
+        val seconds = timestamp.substring(17).takeWhile { it.isDigit() || it == '.' }.toDouble()
+        val dayFraction = (hours * 3600 + minutes * 60 + seconds) / 86400.0
+        return (year % 100) * 1000 + getDayOfYear(year, month, dayOfMonth) + dayFraction
+    }
+
+    /**
+     * Catalog numbers above 99999 do not fit the 5 digit TLE field, so they are encoded as Alpha-5:
+     * the leading two digits become a letter, with I and O skipped to avoid confusion with 1 and 0.
+     */
+    private fun parseCatnum(value: String): Int {
+        val catnum = value.trim()
+        if (catnum.first().isDigit()) return catnum.toInt()
+        val alphaIndex = alpha5Alphabet.indexOf(catnum.first().uppercaseChar())
+        require(alphaIndex >= 0) { "Unknown Alpha-5 catalog number: $catnum" }
+        return (alphaIndex + 10) * 10000 + catnum.drop(1).trim().toInt()
+    }
+
    private fun parseTLE(tle: List<String>): OrbitalData? = runCatching {
        val line1 = tle[1]
        val line2 = tle[2]
        OrbitalData(
-            name = tle[0].trim(),
+            name = tle[0].trim().removePrefix("0 "),
            epoch = line1.substring(18, 32).toDouble(),
            meanmo = line2.substring(52, 63).toDouble(),
            eccn = line2.substring(26, 33).toDouble() / 1e7,
@@ -99,7 +136,7 @@ class DataParser(private val dispatcher: CoroutineDispatcher) {
            raan = line2.substring(17, 25).toDouble(),
            argper = line2.substring(34, 42).toDouble(),
            meanan = line2.substring(43, 51).toDouble(),
-            catnum = line1.substring(2, 7).trim().toInt(),
+            catnum = parseCatnum(line1.substring(2, 7)),
            bstar = 1e-5 * line1.substring(53, 59).toDouble() / 10.0.pow(line1.substring(60, 61).toDouble()),
            ndot = line1.substring(33, 43).trim().toDouble()
        )
@@ -16,28 +16,18 @@ import java.util.Locale
 /**
 * Computes Doppler-corrected reciprocal frequencies for linear transponders.
 *
- * The full physical path:
+ * For a linear (passband) transponder, uplink and downlink frequencies are
+ * related by a fixed passband offset. When the satellite moves, both are
+ * Doppler-shifted. Given one, this computes the other:
 *
- * TX→RX (uplink → downlink):
- *   ① 地面发射 f_tx
- *   ② 卫星收到 f_tx × (c - v) / c  （上行多普勒）
- *   ③ 卫星转发 = passband映射(②)    （在卫星上做映射）
- *   ④ 地面听到 ③ × (c - v) / c     （下行多普勒）
- *
- * RX→TX (downlink → uplink):
- *   ④ 地面听到 f_rx
- *   ③ 卫星转发 = f_rx × (c + v) / c  （逆下行多普勒）
- *   ② 卫星收到 = 逆passband映射(③)
- *   ① 地面应发射 = ② × (c + v) / c   （逆上行多普勒）
- *
- * Addresses GitHub issue #91 (Custom frequency Doppler correction).
+ *   downlink → uplink: mapDownlinkToUplink (passband) → getUplinkFreq (Doppler)
+ *   uplink → downlink: mapUplinkToDownlink (passband) → getDownlinkFreq (Doppler)
 */
 object DopplerFrequencyCalculator {

    /**
-     * Given a downlink frequency (what the user hears), compute the
-     * uplink frequency the user should transmit.
-     * Full path: ④→③→②→①
+     * 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,
@@ -45,22 +35,17 @@ object DopplerFrequencyCalculator {
        orbitalPos: OrbitalPos
    ): Long? {
        if (!isLinearTransponder(transponder)) return null
-        // ④→③ 逆下行多普勒：卫星转发的频率
-        val satTx = orbitalPos.getUplinkFreq(downlinkHz)
-        // ③→② 逆 passband 映射
-        val satRx = TransponderMapper.mapDownlinkToUplink(satTx, transponder) ?: return null
-        // ②→① 逆上行多普勒：地面应发射的频率
-        return orbitalPos.getUplinkFreq(satRx)
+        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz, transponder) ?: return null
+        return orbitalPos.getUplinkFreq(baseUplink)
    }

    /**
-     * Given a downlink frequency (what the user hears), compute the
-     * uplink frequency the user should transmit, with an offset applied
-     * to the downlink (in Hz).
-     * Full path: ④→③→②→①
+     * Given a downlink frequency, compute the Doppler-corrected uplink frequency
+     * with an offset applied to the downlink (in Hz).
+     * Returns null if the transponder is not a linear passband type.
     *
     * The user-entered downlink frequency already includes the offset, so subtract
-     * it before the inverse downlink Doppler.
+     * it before mapping the downlink passband position back to the uplink.
     */
    fun computeUplinkFromDownlinkWithOffset(
        downlinkHz: Long,
@@ -69,20 +54,13 @@ object DopplerFrequencyCalculator {
        offsetHz: Long
    ): Long? {
        if (!isLinearTransponder(transponder)) return null
-        // ④→③ 逆下行多普勒：卫星转发的频率（含 offset）
-        val satTxWithOffset = orbitalPos.getUplinkFreq(downlinkHz)
-        // ③ 去掉 offset（offset 在卫星本地频率域）
-        val satTx = satTxWithOffset - offsetHz
-        // ③→② 逆 passband 映射
-        val satRx = TransponderMapper.mapDownlinkToUplink(satTx, transponder) ?: return null
-        // ②→① 逆上行多普勒：地面应发射的频率
-        return orbitalPos.getUplinkFreq(satRx)
+        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz - offsetHz, transponder) ?: return null
+        return orbitalPos.getUplinkFreq(baseUplink)
    }

    /**
-     * Given an uplink frequency (what the user transmits), compute the
-     * downlink frequency the user will hear.
-     * Full path: ①→②→③→④
+     * 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,
@@ -90,19 +68,14 @@ object DopplerFrequencyCalculator {
        orbitalPos: OrbitalPos
    ): Long? {
        if (!isLinearTransponder(transponder)) return null
-        // ①→② 上行多普勒：卫星收到的频率
-        val satRx = orbitalPos.getDownlinkFreq(uplinkHz)
-        // ②→③ passband 映射
-        val satTx = TransponderMapper.mapUplinkToDownlink(satRx, transponder) ?: return null
-        // ③→④ 下行多普勒：地面听到的
-        return orbitalPos.getDownlinkFreq(satTx)
+        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
+        return orbitalPos.getDownlinkFreq(baseDownlink)
    }

    /**
-     * Given an uplink frequency (what the user transmits), compute the
-     * downlink frequency the user will hear, with an offset applied
-     * to the downlink (in Hz).
-     * Full path: ①→②→③→④
+     * 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,
@@ -111,13 +84,8 @@ object DopplerFrequencyCalculator {
        offsetHz: Long
    ): Long? {
        if (!isLinearTransponder(transponder)) return null
-        // ①→② 上行多普勒：卫星收到的频率
-        val satRx = orbitalPos.getDownlinkFreq(uplinkHz)
-        // ②→③ passband 映射
-        val satTx = TransponderMapper.mapUplinkToDownlink(satRx, transponder) ?: return null
-        // ③ 加上 offset（offset 在卫星本地频率域）
-        // ③→④ 下行多普勒：地面听到的
-        return orbitalPos.getDownlinkFreq(satTx + offsetHz)
+        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
+        return orbitalPos.getDownlinkFreq(baseDownlink + offsetHz)
    }

    /** True if this transponder supports linear passband mapping. */
@@ -134,8 +102,8 @@ object DopplerFrequencyCalculator {
     * True for the radio entry that should drive the standalone Calculator page.
     *
     * A frequency range alone is not enough: some non-user-facing or drifting data entries
-     * can also have low/high frequencies. The calculator is meant for the named linear
-     * transponder entry, e.g. "Linear Transponder", "Linear Transp.", "SSB Transponder".
+     * can also have low/high frequencies. The calculator is meant for named linear
+     * transponders, e.g. "Linear Transponder", "Linear Transp.", "SSB Transponder".
     */
    fun isNamedLinearTransponder(transponder: SatRadio): Boolean {
        if (!isLinearTransponder(transponder)) return false
@@ -41,6 +41,21 @@ fun Double.round(decimals: Int): Double {
    return kotlin.math.round(this * multiplier) / multiplier
 }

+fun String.aprsPasscode(): Int {
+    val callsign = this.trim().uppercase().substringBefore('-') // commonly strip SSID
+    var hash = 0x73E2
+    var i = 0
+    while (i < callsign.length) {
+        hash = hash xor (callsign[i].code shl 8)
+        i++
+        if (i < callsign.length) {
+            hash = hash xor callsign[i].code
+            i++
+        }
+    }
+    return hash and 0x7FFF
+}
+
 //fun String.getHash(type: String = "SHA-256"): String {
 //    val hexChars = "0123456789ABCDEF"
 //    val bytes = MessageDigest.getInstance(type).digest(this.toByteArray())
@@ -18,10 +18,12 @@
 package com.rtbishop.look4sat.core.domain

 import com.rtbishop.look4sat.core.domain.utility.DataParser
+import com.rtbishop.look4sat.core.domain.utility.aprsPasscode
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
+import kotlin.math.abs

@ExperimentalCoroutinesApi
 class DataParserTest {
@@ -60,8 +62,49 @@ class DataParserTest {
    fun `Given valid CSV stream returns valid data`() = runTest(testDispatcher) {
        val parsedList = dataParser.parseCSVStream(validCSVStream)
        assert(parsedList.size == 2)
-        assert(parsedList[0].epoch == 21320.51955234)
-        assert(parsedList[1].epoch == 24069.23963816)
+        assert(abs(parsedList[0].epoch - 21320.51955234) < 1e-8)
+        assert(abs(parsedList[1].epoch - 24069.23963816) < 1e-8)
+    }
+
+    @Test
+    fun `Given CSV stream with reordered columns returns valid data`() = runTest(testDispatcher) {
+        val csvStream = """
+            NORAD_CAT_ID,EPOCH,OBJECT_NAME,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY
+            25544,2021-11-16T12:28:09.322176,ISS (ZARYA),.31985E-4,.1288E-4,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseCSVStream(csvStream)[0]
+        assert(sat.name == "ISS (ZARYA)")
+        assert(sat.catnum == 25544)
+        assert(sat.meanmo == 15.48582035)
+        assert(sat.bstar == 0.31985E-4)
+        assert(abs(sat.epoch - 21320.51955234) < 1e-8)
+    }
+
+    @Test
+    fun `Given CSV epoch without fractional seconds returns valid data`() = runTest(testDispatcher) {
+        val csvStream = """
+            OBJECT_NAME,OBJECT_ID,EPOCH,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY,EPHEMERIS_TYPE,CLASSIFICATION_TYPE,NORAD_CAT_ID,ELEMENT_SET_NO,REV_AT_EPOCH,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION_DDOT
+            ISS (ZARYA),1998-067A,2021-11-16T12:28:09Z,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
+            ISS (ZARYA),1998-067A,2021-11-16T00:00:30,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
+        """.trimIndent().byteInputStream()
+        val parsedList = dataParser.parseCSVStream(csvStream)
+        assert(parsedList.size == 2)
+        // the dropped microseconds are worth a few microdays, the rest of the epoch is intact
+        assert(abs(parsedList[0].epoch - 21320.51955234) < 1e-5)
+        // just past midnight: the old formatter produced a broken 21320.0E-4 style epoch here
+        assert(abs(parsedList[1].epoch - 21320.00034722) < 1e-8)
+    }
+
+    @Test
+    fun `Given TLE stream with alpha-5 catalog number returns valid data`() = runTest(testDispatcher) {
+        val tleStream = """
+            NAVSTAR 43
+            1 T0111U 98067A   21320.51955234  .00001288  00000+0  31985-4 0  9990
+            2 T0111  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
+        """.trimIndent().byteInputStream()
+        val sat = dataParser.parseTLEStream(tleStream)[0]
+        // A stands for 10 and I and O are skipped, so T is 27 and T0111 stands for 270111
+        assert(sat.catnum == 270111)
    }

    @Test
@@ -239,4 +282,10 @@ class DataParserTest {
        // Matches the CSV test data epoch: 2021-11-16 → day 320
        assert(dataParser.getDayOfYear(2021, 11, 16) == 320)
    }
+
+    @Test
+    fun `check APRS passcode calculation`() {
+        assert("M7LNB".aprsPasscode() == 12443)
+        assert("N0CALL".aprsPasscode() == 13023)
+    }
 }
@@ -3,7 +3,11 @@ 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.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
 import org.junit.Test

 class DopplerFrequencyCalculatorTest {
@@ -162,8 +166,6 @@ class DopplerFrequencyCalculatorTest {
        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)
    }

@@ -178,24 +180,23 @@ class DopplerFrequencyCalculatorTest {

    @Test
    fun computeUplinkFromDownlink_withDoppler_positiveRangeRate() {
-        // Satellite receding (positive range rate) → ground must transmit higher freq to compensate
+        // 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 orbitalPos = pos(7.0)
        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() {
+    fun computeUplinkFromDownlink_fmTransponder_returnsNull() {
        val orbitalPos = pos()
        val result = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_600_000L, fmTransponder(), orbitalPos)
        assertNull(result)
    }

    @Test
-    fun computeDownlinkFromUplink_fm_transponder_returnsNull() {
+    fun computeDownlinkFromUplink_fmTransponder_returnsNull() {
        val orbitalPos = pos()
        val result = DopplerFrequencyCalculator.computeDownlinkFromUplink(145_900_000L, fmTransponder(), orbitalPos)
        assertNull(result)
@@ -254,13 +255,11 @@ class DopplerFrequencyCalculatorTest {
        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
@@ -268,7 +267,6 @@ class DopplerFrequencyCalculatorTest {
        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)
    }
@@ -1,301 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.core.domain.cw
-
-import org.junit.Assert.*
-import org.junit.Test
-import kotlin.math.PI
-import kotlin.math.sin
-
-class CwDecoderTest {
-
-    // --- Morse table ---
-
-    @Test
-    fun morseToChar_basicLetters() {
-        assertEquals('A', CwBayesianDecoder.morseToChar("01"))
-        assertEquals('S', CwBayesianDecoder.morseToChar("000"))
-        assertEquals('O', CwBayesianDecoder.morseToChar("111"))
-    }
-
-    @Test
-    fun morseToChar_numbers() {
-        assertEquals('1', CwBayesianDecoder.morseToChar("01111"))
-        assertEquals('0', CwBayesianDecoder.morseToChar("11111"))
-    }
-
-    @Test
-    fun morseToChar_unknown_returnsNull() {
-        assertNull(CwBayesianDecoder.morseToChar("......."))
-        assertNull(CwBayesianDecoder.morseToChar(""))
-    }
-
-    // --- FFT ---
-
-    @Test
-    fun fft_magnitudeSpectrum_detectsTone() {
-        val fft = CwFFT(256)
-        val sampleRate = 8000f
-        val freq = 700f
-        val buffer = FloatArray(256) { (sin(2.0 * PI * freq * it / sampleRate)).toFloat() }
-        val mag = fft.magnitudeSpectrum(buffer)
-        // Peak should be at bin around 700 * 256 / 8000 ≈ 22.4
-        var maxBin = 0
-        var maxVal = 0f
-        for (i in mag.indices) {
-            if (mag[i] > maxVal) { maxVal = mag[i]; maxBin = i }
-        }
-        assertTrue("Peak bin $maxBin should be near 22", maxBin in 18..26)
-        assertTrue("Peak value $maxVal should be positive", maxVal > 0.01f)
-    }
-
-    @Test
-    fun fft_magnitudeSpectrum_silence_isFlat() {
-        val fft = CwFFT(256)
-        val buffer = FloatArray(256) { 0f }
-        val mag = fft.magnitudeSpectrum(buffer)
-        for (v in mag) assertEquals("Silence spectrum should be 0, got $v", 0f, v, 1e-6f)
-    }
-
-    @Test
-    fun fft_rejectsWrongSize() {
-        assertThrows(IllegalArgumentException::class.java) { CwFFT(100) }
-    }
-
-    // --- Spectrogram ---
-
-    @Test
-    fun spectrogram_addSamples_updatesEnergy() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val freq = 700f
-        // Feed multiple frames to stabilize energy normalization
-        for (i in 0..5) {
-            val buffer = FloatArray(256) { (sin(2.0 * PI * freq * it / 8000.0)).toFloat() }
-            spec.addSamples(buffer)
-        }
-        val col = spec.getCurrentColumn()
-        val peakBin = spec.findPeakBin()
-        assertTrue("Peak bin $peakBin should be >= 0", peakBin >= 0)
-    }
-
-    @Test
-    fun spectrogram_findPeakBin_returnsValidBin() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        // Add multiple frames of 700 Hz tone
-        for (i in 0..5) {
-            val buffer = FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() }
-            spec.addSamples(buffer)
-        }
-        val peakBin = spec.findPeakBin()
-        assertTrue("Peak bin should be >= 0, got $peakBin", peakBin >= 0)
-    }
-
-    @Test
-    fun spectrogram_freqToBin_roundtrip() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val freq = 700f
-        val bin = spec.freqToBin(freq)
-        val backFreq = spec.binToFreq(bin)
-        assertTrue("Freq $freq → bin $bin → freq $backFreq", backFreq > 600f && backFreq < 800f)
-    }
-
-    @Test
-    fun spectrogram_getBinEnergy_returnsCorrectLength() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val energy = spec.getBinEnergy(0, 10)
-        assertEquals(10, energy.size)
-    }
-
-    @Test
-    fun spectrogram_reset() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        spec.addSamples(FloatArray(256) { 1f })
-        spec.reset()
-        assertEquals(-1, spec.findPeakBin())
-    }
-
-    // --- Bayesian decoder ---
-
-    @Test
-    fun bayesian_processTone_dit() {
-        val decoder = CwBayesianDecoder()
-        // At 20 WPM, dot = 60 ms
-        val result = decoder.processTone(60f)
-        assertEquals('0', result.symbol)
-        assertTrue("Dit probability should be positive", result.probability > 0.1f)
-    }
-
-    @Test
-    fun bayesian_processTone_dash() {
-        val decoder = CwBayesianDecoder()
-        // Dash = 3 * dot = 180 ms
-        val result = decoder.processTone(180f)
-        assertEquals('1', result.symbol)
-        assertTrue("Dash probability should be positive", result.probability > 0.1f)
-    }
-
-    @Test
-    fun bayesian_processTone_unknown_returnsNull() {
-        val decoder = CwBayesianDecoder()
-        // Very long tone — low probability for both dit and dash
-        val result = decoder.processTone(5000f)
-        assertNull(result.symbol)
-    }
-
-    @Test
-    fun bayesian_processGap_interChar_returnsChar() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f) // dit
-        decoder.processTone(60f) // dit
-        decoder.processTone(60f) // dit
-        // 3 dots = "000" = 'S'
-        val char = decoder.processGap(180f) // 3 * dot = inter-char gap
-        assertEquals('S', char)
-    }
-
-    @Test
-    fun bayesian_processGap_wordGap_addsSpace() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f) // dit = 'E'
-        decoder.processGap(180f) // inter-char gap
-        // Now word gap
-        val space = decoder.processGap(420f) // 7 * dot
-        assertEquals(' ', space)
-    }
-
-    @Test
-    fun bayesian_decodedText_accumulates() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f) // dit = 'E'
-        decoder.processGap(180f) // inter-char
-        assertTrue(decoder.decodedText.isNotEmpty())
-    }
-
-    @Test
-    fun bayesian_reset() {
-        val decoder = CwBayesianDecoder()
-        decoder.processTone(60f)
-        decoder.reset()
-        assertEquals("", decoder.decodedText)
-    }
-
-    @Test
-    fun bayesian_getSpeed() {
-        val decoder = CwBayesianDecoder()
-        // Send 3 dits at 20 WPM (60 ms each)
-        decoder.processTone(60f)
-        decoder.processTone(60f)
-        decoder.processTone(60f)
-        val speed = decoder.getSpeed()
-        assertTrue("Speed should be ~20 WPM, got $speed", speed > 15f && speed < 30f)
-    }
-
-    // --- Channel tracker ---
-
-    @Test
-    fun channelTracker_initialState() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        val tracker = CwChannelTracker(spec)
-        val channels = tracker.update()
-        assertTrue("No channels should be active initially", channels.isEmpty())
-    }
-
-    @Test
-    fun channelTracker_detectsTone() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        // Feed a tone
-        for (i in 0..5) {
-            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        val tracker = CwChannelTracker(spec)
-        val channels = tracker.update()
-        assertTrue("Should detect at least 1 channel", channels.isNotEmpty())
-    }
-
-    @Test
-    fun channelTracker_bestChannel() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        for (i in 0..5) {
-            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        val tracker = CwChannelTracker(spec)
-        tracker.update()
-        val best = tracker.getBestChannel()
-        assertNotNull("Best channel should exist", best)
-        if (best != null) assertTrue(best.frequency in 600f..800f)
-    }
-
-    @Test
-    fun channelTracker_reset() {
-        val spec = CwSpectrogram(sampleRate = 8000)
-        for (i in 0..5) {
-            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        val tracker = CwChannelTracker(spec)
-        tracker.update()
-        tracker.reset()
-        assertNull(tracker.getBestChannel())
-    }
-
-    // --- Full decoder ---
-
-    @Test
-    fun decoder_initialState() {
-        val decoder = CwDecoder()
-        assertEquals("", decoder.decodedTextFlow.value)
-        assertEquals(0f, decoder.signalStrength.value, 0.001f)
-    }
-
-    @Test
-    fun decoder_processSilence_doesNotCrash() {
-        val decoder = CwDecoder()
-        decoder.processBuffer(FloatArray(256) { 0f })
-        assertEquals("", decoder.decodedTextFlow.value)
-    }
-
-    @Test
-    fun decoder_processNoise_doesNotCrash() {
-        val decoder = CwDecoder()
-        decoder.processBuffer(FloatArray(256) { (Math.random() * 2 - 1).toFloat() * 0.1f })
-        assertNotNull(decoder.decodedTextFlow.value)
-    }
-
-    @Test
-    fun decoder_processTone_doesNotCrash() {
-        val decoder = CwDecoder()
-        for (i in 0..20) {
-            decoder.processBuffer(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
-        }
-        assertNotNull(decoder.decodedTextFlow.value)
-    }
-
-    @Test
-    fun decoder_reset() {
-        val decoder = CwDecoder()
-        decoder.processBuffer(FloatArray(256) { 1f })
-        decoder.resetDecoder()
-        assertEquals("", decoder.decodedTextFlow.value)
-        assertEquals(0f, decoder.signalStrength.value, 0.001f)
-    }
-
-    @Test
-    fun decoder_withFixedPitch() {
-        val decoder = CwDecoder(sampleRate = 8000, cwToneFreq = 700f)
-        assertEquals(700f, decoder.estimatedPitch.value)
-    }
-}
@@ -0,0 +1,79 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.predict
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.time.Instant
+import kotlin.math.abs
+
+class CelestialComputerTest {
+
+    private data class RiseSetCase(
+        val name: String,
+        val observer: GeoPos,
+        val startIso: String
+    )
+
+    @Test
+    fun `findSunRiseSet returns distinct sunrise and sunset for representative locations`() {
+        val cases = listOf(
+            RiseSetCase("Equator at March equinox", GeoPos(0.0, 0.0), "2026-03-20T00:00:00Z"),
+            RiseSetCase("Equator at September equinox", GeoPos(0.0, 0.0), "2026-09-23T00:00:00Z"),
+            RiseSetCase("Sydney winter", GeoPos(-33.8688, 151.2093), "2026-06-21T00:00:00Z"),
+            RiseSetCase("Buenos Aires winter", GeoPos(-34.6037, -58.3816), "2026-06-21T00:00:00Z"),
+            RiseSetCase("Cape Town winter", GeoPos(-33.9249, 18.4241), "2026-06-21T00:00:00Z"),
+            RiseSetCase("London summer", GeoPos(51.5074, -0.1278), "2026-06-21T00:00:00Z")
+        )
+
+        cases.forEach { testCase ->
+            val result = CelestialComputer.findSunRiseSet(testCase.observer, testCase.startIso.toMillis())
+            val daylightDuration = result.setTimeMillis - result.riseTimeMillis
+
+            assertTrue("${testCase.name}: sunrise should be non-zero", result.riseTimeMillis > 0L)
+            assertTrue("${testCase.name}: sunset should be non-zero", result.setTimeMillis > 0L)
+            assertTrue("${testCase.name}: sunset should be after sunrise", result.setTimeMillis > result.riseTimeMillis)
+            assertTrue("${testCase.name}: daylight duration should be longer than 1 hour", daylightDuration > HOUR_MILLIS)
+            assertTrue("${testCase.name}: daylight duration should be shorter than 24 hours", daylightDuration < DAY_MILLIS)
+
+            val riseElevation = CelestialComputer.getSunPosition(testCase.observer, result.riseTimeMillis).elevation
+            val setElevation = CelestialComputer.getSunPosition(testCase.observer, result.setTimeMillis).elevation
+            assertEquals("${testCase.name}: sunrise should converge near the standard threshold", SUNRISE_SET_THRESHOLD, riseElevation, 0.02)
+            assertEquals("${testCase.name}: sunset should converge near the standard threshold", SUNRISE_SET_THRESHOLD, setElevation, 0.02)
+        }
+    }
+
+    @Test
+    fun `findSunRiseSet does not return the same instant for equinox regression cases`() {
+        listOf("2026-03-20T00:00:00Z", "2026-09-23T00:00:00Z").forEach { startIso ->
+            val result = CelestialComputer.findSunRiseSet(GeoPos(0.0, 0.0), startIso.toMillis())
+            val separationMillis = abs(result.setTimeMillis - result.riseTimeMillis)
+
+            assertTrue("$startIso: sunrise and sunset should be separated", separationMillis > HOUR_MILLIS)
+        }
+    }
+
+    private fun String.toMillis(): Long = Instant.parse(this).toEpochMilli()
+
+    private companion object {
+        private const val SUNRISE_SET_THRESHOLD = -0.8333
+        private const val HOUR_MILLIS = 60L * 60L * 1000L
+        private const val DAY_MILLIS = 24L * HOUR_MILLIS
+    }
+}
@@ -27,13 +27,18 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.RowScope
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBars
 import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.CircularProgressIndicator
@@ -47,7 +52,7 @@ import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.rememberModalBottomSheetState
-import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
+import androidx.compose.material3.adaptive.currentWindowAdaptiveInfoV2
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.runtime.remember
@@ -71,6 +76,8 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalWindowInfo
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.TextUnit
@@ -143,7 +150,7 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
        if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
    }
    val sdfTime = remember(isUtc) {
-        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", displayLocale()).also { it.timeZone = timeZone }
    }
    ElevatedCard(
        modifier = modifier
@@ -157,13 +164,16 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
                .padding(start = 6.dp, top = 1.dp, end = 6.dp, bottom = 0.dp)
        ) {
            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    text = "${stringResource(R.string.pass_satId, pass.catNum)} - ",
+                    color = MaterialTheme.colorScheme.primary
+                )
                Text(
                    text = pass.name,
                    modifier = Modifier
                        .weight(1f)
                        .padding(end = 6.dp)
                        .infiniteMarquee(),
-                    color = MaterialTheme.colorScheme.primary,
                    fontWeight = FontWeight.Medium,
                    maxLines = 1,
                    overflow = TextOverflow.Ellipsis
@@ -209,6 +219,11 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
    }
 }

+private fun displayLocale(): Locale {
+    val locale = Locale.getDefault()
+    return if (locale.language == Locale.CHINESE.language) locale else Locale.ENGLISH
+}
+
@Composable
 fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier) {
    ElevatedButton(
@@ -224,8 +239,13 @@ fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier)
 }

@Composable
-fun IconCard(action: () -> Unit, resId: Int, modifier: Modifier = Modifier, enabled: Boolean = true) {
-    ElevatedCard(modifier = Modifier.size(48.dp), enabled = enabled, onClick = action) {
+fun IconCard(
+    action: () -> Unit, resId: Int, modifier: Modifier = Modifier,
+    enabled: Boolean = true, containerColor: Color = Color.Unspecified
+) {
+    val colors = if (containerColor == Color.Unspecified) CardDefaults.elevatedCardColors()
+    else CardDefaults.elevatedCardColors(containerColor = containerColor)
+    ElevatedCard(modifier = Modifier.size(48.dp), enabled = enabled, onClick = action, colors = colors) {
        Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
            Icon(painter = painterResource(resId), contentDescription = null, modifier = modifier)
        }
@@ -281,51 +301,86 @@ fun getDefaultPass(): OrbitalPass = OrbitalPass(
 )

@Composable
-fun SharedDialog(
-    title: String, onCancel: () -> Unit, onAccept: () -> Unit, content: @Composable () -> Unit
-) {
-    SharedDialog(title = title, onDismissRequest = onCancel, onCancel = onCancel, onAccept = onAccept) { _ ->
-        content()
-    }
-}
-
-@Composable
-fun SharedDialog(
+fun InfoDialog(
    title: String,
-    onDismissRequest: () -> Unit,
-    onCancel: (() -> Unit)? = null,
-    onAccept: (() -> Unit)? = null,
-    titleFontSize: Int = 16,
-    titleTextAlign: TextAlign = if (onCancel != null && onAccept != null) TextAlign.Center else TextAlign.Start,
-    content: @Composable (padding: Dp) -> Unit
+    onDismiss: () -> Unit,
+    onAccept: () -> Unit,
+    extraAction: (@Composable () -> Unit)? = null,
+    content: @Composable () -> Unit
 ) {
-    DialogShell(onDismissRequest = onDismissRequest) { padding ->
+    DialogShell(onDismissRequest = onDismiss) { padding ->
        Row(
            verticalAlignment = Alignment.CenterVertically,
            modifier = Modifier
                .fillMaxWidth()
                .padding(start = padding, top = padding, end = padding)
        ) {
-            if (onCancel != null) {
-                CardButton(onClick = onCancel, text = stringResource(R.string.btn_cancel))
-            }
            Text(
                text = title,
-                fontSize = titleFontSize.sp,
+                fontSize = 16.sp,
                fontWeight = FontWeight.Medium,
                color = MaterialTheme.colorScheme.primary,
-                textAlign = titleTextAlign,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                modifier = Modifier.weight(1f)
+            )
+            extraAction?.let {
+                it()
+                Spacer(modifier = Modifier.width(8.dp))
+            }
+            CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
+        }
+        content()
+    }
+}
+
+@Composable
+fun ConfirmDialog(
+    title: String,
+    onCancel: () -> Unit,
+    onAccept: () -> Unit,
+    content: @Composable () -> Unit
+) {
+    DialogShell(onDismissRequest = onCancel) { padding ->
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(start = padding, top = padding, end = padding)
+        ) {
+            CardButton(onClick = onCancel, text = stringResource(R.string.btn_cancel))
+            Text(
+                text = title,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary,
+                textAlign = TextAlign.Center,
                maxLines = 1,
                overflow = TextOverflow.Ellipsis,
                modifier = Modifier
                    .weight(1f)
-                    .padding(horizontal = if (onCancel != null && onAccept != null) padding else 0.dp)
+                    .padding(horizontal = padding)
            )
-            if (onAccept != null) {
-                CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
-            }
+            CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
        }
-        content(padding)
+        content()
+    }
+}
+
+@Composable
+fun WhatsNewDialog(onDismiss: () -> Unit) {
+    InfoDialog(
+        title = stringResource(R.string.pass_whatsnew_title),
+        onDismiss = onDismiss,
+        onAccept = onDismiss
+    ) {
+        Text(
+            text = stringResource(R.string.pass_whatsnew_message),
+            fontSize = 16.sp,
+            color = MaterialTheme.colorScheme.onSurface,
+            modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+        )
+        Spacer(modifier = Modifier.height(0.dp))
    }
 }

@@ -337,6 +392,9 @@ private fun DialogShell(
 ) {
    val padding = LocalSpacing.current.large
    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
+    val statusBarHeight = WindowInsets.statusBars.asPaddingValues().calculateTopPadding()
+    val containerHeight = with(LocalDensity.current) { LocalWindowInfo.current.containerSize.height.toDp() }
+    val maxSheetHeight = containerHeight - statusBarHeight
    val stopSheetFling = remember {
        object : NestedScrollConnection {
            override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
@@ -354,7 +412,7 @@ private fun DialogShell(
        onDismissRequest = onDismissRequest,
        sheetState = sheetState,
        dragHandle = null,
-        shape = MaterialTheme.shapes.medium,
+        shape = RoundedCornerShape(topStart = 12.dp, topEnd = 12.dp),
        scrimColor = Color.Black.copy(alpha = 0.64f)
    ) {
        Column(
@@ -362,6 +420,7 @@ private fun DialogShell(
            verticalArrangement = Arrangement.spacedBy(padding),
            modifier = Modifier
                .fillMaxWidth()
+                .heightIn(max = maxSheetHeight)
                .nestedScroll(stopSheetFling)
        ) {
            content(padding)
@@ -371,11 +430,11 @@ private fun DialogShell(

@Composable
 fun hasEnoughHeight(): Boolean =
-    currentWindowAdaptiveInfo().windowSizeClass.isHeightAtLeastBreakpoint(480)
+    currentWindowAdaptiveInfoV2().windowSizeClass.isHeightAtLeastBreakpoint(480)

@Composable
 fun hasEnoughWidth(): Boolean =
-    currentWindowAdaptiveInfo().windowSizeClass.isWidthAtLeastBreakpoint(600)
+    currentWindowAdaptiveInfoV2().windowSizeClass.isWidthAtLeastBreakpoint(600)

@Composable
 fun isVerticalLayout(): Boolean = !hasEnoughWidth()
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.rtbishop.look4sat.core.presentation
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.border
+import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
+import androidx.compose.foundation.gestures.scrollBy
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.foundation.lazy.LazyListItemInfo
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SwipeToDismissBox
+import androidx.compose.material3.SwipeToDismissBoxValue
+import androidx.compose.material3.rememberSwipeToDismissBoxState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.dropShadow
+import androidx.compose.ui.draw.innerShadow
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.zIndex
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
+
+//region DragDrop Region
+@Composable
+fun rememberDragDropState(lazyListState: LazyListState, onMove: (Int, Int) -> Unit): DragDropState {
+    val scope = rememberCoroutineScope()
+    val state = remember(lazyListState) {
+        DragDropState(state = lazyListState, onMove = onMove, scope = scope)
+    }
+    LaunchedEffect(state) {
+        while (true) {
+            val diff = state.scrollChannel.receive()
+            lazyListState.scrollBy(diff)
+        }
+    }
+    return state
+}
+
+class DragDropState internal constructor(
+    private val state: LazyListState,
+    private val scope: CoroutineScope,
+    private val onMove: (Int, Int) -> Unit
+) {
+    var draggingItemIndex by mutableStateOf<Int?>(null)
+        private set
+
+    internal val scrollChannel = Channel<Float>()
+
+    private var draggingItemDraggedDelta by mutableFloatStateOf(0f)
+    private var draggingItemInitialOffset by mutableIntStateOf(0)
+    internal val draggingItemOffset: Float
+        get() = draggingItemLayoutInfo?.let { item ->
+            draggingItemInitialOffset + draggingItemDraggedDelta - item.offset
+        } ?: 0f
+
+    private val draggingItemLayoutInfo: LazyListItemInfo?
+        get() = state.layoutInfo.visibleItemsInfo.firstOrNull { it.index == draggingItemIndex }
+
+    internal var previousIndexOfDraggedItem by mutableStateOf<Int?>(null)
+        private set
+    internal var previousItemOffset = Animatable(0f)
+        private set
+
+    internal fun onDragStart(offset: Offset) {
+        state.layoutInfo.visibleItemsInfo.firstOrNull { item ->
+            offset.y.toInt() in item.offset..(item.offset + item.size)
+        }?.also {
+            draggingItemIndex = it.index
+            draggingItemInitialOffset = it.offset
+        }
+    }
+
+    internal fun onDragInterrupted() {
+        if (draggingItemIndex != null) {
+            previousIndexOfDraggedItem = draggingItemIndex
+            val startOffset = draggingItemOffset
+            scope.launch {
+                previousItemOffset.snapTo(startOffset)
+                previousItemOffset.animateTo(
+                    0f, spring(stiffness = Spring.StiffnessMediumLow, visibilityThreshold = 1f)
+                )
+                previousIndexOfDraggedItem = null
+            }
+        }
+        draggingItemDraggedDelta = 0f
+        draggingItemIndex = null
+        draggingItemInitialOffset = 0
+    }
+
+    internal fun onDrag(offset: Offset) {
+        draggingItemDraggedDelta += offset.y
+
+        val draggingItem = draggingItemLayoutInfo ?: return
+        val startOffset = draggingItem.offset + draggingItemOffset
+        val endOffset = startOffset + draggingItem.size
+        val middleOffset = startOffset + (endOffset - startOffset) / 2f
+
+        val targetItem = state.layoutInfo.visibleItemsInfo.find { item ->
+            middleOffset.toInt() in item.offset..item.offsetEnd && draggingItem.index != item.index
+        }
+        if (targetItem != null) {
+            if (draggingItem.index == state.firstVisibleItemIndex || targetItem.index == state.firstVisibleItemIndex) {
+                state.requestScrollToItem(state.firstVisibleItemIndex, state.firstVisibleItemScrollOffset)
+            }
+            onMove.invoke(draggingItem.index, targetItem.index)
+            draggingItemIndex = targetItem.index
+        } else {
+            val overscroll = when {
+                draggingItemDraggedDelta > 0 -> (endOffset - state.layoutInfo.viewportEndOffset).coerceAtLeast(0f)
+                draggingItemDraggedDelta < 0 -> (startOffset - state.layoutInfo.viewportStartOffset).coerceAtMost(0f)
+                else -> 0f
+            }
+            if (overscroll != 0f) {
+                scrollChannel.trySend(overscroll)
+            }
+        }
+    }
+
+    private val LazyListItemInfo.offsetEnd: Int
+        get() = this.offset + this.size
+}
+
+fun Modifier.dragContainer(dragDropState: DragDropState): Modifier {
+    return pointerInput(dragDropState) {
+        detectDragGesturesAfterLongPress(
+            onDrag = { change, offset ->
+                change.consume()
+                dragDropState.onDrag(offset = offset)
+            },
+            onDragStart = { offset -> dragDropState.onDragStart(offset) },
+            onDragEnd = { dragDropState.onDragInterrupted() },
+            onDragCancel = { dragDropState.onDragInterrupted() }
+        )
+    }
+}
+
+@Composable
+fun LazyItemScope.DraggableItem(
+    dragDropState: DragDropState,
+    index: Int,
+    modifier: Modifier = Modifier,
+    content: @Composable ColumnScope.(isDragging: Boolean) -> Unit
+) {
+    val zIndexMod = Modifier.zIndex(1f)
+    val dragging = index == dragDropState.draggingItemIndex
+    val draggingModifier = when {
+        dragging -> zIndexMod.graphicsLayer { translationY = dragDropState.draggingItemOffset }
+        index == dragDropState.previousIndexOfDraggedItem -> {
+            zIndexMod.graphicsLayer { translationY = dragDropState.previousItemOffset.value }
+        }
+        else -> Modifier.animateItem(fadeInSpec = null, fadeOutSpec = null)
+    }
+    Column(modifier = modifier.then(draggingModifier)) { content(dragging) }
+}
+//endregion
+
+//region Swipe Region
+@Composable
+fun SwipeableItem(onRemove: () -> Unit, content: @Composable () -> Unit) {
+    val coroutineScope = rememberCoroutineScope()
+    val dismissThresholdPx = with(LocalDensity.current) { 120.dp.toPx() }
+    val dismissState = rememberSwipeToDismissBoxState { dismissThresholdPx }
+    val isVisible = remember { mutableStateOf(true) }
+    val willTrigger by remember { derivedStateOf { dismissState.targetValue != SwipeToDismissBoxValue.Settled } }
+    val hapticFeedback = LocalHapticFeedback.current
+    LaunchedEffect(willTrigger) {
+        val feedbackType = if (willTrigger) HapticFeedbackType.LongPress else HapticFeedbackType.SegmentTick
+        hapticFeedback.performHapticFeedback(feedbackType)
+    }
+    AnimatedVisibility(visible = isVisible.value, exit = fadeOut(spring())) {
+        SwipeToDismissBox(
+            state = dismissState,
+            enableDismissFromStartToEnd = true,
+            enableDismissFromEndToStart = false,
+            backgroundContent = { DismissBackground(willTrigger) },
+            content = { content() },
+            onDismiss = {
+                isVisible.value = false
+                coroutineScope.launch { dismissState.reset() }
+            }
+        )
+    }
+    LaunchedEffect(isVisible.value) {
+        if (!isVisible.value) { delay(250.milliseconds).also { onRemove() } }
+    }
+}
+
+@Composable
+fun DismissBackground(willTrigger: Boolean, bgColor: Color = Color(0xFFFF3C3A)) {
+    val iconScale by animateFloatAsState(targetValue = if (willTrigger) 1f else .8f)
+    val slide by animateDpAsState(targetValue = if (willTrigger) 32.dp else (12).dp)
+    Box(
+        contentAlignment = Alignment.CenterStart,
+        modifier = Modifier
+            .fillMaxSize()
+            .border(width = 2.dp, shape = MaterialTheme.shapes.extraLarge, color = bgColor)
+            .dropShadow(shape = MaterialTheme.shapes.extraLarge) {
+                color = bgColor
+                radius = 40f
+                alpha = if (willTrigger) .2f else 0f
+            }
+            .innerShadow(shape = MaterialTheme.shapes.extraLarge) {
+                color = bgColor
+                radius = 40f
+                alpha = if (willTrigger) 1f else .2f
+            }
+    ) {
+        Icon(
+            painter = painterResource(R.drawable.ic_delete),
+            contentDescription = null,
+            modifier = Modifier
+                .size(32.dp)
+                .fillMaxHeight()
+                .graphicsLayer {
+                    scaleX = iconScale
+                    scaleY = iconScale
+                    translationX = slide.toPx()
+                }
+        )
+    }
+}
+//endregion
@@ -0,0 +1,311 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.presentation
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
+import androidx.compose.foundation.gestures.scrollBy
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableFloatState
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.zIndex
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * Long-press drag-to-reorder for rows inside a `LazyColumn`, with built-in edge auto-scroll and
+ * a settle-back animation when the finger is released.
+ *
+ * Reordering only ever swaps an item with its neighbor *inside the `items` list* passed to
+ * [rememberDragRowState] — so multiple independent groups of rows (e.g. two sections separated
+ * by header items) can share one [DragReorderState]/`LazyColumn` simply by giving each section
+ * its own backing list and calling [rememberDragRowState] with that section's list. Keys must be
+ * globally unique across the whole `LazyColumn` and match exactly what is passed as the
+ * `key = { ... }` lambda of `items`/`itemsIndexed`.
+ *
+ * Usage:
+ * ```
+ * val dragState = rememberDragReorderState(listState)
+ * itemsIndexed(entries, key = { _, e -> e.id }) { index, entry ->
+ *     val row = rememberDragRowState(dragState, entries, entry, key = { it.id }) { from, to ->
+ *         entries.add(to, entries.removeAt(from))
+ *     }
+ *     Row(
+ *         modifier = Modifier
+ *             .dragLift(row.isLifted, row.translationY)
+ *             .animateItem(placementSpec = if (row.isDragging) tween(0) else spring())
+ *     ) {
+ *         Icon(modifier = Modifier.dragHandle(row), painter = ..., contentDescription = null)
+ *         Text(entry.label)
+ *     }
+ * }
+ * ```
+ */
+@Stable
+class DragReorderState internal constructor(internal val listState: LazyListState) {
+    internal var draggedKey by mutableStateOf<Any?>(null)
+}
+
+@Composable
+fun rememberDragReorderState(listState: LazyListState): DragReorderState =
+    remember(listState) { DragReorderState(listState) }
+
+/** Used for the settle-back animation once the finger is released: quick and snappy. */
+private val reorderSettleSpec = tween<Float>(durationMillis = 150, easing = FastOutSlowInEasing)
+
+/**
+ * Per-row drag bookkeeping, obtained via [rememberDragRowState].
+ *
+ * [dragStartOffset] is this row's viewport offset captured once at drag start, [fingerOffset] is
+ * the raw accumulated finger travel (used for edge auto-scroll and swap detection). [translationY]
+ * is derived every frame from those two plus the row's *current* live layout offset, so it
+ * automatically stays correct across neighbor swaps and list auto-scroll without any manual
+ * offset-compensation math.
+ */
+@Stable
+class DragRowState<T> internal constructor(
+    private val dragState: DragReorderState,
+    private val itemsState: State<List<T>>,
+    private val itemKey: Any,
+    private val key: (T) -> Any,
+    private val onMoveState: State<(Int, Int) -> Unit>,
+    private val scope: CoroutineScope
+) {
+    internal val fingerOffset: MutableFloatState = mutableFloatStateOf(0f)
+    internal val dragStartOffset: MutableFloatState = mutableFloatStateOf(0f)
+    internal val startCenterY: MutableFloatState = mutableFloatStateOf(0f)
+    internal val settleAnim = Animatable(0f)
+
+    var isSettling: Boolean by mutableStateOf(false)
+        private set
+
+    val isDragging: Boolean get() = dragState.draggedKey == itemKey
+    val isLifted: Boolean get() = isDragging || isSettling
+
+    val translationY: Float
+        get() = when {
+            isSettling -> settleAnim.value
+            isDragging -> currentTranslation()
+            else -> 0f
+        }
+
+    /**
+     * How far this row must be pushed away from its *current* layout slot so it stays glued to
+     * the finger. Because [dragStartOffset] is fixed at drag start while the row's live layout
+     * offset moves as neighbors swap places or the list auto-scrolls, this difference naturally
+     * absorbs both effects with no extra bookkeeping.
+     */
+    private fun currentTranslation(): Float {
+        val liveOffset = dragState.listState.layoutInfo.visibleItemsInfo
+            .firstOrNull { it.key == itemKey }?.offset?.toFloat()
+            ?: dragStartOffset.floatValue
+        return dragStartOffset.floatValue + fingerOffset.floatValue - liveOffset
+    }
+
+    internal fun onDragStart() {
+        isSettling = false
+        val layout = dragState.listState.layoutInfo.visibleItemsInfo.firstOrNull { it.key == itemKey }
+        dragStartOffset.floatValue = (layout?.offset ?: 0).toFloat()
+        startCenterY.floatValue = (layout?.offset ?: 0) + (layout?.size ?: 0) / 2f
+        fingerOffset.floatValue = 0f
+        dragState.draggedKey = itemKey
+    }
+
+    internal fun onDrag(deltaY: Float) {
+        if (dragState.draggedKey != itemKey) return
+        fingerOffset.floatValue += deltaY
+        reorderLive()
+    }
+
+    private fun reorderLive() {
+        val items = itemsState.value
+        val myIndex = items.indexOfFirst { key(it) == itemKey }
+        if (myIndex !in items.indices) return
+        val myCenter = startCenterY.floatValue + fingerOffset.floatValue
+        val visible = dragState.listState.layoutInfo.visibleItemsInfo
+        val onMove = onMoveState.value
+        // Dragging down: swap when the dragged center passes the next row's midpoint.
+        if (myIndex < items.lastIndex) {
+            val nextKey = key(items[myIndex + 1])
+            val next = visible.firstOrNull { it.key == nextKey }
+            if (next != null && myCenter > next.offset + next.size / 2f) {
+                onMove(myIndex, myIndex + 1)
+                return
+            }
+        }
+        // Dragging up: swap when the dragged center passes the previous row's midpoint.
+        if (myIndex > 0) {
+            val prevKey = key(items[myIndex - 1])
+            val prev = visible.firstOrNull { it.key == prevKey }
+            if (prev != null && myCenter < prev.offset + prev.size / 2f) {
+                onMove(myIndex, myIndex - 1)
+            }
+        }
+    }
+
+    // Reset the drag bookkeeping and fly the lifted row back into its slot.
+    // All state resets happen inside the launched block so the settle animation takes over from
+    // the current visual position without a one-frame jump: isSettling is flipped to true
+    // (switching rendering to settleAnim, already snapped to the last offset) before the drag
+    // flags are cleared.
+    internal fun onDragEnd() {
+        val lastOffset = currentTranslation()
+        if (kotlin.math.abs(lastOffset) < 1f) {
+            fingerOffset.floatValue = 0f
+            dragState.draggedKey = null
+            return
+        }
+        scope.launch {
+            settleAnim.snapTo(lastOffset)
+            isSettling = true
+            fingerOffset.floatValue = 0f
+            dragState.draggedKey = null
+            settleAnim.animateTo(0f, reorderSettleSpec)
+            isSettling = false
+        }
+    }
+}
+
+/**
+ * Remembers a [DragRowState] for one row of a drag-reorderable list.
+ *
+ * [items] must be the exact (optionally section-scoped) list backing the enclosing
+ * `items`/`itemsIndexed` call, and [key] must return the same value used as that call's
+ * `key = { ... }` lambda. Reordering only ever swaps neighbors within [items], so passing a
+ * section-local list is what confines dragging to one section of a multi-section `LazyColumn`.
+ */
+@Composable
+fun <T> rememberDragRowState(
+    dragState: DragReorderState,
+    items: List<T>,
+    item: T,
+    key: (T) -> Any,
+    onMove: (from: Int, to: Int) -> Unit
+): DragRowState<T> {
+    val scope = rememberCoroutineScope()
+    val itemsState = rememberUpdatedState(items)
+    val onMoveState = rememberUpdatedState(onMove)
+    val itemKey = key(item)
+    val rowState = remember(dragState, itemKey) {
+        DragRowState(dragState, itemsState, itemKey, key, onMoveState, scope)
+    }
+    LaunchedEffect(rowState.isDragging) {
+        if (!rowState.isDragging) return@LaunchedEffect
+        autoScrollWhileDragging(dragState.listState, rowState.startCenterY, rowState.fingerOffset)
+    }
+    return rowState
+}
+
+/** Drag-handle gesture: attach to a small handle icon to start/drive/end reordering of [rowState]'s row. */
+fun Modifier.dragHandle(rowState: DragRowState<*>): Modifier = pointerInput(rowState) {
+    detectDragGesturesAfterLongPress(
+        onDragStart = { rowState.onDragStart() },
+        onDragEnd = { rowState.onDragEnd() },
+        onDragCancel = { rowState.onDragEnd() }
+    ) { change, dragAmount ->
+        change.consume()
+        rowState.onDrag(dragAmount.y)
+    }
+}
+
+/**
+ * Visual treatment for a draggable row: while [isLifted], translates the row by [translationY],
+ * scales it up slightly and raises it above its neighbors with a shadow and a solid background so
+ * it fully covers the row beneath instead of showing a translucent overlap of both rows.
+ */
+@Composable
+fun Modifier.dragLift(isLifted: Boolean, translationY: Float): Modifier {
+    val shape = MaterialTheme.shapes.small
+    val scale by animateFloatAsState(
+        targetValue = if (isLifted) 1.02f else 1f,
+        animationSpec = spring(stiffness = Spring.StiffnessMediumLow),
+        label = "dragScale"
+    )
+    return this
+        .graphicsLayer {
+            if (isLifted) {
+                this.translationY = translationY
+                scaleX = scale
+                scaleY = scale
+            }
+        }
+        .then(
+            if (isLifted) {
+                Modifier
+                    .zIndex(1f)
+                    .shadow(8.dp, shape, clip = false)
+                    .background(MaterialTheme.colorScheme.surface, shape)
+            } else {
+                Modifier
+            }
+        )
+}
+
+/**
+ * Scrolls the list while dragging so the entry follows the finger past the viewport edges.
+ * The visual center is tracked independently of the entry's layout slot (which can scroll out of
+ * `LazyListState.layoutInfo.visibleItemsInfo` during a long drag); [startCenterY] is the entry's
+ * viewport center captured at drag start and [fingerOffset] is the raw finger delta. The
+ * resulting scroll is picked up automatically by [DragRowState.translationY] on the next frame,
+ * so no separate scroll-compensation bookkeeping is required here.
+ */
+private suspend fun autoScrollWhileDragging(
+    listState: LazyListState,
+    startCenterY: MutableFloatState,
+    fingerOffset: MutableFloatState
+) {
+    val threshold = 48f
+    val maxSpeed = 24f
+    while (true) {
+        val info = listState.layoutInfo
+        val center = startCenterY.floatValue + fingerOffset.floatValue
+        val top = info.viewportStartOffset + threshold
+        val bottom = info.viewportEndOffset - threshold
+        val delta = when {
+            center < top -> -(top - center).coerceAtMost(maxSpeed)
+            center > bottom -> (center - bottom).coerceAtMost(maxSpeed)
+            else -> 0f
+        }
+        if (delta != 0f) listState.scrollBy(delta)
+        delay(16L.milliseconds)
+    }
+}
@@ -46,7 +46,7 @@ data object Spacing {
    val extraSmall = 6.dp
    val small = 8.dp
    val medium = 12.dp
-    val large = 16.dp
+    val large = 12.dp
    val extraLarge = 24.dp
 }

@@ -79,6 +79,10 @@ private val lightScheme = lightColorScheme(
    onSecondary = Color(0xFFFFFFFF),
    secondaryContainer = Color(0xFFF1E1BB),
    onSecondaryContainer = Color(0xFF221B04),
+    tertiary = Color(0xFF3C6FE0), // AMSAT Active (darker for light theme)
+    onTertiary = Color(0xFFFFFFFF),
+    tertiaryContainer = Color(0xFFE09800), // AMSAT Telemetry (darker)
+    onTertiaryContainer = Color(0xFF000000),
    background = Color(0xFFFFF8F0),
    onBackground = Color(0xFF1E1B13),
    surface = Color(0xFFFFF8F0),
@@ -101,10 +105,10 @@ private val darkScheme = darkColorScheme(
    onSecondary = Color(0xFF000000),
    secondaryContainer = Color(0xFF404040), // navBar indicator,
    onSecondaryContainer = Color(0xFFE0E0E0), // navBar active icon
-//    tertiary = Color(0xFF121212),
-//    onTertiary = Color(0xFF121212),
-//    tertiaryContainer = Color(0xFF121212),
-//    onTertiaryContainer = Color(0xFF121212),
+    tertiary = Color(0xFF648FFF), // AMSAT Active (from amsat.org/status)
+    onTertiary = Color(0xFF000000),
+    tertiaryContainer = Color(0xFFFFB000), // AMSAT Telemetry
+    onTertiaryContainer = Color(0xFF000000),
    background = Color(0xFF121212),
    onBackground = Color(0xFFE0E0E0),
    surface = Color(0xFF202020), // card background
@@ -24,20 +24,17 @@ import kotlinx.serialization.Serializable
 sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {

    @Serializable
-    data object Satellites : Screen(R.drawable.ic_satellites, R.string.nav_sat)
+    data object Satellites : Screen(R.drawable.ic_sputnik, R.string.nav_sat)

    @Serializable
    data object Passes : Screen(R.drawable.ic_passes, R.string.nav_pass)

    @Serializable
-    data object Radar : Screen(R.drawable.ic_radar, R.string.nav_radar)
+    data object Status : Screen(R.drawable.ic_satellite, R.string.nav_status)

    @Serializable
    data object Map : Screen(R.drawable.ic_map, R.string.nav_map)

-    @Serializable
-    data object Mutual : Screen(R.drawable.ic_match, R.string.nav_mutual)
-
    @Serializable
    data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs)
 }
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M440,520L200,520L200,440L440,440L440,200L520,200L520,440L760,440L760,520L520,520L520,760L440,760L440,520Z" />
+</vector>
@@ -1,11 +1,9 @@
-<?xml version="1.0" encoding="utf-8"?>
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:tint="?attr/colorControlNormal"
-    android:height="24dp"
    android:width="24dp"
+    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    <path
        android:fillColor="@android:color/white"
-        android:pathData="M6,19h4L10,5L6,5v14zM14,5v14h4L18,5h-4z"/>
+        android:pathData="M20,9H4v2h16V9zM4,15h16v-2H4V15z" />
 </vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="15"
+    android:viewportHeight="15">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M13.91,6.75c-1.17,2.25 -4.3,5.31 -6.07,6.94c-0.19,0.172 -0.48,0.172 -0.67,0C5.39,12.06 2.26,9 1.09,6.75C-1.48,1.8 5,-1.5 7.5,3.45C10,-1.5 16.48,1.8 13.91,6.75z" />
+</vector>
@@ -1,22 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="96"
-    android:viewportHeight="96">
-
-    <path
-        android:fillColor="@android:color/transparent"
-        android:strokeColor="@android:color/white"
-        android:strokeWidth="6"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round"
-        android:pathData="M 8 76 C 8 44, 21 24, 39 24 C 57 24, 70 44, 70 76" />
-
-    <path
-        android:fillColor="@android:color/transparent"
-        android:strokeColor="@android:color/white"
-        android:strokeWidth="6"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round"
-        android:pathData="M 30 76 C 30 54, 44 42, 62 42 C 80 42, 94 54, 94 76" />
-</vector>
@@ -1,9 +1,9 @@
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24">
+    android:viewportWidth="960"
+    android:viewportHeight="960">
    <path
        android:fillColor="@android:color/white"
-        android:pathData="M14,21c1.93,0 3.62,-1.17 4,-3l-1.75,-0.88C16,18.21 15.33,19 14,19l-4.9,0c0.83,-1 1.5,-2.34 1.5,-4c0,-0.35 -0.03,-0.69 -0.08,-1L14,14v-2l-4.18,0C9,10.42 8,9.6 8,8c0,-1.93 1.57,-3.5 3.5,-3.5c1.5,0 2.79,0.95 3.28,2.28L16.63,6c-0.8,-2.05 -2.79,-3.5 -5.13,-3.5C8.46,2.5 6,4.96 6,8c0,1.78 0.79,2.9 1.49,4L6,12v2l2.47,0c0.08,0.31 0.13,0.64 0.13,1c0,2.7 -2.6,4 -2.6,4v2H14z" />
+        android:pathData="M240,840L240,760Q240,760 256.5,750Q273,740 292.5,720.5Q312,701 328,670.5Q344,640 344,600Q344,589 342.5,579Q341,569 339,560L240,560L240,480L300,480Q279,447 259.5,410.5Q240,374 240,320Q240,228 304,164Q368,100 460,100Q531,100 586,139Q641,178 665,240L591,271Q576,231 540.5,205.5Q505,180 460,180Q402,180 361,221Q320,262 320,320Q320,368 344,400Q368,432 393,480L560,480L560,560L421,560Q423,569 423.5,579Q424,589 424,600Q424,650 406.5,690Q389,730 364,760L560,760Q600,760 621,739Q642,718 650,685L720,720Q709,775 663.5,807.5Q618,840 560,840L240,840Z" />
 </vector>
@@ -1,9 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="960"
-    android:viewportHeight="960">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M480,880Q397,880 324,848.5Q251,817 197,763Q143,709 111.5,636Q80,563 80,480Q80,397 111.5,324Q143,251 197,197Q251,143 324,111.5Q397,80 480,80L520,80L520,411Q538,422 549,439.5Q560,457 560,480Q560,513 536.5,536.5Q513,560 480,560Q447,560 423.5,536.5Q400,513 400,480Q400,457 411,439Q422,421 440,411L440,325Q388,339 354,381.5Q320,424 320,480Q320,546 367,593Q414,640 480,640Q546,640 593,593Q640,546 640,480Q640,444 625.5,413.5Q611,383 586,360L643,303Q678,336 699,381.5Q720,427 720,480Q720,580 650,650Q580,720 480,720Q380,720 310,650Q240,580 240,480Q240,390 297,323.5Q354,257 440,243L440,162Q321,177 240.5,267Q160,357 160,480Q160,614 253,707Q346,800 480,800Q614,800 707,707Q800,614 800,480Q800,411 773,351Q746,291 699,247L756,190Q813,245 846.5,319.5Q880,394 880,480Q880,563 848.5,636Q817,709 763,763Q709,817 636,848.5Q563,880 480,880Z" />
-</vector>
@@ -1,11 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:tint="?attr/colorControlNormal"
-    android:height="24dp"
    android:width="24dp"
+    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    <path
        android:fillColor="@android:color/white"
-        android:pathData="M17,3L5,3c-1.11,0 -2,0.9 -2,2v14c0,1.1 0.89,2 2,2h14c1.1,0 2,-0.9 2,-2L21,7l-4,-4zM12,19c-1.66,0 -3,-1.34 -3,-3s1.34,-3 3,-3 3,1.34 3,3 -1.34,3 -3,3zM15,9L5,9L5,5h10v4z"/>
+        android:pathData="M17.65,6.35C16.2,4.9 14.21,4 12,4c-4.42,0 -7.99,3.58 -7.99,8s3.57,8 7.99,8c3.73,0 6.84,-2.55 7.73,-6h-2.08c-0.82,2.33 -3.04,4 -5.65,4 -3.31,0 -6,-2.69 -6,-6s2.69,-6 6,-6c1.66,0 3.14,0.69 4.22,1.78L13,11h7V4l-2.35,2.35z" />
 </vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M13,3c-4.97,0 -9,4.03 -9,9L1,12l3.89,3.89 0.07,0.14L9,12L6,12c0,-3.87 3.13,-7 7,-7s7,3.13 7,7 -3.13,7 -7,7c-1.93,0 -3.68,-0.79 -4.94,-2.06l-1.42,1.42C8.27,19.99 10.51,21 13,21c4.97,0 9,-4.03 9,-9s-4.03,-9 -9,-9zM12,8v5l4.28,2.54 0.72,-1.21 -3.5,-2.08L13.5,8L12,8z" />
+</vector>
@@ -0,0 +1,31 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="128"
+    android:viewportHeight="128">
+  <path
+      android:pathData="m105.14,114.12a2.86,2.86 90,0 0,1.7 -0.85l19.33,-19.33a2.86,2.86 90,0 0,-0 -4.03l-26.58,-26.62a2.86,2.86 90,0 0,-1.84 -0.81l-7.92,-0.63 5.77,-5.77a2.86,2.86 90,0 0,-0 -4.03l-19.6,-19.64a2.86,2.86 90,0 0,-4.07 -0l-5.77,5.77 -0.63,-7.92a2.86,2.86 90,0 0,-0.81 -1.83l-26.63,-26.58a2.86,2.86 90,0 0,-4.07 -0l-19.29,19.29a2.86,2.86 90,0 0,-0 4.07l26.58,26.62a2.86,2.86 90,0 0,1.83 0.81l7.92,0.63 -5.77,5.77a2.86,2.86 90,0 0,-0 4.07l19.6,19.6a2.86,2.86 90,0 0,4.07 -0l5.77,-5.77 0.63,7.92a2.86,2.86 90,0 0,0.81 1.83l26.63,26.58a2.86,2.86 90,0 0,2.06 0.85,2.86 2.86,90 0,0 0.27,-0zM104.82,107.23 L80.97,83.38 80.16,72.69 85.58,67.27 96.28,68.12 120.13,91.93zM55.33,47.85 L44.63,47 20.78,23.19 36.08,7.89 59.89,31.74 60.74,42.44z"
+      android:fillColor="#ffffff"
+      android:strokeColor="#00000000"
+      android:fillType="evenOdd"/>
+  <path
+      android:pathData="m62.65,115.81a2.86,2.86 90,1 0,-0 -5.73c-11.46,-0 -22.88,-4.35 -31.63,-13.11 -8.74,-8.74 -13.1,-20.17 -13.1,-31.61a2.86,2.86 90,1 0,-5.73 -0c-0,12.9 4.94,25.83 14.77,35.66 9.85,9.85 22.77,14.78 35.68,14.78z"
+      android:fillColor="#ffffff"
+      android:strokeColor="#00000000"
+      android:fillType="evenOdd"/>
+  <path
+      android:pathData="m62.65,127a2.86,2.86 90,1 0,-0 -5.73c-14.32,-0 -28.61,-5.44 -39.55,-16.37 -10.93,-10.93 -16.38,-25.23 -16.38,-39.54a2.86,2.86 90,1 0,-5.73 -0c-0,15.76 6.03,31.56 18.06,43.59 12.03,12.03 27.82,18.05 43.6,18.05z"
+      android:fillColor="#ffffff"
+      android:strokeColor="#00000000"
+      android:fillType="evenOdd"/>
+  <path
+      android:pathData="m62.65,104.7a2.86,2.86 90,1 0,-0 -5.73c-8.62,-0 -17.2,-3.26 -23.78,-9.84 -6.58,-6.58 -9.86,-15.17 -9.86,-23.77a2.86,2.86 90,1 0,-5.73 -0c-0,10.06 3.86,20.15 11.53,27.82 7.67,7.67 17.76,11.52 27.83,11.52z"
+      android:fillColor="#ffffff"
+      android:strokeColor="#00000000"
+      android:fillType="evenOdd"/>
+  <path
+      android:pathData="m62.65,93.48a2.86,2.86 90,1 0,-0 -5.73c-5.74,-0 -11.45,-2.17 -15.84,-6.56 -4.38,-4.38 -6.56,-10.1 -6.56,-15.83a2.86,2.86 90,1 0,-5.73 -0c-0,7.19 2.76,14.41 8.24,19.88 5.48,5.48 12.69,8.23 19.89,8.23z"
+      android:fillColor="#ffffff"
+      android:strokeColor="#00000000"
+      android:fillType="evenOdd"/>
+</vector>
@@ -1,9 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="960"
-    android:viewportHeight="960">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M240,800L280,640L120,640L140,560L300,560L340,400L180,400L200,320L360,320L400,160L480,160L440,320L600,320L640,160L720,160L680,320L840,320L820,400L660,400L620,560L780,560L760,640L600,640L560,800L480,800L520,640L360,640L320,800L240,800ZM380,560L540,560L580,400L420,400L380,560Z" />
-</vector>
@@ -13,12 +13,16 @@
    <string name="nav_prefs">Ajustes</string>

    <!-- Satellites screen -->
-    <string name="sat_type_hint">Tipo: %s</string>
-    <string name="sat_type_title">Seleccionar tipo de satélite</string>
+    <string name="sat_type_hint">Modos: %s</string>
+    <string name="sat_type_title">Seleccionar modos</string>
    <string name="sat_search_hint">Id - Nombre</string>
    <string name="sat_search_clear">Vaciar</string>
    <string name="sat_clear_all">Vaciar todo</string>
    <string name="sat_select_all">Seleccionar todo</string>
+    <string name="sat_group_selected">Seleccionados</string>
+    <string name="sat_group_available">Disponibles</string>
+    <string name="sat_group_selected_count">Seleccionados (%1$d)</string>
+    <string name="sat_group_available_count">Disponibles (%1$d)</string>
    <string name="sat_empty_list_message">
        Asegúrese de que su consulta de búsqueda sea correcta y que la base de datos esté actualizada</string>
    <string name="sat_warning_title">Alarma\!</string>
@@ -26,7 +30,7 @@
        Esta aplicación incluye más de 9000 satélites.
        No tiene sentido rastrearlos todos a la vez.
        \n\nIntenta siempre limitar la lista a los que te
-        interesen mediante la búsqueda y el selector de tipos.</string>
+        interesen mediante la búsqueda y el selector de modos.</string>

    <!-- Passes screen -->
    <string name="pass_filter_title">Filtrar pases</string>
@@ -35,7 +39,7 @@
    <string name="pass_filter_aos_time">Ventana AOS</string>
    <string name="pass_filter_invert_time">Invertir ventana AOS</string>
    <string name="pass_filter_deep_space">DeepSpace (período &gt;225min)</string>
-    <string name="pass_modes_title">Tipo de modulación</string>
+    <string name="pass_modes_title">Seleccionar modos</string>
    <string name="pass_elevation">Elevación: %.1f°</string>
    <string name="pass_altitude">Altitud: %.0f km</string>
    <string name="pass_empty_list_message">
@@ -96,11 +100,11 @@
    <string name="prefs_loc_qth_title">QTH</string>
    <string name="prefs_loc_qth_error">Ubicación QTH no válida</string>
    <string name="prefs_loc_success">Ubicación actualizada con éxito</string>
-    <string name="prefs_station_title">Ajustar ubicaicón de la estación</string>
-    <string name="prefs_station_lat_text">Latitud de tu estación terrestre</string>
-    <string name="prefs_station_lon_text">Longitud de tu estación terrestre</string>
-    <string name="prefs_locator_title">Ajustes ubicación QTH</string>
-    <string name="prefs_locator_text">Ajustar posición de la estación con tu ubicación</string>
+    <string name="prefs_station_title">Ubicación de la estación</string>
+    <string name="prefs_station_lat_text">Latitud de estación</string>
+    <string name="prefs_station_lon_text">Longitud de estación</string>
+    <string name="prefs_locator_title">Localizador QTH</string>
+    <string name="prefs_locator_text">Posición por localizador</string>

    <string name="prefs_data_title">Datos satelitales</string>
    <string name="prefs_data_entries">Satélites: %s</string>
@@ -110,39 +114,57 @@
    <string name="prefs_data_clear">Vaciar</string>
    <string name="prefs_data_clear_success">Datos eliminados con éxito</string>
    <string name="prefs_data_update_success">Actualización completada con éxito</string>
+    <string name="prefs_data_import_satellites_error">No se importaron satélites. Usa un TLE/3LE (.txt) u OMM (.csv) válido.</string>
+    <string name="prefs_data_import_transceivers_error">No se importaron transceptores. Usa un SatNOGS (.json) válido.</string>

-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">Fuentes personalizadas</string>
+    <string name="prefs_data_sources_restore">Restaurar fuentes predeterminadas</string>
+    <string name="prefs_data_sources_sat_title">Datos de satélites</string>
+    <string name="prefs_data_sources_transceivers_title">Datos de transceptores</string>
+    <string name="prefs_data_sources_sat_hint">Prioridad arriba: nombres de satélites</string>
+    <string name="prefs_data_sources_transceivers_hint">Prioridad arriba: datos de transceptores</string>
+    <string name="prefs_data_sources_tle_switch">URL TLE</string>
+    <string name="prefs_data_sources_transceivers_switch">URL transceptores</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>

-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
+    <string name="prefs_data_output_title">Salida de datos</string>
+    <string name="prefs_net_output">Red</string>
    <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>

-    <string name="prefs_net_title">Salida de datos de red</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
+    <string name="nav_radiocontrol">Control de radio</string>
+    <string name="rc_settings_title">Control CAT</string>
+    <string name="rc_radio_model">Modelo de radio</string>
+    <string name="rc_tx_device_hint">Dirección BT TX</string>
+    <string name="rc_rx_device_hint">Dirección BT RX</string>
+    <string name="rc_tx_name_hint">Nombre radio TX</string>
+    <string name="rc_rx_name_hint">Nombre radio RX</string>
+    <string name="rc_enable_switch">Activar CAT</string>
+
+    <string name="prefs_net_title">Salida de red</string>
+    <string name="prefs_net_rotator_switch">Activar salida de rotación</string>
    <string name="prefs_net_rotator_address_hint">IP:Puerto</string>
    <string name="prefs_net_rotator_format_hint">Formato de datos</string>
-    <string name="prefs_net_frequency_switch">Enable frequency output</string>
+    <string name="prefs_net_frequency_switch">Activar salida de frecuencia</string>
    <string name="prefs_net_frequency_address_hint">IP:Puerto</string>
    <string name="prefs_net_frequency_format_hint">Formato de datos</string>

-    <string name="prefs_bt_title">Salida por Bluetooth</string>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Id dispositivo</string>
-    <string name="prefs_bt_rotator_output_hint">Formato de datos</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">Id dispositivo</string>
-    <string name="prefs_bt_frequency_output_hint">Formato de datos</string>
+    <string name="prefs_bt_title">Salida Bluetooth</string>
+    <string name="prefs_bt_rotator_switch">Activar salida de rotación</string>
+    <string name="prefs_bt_rotator_device_hint">ID dispositivo</string>
+    <string name="prefs_bt_rotator_output_hint">Formato</string>
+    <string name="prefs_bt_frequency_switch">Activar salida de frecuencia</string>
+    <string name="prefs_bt_frequency_device_hint">ID dispositivo</string>
+    <string name="prefs_bt_frequency_output_hint">Formato</string>
    <string name="prefs_bt_perm_error">Revisa los permisos de Bluetooth</string>
    <string name="prefs_net_perm_error">Revisa los permisos de red</string>

-    <string name="prefs_other_title">Otros ajustes</string>
-    <string name="prefs_other_switch_utc">Mostrar tiempos de pase en UTC</string>
-    <string name="prefs_other_switch_update">Habilitar auto actualización de datos</string>
-    <string name="prefs_other_switch_sweep">Habilitar animaciones radar</string>
-    <string name="prefs_other_switch_sensors">Usar sensores para rotar vista de radar</string>
-    <string name="prefs_other_switch_night_mode">Activar filtro nocturno rojo</string>
+    <string name="prefs_other_title">Otros</string>
+    <string name="prefs_other_switch_utc">Hora UTC</string>
+    <string name="prefs_other_switch_update">Actualización automática</string>
+    <string name="prefs_other_switch_sweep">Animación radar</string>
+    <string name="prefs_other_switch_sensors">Sensores</string>
+    <string name="prefs_other_switch_night_mode">Filtro nocturno</string>

    <string name="prefs_highlight_title">Resaltado de elevación</string>
    <string name="prefs_highlight_low">Baja &lt; %1$d°</string>
@@ -13,19 +13,23 @@
    <string name="nav_prefs">Настройки</string>

    <!-- Satellites screen -->
-    <string name="sat_type_hint">Тип: %s</string>
-    <string name="sat_type_title">Выберите тип спутника</string>
+    <string name="sat_type_hint">Режимы: %s</string>
+    <string name="sat_type_title">Выберите режимы</string>
    <string name="sat_search_hint">Id - Название</string>
    <string name="sat_search_clear">Очистить</string>
    <string name="sat_clear_all">Очистить</string>
    <string name="sat_select_all">Выбрать</string>
+    <string name="sat_group_selected">Выбранные</string>
+    <string name="sat_group_available">Доступные</string>
+    <string name="sat_group_selected_count">Выбранные (%1$d)</string>
+    <string name="sat_group_available_count">Доступные (%1$d)</string>
    <string name="sat_empty_list_message">Убедитесь, что ваш поисковый запрос верен и база данных обновлена</string>
    <string name="sat_warning_title">Внимание\!</string>
    <string name="sat_warning_message">
        В этом приложении перечислено более 9000 спутников.
        Отслеживать их все одновременно бессмысленно.
        \n\nВсегда старайтесь сузить список до тех,
-        которые вас интересуют, используя поиск и селектор типов.</string>
+        которые вас интересуют, используя поиск и выбор режимов.</string>

    <!-- Passes screen -->
    <string name="pass_filter_title">Фильтровать пролеты</string>
@@ -34,7 +38,7 @@
    <string name="pass_filter_aos_time">Окно AOS</string>
    <string name="pass_filter_invert_time">Инвертировать окно AOS</string>
    <string name="pass_filter_deep_space">DeepSpace (период &gt;225мин)</string>
-    <string name="pass_modes_title">Выберите тип модуляции</string>
+    <string name="pass_modes_title">Выберите режимы</string>
    <string name="pass_elevation">Элевация: %.1f°</string>
    <string name="pass_altitude">Высота: %d км</string>
    <string name="pass_empty_list_message">
@@ -95,11 +99,11 @@
    <string name="prefs_loc_qth_title">QTH</string>
    <string name="prefs_loc_qth_error">Неправильный локатор QTH</string>
    <string name="prefs_loc_success">Позиция успешно обновлена</string>
-    <string name="prefs_station_title">Настройки местоположения</string>
-    <string name="prefs_station_lat_text">Введите широту наземной станции</string>
-    <string name="prefs_station_lon_text">Введите долготу наземной станции</string>
-    <string name="prefs_locator_title">Настройки локатора QTH</string>
-    <string name="prefs_locator_text">Введите позицию через локатор</string>
+    <string name="prefs_station_title">Положение станции</string>
+    <string name="prefs_station_lat_text">Широта станции</string>
+    <string name="prefs_station_lon_text">Долгота станции</string>
+    <string name="prefs_locator_title">Локатор QTH</string>
+    <string name="prefs_locator_text">Позиция по локатору</string>

    <string name="prefs_data_title">Данные спутников</string>
    <string name="prefs_data_entries">Спутников: %s</string>
@@ -109,16 +113,35 @@
    <string name="prefs_data_clear">Очистить</string>
    <string name="prefs_data_clear_success">Очистка прошла успешно</string>
    <string name="prefs_data_update_success">Обновление прошло успешно</string>
+    <string name="prefs_data_import_satellites_error">Спутники не импортированы. Нужен TLE/3LE (.txt) или OMM (.csv).</string>
+    <string name="prefs_data_import_transceivers_error">Трансиверы не импортированы. Нужен SatNOGS (.json).</string>

-    <string name="prefs_data_sources_title">Свои источники данных</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom Transceivers URL</string>
+    <string name="prefs_data_sources_title">Свои источники</string>
+    <string name="prefs_data_sources_restore">Восстановить источники по умолчанию</string>
+    <string name="prefs_data_sources_sat_title">Данные спутников</string>
+    <string name="prefs_data_sources_transceivers_title">Данные трансиверов</string>
+    <string name="prefs_data_sources_sat_hint">Приоритет сверху: названия спутников</string>
+    <string name="prefs_data_sources_transceivers_hint">Приоритет сверху: данные трансиверов</string>
+    <string name="prefs_data_sources_tle_switch">URL TLE</string>
+    <string name="prefs_data_sources_transceivers_switch">URL трансиверов</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>

-    <string name="prefs_data_output_title">Вывод данных</string>
+    <string name="prefs_data_output_title">Вывод</string>
    <string name="prefs_net_output">Сеть</string>
    <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>

-    <string name="prefs_net_title">Вывод сетевых данных</string>
+    <string name="nav_radiocontrol">Управление радио</string>
+
+    <string name="rc_settings_title">CAT управление</string>
+    <string name="rc_radio_model">Модель радио</string>
+    <string name="rc_tx_device_hint">BT адрес TX</string>
+    <string name="rc_rx_device_hint">BT адрес RX</string>
+    <string name="rc_tx_name_hint">Имя радио TX</string>
+    <string name="rc_rx_name_hint">Имя радио RX</string>
+    <string name="rc_enable_switch">Включить CAT</string>
+
+    <string name="prefs_net_title">Сетевой вывод</string>
    <string name="prefs_net_rotator_switch">Включить вывод ротатора</string>
    <string name="prefs_net_rotator_address_hint">IP:Порт</string>
    <string name="prefs_net_rotator_format_hint">Формат</string>
@@ -126,22 +149,22 @@
    <string name="prefs_net_frequency_address_hint">IP:Порт</string>
    <string name="prefs_net_frequency_format_hint">Формат</string>

-    <string name="prefs_bt_title">Вывод данных Bluetooth</string>
+    <string name="prefs_bt_title">Вывод Bluetooth</string>
    <string name="prefs_bt_rotator_switch">Включить вывод ротатора</string>
-    <string name="prefs_bt_rotator_device_hint">Id устройства</string>
+    <string name="prefs_bt_rotator_device_hint">ID устройства</string>
    <string name="prefs_bt_rotator_output_hint">Формат</string>
    <string name="prefs_bt_frequency_switch">Включить вывод частоты</string>
-    <string name="prefs_bt_frequency_device_hint">Id устройства</string>
+    <string name="prefs_bt_frequency_device_hint">ID устройства</string>
    <string name="prefs_bt_frequency_output_hint">Формат</string>
    <string name="prefs_bt_perm_error">Нет разрешения использовать bluetooth</string>
    <string name="prefs_net_perm_error">Нет разрешения использовать сеть</string>

-    <string name="prefs_other_title">Другие настройки</string>
-    <string name="prefs_other_switch_utc">Показывать время по UTC</string>
-    <string name="prefs_other_switch_update">Обновлять данные автоматически</string>
-    <string name="prefs_other_switch_sweep">Показывать анимацию радара</string>
-    <string name="prefs_other_switch_sensors">Использовать сенсоры устройства</string>
-    <string name="prefs_other_switch_night_mode">Включить красный ночной фильтр</string>
+    <string name="prefs_other_title">Прочее</string>
+    <string name="prefs_other_switch_utc">Время в UTC</string>
+    <string name="prefs_other_switch_update">Автообновление данных</string>
+    <string name="prefs_other_switch_sweep">Анимация радара</string>
+    <string name="prefs_other_switch_sensors">Сенсоры</string>
+    <string name="prefs_other_switch_night_mode">Ночной фильтр</string>

    <string name="prefs_highlight_title">Подсветка высоты</string>
    <string name="prefs_highlight_low">Низко &lt; %1$d°</string>
@@ -13,19 +13,23 @@
    <string name="nav_prefs">පසුතල</string>

    <!-- Satellites screen -->
-    <string name="sat_type_hint">වර්ගය: %s</string>
-    <string name="sat_type_title">චන්ද්‍රිකා ආකාරය තෝරන්න</string>
+    <string name="sat_type_hint">මාදිලි: %s</string>
+    <string name="sat_type_title">මාදිලි තෝරන්න</string>
    <string name="sat_search_hint">Id - නම</string>
    <string name="sat_search_clear">පිරිසිදු ක°</string>
    <string name="sat_clear_all">සියල්ල පිරිසිදු ක°</string>
    <string name="sat_select_all">සියල්ල තෝරන්න</string>
+    <string name="sat_group_selected">තෝරාගත්</string>
+    <string name="sat_group_available">තිබෙන</string>
+    <string name="sat_group_selected_count">තෝරාගත් (%1$d)</string>
+    <string name="sat_group_available_count">තිබෙන (%1$d)</string>
    <string name="sat_empty_list_message">
        ඔබගේ සෙවුම් විමසුම නිවැරදි බවත් දත්ත සමුදාය යාවත්කාලීන කර ඇති බවත් සහතික කර ගන්න</string>
    <string name="sat_warning_title">අවවාදයයි\!</string>
    <string name="sat_warning_message">
        මෙම යෙදුමේ ලැයිස්තුගත කර ඇති චන්ද්‍රිකා 9000 කට වඩා තිබේ.
        ඒවා සියල්ලම එකවර නිරීක්ෂණය කිරීම තේරුමක් නැති දෙයක්.
-        \n\nසෙවීම සහ වර්ග තේරීම හරහා ඔබ උනන්දුවක් දක්වන
+        \n\nසෙවීම සහ මාදිලි තේරීම හරහා ඔබ උනන්දුවක් දක්වන
        ඒවාට පමණක් ලැයිස්තුව පටු කිරීමට සැමවිටම උත්සාහ කරන්න.</string>

    <!-- Passes screen -->
@@ -35,7 +39,7 @@
    <string name="pass_filter_aos_time">AOS කවුළුව</string>
    <string name="pass_filter_invert_time">AOS කවුළුව ප්‍රතිවිරුද්ධ කරන්න</string>
    <string name="pass_filter_deep_space">DeepSpace (කාලය &gt;225min)</string>
-    <string name="pass_modes_title">මූර්ජන ආකාරය තෝරන්න</string>
+    <string name="pass_modes_title">මූර්ජන තෝරන්න</string>
    <string name="pass_elevation">උත්තෝලනය: %.1f°</string>
    <string name="pass_altitude">උන්නතාශය: %d km</string>
    <string name="pass_empty_list_message">
@@ -96,11 +100,11 @@
    <string name="prefs_loc_qth_title">QTH</string>
    <string name="prefs_loc_qth_error">QTH locator වලංගු නොවේ</string>
    <string name="prefs_loc_success">පිහිටීම යාවත්කාලීනය සාර්ථකයි</string>
-    <string name="prefs_station_title">පොළෙහි පිහිටීම් පසුතල</string>
-    <string name="prefs_station_lat_text">ඔබගේ පොළෙහි අක්‍ෂාංශය සකසන්න</string>
-    <string name="prefs_station_lon_text">ඔබගේ පොළෙහි දේශාංශය සකසන්න</string>
-    <string name="prefs_locator_title">QTH locator පසුතල</string>
-    <string name="prefs_locator_text"> ඔබගේ locator භාවිතා කර පොළහි පිහිටීම සකසන්න</string>
+    <string name="prefs_station_title">පොළ පිහිටීම</string>
+    <string name="prefs_station_lat_text">පොළ අක්‍ෂාංශය</string>
+    <string name="prefs_station_lon_text">පොළ දේශාංශය</string>
+    <string name="prefs_locator_title">QTH locator</string>
+    <string name="prefs_locator_text">locator මඟින් පොළ පිහිටීම සකසන්න</string>

    <string name="prefs_data_title">චන්ද්‍රිකා දත්ත</string>
    <string name="prefs_data_entries">චන්ද්‍රිකා: %s</string>
@@ -110,39 +114,57 @@
    <string name="prefs_data_clear">පිරිසිදු ක°</string>
    <string name="prefs_data_clear_success">දත්ත ඉවත් කිරීම සාර්ථකයි</string>
    <string name="prefs_data_update_success">යාවත්කාලීනය සම්පූර්ණ කිරීම සාර්ථකයි</string>
+    <string name="prefs_data_import_satellites_error">චන්ද්‍රිකා ආයාත නොවීය. වලංගු TLE/3LE (.txt) හෝ OMM (.csv) ගොනුවක් තෝරන්න.</string>
+    <string name="prefs_data_import_transceivers_error">සම්ප්‍රේෂක ආයාත නොවීය. වලංගු SatNOGS (.json) ගොනුවක් තෝරන්න.</string>

-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">අභිරුචි මූලාශ්‍ර</string>
+    <string name="prefs_data_sources_restore">පෙරනිමි මූලාශ්‍ර ප්‍රතිස්ථාපනය කරන්න</string>
+    <string name="prefs_data_sources_sat_title">චන්ද්‍රිකා දත්ත</string>
+    <string name="prefs_data_sources_transceivers_title">සම්ප්‍රේෂක දත්ත</string>
+    <string name="prefs_data_sources_sat_hint">ඉහළ ප්‍රමුඛතාව: චන්ද්‍රිකා නම්</string>
+    <string name="prefs_data_sources_transceivers_hint">ඉහළ ප්‍රමුඛතාව: සම්ප්‍රේෂක දත්ත</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">Transceivers URL</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>

-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
+    <string name="prefs_data_output_title">දත්ත ප්‍රතිදානය</string>
+    <string name="prefs_net_output">ජාලය</string>
    <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>
+
+    <string name="nav_radiocontrol">රේඩියෝ පාලනය</string>
+    <string name="rc_settings_title">CAT පාලනය</string>
+    <string name="rc_radio_model">රේඩියෝ මාදිලිය</string>
+    <string name="rc_tx_device_hint">TX BT ලිපිනය</string>
+    <string name="rc_rx_device_hint">RX BT ලිපිනය</string>
+    <string name="rc_tx_name_hint">TX රේඩියෝ නම</string>
+    <string name="rc_rx_name_hint">RX රේඩියෝ නම</string>
+    <string name="rc_enable_switch">CAT සබල කරන්න</string>

    <string name="prefs_net_title">ජාල ප්‍රතිදානය</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
+    <string name="prefs_net_rotator_switch">Rotation ප්‍රතිදානය සබල කරන්න</string>
    <string name="prefs_net_rotator_address_hint">IP:Port</string>
-    <string name="prefs_net_rotator_format_hint">දත්ත අකාරය</string>
-    <string name="prefs_net_frequency_switch">Enable frequency output</string>
+    <string name="prefs_net_rotator_format_hint">දත්ත ආකෘතිය</string>
+    <string name="prefs_net_frequency_switch">Frequency ප්‍රතිදානය සබල කරන්න</string>
    <string name="prefs_net_frequency_address_hint">IP:Port</string>
-    <string name="prefs_net_frequency_format_hint">දත්ත අකාරය</string>
+    <string name="prefs_net_frequency_format_hint">දත්ත ආකෘතිය</string>

-    <string name="prefs_bt_title">Bluetooth දත්ත ප්‍රතිදානය</string>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">උපාංග id</string>
-    <string name="prefs_bt_rotator_output_hint">දත්ත අකාරය</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">උපාංග id</string>
-    <string name="prefs_bt_frequency_output_hint">දත්ත අකාරය</string>
+    <string name="prefs_bt_title">Bluetooth ප්‍රතිදානය</string>
+    <string name="prefs_bt_rotator_switch">Rotation ප්‍රතිදානය සබල කරන්න</string>
+    <string name="prefs_bt_rotator_device_hint">උපාංග ID</string>
+    <string name="prefs_bt_rotator_output_hint">දත්ත ආකෘතිය</string>
+    <string name="prefs_bt_frequency_switch">Frequency ප්‍රතිදානය සබල කරන්න</string>
+    <string name="prefs_bt_frequency_device_hint">උපාංග ID</string>
+    <string name="prefs_bt_frequency_output_hint">දත්ත ආකෘතිය</string>
    <string name="prefs_bt_perm_error">Bluetooth අවසර පරික්‍ෂා ක°</string>
    <string name="prefs_net_perm_error">Network අවසර පරික්‍ෂා කරන්න</string>

-    <string name="prefs_other_title">වෙනත් සැකසුම්</string>
-    <string name="prefs_other_switch_utc">පසුකර වේලාවන් UTC මගින්</string>
-    <string name="prefs_other_switch_update">ස්වයං දත්ත යාවත්කාලීනය</string>
-    <string name="prefs_other_switch_sweep">radar sweep සජීවිකරණය සබල කරන්න</string>
-    <string name="prefs_other_switch_sensors">Radar දර්ශනය කරකැවීමට සංවේදක භාවිතා කරන්න </string>
-    <string name="prefs_other_switch_night_mode">රතු රාත්‍රී පෙරහන සබල කරන්න</string>
+    <string name="prefs_other_title">වෙනත්</string>
+    <string name="prefs_other_switch_utc">UTC වේලාව</string>
+    <string name="prefs_other_switch_update">දත්ත ස්වයං යාවත්කාලීන</string>
+    <string name="prefs_other_switch_sweep">Radar sweep</string>
+    <string name="prefs_other_switch_sensors">සංවේදක</string>
+    <string name="prefs_other_switch_night_mode">රාත්‍රී පෙරහන</string>

    <string name="prefs_highlight_title">උස් උද්දීපනය</string>
    <string name="prefs_highlight_low">අඩු &lt; %1$d°</string>
@@ -14,19 +14,23 @@
    <string name="nav_prefs">Ayarlar</string>

    <!-- Satellites screen -->
-    <string name="sat_type_hint">Uydu türü: %s</string>
-    <string name="sat_type_title">Uydu türü seçin</string>
+    <string name="sat_type_hint">Modlar: %s</string>
+    <string name="sat_type_title">Modları seçin</string>
    <string name="sat_search_hint">Id - Ad</string>
    <string name="sat_search_clear">Temizle</string>
    <string name="sat_clear_all">Tümünü temizle</string>
    <string name="sat_select_all">Tümünü seç</string>
+    <string name="sat_group_selected">Seçilenler</string>
+    <string name="sat_group_available">Kullanılabilir</string>
+    <string name="sat_group_selected_count">Seçilenler (%1$d)</string>
+    <string name="sat_group_available_count">Kullanılabilir (%1$d)</string>
    <string name="sat_empty_list_message">"Arama sorgunuzun doğru olduğundan ve veritabanının güncellendiğinden emin olun"</string>
    <string name="sat_warning_title">Uyarı\!</string>
    <string name="sat_warning_message">
        Bu uygulamada 9000\'den fazla uydu listelenmiştir.
        Hepsini aynı anda takip etmek anlamsızdır.
        \n\nListeyi yalnızca ilgilendiğiniz uydularla
-        daraltmak için arama ve tür seçiciyi kullanın.</string>
+        daraltmak için arama ve mod seçiciyi kullanın.</string>

    <!-- Passes screen -->
    <string name="pass_filter_title">Geçişleri filtrele</string>
@@ -36,7 +40,7 @@
    <string name="pass_filter_invert_time">AOS aralığını tersine çevir</string>
    <string name="pass_filter_deep_space">DeepSpace (periyot &gt;225dk)</string>
    <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
-    <string name="pass_modes_title">Modulasyon türü seçin</string>
+    <string name="pass_modes_title">Modları seçin</string>
    <string name="pass_satId" translatable="false">%05d</string>
    <string name="pass_elevation">Yükseklik açısı: %.1f°</string>
    <string name="pass_deep_space" translatable="false">DeepSpace</string>
@@ -127,11 +131,11 @@
    <string name="prefs_loc_qth_title">QTH</string>
    <string name="prefs_loc_qth_error">Geçersiz QTH konumlandırıcısı</string>
    <string name="prefs_loc_success">Konum başarıyla güncellendi</string>
-    <string name="prefs_station_title">İstasyon konumu ayarları</string>
-    <string name="prefs_station_lat_text">Yer istasyonunuzun enlemini girin</string>
-    <string name="prefs_station_lon_text">Yer istasyonunuzun boylamını girin</string>
-    <string name="prefs_locator_title">QTH konumlandırıcı ayarları</string>
-    <string name="prefs_locator_text">İstasyon konumunu konumlandırıcı ile ayarlayın</string>
+    <string name="prefs_station_title">İstasyon konumu</string>
+    <string name="prefs_station_lat_text">İstasyon enlemi</string>
+    <string name="prefs_station_lon_text">İstasyon boylamı</string>
+    <string name="prefs_locator_title">QTH konumlandırıcı</string>
+    <string name="prefs_locator_text">Konumu lokatörle ayarla</string>

    <string name="prefs_data_title">Uydu verisi</string>
    <string name="prefs_data_entries">Uydular: %s</string>
@@ -141,28 +145,35 @@
    <string name="prefs_data_clear">Temizle</string>
    <string name="prefs_data_clear_success">Veriler başarıyla temizlendi</string>
    <string name="prefs_data_update_success">Güncelleme başarıyla tamamlandı</string>
+    <string name="prefs_data_import_satellites_error">Uydu içe aktarılmadı. Geçerli bir TLE/3LE (.txt) veya OMM (.csv) dosyası seçin.</string>
+    <string name="prefs_data_import_transceivers_error">Transceiver içe aktarılmadı. Geçerli bir SatNOGS (.json) dosyası seçin.</string>

-    <string name="prefs_data_sources_title">Özel veri kaynakları</string>
-    <string name="prefs_data_sources_tle_switch">Özel TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Özel transceiver URL</string>
+    <string name="prefs_data_sources_title">Özel kaynaklar</string>
+    <string name="prefs_data_sources_restore">Varsayılan kaynakları geri yükle</string>
+    <string name="prefs_data_sources_sat_title">Uydu verileri</string>
+    <string name="prefs_data_sources_transceivers_title">Transceiver verileri</string>
+    <string name="prefs_data_sources_sat_hint">Öncelik üstte: uydu adları</string>
+    <string name="prefs_data_sources_transceivers_hint">Öncelik üstte: transceiver verileri</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">Transceiver URL</string>
    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>

-    <string name="prefs_data_output_title">Veri aktarımı</string>
+    <string name="prefs_data_output_title">Veri çıkışı</string>
    <string name="prefs_net_output">Ağ</string>
    <string name="prefs_bt_output">Bluetooth</string>
    <string name="prefs_cat_output">CAT</string>

    <!-- Radio Control -->
    <string name="nav_radiocontrol">Radyo Kontrolü</string>
-    <string name="rc_settings_title">CAT Radyo Kontrolü</string>
+    <string name="rc_settings_title">CAT kontrolü</string>
    <string name="rc_radio_model">Radyo Modeli</string>
-    <string name="rc_tx_device_hint">TX Radyo BT Adresi</string>
-    <string name="rc_rx_device_hint">RX Radyo BT Adresi</string>
+    <string name="rc_tx_device_hint">TX BT adresi</string>
+    <string name="rc_rx_device_hint">RX BT adresi</string>
    <string name="rc_tx_name_hint">TX Radyo Adı</string>
    <string name="rc_rx_name_hint">RX Radyo Adı</string>
-    <string name="rc_enable_switch">CAT Kontrolünü Etkinleştir</string>
+    <string name="rc_enable_switch">CAT\'i etkinleştir</string>

-    <string name="prefs_net_title">Ağ veri çıkışı</string>
+    <string name="prefs_net_title">Ağ çıkışı</string>
    <string name="prefs_net_rotator_switch">Döndürme çıkışını etkinleştir</string>
    <string name="prefs_net_rotator_address_hint">IP:Port</string>
    <string name="prefs_net_rotator_format_hint">Biçim</string>
@@ -170,22 +181,22 @@
    <string name="prefs_net_frequency_address_hint">IP:Port</string>
    <string name="prefs_net_frequency_format_hint">Biçim</string>

-    <string name="prefs_bt_title">Bluetooth veri çıkışı</string>
+    <string name="prefs_bt_title">Bluetooth çıkışı</string>
    <string name="prefs_bt_rotator_switch">Döndürme çıkışını etkinleştir</string>
    <string name="prefs_bt_rotator_device_hint">Cihaz kimliği</string>
-    <string name="prefs_bt_rotator_output_hint">Veri biçimi</string>
+    <string name="prefs_bt_rotator_output_hint">Biçim</string>
    <string name="prefs_bt_frequency_switch">Frekans çıkışını etkinleştir</string>
    <string name="prefs_bt_frequency_device_hint">Cihaz kimliği</string>
-    <string name="prefs_bt_frequency_output_hint">Veri biçimi</string>
+    <string name="prefs_bt_frequency_output_hint">Biçim</string>
    <string name="prefs_bt_perm_error">Bluetooth izninizi kontrol edin</string>
    <string name="prefs_net_perm_error">Ağ izninizi kontrol edin</string>

-    <string name="prefs_other_title">Diğer ayarlar</string>
-    <string name="prefs_other_switch_utc">Geçiş saatini UTC olarak göster</string>
-    <string name="prefs_other_switch_update">Otomatik veri güncellemeyi etkinleştir</string>
-    <string name="prefs_other_switch_sweep">Radar taramasını etkinleştir</string>
-    <string name="prefs_other_switch_sensors">Radar görünümünü döndürmek için sensörleri kullan</string>
-    <string name="prefs_other_switch_night_mode">Kırmızı gece filtresini etkinleştir</string>
+    <string name="prefs_other_title">Diğer</string>
+    <string name="prefs_other_switch_utc">UTC saati</string>
+    <string name="prefs_other_switch_update">Veriyi otomatik güncelle</string>
+    <string name="prefs_other_switch_sweep">Radar taraması</string>
+    <string name="prefs_other_switch_sensors">Sensör</string>
+    <string name="prefs_other_switch_night_mode">Gece filtresi</string>

    <string name="prefs_highlight_title">Elevasyon vurgusu</string>
    <string name="prefs_highlight_low">Düşük &lt; %1$d°</string>
@@ -199,8 +210,7 @@
        \n• Dave Moten (predict4java)
        \n• Alexandru Csete (Gpredict)
        \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)
-        \n• BG7NTA (CW decoding feature)</string>
+        \n• Libre Space Foundation (SatNOGS)</string>
    <string name="prefs_outro_license">Bu uygulama herhangi bir garanti sunmaz</string>

 </resources>
@@ -13,12 +13,16 @@
    <string name="nav_prefs">Налаштування</string>

    <!-- Satellites screen -->
-    <string name="sat_type_hint">Тип: %s</string>
-    <string name="sat_type_title">Виберіть тип супутника</string>
+    <string name="sat_type_hint">Режими: %s</string>
+    <string name="sat_type_title">Виберіть режими</string>
    <string name="sat_search_hint">Id - Назва</string>
    <string name="sat_search_clear">Очистити</string>
    <string name="sat_clear_all">Очистити всі</string>
    <string name="sat_select_all">Вибрати всі</string>
+    <string name="sat_group_selected">Обрані</string>
+    <string name="sat_group_available">Доступні</string>
+    <string name="sat_group_selected_count">Обрані (%1$d)</string>
+    <string name="sat_group_available_count">Доступні (%1$d)</string>
    <string name="sat_empty_list_message">
        Переконайтеся, що ваш пошуковий запит правильний, а база даних оновлена</string>
    <string name="sat_warning_title">Увага\!</string>
@@ -26,7 +30,7 @@
        У цьому додатку перелічено понад 9000 супутників.
        Немає сенсу відстежувати їх усі одночасно.
        \n\nЗавжди намагайтеся звузити список лише до тих,
-        які вас цікавлять, за допомогою пошуку та селектора типів.</string>
+        які вас цікавлять, за допомогою пошуку та вибору режимів.</string>

    <!-- Passes screen -->
    <string name="pass_filter_title">Фільтр прольотів</string>
@@ -35,7 +39,7 @@
    <string name="pass_filter_aos_time">Вікно AOS</string>
    <string name="pass_filter_invert_time">Інвертувати вікно AOS</string>
    <string name="pass_filter_deep_space">DeepSpace (період &gt;225хв)</string>
-    <string name="pass_modes_title">Виберіть тип модуляції</string>
+    <string name="pass_modes_title">Виберіть режими</string>
    <string name="pass_elevation">Піднес.: %.1f°</string>
    <string name="pass_altitude">Висота: %.0f км</string>
    <string name="pass_empty_list_message">
@@ -96,11 +100,11 @@
    <string name="prefs_loc_qth_title">QTH</string>
    <string name="prefs_loc_qth_error">Некоректний локатор QTH</string>
    <string name="prefs_loc_success">Позицію успішно оновлено</string>
-    <string name="prefs_station_title">Налаштування місцезнаходження станції</string>
-    <string name="prefs_station_lat_text">Широта місцезнаходження станції</string>
-    <string name="prefs_station_lon_text">Довгота місцезнаходження станції</string>
-    <string name="prefs_locator_title">Налаштування QTH локатора</string>
-    <string name="prefs_locator_text">Задати позицію за QTH локатором</string>
+    <string name="prefs_station_title">Позиція станції</string>
+    <string name="prefs_station_lat_text">Широта станції</string>
+    <string name="prefs_station_lon_text">Довгота станції</string>
+    <string name="prefs_locator_title">Локатор QTH</string>
+    <string name="prefs_locator_text">Позиція за локатором</string>

    <string name="prefs_data_title">Супутникові дані</string>
    <string name="prefs_data_entries">Супутників: %s</string>
@@ -110,39 +114,57 @@
    <string name="prefs_data_clear">Очистити</string>
    <string name="prefs_data_clear_success">Дані успішно очищено</string>
    <string name="prefs_data_update_success">Оновлення успішне</string>
+    <string name="prefs_data_import_satellites_error">Супутники не імпортовано. Потрібен TLE/3LE (.txt) або OMM (.csv).</string>
+    <string name="prefs_data_import_transceivers_error">Трансивери не імпортовано. Потрібен SatNOGS (.json).</string>

-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
+    <string name="prefs_data_sources_title">Власні джерела</string>
+    <string name="prefs_data_sources_restore">Відновити джерела за замовчуванням</string>
+    <string name="prefs_data_sources_sat_title">Дані супутників</string>
+    <string name="prefs_data_sources_transceivers_title">Дані трансиверів</string>
+    <string name="prefs_data_sources_sat_hint">Пріоритет зверху: назви супутників</string>
+    <string name="prefs_data_sources_transceivers_hint">Пріоритет зверху: дані трансиверів</string>
+    <string name="prefs_data_sources_tle_switch">URL TLE</string>
+    <string name="prefs_data_sources_transceivers_switch">URL трансиверів</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>

-    <string name="prefs_data_output_title">Data output</string>
-    <string name="prefs_net_output">Network</string>
+    <string name="prefs_data_output_title">Вивід даних</string>
+    <string name="prefs_net_output">Мережа</string>
    <string name="prefs_bt_output">Bluetooth</string>
+    <string name="prefs_cat_output">CAT</string>

-    <string name="prefs_net_title">Вивід мережевих даних</string>
-    <string name="prefs_net_rotator_switch">Enable rotation output</string>
+    <string name="nav_radiocontrol">Керування радіо</string>
+    <string name="rc_settings_title">CAT керування</string>
+    <string name="rc_radio_model">Модель радіо</string>
+    <string name="rc_tx_device_hint">BT адреса TX</string>
+    <string name="rc_rx_device_hint">BT адреса RX</string>
+    <string name="rc_tx_name_hint">Назва радіо TX</string>
+    <string name="rc_rx_name_hint">Назва радіо RX</string>
+    <string name="rc_enable_switch">Увімкнути CAT</string>
+
+    <string name="prefs_net_title">Мережевий вивід</string>
+    <string name="prefs_net_rotator_switch">Увімкнути вивід повороту</string>
    <string name="prefs_net_rotator_address_hint">IP:Порт</string>
    <string name="prefs_net_rotator_format_hint">Формат даних</string>
-    <string name="prefs_net_frequency_switch">Enable frequency output</string>
+    <string name="prefs_net_frequency_switch">Увімкнути вивід частоти</string>
    <string name="prefs_net_frequency_address_hint">IP:Порт</string>
    <string name="prefs_net_frequency_format_hint">Формат даних</string>

-    <string name="prefs_bt_title">Вивід даних Bluetooth</string>
-    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Id пристрою</string>
+    <string name="prefs_bt_title">Вивід Bluetooth</string>
+    <string name="prefs_bt_rotator_switch">Увімкнути вивід повороту</string>
+    <string name="prefs_bt_rotator_device_hint">ID пристрою</string>
    <string name="prefs_bt_rotator_output_hint">Формат даних</string>
-    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">Id пристрою</string>
+    <string name="prefs_bt_frequency_switch">Увімкнути вивід частоти</string>
+    <string name="prefs_bt_frequency_device_hint">ID пристрою</string>
    <string name="prefs_bt_frequency_output_hint">Формат даних</string>
    <string name="prefs_bt_perm_error">Перевірте дозвіл Bluetooth</string>
    <string name="prefs_net_perm_error">Перевірте дозвіл мережі</string>

-    <string name="prefs_other_title">Інші налаштування</string>
-    <string name="prefs_other_switch_utc">Показувати час в UTC</string>
-    <string name="prefs_other_switch_update">Автоматичне оновлення даних</string>
-    <string name="prefs_other_switch_sweep">Показувати анімацію радара</string>
-    <string name="prefs_other_switch_sensors">Використовувати сенсори пристрою</string>
-    <string name="prefs_other_switch_night_mode">Увімкнути червоний нічний фільтр</string>
+    <string name="prefs_other_title">Інше</string>
+    <string name="prefs_other_switch_utc">Час в UTC</string>
+    <string name="prefs_other_switch_update">Автооновлення даних</string>
+    <string name="prefs_other_switch_sweep">Анімація радара</string>
+    <string name="prefs_other_switch_sensors">Сенсори</string>
+    <string name="prefs_other_switch_night_mode">Нічний фільтр</string>

    <string name="prefs_highlight_title">Підсвічування висоти</string>
    <string name="prefs_highlight_low">Низько &lt; %1$d°</string>
@@ -9,20 +9,62 @@
    <string name="nav_sat">卫星</string>
    <string name="nav_pass">过境</string>
    <string name="nav_radar">雷达</string>
-    <string name="nav_mutual">匹配</string>
    <string name="nav_map">地图</string>
    <string name="nav_prefs">设置</string>

+    <!-- AMSAT Status screen -->
+    <string name="nav_amsat">AMSAT</string>
+    <string name="amsat_title">AMSAT 卫星状态</string>
+    <string name="amsat_refresh">刷新</string>
+    <string name="amsat_retry">重试</string>
+    <string name="amsat_updated">更新于：</string>
+    <string name="amsat_active">活跃</string>
+    <string name="amsat_tlm">遥测/信标</string>
+    <string name="amsat_not_heard">未听到</string>
+    <string name="amsat_conflict">冲突</string>
+    <string name="amsat_name">名称</string>
+    <string name="amsat_load_failed">加载失败 - 检查网络后重试</string>
+    <string name="amsat_no_reports">此时间段无报告</string>
+    <string name="amsat_close">关闭</string>
+    <string name="amsat_status_heard">已听到</string>
+    <string name="amsat_status_tlm_only">仅遥测</string>
+    <string name="amsat_status_not_heard">未听到</string>
+    <string name="amsat_status_crew_active">乘组活跃</string>
+    <string name="amsat_upload">上传</string>
+    <string name="amsat_upload_back">返回</string>
+    <string name="amsat_upload_report">上传报告到 AMSAT</string>
+    <string name="amsat_upload_status">状态</string>
+    <string name="amsat_upload_callsign">呼号</string>
+    <string name="amsat_upload_grid">网格</string>
+    <string name="amsat_upload_time_now">时间：当前 UTC %s</string>
+    <string name="amsat_upload_submit">提交到 AMSAT</string>
+    <string name="amsat_upload_confirm">确认上传</string>
+    <string name="amsat_upload_confirm_title">确认上传到 AMSAT</string>
+    <string name="amsat_upload_confirm_message">这条公开报告将上传到 AMSAT。\n卫星：%1$s\n状态：%2$s\n呼号：%3$s\n网格：%4$s</string>
+    <string name="amsat_upload_grid_none">未填写</string>
+    <string name="amsat_upload_success">报告已上传</string>
+    <string name="amsat_upload_failed">上传失败：%s</string>
+    <string name="amsat_upload_callsign_required">请填写呼号</string>
+    <string name="amsat_upload_grid_invalid">网格应为 4 或 6 位 Maidenhead 定位符</string>
+    <string name="amsat_upload_active">活跃</string>
+    <string name="amsat_upload_tlm">遥测/信标</string>
+    <string name="amsat_upload_not_heard">未听到</string>
+    <string name="amsat_upload_crew_active">ISS 语音</string>
+
    <!-- Satellites screen -->
-    <string name="sat_type_hint">类型：%s</string>
-    <string name="sat_type_title">选择卫星类型</string>
+    <string name="sat_type_hint">模式：%s</string>
+    <string name="sat_type_title">选择模式</string>
    <string name="sat_search_hint">Id - 名称</string>
    <string name="sat_search_clear">清空</string>
    <string name="sat_clear_all">全部清空</string>
    <string name="sat_select_all">全选</string>
+    <string name="sat_group_selected">已选择</string>
+    <string name="sat_group_available">可用</string>
+    <string name="sat_group_selected_count">已选择（%1$d）</string>
+    <string name="sat_group_available_count">可用（%1$d）</string>
    <string name="sat_empty_list_message">请确保您的搜索查询正确且数据库已更新</string>
    <string name="sat_warning_title">警告\!</string>
-    <string name="sat_warning_message">此应用收录了超过9000颗卫星信息\n同时追踪所有卫星并不现实\n建议始终通过搜索和分类筛选功能仅勾选您感兴趣的卫星</string>
+    <string name="sat_warning_message">此应用收录了超过9000颗卫星信息\n同时追踪所有卫星并不现实\n建议始终通过搜索和模式筛选功能仅勾选您感兴趣的卫星</string>

    <!-- Passes screen -->
    <string name="pass_filter_title">筛选过境</string>
@@ -31,7 +73,7 @@
    <string name="pass_filter_aos_time">AOS 时间段</string>
    <string name="pass_filter_invert_time">反选 AOS 时间段</string>
    <string name="pass_filter_deep_space">DeepSpace（周期 &gt;225分钟）</string>
-    <string name="pass_modes_title">选择调制类型</string>
+    <string name="pass_modes_title">选择模式</string>
    <string name="pass_elevation">仰角：%.1f°</string>
    <string name="pass_altitude">高度：%d km</string>
    <string name="pass_empty_list_message">请确保您的过滤器设置正确，并且已选择卫星</string>
@@ -57,17 +99,27 @@
    <string name="radar_string_no">否</string>
    <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>
+    <!-- Radar screen (CAT control / SSTV) -->
+    <string name="radar_connect">连接</string>
+    <string name="radar_disconnect">断开连接</string>
+    <string name="radar_off">关</string>
+    <string name="radar_stop">停止</string>
+    <string name="radar_track">跟踪</string>
+    <string name="radar_tx_base">TX 基频：</string>
+
+    <!-- SSTV screen -->
+    <string name="sstv_grant_permission">授予权限</string>
+    <string name="sstv_listening">正在监听…</string>
+    <string name="sstv_mic_permission">需要麦克风权限</string>
+    <string name="sstv_mode_format">模式：%s</string>
+    <string name="sstv_mode_title">SSTV 模式</string>
+    <string name="sstv_no_signal">无信号</string>
+    <string name="sstv_no_transceiver">未选择收发器</string>
+    <string name="sstv_rx_format">RX：%s Hz</string>

    <!-- Map screen -->
    <string name="map_prev">上一个</string>
@@ -89,6 +141,12 @@
    <string name="prefs_donate_title">支持</string>
    <string name="prefs_privacy_title">隐私政策</string>

+    <string name="settings_paired_devices">已配对的蓝牙设备：</string>
+    <string name="settings_split_mode">分频模式（仅 IC-705）</string>
+    <string name="prefs_lat_prefix">纬度：%s°</string>
+    <string name="prefs_lon_prefix">经度：%s°</string>
+    <string name="prefs_qth_prefix">QTH：%s</string>
+
    <string name="prefs_updated_title">更新：%s</string>
    <string name="prefs_updated_time">yyyy MMM d - HH:mm:ss</string>

@@ -100,11 +158,11 @@
    <string name="prefs_loc_qth_title">QTH 网格</string>
    <string name="prefs_loc_qth_error">无效的 QTH 网格</string>
    <string name="prefs_loc_success">位置更新成功</string>
-    <string name="prefs_station_title">站点位置设置</string>
-    <string name="prefs_station_lat_text">输入站点的纬度</string>
-    <string name="prefs_station_lon_text">输入站点的经度</string>
-    <string name="prefs_locator_title">QTH 网格</string>
-    <string name="prefs_locator_text">使用梅登黑德网格设置站点位置</string>
+    <string name="prefs_station_title">站点位置</string>
+    <string name="prefs_station_lat_text">站点纬度</string>
+    <string name="prefs_station_lon_text">站点经度</string>
+    <string name="prefs_locator_title">QTH 定位</string>
+    <string name="prefs_locator_text">通过 QTH 设置站点位置</string>

    <string name="prefs_data_title">卫星数据更新</string>
    <string name="prefs_data_entries">卫星：%s</string>
@@ -114,20 +172,34 @@
    <string name="prefs_data_clear">清空</string>
    <string name="prefs_data_clear_success">数据清空成功</string>
    <string name="prefs_data_update_success">更新成功</string>
-
    <string name="prefs_data_import_satellites_error">未导入卫星。请选择有效的 TLE/3LE (.txt) 或 OMM (.csv) 文件。</string>
    <string name="prefs_data_import_transceivers_error">未导入收发器。请选择有效的 SatNOGS (.json) 文件。</string>

-    <string name="prefs_data_sources_title">自定义数据源</string>
-    <string name="prefs_data_sources_tle_switch">自定义TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">自定义收发器URL</string>
+    <string name="prefs_data_sources_title">自定义源</string>
+    <string name="prefs_data_sources_restore">恢复默认源</string>
+    <string name="prefs_data_sources_sat_title">卫星数据</string>
+    <string name="prefs_data_sources_transceivers_title">收发器数据</string>
+    <string name="prefs_data_sources_sat_hint">靠前优先：卫星名称</string>
+    <string name="prefs_data_sources_transceivers_hint">靠前优先：收发器数据</string>
+    <string name="prefs_data_sources_tle_switch">TLE URL</string>
+    <string name="prefs_data_sources_transceivers_switch">收发器 URL</string>
+    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>

    <string name="prefs_data_output_title">数据输出</string>
    <string name="prefs_net_output">网络</string>
    <string name="prefs_bt_output">蓝牙</string>
    <string name="prefs_cat_output">CAT</string>

-    <string name="prefs_net_title">网络数据输出</string>
+    <string name="nav_radiocontrol">电台控制</string>
+    <string name="rc_settings_title">CAT 控制</string>
+    <string name="rc_radio_model">电台型号</string>
+    <string name="rc_tx_device_hint">TX 电台蓝牙地址</string>
+    <string name="rc_rx_device_hint">RX 电台蓝牙地址</string>
+    <string name="rc_tx_name_hint">TX 电台名称</string>
+    <string name="rc_rx_name_hint">RX 电台名称</string>
+    <string name="rc_enable_switch">启用 CAT</string>
+
+    <string name="prefs_net_title">网络输出</string>
    <string name="prefs_net_rotator_switch">启用方位俯仰角输出</string>
    <string name="prefs_net_rotator_address_hint">IP:端口</string>
    <string name="prefs_net_rotator_format_hint">数据格式</string>
@@ -135,7 +207,7 @@
    <string name="prefs_net_frequency_address_hint">IP:端口</string>
    <string name="prefs_net_frequency_format_hint">数据格式</string>

-    <string name="prefs_bt_title">蓝牙数据输出</string>
+    <string name="prefs_bt_title">蓝牙输出</string>
    <string name="prefs_bt_rotator_switch">启用方位俯仰角输出</string>
    <string name="prefs_bt_rotator_device_hint">蓝牙设备 ID</string>
    <string name="prefs_bt_rotator_output_hint">数据格式</string>
@@ -145,22 +217,14 @@
    <string name="prefs_bt_perm_error">请检查蓝牙权限</string>
    <string name="prefs_net_perm_error">请检查网络权限</string>

-    <!-- Radio Control -->
-    <string name="nav_radiocontrol">电台控制</string>
-    <string name="rc_settings_title">CAT 电台控制</string>
-    <string name="rc_radio_model">电台型号</string>
-    <string name="rc_tx_device_hint">发射电台蓝牙地址</string>
-    <string name="rc_rx_device_hint">接收电台蓝牙地址</string>
-    <string name="rc_tx_name_hint">发射电台名称</string>
-    <string name="rc_rx_name_hint">接收电台名称</string>
-    <string name="rc_enable_switch">启用 CAT 控制</string>
-
-    <string name="prefs_other_title">其他设置</string>
-    <string name="prefs_other_switch_utc">以 UTC 时间显示</string>
-    <string name="prefs_other_switch_update">启用卫星数据自动更新</string>
-    <string name="prefs_other_switch_sweep">启用雷达扫描动画</string>
-    <string name="prefs_other_switch_sensors">使用传感器旋转雷达视图</string>
-    <string name="prefs_other_switch_night_mode">启用红色夜间模式</string>
+    <string name="prefs_other_title">其他</string>
+    <string name="prefs_other_switch_utc">UTC 时间</string>
+    <string name="prefs_other_switch_update">自动更新数据</string>
+    <string name="prefs_other_switch_sweep">雷达扫描动画</string>
+    <string name="prefs_other_switch_sensors">传感器控制雷达</string>
+    <string name="prefs_other_switch_night_mode">红色夜间模式</string>
+    <string name="prefs_other_compass_offset">雷达罗盘水平偏移量</string>
+    <string name="prefs_other_compass_offset_elev">雷达罗盘俯仰偏移量</string>

    <string name="prefs_highlight_title">仰角高亮</string>
    <string name="prefs_highlight_low">低 &lt; %1$d°</string>
@@ -174,41 +238,10 @@
        \n• Dave Moten (predict4java)
        \n• Alexandru Csete (Gpredict)
        \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)
-        \n• xdsopl 和 Robot36 贡献者!
-        \n• BG7NTA（CW解码功能）</string>
+        \n• Libre Space Foundation (SatNOGS)</string>
    <string name="prefs_outro_license">该应用程序不提供任何保修.</string>

-    <!-- 匹配页 Mutual match page -->
-    <string name="mutual_title">过境匹配</string>
-    <string name="mutual_station_you">你的位置</string>
-    <string name="mutual_station_opposite">友台位置</string>
-    <string name="mutual_label_you">你</string>
-    <string name="mutual_label_opposite">友台</string>
-    <string name="mutual_status_calculating">正在计算双方共同可见窗口…</string>
-    <string name="mutual_status_error">请修正提示后重新查询</string>
-    <string name="mutual_status_matches">找到 %d 个匹配 · 点击卡片展开曲线</string>
-    <string name="mutual_status_none">未找到共同可见窗口，调整时间或仰角后重试</string>
-    <string name="mutual_status_idle">输入双方位置后点击查询</string>
-    <string name="mutual_chip_calculating">计算中</string>
-    <string name="mutual_chip_error">有错误</string>
-    <string name="mutual_chip_matches">%d 个匹配</string>
-    <string name="mutual_chip_none">无匹配</string>
-    <string name="mutual_chip_idle">待查询</string>
-    <string name="mutual_use_current">填入当前位置</string>
-    <string name="mutual_lat">纬度</string>
-    <string name="mutual_lon">经度</string>
-    <string name="mutual_grid">网格</string>
-    <string name="mutual_grid_hint">支持 4/6/8 位 Maidenhead 网格；也可直接输入经纬度</string>
-    <string name="mutual_min_elevation">最小仰角：%d°</string>
-    <string name="mutual_time_range">时间范围</string>
-    <string name="mutual_calculating">计算中…</string>
-    <string name="mutual_query">查询匹配</string>
-    <string name="mutual_elevation_you">你：%d°</string>
-    <string name="mutual_elevation_opposite">友台：%d°</string>
-    <string name="mutual_both_tracks">双方轨迹</string>
-    <string name="mutual_open_radar">查看雷达</string>
-    <string name="mutual_station_a">站点A</string>
-    <string name="mutual_station_b">站点B</string>
+    <!-- Main screen -->
+    <string name="tracking_format">跟踪：%s</string>

 </resources>
@@ -10,24 +10,28 @@
    <string name="nav_sat">Satellites</string>
    <string name="nav_pass">Passes</string>
    <string name="nav_radar">Radar</string>
-    <string name="nav_mutual">Match</string>
    <string name="nav_map">Map</string>
    <string name="nav_prefs">Settings</string>
+    <string name="nav_status" translatable="false">AMSAT</string>

    <!-- Satellites screen -->
-    <string name="sat_type_hint">Type: %s</string>
-    <string name="sat_type_title">Select satellite type</string>
+    <string name="sat_type_hint">Modes: %s</string>
+    <string name="sat_type_title">Select modes</string>
    <string name="sat_search_hint">Id - Name</string>
    <string name="sat_search_clear">Clear</string>
    <string name="sat_clear_all">Clear all</string>
    <string name="sat_select_all">Select all</string>
+    <string name="sat_group_selected">Selected</string>
+    <string name="sat_group_available">Available</string>
+    <string name="sat_group_selected_count">Selected (%1$d)</string>
+    <string name="sat_group_available_count">Available (%1$d)</string>
    <string name="sat_empty_list_message">"Make sure your search query is correct and the DB is updated"</string>
    <string name="sat_warning_title">Warning\!</string>
    <string name="sat_warning_message">
        There are over 9000 satellites listed in this app.
        It makes no sense to track them all at the same time.
        \n\nAlways try to narrow down the list to only the ones
-        you\'re interested in via search and types selector.</string>
+        you\'re interested in via search and the modes selector.</string>

    <!-- Passes screen -->
    <string name="pass_filter_title">Filter passes</string>
@@ -37,7 +41,7 @@
    <string name="pass_filter_invert_time">Invert AOS window</string>
    <string name="pass_filter_deep_space">DeepSpace (period >225min)</string>
    <string name="pass_time_placeholder" translatable="false"> -- : -- : -- </string>
-    <string name="pass_modes_title">Select modulation type</string>
+    <string name="pass_modes_title">Select modes</string>
    <string name="pass_satId" translatable="false">%05d</string>
    <string name="pass_elevation">Elevation: %.1f°</string>
    <string name="pass_deep_space" translatable="false">DeepSpace</string>
@@ -52,10 +56,55 @@
        \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
+        * Tweaked sunrise/sunset calculations, added tests by atsunatsu (#241)
+        \n\n* Overhauled sources import, added HTTP status by wty2019wty (#242)
+        \nSources now have priority - the top ones define satellite names and transceiver data.
+        \nYou can enable/disable sources and restore defaults via the Satellite data import dialog.
+        \n\n* Localized AMSAT status screen for Chinese by atsunatsu (#245)
+        \n\n* Extracted hardcoded UI strings to resources by TianhengZhuang (#247)
+        \n\n* Added AMSAT satellite status reports submission by atsunatsu (#248)
+        \n\n* Slightly optimized map performance to reduce ANRs and memory consumption. Zoom in to see satellite labels.
    </string>

+    <!-- AMSAT Status screen -->
+    <string name="nav_amsat">AMSAT</string>
+    <string name="amsat_title">AMSAT Satellite Status</string>
+    <string name="amsat_refresh">Refresh</string>
+    <string name="amsat_retry">Retry</string>
+    <string name="amsat_updated">Updated:</string>
+    <string name="amsat_active">Active</string>
+    <string name="amsat_tlm">TLM/Beacon</string>
+    <string name="amsat_not_heard">Not Heard</string>
+    <string name="amsat_conflict">Conflicting</string>
+    <string name="amsat_name">Name</string>
+    <string name="amsat_load_failed">Load failed - check network and retry</string>
+    <string name="amsat_no_reports">No reports for this period</string>
+    <string name="amsat_close">Close</string>
+    <string name="amsat_status_heard">Heard</string>
+    <string name="amsat_status_tlm_only">Telemetry Only</string>
+    <string name="amsat_status_not_heard">Not Heard</string>
+    <string name="amsat_status_crew_active">Crew Active</string>
+    <string name="amsat_upload">Upload</string>
+    <string name="amsat_upload_back">Back</string>
+    <string name="amsat_upload_report">Upload report to AMSAT</string>
+    <string name="amsat_upload_status">Status</string>
+    <string name="amsat_upload_callsign">Callsign</string>
+    <string name="amsat_upload_grid">Grid</string>
+    <string name="amsat_upload_time_now">Time: current UTC %s</string>
+    <string name="amsat_upload_submit">Submit to AMSAT</string>
+    <string name="amsat_upload_confirm">Upload</string>
+    <string name="amsat_upload_confirm_title">Confirm AMSAT upload</string>
+    <string name="amsat_upload_confirm_message">This public report will be uploaded to AMSAT.\nSatellite: %1$s\nStatus: %2$s\nCallsign: %3$s\nGrid: %4$s</string>
+    <string name="amsat_upload_grid_none">Not provided</string>
+    <string name="amsat_upload_success">Report uploaded</string>
+    <string name="amsat_upload_failed">Upload failed: %s</string>
+    <string name="amsat_upload_callsign_required">Callsign is required</string>
+    <string name="amsat_upload_grid_invalid">Grid must be a 4 or 6 character Maidenhead locator</string>
+    <string name="amsat_upload_active">Active</string>
+    <string name="amsat_upload_tlm">TLM/Beacon</string>
+    <string name="amsat_upload_not_heard">Not Heard</string>
+    <string name="amsat_upload_crew_active">Crew Active</string>
+
    <!-- Radar screen -->
    <string name="radar_back">Back</string>
    <string name="radar_notify">Notify</string>
@@ -81,16 +130,27 @@
    <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>
+    <!-- Radar screen (CAT control / SSTV) -->
+    <string name="radar_connect">Connect</string>
+    <string name="radar_disconnect">Disconnect</string>
+    <string name="radar_off">Off</string>
+    <string name="radar_stop">Stop</string>
+    <string name="radar_track">Track</string>
+    <string name="radar_tx_base">TX Base: </string>
+
+    <!-- SSTV screen -->
+    <string name="sstv_grant_permission">Grant permission</string>
+    <string name="sstv_listening">Listening…</string>
+    <string name="sstv_mic_permission">Microphone access needed</string>
+    <string name="sstv_mode_format">Mode: %s</string>
+    <string name="sstv_mode_title">SSTV Mode</string>
+    <string name="sstv_no_signal">No signal</string>
+    <string name="sstv_no_transceiver">No transceiver selected</string>
+    <string name="sstv_rx_format">RX: %s Hz</string>

    <!-- Map screen -->
    <string name="map_prev">Prev</string>
@@ -124,6 +184,12 @@
    <string name="prefs_privacy_title">Privacy Policy</string>
    <string name="prefs_privacy_url" translatable="false">https://sites.google.com/view/look4sat-privacy-policy/home</string>

+    <string name="settings_paired_devices">Paired Bluetooth Devices:</string>
+    <string name="settings_split_mode">Split mode (IC-705 only)</string>
+    <string name="prefs_lat_prefix">Lat: %s°</string>
+    <string name="prefs_lon_prefix">Lon: %s°</string>
+    <string name="prefs_qth_prefix">Qth: %s</string>
+
    <string name="prefs_updated_title">Updated: %s</string>
    <string name="prefs_updated_time">d MMM yyyy - HH:mm:ss</string>

@@ -135,11 +201,11 @@
    <string name="prefs_loc_qth_title">QTH</string>
    <string name="prefs_loc_qth_error">Invalid QTH locator</string>
    <string name="prefs_loc_success">Position updated successfully</string>
-    <string name="prefs_station_title">Station position settings</string>
-    <string name="prefs_station_lat_text">Set your ground station\'s latitude</string>
-    <string name="prefs_station_lon_text">Set your ground station\'s longitude</string>
-    <string name="prefs_locator_title">QTH locator settings</string>
-    <string name="prefs_locator_text">Set station\'s position using locator</string>
+    <string name="prefs_station_title">Station position</string>
+    <string name="prefs_station_lat_text">Station latitude</string>
+    <string name="prefs_station_lon_text">Station longitude</string>
+    <string name="prefs_locator_title">QTH locator</string>
+    <string name="prefs_locator_text">Set position via locator</string>

    <string name="prefs_data_title">Satellite data</string>
    <string name="prefs_data_entries">Satellites: %s</string>
@@ -152,10 +218,12 @@
    <string name="prefs_data_import_satellites_error">No satellites imported. Select a valid TLE/3LE (.txt) or OMM (.csv) file.</string>
    <string name="prefs_data_import_transceivers_error">No transceivers imported. Select a valid SatNOGS (.json) file.</string>

-    <string name="prefs_data_sources_title">Custom data sources</string>
-    <string name="prefs_data_sources_tle_switch">Custom TLE URL</string>
-    <string name="prefs_data_sources_transceivers_switch">Custom transceivers URL</string>
-    <string name="prefs_data_sources_url_title" translatable="false">URL (HTTPS)</string>
+    <string name="prefs_data_sources_title">Data sources</string>
+    <string name="prefs_data_sources_restore">Restore default sources</string>
+    <string name="prefs_data_sources_sat_title">Satellites data</string>
+    <string name="prefs_data_sources_transceivers_title">Transceivers data</string>
+    <string name="prefs_data_sources_sat_hint">Top priority affects satellite names</string>
+    <string name="prefs_data_sources_transceivers_hint">Top priority affects transceivers data</string>

    <string name="prefs_data_output_title">Data output</string>
    <string name="prefs_net_output">Network</string>
@@ -164,38 +232,42 @@

    <!-- Radio Control -->
    <string name="nav_radiocontrol">Radio Control</string>
-    <string name="rc_settings_title">CAT Radio Control</string>
+    <string name="rc_settings_title">CAT control</string>
    <string name="rc_radio_model">Radio Model</string>
-    <string name="rc_tx_device_hint">TX Radio BT Address</string>
-    <string name="rc_rx_device_hint">RX Radio BT Address</string>
+    <string name="rc_tx_device_hint">TX BT address</string>
+    <string name="rc_rx_device_hint">RX BT address</string>
    <string name="rc_tx_name_hint">TX Radio Name</string>
    <string name="rc_rx_name_hint">RX Radio Name</string>
-    <string name="rc_enable_switch">Enable CAT Control</string>
+    <string name="rc_enable_switch">Enable CAT</string>

-    <string name="prefs_net_title">Network data output</string>
+    <string name="prefs_net_title">Network output</string>
    <string name="prefs_net_rotator_switch">Enable rotation output</string>
    <string name="prefs_net_rotator_address_hint">IP:Port</string>
    <string name="prefs_net_rotator_format_hint">Format</string>
    <string name="prefs_net_frequency_switch">Enable frequency output</string>
    <string name="prefs_net_frequency_address_hint">IP:Port</string>
    <string name="prefs_net_frequency_format_hint">Format</string>
+    <string name="prefs_net_frequency_offset_hint" translatable="false">Frequency offset (Hz)</string>
+    <string name="prefs_net_frequency_offset_help" translatable="false">Range: -50000 to 50000 Hz. Positive values increase reported frequency; negative values decrease it.</string>

-    <string name="prefs_bt_title">Bluetooth data output</string>
+    <string name="prefs_bt_title">Bluetooth output</string>
    <string name="prefs_bt_rotator_switch">Enable rotation output</string>
-    <string name="prefs_bt_rotator_device_hint">Device id</string>
-    <string name="prefs_bt_rotator_output_hint">Data format</string>
+    <string name="prefs_bt_rotator_device_hint">Device ID</string>
+    <string name="prefs_bt_rotator_output_hint">Format</string>
    <string name="prefs_bt_frequency_switch">Enable frequency output</string>
-    <string name="prefs_bt_frequency_device_hint">Device id</string>
-    <string name="prefs_bt_frequency_output_hint">Data format</string>
+    <string name="prefs_bt_frequency_device_hint">Device ID</string>
+    <string name="prefs_bt_frequency_output_hint">Format</string>
    <string name="prefs_bt_perm_error">Check your bluetooth permission</string>
    <string name="prefs_net_perm_error">Check your network permission</string>

-    <string name="prefs_other_title">Other settings</string>
-    <string name="prefs_other_switch_utc">Show pass time in UTC</string>
-    <string name="prefs_other_switch_update">Enable automatic data update</string>
-    <string name="prefs_other_switch_sweep">Enable radar sweep animation</string>
-    <string name="prefs_other_switch_sensors">Use sensors to rotate radar view</string>
-    <string name="prefs_other_switch_night_mode">Enable red night mode filter</string>
+    <string name="prefs_other_title">Other</string>
+    <string name="prefs_other_switch_utc">UTC time</string>
+    <string name="prefs_other_switch_update">Auto-update data</string>
+    <string name="prefs_other_switch_sweep">Radar sweep</string>
+    <string name="prefs_other_switch_sensors">Use sensors</string>
+    <string name="prefs_other_switch_night_mode">Night filter</string>
+    <string name="prefs_other_compass_offset">Radar compass offset</string>
+    <string name="prefs_other_compass_offset_elev">Radar compass offset (elev)</string>

    <string name="prefs_highlight_title">Elevation highlight</string>
    <string name="prefs_highlight_low">Low &lt; %1$d°</string>
@@ -211,40 +283,10 @@
        \n* Dr T.S. Kelso (Celestrak)
        \n* Libre Space Foundation (SatNOGS)
        \n* xdsopl and Robot36 contributors!
-        \n* BG7NTA (CW decoding feature)
    </string>
    <string name="prefs_outro_license">The app comes with no warranty</string>

-    <!-- Mutual match page -->
-    <string name="mutual_title">Pass Match</string>
-    <string name="mutual_station_you">Your Station</string>
-    <string name="mutual_station_opposite">Opposite Station</string>
-    <string name="mutual_label_you">You</string>
-    <string name="mutual_label_opposite">Opposite</string>
-    <string name="mutual_status_calculating">Calculating mutual visibility windows…</string>
-    <string name="mutual_status_error">Fix the reported issues and retry</string>
-    <string name="mutual_status_matches">%d matches found · tap a card to expand</string>
-    <string name="mutual_status_none">No mutual windows found. Adjust time or min elevation and retry</string>
-    <string name="mutual_status_idle">Enter both stations, then tap Query</string>
-    <string name="mutual_chip_calculating">Calculating</string>
-    <string name="mutual_chip_error">Error</string>
-    <string name="mutual_chip_matches">%d matches</string>
-    <string name="mutual_chip_none">No matches</string>
-    <string name="mutual_chip_idle">Idle</string>
-    <string name="mutual_use_current">Use current</string>
-    <string name="mutual_lat">Lat</string>
-    <string name="mutual_lon">Lon</string>
-    <string name="mutual_grid">Grid</string>
-    <string name="mutual_grid_hint">Supports 4/6/8-char Maidenhead grid; or enter lat/lon directly</string>
-    <string name="mutual_min_elevation">Min elevation: %d°</string>
-    <string name="mutual_time_range">Time range</string>
-    <string name="mutual_calculating">Calculating…</string>
-    <string name="mutual_query">Query Match</string>
-    <string name="mutual_elevation_you">You: %d°</string>
-    <string name="mutual_elevation_opposite">Opposite: %d°</string>
-    <string name="mutual_both_tracks">Both tracks</string>
-    <string name="mutual_open_radar">Open Radar</string>
-    <string name="mutual_station_a">Station A</string>
-    <string name="mutual_station_b">Station B</string>
+    <!-- Main screen -->
+    <string name="tracking_format">Tracking: %s</string>

 </resources>
@@ -1,2 +1,5 @@
-* Added required tweaks to support Android 17 (API 37)
-* Added ACCESS_LOCAL_NETWORK permission check to support network data output
+* Tweaked sun calculations, added tests by atsunatsu (#241)
+* Overhauled sources import, added HTTP status by wty2019wty (#242)
+* Localized AMSAT status screen for Chinese by atsunatsu (#245)
+* Extracted hardcoded UI strings to resources by TianhengZhuang (#247)
+* Added AMSAT satellite status reports submission by atsunatsu (#248)
@@ -1,38 +0,0 @@
-import com.android.build.api.dsl.LibraryExtension
-import com.android.build.api.variant.CanProduceConsumerProguardFiles
-
-plugins {
-    alias(libs.plugins.convention.featurePlugin)
-}
-
-android {
-    namespace = "com.rtbishop.look4sat.feature.cw"
-    compileOptions {
-        encoding = "UTF-8"
-    }
-    // 照搬 Morse Expert 1.15: native 解码器仅 armeabi-v7a
-    defaultConfig {
-        ndk {
-            abiFilters += listOf("armeabi-v7a")
-        }
-    }
-}
-
-// CW 类保持规则(JNI 按类名注册 + 照搬混淆类保逻辑), 由 app 的 R8 消费
-// AGP 9: consumer 规则走 variant 级 CanProduceConsumerProguardFiles
-androidComponents {
-    onVariants(selector().all()) { variant ->
-        (variant as? CanProduceConsumerProguardFiles)?.consumerProguardFiles?.add(
-            project.layout.projectDirectory.file("proguard-rules.pro")
-        )
-    }
-}
-
-dependencies {
-    implementation("androidx.constraintlayout:constraintlayout:2.2.1")
-}
-
-// 照搬的 Java 源码含中文注释, 强制 UTF-8 编译(compileOptions 在部分 AGP 版本不生效)
-tasks.withType<JavaCompile>().configureEach {
-    options.encoding = "UTF-8"
-}
@@ -1,31 +0,0 @@
-# Look4Sat Pro — CW 解码模块(照搬 Morse Expert 1.15)混淆规则
-# 所有 CW 类保持原名: pas.* 通过 RegisterNatives 按类名注册 JNI(混淆即崩);
-# 其余为照搬的混淆名类(命名已无混淆意义, 保持以保逻辑完整)。
-
-# JNI 引擎(RegisterNatives 按类名/方法名查表)
-keep class pas.** { *; }
-
-# 照搬的解码/UI 类(全部保持)
-keep class com.ve3nea.morse_expert.** { *; }
-keep class H2.** { *; }
-keep class I2.b { *; }
-keep class J2.** { *; }
-keep class k3.** { *; }
-keep class i3.** { *; }
-keep class g3.** { *; }
-keep class j3.** { *; }
-keep class s.** { *; }
-keep class d1.AbstractC1518b { *; }
-keep class B0.b { *; }
-keep class B.RunnableC0001b { *; }
-keep class D.n { *; }
-keep class E2.g { *; }
-keep class F2.a { *; }
-keep class I0.d { *; }
-keep class K1.a { *; }
-keep class j1.C1646n { *; }
-
-# sun.misc stub(Android 无此类, 仅编译期; 防止 R8 异常处理)
-dontwarn sun.misc.**
-keep class sun.misc.Unsafe { *; }
-keep class sun.misc.Cleaner { *; }
@@ -1,63 +0,0 @@
-package B;
-
-import android.text.SpannableStringBuilder;
-import com.ve3nea.morse_expert.DecodedTextView;
-import com.ve3nea.morse_expert.MainActivity;
-import H2.b;
-
-/**
- * 照搬自 Morse Expert 1.15 B.RunnableC0001b, 类名保持混淆原名。
- * R8 合并 Runnable 手术: 构造按 smali 真实签名 5 参 (Object,Object,int,int,boolean),
- * 字段 = i(Object)/h(Object)/g(int)/f(int); run() 仅保留 case 4(f==2 对应 pswitch_4:
- * 解码文本 UI 更新, H2.b 调用), 其余 case(权限/Intent/通知等库代码)已裁剪。
- * 注: jadx 4 参构造为错误还原, 已按 smali 修正。
- */
-public final class RunnableC0001b implements Runnable {
-    public final /* synthetic */ int f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public final int g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public final Object h;
-
-    /* renamed from: i, reason: collision with root package name */
-    public final Object i;
-
-    public /* synthetic */ RunnableC0001b(Object obj, Object obj2, int i4, int i5, boolean z) {
-        this.i = obj;
-        this.h = obj2;
-        this.g = i4;
-        this.f = i5;
-    }
-
-    @Override // java.lang.Runnable
-    public final void run() {
-        if (this.f == 2) {
-            MainActivity mainActivity = ((b) this.i).f620p;
-            if (mainActivity != null) {
-                SpannableStringBuilder spannableStringBuilder = (SpannableStringBuilder) this.h;
-                int i5 = this.g;
-                DecodedTextView decodedTextView = (DecodedTextView) mainActivity.f11035D.f11888g;
-                if (!decodedTextView.f11032n && !decodedTextView.f11033o.get()) {
-                    decodedTextView.beginBatchEdit();
-                    try {
-                        int length2 = decodedTextView.length();
-                        int min = Math.min(length2, i5);
-                        if (min > 0) {
-                            decodedTextView.getEditableText().delete(length2 - min, length2);
-                        }
-                        decodedTextView.q(spannableStringBuilder);
-                        decodedTextView.endBatchEdit();
-                        return;
-                    } catch (Throwable th) {
-                        decodedTextView.endBatchEdit();
-                        throw th;
-                    }
-                }
-                return;
-            }
-            return;
-        }
-    }
-}
@@ -1,61 +0,0 @@
-package B0;
-
-import android.widget.TextView;
-import com.ve3nea.morse_expert.MainActivity;
-import com.ve3nea.morse_expert.ScaleView;
-import java.util.Locale;
-import d1.AbstractC1518b;
-
-/**
- * 照搬自 Morse Expert 1.15 B0.b, 类名保持混淆原名。
- * R8 合并 Runnable 手术: 构造按 smali 真实签名 (H2/b, String, [I) -> f=4;
- * 只保留 case 4(状态栏更新: dBFS/Hz/dB/WPM + ScaleView 频率标记, H2.b 调用),
- * 其余 case(WorkManager/动画等库代码)已裁剪。
- * r3 = scaleView.getHeight()(smali 证实, jadx 寄存器未展开)。
- */
-public final class b implements Runnable {
-    public final /* synthetic */ int f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public final Object g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public final Object h;
-
-    /* renamed from: i, reason: collision with root package name */
-    public final Object i;
-
-    public b(H2.b bVar, String str, int[] iArr) {
-        this.f = 4;
-        this.g = bVar;
-        this.h = iArr;
-        this.i = str;
-    }
-
-    @Override // java.lang.Runnable
-    public final void run() {
-        if (this.f == 4) {
-            MainActivity mainActivity = ((H2.b) this.g).f621q;
-            if (mainActivity != null) {
-                String str2 = (String) this.i;
-                int[] iArr = (int[]) this.h;
-                String concat;
-                String format = String.format(Locale.US, " %3d dBFS", Integer.valueOf(iArr[0]));
-                if (iArr[5] == 0) {
-                    concat = format.concat("  Idle    ");
-                } else {
-                    concat = format.concat(String.format(Locale.US, "    %4d Hz    %2d dB    %2d WPM    ", Integer.valueOf(iArr[1]), Integer.valueOf(iArr[2]), Integer.valueOf(iArr[3])));
-                }
-                ((TextView) mainActivity.f11035D.f11890i).setText(AbstractC1518b.e(concat, str2));
-                ScaleView scaleView = (ScaleView) mainActivity.f11035D.f11889h;
-                int i4 = iArr[1];
-                scaleView.f11041g = iArr[5];
-                // r3 = scaleView.getHeight()(smali 证实)
-                scaleView.f = (scaleView.getHeight() - 1) - Math.round(((Math.round(i4 * 0.128f) - H2.b.f606z) * scaleView.getHeight()) / H2.b.f603B);
-                scaleView.invalidate();
-                return;
-            }
-            return;
-        }
-    }
-}
@@ -1,69 +0,0 @@
-package D;
-
-import android.graphics.Bitmap;
-import android.opengl.GLES20;
-import android.opengl.GLUtils;
-import com.ve3nea.morse_expert.WaterfallSurfaceView;
-
-/**
- * 照搬自 Morse Expert 1.15, 类名保持混淆原名。
- * R8 合并 Runnable 手术: 只保留 case 1(瀑布图频谱->OpenGL 纹理, H2.b 调用),
- * 其余 case(库/广告)已裁剪。
- */
-public final /* synthetic */ class n implements Runnable {
-    public final /* synthetic */ int f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public final /* synthetic */ Object f224g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public final /* synthetic */ Object f225h;
-
-    public /* synthetic */ n(Object obj, int i4, Object obj2) {
-        this.f = i4;
-        this.f224g = obj;
-        this.f225h = obj2;
-    }
-
-    @Override // java.lang.Runnable
-    public final void run() {
-        int i4 = this.f;
-        Object obj = this.f225h;
-        Object obj2 = this.f224g;
-        if (i4 == 1) {
-            float[] fArr = (float[]) obj;
-            J2.b bVar = ((WaterfallSurfaceView) obj2).f;
-            Bitmap bitmap = bVar.f733h;
-            int width = bVar.f730d.getWidth();
-            double d4 = width;
-            double b4 = (bVar.b() + 4.0d) % d4;
-            double d5 = bVar.f737l - b4;
-            if (d5 > d4 / 2.0d) {
-                d5 -= d4;
-            } else if (d5 < (-width) / 2.0d) {
-                d5 += d4;
-            }
-            if (Math.abs(d5) > 8.0d) {
-                bVar.f737l = (int) Math.floor(b4);
-            } else {
-                bVar.f732g = (d5 * 1.0E-5d) + bVar.f732g;
-            }
-            int height = bitmap.getHeight() - 1;
-            for (int i5 = 0; i5 <= height; i5++) {
-                J2.a aVar = bVar.f734i;
-                int round = Math.round((fArr[i5] * 4.0f) + 30.0f);
-                aVar.getClass();
-                bitmap.setPixel(0, height - i5, aVar.f727a[Math.max(0, Math.min(255, round))]);
-            }
-            int i6 = bVar.f737l;
-            GLES20.glBindTexture(3553, bVar.f728a[0]);
-            J2.b.a();
-            GLUtils.texSubImage2D(3553, 0, i6, 0, bitmap);
-            J2.b.a();
-            int i7 = bVar.f737l + 1;
-            bVar.f737l = i7;
-            bVar.f737l = i7 % width;
-            return;
-        }
-    }
-}
@@ -1,44 +0,0 @@
-package E2;
-
-import android.util.Log;
-import android.view.MotionEvent;
-import android.view.View;
-import com.ve3nea.morse_expert.MainActivity;
-import com.ve3nea.morse_expert.ScaleView;
-
-/**
- * 照搬自 Morse Expert 1.15 (com.ve3nea.morse_expert), 类名保持混淆原名。
- * R8 合并类手术: 只保留 case 1(瀑布图触摸选频率=应用逻辑),
- * 其余 case(广告 P4 / appcompat 焦点 / 弹窗)为库代码, 已裁剪。
- */
-public final class g implements View.OnTouchListener {
-    public final /* synthetic */ int f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public final /* synthetic */ Object f411g;
-
-    public /* synthetic */ g(Object obj, int i4) {
-        this.f = i4;
-        this.f411g = obj;
-    }
-
-    @Override // android.view.View.OnTouchListener
-    public final boolean onTouch(View view, MotionEvent motionEvent) {
-        int i4 = this.f;
-        Object obj = this.f411g;
-        if (i4 == 1) {
-            MainActivity mainActivity = (MainActivity) obj;
-            if (motionEvent.getActionMasked() == 0 && mainActivity.f11037F != null) {
-                // smali 证实: p1 先被重赋值为 f11035D.h(ScaleView)再 getHeight;
-                // 公式 = round((f606z + ((scaleH-1-y)*f603B/scaleH)) / 0.128f)
-                ScaleView scaleView = (ScaleView) mainActivity.f11035D.f11889h;
-                float y3 = motionEvent.getY();
-                int round = Math.round((H2.b.f606z + ((((scaleView.getHeight() - 1) - y3) * H2.b.f603B) / scaleView.getHeight())) / 0.128f);
-                mainActivity.f11037F.f622r.set(round);
-                Log.i("Waterfall", String.format("Touch at %d Hz`", Integer.valueOf(round)));
-            }
-            return false;
-        }
-        return false;
-    }
-}
@@ -1,53 +0,0 @@
-package F2;
-
-import com.rtbishop.look4sat.feature.cw.R;
-import android.view.ActionMode;
-import android.view.Menu;
-import android.view.MenuItem;
-import com.ve3nea.morse_expert.DecodedTextView;
-
-/* loaded from: classes.dex */
-public final class a implements ActionMode.Callback {
-
-    /* renamed from: a, reason: collision with root package name */
-    public final /* synthetic */ DecodedTextView f564a;
-
-    public a(DecodedTextView decodedTextView) {
-        this.f564a = decodedTextView;
-    }
-
-    @Override // android.view.ActionMode.Callback
-    public final boolean onActionItemClicked(ActionMode actionMode, MenuItem menuItem) {
-        int itemId = menuItem.getItemId();
-        DecodedTextView decodedTextView = this.f564a;
-        if (itemId != 73) {
-            if (itemId != 74) {
-                return false;
-            }
-            decodedTextView.s();
-            return true;
-        }
-        decodedTextView.r();
-        actionMode.finish();
-        return true;
-    }
-
-    @Override // android.view.ActionMode.Callback
-    public final boolean onCreateActionMode(ActionMode actionMode, Menu menu) {
-        this.f564a.f11032n = true;
-        // 原: if (menu.findItem(R.id.shareText) == null) 检查(shareText 为原 APK 资源, 简化后始终添加)
-        menu.add(0, 74, 0, "Share").setIcon(R.drawable.ic_baseline_share_24);
-        menu.add(0, 73, 0, "Save").setIcon(R.drawable.ic_baseline_save_24);
-        return true;
-    }
-
-    @Override // android.view.ActionMode.Callback
-    public final void onDestroyActionMode(ActionMode actionMode) {
-        this.f564a.f11032n = false;
-    }
-
-    @Override // android.view.ActionMode.Callback
-    public final boolean onPrepareActionMode(ActionMode actionMode, Menu menu) {
-        return false;
-    }
-}
@@ -1,82 +0,0 @@
-package H2;
-
-import android.media.AudioRecord;
-import android.util.Log;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/* loaded from: classes.dex */
-public final class a implements Runnable {
-    public final int f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public final AudioRecord f596g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public final ExecutorService f597h;
-
-    /* renamed from: i, reason: collision with root package name */
-    public final AtomicBoolean f598i;
-
-    /* renamed from: j, reason: collision with root package name */
-    public final short[] f599j;
-
-    /* renamed from: k, reason: collision with root package name */
-    public final float[] f600k;
-
-    /* renamed from: l, reason: collision with root package name */
-    public b f601l;
-
-    public a() {
-        int minBufferSize = AudioRecord.getMinBufferSize(8000, 16, 2);
-        int i4 = b.f604C;
-        this.f = i4;
-        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
-        this.f597h = newSingleThreadExecutor;
-        AtomicBoolean atomicBoolean = new AtomicBoolean(false);
-        this.f598i = atomicBoolean;
-        this.f599j = new short[i4];
-        this.f600k = new float[i4];
-        AudioRecord audioRecord = new AudioRecord(1, 8000, 16, 2, minBufferSize * 4);
-        this.f596g = audioRecord;
-        if (audioRecord.getState() == 1) {
-            audioRecord.startRecording();
-            if (audioRecord.getState() != 1) {
-                Log.e("AudioRecord", "cannot start");
-            }
-            atomicBoolean.set(true);
-            newSingleThreadExecutor.execute(this);
-            return;
-        }
-        Log.e("AudioInput", "Failed to initialize");
-    }
-
-    @Override // java.lang.Runnable
-    public final void run() {
-        while (true) {
-            try {
-                if (this.f598i.get()) {
-                    float[] fArr = this.f600k;
-                    AudioRecord audioRecord = this.f596g;
-                    short[] sArr = this.f599j;
-                    int i4 = this.f;
-                    if (audioRecord.read(sArr, 0, i4) == i4) {
-                        for (int i5 = 0; i5 < i4; i5++) {
-                            fArr[i5] = sArr[i5] / 32768.0f;
-                        }
-                        b bVar = this.f601l;
-                        if (bVar != null) {
-                            bVar.a(fArr);
-                        }
-                    }
-                } else {
-                    TimeUnit.MILLISECONDS.sleep(100L);
-                }
-            } catch (Exception e4) {
-                Log.e("Audio thread", "Exception: ", e4);
-            }
-        }
-    }
-}
@@ -1,582 +0,0 @@
-package H2;
-
-import B.RunnableC0001b;
-import D.n;
-import android.content.Context;
-import android.media.MediaScannerConnection;
-import android.os.Handler;
-import android.os.Looper;
-import android.text.SpannableStringBuilder;
-import android.text.format.DateFormat;
-import android.text.style.ForegroundColorSpan;
-import android.util.Log;
-import com.ve3nea.morse_expert.MainActivity;
-import com.ve3nea.morse_expert.WaterfallSurfaceView;
-import i3.d;
-import java.io.BufferedOutputStream;
-import java.io.DataOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import k3.s;
-import pas.decoder;
-import pas.nativedecoder;
-
-/* loaded from: classes.dex */
-public final class b {
-
-    /* renamed from: A, reason: collision with root package name */
-    public static final int f602A;
-
-    /* renamed from: B, reason: collision with root package name */
-    public static final int f603B;
-
-    /* renamed from: C, reason: collision with root package name */
-    public static final int f604C;
-
-    /* renamed from: D, reason: collision with root package name */
-    public static final d f605D;
-
-    /* renamed from: z, reason: collision with root package name */
-    public static final int f606z;
-
-    /* renamed from: a, reason: collision with root package name */
-    public final float[] f607a;
-
-    /* renamed from: b, reason: collision with root package name */
-    public final float[] f608b;
-    public final float[] c;
-
-    /* renamed from: d, reason: collision with root package name */
-    public final float[] f609d;
-
-    /* renamed from: e, reason: collision with root package name */
-    public final nativedecoder.TNativeDecoder f610e;
-    public int f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public int f611g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public int f612h;
-
-    /* renamed from: i, reason: collision with root package name */
-    public decoder.TDecoderState f613i;
-
-    /* renamed from: j, reason: collision with root package name */
-    public String f614j;
-
-    /* renamed from: k, reason: collision with root package name */
-    public final c f615k;
-
-    /* renamed from: l, reason: collision with root package name */
-    public int f616l;
-
-    /* renamed from: m, reason: collision with root package name */
-    public final I2.b f617m;
-
-    /* renamed from: n, reason: collision with root package name */
-    public final Handler f618n;
-
-    /* renamed from: o, reason: collision with root package name */
-    public WaterfallSurfaceView f619o;
-
-    /* renamed from: p, reason: collision with root package name */
-    public MainActivity f620p;
-
-    /* renamed from: q, reason: collision with root package name */
-    public MainActivity f621q;
-
-    /* renamed from: r, reason: collision with root package name */
-    public final AtomicInteger f622r;
-
-    /* renamed from: s, reason: collision with root package name */
-    public final AtomicBoolean f623s;
-
-    /* renamed from: t, reason: collision with root package name */
-    public final Context f624t;
-
-    /* renamed from: u, reason: collision with root package name */
-    public int f625u;
-
-    /* renamed from: v, reason: collision with root package name */
-    public final AtomicBoolean f626v;
-
-    /* renamed from: w, reason: collision with root package name */
-    public DataOutputStream f627w;
-
-    /* renamed from: x, reason: collision with root package name */
-    public int f628x;
-
-    /* renamed from: y, reason: collision with root package name */
-    public String f629y;
-
-    /* JADX WARN: Removed duplicated region for block: B:14:0x012d  */
-    /* JADX WARN: Type inference failed for: r0v4, types: [i3.d, java.lang.Object] */
-    static {
-        boolean z3;
-        float f;
-        float f4;
-        float f5;
-        int round = Math.round(25.6f);
-        f606z = round;
-        int round2 = Math.round(153.6f);
-        f602A = round2;
-        f603B = round2 - round;
-        f604C = Math.round(85.333336f);
-        i3.d obj = new i3.d();
-        if (2048 > 1073741824) {
-            z3 = true;
-        } else {
-            z3 = false;
-        }
-        obj.f11709l = z3;
-        int i4 = (int) 1024;
-        obj.f11700a = i4;
-        obj.f11701b = 1024L;
-        if (!z3) {
-            obj.f11708k = 1;
-            int[] iArr = new int[((int) g3.c.a((1 << (((int) (g3.c.d(((float) 1024) + 0.5f) / g3.c.d(2.0d))) / 2)) + 2)) + 2];
-            obj.c = iArr;
-            float[] fArr = new float[i4];
-            obj.f11703e = fArr;
-            int i5 = (i4 * 2) >> 2;
-            obj.f11704g = i5;
-            iArr[0] = i5;
-            iArr[1] = 1;
-            if (i5 > 2) {
-                int i6 = i5 >> 1;
-                float f6 = 0.7853982f / i6;
-                float f7 = 2.0f * f6;
-                float b4 = (float) g3.c.b(i6 * f6);  // r9 = i6 (smali)
-                fArr[0] = 1.0f;
-                fArr[1] = b4;
-                if (i6 == 4) {
-                    double d4 = f7;
-                    f4 = 0.5f;
-                    fArr[2] = (float) g3.c.b(d4);
-                    fArr[3] = (float) g3.c.f(d4);
-                } else {
-                    f4 = 0.5f;
-                    if (i6 > 4) {
-                        iArr[2] = 0;
-                        iArr[3] = 16;
-                        int i7 = i5;
-                        int i8 = 2;
-                        f5 = 1.0f;
-                        while (i7 > 32) {
-                            int i9 = i8 << 1;
-                            int i10 = i8 << 4;
-                            for (int i11 = i8; i11 < i9; i11++) {
-                                int i12 = iArr[i11] << 2;
-                                iArr[i8 + i11] = i12;
-                                iArr[i9 + i11] = i12 + i10;
-                            }
-                            i7 >>= 2;
-                            i8 = i9;
-                        }
-                        fArr[2] = 0.5f / ((float) g3.c.b(f7));
-                        fArr[3] = 0.5f / ((float) g3.c.b(6.0f * f6));
-                        for (int i13 = 4; i13 < i6; i13 += 4) {
-                            float f8 = i13 * f6;
-                            double d5 = f8;
-                            fArr[i13] = (float) g3.c.b(d5);
-                            fArr[i13 + 1] = (float) g3.c.f(d5);
-                            double d6 = 3.0f * f8;
-                            fArr[i13 + 2] = (float) g3.c.b(d6);
-                            fArr[i13 + 3] = -((float) g3.c.f(d6));
-                        }
-                        int i14 = 0;
-                        while (i6 > 2) {
-                            int i15 = i14 + i6;
-                            i6 >>= 1;
-                            fArr[i15] = f5;
-                            fArr[i15 + 1] = b4;
-                            if (i6 == 4) {
-                                float f9 = fArr[i14 + 4];
-                                float f10 = fArr[i14 + 5];
-                                fArr[i15 + 2] = f9;
-                                fArr[i15 + 3] = f10;
-                            } else if (i6 > 4) {
-                                float f11 = fArr[i14 + 4];
-                                float f12 = fArr[i14 + 6];
-                                fArr[i15 + 2] = f4 / f11;
-                                fArr[i15 + 3] = f4 / f12;
-                                for (int i16 = 4; i16 < i6; i16 += 4) {
-                                    int i17 = (i16 * 2) + i14;
-                                    int i18 = i15 + i16;
-                                    float f13 = fArr[i17];
-                                    float f14 = fArr[i17 + 1];
-                                    float f15 = fArr[i17 + 2];
-                                    float f16 = fArr[i17 + 3];
-                                    fArr[i18] = f13;
-                                    fArr[i18 + 1] = f14;
-                                    fArr[i18 + 2] = f15;
-                                    fArr[i18 + 3] = f16;
-                                }
-                            }
-                            i14 = i15;
-                        }
-                    }
-                }
-                f5 = 1.0f;
-                int i142 = 0;
-                while (i6 > 2) {
-                }
-            }
-            int i19 = i4 >> 2;
-            obj.f11706i = i19;
-            iArr[1] = i19;
-            if (i19 > 1) {
-                int i20 = i19 >> 1;
-                float f17 = 0.7853982f / i20;
-                float b5 = (float) g3.c.b(i20 * f17);  // r6 = i20 (smali)
-                fArr[i5] = b5;
-                fArr[i5 + i20] = b5 * 0.5f;
-                for (int i21 = 1; i21 < i20; i21++) {
-                    double d7 = i21 * f17;
-                    fArr[i5 + i21] = ((float) g3.c.b(d7)) * 0.5f;
-                    fArr[(i5 + i19) - i21] = ((float) g3.c.f(d7)) * 0.5f;
-                }
-            }
-        } else {
-            obj.f11708k = 1;
-            s sVar = new s(((long) g3.c.a((1 << ((int) (((long) (g3.c.d(((float) 1024) + 0.5f) / g3.c.d(2.0d))) / 2))) + 2)) + 2, true);
-            obj.f11702d = sVar;
-            k3.d dVar = new k3.d(1024L, true);
-            obj.f = dVar;
-            obj.f11705h = 512L;
-            sVar.c(0L, 512L);
-            sVar.c(1L, 1L);
-            if (512 > 2) {
-                long j4 = 512 >> 1;
-                float f18 = 0.7853982f / ((float) j4);
-                float f19 = f18 * 2.0f;
-                float b6 = (float) g3.c.b(j4 * f18);  // r14 = j4 (smali 同模式)
-                dVar.c(0L, 1.0f);
-                dVar.c(1L, b6);
-                if (j4 == 4) {
-                    f = 0.5f;
-                    double d8 = f19;
-                    dVar.c(2L, (float) g3.c.b(d8));
-                    dVar.c(3L, (float) g3.c.f(d8));
-                } else {
-                    f = 0.5f;
-                    if (j4 > 4) {
-                        sVar.c(2L, 0L);
-                        sVar.c(3L, 16L);
-                        long j5 = 2;
-                        long j6 = 512;
-                        while (j6 > 32) {
-                            long j7 = j5 << 1;
-                            long j8 = j5 << 4;
-                            long j9 = j5;
-                            while (j9 < j7) {
-                                long b7 = sVar.b(j9) << 2;
-                                sVar.c(j5 + j9, b7);
-                                sVar.c(j7 + j9, b7 + j8);
-                                j9++;
-                                f19 = f19;
-                            }
-                            j6 >>= 2;
-                            j5 = j7;
-                        }
-                        dVar.c(2L, 0.5f / ((float) g3.c.b(f19)));
-                        dVar.c(3L, 0.5f / ((float) g3.c.b(6.0f * f18)));
-                        long j10 = 4;
-                        while (j10 < j4) {
-                            float f20 = ((float) j10) * f18;
-                            double d9 = f20;
-                            dVar.c(j10, (float) g3.c.b(d9));
-                            dVar.c(j10 + 1, (float) g3.c.f(d9));
-                            double d10 = 3.0f * f20;
-                            long j11 = j10;
-                            dVar.c(j10 + 2, (float) g3.c.b(d10));
-                            dVar.c(j11 + 3, -((float) g3.c.f(d10)));
-                            j10 = j11 + 4;
-                        }
-                    }
-                }
-                long j12 = 0;
-                long j13 = 2;
-                while (j4 > j13) {
-                    long j14 = j12 + j4;
-                    j4 >>= 1;
-                    dVar.c(j14, 1.0f);
-                    dVar.c(j14 + 1, b6);
-                    if (j4 == 4) {
-                        float b8 = dVar.b(j12 + 4);
-                        float b9 = dVar.b(j12 + 5);
-                        j13 = 2;
-                        dVar.c(j14 + 2, b8);
-                        dVar.c(j14 + 3, b9);
-                    } else {
-                        j13 = 2;
-                        if (j4 > 4) {
-                            float b10 = dVar.b(j12 + 4);
-                            float b11 = dVar.b(6 + j12);
-                            dVar.c(j14 + 2, f / b10);
-                            dVar.c(j14 + 3, f / b11);
-                            long j15 = 4;
-                            while (j15 < j4) {
-                                long j16 = (j15 * 2) + j12;
-                                float f21 = b6;
-                                long j17 = j14 + j15;
-                                long j18 = j12;
-                                float b12 = dVar.b(j16);
-                                long j19 = j14;
-                                float b13 = dVar.b(j16 + 1);
-                                float b14 = dVar.b(j16 + 2);
-                                float b15 = dVar.b(j16 + 3);
-                                dVar.c(j17, b12);
-                                dVar.c(j17 + 1, b13);
-                                dVar.c(j17 + 2, b14);
-                                dVar.c(j17 + 3, b15);
-                                j15 += 4;
-                                b6 = f21;
-                                j12 = j18;
-                                j14 = j19;
-                            }
-                        }
-                    }
-                    b6 = b6;
-                    j12 = j14;
-                }
-            }
-            long j20 = 256;
-            obj.f11707j = 256L;
-            long j21 = 1;
-            sVar.c(1L, 256L);
-            if (256 > 1) {
-                long j22 = 256 >> 1;
-                float f22 = 0.7853982f / ((float) j22);
-                long j23 = 512;
-                dVar.c(512L, (float) g3.c.b(j22 * f22));  // r1 = j22 (smali)
-                dVar.c(512 + j22, dVar.b(512L) * 0.5f);
-                long j24 = 1;
-                while (j24 < j22) {
-                    long j25 = j20;
-                    long j26 = j21;
-                    double d11 = ((float) j24) * f22;
-                    long j27 = j23;
-                    dVar.c(j23 + j24, ((float) g3.c.b(d11)) * 0.5f);
-                    dVar.c((j27 + j25) - j24, ((float) g3.c.f(d11)) * 0.5f);
-                    j24 += j26;
-                    j20 = j25;
-                    j21 = j26;
-                    j23 = j27;
-                }
-            }
-        }
-        f605D = obj;
-    }
-
-    public b(Context context) {
-        float[] fArr = new float[1024];
-        fArr[512] = 1.0f;
-        for (int i4 = 1; i4 < 512; i4++) {
-            double d4 = (i4 * 6.283185307179586d) / 1024;
-            float cos = (float) ((Math.cos(d4 * 2.0d) * 0.08d) + (0.42d - (Math.cos(d4) * 0.5d)));
-            fArr[i4] = cos;
-            double d5 = 0.003125f * 6.283185307179586d * (i4 - 512);
-            float sin = (float) ((Math.sin(d5) / d5) * cos);
-            fArr[i4] = sin;
-            fArr[1024 - i4] = sin;
-        }
-        this.f607a = fArr;
-        this.f608b = new float[1024];
-        this.c = new float[1024];
-        this.f609d = new float[f603B];
-        this.f610e = nativedecoder.TNativeDecoder.Create();
-        this.f614j = "";
-        this.f615k = new c(4000, 0);
-        I2.b bVar = new I2.b();
-        this.f617m = bVar;
-        this.f618n = new Handler(Looper.getMainLooper());
-        this.f622r = new AtomicInteger();
-        this.f623s = new AtomicBoolean(false);
-        this.f625u = 0;
-        this.f626v = new AtomicBoolean(false);
-        this.f628x = 0;
-        this.f624t = context;
-        bVar.b(context);
-    }
-
-    /* JADX WARN: Removed duplicated region for block: B:57:0x01e2  */
-    /* JADX WARN: Removed duplicated region for block: B:63:0x020a A[LOOP:6: B:62:0x0208->B:63:0x020a, LOOP_END] */
-    /* JADX WARN: Removed duplicated region for block: B:66:0x0216 A[LOOP:7: B:65:0x0214->B:66:0x0216, LOOP_END] */
-    /* JADX WARN: Removed duplicated region for block: B:70:0x0232  */
-    /* JADX WARN: Removed duplicated region for block: B:73:? A[RETURN, SYNTHETIC] */
-    /*
-        Code decompiled incorrectly, please refer to instructions dump.
-    */
-    public final void a(float[] fArr) {
-        c cVar;
-        float[] fArr2;
-        float[] fArr3;
-        b bVar;
-        Exception exc;
-        int i4;
-        float f;
-        int i5;
-        WaterfallSurfaceView waterfallSurfaceView;
-        int length = fArr.length;
-        int i6 = 0;
-        while (true) {
-            cVar = this.f615k;
-            if (i6 >= length) {
-                break;
-            }
-            cVar.c(Math.abs(fArr[i6]));
-            i6++;
-        }
-        this.f616l = Math.round(((float) Math.log10(Math.max(-0.5d, cVar.f633e))) * 20.0f);
-        int i7 = f604C;
-        int i8 = 1024 - i7;
-        float[] fArr4 = this.f608b;
-        System.arraycopy(fArr4, i7, fArr4, 0, i8);
-        System.arraycopy(fArr, 0, fArr4, i8, i7);
-        int i9 = 0;
-        while (true) {
-            fArr2 = this.c;
-            if (i9 >= 1024) {
-                break;
-            }
-            fArr2[i9] = fArr4[i9] * this.f607a[i9];
-            i9++;
-        }
-        f605D.k(fArr2, 0);
-        int i10 = f606z;
-        int i11 = i10;
-        while (true) {
-            int i12 = f602A;
-            float f4 = 0.0f;
-            fArr3 = this.f609d;
-            if (i11 < i12) {
-                int i13 = i11 * 2;
-                float f5 = fArr2[i13];
-                float f6 = fArr2[i13 + 1];
-                float f7 = ((f6 * f6) + (f5 * f5)) * 0.001f;
-                if (!Float.isNaN(f7)) {
-                    f4 = f7;
-                }
-                fArr3[i11 - i10] = f4;
-                i11++;
-            } else {
-                // smali: 循环内无 try; 录音写入 try 在循环后(见下)
-                break;
-            }
-        }
-        DataOutputStream dataOutputStream = this.f627w;
-        Context context = this.f624t;
-        AtomicBoolean atomicBoolean = this.f626v;
-        try { // smali try_start_0: 录音写入整块(原 jadx 误把 try 放 break 处)
-            if (dataOutputStream == null && atomicBoolean.get()) {
-                File file = new File(context.getExternalFilesDir(null), ((String) DateFormat.format("yyyy-MM-dd_HH_mm_ss", new Date())) + "_spectra.bin");
-                this.f629y = file.getAbsoluteFile().toString();
-                this.f627w = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file, false)));
-                this.f628x = 0;
-                this.f614j = " Recording...";
-            }
-            if (this.f627w != null) {
-                for (float f8 : fArr3) {
-                    this.f627w.writeFloat(f8);
-                }
-            }
-            if (atomicBoolean.get()) {
-                int i14 = this.f628x + 1;
-                this.f628x = i14;
-                if (i14 >= 2048) {
-                    atomicBoolean.set(false);
-                    this.f627w.close();
-                    this.f627w = null;
-                    this.f614j = "";
-                    MediaScannerConnection.scanFile(context, new String[]{this.f629y}, new String[]{"application/x-binary"}, null);
-                }
-            }
-        } catch (IOException e4) {
-            Log.e("File write", "Exception: ", e4);
-        }
-        nativedecoder.TNativeDecoder tNativeDecoder = this.f610e;
-        try {
-            this.f613i = tNativeDecoder.ProcessSpectrum(fArr3);
-            int i15 = this.f625u + 1;
-            this.f625u = i15;
-            Handler handler = this.f618n;
-            if (i15 == 15) {
-                try {
-                    this.f625u = 0;
-                    this.f = tNativeDecoder.getPitch();
-                    this.f611g = tNativeDecoder.getSnr();
-                    this.f612h = tNativeDecoder.getWpm();
-                    handler.post(new B0.b(this, this.f614j, new int[]{this.f616l, this.f, this.f611g, this.f612h, tNativeDecoder.getSignalCount(), this.f613i.Value}));
-                    AtomicInteger atomicInteger = this.f622r;
-                    int i16 = atomicInteger.get();
-                    if (i16 != 0) {
-                        tNativeDecoder.LockToPitch(i16);
-                        atomicInteger.set(0);
-                    }
-                    tNativeDecoder.setHamMode(this.f623s.get());
-                } catch (Exception e5) {
-                    // jadx 幻觉区(空循环/空 if 为 catch 错位还原)已裁剪; 原 smali: 记录异常后跳回正常流程尾部
-                    exc = e5;
-                    bVar = this;
-                    Log.e("Audio Processor", "Exception", exc);
-                }
-            }
-            int charCount = tNativeDecoder.getCharCount();
-            if (charCount > 0) {
-                SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
-                int i18 = 0;
-                while (i18 < charCount) {
-                    decoder.TCharInfo GetChar = tNativeDecoder.GetChar(i18);
-                    spannableStringBuilder.append(GetChar.getChar());
-                    ForegroundColorSpan foregroundColorSpan = new ForegroundColorSpan(this.f617m.a(GetChar));
-                    int i19 = i18 + 1;
-                    spannableStringBuilder.setSpan(foregroundColorSpan, i18, i19, 33);
-                    i18 = i19;
-                }
-                bVar = this;
-                try {
-                    handler.post(new RunnableC0001b(bVar, spannableStringBuilder, tNativeDecoder.getDeleteCount(), 2, false));
-                } catch (Exception e6) {
-                    // jadx 幻觉区已裁剪(同 catch e5); 原 smali: 记录异常后跳回正常流程尾部
-                    exc = e6;
-                    Log.e("Audio Processor", "Exception", exc);
-                }
-            } else {
-                bVar = this;
-            }
-        } catch (Exception e7) {
-            // jadx 幻觉(e 变量)已裁剪
-            bVar = this;
-        }
-        i4 = f603B;
-        int i1722 = i4 / 2;
-        float[] copyOfRange22 = Arrays.copyOfRange(fArr3, i1722 - 20, i1722 + 20);
-        Arrays.sort(copyOfRange22);
-        f = copyOfRange22[20];
-        if (f > 0.0f) {
-            for (int i20 = 0; i20 < i4; i20++) {
-                fArr3[i20] = fArr3[i20] / f;
-            }
-        }
-        float[] fArr522 = (float[]) fArr3.clone();
-        new c(12, 1).a(fArr522);
-        new c(12, 0).a(fArr522);
-        for (i5 = 0; i5 < i4; i5++) {
-            fArr3[i5] = fArr3[i5] - fArr522[i5];
-        }
-        for (int i21 = 0; i21 < i4; i21++) {
-            fArr3[i21] = ((float) Math.log10(Math.max(-0.5d, fArr3[i21]) + 1.0d)) * 10.0f;
-        }
-        waterfallSurfaceView = bVar.f619o;
-        if (waterfallSurfaceView != null) {
-            waterfallSurfaceView.queueEvent(new n(waterfallSurfaceView, 1, (float[]) fArr3.clone()));
-        }
-    }
-}
@@ -1,89 +0,0 @@
-package H2;
-
-/* loaded from: classes.dex */
-public final class c {
-
-    /* renamed from: a, reason: collision with root package name */
-    public final int f630a;
-
-    /* renamed from: b, reason: collision with root package name */
-    public float[] f631b;
-    public int c;
-
-    /* renamed from: d, reason: collision with root package name */
-    public float f632d;
-
-    /* renamed from: e, reason: collision with root package name */
-    public float f633e;
-    public final /* synthetic */ int f;
-
-    public c(int i4, int i5) {
-        this.f = i5;
-        this.f630a = i4 - 1;
-    }
-
-    public final void a(float[] fArr) {
-        int i4 = this.f630a / 2;
-        int length = fArr.length;
-        if (length > i4) {
-            this.f631b = null;
-            for (int i5 = 0; i5 < i4; i5++) {
-                c(fArr[i5]);
-            }
-            for (int i6 = i4; i6 < length; i6++) {
-                fArr[i6 - i4] = c(fArr[i6]);
-            }
-            for (int i7 = length; i7 < length + i4; i7++) {
-                fArr[i7 - i4] = c(fArr[length - 1]);
-            }
-            return;
-        }
-        throw new IllegalArgumentException("Sliding Filter error: input too short");
-    }
-
-    public final float b(float f, float f4) {
-        switch (this.f) {
-            case 0:
-                return Math.max(f, f4);
-            default:
-                return Math.min(f, f4);
-        }
-    }
-
-    public final float c(float f) {
-        float[] fArr = this.f631b;
-        int i4 = this.f630a;
-        if (fArr == null) {
-            this.f631b = new float[i4];
-            for (int i5 = 0; i5 < i4; i5++) {
-                this.f631b[i5] = f;
-            }
-            this.f632d = f;
-            return f;
-        }
-        float b4 = b(this.f632d, f);
-        this.f632d = b4;
-        this.f633e = b(this.f631b[this.c], b4);
-        float[] fArr2 = this.f631b;
-        int i6 = this.c;
-        int i7 = i6 + 1;
-        this.c = i7;
-        fArr2[i6] = f;
-        if (i7 == i4) {
-            int length = fArr2.length;
-            while (true) {
-                this.c = length - 1;
-                int i8 = this.c;
-                if (i8 <= 0) {
-                    break;
-                }
-                float[] fArr3 = this.f631b;
-                fArr3[i8 - 1] = b(fArr3[i8 - 1], fArr3[i8]);
-                length = this.c;
-            }
-            this.c = 0;
-            this.f632d = f;
-        }
-        return this.f633e;
-    }
-}
@@ -1,42 +0,0 @@
-package I0;
-
-/**
- * 照搬自 Morse Expert 1.15 I0.d, 类名保持混淆原名。
- * R8 合并类手术: 只保留 (i3.d, int, int, float[]) FFT 任务构造;
- * run() 按 smali 原样还原: R8 已将任务体优化为死代码(aget 后 throw null,
- * 永不执行), 保留原语义(行为与原 APK 完全一致)。
- * SystemForegroundService(work 库)case 已裁剪。
- */
-public final class d implements Runnable {
-    public final /* synthetic */ int f = 0;
-
-    /* renamed from: g, reason: collision with root package name */
-    public final /* synthetic */ int f653g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public final /* synthetic */ int f654h;
-
-    /* renamed from: i, reason: collision with root package name */
-    public final /* synthetic */ Object f655i;
-
-    /* renamed from: j, reason: collision with root package name */
-    public final /* synthetic */ Object f656j;
-
-    public d(i3.d dVar, int i4, int i5, float[] fArr) {
-        this.f656j = dVar;
-        this.f653g = i4;
-        this.f654h = i5;
-        this.f655i = fArr;
-    }
-
-    @Override // java.lang.Runnable
-    public final void run() {
-        int i6 = this.f654h;
-        int i7 = this.f653g;
-        if (i7 >= i6) {
-            return;
-        }
-        float f = ((float[]) this.f655i)[i7 * 2];
-        // R8 原代码: aget 后 throw null(死代码, 永不执行) —— 照搬语义, 不执行任何计算
-    }
-}
@@ -1,73 +0,0 @@
-package I2;
-
-import android.content.Context;
-import android.content.SharedPreferences;
-import pas.decoder;
-
-/* loaded from: classes.dex */
-public final class b {
-
-    /* renamed from: b, reason: collision with root package name */
-    public static final String[] f663b = {"bg_color", "text_color", "text_color_weak", "call_color", "call_color_weak", "cq_color", "cq_color_weak", "rst_color", "rst_color_weak"};
-    public static final String[] c = {"Background color", "Text color", "Text color, weak", "Callsign color", "Callsign color, weak", "CQ color", "CQ color, weak", "RST color", "RST color, weak"};
-
-    /* renamed from: d, reason: collision with root package name */
-    public static final int[] f664d = {-3084048, -16777216, -5592406, -65536, -30584, -16776961, -7829249, -65281, -30465};
-
-    /* renamed from: a, reason: collision with root package name */
-    public final int[] f665a = (int[]) f664d.clone();
-
-    public final int a(decoder.TCharInfo tCharInfo) {
-        boolean lowSnr = tCharInfo.getLowSnr();
-        int[] iArr = this.f665a;
-        if (lowSnr) {
-            int i4 = tCharInfo.getWordType().Value;
-            if (i4 != 0) {
-                if (i4 != 1) {
-                    if (i4 != 2) {
-                        if (i4 != 3) {
-                            if (i4 != 4) {
-                                if (i4 == 5) {
-                                    return iArr[4];
-                                }
-                                return -16777216;
-                            }
-                            return iArr[2];
-                        }
-                        return iArr[6];
-                    }
-                    return iArr[8];
-                }
-                return iArr[2];
-            }
-            return iArr[2];
-        }
-        int i5 = tCharInfo.getWordType().Value;
-        if (i5 != 0) {
-            if (i5 != 1) {
-                if (i5 != 2) {
-                    if (i5 != 3) {
-                        if (i5 != 4) {
-                            if (i5 != 5) {
-                                return -16777216;
-                            }
-                            return iArr[3];
-                        }
-                        return iArr[1];
-                    }
-                    return iArr[5];
-                }
-                return iArr[7];
-            }
-            return iArr[1];
-        }
-        return iArr[1];
-    }
-
-    public final void b(Context context) {
-        SharedPreferences sharedPreferences = context.getSharedPreferences(context.getPackageName() + "_preferences", 0);  // 原 c0.x.a(context)
-        for (int i4 = 0; i4 < 9; i4++) {
-            this.f665a[i4] = sharedPreferences.getInt(f663b[i4], f664d[i4]);
-        }
-    }
-}
@@ -1,45 +0,0 @@
-package J2;
-
-/* loaded from: classes.dex */
-public final class a {
-
-    /* renamed from: b, reason: collision with root package name */
-    public static final int[] f726b = {16, 17749, 65535, 16776960, 16711680};
-
-    /* renamed from: a, reason: collision with root package name */
-    public final int[] f727a;
-
-    public a() {
-        int[] iArr = new int[256];
-        this.f727a = iArr;
-        int i4 = 4;
-        float f = 255.0f / 4;
-        int[] iArr2 = f726b;
-        int i5 = 0;
-        int i6 = -16777216;
-        iArr[0] = iArr2[0] | (-16777216);
-        int i7 = 1;
-        while (i7 <= i4) {
-            int round = Math.round(i7 * f);
-            iArr[round] = iArr2[i7] | i6;
-            int i8 = round - i5;
-            int i9 = iArr[i5];
-            int i10 = (i9 >> 16) & 255;
-            int i11 = (i9 >> 8) & 255;
-            int i12 = i9 & 255;
-            float f4 = i8;
-            // r10 = iArr2[i7] (下一个锚点色, smali: aget v10, v4, v8)
-            float f5 = (((iArr2[i7] >> 16) & 255) - i10) / f4;
-            float f6 = (((iArr2[i7] >> 8) & 255) - i11) / f4;
-            float f7 = ((iArr2[i7] & 255) - i12) / f4;
-            for (int i13 = 1; i13 < i8; i13++) {
-                float f8 = i13;
-                iArr[i5 + i13] = ((Math.round(f5 * f8) + i10) << 16) | (-16777216) | ((Math.round(f6 * f8) + i11) << 8) | (Math.round(f8 * f7) + i12);
-            }
-            i7++;
-            i5 = round;
-            i4 = 4;
-            i6 = -16777216;
-        }
-    }
-}
@@ -1,183 +0,0 @@
-package J2;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.opengl.GLES20;
-import android.opengl.GLSurfaceView;
-import android.opengl.GLUtils;
-import android.os.SystemClock;
-import android.util.Log;
-import java.nio.Buffer;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.FloatBuffer;
-import javax.microedition.khronos.egl.EGLConfig;
-import javax.microedition.khronos.opengles.GL10;
-
-/* loaded from: classes.dex */
-public final class b implements GLSurfaceView.Renderer {
-
-    /* renamed from: b, reason: collision with root package name */
-    public FloatBuffer f729b;
-    public int c;
-
-    /* renamed from: d, reason: collision with root package name */
-    public final Bitmap f730d;
-    public final Context f;
-
-    /* renamed from: g, reason: collision with root package name */
-    public double f732g;
-
-    /* renamed from: h, reason: collision with root package name */
-    public final Bitmap f733h;
-
-    /* renamed from: i, reason: collision with root package name */
-    public final a f734i;
-
-    /* renamed from: j, reason: collision with root package name */
-    public long f735j;
-
-    /* renamed from: k, reason: collision with root package name */
-    public double f736k;
-
-    /* renamed from: l, reason: collision with root package name */
-    public int f737l;
-
-    /* renamed from: a, reason: collision with root package name */
-    public final int[] f728a = new int[1];
-
-    /* renamed from: e, reason: collision with root package name */
-    public final float[] f731e = {-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f};
-
-    public b(Context context, int i4) {
-        Bitmap.Config config = Bitmap.Config.ARGB_8888;
-        Bitmap createBitmap = Bitmap.createBitmap(2048, i4, config);
-        this.f730d = createBitmap;
-        createBitmap.eraseColor(16);
-        this.f732g = 0.09375d;
-        this.f734i = new a();
-        this.f735j = 0L;
-        this.f736k = 0.0d;
-        this.f737l = -1;
-        this.f = context;
-        this.f733h = Bitmap.createBitmap(1, i4, config);
-    }
-
-    public static void a() {
-        int glGetError = GLES20.glGetError();
-        if (glGetError != 0) {
-            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];
-            Log.e(stackTraceElement.getFileName() + ":" + stackTraceElement.getLineNumber(), ", GLES20 error: " + glGetError);
-        }
-    }
-
-    public final double b() {
-        long uptimeMillis = SystemClock.uptimeMillis();
-        double width = (((uptimeMillis - this.f735j) * this.f732g) + this.f736k) % this.f730d.getWidth();
-        this.f735j = uptimeMillis;
-        this.f736k = width;
-        return width;
-    }
-
-    public final void c(GL10 gl10) {
-        GLES20.glUseProgram(this.c);
-        a();
-        GLES20.glActiveTexture(33984);
-        a();
-        GLES20.glBindTexture(3553, this.f728a[0]);
-        a();
-        GLES20.glUniform1i(GLES20.glGetUniformLocation(this.c, "uTexture"), 0);
-        a();
-        int glGetAttribLocation = GLES20.glGetAttribLocation(this.c, "aPosition");
-        a();
-        int glGetAttribLocation2 = GLES20.glGetAttribLocation(this.c, "aTexPos");
-        a();
-        this.f729b.position(0);
-        a();
-        GLES20.glVertexAttribPointer(glGetAttribLocation, 2, 5126, false, 16, (Buffer) this.f729b);
-        a();
-        GLES20.glEnableVertexAttribArray(glGetAttribLocation);
-        a();
-        this.f729b.position(2);
-        a();
-        GLES20.glVertexAttribPointer(glGetAttribLocation2, 2, 5126, false, 16, (Buffer) this.f729b);
-        a();
-        GLES20.glEnableVertexAttribArray(glGetAttribLocation2);
-        a();
-        GLES20.glDrawArrays(5, 0, 4);
-        a();
-    }
-
-    public final void d(GL10 gl10, int i4, int i5) {
-        GLES20.glViewport(0, 0, i4, i5);
-        a();
-    }
-
-    @Override // android.opengl.GLSurfaceView.Renderer
-    public final void onDrawFrame(GL10 gl10) {
-        float b4 = (float) (b() / this.f730d.getWidth());
-        float f = 0.5f + b4;
-        float[] fArr = this.f731e;
-        fArr[6] = f;
-        fArr[2] = f;
-        float f4 = b4 + 1.0f;
-        fArr[14] = f4;
-        fArr[10] = f4;
-        this.f729b.position(0);
-        this.f729b.put(this.f731e);
-        c(gl10);
-    }
-
-    @Override // android.opengl.GLSurfaceView.Renderer
-    public final void onSurfaceChanged(GL10 gl10, int i4, int i5) {
-        d(gl10, i4, i5);
-        float width = 1.0f - (((this.f730d.getWidth() * 0.7f) / (i4 / this.f.getResources().getDisplayMetrics().density)) * 2.0f);
-        float[] fArr = this.f731e;
-        fArr[4] = width;
-        fArr[0] = width;
-        this.f729b.position(0);
-        this.f729b.put(this.f731e);
-    }
-
-    @Override // android.opengl.GLSurfaceView.Renderer
-    public final void onSurfaceCreated(GL10 gl10, EGLConfig eGLConfig) {
-        int glCreateShader = GLES20.glCreateShader(35633);
-        a();
-        GLES20.glShaderSource(glCreateShader, "attribute vec2 aPosition;\nattribute vec2 aTexPos;\nvarying vec2 vTexPos;\nvoid main() {\n  vTexPos = aTexPos;\n  gl_Position = vec4(aPosition.xy, 0.0, 1.0);\n}");
-        a();
-        GLES20.glCompileShader(glCreateShader);
-        a();
-        int glCreateShader2 = GLES20.glCreateShader(35632);
-        a();
-        GLES20.glShaderSource(glCreateShader2, "precision mediump float;\nuniform sampler2D uTexture;\nvarying vec2 vTexPos;\nvoid main(void)\n{\n  gl_FragColor = texture2D(uTexture, vTexPos);\n}");
-        a();
-        GLES20.glCompileShader(glCreateShader2);
-        a();
-        this.c = GLES20.glCreateProgram();
-        a();
-        GLES20.glAttachShader(this.c, glCreateShader);
-        a();
-        GLES20.glAttachShader(this.c, glCreateShader2);
-        a();
-        GLES20.glLinkProgram(this.c);
-        a();
-        int[] iArr = this.f728a;
-        GLES20.glGenTextures(1, iArr, 0);
-        a();
-        GLES20.glBindTexture(3553, iArr[0]);
-        a();
-        GLES20.glTexParameteri(3553, 10240, 9729);
-        GLES20.glTexParameteri(3553, 10242, 10497);
-        GLES20.glTexParameteri(3553, 10241, 9729);
-        GLES20.glTexParameteri(3553, 10243, 10497);
-        a();
-        GLUtils.texImage2D(3553, 0, this.f730d, 0);
-        a();
-        float[] fArr = this.f731e;
-        ByteBuffer allocateDirect = ByteBuffer.allocateDirect(fArr.length * 4);
-        allocateDirect.order(ByteOrder.nativeOrder());
-        FloatBuffer asFloatBuffer = allocateDirect.asFloatBuffer();
-        this.f729b = asFloatBuffer;
-        asFloatBuffer.put(fArr);
-    }
-}
@@ -1,10 +0,0 @@
-package K1;
-
-/**
- * 照搬自 Morse Expert 1.15 K1.a 精简版: 仅保留 k3 FFT 库引用的内存统计静态字段
- * (K1.a.c 长整型记账)。原 K1.a(828 行)的其余方法为状态栏/库代码, 已裁剪
- * (状态栏逻辑已在 MainActivity 内联)。
- */
-public class a {
-    public static long c = 0;
-}
@@ -1,213 +0,0 @@
-/*
- * CwDecodeScreen.kt — Look4Sat 的 CW 解码页面(Compose 外壳)。
- *
- * 照搬自 Morse Expert 1.15 的 com.ve3nea.morse_expert.MainActivity(已改为普通控制器类):
- * - AndroidView 嵌入原版 activity_main.xml(ConstraintLayout 根, 含 decodedTextView/scaleView/
- *   statusTextView/verticalLayout/waterfallView);
- * - 生命周期 onCreate/onResume/onPause/onDestroy 全部委托给控制器, 顺序与原 Activity 一致
- *   (onCreate 必须在 onResume 前, onDispose 先 onPause 再 onDestroy);
- * - 麦克风权限(RECORD_AUDIO)由 Compose 侧管理, 授予后调用 onPermissionGranted()(= v()),
- *   用 initialized 标记保证只调一次(v() 会 new a() 覆盖 f11036E);
- * - 原 options_menu 的 清除/暂停/保存/录音/设置 改为顶部一行按钮(图标用模块内原版 drawable)。
- *
- * 注意: 控制器 onCreate 内的 setImmersive(window, false) 会把宿主窗口恢复为
- * decorFitsSystemWindows(true)(原版行为照搬, 会对整个宿主 Activity 生效)。
- */
-package com.rtbishop.look4sat.feature.cw
-
-import android.Manifest
-import android.app.Activity
-import android.content.Context
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.net.Uri
-import android.provider.Settings
-import android.view.LayoutInflater
-import androidx.activity.compose.BackHandler
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-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.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.systemBarsPadding
-import androidx.compose.material3.Button
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-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.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.viewinterop.AndroidView
-import androidx.constraintlayout.widget.ConstraintLayout
-import com.ve3nea.morse_expert.MainActivity
-
-@Composable
-fun CwDecodeScreen(navigateUp: () -> Unit = {}) {
-    val context = LocalContext.current
-    val activity = remember(context) {
-        context as? Activity ?: error("CwDecodeScreen must be hosted in an Activity")
-    }
-    // 照搬的控制器(普通类, 非 Activity); 每次进入页面新建实例
-    val controller = remember { MainActivity() }
-    // 提前 inflate 原版布局, 供 AndroidView 与控制器 onCreate 共用同一根视图
-    val rootView = remember(context) {
-        LayoutInflater.from(context).inflate(R.layout.activity_main, null) as ConstraintLayout
-    }
-
-    var permissionGranted by remember {
-        mutableStateOf(
-            context.checkSelfPermission(Manifest.permission.RECORD_AUDIO) ==
-                PackageManager.PERMISSION_GRANTED
-        )
-    }
-    var permanentlyDenied by remember { mutableStateOf(false) }
-    // v() 会 new a() 覆盖 f11036E, 必须保证只初始化一次
-    var initialized by remember { mutableStateOf(false) }
-    var showSettings by remember { mutableStateOf(false) }
-
-    // 生命周期: onCreate 必须在 onResume 前; onDispose 先 onPause 再 onDestroy
-    DisposableEffect(Unit) {
-        controller.onCreate(activity, rootView)
-        controller.onResume()
-        onDispose {
-            controller.onPause()
-            controller.onDestroy()
-        }
-    }
-
-    // 权限授予后启动解码核心; "首次进入已授权" 与 "弹窗回调授权" 两条路径统一走这里
-    LaunchedEffect(permissionGranted) {
-        if (permissionGranted && !initialized) {
-            controller.onPermissionGranted() // = v(): 创建音频采集 + 解码核心
-            // v() 只创建核心; 页面此刻已处于 resumed, 需再走一次 onResume 立即启动录音
-            // (AudioRecord 是新建的, startRecording 不会重复; GLSurfaceView.onResume 幂等)
-            controller.onResume()
-            initialized = true
-        }
-    }
-
-    val permissionLauncher = rememberLauncherForActivityResult(
-        ActivityResultContracts.RequestPermission()
-    ) { granted ->
-        permissionGranted = granted
-        permanentlyDenied = !granted &&
-            !activity.shouldShowRequestPermissionRationale(Manifest.permission.RECORD_AUDIO)
-    }
-
-    // 原版 tap_back_again_to_close: 单击返回只提示, 2 秒内再按才退出
-    BackHandler {
-        if (!controller.handleBackPress()) navigateUp()
-    }
-
-    if (showSettings) {
-        CwSettingsDialog(controller = controller, onDismiss = { showSettings = false })
-    }
-
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .systemBarsPadding()
-    ) {
-        // 原 options_menu: 暂停/清除/保存(原版图标) + 录音/设置(文字按钮)
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 4.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceEvenly
-        ) {
-            IconButton(onClick = { controller.togglePause() }) {
-                Icon(
-                    painter = painterResource(R.drawable.ic_baseline_pause_24),
-                    contentDescription = stringResource(R.string.pause)
-                )
-            }
-            IconButton(onClick = { controller.clearDecoded() }) {
-                Icon(
-                    painter = painterResource(R.drawable.ic_baseline_delete_24),
-                    contentDescription = stringResource(R.string.clear)
-                )
-            }
-            IconButton(onClick = { controller.saveText() }) {
-                Icon(
-                    painter = painterResource(R.drawable.ic_baseline_save_24),
-                    contentDescription = stringResource(R.string.save_text)
-                )
-            }
-            // recordSignals 需要解码核心(f11037F), 未初始化时禁用
-            TextButton(
-                onClick = { if (initialized) controller.recordSignals() },
-                enabled = initialized
-            ) {
-                Text(stringResource(R.string.record_signals))
-            }
-            TextButton(onClick = { showSettings = true }) {
-                Text(stringResource(R.string.settings))
-            }
-        }
-
-        Box(modifier = Modifier.weight(1f).fillMaxWidth()) {
-            AndroidView(
-                factory = { rootView },
-                modifier = Modifier.fillMaxSize()
-            )
-            if (!permissionGranted) {
-                // 未授予麦克风权限: 遮罩 + 提示文字 + 请求按钮
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .background(Color(0x99000000)),
-                    contentAlignment = Alignment.Center
-                ) {
-                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                        Text(
-                            text = "Microphone permission is required for CW decoding",
-                            color = Color.White,
-                            textAlign = TextAlign.Center,
-                            modifier = Modifier.padding(horizontal = 24.dp)
-                        )
-                        Spacer(modifier = Modifier.height(12.dp))
-                        Button(onClick = {
-                            permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
-                        }) {
-                            Text("Grant permission")
-                        }
-                        if (permanentlyDenied) {
-                            // 勾选了"不再询问": 引导去系统设置开启
-                            TextButton(onClick = {
-                                activity.startActivity(
-                                    Intent(
-                                        Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
-                                        Uri.parse("package:${activity.packageName}")
-                                    )
-                                )
-                            }) {
-                                Text("Open app settings")
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
@@ -1,218 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- */
-package com.rtbishop.look4sat.feature.cw
-
-import android.content.Context
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.RadioButton
-import androidx.compose.material3.Slider
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import com.ve3nea.morse_expert.MainActivity
-import kotlin.math.roundToInt
-
-/** 键名/默认值照搬原 Morse Expert(root_preferences.xml + SettingsActivity 逻辑)。 */
-private const val KEY_MESSAGE_TYPE = "message_type"
-private const val KEY_TEXT_FONT_SIZE = "text_font_size"
-private const val DEFAULT_MESSAGE_TYPE = "general_text"
-private const val DEFAULT_TEXT_FONT_SIZE = 18
-private const val MIN_FONT_SIZE = 7
-private const val MAX_FONT_SIZE = 99
-
-/** 预置色板(9 色, 3x3 网格);原 ColorPreferenceCompat 用第三方 colorpicker, 不引入。 */
-private val PaletteColors = listOf(
-    0xFFD0F0F0.toInt(), 0xFF000000.toInt(), 0xFFFFFFFF.toInt(),
-    0xFFAAAAAA.toInt(), 0xFFFF0000.toInt(), 0xFF00FF00.toInt(),
-    0xFF0000FF.toInt(), 0xFFFFFF00.toInt(), 0xFFFF00FF.toInt(),
-)
-
-/**
- * CW 设置弹窗(替代原 Morse Expert 的 SettingsActivity)。
- * 设置项与键名照搬原 APK: message_type / text_font_size / 9 个颜色
- * (I2.b.f663b 键名, I2.b.f664d 默认值, I2.b.c 英文标题)。
- * 存储: SharedPreferences(getPackageName() + "_preferences")。
- * 点击 OK 保存并调用 controller.onResume() 立即生效; Cancel/点外部仅关闭不保存。
- */
-@Composable
-fun CwSettingsDialog(controller: MainActivity, onDismiss: () -> Unit) {
-    val activity = controller.mActivity ?: return
-    val prefs = remember(activity) {
-        activity.getSharedPreferences(activity.packageName + "_preferences", Context.MODE_PRIVATE)
-    }
-
-    var messageType by remember {
-        mutableStateOf(prefs.getString(KEY_MESSAGE_TYPE, DEFAULT_MESSAGE_TYPE) ?: DEFAULT_MESSAGE_TYPE)
-    }
-    var fontSize by remember {
-        mutableStateOf(
-            prefs.getInt(KEY_TEXT_FONT_SIZE, DEFAULT_TEXT_FONT_SIZE)
-                .toFloat().coerceIn(MIN_FONT_SIZE.toFloat(), MAX_FONT_SIZE.toFloat())
-        )
-    }
-    var colorValues by remember {
-        mutableStateOf(IntArray(9) { i -> prefs.getInt(I2.b.f663b[i], I2.b.f664d[i]) })
-    }
-
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text("CW Settings") },
-        text = {
-            Column(
-                modifier = Modifier
-                    .verticalScroll(rememberScrollState())
-                    .padding(top = 4.dp)
-            ) {
-                Text("Message type", style = MaterialTheme.typography.titleSmall)
-                MessageTypeRow("general_text", "General Text", messageType) { messageType = it }
-                MessageTypeRow("ham_radio_qso", "Ham Radio QSO", messageType) { messageType = it }
-                HorizontalDivider(Modifier.padding(vertical = 8.dp))
-
-                Text("Text font size", style = MaterialTheme.typography.titleSmall)
-                Row(verticalAlignment = Alignment.CenterVertically) {
-                    Slider(
-                        value = fontSize,
-                        onValueChange = { fontSize = it },
-                        valueRange = MIN_FONT_SIZE.toFloat()..MAX_FONT_SIZE.toFloat(),
-                        steps = MAX_FONT_SIZE - MIN_FONT_SIZE - 1,
-                        modifier = Modifier.weight(1f),
-                    )
-                    Text(
-                        text = "${fontSize.roundToInt()}",
-                        style = MaterialTheme.typography.titleMedium,
-                        textAlign = TextAlign.End,
-                        modifier = Modifier.width(44.dp),
-                    )
-                }
-                HorizontalDivider(Modifier.padding(vertical = 8.dp))
-
-                Text("Colors", style = MaterialTheme.typography.titleSmall)
-                for (i in 0 until 9) {
-                    ColorSettingRow(
-                        title = I2.b.c[i],
-                        value = colorValues[i],
-                        onSelect = { selected ->
-                            colorValues = colorValues.copyOf().also { it[i] = selected }
-                        },
-                    )
-                }
-            }
-        },
-        confirmButton = {
-            TextButton(onClick = {
-                val editor = prefs.edit()
-                editor.putString(KEY_MESSAGE_TYPE, messageType)
-                editor.putInt(KEY_TEXT_FONT_SIZE, fontSize.roundToInt())
-                for (i in 0 until 9) {
-                    editor.putInt(I2.b.f663b[i], colorValues[i])
-                }
-                editor.apply()
-                // 原 SettingsActivity 返回时由 MainActivity.onResume() 重新读取全部设置; 照搬逻辑已就位
-                controller.onResume()
-                onDismiss()
-            }) { Text("OK") }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) { Text("Cancel") }
-        },
-    )
-}
-
-@Composable
-private fun MessageTypeRow(option: String, label: String, selected: String, onSelect: (String) -> Unit) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .clip(RoundedCornerShape(6.dp))
-            .clickable { onSelect(option) }
-            .padding(vertical = 2.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        RadioButton(selected = option == selected, onClick = { onSelect(option) })
-        Text(label, style = MaterialTheme.typography.bodyMedium)
-    }
-}
-
-@Composable
-private fun ColorSettingRow(title: String, value: Int, onSelect: (Int) -> Unit) {
-    Column(Modifier.fillMaxWidth().padding(vertical = 6.dp)) {
-        Row(verticalAlignment = Alignment.CenterVertically) {
-            Text(title, style = MaterialTheme.typography.bodyMedium, modifier = Modifier.weight(1f))
-            Box(
-                Modifier
-                    .size(20.dp)
-                    .clip(RoundedCornerShape(4.dp))
-                    .background(Color(value)),
-            )
-            Spacer(Modifier.width(6.dp))
-            Text(
-                text = String.format("#%06X", value and 0xFFFFFF),
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
-        Spacer(Modifier.height(6.dp))
-        PaletteGrid(selected = value, onSelect = onSelect)
-    }
-}
-
-@Composable
-private fun PaletteGrid(selected: Int, onSelect: (Int) -> Unit) {
-    Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
-        PaletteColors.chunked(3).forEach { rowColors ->
-            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                rowColors.forEach { color ->
-                    val isSelected = color == selected
-                    Box(
-                        modifier = Modifier
-                            .size(36.dp)
-                            .border(
-                                width = if (isSelected) 3.dp else 1.dp,
-                                color = if (isSelected) MaterialTheme.colorScheme.primary
-                                else MaterialTheme.colorScheme.outlineVariant,
-                                shape = RoundedCornerShape(6.dp),
-                            )
-                            .clip(RoundedCornerShape(6.dp))
-                            .background(Color(color))
-                            .clickable { onSelect(color) },
-                    )
-                }
-            }
-        }
-    }
-}
@@ -1,14 +0,0 @@
-package com.rtbishop.look4sat.feature.cw.suncompat;
-
-/**
- * 编译期 stub:Android 无 sun.misc.Cleaner(照搬 Morse Expert 1.15 k3 FFT 库的清理回调,
- * 实际 FFT 1024 点不触发 native 路径)。
- */
-public class Cleaner {
-    public static Cleaner create(Object referent, Runnable thunk) {
-        return null;
-    }
-
-    public void clean() {
-    }
-}
Author	SHA1	Message	Date
atsunatsu	c1277763de	fix: apply elevation color thresholds on radar page LocalElevationThresholds was provided inside MainScreen, but RadarDestination is a root-level sibling entry in NavRoot's NavDisplay, so the radar page's top bar fell outside the CompositionLocal scope and always used the default 15/45 thresholds instead of the user-configured ones. Hoist the CompositionLocalProvider to NavRoot so both the tab content and the root-level RadarDestination read the user's low/high elevation thresholds, and drop the now-redundant provider from MainScreen.	2026-09-16 04:17:52 +08:00
Arty Bishop	d471f02370	v4.4.7 - Data import overhaul, AMSAT reports, Map tweaks	2026-09-13 20:26:27 +01:00
Arty Bishop	9699d142fa	Fixed RadarScreen padding, implemented basic Detekt setup	2026-09-13 17:29:38 +01:00
Arty Bishop	6f3e3351c9	Tweaked data source management, migrated DB and Settings	2026-09-13 15:19:23 +01:00
Arty Bishop	d4a2fae0cd	Updated dependencies and gradle plugin, minor fixes	2026-09-12 11:40:59 +01:00
dependabot[bot]	d0bbb97f29	Bump actions/setup-java from 5 to 6 (#249 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-03 08:40:23 +01:00
atsunatsuandatsunatsu	c2fc5688b9	Added AMSAT satellite status reports submission (#248 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-09-03 08:39:34 +01:00
TianhengZhuang	796056a582	Extracted hardcoded UI strings to resources (en/zh) (#247 )	2026-09-02 09:08:37 +01:00
atsunatsuandatsunatsu	9cac33dae7	Localized AMSAT status screen for Chinese (#245 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-09-02 09:05:45 +01:00
wty2019wty	082266e385	Overhauled data source management, added HTTP status (#242 )	2026-08-21 14:11:30 +02:00
atsunatsuandatsunatsu	a42a5f1f0d	Tweaked sunrise/sunset calculations, added unit tests (#241 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-08-19 14:46:39 +02:00
Arty Bishop	7cdc2952dc	v4.4.6 - AMSAT status page, fully customizable data sources	2026-08-13 09:47:26 +02:00
Arty Bishop	bd51044690	Added custom frequency offset setting to network reporting	2026-08-12 20:17:26 +02:00
PingouinFerreux	1982c2d3dc	Fixed broken star history chart in README (#240 )	2026-08-12 18:22:53 +02:00
Arty Bishop	2f4e3f5802	Added the ability to fully customize data sources via import	2026-08-12 13:01:45 +02:00
Arty Bishop	24eebdef74	Consolidated app dialogs and tweaked bottom sheets	2026-08-11 14:14:14 +02:00
Arty Bishop	3f5b48f270	Integrated the AMSAT status page created by MCKero6423	2026-08-11 14:05:55 +02:00
atsunatsuandatsunatsu	060fa2dfcd	Added remembering per-satellite doppler offset (#237 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-08-11 14:02:15 +02:00
atsunatsuandatsunatsu	8b5960282f	Broaden linear transponder detection, logic fixes (#236 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-08-08 21:31:44 +02:00
mckero	10eb84690e	Added AMSAT satellite status tracking page (#234 )	2026-08-08 14:26:36 +02:00
atsunatsu atsunatsu wty2019wty	bf25292bf8	Fixed recalculating Radar track on station position change (#235 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com> Co-authored-by: wty2019wty <74123961+wty2019wty@users.noreply.github.com>	2026-08-08 14:10:55 +02:00
Arty Bishop	8fbfcb3712	v4.4.5 - Pass progress hotfix, swapped modes/filter dialogs	2026-08-05 13:14:50 +02:00
Arty Bishop	602b1553a2	v4.4.4 - Icom CAT, components, filters and sources tweaks	2026-08-04 20:51:22 +02:00
atsunatsuandatsunatsu	bd0881fb4b	Added linear transponder Doppler calculator (#232 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-08-04 18:45:12 +02:00
atsunatsuandatsunatsu	a9dd3e6e55	Localized pass date and time formats for Chinese (#231 ) Co-authored-by: atsunatsu <atsunatsu@users.noreply.github.com>	2026-08-04 18:12:10 +02:00
Lukas	905995ab44	Added configurable Radar offset to the sensors output (#230 )	2026-08-04 18:08:44 +02:00
Arty Bishop	f9806d7f7f	Replaced the types selection dialog with modes selection	2026-07-31 16:04:39 +02:00
Arty Bishop	2d3adfc6a6	Added small tweaks to Sources, Components and strings	2026-07-31 12:27:25 +02:00