fix: passband RX update now uses full Doppler round-trip instead of pure passband mapping

When adjusting RX in passband mode (via +/- buttons or slider), the old code used TransponderMapper.mapDownlinkToUplink (pure passband mapping without Doppler compensation), producing ~10kHz error at LEO velocities. Fix: use DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset for the full TX-from-RX round-trip, matching the RX→PASSBAND button onClick logic. Also fixed frame mismatch: position now uses txLow/txRange (Doppler-shifted frame) consistently.
2026-10-02 03:15:37 +00:00 · 2026-08-19 22:19:14 +08:00
1 parent 463df58eb9
commit 9e7fdbfe71
@@ -17,8 +17,10 @@
 */
 package com.rtbishop.look4sat.core.data.framework

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

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

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

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

    override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
        reporterScope.launch {
@@ -53,51 +67,48 @@ class NetworkReporter(
                .replace($$"$AZ", azimuth.toString())
                .replace($$"$EL", el.toString())
                .unescapeControlChars()
-            write(rotatorSocket, command) { rotatorConnected = false }
+            write(rotatorSocket, command) { resetRotatorConnection() }
        }
    }

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

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

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

+    private fun resetRotatorConnection() {
+        rotatorConnected = false
+        closeQuietly(rotatorSocket)
+        rotatorSocket = null
+    }
+
+    private fun resetFrequencyConnection() {
+        frequencyConnected = false
+        closeQuietly(frequencySocket)
+        frequencySocket = null
+    }
+
+    private fun closeQuietly(socket: SocketChannel?) {
+        try {
+            socket?.close()
+        } catch (_: Exception) {}
+    }
+
+    private fun Long.safeAdd(delta: Long): Long {
+        return when {
+            delta > 0 && this > Long.MAX_VALUE - delta -> Long.MAX_VALUE
+            delta < 0 && this < Long.MIN_VALUE - delta -> Long.MIN_VALUE
+            else -> this + delta
+        }
+    }
+
    private fun String.unescapeControlChars(): String =
-        replace("\\r", "\r").replace("\\n", "\n").replace("\\t", "\t")
+        replace("""\r""", 13.toChar().toString())
+            .replace("""\n""", 10.toChar().toString())
+            .replace("""\t""", 9.toChar().toString())
 }
@@ -117,7 +117,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
        )
    }

@@ -35,7 +35,10 @@ class AmSatRepository(private val remoteSource: IRemoteSource) : IAmSatRepositor
    override suspend fun fetchStatus(): SatStatusPage? = withContext(Dispatchers.IO) {
        val nowSec = System.currentTimeMillis() / 1000
        val catalogJson = remoteSource.getAmSatCatalog() ?: return@withContext null
-        val reportsJson = remoteSource.getAmSatReports(hours = 168, limit = 500) ?: 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)
@@ -52,7 +55,7 @@ class AmSatRepository(private val remoteSource: IRemoteSource) : IAmSatRepositor
        return try {
            val arr = JSONObject(json).getJSONArray("data")
            (0 until arr.length()).map { arr.getJSONObject(it).getString("name") }
-        } catch (e: Exception) {
+        } catch (_: Exception) {
            emptyList()
        }
    }
@@ -73,7 +76,7 @@ class AmSatRepository(private val remoteSource: IRemoteSource) : IAmSatRepositor
                    reportedTimeUtcSec = parseIsoUtcSec(iso)
                )
            }
-        } catch (e: Exception) {
+        } catch (_: Exception) {
            emptyList()
        }
    }
@@ -82,22 +85,22 @@ class AmSatRepository(private val remoteSource: IRemoteSource) : IAmSatRepositor
    private fun parseIsoUtcSec(iso: String): Long {
        return try {
            (isoUtcFormat.parse(iso)?.time ?: 0L) / 1000
-        } catch (e: Exception) {
+        } catch (_: Exception) {
            0L
        }
    }

-    /** Build one SatStatus (6 days x 12 slots) per catalog satellite, slotting reports by age. */
+    /** Build one SatStatus (3 days x 12 slots) per catalog satellite, slotting reports by age. */
    private fun buildStatuses(names: List<String>, reports: List<ApiReport>, nowSec: Long): List<SatStatus> {
        val byName = reports.groupBy { it.name }
        val monthAbbr = arrayOf("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
        val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
-        val labels = (0 until 6).map { d ->
+        val labels = (0 until 3).map { d ->
            utc.timeInMillis = (nowSec - d * 86400L) * 1000
            "${monthAbbr[utc.get(Calendar.MONTH)]} ${utc.get(Calendar.DAY_OF_MONTH)}"
        }
        return names.map { name ->
-            val slots = (0 until 72).map { slotIdx ->
+            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 }
@@ -112,7 +115,7 @@ class AmSatRepository(private val remoteSource: IRemoteSource) : IAmSatRepositor
                    )
                }
            }
-            val days = (0 until 6).map { d ->
+            val days = (0 until 3).map { d ->
                SatDay(dateLabel = labels[d], slots = slots.subList(d * 12, (d + 1) * 12))
            }
            SatStatus(name = name, days = days)
@@ -66,25 +66,26 @@ 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() }
+        val settings = settingsRepo.dataSourcesSettings.value
+        val tleUrls = settings.satelliteUrls.filter { it.isNotBlank() }.map(::normalizeUrl).distinct()
+        val radioUrls = settings.transceiversUrls.filter { it.isNotBlank() }.map(::normalizeUrl).distinct()
+        val builtinTypesByUrl = Sources.satelliteDataUrls
+            .filterValues { it.isNotBlank() }
+            .mapValues { normalizeUrl(it.value) }
+            .entries
+            .associate { (type, url) -> url to type }
+        val importedTypeIds = mutableMapOf<String, MutableList<Int>>()
        // launch all network requests concurrently
-        val tleJobs = tleUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
-        val radioJobs = radioUrls.values.map { url -> async { url to remoteSource.getNetworkStream(url) } }
-        // parse fetched data concurrently and associate with types
+        val tleJobs = tleUrls.map { url -> async { url to remoteSource.getNetworkStream(url) } }
+        val radioJobs = radioUrls.map { url -> async { url to remoteSource.getNetworkStream(url) } }
+        // parse fetched data concurrently and associate known built-in URLs with existing type filters.
        val importedEntries = tleJobs.awaitAll().flatMap { (url, stream) ->
-            val type = tleUrls.entries.find { it.value == url }?.key ?: customSourceType
-            stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty().also { entries ->
-                settingsRepo.setSatelliteTypeIds(type, entries.map { it.catnum })
-            }
+            val entries = stream?.let { parseSatelliteStream(url, unwrapIfZipped(url, it)) }.orEmpty()
+            val type = builtinTypesByUrl[url] ?: customSourceType
+            importedTypeIds.getOrPut(type) { mutableListOf() }.addAll(entries.map { it.catnum })
+            entries
        }
+        importedTypeIds.forEach { (type, ids) -> settingsRepo.setSatelliteTypeIds(type, ids.distinct()) }
        val importedRadios = radioJobs.awaitAll().flatMap { (url, stream) ->
            stream?.let { dataParser.parseJSONStream(unwrapIfZipped(url, it)) }.orEmpty()
        }
@@ -100,6 +101,9 @@ class DatabaseRepo(
        setUpdateSuccessful(0L)
    }

+    private fun normalizeUrl(url: String): String =
+        if (url.startsWith("http", ignoreCase = true)) url else "https://$url"
+
    private suspend fun parseSatelliteStream(url: String, stream: InputStream): List<OrbitalData> {
        val bufferedStream = stream.buffered()
        return when {
@@ -37,6 +37,8 @@ import com.rtbishop.look4sat.core.domain.utility.round
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
+import com.rtbishop.look4sat.core.domain.model.Constants
+import com.rtbishop.look4sat.core.domain.source.Sources

 class SettingsRepo(
    private val locationManager: LocationManager,
@@ -67,6 +69,7 @@ class SettingsRepo(
    private val keyFrequencyAddress = "frequencyAddress"
    private val keyFrequencyPort = "frequencyPort"
    private val keyFrequencyFormat = "frequencyFormat"
+    private val keyFrequencyOffsetHz = "frequencyOffsetHz"
    private val keySelectedIds = "selectedIds"
    private val keySelectedTypes = "selectedTypes"
    private val keySelectedModes = "selectedModes"
@@ -91,7 +94,10 @@ class SettingsRepo(
    private val keyUseCustomTransceivers = "useCustomTransceivers"
    private val keyTleUrl = "tleUrl"
    private val keyTransceiversUrl = "transceiversUrl"
+    private val keySatelliteUrls = "satelliteUrls"
+    private val keyTransceiversUrls = "transceiversUrls"
    private val separatorComma = ","
+    private val separatorUrl = "\n"

    //region # Satellites selection settings
    private val _satelliteSelection = MutableStateFlow(getSelectedIds())
@@ -298,6 +304,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 +317,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 +326,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 +338,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",
@@ -382,20 +395,45 @@ class SettingsRepo(

    override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
        preferences.edit {
-            putBoolean(keyUseCustomTle, settings.useCustomTLE)
-            putBoolean(keyUseCustomTransceivers, settings.useCustomTransceivers)
-            putString(keyTleUrl, settings.tleUrl)
-            putString(keyTransceiversUrl, settings.transceiversUrl)
+            putString(keySatelliteUrls, settings.satelliteUrls.joinToString(separatorUrl))
+            putString(keyTransceiversUrls, settings.transceiversUrls.joinToString(separatorUrl))
        }
        _dataSourcesSettings.value = settings
    }

    private fun getDataSourcesSettings(): DataSourcesSettings = DataSourcesSettings(
-        useCustomTLE = preferences.getBoolean(keyUseCustomTle, false),
-        useCustomTransceivers = preferences.getBoolean(keyUseCustomTransceivers, false),
-        tleUrl = preferences.getString(keyTleUrl, "https://example.com/tle.txt") ?: "",
-        transceiversUrl = preferences.getString(keyTransceiversUrl, "https://example.com/radio.json") ?: ""
+        satelliteUrls = getDataSourceUrls(
+            key = keySatelliteUrls,
+            defaultUrls = Sources.satelliteDataUrls.values.filter { it.isNotBlank() },
+            legacyEnabledKey = keyUseCustomTle,
+            legacyUrlKey = keyTleUrl
+        ),
+        transceiversUrls = getDataSourceUrls(
+            key = keyTransceiversUrls,
+            defaultUrls = Sources.transceiversDataUrls.values.filter { it.isNotBlank() },
+            legacyEnabledKey = keyUseCustomTransceivers,
+            legacyUrlKey = keyTransceiversUrl
+        )
    )
+
+    private fun getDataSourceUrls(
+        key: String,
+        defaultUrls: List<String>,
+        legacyEnabledKey: String,
+        legacyUrlKey: String
+    ): List<String> {
+        val stored = preferences.getString(key, null)
+            ?.split(separatorUrl)
+            ?.map { it.trim() }
+            ?.filter { it.isNotBlank() }
+        if (stored != null) return stored
+        val legacyCustomUrl = preferences.getString(legacyUrlKey, null)?.trim().orEmpty()
+        return if (preferences.getBoolean(legacyEnabledKey, false) && legacyCustomUrl.isNotBlank()) {
+            (defaultUrls + legacyCustomUrl).distinct()
+        } else {
+            defaultUrls
+        }
+    }
    //endregion

    //region # Radio control settings
@@ -24,7 +24,6 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import java.io.ByteArrayInputStream
 import java.io.InputStream

 class RemoteSource(
@@ -46,10 +45,14 @@ class RemoteSource(
    override suspend fun getNetworkStream(url: String): InputStream? = withContext(dispatcher) {
        try {
            val networkRequest = Request.Builder().url(url).build()
-            httpClient.newCall(networkRequest).execute().use { response ->
-                if (!response.isSuccessful) return@withContext null
-                ByteArrayInputStream(response.body.bytes())
+            val response = httpClient.newCall(networkRequest).execute()
+            if (!response.isSuccessful) {
+                response.close()
+                return@withContext null
            }
+            // Return the body stream directly as the caller is responsible for closing it.
+            // Closing the stream returns the connection to OkHttp's pool.
+            response.body.byteStream().buffered()
        } catch (exception: Exception) {
            println("RemoteSource network stream exception: $exception")
            null
@@ -91,10 +91,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)
@@ -124,6 +122,10 @@ private class FakeRemoteSource : IRemoteSource {
    override suspend fun getFileStream(uri: String): InputStream? = fileStreams[uri]?.invoke()

    override suspend fun getNetworkStream(url: String): InputStream? = networkStreams[url]?.invoke()
+
+    override suspend fun getAmSatCatalog(): String? = null
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = null
 }

 private class FakeLocalSource : ILocalSource {
@@ -176,7 +178,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(
@@ -226,9 +228,7 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou

 private fun defaultDataSourcesSettings(): DataSourcesSettings {
    return DataSourcesSettings(
-        useCustomTLE = false,
-        useCustomTransceivers = false,
-        tleUrl = "",
-        transceiversUrl = ""
+        satelliteUrls = emptyList(),
+        transceiversUrls = emptyList()
    )
 }