feat(radar): fill radar in split-screen via measured window size

The previous compact-mode trigger used currentWindowAdaptiveInfo(),
which reports the full-screen size class in split-screen / multi-window,
so the radar never enlarged there. Measure the actual window bounds with
BoxWithConstraints: compact (radar weight 1f fills all space, pager fixed
132dp strip) when maxWidth < 600dp && maxHeight < 480dp.

build: release version 4.4.7-ba7opf.17.6 (529)

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

@@ -26,6 +26,7 @@ import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.LoTWSyncMode
 import com.rtbishop.look4sat.core.domain.repository.LoTWResult
+import com.rtbishop.look4sat.core.domain.logbook.toConfirmedRecord
 import com.rtbishop.look4sat.core.domain.repository.applyLoTWGridResult
 import com.rtbishop.look4sat.core.domain.repository.lotwCursorApi
 import com.rtbishop.look4sat.core.domain.repository.lotwSyncToday
@@ -116,6 +117,11 @@ class MainApplication : Application(), IContainerProvider {
         val result = container.lotwRepo.fetchConfirmedGridQsos(callsign, lotwSettings.password, since)
         if (result is LoTWResult.Success) {
             val count = applyLoTWGridResult(settingsRepo, result, mode, callsign, timeNow)
+            // Feed the logbook so confirmations appear and local uploads get matched.
+            runCatching {
+                val confirmed = result.qsos.values.flatten().map { it.toConfirmedRecord(callsign) }
+                container.qsoRepository.mergeLoTW(confirmed)
+            }
             println("Periodic LoTW grid sync finished: $count worked grids")
         } else {
             println("Periodic LoTW grid sync skipped (${result::class.simpleName})")

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

@@ -177,6 +177,28 @@ fun MainScreen(
         factory = MapFilterViewModel.factory()
     )
 
+    // Map grid-QSO dialog "Match" button: pre-fill the match page for that
+    // grid and run the query BEFORE navigating, so the page's first frame
+    // already contains the results (time-range card at the top, pass curves
+    // right below — no scroll flicker). Navigation happens once the query
+    // finishes (see the collector below).
+    val mutualState by mutualViewModel.uiState.collectAsStateWithLifecycle()
+    val matchCalculating = mutualState.pendingNavigation && mutualState.isCalculating
+
+    LaunchedEffect(mutualViewModel) {
+        mutualViewModel.uiState.collect { state ->
+            if (state.pendingNavigation && !state.isCalculating) {
+                mutualViewModel.consumePendingNavigation()
+                // Push Mutual on top of the Map entry instead of replacing the
+                // stack (bottom-nav style): the system back gesture then pops
+                // back to the map page, which is the page the user came from.
+                if (backStack.lastOrNull() !is Screen.Mutual) {
+                    backStack.add(Screen.Mutual)
+                }
+            }
+        }
+    }
+
     CompositionLocalProvider(
         LocalElevationThresholds provides ElevationThresholds(
             low = otherSettings.lowElevation,
@@ -244,7 +266,18 @@ fun MainScreen(
                             )
                         }
                         entry<Screen.Map> {
-                            MapDestination(mapFilterViewModel = mapFilterViewModel)
+                            MapDestination(
+                                mapFilterViewModel = mapFilterViewModel,
+                                matchCalculating = matchCalculating,
+                                onMatchGrid = { grid ->
+                                    // Grid-QSO dialog "Match" button: pre-fill
+                                    // the match page for that grid and start the
+                                    // query. Navigation to the match page is
+                                    // handled by the uiState collector above,
+                                    // once the query finishes.
+                                    mutualViewModel.prefillMatchFromGrid(grid)
+                                }
+                            )
                         }
                         entry<Screen.Mutual> {
                             MutualScreen(

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/Look4SatDao.kt

@@ -45,9 +45,22 @@ interface Look4SatDao {
     @Query("DELETE FROM entries")
     suspend fun deleteEntries()
 
-    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes)")
+    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes) AND isAlive = 1")
     suspend fun getIdsWithModes(modes: List<String>): List<Int>
 
+    /** Like [getIdsWithModes] but only matches transponder records with an uplink,
+     *  excluding downlink-only beacons/telemetry that share the same mode label
+     *  (e.g. CW beacons, FM voice-synthesis beacons) from FM/Linear filter fallback. */
+    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes) AND uplinkLow IS NOT NULL AND isAlive = 1")
+    suspend fun getIdsWithModesAndUplink(modes: List<String>): List<Int>
+
+    /** Like [getIdsWithModes] but only matches records whose service class is
+     *  "Amateur", so the SSTV filter never matches weather birds (TIROS),
+     *  launcher debris or other non-amateur transmitters that happen to carry
+     *  an SSTV-labelled downlink. */
+    @Query("SELECT catnum FROM radios WHERE downlinkMode IN (:modes) AND service = 'Amateur' AND isAlive = 1")
+    suspend fun getIdsWithModesAndAmateur(modes: List<String>): List<Int>
+
     @Query("SELECT COUNT(*) FROM radios")
     suspend fun getRadiosTotal(): Int
 

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/Look4SatDb.kt

@@ -24,7 +24,7 @@ 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 = 2, exportSchema = false)
+@Database(entities = [SatEntry::class, SatRadio::class], version = 3, exportSchema = false)
 abstract class Look4SatDb : RoomDatabase() {
     abstract fun look4SatDao(): Look4SatDao
 }
@@ -37,3 +37,11 @@ val MIGRATION_1_2 = object : Migration(1, 2) {
         db.execSQL("ALTER TABLE radios ADD COLUMN isCustom INTEGER NOT NULL DEFAULT 0")
     }
 }
+
+/** Adds the transceiver service class ("Amateur" etc.), used by the SSTV virtual
+ * filter to tell amateur satellites apart from debris/weather/launcher stages. */
+val MIGRATION_2_3 = object : Migration(2, 3) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("ALTER TABLE radios ADD COLUMN service TEXT")
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/QsoDao.kt

@@ -0,0 +1,50 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.data.database
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Transaction
+import com.rtbishop.look4sat.core.data.database.entity.QsoEntity
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface QsoDao {
+    @Query("SELECT * FROM qso_records ORDER BY startUtcMillis DESC, id DESC")
+    fun observeAll(): Flow<List<QsoEntity>>
+
+    @Query("SELECT * FROM qso_records WHERE id = :id LIMIT 1")
+    suspend fun find(id: Long): QsoEntity?
+
+    @Query("SELECT * FROM qso_records ORDER BY startUtcMillis DESC, id DESC")
+    suspend fun getAll(): List<QsoEntity>
+
+    @Query("SELECT dedupeKey FROM qso_records")
+    suspend fun getDedupeKeys(): List<String>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun save(record: QsoEntity): Long
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    suspend fun importRecords(records: List<QsoEntity>): List<Long>
+
+    @Transaction
+    suspend fun saveBatch(records: List<QsoEntity>) {
+        records.forEach { save(it) }
+    }
+
+    @Query("DELETE FROM qso_records WHERE id = :id")
+    suspend fun delete(id: Long)
+
+    @Query("UPDATE qso_records SET lotwUploaded = 1 WHERE id IN (:ids)")
+    suspend fun markUploaded(ids: List<Long>)
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/QsoDatabase.kt

@@ -0,0 +1,33 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.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.QsoEntity
+
+/**
+ * Separate database for the logbook (QSO records, LoTW confirmations and
+ * upload receipts). Kept apart from [Look4SatDb] so existing installations
+ * never need a migration of the satellite database.
+ */
+@Database(entities = [QsoEntity::class], version = 2, exportSchema = false)
+abstract class QsoDatabase : RoomDatabase() {
+    abstract fun qsoDao(): QsoDao
+}
+
+/** v1 → v2: track whether a QSO was uploaded to LoTW (distinct from confirmed). */
+val MIGRATION_QSO_1_2 = object : Migration(1, 2) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("ALTER TABLE qso_records ADD COLUMN lotwUploaded INTEGER NOT NULL DEFAULT 0")
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/entity/QsoEntity.kt

@@ -0,0 +1,55 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.data.database.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(
+    tableName = "qso_records",
+    indices = [Index(value = ["dedupeKey"])]
+)
+data class QsoEntity(
+    @PrimaryKey(autoGenerate = true) val id: Long = 0L,
+    val startUtcMillis: Long,
+    val endUtcMillis: Long?,
+    val theirCallsign: String,
+    val myCallsign: String,
+    val theirGrid: String,
+    val myGrid: String,
+    val sentReport: String,
+    val receivedReport: String,
+    val txFrequencyHz: Long?,
+    val rxFrequencyHz: Long?,
+    val band: String,
+    val rxBand: String,
+    @ColumnInfo(defaultValue = "'MFSK'") val mode: String,
+    @ColumnInfo(defaultValue = "'FT4'") val submode: String,
+    val satelliteName: String,
+    val transponderName: String,
+    val satelliteMode: String,
+    val passAosUtcMillis: Long?,
+    val automatic: Boolean,
+    val status: String,
+    @ColumnInfo(defaultValue = "''") val dedupeKey: String,
+    @ColumnInfo(defaultValue = "''") val propagationMode: String = "",
+    @ColumnInfo(defaultValue = "0") val lotwConfirmed: Boolean = false,
+    @ColumnInfo(defaultValue = "0") val lotwUploaded: Boolean = false,
+    @ColumnInfo(defaultValue = "0") val lotwReceived: Boolean = false,
+    @ColumnInfo(defaultValue = "''") val lotwQslDate: String = "",
+    @ColumnInfo(defaultValue = "''") val vuccGrids: String = "",
+    val dxcc: Int? = null,
+    @ColumnInfo(defaultValue = "''") val country: String = "",
+    val cqZone: Int? = null,
+    @ColumnInfo(defaultValue = "''") val region: String = "",
+    @ColumnInfo(defaultValue = "''") val comment: String = ""
+)

core/data/src/main/java/com/rtbishop/look4sat/core/data/database/entity/SatRadio.kt

@@ -33,6 +33,10 @@ data class SatRadio(
     val uplinkMode: String?,
     val isInverted: Boolean,
     val catnum: Int?,
+    /** Service class from the transceiver source ("Amateur"/"Unknown" etc.).
+     *  Used to tell amateur satellites apart from debris / weather birds
+     *  (TIROS) / launcher stages (Ariane 6 R/B) in the SSTV virtual filter. */
+    val service: String? = null,
     /** Set for manually imported transceivers, which remote updates must not replace. */
     val isCustom: Boolean = false
 )

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

@@ -25,13 +25,18 @@ import android.location.LocationManager
 import androidx.room.Room
 import com.rtbishop.look4sat.core.data.database.Look4SatDb
 import com.rtbishop.look4sat.core.data.database.MIGRATION_1_2
+import com.rtbishop.look4sat.core.data.database.MIGRATION_2_3
+import com.rtbishop.look4sat.core.data.database.MIGRATION_QSO_1_2
+import com.rtbishop.look4sat.core.data.database.QsoDatabase
 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.lotw.LoTWUploadRepository
 import com.rtbishop.look4sat.core.data.repository.AmSatRepository
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
+import com.rtbishop.look4sat.core.data.repository.QsoRepository
 import com.rtbishop.look4sat.core.data.repository.SatelliteRepo
 import com.rtbishop.look4sat.core.data.repository.SelectionRepo
 import com.rtbishop.look4sat.core.data.repository.SensorsRepo
@@ -45,8 +50,10 @@ import com.rtbishop.look4sat.core.data.usecase.AddToCalendar
 import com.rtbishop.look4sat.core.data.usecase.AudioCapture
 import com.rtbishop.look4sat.core.data.usecase.SaveImage
 import com.rtbishop.look4sat.core.data.usecase.ShowToast
+import com.rtbishop.look4sat.core.domain.logbook.IQsoRepository
 import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
 import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
+import com.rtbishop.look4sat.core.domain.repository.ILoTWUploadRepository
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.IRadioController
 import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
@@ -73,6 +80,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
 
 class MainContainer(private val context: Context) : IMainContainer {
 
@@ -88,6 +96,13 @@ class MainContainer(private val context: Context) : IMainContainer {
     override val updateRepo by lazy { UpdateRepository(remoteSource) }
     override val wavelogRepo: IWavelogRepository by lazy { WavelogRepository() }
     override val lotwRepo: ILoTWRepository by lazy { LoTWRepository() }
+    override val qsoRepository: IQsoRepository by lazy {
+        val database = Room.databaseBuilder(context, QsoDatabase::class.java, "Look4SatQsoDB")
+            .addMigrations(MIGRATION_QSO_1_2)
+            .build()
+        QsoRepository(database.qsoDao(), Dispatchers.IO)
+    }
+    override val lotwUploadRepository: ILoTWUploadRepository by lazy { LoTWUploadRepository(context) }
     override val radioTrackingService: IRadioTrackingService by lazy {
         val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
         RadioTrackingService(appScope, manager, satelliteRepo, settingsRepo)
@@ -169,14 +184,23 @@ class MainContainer(private val context: Context) : IMainContainer {
     private fun provideLocalSource(): ILocalSource {
         val builder = Room.databaseBuilder(context, Look4SatDb::class.java, "Look4SatDBv400")
         val database = builder
-            .addMigrations(MIGRATION_1_2)
+            .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
             .fallbackToDestructiveMigration(false)
             .build()
         return LocalSource(database.look4SatDao())
     }
 
     private fun provideRemoteSource(): IRemoteSource {
-        return RemoteSource(Dispatchers.IO, context.contentResolver, OkHttpClient.Builder().build())
+        // amsat.org live pages are slow (7-10s+ from some networks); the
+        // OkHttp defaults (10s read timeout) made every AMSAT Live update
+        // time out, silently keeping stale FM/Linear lists forever.
+        val client = OkHttpClient.Builder()
+            .connectTimeout(20, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+            .writeTimeout(30, TimeUnit.SECONDS)
+            .callTimeout(60, TimeUnit.SECONDS)
+            .build()
+        return RemoteSource(Dispatchers.IO, context.contentResolver, client)
     }
 
     private fun provideSatelliteRepo(): ISatelliteRepo {

core/data/src/main/java/com/rtbishop/look4sat/core/data/lotw/LoTWConfig.kt

@@ -0,0 +1,171 @@
+package com.rtbishop.look4sat.core.data.lotw
+
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.displayMode
+import com.rtbishop.look4sat.core.domain.repository.LoTWProblem
+import com.rtbishop.look4sat.core.domain.repository.LoTWRegionField
+import com.rtbishop.look4sat.core.domain.repository.LoTWRegionOption
+import com.rtbishop.look4sat.core.domain.repository.LoTWStation
+import com.rtbishop.look4sat.core.domain.repository.LoTWStationMeta
+import com.rtbishop.look4sat.core.domain.repository.LoTWZonePair
+import org.w3c.dom.Element
+import org.xml.sax.InputSource
+import org.xml.sax.SAXException
+import java.io.InputStream
+import java.io.StringReader
+import java.util.Locale
+import java.util.zip.GZIPInputStream
+import javax.xml.parsers.DocumentBuilderFactory
+
+/** Bundled ARRL configuration 11.34 from https://lotw.arrl.org/lotw/config.tq6. */
+internal class LoTWConfig(input: InputStream) {
+    private val root = input.use { source -> GZIPInputStream(source).use { gzip ->
+        val xml = gzip.bufferedReader(Charsets.UTF_8).readText()
+        require(!xml.contains("<!DOCTYPE", true) && !xml.contains("<!ENTITY", true))
+        // Android's DOM provider does not support Xerces-specific setFeature flags.
+        DocumentBuilderFactory.newInstance().apply { isExpandEntityReferences = false }.newDocumentBuilder().apply {
+            setEntityResolver { _, _ -> throw SAXException("External entities are not permitted") }
+        }.parse(InputSource(StringReader(xml))).documentElement
+    } }
+    private val config = root.elements("tqslconfig").single()
+    val version = config.getAttribute("majorversion") + "." + config.getAttribute("minorversion")
+    private val spec = config.elements("sigspec").single { it.getAttribute("version") == "2.0" }
+    val stationOrder = spec.elements("tSTATION").single().childElements().map { it.tagName }
+    val contactOrder = spec.elements("tCONTACT").single().childElements().map { it.tagName }
+    private val primaryRegionFields = setOf("US_STATE", "CA_PROVINCE", "RU_OBLAST", "CN_PROVINCE", "AU_STATE", "JA_PREFECTURE", "FI_KUNTA")
+    private val secondaryRegionFields = setOf("US_COUNTY", "JA_CITY_GUN_KU")
+    private val bands = config.elements("bands").single().elements("band")
+    private val satellites = config.elements("satellite").associateBy { it.getAttribute("name").uppercase(Locale.US) }
+    private val modes = config.elements("modes").single().elements("mode").map { it.textContent }.toSet()
+
+    fun mode(record: QsoRecord): String {
+        val display = record.displayMode
+        if (display in modes) return display
+        val mapped = config.elements("adifmode").firstOrNull { it.textContent.equals(display, true) }?.getAttribute("mode")
+        return mapped ?: fail(LoTWProblem.MODE, display)
+    }
+
+    fun band(explicit: String, frequency: Long?, required: Boolean): String {
+        if (frequency != null && frequency <= 0) fail(LoTWProblem.BAND)
+        val frequencyBand = frequency?.let { hz -> bands.firstOrNull { band ->
+            val unit = if (band.getAttribute("spectrum") == "HF") 1_000.0 else 1_000_000.0
+            val mhz = hz / unit
+            mhz >= band.getAttribute("low").toDouble() && mhz <= band.getAttribute("high").toDouble()
+        }?.textContent }
+        val value = explicit.trim().uppercase(Locale.US).ifBlank { frequencyBand.orEmpty() }
+        if (value.isBlank() && !required && frequency == null) return ""
+        if (bands.none { it.textContent == value } || (frequency != null && frequencyBand != value)) fail(LoTWProblem.BAND, value)
+        return value
+    }
+
+    fun satellite(name: String, date: String): String {
+        val normalized = name.trim().uppercase(Locale.US)
+        // Look4Sat satellite names come from SatNOGS (e.g. "SO-50 (SaudiOSCAR 50)");
+        // the bundled config only knows the official LoTW name ("SO-50"). Exact match
+        // first, then accept any satellite whose official name is a substring of the
+        // Look4Sat name (covers SO-50, AO-91, IO-86, CAS-7B …). Failing that the
+        // contact is unavailable for upload.
+        val sat = satellites[normalized]
+            ?: satellites.entries.firstOrNull { (official, _) ->
+                official.length > 1 && normalized.contains(official)
+            }?.value
+            ?: fail(LoTWProblem.SATELLITE, normalized)
+        val first = sat.getAttribute("startDate")
+        val last = sat.getAttribute("endDate")
+        if ((first.isNotBlank() && date < first) || (last.isNotBlank() && date > last)) fail(LoTWProblem.SATELLITE, normalized)
+        return sat.getAttribute("name").uppercase(Locale.US)
+    }
+
+    fun propagation(value: String): String {
+        val normalized = value.trim().uppercase(Locale.US)
+        if (normalized.isNotBlank() && config.elements("propmode").none { it.getAttribute("name") == normalized || it.textContent == normalized }) {
+            fail(LoTWProblem.INVALID_CONTACT, normalized)
+        }
+        return normalized
+    }
+
+    /** Region-field metadata and the national zonemap for one DXCC entity. */
+    fun stationMeta(dxcc: Int): LoTWStationMeta {
+        val pageFields = config.elements("page").filter { it.getAttribute("dependency") == dxcc.toString() }
+            .flatMap { it.elements("pageField") }.map { it.textContent }
+        val primary = pageFields.firstOrNull { it in primaryRegionFields }
+        val regionField = primary?.let { id ->
+            val field = config.elements("field").single { it.getAttribute("Id") == id }
+            val dependency = if (field.getAttribute("dependsOn") == "DXCC") dxcc.toString() else null
+            val options = field.elements("enums").filter {
+                it.getAttribute("dependency").isBlank() || it.getAttribute("dependency") == dependency
+            }.flatMap { it.elements("enum") }.map { enum ->
+                LoTWRegionOption(
+                    code = enum.getAttribute("value").uppercase(Locale.US),
+                    name = enum.textContent.trim().ifBlank { enum.getAttribute("value") },
+                    zones = parseZonemap(enum.getAttribute("zonemap"))
+                )
+            }
+            LoTWRegionField(id = id, label = field.getAttribute("label"), options = options)
+        }
+        val entity = config.elements("dxcc").flatMap { it.elements("entity") }
+            .firstOrNull { it.getAttribute("arrlId") == dxcc.toString() }
+        val countryZones = entity?.getAttribute("zonemap")?.let(::parseZonemap).orEmpty()
+        return LoTWStationMeta(regionField, countryZones)
+    }
+
+    private fun parseZonemap(zonemap: String): List<LoTWZonePair> = zonemap.split(',').mapNotNull { pair ->
+        val parts = pair.split(':')
+        if (parts.size != 2) return@mapNotNull null
+        val itu = parts[0].trim().toIntOrNull() ?: return@mapNotNull null
+        val cq = parts[1].trim().toIntOrNull() ?: return@mapNotNull null
+        LoTWZonePair(itu, cq)
+    }
+
+    fun stationFields(station: LoTWStation, dxcc: Int): Map<String, String> {
+        fun normalized(value: String) = value.trim().uppercase(Locale.US)
+        val grids = station.grid.split(',').map(::normalized).filter(String::isNotBlank).distinct()
+        if (grids.size !in 1..4 || grids.any { !it.matches(Regex("[A-R]{2}[0-9]{2}([A-X]{2}([0-9]{2})?)?")) }) {
+            fail(LoTWProblem.STATION_GRID)
+        }
+        // The primary grid goes into GRIDSQUARE (the field the config's tSTATION
+        // order signs); the full multi-grid set goes into MY_VUCC_GRIDS, an extra
+        // station field that TQSL stores but does not sign (same precedent as IOTA).
+        val fields = linkedMapOf("GRIDSQUARE" to grids.first())
+        if (grids.size > 1) fields["MY_VUCC_GRIDS"] = grids.joinToString(",")
+        fun zone(name: String, value: String, maximum: Int) {
+            if (value.isBlank()) return
+            val number = value.trim().toIntOrNull()?.takeIf { it in 1..maximum } ?: fail(LoTWProblem.STATION_ZONE)
+            fields[name] = number.toString()
+        }
+        zone("CQZ", station.cqZone, 40)
+        zone("ITUZ", station.ituZone, 90)
+        if (station.iota.isNotBlank()) {
+            val iota = normalized(station.iota)
+            if (!iota.matches(Regex("(AF|AN|AS|EU|NA|OC|SA)-[0-9]{3}"))) fail(LoTWProblem.STATION_IOTA)
+            fields["IOTA"] = iota
+        }
+        val pageFields = config.elements("page").filter { it.getAttribute("dependency") == dxcc.toString() }
+            .flatMap { it.elements("pageField") }.map { it.textContent }
+        val primary = pageFields.firstOrNull { it in primaryRegionFields }
+        val secondary = pageFields.firstOrNull { it in secondaryRegionFields }
+        fun region(name: String?, value: String) {
+            if (value.isBlank()) return
+            if (name == null) fail(LoTWProblem.STATION_REGION)
+            val field = config.elements("field").single { it.getAttribute("Id") == name }
+            val dependency = when (field.getAttribute("dependsOn")) {
+                "DXCC" -> dxcc.toString()
+                else -> fields[field.getAttribute("dependsOn")]
+            }
+            val options = field.elements("enums").filter {
+                it.getAttribute("dependency").isBlank() || it.getAttribute("dependency") == dependency
+            }.flatMap { it.elements("enum") }.map { it.getAttribute("value").uppercase(Locale.US) }
+            val code = normalized(value)
+            if (code !in options) fail(LoTWProblem.STATION_REGION, name)
+            fields[name] = code
+        }
+        region(primary, station.region)
+        region(secondary, station.county)
+        return fields
+    }
+}
+
+private fun Element.elements(tag: String): List<Element> = getElementsByTagName(tag).let { nodes ->
+    (0 until nodes.length).map { nodes.item(it) as Element }
+}
+private fun Element.childElements(): List<Element> = (0 until childNodes.length).mapNotNull { childNodes.item(it) as? Element }

core/data/src/main/java/com/rtbishop/look4sat/core/data/lotw/LoTWKeyMaterial.kt

@@ -0,0 +1,157 @@
+package com.rtbishop.look4sat.core.data.lotw
+
+import com.rtbishop.look4sat.core.domain.repository.LoTWCertificate
+import com.rtbishop.look4sat.core.domain.repository.LoTWOperationException
+import com.rtbishop.look4sat.core.domain.repository.LoTWProblem
+import java.security.KeyStore
+import java.security.PrivateKey
+import java.security.Signature
+import java.security.cert.X509Certificate
+import java.text.SimpleDateFormat
+import java.util.Collections
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+internal data class LoTWKeyMaterial(val key: PrivateKey, val certificate: X509Certificate, val info: LoTWCertificate) {
+    companion object {
+        fun read(bytes: ByteArray, password: CharArray, now: Long): LoTWKeyMaterial {
+            if (bytes.isEmpty() || bytes.size > MAX_CERTIFICATE_BYTES) fail(LoTWProblem.CERTIFICATE_INVALID)
+            val key: PrivateKey
+            val cert: X509Certificate
+            val store = try {
+                KeyStore.getInstance("PKCS12").apply { bytes.inputStream().use { load(it, password) } }
+            } catch (_: Exception) {
+                // Modern TQSL / OpenSSL 3 exports use PBES2+AES-CBC which Android's legacy
+                // Bouncy Castle parser cannot read. Fall back to our own PBES2 reader; if
+                // that fails too, report the real reason (format vs password).
+                if (isPbes2(bytes)) {
+                    try {
+                        val parsed = Pkcs12Reader.read(bytes, password)
+                        parsed.first to parsed.second
+                    } catch (e: Exception) {
+                        // Classify by exception type so the user sees the right message:
+                        //  - BadPadding (BAD_DECRYPT)          -> wrong password
+                        //  - IllegalStateException (error())    -> unsupported algorithm,
+                        //    message is the algorithm name
+                        //  - IllegalArgumentException (require()) -> structurally invalid file
+                        fail(
+                            when {
+                                e is javax.crypto.BadPaddingException -> LoTWProblem.CERTIFICATE_PASSWORD
+                                e is IllegalStateException && password.isNotEmpty() -> LoTWProblem.CERTIFICATE_FORMAT
+                                else -> LoTWProblem.CERTIFICATE_INVALID
+                            },
+                            if (e is IllegalStateException) (e.message ?: "") else ""
+                        )
+                    }
+                } else {
+                    fail(LoTWProblem.CERTIFICATE_PASSWORD)
+                }
+            }
+            if (store is Pair<*, *>) {
+                @Suppress("UNCHECKED_CAST")
+                key = store.first as PrivateKey
+                @Suppress("UNCHECKED_CAST")
+                cert = store.second as X509Certificate
+            } else {
+                val ks = store as KeyStore
+                val aliases = Collections.list(ks.aliases()).filter { ks.isKeyEntry(it) }
+                if (aliases.size != 1) fail(LoTWProblem.CERTIFICATE_INVALID)
+                val alias = aliases.single()
+                key = try { ks.getKey(alias, password) as? PrivateKey }
+                catch (_: Exception) { fail(LoTWProblem.CERTIFICATE_PASSWORD) }
+                    ?: fail(LoTWProblem.CERTIFICATE_INVALID)
+                cert = ks.getCertificate(alias) as? X509Certificate ?: fail(LoTWProblem.CERTIFICATE_INVALID)
+            }
+            if (key.algorithm != "RSA" || cert.publicKey.algorithm != "RSA") fail(LoTWProblem.CERTIFICATE_INVALID)
+            try { cert.checkValidity(Date(now)) } catch (_: Exception) { fail(LoTWProblem.CERTIFICATE_EXPIRED) }
+            val info = try { metadata(cert) } catch (_: Exception) { fail(LoTWProblem.CERTIFICATE_INVALID) }
+            // Use the platform's crypto implementation, including PKCS#1 padding. No custom cryptography.
+            val challenge = "Look4Sat LoTW certificate key check".toByteArray(Charsets.US_ASCII)
+            val signed = Signature.getInstance("SHA1withRSA").run { initSign(key); update(challenge); sign() }
+            val valid = Signature.getInstance("SHA1withRSA").run { initVerify(cert); update(challenge); verify(signed) }
+            if (!valid) fail(LoTWProblem.CERTIFICATE_INVALID)
+            return LoTWKeyMaterial(key, cert, info)
+        }
+
+        /** True when the PKCS12 uses PBES2 (OID 1.2.840.113549.1.5.13), the default
+         *  algorithm of OpenSSL 3 / modern TQSL. Android's legacy BC parser can't read it. */
+        private fun isPbes2(bytes: ByteArray): Boolean {
+            val oid = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x05, 0x0d)
+            if (bytes.size < oid.size) return false
+            outer@ for (i in 0..bytes.size - oid.size) {
+                for (j in oid.indices) if (bytes[i + j] != oid[j]) continue@outer
+                return true
+            }
+            return false
+        }
+
+        private fun metadata(cert: X509Certificate): LoTWCertificate {
+            val oid = byteArrayOf(0x2b, 0x06, 0x01, 0x04, 0x01, 0xe0.toByte(), 0x3c, 0x01, 0x01)
+            val subject = DerValue.read(cert.subjectX500Principal.encoded).single()
+            require(subject.tag == 0x30)
+            val calls = subject.children().flatMap { it.children() }.mapNotNull { attribute ->
+                val pair = attribute.children()
+                if (pair.size == 2 && pair[0].tag == 6 && pair[0].data.contentEquals(oid)) pair[1].text() else null
+            }
+            val call = calls.single().trim().uppercase(Locale.US)
+            require(call.matches(Regex("[A-Z0-9]+(/[A-Z0-9]+)*")) && call.any(Char::isDigit) && call.any(Char::isLetter))
+            val first = extension(cert, "2")
+            val last = extension(cert, "3").takeUnless { it == "0000-00-00" }.orEmpty()
+            require(validDate(first) && (last.isBlank() || validDate(last)) && (last.isBlank() || last >= first))
+            val dxcc = extension(cert, "4").toInt()
+            require(dxcc > 0)
+            return LoTWCertificate(call, dxcc, cert.serialNumber.toString(16), utc(cert.notAfter.time, "yyyy-MM-dd"), first, last)
+        }
+
+        private fun extension(cert: X509Certificate, suffix: String): String {
+            val bytes = cert.getExtensionValue("1.3.6.1.4.1.12348.1.$suffix") ?: return ""
+            val outer = DerValue.read(bytes).single()
+            require(outer.tag == 4)
+            // TrustedQSL uses raw ASCII extension values. Also accept DER string-wrapped values.
+            return if (outer.data.all { it.toInt() in 32..126 || it.toInt() == 0 }) {
+                outer.data.toString(Charsets.US_ASCII).trim('\u0000', ' ')
+            } else DerValue.read(outer.data).single().text().trim()
+        }
+    }
+}
+
+internal const val MAX_CERTIFICATE_BYTES = 1024 * 1024
+internal fun fail(problem: LoTWProblem, detail: String = ""): Nothing = throw LoTWOperationException(problem, detail)
+internal fun utc(millis: Long, pattern: String): String = SimpleDateFormat(pattern, Locale.US).apply {
+    timeZone = TimeZone.getTimeZone("UTC")
+}.format(Date(millis))
+internal fun validDate(value: String): Boolean = value.matches(Regex("[0-9]{4}-[0-9]{2}-[0-9]{2}")) && runCatching {
+    SimpleDateFormat("yyyy-MM-dd", Locale.US).apply { isLenient = false }.parse(value) != null
+}.getOrDefault(false)
+
+/** Only bounded DER metadata decoding; cryptographic verification is delegated to JCA. */
+internal data class DerValue(val tag: Int, val data: ByteArray) {
+    fun children(): List<DerValue> = read(data)
+    fun text(): String = when (tag) {
+        12, 19, 20, 22, 23, 24 -> data.toString(Charsets.UTF_8)
+        30 -> data.toString(Charsets.UTF_16BE)
+        else -> error("Not an ASN.1 string")
+    }
+    companion object {
+        fun read(bytes: ByteArray): List<DerValue> {
+            val result = mutableListOf<DerValue>()
+            var offset = 0
+            while (offset < bytes.size) {
+                require(bytes.size - offset >= 2)
+                val tag = bytes[offset++].toInt() and 255
+                var length = bytes[offset++].toInt() and 255
+                if (length and 128 != 0) {
+                    val size = length and 127
+                    require(size in 1..3 && size <= bytes.size - offset)
+                    length = 0
+                    repeat(size) { length = (length shl 8) or (bytes[offset++].toInt() and 255) }
+                }
+                require(length <= bytes.size - offset)
+                result += DerValue(tag, bytes.copyOfRange(offset, offset + length))
+                offset += length
+            }
+            return result
+        }
+    }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/lotw/LoTWSigner.kt

@@ -0,0 +1,80 @@
+package com.rtbishop.look4sat.core.data.lotw
+
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
+import com.rtbishop.look4sat.core.domain.logbook.isSatellite
+import com.rtbishop.look4sat.core.domain.repository.LoTWProblem
+import java.io.ByteArrayOutputStream
+import java.math.BigDecimal
+import java.security.MessageDigest
+import java.security.Signature
+import java.util.Locale
+import java.util.zip.GZIPOutputStream
+import kotlin.io.encoding.Base64
+
+internal data class LoTWContact(val record: QsoRecord, val fields: Map<String, String>, val signData: String, val fingerprint: String)
+
+internal class LoTWSigner(private val config: LoTWConfig) {
+    fun contact(record: QsoRecord, key: LoTWKeyMaterial, station: Map<String, String>, now: Long): LoTWContact {
+        val call = record.theirCallsign.trim().uppercase(Locale.US)
+        if (record.status != QsoStatus.COMPLETE || !call.matches(Regex("[A-Z0-9]+(/[A-Z0-9]+)*")) ||
+            !call.any(Char::isLetter) || !call.any(Char::isDigit)) fail(LoTWProblem.INVALID_CONTACT, call)
+        if (!record.myCallsign.trim().equals(key.info.callsign, true)) fail(LoTWProblem.CALLSIGN_MISMATCH, call)
+        val date = utc(record.startUtcMillis, "yyyy-MM-dd")
+        if (date < key.info.firstQsoDate || (key.info.lastQsoDate.isNotBlank() && date > key.info.lastQsoDate) || record.startUtcMillis > now) {
+            fail(LoTWProblem.QSO_DATE, call)
+        }
+        fun mhz(hz: Long?): String = hz?.let { BigDecimal.valueOf(it, 6).stripTrailingZeros().toPlainString() }.orEmpty()
+        val fields = linkedMapOf(
+            "BAND" to config.band(record.band, record.txFrequencyHz, true),
+            "BAND_RX" to config.band(record.rxBand, record.rxFrequencyHz, false),
+            "CALL" to call,
+            "FREQ" to mhz(record.txFrequencyHz),
+            "FREQ_RX" to mhz(record.rxFrequencyHz),
+            "MODE" to config.mode(record),
+            "PROP_MODE" to if (record.isSatellite) "SAT" else config.propagation(record.propagationMode),
+            "QSO_DATE" to date,
+            "QSO_TIME" to utc(record.startUtcMillis, "HH:mm:ss'Z'"),
+            "SAT_NAME" to if (record.isSatellite) config.satellite(record.satelliteName, date) else ""
+        ).filterValues { it.isNotBlank() }
+        val signData = (config.stationOrder.map { station[it].orEmpty() } + config.contactOrder.map { fields[it].orEmpty() }).joinToString("")
+        // Fingerprint identifies the CONTACT only (call, date/time, band, mode,
+        // satellite, frequency). Station fields (grid, zones, county, IOTA) are
+        // deliberately excluded: changing the station location must not change
+        // the fingerprint, otherwise previously-uploaded contacts would lose
+        // their ledger entry and be re-uploaded (and rejected as duplicates).
+        val identity = field("CALL", key.info.callsign) + field("DXCC", key.info.dxcc.toString()) +
+            fields.entries.joinToString("") { field(it.key, it.value) }
+        val hash = MessageDigest.getInstance("SHA-256").digest(identity.toByteArray(Charsets.UTF_8)).joinToString("") { "%02x".format(it) }
+        return LoTWContact(record, fields, signData, hash)
+    }
+
+    fun sign(contacts: List<LoTWContact>, key: LoTWKeyMaterial, station: Map<String, String>): ByteArray {
+        val text = buildString {
+            append(field("TQSL_IDENT", "Look4Sat LoTW Config: V${config.version} AllowDupes: false"))
+            append(field("REC_TYPE", "tCERT")); append(field("CERT_UID", "1"))
+            append(field("CERTIFICATE", Base64.Default.encode(key.certificate.encoded).chunked(64).joinToString("\n")))
+            append("<eor>\n")
+            append(field("REC_TYPE", "tSTATION")); append(field("STATION_UID", "1")); append(field("CERT_UID", "1"))
+            append(field("CALL", key.info.callsign)); append(field("DXCC", key.info.dxcc.toString()))
+            station.forEach { (name, value) -> append(field(name, value)) }
+            append("<eor>\n")
+            contacts.forEach { contact ->
+                append(field("REC_TYPE", "tCONTACT")); append(field("STATION_UID", "1"))
+                contact.fields.forEach { (name, value) -> append(field(name, value)) }
+                // SHA-1 is required by the LoTW V2.0 wire format, not chosen for general-purpose signing.
+                val signature = Signature.getInstance("SHA1withRSA").run {
+                    initSign(key.key); update(contact.signData.toByteArray(Charsets.UTF_8)); sign()
+                }
+                val encoded = Base64.Default.encode(signature).chunked(64).joinToString("\n")
+                append("<SIGN_LOTW_V2.0:${encoded.length}:6>$encoded\n")
+                append(field("SIGNDATA", contact.signData)); append("<eor>\n")
+            }
+        }
+        return ByteArrayOutputStream().also { output ->
+            GZIPOutputStream(output).use { it.write(text.toByteArray(Charsets.UTF_8)) }
+        }.toByteArray()
+    }
+}
+
+private fun field(name: String, value: String): String = "<$name:${value.toByteArray(Charsets.UTF_8).size}>$value\n"

core/data/src/main/java/com/rtbishop/look4sat/core/data/lotw/LoTWStorage.kt

@@ -0,0 +1,61 @@
+package com.rtbishop.look4sat.core.data.lotw
+
+import android.content.Context
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.AtomicFile
+import java.io.File
+import java.security.KeyStore
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+
+internal interface LoTWStorage {
+    fun read(name: String): ByteArray?
+    fun write(name: String, data: ByteArray)
+    fun delete(name: String)
+}
+
+/** P12 backups and their saved passwords are encrypted at rest and excluded from Android/cloud backup. */
+internal class AndroidLoTWStorage(context: Context) : LoTWStorage {
+    private val directory = File(context.noBackupFilesDir, "lotw")
+    private val store by lazy { KeyStore.getInstance("AndroidKeyStore").apply { load(null) } }
+    private fun file(name: String): AtomicFile {
+        require(name.matches(Regex("[a-z]+")))
+        check(directory.isDirectory || directory.mkdirs())
+        return AtomicFile(File(directory, name))
+    }
+    private fun key(): SecretKey = (store.getKey(ALIAS, null) as? SecretKey) ?: KeyGenerator.getInstance(
+        KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore"
+    ).run {
+        init(KeyGenParameterSpec.Builder(ALIAS, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
+            .setBlockModes(KeyProperties.BLOCK_MODE_GCM).setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+            .setKeySize(256).build())
+        generateKey()
+    }
+    @Synchronized override fun read(name: String): ByteArray? {
+        val file = file(name)
+        if (!file.baseFile.exists() && !File(file.baseFile.path + ".bak").exists()) return null
+        val bytes = file.readFully()
+        require(bytes.size in 29..(16 * 1024 * 1024) && bytes[0] == 1.toByte())
+        return Cipher.getInstance("AES/GCM/NoPadding").run {
+            init(Cipher.DECRYPT_MODE, key(), GCMParameterSpec(128, bytes.copyOfRange(1, 13)))
+            updateAAD(name.toByteArray(Charsets.UTF_8))
+            doFinal(bytes, 13, bytes.size - 13)
+        }
+    }
+    @Synchronized override fun write(name: String, data: ByteArray) {
+        val cipher = Cipher.getInstance("AES/GCM/NoPadding").apply {
+            init(Cipher.ENCRYPT_MODE, key())
+            updateAAD(name.toByteArray(Charsets.UTF_8))
+        }
+        val bytes = byteArrayOf(1) + cipher.iv + cipher.doFinal(data)
+        val file = file(name)
+        val stream = file.startWrite()
+        try { stream.write(bytes); file.finishWrite(stream) }
+        catch (error: Exception) { file.failWrite(stream); throw error }
+    }
+    @Synchronized override fun delete(name: String) = file(name).delete()
+    private companion object { const val ALIAS = "look4sat.lotw.storage.v1" }
+}

core/data/src/main/java/com/rtbishop/look4sat/core/data/lotw/LoTWUploadRepository.kt

@@ -0,0 +1,394 @@
+package com.rtbishop.look4sat.core.data.lotw
+
+import android.content.Context
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
+import com.rtbishop.look4sat.core.domain.repository.ILoTWUploadRepository
+import com.rtbishop.look4sat.core.domain.repository.LoTWCertificate
+import com.rtbishop.look4sat.core.domain.repository.LoTWOperationException
+import com.rtbishop.look4sat.core.domain.repository.LoTWProblem
+import com.rtbishop.look4sat.core.domain.repository.LoTWStation
+import com.rtbishop.look4sat.core.domain.repository.LoTWStationMeta
+import com.rtbishop.look4sat.core.domain.repository.LoTWUploadAudit
+import com.rtbishop.look4sat.core.domain.repository.LoTWUploadPreview
+import com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.MultipartBody
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import java.io.ByteArrayOutputStream
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import java.io.IOException
+import java.nio.ByteBuffer
+import java.nio.CharBuffer
+import java.util.Locale
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import kotlin.coroutines.coroutineContext
+import kotlin.coroutines.resume
+
+private fun readBoundedBody(response: Response, limit: Int): String = response.body.charStream().use { reader ->
+    val result = StringBuilder()
+    val buffer = CharArray(8192)
+    while (true) {
+        val count = reader.read(buffer)
+        if (count < 0) break
+        require(result.length <= limit - count) { "Response exceeds size limit" }
+        result.append(buffer, 0, count)
+    }
+    result.toString()
+}
+
+class LoTWUploadRepository internal constructor(
+    private val storage: LoTWStorage,
+    private val config: () -> LoTWConfig,
+    client: OkHttpClient = OkHttpClient(),
+    private val now: () -> Long = System::currentTimeMillis
+) : ILoTWUploadRepository {
+    constructor(context: Context) : this(AndroidLoTWStorage(context), { LoTWConfig(context.assets.open("lotw/config.tq6")) })
+    private val client = client.newBuilder().connectTimeout(30, TimeUnit.SECONDS).readTimeout(120, TimeUnit.SECONDS)
+        .callTimeout(180, TimeUnit.SECONDS).retryOnConnectionFailure(false).followRedirects(false).followSslRedirects(false).build()
+    private val mutex = Mutex()
+    @Volatile private var pending: Pending? = null
+    private data class Pending(val preview: LoTWUploadPreview, val data: ByteArray, val hashes: List<String>, val created: Long)
+    private data class SigningContext(val key: LoTWKeyMaterial, val signer: LoTWSigner, val location: Map<String, String>)
+
+    override suspend fun certificate(): LoTWCertificate? = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val bytes = storage.read("certificate") ?: return@withLock null
+            try {
+                readBundle(bytes).let { bundle ->
+                    bundle.p12.fill(0)
+                    bundle.password?.fill(0)
+                    bundle.info.copy(passwordSaved = bundle.password != null)
+                }
+            } finally { bytes.fill(0) }
+        }
+    }
+
+    override suspend fun importCertificate(data: ByteArray, password: CharArray): LoTWCertificate = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val passwordBytes = encodePassword(password)
+            try {
+                if (passwordBytes.size > MAX_CERTIFICATE_PASSWORD_BYTES) fail(LoTWProblem.CERTIFICATE_PASSWORD)
+                val key = LoTWKeyMaterial.read(data, password, now())
+                val bytes = encodeBundle(key.info, data, passwordBytes)
+                try { storage.write("certificate", bytes) } finally { bytes.fill(0) }
+                discardPreview()
+                key.info.copy(passwordSaved = true)
+            } finally {
+                passwordBytes.fill(0)
+                password.fill('\u0000')
+                data.fill(0)
+            }
+        }
+    }
+
+    override suspend fun saveCertificatePassword(password: CharArray): LoTWCertificate = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val stored = storage.read("certificate") ?: fail(LoTWProblem.CERTIFICATE_MISSING)
+            val bundle = try { readBundle(stored) } finally { stored.fill(0) }
+            val passwordBytes = encodePassword(password)
+            try {
+                if (passwordBytes.size > MAX_CERTIFICATE_PASSWORD_BYTES) fail(LoTWProblem.CERTIFICATE_PASSWORD)
+                val key = LoTWKeyMaterial.read(bundle.p12, password, now())
+                val bytes = encodeBundle(key.info, bundle.p12, passwordBytes)
+                try { storage.write("certificate", bytes) } finally { bytes.fill(0) }
+                discardPreview()
+                key.info.copy(passwordSaved = true)
+            } finally {
+                bundle.p12.fill(0)
+                bundle.password?.fill(0)
+                passwordBytes.fill(0)
+                password.fill('\u0000')
+            }
+        }
+    }
+
+    override suspend fun station(): LoTWStation? = withContext(Dispatchers.IO) {
+        mutex.withLock { readStation() }
+    }
+
+    override suspend fun saveStation(station: LoTWStation): LoTWStation = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val stored = storage.read("certificate") ?: fail(LoTWProblem.CERTIFICATE_MISSING)
+            val bundle = try { readBundle(stored) } finally { stored.fill(0) }
+            val normalized = station.normalized()
+            try {
+                config().stationFields(normalized, bundle.info.dxcc)
+            } catch (e: LoTWOperationException) {
+                // A region saved under a different certificate no longer applies to
+                // this DXCC entity — drop it instead of failing the whole save.
+                if (e.reason != LoTWProblem.STATION_REGION) throw e
+                val cleaned = normalized.copy(region = "", county = "")
+                config().stationFields(cleaned, bundle.info.dxcc)
+                writeStation(cleaned)
+                discardPreview()
+                return@withLock cleaned
+            } finally {
+                bundle.p12.fill(0)
+                bundle.password?.fill(0)
+            }
+            writeStation(normalized)
+            discardPreview()
+            normalized
+        }
+    }
+
+    override suspend fun removeCertificate() = withContext(Dispatchers.IO) {
+        mutex.withLock { discardPreview(); storage.delete("certificate") }
+    }
+
+    override suspend fun stationMeta(dxcc: Int): LoTWStationMeta = withContext(Dispatchers.IO) {
+        config().stationMeta(dxcc)
+    }
+
+    override suspend fun audit(records: List<QsoRecord>): LoTWUploadAudit = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val signing = signingContext()
+            val ledger = ledger()
+            val unique = hashSetOf<String>()
+            var pendingCount = 0
+            var uploaded = 0
+            var unknown = 0
+            var unavailable = 0
+            records.sortedBy { it.startUtcMillis }.forEach { record ->
+                coroutineContext.ensureActive()
+                when {
+                    record.status != QsoStatus.COMPLETE -> unavailable++
+                    record.lotwReceived || record.lotwUploaded -> uploaded++
+                    else -> {
+                        val contact = try {
+                            signing.signer.contact(record, signing.key, signing.location, now())
+                        } catch (_: LoTWOperationException) {
+                            unavailable++
+                            null
+                        }
+                        if (contact != null) when {
+                            !unique.add(contact.fingerprint) -> unavailable++
+                            ledger[contact.fingerprint] == "accepted" -> uploaded++
+                            ledger[contact.fingerprint] == "unknown" -> unknown++
+                            else -> pendingCount++
+                        }
+                    }
+                }
+            }
+            LoTWUploadAudit(records.size, pendingCount, uploaded, unknown, unavailable)
+        }
+    }
+
+    override suspend fun prepare(records: List<QsoRecord>, resubmit: Boolean): LoTWUploadPreview = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            discardPreview()
+            if (records.size > 10_000) fail(LoTWProblem.TOO_MANY_CONTACTS)
+            val signing = signingContext()
+            val ledger = ledger()
+            var skipped = 0
+            var unknown = 0
+            var unavailable = 0
+            val unique = hashSetOf<String>()
+            val contacts = records.sortedBy { it.startUtcMillis }.mapNotNull { record ->
+                coroutineContext.ensureActive()
+                if (record.status != QsoStatus.COMPLETE || ((record.lotwReceived || record.lotwUploaded) && !resubmit)) { skipped++; return@mapNotNull null }
+                val contact = try {
+                    signing.signer.contact(record, signing.key, signing.location, now())
+                } catch (_: LoTWOperationException) {
+                    // One un-signable record must not abort the whole batch:
+                    // skip it, count it, and let the rest upload.
+                    unavailable++
+                    return@mapNotNull null
+                }
+                val previous = ledger[contact.fingerprint]
+                when {
+                    (previous == "accepted" && !resubmit) || !unique.add(contact.fingerprint) -> { skipped++; null }
+                    previous == "unknown" && !resubmit -> { skipped++; unknown++; null }
+                    else -> contact
+                }
+            }
+            val preview = LoTWUploadPreview(
+                UUID.randomUUID().toString(), signing.key.info.callsign, signing.key.info.dxcc, signing.location.getValue("GRIDSQUARE"),
+                contacts.size, skipped,
+                contacts.firstOrNull()?.record?.let { utc(it.startUtcMillis, "yyyy-MM-dd HH:mm:ss") }.orEmpty(),
+                contacts.lastOrNull()?.record?.let { utc(it.startUtcMillis, "yyyy-MM-dd HH:mm:ss") }.orEmpty(),
+                contacts.map { "${utc(it.record.startUtcMillis, "MM-dd HH:mm")} ${it.record.theirCallsign} ${it.fields["MODE"]} ${it.fields["SAT_NAME"].orEmpty()}" },
+                unknown,
+                unavailable,
+                contacts.map { it.record.id }
+            )
+            if (contacts.isNotEmpty()) pending = Pending(
+                preview,
+                signing.signer.sign(contacts, signing.key, signing.location),
+                contacts.map { it.fingerprint },
+                now()
+            )
+            preview
+        }
+    }
+
+    override suspend fun upload(previewId: String): LoTWUploadResult = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            val payload = pending?.takeIf { it.preview.id == previewId && now() - it.created in 0..900_000 }
+                ?: return@withLock LoTWUploadResult.ExpiredPreview
+            pending = null // A preview is a one-shot authorization, including across failures.
+            val ledger = ledger()
+            payload.hashes.forEach { ledger[it] = "unknown" }
+            saveLedger(ledger) // Persist BEFORE the POST, so process death/cancellation cannot cause an automatic retry.
+            try {
+                val result = post(payload.data, payload.preview.count)
+                when (result) {
+                    is LoTWUploadResult.Accepted -> payload.hashes.forEach { ledger[it] = "accepted" }
+                    is LoTWUploadResult.Rejected -> payload.hashes.forEach { ledger.remove(it) }
+                    else -> Unit
+                }
+                saveLedger(ledger)
+                result
+            } finally { payload.data.fill(0) }
+        }
+    }
+
+    override fun discardPreview() { pending?.data?.fill(0); pending = null }
+
+    private fun signingContext(): SigningContext {
+        val stored = storage.read("certificate") ?: fail(LoTWProblem.CERTIFICATE_MISSING)
+        val bundle = try { readBundle(stored) } finally { stored.fill(0) }
+        val passwordBytes = bundle.password ?: run {
+            bundle.p12.fill(0)
+            fail(LoTWProblem.CERTIFICATE_PASSWORD)
+        }
+        val password = decodePassword(passwordBytes)
+        return try {
+            val key = LoTWKeyMaterial.read(bundle.p12, password, now())
+            val tqslConfig = config()
+            val signer = LoTWSigner(tqslConfig)
+            val station = readStation() ?: fail(LoTWProblem.STATION_GRID)
+            SigningContext(key, signer, tqslConfig.stationFields(station, key.info.dxcc))
+        } finally {
+            bundle.p12.fill(0)
+            passwordBytes.fill(0)
+            password.fill('\u0000')
+        }
+    }
+
+    private fun readStation(): LoTWStation? = storage.read("station")?.inputStream()?.let { stream ->
+        DataInputStream(stream).use { input ->
+            require(input.readInt() == 1)
+            LoTWStation(input.readUTF(), input.readUTF(), input.readUTF(), input.readUTF(), input.readUTF(), input.readUTF())
+        }
+    }
+
+    private fun writeStation(station: LoTWStation) {
+        val bytes = ByteArrayOutputStream().also { stream -> DataOutputStream(stream).use { output ->
+            output.writeInt(1)
+            listOf(station.grid, station.cqZone, station.ituZone, station.region, station.county, station.iota).forEach(output::writeUTF)
+        } }.toByteArray()
+        try { storage.write("station", bytes) } finally { bytes.fill(0) }
+    }
+
+    private suspend fun post(data: ByteArray, count: Int): LoTWUploadResult = suspendCancellableCoroutine { continuation ->
+        val body = MultipartBody.Builder().setType(MultipartBody.FORM)
+            .addFormDataPart("upfile", "look4sat-${UUID.randomUUID()}.tq8", data.toRequestBody("application/octet-stream".toMediaType())).build()
+        val call = client.newCall(Request.Builder().url("https://lotw.arrl.org/lotw/upload").post(body).build())
+        continuation.invokeOnCancellation { call.cancel() }
+        call.enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                if (continuation.isActive) continuation.resume(LoTWUploadResult.Unknown)
+            }
+            override fun onResponse(call: Call, response: Response) {
+                val result = try {
+                    response.use {
+                        if (!it.isSuccessful) LoTWUploadResult.Unknown else parseLoTWUploadResponse(readBoundedBody(it, 256 * 1024), count)
+                    }
+                } catch (_: Exception) { LoTWUploadResult.Unknown }
+                if (continuation.isActive) continuation.resume(result)
+            }
+        })
+    }
+
+    private fun ledger(): MutableMap<String, String> = storage.read("receipts")?.inputStream()?.let { stream ->
+        DataInputStream(stream).use { input ->
+            require(input.readInt() == 1)
+            val size = input.readInt().also { require(it in 0..200_000) }
+            val entries = linkedMapOf<String, String>()
+            repeat(size) { entries[input.readUTF()] = input.readUTF() }
+            entries
+        }
+    } ?: linkedMapOf()
+
+    private fun saveLedger(entries: Map<String, String>) {
+        val bytes = ByteArrayOutputStream().also { stream -> DataOutputStream(stream).use { output ->
+            output.writeInt(1); output.writeInt(entries.size)
+            entries.forEach { (hash, status) -> output.writeUTF(hash); output.writeUTF(status) }
+        } }.toByteArray()
+        storage.write("receipts", bytes)
+    }
+}
+
+internal fun parseLoTWUploadResponse(body: String, count: Int): LoTWUploadResult {
+    val markers = Regex("<!--\\s*\\.UPL\\.\\s*(accepted|rejected)\\s*-->", RegexOption.IGNORE_CASE)
+        .findAll(body).map { it.groupValues[1].lowercase() }.toList()
+    return when (markers.singleOrNull()) {
+        "accepted" -> LoTWUploadResult.Accepted(count)
+        "rejected" -> {
+            val message = Regex("<!--\\s*\\.UPLMESSAGE\\.\\s*(.*?)-->", setOf(RegexOption.IGNORE_CASE, RegexOption.DOT_MATCHES_ALL))
+                .find(body)?.groupValues?.get(1).orEmpty().replace(Regex("<[^>]*>"), " ")
+                .replace(Regex("[\\p{Cc}\\s]+"), " ").trim().take(500)
+            LoTWUploadResult.Rejected(message)
+        }
+        else -> LoTWUploadResult.Unknown
+    }
+}
+
+private data class StoredCertificate(val info: LoTWCertificate, val p12: ByteArray, val password: ByteArray?)
+
+private fun encodeBundle(info: LoTWCertificate, p12: ByteArray, password: ByteArray): ByteArray = ByteArrayOutputStream().also { stream ->
+    DataOutputStream(stream).use { output ->
+        output.writeInt(2)
+        output.writeUTF(info.callsign); output.writeInt(info.dxcc); output.writeUTF(info.serial)
+        output.writeUTF(info.expires); output.writeUTF(info.firstQsoDate); output.writeUTF(info.lastQsoDate)
+        output.writeInt(password.size); output.write(password)
+        output.writeInt(p12.size); output.write(p12)
+    }
+}.toByteArray()
+
+private fun readBundle(bytes: ByteArray): StoredCertificate = DataInputStream(bytes.inputStream()).use { input ->
+    val version = input.readInt().also { require(it in 1..2) }
+    val info = LoTWCertificate(input.readUTF(), input.readInt(), input.readUTF(), input.readUTF(), input.readUTF(), input.readUTF())
+    val password = if (version >= 2) {
+        val size = input.readInt().also { require(it in 0..MAX_CERTIFICATE_PASSWORD_BYTES) }
+        ByteArray(size).also { input.readFully(it) }
+    } else null
+    val p12Size = input.readInt().also { require(it in 1..MAX_CERTIFICATE_BYTES) }
+    StoredCertificate(info, ByteArray(p12Size).also { input.readFully(it) }, password)
+}
+
+private fun encodePassword(password: CharArray): ByteArray {
+    val buffer = Charsets.UTF_8.encode(CharBuffer.wrap(password))
+    return ByteArray(buffer.remaining()).also(buffer::get)
+}
+
+private fun decodePassword(password: ByteArray): CharArray {
+    val buffer = Charsets.UTF_8.decode(ByteBuffer.wrap(password))
+    return CharArray(buffer.remaining()).also(buffer::get)
+}
+
+private fun LoTWStation.normalized() = LoTWStation(
+    grid.trim().uppercase(Locale.US),
+    cqZone.trim(),
+    ituZone.trim(),
+    region.trim().uppercase(Locale.US),
+    county.trim().uppercase(Locale.US),
+    iota.trim().uppercase(Locale.US)
+)
+
+private const val MAX_CERTIFICATE_PASSWORD_BYTES = 16 * 1024

core/data/src/main/java/com/rtbishop/look4sat/core/data/lotw/Pkcs12Reader.kt

@@ -0,0 +1,301 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.rtbishop.look4sat.core.data.lotw
+
+import java.io.ByteArrayInputStream
+import java.security.KeyFactory
+import java.security.PrivateKey
+import java.security.cert.CertificateFactory
+import java.security.cert.X509Certificate
+import java.security.spec.PKCS8EncodedKeySpec
+import javax.crypto.Cipher
+import javax.crypto.SecretKeyFactory
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.PBEKeySpec
+import javax.crypto.spec.SecretKeySpec
+
+/**
+ * Minimal PKCS#12 reader for the PBES2/AES-CBC format that OpenSSL 3 and modern
+ * TQSL produce by default. Android's legacy bundled Bouncy Castle PKCS12 parser
+ * cannot handle PBES2, so we parse the DER structure ourselves and decrypt with
+ * the platform JCE (PBKDF2WithHmacSHA1/256 + AES/CBC), which ships on Android.
+ *
+ * Handles both layouts:
+ *  - OpenSSL `-certpbe NONE`: plaintext certificate bags + a PBES2-shrouded key
+ *    inside a plaintext `data` ContentInfo.
+ *  - Modern TQSL: the certificate SafeContents wrapped in an `encryptedData`
+ *    ContentInfo (PBES2), plus the PBES2-shrouded key in a plaintext `data`
+ *    ContentInfo.
+ */
+internal object Pkcs12Reader {
+
+    private val OID_DATA = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x07, 0x01)
+    private val OID_ENCRYPTED_DATA = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x07, 0x06)
+    private val OID_PKCS8_SHROUDED_KEY_BAG = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x0c, 0x0a, 0x01, 0x02)
+    private val OID_CERT_BAG = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x0c, 0x0a, 0x01, 0x03)
+    private val OID_X509_CERT = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x09, 0x16, 0x01)
+    private val OID_PBES2 = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x05, 0x0d)
+    private val OID_PBKDF2 = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x01, 0x05, 0x0c)
+    private val OID_HMAC_SHA1 = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x02, 0x07)
+    private val OID_HMAC_SHA256 = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x02, 0x09)
+    private val OID_HMAC_SHA384 = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x02, 0x0a)
+    private val OID_HMAC_SHA512 = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x02, 0x0b)
+    private val OID_AES_256_CBC = byteArrayOf(0x60, 0x86.toByte(), 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x2a)
+    private val OID_AES_192_CBC = byteArrayOf(0x60, 0x86.toByte(), 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x16)
+    private val OID_AES_128_CBC = byteArrayOf(0x60, 0x86.toByte(), 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x02)
+    private val OID_DES_EDE3_CBC = byteArrayOf(0x2a, 0x86.toByte(), 0x48, 0x86.toByte(), 0xf7.toByte(), 0x0d, 0x03, 0x07)
+
+    fun read(bytes: ByteArray, password: CharArray): Pair<PrivateKey, X509Certificate> {
+        val pfx = DerReader.read(bytes)
+        require(pfx.tag == 0x30) { "not a PFX" }
+        val pfxChildren = DerReader.children(pfx.content)
+        require(pfxChildren.size >= 2) { "PFX too small" }
+        // authSafe ContentInfo
+        val authSafeCi = DerReader.children(pfxChildren[1].content)
+        require(authSafeCi.size >= 2) { "authSafe malformed" }
+        // content: [0] EXPLICIT OCTET STRING -> AuthenticatedSafe
+        val explicit = DerReader.children(authSafeCi[1].content).first()
+        val octet = DerReader.read(explicit.content)
+        // octet.content is the AuthenticatedSafe body: a sequence of ContentInfo.
+        var privateKey: PrivateKey? = null
+        val certs = mutableListOf<X509Certificate>()
+        for (info in DerReader.children(octet.content)) {
+            val parts = DerReader.children(info.content)
+            if (parts.isEmpty()) continue
+            when {
+                parts[0].content.contentEquals(OID_DATA) ->
+                    parseSafeContentsContent(parts, password, certs) { privateKey = it }
+                parts[0].content.contentEquals(OID_ENCRYPTED_DATA) ->
+                    parseEncryptedData(parts, password, certs)
+            }
+        }
+        val key = privateKey ?: error("no private key bag found")
+        require(certs.isNotEmpty()) { "no certificate bag found" }
+        return key to certs[0]
+    }
+
+    /** A plaintext ContentInfo: [0] EXPLICIT OCTET STRING -> full SafeContents DER. */
+    private fun parseSafeContentsContent(
+        parts: List<Der>,
+        password: CharArray,
+        certs: MutableList<X509Certificate>,
+        onKey: (PrivateKey) -> Unit
+    ) {
+        val explicit = DerReader.children(parts[1].content).first()
+        parseSafeBags(explicit.content, password, certs, onKey)
+    }
+
+    /** EncryptedData ContentInfo: version, EncryptedContentInfo{ oid, PBES2 alg, [0] IMPLICIT OCTET }. */
+    private fun parseEncryptedData(
+        parts: List<Der>,
+        password: CharArray,
+        certs: MutableList<X509Certificate>
+    ) {
+        // parts[0] = encryptedData OID; parts[1] = [0] EXPLICIT EncryptedData SEQ
+        val explicit = DerReader.children(parts[1].content).first()
+        val eciParts = DerReader.children(explicit.content)
+        // eciParts = [version INT, EncryptedContentInfo SEQ]
+        require(eciParts.size >= 2) { "EncryptedData malformed" }
+        val eci = DerReader.children(eciParts[1].content)
+        // eci = [contentType OID, contentEncryptionAlgorithm, [0] IMPLICIT OCTET STRING]
+        require(eci.size >= 3) { "EncryptedContentInfo malformed" }
+        val alg = eci[1]
+        val ciphertext = eci[2].content // [0] IMPLICIT OCTET STRING -> raw bytes
+        val safeContents = decryptPbes2(alg, ciphertext, password)
+        // The decrypted SafeContents holds certificate bags.
+        parseSafeBags(safeContents, password, certs) {}
+    }
+
+    /** Decrypt a PBES2-encrypted blob given its AlgorithmIdentifier. */
+    private fun decryptPbes2(algorithm: Der, encrypted: ByteArray, password: CharArray): ByteArray {
+        val algParts = DerReader.children(algorithm.content)
+        require(algParts.size >= 2 && algParts[0].content.contentEquals(OID_PBES2)) { "not PBES2" }
+        // PBES2-params ::= SEQUENCE { kdf AlgorithmIdentifier, enc AlgorithmIdentifier }
+        val pbes2 = DerReader.children(algParts[1].content)
+        val kdf = DerReader.children(pbes2[0].content)
+        // KDF must be PBKDF2 (OpenSSL 3 also supports scrypt — not available on the
+        // platform JCE, so report it by name instead of a generic failure).
+        if (kdf.isEmpty() || !kdf[0].content.contentEquals(OID_PBKDF2)) {
+            error(oidName(kdf.firstOrNull()?.content))
+        }
+        val kdfParams = DerReader.children(kdf[1].content)
+        val salt = kdfParams[0].content
+        val iterations = readInt(kdfParams[1].content)
+        require(iterations in 1..10_000_000) { "implausible PBKDF2 iteration count" }
+        // Optional PBKDF2-params elements: keyLength (INTEGER) and/or prf (SEQUENCE),
+        // in either order. Distinguish by DER tag — mistaking prf for keyLength yields
+        // an absurd key size and a PBKDF2 that runs for hours.
+        var keyBits = -1 // -1 = not written; defaulted below from the cipher
+        var prfName = "PBKDF2WithHmacSHA1"
+        for (i in 2 until kdfParams.size) {
+            val param = kdfParams[i]
+            when (param.tag) {
+                0x02 -> keyBits = readInt(param.content) * 8
+                0x30 -> {
+                    val prf = DerReader.children(param.content)
+                    prfName = when {
+                        prf.isEmpty() || prf[0].content.contentEquals(OID_HMAC_SHA1) -> "PBKDF2WithHmacSHA1"
+                        prf[0].content.contentEquals(OID_HMAC_SHA256) -> "PBKDF2WithHmacSHA256"
+                        prf[0].content.contentEquals(OID_HMAC_SHA384) -> "PBKDF2WithHmacSHA384"
+                        prf[0].content.contentEquals(OID_HMAC_SHA512) -> "PBKDF2WithHmacSHA512"
+                        else -> error(oidName(prf[0].content))
+                    }
+                }
+            }
+        }
+        val enc = DerReader.children(pbes2[1].content)
+        val encOid = enc[0].content
+        val iv = enc[1].content
+        val (cipherName, aesKeyBits) = when {
+            encOid.contentEquals(OID_AES_256_CBC) -> "AES/CBC/PKCS5Padding" to 256
+            encOid.contentEquals(OID_AES_192_CBC) -> "AES/CBC/PKCS5Padding" to 192
+            encOid.contentEquals(OID_AES_128_CBC) -> "AES/CBC/PKCS5Padding" to 128
+            encOid.contentEquals(OID_DES_EDE3_CBC) -> "DESede/CBC/PKCS5Padding" to 192
+            else -> error(oidName(encOid))
+        }
+        val finalKeyBits = if (keyBits > 0) keyBits else aesKeyBits
+        require(finalKeyBits in 128..512) { "implausible PBKDF2 key size" }
+
+        val spec = PBEKeySpec(password, salt, iterations, finalKeyBits)
+        val secretKey = try {
+            SecretKeyFactory.getInstance(prfName).generateSecret(spec)
+        } catch (e: java.security.NoSuchAlgorithmException) {
+            // e.g. PBKDF2WithHmacSHA512 needs API 26+; surface the real reason.
+            error(prfName.replace("PBKDF2WithHmac", "PBKDF2-HMAC-") + " (needs Android 8.0+)")
+        }
+        val cipher = Cipher.getInstance(cipherName)
+        cipher.init(
+            Cipher.DECRYPT_MODE,
+            if (cipherName == "AES/CBC/PKCS5Padding") SecretKeySpec(secretKey.encoded, "AES")
+            else SecretKeySpec(secretKey.encoded, "DESede"),
+            IvParameterSpec(iv)
+        )
+        return cipher.doFinal(encrypted)
+    }
+
+    /** Human-readable name for a known algorithm OID. */
+    private fun oidName(oid: ByteArray?): String = when {
+        oid == null -> "unknown algorithm"
+        oid.contentEquals(OID_PBKDF2) -> "PBKDF2"
+        oid.contentEquals(OID_HMAC_SHA1) -> "PBKDF2-HMAC-SHA1"
+        oid.contentEquals(OID_HMAC_SHA256) -> "PBKDF2-HMAC-SHA256"
+        oid.contentEquals(OID_HMAC_SHA384) -> "PBKDF2-HMAC-SHA384"
+        oid.contentEquals(OID_HMAC_SHA512) -> "PBKDF2-HMAC-SHA512"
+        oid.contentEquals(OID_AES_256_CBC) -> "AES-256-CBC"
+        oid.contentEquals(OID_AES_192_CBC) -> "AES-192-CBC"
+        oid.contentEquals(OID_AES_128_CBC) -> "AES-128-CBC"
+        oid.contentEquals(OID_DES_EDE3_CBC) -> "DES-EDE3-CBC"
+        else -> "unknown algorithm"
+    }
+
+    private fun parseSafeBags(
+        safeContentsDer: ByteArray,
+        password: CharArray,
+        certs: MutableList<X509Certificate>,
+        onKey: (PrivateKey) -> Unit
+    ) {
+        val safeContents = DerReader.read(safeContentsDer)
+        require(safeContents.tag == 0x30) { "SafeContents malformed" }
+        for (bag in DerReader.children(safeContents.content)) {
+            val bagParts = DerReader.children(bag.content)
+            if (bagParts.size < 2) continue
+            val bagOid = bagParts[0].content
+            val bagValue = DerReader.children(bagParts[1].content).first()
+            when {
+                bagOid.contentEquals(OID_PKCS8_SHROUDED_KEY_BAG) ->
+                    onKey(decryptShroudedKeyBag(bagValue, password))
+                bagOid.contentEquals(OID_CERT_BAG) -> parseCertBag(bagValue, certs)
+            }
+        }
+    }
+
+    private fun decryptShroudedKeyBag(bagValue: Der, password: CharArray): PrivateKey {
+        // bagValue = the SafeBag value SEQ (EncryptedPrivateKeyInfo): children are
+        // [AlgorithmIdentifier, encryptedData OCTET STRING].
+        val parts = DerReader.children(bagValue.content)
+        require(parts.size == 2) { "EncryptedPrivateKeyInfo malformed" }
+        val pkcs8 = decryptPbes2(parts[0], parts[1].content, password)
+        return KeyFactory.getInstance("RSA").generatePrivate(PKCS8EncodedKeySpec(pkcs8))
+    }
+
+    private fun parseCertBag(bagValue: Der, certs: MutableList<X509Certificate>) {
+        // bagValue = the SafeBag value SEQ (CertBag): children are
+        // [certType OID, [0] EXPLICIT OCTET STRING (full X.509 DER)].
+        val parts = DerReader.children(bagValue.content)
+        if (parts.size < 2) return
+        if (!parts[0].content.contentEquals(OID_X509_CERT)) return
+        // [0] EXPLICIT -> OCTET STRING -> full X.509 certificate DER.
+        val explicit = DerReader.children(parts[1].content).first()
+        val certDer = explicit.content
+        val factory = CertificateFactory.getInstance("X.509")
+        certs.add(factory.generateCertificate(ByteArrayInputStream(certDer)) as X509Certificate)
+    }
+
+    private fun readInt(bytes: ByteArray): Int {
+        var value = 0
+        var start = 0
+        if (bytes.size > 1 && bytes[0].toInt() == 0x00) start = 1 // strip leading zero for positive
+        for (i in start until bytes.size) value = (value shl 8) or (bytes[i].toInt() and 0xff)
+        return value
+    }
+
+    /** Minimal DER element parser. */
+    private data class Der(val tag: Int, val content: ByteArray)
+
+    private object DerReader {
+        fun read(der: ByteArray, offset: Int = 0): Der {
+            require(offset < der.size) { "DER truncated" }
+            val tag = der[offset].toInt() and 0xff
+            var i = offset + 1
+            var len = der[i].toInt() and 0xff
+            i++
+            if (len and 0x80 != 0) {
+                val numBytes = len and 0x7f
+                len = 0
+                repeat(numBytes) {
+                    len = (len shl 8) or (der[i].toInt() and 0xff)
+                    i++
+                }
+            }
+            require(i + len <= der.size) { "DER length overflow" }
+            return Der(tag, der.copyOfRange(i, i + len))
+        }
+
+        fun children(content: ByteArray): List<Der> {
+            val out = mutableListOf<Der>()
+            var off = 0
+            while (off < content.size) {
+                val d = read(content, off)
+                out.add(d)
+                val step = headerSize(content, off) + d.content.size
+                if (step <= 0) break // defensive: never spin on malformed input
+                off += step
+            }
+            return out
+        }
+
+        private fun headerSize(der: ByteArray, offset: Int): Int {
+            var i = offset + 1
+            var len = der[i].toInt() and 0xff
+            i++
+            if (len and 0x80 != 0) i += len and 0x7f
+            return i - offset
+        }
+    }
+}

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

@@ -23,6 +23,7 @@ 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.NetworkResult
 import com.rtbishop.look4sat.core.domain.source.Sources
 import com.rtbishop.look4sat.core.domain.utility.DataParser
 import kotlinx.coroutines.CoroutineDispatcher

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

@@ -252,17 +252,40 @@ class LoTWRepository : ILoTWRepository {
         var country: String? = null
         var cqz: Int? = null
         var state: String? = null
-        var myGrid: String? = null
+        // Own-station (台址) fields: MY_GRIDSQUARE + MY_VUCC_GRIDS give the
+        // full grid set of the station location; the remaining MY_* fields
+        // together identify the station location (one callsign can own
+        // several locations, and one location can span several grids).
+        var myGrids = mutableSetOf<String>()
+        var myCallsign: String? = null
+        var myDxcc: String? = null
+        var myState: String? = null
+        var myCq: String? = null
+        var myItu: String? = null
+        var myIota: String? = null
+        var myCountry: String? = null
         val gridsInRecord = mutableListOf<String>()
 
         fun emitRecord() {
             if (propMode != "SAT" || gridsInRecord.isEmpty()) return
             val epochMs = adifTimestampToEpoch(qsoDate, timeOn)
+            val stationKey = buildString {
+                append(myCallsign ?: "")
+                append('|').append(myDxcc ?: "")
+                append('|').append(myState ?: "")
+                append('|').append(myCq ?: "")
+                append('|').append(myItu ?: "")
+                append('|').append(myIota ?: "")
+                append('|').append(myCountry ?: "")
+            }.ifBlank { null }
             val qso = com.rtbishop.look4sat.core.domain.model.GridQso(
                 call = call, epochMs = epochMs, satName = satName,
                 mode = mode, bandUp = bandUp, bandDown = bandDown,
                 dxcc = dxcc, country = country, cqz = cqz, state = state,
-                myGrid = myGrid
+                myGrid = myGrids.firstOrNull(),
+                myGrids = myGrids,
+                myCallsign = myCallsign,
+                stationKey = stationKey
             )
             for (grid in gridsInRecord) {
                 result.getOrPut(grid) { mutableListOf() }.add(qso)
@@ -273,7 +296,9 @@ class LoTWRepository : ILoTWRepository {
             propMode = null; call = ""; qsoDate = ""; timeOn = ""
             satName = ""; mode = ""; bandUp = ""; bandDown = ""
             dxcc = null; country = null; cqz = null; state = null
-            myGrid = null
+            myGrids = mutableSetOf()
+            myCallsign = null; myDxcc = null; myState = null
+            myCq = null; myItu = null; myIota = null; myCountry = null
             gridsInRecord.clear()
         }
 
@@ -311,10 +336,40 @@ class LoTWRepository : ILoTWRepository {
                 line.startsWith("<MY_GRIDSQUARE:") -> {
                     // Own-station grid (must not be confused with GRIDSQUARE —
                     // the opposite station's grid). Recorded per QSO so awards
-                    // can be counted per operated grid.
+                    // can be counted per operated grid. A station location may
+                    // also carry MY_VUCC_GRIDS (below) for multi-grid roaming.
                     val value = adifValue(line)
-                    if (value.length >= 4) myGrid = value.take(4).uppercase()
+                    if (value.length >= 4) myGrids.add(value.take(4).uppercase())
                 }
+                line.startsWith("<MY_VUCC_GRIDS:") -> {
+                    // Own-station VUCC grids: a comma-separated list LoTW emits
+                    // when one station location spans several grid squares
+                    // (e.g. "OM60,OM50" with MY_GRIDSQUARE absent). Without
+                    // this field the extra grids of a multi-grid 台址 silently
+                    // vanished from both the blue stripes and the per-台址 VUCC
+                    // count. Same split/truncate as VUCC_GRIDS below.
+                    adifValue(line).split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) myGrids.add(field.take(4))
+                    }
+                }
+                // Remaining MY_* fields identify the station location (台址):
+                // grouped together they form the stationKey used by the map's
+                // operated-grid selector. One callsign can own several 台址.
+                line.startsWith("<STATION_CALLSIGN:") ->
+                    myCallsign = adifValue(line).trim().uppercase().ifBlank { null }
+                line.startsWith("<MY_DXCC:") ->
+                    myDxcc = adifValue(line).trim().ifBlank { null }
+                line.startsWith("<MY_STATE:") ->
+                    myState = adifValue(line).trim().ifBlank { null }?.let { normalizeState(it) }
+                line.startsWith("<MY_CQ_ZONE:") ->
+                    myCq = adifValue(line).trim().ifBlank { null }
+                line.startsWith("<MY_ITU_ZONE:") ->
+                    myItu = adifValue(line).trim().ifBlank { null }
+                line.startsWith("<MY_IOTA:") ->
+                    myIota = adifValue(line).trim().uppercase().ifBlank { null }
+                line.startsWith("<MY_COUNTRY:") ->
+                    myCountry = adifValue(line).trim().ifBlank { null }
                 line.startsWith("<GRIDSQUARE:") || line.startsWith("<VUCC_GRIDS:") -> {
                     // VUCC_GRIDS holds a comma-separated list of grids
                     // ("EN52en,EN53fa"), up to four for contacts spanning
@@ -420,23 +475,30 @@ class LoTWRepository : ILoTWRepository {
         // would silently drop every own grid on real reports; buffer the record
         // and decide at <EOR> instead.
         var propMode: String? = null
-        var myGrid: String? = null
+        var myGrids = mutableSetOf<String>()
         for (raw in body.lineSequence()) {
             val line = raw.trim()
             when {
                 line.equals("<EOR>", ignoreCase = true) -> {
-                    if (propMode == "SAT" && myGrid != null) grids.add(myGrid)
+                    if (propMode == "SAT" && myGrids.isNotEmpty()) grids.addAll(myGrids)
                     propMode = null
-                    myGrid = null
+                    myGrids = mutableSetOf()
                 }
                 line.startsWith("<PROP_MODE:") -> {
                     propMode = adifValue(line).uppercase()
                 }
                 line.startsWith("<MY_GRIDSQUARE:") -> {
-                    // MY_GRIDSQUARE must not be mistaken for GRIDSQUARE (the
-                    // opposite station's grid) — only own-station grids count.
                     val value = adifValue(line)
-                    if (value.length >= 4) myGrid = value.take(4)
+                    if (value.length >= 4) myGrids.add(value.take(4).uppercase())
+                }
+                line.startsWith("<MY_VUCC_GRIDS:") -> {
+                    // Multi-grid 台址: each field of MY_VUCC_GRIDS is a grid the
+                    // station location covered; without this the extra grids
+                    // never reached the blue stripes.
+                    adifValue(line).split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) myGrids.add(field.take(4))
+                    }
                 }
             }
         }

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

@@ -0,0 +1,206 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.data.database.QsoDao
+import com.rtbishop.look4sat.core.data.database.entity.QsoEntity
+import com.rtbishop.look4sat.core.domain.logbook.AdifCodec
+import com.rtbishop.look4sat.core.domain.logbook.AdifImportResult
+import com.rtbishop.look4sat.core.domain.logbook.IQsoRepository
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
+import com.rtbishop.look4sat.core.domain.logbook.sameConfirmedContact
+import com.rtbishop.look4sat.core.domain.logbook.withConfirmation
+import com.rtbishop.look4sat.core.domain.logbook.confirmationLookupKey
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import java.util.Locale
+
+class QsoRepository(
+    private val dao: QsoDao,
+    private val dispatcher: CoroutineDispatcher
+) : IQsoRepository {
+    private val importMutex = Mutex()
+
+    override val records: Flow<List<QsoRecord>> = dao.observeAll().map { records -> records.map(QsoEntity::toDomain) }
+
+    override suspend fun find(id: Long): QsoRecord? = withContext(dispatcher) { dao.find(id)?.toDomain() }
+
+    override suspend fun save(record: QsoRecord): Long = withContext(dispatcher) {
+        importMutex.withLock {
+            val previous = if (record.id != 0L) dao.find(record.id)?.toDomain() else null
+            val saved = if (previous?.lotwConfirmed == true && sameConfirmedContact(record, previous)) {
+                record.withConfirmation(previous)
+            } else if (previous?.lotwConfirmed == true) record.copy(
+                lotwConfirmed = false, lotwQslDate = "", vuccGrids = emptyList(),
+                dxcc = null, country = "", cqZone = null, region = ""
+            ) else record
+            val received = if (previous != null && (
+                stableQsoKey(record) != stableQsoKey(previous) || record.myGrid != previous.myGrid ||
+                    record.rxFrequencyHz != previous.rxFrequencyHz || record.band != previous.band ||
+                    record.rxBand != previous.rxBand || record.propagationMode != previous.propagationMode
+                )) false else saved.lotwReceived
+            dao.save(saved.copy(lotwReceived = received).toEntity())
+        }
+    }
+
+    override suspend fun delete(id: Long) = withContext(dispatcher) { importMutex.withLock { dao.delete(id) } }
+
+    override suspend fun markUploaded(ids: List<Long>) = withContext(dispatcher) {
+        if (ids.isEmpty()) return@withContext
+        dao.markUploaded(ids)
+    }
+
+    override suspend fun exportAdi(ids: Set<Long>?, includeIncomplete: Boolean): String = withContext(dispatcher) {
+        val records = dao.getAll()
+            .asSequence()
+            .filter { ids == null || it.id in ids }
+            .map(QsoEntity::toDomain)
+            .filter { includeIncomplete || it.status == QsoStatus.COMPLETE }
+            .toList()
+        AdifCodec.encode(records)
+    }
+
+    override suspend fun importAdi(content: String): AdifImportResult = withContext(dispatcher) {
+        importMutex.withLock {
+            mergeRecords(AdifCodec.decode(content))
+        }
+    }
+
+    override suspend fun mergeConfirmed(records: List<QsoRecord>): AdifImportResult = withContext(dispatcher) {
+        importMutex.withLock { mergeRecords(records.filter { it.lotwConfirmed }) }
+    }
+
+    override suspend fun mergeLoTW(records: List<QsoRecord>): AdifImportResult = withContext(dispatcher) {
+        importMutex.withLock { mergeRecords(records, fromLoTW = true) }
+    }
+
+    private suspend fun mergeRecords(records: List<QsoRecord>, fromLoTW: Boolean = false): AdifImportResult {
+        val working = dao.getAll().map(QsoEntity::toDomain).toMutableList()
+        val lookup = working.indices.groupBy { working[it].confirmationLookupKey() }
+            .mapValues { it.value.toMutableList() }.toMutableMap()
+        val knownKeys = working.mapTo(mutableSetOf(), ::stableQsoKey)
+        val changes = linkedMapOf<Int, QsoRecord>()
+        var imported = 0
+        var updated = 0
+        var skipped = 0
+        records.forEach { remote ->
+            if (!fromLoTW && !remote.lotwConfirmed && stableQsoKey(remote) in knownKeys) { skipped++; return@forEach }
+            val candidates = if (fromLoTW || remote.lotwConfirmed) lookup[remote.confirmationLookupKey()].orEmpty()
+                .filter { sameConfirmedContact(working[it], remote) } else emptyList()
+            val exact = candidates.filter { working[it].startUtcMillis == remote.startUtcMillis }
+            val match = exact.singleOrNull() ?: candidates.singleOrNull()
+            if (match == null) {
+                if (stableQsoKey(remote) in knownKeys) { skipped++; return@forEach }
+                val added = remote.copy(id = 0L)
+                changes[working.size] = added
+                lookup.getOrPut(added.confirmationLookupKey()) { mutableListOf() }.add(working.size)
+                knownKeys += stableQsoKey(added)
+                working += added
+                imported++
+            } else {
+                val previous = working[match]
+                val merged = previous.withConfirmation(remote)
+                if (merged == previous) skipped++ else {
+                    working[match] = merged
+                    changes[match] = merged
+                    updated++
+                }
+            }
+        }
+        dao.saveBatch(changes.values.map(QsoRecord::toEntity))
+        return AdifImportResult(imported, skipped, updated)
+    }
+}
+
+private fun QsoEntity.toDomain() = QsoRecord(
+    id = id,
+    startUtcMillis = startUtcMillis,
+    endUtcMillis = endUtcMillis,
+    theirCallsign = theirCallsign,
+    myCallsign = myCallsign,
+    theirGrid = theirGrid,
+    myGrid = myGrid,
+    sentReport = sentReport,
+    receivedReport = receivedReport,
+    txFrequencyHz = txFrequencyHz,
+    rxFrequencyHz = rxFrequencyHz,
+    band = band,
+    rxBand = rxBand,
+    mode = mode,
+    submode = submode,
+    satelliteName = satelliteName,
+    transponderName = transponderName,
+    satelliteMode = satelliteMode,
+    passAosUtcMillis = passAosUtcMillis,
+    automatic = automatic,
+    status = runCatching { QsoStatus.valueOf(status) }.getOrDefault(QsoStatus.DRAFT),
+    propagationMode = propagationMode,
+    lotwConfirmed = lotwConfirmed,
+    lotwUploaded = lotwUploaded,
+    lotwReceived = lotwReceived,
+    lotwQslDate = lotwQslDate,
+    vuccGrids = vuccGrids.split(',').filter(String::isNotBlank),
+    dxcc = dxcc,
+    country = country,
+    cqZone = cqZone,
+    region = region,
+    comment = comment
+)
+
+private fun QsoRecord.toEntity() = QsoEntity(
+    id = id,
+    startUtcMillis = startUtcMillis,
+    endUtcMillis = endUtcMillis,
+    theirCallsign = theirCallsign.trim().uppercase(Locale.US),
+    myCallsign = myCallsign.trim().uppercase(Locale.US),
+    theirGrid = theirGrid.trim().uppercase(Locale.US),
+    myGrid = myGrid.trim().uppercase(Locale.US),
+    sentReport = sentReport.trim(),
+    receivedReport = receivedReport.trim(),
+    txFrequencyHz = txFrequencyHz,
+    rxFrequencyHz = rxFrequencyHz,
+    band = band,
+    rxBand = rxBand,
+    mode = mode.trim(),
+    submode = submode.trim(),
+    satelliteName = satelliteName,
+    transponderName = transponderName,
+    satelliteMode = satelliteMode,
+    passAosUtcMillis = passAosUtcMillis,
+    automatic = automatic,
+    status = status.name,
+    dedupeKey = stableQsoKey(this),
+    propagationMode = propagationMode.ifBlank { if (satelliteName.isNotBlank()) "SAT" else "" },
+    lotwConfirmed = lotwConfirmed,
+    lotwUploaded = lotwUploaded,
+    lotwReceived = lotwReceived,
+    lotwQslDate = lotwQslDate,
+    vuccGrids = vuccGrids.joinToString(","),
+    dxcc = dxcc,
+    country = country,
+    cqZone = cqZone,
+    region = region,
+    comment = comment
+)
+
+internal fun stableQsoKey(record: QsoRecord): String = listOf(
+    record.startUtcMillis.toString(),
+    record.theirCallsign.trim().uppercase(Locale.US),
+    record.myCallsign.trim().uppercase(Locale.US),
+    record.txFrequencyHz?.toString().orEmpty(),
+    record.mode.trim().uppercase(Locale.US),
+    record.submode.trim().uppercase(Locale.US),
+    record.satelliteName.trim().uppercase(Locale.US)
+).joinToString("|")

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

@@ -65,6 +65,12 @@ class SatelliteRepo(
 
     override suspend fun getRadiosWithId(id: Int) = localStorage.getRadiosWithId(id)
 
+    override suspend fun getSatelliteIdsWithModes(modes: List<String>) = localStorage.getIdsWithModes(modes)
+
+    override suspend fun getSatelliteIdsWithModesAndUplink(modes: List<String>) = localStorage.getIdsWithModesAndUplink(modes)
+
+    override suspend fun getSatelliteIdsWithModesAndAmateur(modes: List<String>) = localStorage.getIdsWithModesAndAmateur(modes)
+
     override suspend fun initRepository() = withContext(dispatcher) {
         combine(
             settingsRepo.selectedIds,

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

@@ -43,12 +43,15 @@ class SelectionRepo(
 
     // Resolve type IDs once when types change, then filter items reactively.
     // The HashSet gives O(1) catnum lookups instead of O(n) with a List.
+    // The three virtual types ("AMSAT Live FM", "AMSAT Live Linear", "Live SSTV")
+    // are resolved from hardcoded FM/Linear catnum sets (Sources) or live
+    // SSTV transponder data instead of SharedPreferences.
     private val itemsWithTypes = currentTypes.flatMapLatest { types: List<String> ->
         val catnumSet: Set<Int>? = if (types.isEmpty()) {
             null // null = no filtering
         } else {
-            val ids = settingsRepo.getSatelliteTypesIds(types)
-            if (ids.isEmpty()) null else ids.toHashSet()
+            val ids = resolveTypeIds(types)
+            if (ids.isEmpty()) emptySet() else ids.toHashSet()
         }
         currentItems.map { items ->
             if (catnumSet == null) items else items.filter { it.catnum in catnumSet }
@@ -61,8 +64,46 @@ class SelectionRepo(
 
     override fun getCurrentTypes() = currentTypes.value
 
-    override fun getTypesList() = Sources.satelliteDataUrls.keys.sorted().toMutableList().apply {
-        removeAt(0)
+    /**
+     * Resolves a list of type names to satellite catnums. The three virtual
+     * transponder/activity types are resolved from hardcoded FM/Linear lists
+     * (Sources.amSatFmCatnums / amSatLinearCatnums) or local SSTV transponder
+     * data; all other types come from the per-type ID lists persisted by
+     * [ISettingsRepo].
+     */
+    private suspend fun resolveTypeIds(types: List<String>): List<Int> {
+        val idsSet = mutableSetOf<Int>()
+        types.forEach { type ->
+            when (type) {
+                Sources.virtualTypeNames[0] -> idsSet.addAll(Sources.amSatFmCatnums)
+                Sources.virtualTypeNames[1] -> idsSet.addAll(Sources.amSatLinearCatnums)
+                // Live SSTV: mode=SSTV transponder records whose service class
+                // is "Amateur", excluding launcher debris / rocket bodies
+                // (names ending in "R/B" or "DEB" — e.g. Ariane 6 R/B) that
+                // carry an amateur payload transponder but are not satellites.
+                Sources.virtualTypeNames[2] -> {
+                    val sstvIds = localSource.getIdsWithModesAndAmateur(listOf("SSTV")).toSet()
+                    val inOrbitNames = currentItems.value.associate { it.catnum to it.name }
+                    val filtered = sstvIds.filter { catnum ->
+                        val name = inOrbitNames[catnum]?.uppercase().orEmpty()
+                        !name.endsWith(" R/B") && !name.endsWith(" DEB") &&
+                            !name.endsWith("R/B") && !name.endsWith("DEB")
+                    }
+                    idsSet.addAll(filtered)
+                }
+                else -> idsSet.addAll(settingsRepo.getSatelliteTypesIds(listOf(type)))
+            }
+        }
+        return idsSet.toList()
+    }
+
+    override fun getTypesList() = buildList {
+        // 三个转发器/活动虚拟类型排在最前.
+        addAll(Sources.virtualTypeNames)
+        // 所有真实 TLE 源类型均可选（含 "All" = CelesTrak active）；只排除
+        // "Other"（空 URL 占位，无数据）。不要用 removeAt(0) —— 字母序第一个
+        // 是 "All"/"ARISS" 这类真实源，删掉会让用户勾不到它们。
+        addAll(Sources.satelliteDataUrls.keys.sorted().filterNot { it == "Other" })
     }
 
     override suspend fun getEntriesFlow() = withContext(dispatcher) {

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

@@ -25,6 +25,7 @@ import androidx.core.location.LocationListenerCompat
 import androidx.core.location.LocationManagerCompat
 import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
 import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.MapSource
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
@@ -98,6 +99,8 @@ class SettingsRepo(
     private val keySstvMode = "sstvMode"
     private val keyLowElevation = "lowElevation"
     private val keyHighElevation = "highElevation"
+    private val keyMapSource = "mapSource"
+    private val keyTiandituKey = "tiandituKey"
     private val keyUseCustomTle = "useCustomTle"
     private val keyUseCustomTransceivers = "useCustomTransceivers"
     private val keyTleUrl = "tleUrl"
@@ -107,6 +110,7 @@ class SettingsRepo(
     private val keySatelliteEnabled = "satelliteEnabled"
     private val keyTransceiversEnabled = "transceiversEnabled"
     private val keySatnogsTleSourceMigration = "satnogsTleSourceMigration"
+    private val keyAutoTleSourceMigration = "autoTleSourceMigration"
     private val separatorComma = ","
     private val separatorUrl = "\n"
     private val legacyCelestrakSatnogsUrl =
@@ -210,7 +214,20 @@ class SettingsRepo(
                         cqz = o.optInt("cq", 0).takeIf { it > 0 },
                         state = o.optString("st").ifBlank { null },
                         // Own-grid field: absent in pre-myGrid data -> null.
-                        myGrid = o.optString("mg").ifBlank { null }
+                        myGrid = o.optString("mg").ifBlank { null },
+                        // Multi-grid 台址 fields (v4.4.7-ba7opf.16+): "mgs" is
+                        // the full grid set (MY_GRIDSQUARE + MY_VUCC_GRIDS);
+                        // pre-multi-grid data has only "mg" and falls back to a
+                        // single-element set so every consumer sees myGrids.
+                        myGrids = o.optJSONArray("mgs")?.let { arr ->
+                            (0 until arr.length()).mapNotNull { i ->
+                                arr.optString(i).takeIf { it.isNotBlank() }
+                            }.toSet()
+                        }?.takeIf { it.isNotEmpty() }
+                            ?: o.optString("mg").ifBlank { null }?.let { setOf(it) }
+                            ?: emptySet(),
+                        myCallsign = o.optString("mc").ifBlank { null },
+                        stationKey = o.optString("sk").ifBlank { null }
                     )
                 }
                 if (list.isNotEmpty()) result[grid] = list
@@ -239,6 +256,9 @@ class SettingsRepo(
                         .put("cq", q.cqz ?: 0)
                         .put("st", q.state ?: "")
                         .put("mg", q.myGrid ?: "")
+                        .put("mgs", org.json.JSONArray(q.myGrids.sorted()))
+                        .put("mc", q.myCallsign ?: "")
+                        .put("sk", q.stationKey ?: "")
                 )
             }
             root.put(grid, array)
@@ -269,6 +289,59 @@ class SettingsRepo(
         preferences.edit { putString(keyRoamedGrids, array.toString()) }
     }
 
+    // Marked stations in unworked gridsquares, persisted as a single JSON
+    // object: {"OL62":[{"c":call,"t":epochMs}, ...]}. Each grid holds an
+    // ordered list (first = pinned/top). v14.1 stored a single object per
+    // grid; reads transparently migrate that old shape to a one-element list.
+    private val keyMarkedGridStations = "markedGridStations"
+
+    override fun getMarkedGridStations(): Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> {
+        val json = preferences.getString(keyMarkedGridStations, null).orEmpty()
+        if (json.isBlank()) return emptyMap()
+        return try {
+            val root = org.json.JSONObject(json)
+            val result = mutableMapOf<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>()
+            for (grid in root.keys()) {
+                val value = root.opt(grid)
+                val list = when (value) {
+                    // v14.2+ shape: JSON array of station objects.
+                    is org.json.JSONArray -> (0 until value.length()).mapNotNull { i ->
+                        val o = value.optJSONObject(i) ?: return@mapNotNull null
+                        val call = o.optString("c").ifBlank { return@mapNotNull null }
+                        com.rtbishop.look4sat.core.domain.model.MarkedStation(call = call, epochMs = o.optLong("t"))
+                    }
+                    // v14.1 legacy shape: a single station object per grid.
+                    is org.json.JSONObject -> {
+                        val call = value.optString("c").ifBlank { null }
+                        if (call == null) emptyList()
+                        else listOf(com.rtbishop.look4sat.core.domain.model.MarkedStation(call = call, epochMs = value.optLong("t")))
+                    }
+                    else -> emptyList()
+                }
+                if (list.isNotEmpty()) result[grid] = list
+            }
+            result
+        } catch (_: Exception) {
+            emptyMap()
+        }
+    }
+
+    override fun setMarkedGridStations(stations: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>) {
+        val root = org.json.JSONObject()
+        for ((grid, list) in stations) {
+            val array = org.json.JSONArray()
+            for (station in list) {
+                array.put(
+                    org.json.JSONObject()
+                        .put("c", station.call)
+                        .put("t", station.epochMs)
+                )
+            }
+            root.put(grid, array)
+        }
+        preferences.edit { putString(keyMarkedGridStations, root.toString()) }
+    }
+
     // LoTW credentials (stored locally on the device only)
     private val keyLoTWCall = "lotwCallsign"
     private val keyLoTWPass = "lotwPassword"
@@ -442,7 +515,9 @@ class SettingsRepo(
     }
 
     override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
-        if (type == "All") return
+        // "All" is a real TLE source type (CelesTrak active group) whose ids
+        // must be persisted like any other type — skipping it made the "All"
+        // filter resolve to an empty set and show nothing.
         val typesString = ids.joinToString(separatorComma)
         preferences.edit { putString("type$type", typesString) }
     }
@@ -542,7 +617,12 @@ class SettingsRepo(
 
     override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) {
         _otherSettings.update { current ->
-            val new = transform(current)
+            val new = transform(current).let {
+                it.copy(
+                    mapSource = MapSource.normalize(it.mapSource),
+                    tiandituKey = it.tiandituKey.trim()
+                )
+            }
             preferences.edit {
                 putBoolean(keyStateOfAutoUpdate, new.stateOfAutoUpdate)
                 putBoolean(keyStateOfAutoLotwSync, new.stateOfAutoLotwSync)
@@ -559,6 +639,8 @@ class SettingsRepo(
                 putString(keySstvMode, new.sstvMode)
                 putLong(keyLowElevation, new.lowElevation.toRawBits())
                 putLong(keyHighElevation, new.highElevation.toRawBits())
+                putString(keyMapSource, new.mapSource)
+                putString(keyTiandituKey, new.tiandituKey)
             }
             new
         }
@@ -579,7 +661,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())),
+        mapSource = MapSource.normalize(preferences.getString(keyMapSource, null).orEmpty()),
+        tiandituKey = preferences.getString(keyTiandituKey, null).orEmpty().trim()
     )
     //endregion
 
@@ -601,6 +685,7 @@ class SettingsRepo(
             putString(keySatelliteEnabled, normalized.satelliteEnabled.joinToString(separatorComma))
             putString(keyTransceiversEnabled, normalized.transceiversEnabled.joinToString(separatorComma))
             putBoolean(keySatnogsTleSourceMigration, true)
+            putBoolean(keyAutoTleSourceMigration, true)
         }
         _dataSourcesSettings.value = normalized
     }
@@ -611,7 +696,7 @@ class SettingsRepo(
             defaultUrls = Sources.satelliteDataUrls.values.filter { it.isNotBlank() },
             legacyEnabledKey = keyUseCustomTle,
             legacyUrlKey = keyTleUrl
-        ).migrateSatnogsTleSource(),
+        ).migrateSatnogsTleSource().migrateAutoTleSources(),
         transceiversUrls = getDataSourceUrls(
             key = keyTransceiversUrls,
             defaultUrls = Sources.transceiversDataUrls.values.filter { it.isNotBlank() },
@@ -672,6 +757,28 @@ class SettingsRepo(
         return migrated
     }
 
+    private fun List<String>.migrateAutoTleSources(): List<String> {
+        if (preferences.getBoolean(keyAutoTleSourceMigration, false)) return this
+        val autoTleUrls = listOfNotNull(
+            Sources.satelliteDataUrls["BI4PYM AutoTLE (GitHub)"],
+            Sources.satelliteDataUrls["BI4PYM AutoTLE (Mirror)"]
+        ).filter { it.isNotBlank() }
+        val missingUrls = autoTleUrls.filterNot { containsSourceUrl(it) }
+        if (missingUrls.isEmpty()) {
+            preferences.edit { putBoolean(keyAutoTleSourceMigration, true) }
+            return this
+        }
+
+        val migrated = this + missingUrls
+        val enabled = alignFlags(migrated, readEnabledFlags(keySatelliteEnabled))
+        preferences.edit {
+            putString(keySatelliteUrls, migrated.joinToString(separatorUrl))
+            putString(keySatelliteEnabled, enabled.joinToString(separatorComma))
+            putBoolean(keyAutoTleSourceMigration, true)
+        }
+        return migrated
+    }
+
     private fun List<String>.containsSourceUrl(url: String): Boolean = any { isSameSourceUrl(it, url) }
 
     private fun isSameSourceUrl(first: String, second: String): Boolean =
@@ -770,6 +877,31 @@ class SettingsRepo(
     }
     //endregion
 
+    //region # Per-satellite logbook mode preset settings
+    private val keySatelliteModes = "satelliteModes"
+
+    override fun getSatelliteMode(catnum: Int): String {
+        val json = preferences.getString(keySatelliteModes, "{}") ?: "{}"
+        return try {
+            JSONObject(json).optString(catnum.toString(), "")
+        } catch (_: Exception) {
+            ""
+        }
+    }
+
+    override fun setSatelliteMode(catnum: Int, mode: String) {
+        val json = preferences.getString(keySatelliteModes, "{}") ?: "{}"
+        val updated = try {
+            val obj = JSONObject(json)
+            if (mode.isBlank()) obj.remove(catnum.toString()) else obj.put(catnum.toString(), mode.uppercase())
+            obj.toString()
+        } catch (_: Exception) {
+            if (mode.isBlank()) "{}" else """{"$catnum": "${mode.uppercase()}"}"""
+        }
+        preferences.edit { putString(keySatelliteModes, updated) }
+    }
+    //endregion
+
     //region # AMSAT status report settings
     private val keyAmSatCallsign = "amSatCallsign"
 

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

@@ -48,6 +48,8 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
     override suspend fun deleteEntries() = look4SatDao.deleteEntries()
 
     override suspend fun getIdsWithModes(modes: List<String>) = look4SatDao.getIdsWithModes(modes)
+    override suspend fun getIdsWithModesAndUplink(modes: List<String>) = look4SatDao.getIdsWithModesAndUplink(modes)
+    override suspend fun getIdsWithModesAndAmateur(modes: List<String>) = look4SatDao.getIdsWithModesAndAmateur(modes)
 
     private fun FrameworkEntry.toDomain() = OrbitalData(
         this.name, this.epoch, this.meanmo, this.eccn, this.incl,
@@ -83,12 +85,14 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
 
     private fun DomainRadio.toFramework() = FrameworkRadio(
         this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
-        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum, this.isCustom
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum,
+        this.service, this.isCustom
     )
 
     private fun FrameworkRadio.toDomain() = DomainRadio(
         this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
-        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum, this.isCustom
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum,
+        this.service, this.isCustom
     )
 
     private fun List<DomainRadio>.toFrameworkRadios() = this.map { radio -> radio.toFramework() }

core/data/src/test/java/com/rtbishop/look4sat/core/data/lotw/LoTWConfigTest.kt

@@ -0,0 +1,78 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.data.lotw
+
+import com.rtbishop.look4sat.core.domain.repository.LoTWZonePair
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** Parses the real bundled ARRL config.tq6 to verify region-field and zonemap extraction. */
+class LoTWConfigTest {
+
+    private val config = LoTWConfig(File("src/main/assets/lotw/config.tq6").inputStream())
+
+    @Test
+    fun `china exposes province field with all 31 options and zonemaps`() {
+        val meta = config.stationMeta(318)
+        assertEquals("CN_PROVINCE", meta.regionField?.id)
+        assertEquals("Province", meta.regionField?.label)
+        assertEquals(31, meta.regionField?.options?.size)
+        val gd = meta.regionField?.options?.first { it.code == "GD" }
+        assertEquals("Guangdong", gd?.name)
+        assertEquals(listOf(LoTWZonePair(44, 24)), gd?.zones)
+        val gx = meta.regionField?.options?.first { it.code == "GX" }
+        assertEquals(listOf(LoTWZonePair(43, 24), LoTWZonePair(44, 24)), gx?.zones)
+        // China spans 8 zone pairs — the UI must NOT prefill from the national map.
+        assertTrue(meta.countryZones.size > 1)
+    }
+
+    @Test
+    fun `usa exposes state field with 49 continental options`() {
+        val meta = config.stationMeta(291)
+        assertEquals("US_STATE", meta.regionField?.id)
+        assertEquals("State", meta.regionField?.label)
+        // AK and HI are separate DXCC entities (6 and 110) with their own 1-option blocks.
+        assertEquals(49, meta.regionField?.options?.size)
+        assertTrue(meta.regionField!!.options.none { it.code == "AK" || it.code == "HI" })
+        assertTrue(meta.countryZones.size > 1)
+    }
+
+    @Test
+    fun `alaska and hawaii each expose their own single-state block`() {
+        val ak = config.stationMeta(6)
+        assertEquals(listOf("AK"), ak.regionField?.options?.map { it.code })
+        val hi = config.stationMeta(110)
+        assertEquals(listOf("HI"), hi.regionField?.options?.map { it.code })
+    }
+
+    @Test
+    fun `germany has no region field and one national zone pair`() {
+        val meta = config.stationMeta(230)
+        assertNull(meta.regionField)
+        assertEquals(listOf(LoTWZonePair(28, 14)), meta.countryZones)
+    }
+
+    @Test
+    fun `india has no region field and one national zone pair`() {
+        val meta = config.stationMeta(324)
+        assertNull(meta.regionField)
+        assertEquals(listOf(LoTWZonePair(41, 22)), meta.countryZones)
+    }
+
+    @Test
+    fun `unknown entity yields empty meta`() {
+        val meta = config.stationMeta(999999)
+        assertNull(meta.regionField)
+        assertTrue(meta.countryZones.isEmpty())
+    }
+}

core/data/src/test/java/com/rtbishop/look4sat/core/data/lotw/Pkcs12ReaderTest.kt

@@ -0,0 +1,134 @@
+/*
+ * 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.lotw
+
+import java.security.Signature
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Verifies the PBES2/AES-256-CBC PKCS12 reader against a fixture generated with
+ * `openssl pkcs12 -export -certpbe NONE` — same layout as modern TQSL exports
+ * (plain certificate bags + PBES2-shrouded private key), which Android's legacy
+ * Bouncy Castle parser cannot read.
+ */
+class Pkcs12ReaderTest {
+
+    private fun fixture(): ByteArray =
+        javaClass.classLoader!!.getResourceAsStream("test_pbes2.p12")!!.use { it.readBytes() }
+
+    private fun fixture(name: String): ByteArray =
+        javaClass.classLoader!!.getResourceAsStream(name)!!.use { it.readBytes() }
+
+    @Test
+    fun readsAes192Variant() {
+        val (key, cert) = Pkcs12Reader.read(fixture("test_pbes2_aes192.p12"), "testpass123".toCharArray())
+        assertEquals("RSA", key.algorithm)
+        assertEquals("RSA", cert.publicKey.algorithm)
+        assertTrue("key/cert pair", keyMatches(key, cert))
+    }
+
+    @Test
+    fun readsDesEde3CbcVariant() {
+        val (key, cert) = Pkcs12Reader.read(fixture("test_pbes2_desede3.p12"), "testpass123".toCharArray())
+        assertEquals("RSA", key.algorithm)
+        assertEquals("RSA", cert.publicKey.algorithm)
+        assertTrue("key/cert pair", keyMatches(key, cert))
+    }
+
+    @Test
+    fun unsupportedCipherNamesTheAlgorithm() {
+        // A valid PBES2 file re-encrypted with an unsupported cipher must report the
+        // algorithm name (so the user can see exactly what to re-export with).
+        val fixtureBytes = fixture("test_pbes2.p12")
+        val e = assertThrows(IllegalStateException::class.java) {
+            // Simulate: patch the AES-256-CBC OID inside the file to an unknown OID.
+            val bogus = ByteArray(fixtureBytes.size) { fixtureBytes[it] }
+            // find AES-256-CBC OID bytes 0x60 86 48 01 65 03 04 01 2a
+            val oid = byteArrayOf(0x60, 0x86.toByte(), 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x2a)
+            var idx = -1
+            outer@ for (i in 0..bogus.size - oid.size) {
+                for (j in oid.indices) if (bogus[i + j] != oid[j]) continue@outer
+                idx = i; break
+            }
+            require(idx >= 0) { "AES-256-CBC OID not found in fixture" }
+            bogus[idx] = 0x7f.toByte() // corrupt the OID tag byte → unknown cipher
+            Pkcs12Reader.read(bogus, "testpass123".toCharArray())
+        }
+        assertTrue("mentions algorithm", e.message.orEmpty().contains("algorithm"))
+    }
+
+    private fun keyMatches(key: java.security.PrivateKey, cert: java.security.cert.X509Certificate): Boolean {
+        val challenge = "Look4Sat LoTW certificate key check".toByteArray(Charsets.US_ASCII)
+        val signed = Signature.getInstance("SHA1withRSA").run {
+            initSign(key); update(challenge); sign()
+        }
+        return Signature.getInstance("SHA1withRSA").run {
+            initVerify(cert); update(challenge); verify(signed)
+        }
+    }
+
+    @Test
+    fun wrongPasswordFailsWithBadPadding() {
+        // A wrong password must surface as a decryption failure (BadPadding), which
+        // LoTWKeyMaterial maps to CERTIFICATE_PASSWORD — not a format error.
+        val e = assertThrows(Exception::class.java) {
+            Pkcs12Reader.read(fixture(), "definitely-wrong-password".toCharArray())
+        }
+        assertTrue("BadPadding", e is javax.crypto.BadPaddingException)
+    }
+
+    @Test
+    fun readsPbes2KeyAndCertificate() {
+        val (key, cert) = Pkcs12Reader.read(fixture(), "testpass123".toCharArray())
+        assertEquals("RSA", key.algorithm)
+        assertEquals("RSA", cert.publicKey.algorithm)
+        assertNotNull(cert.subjectX500Principal)
+    }
+
+    @Test
+    fun keyPairsWithCertificate() {
+        val (key, cert) = Pkcs12Reader.read(fixture(), "testpass123".toCharArray())
+        val challenge = "Look4Sat LoTW certificate key check".toByteArray(Charsets.US_ASCII)
+        val signed = Signature.getInstance("SHA1withRSA").run {
+            initSign(key); update(challenge); sign()
+        }
+        val valid = Signature.getInstance("SHA1withRSA").run {
+            initVerify(cert); update(challenge); verify(signed)
+        }
+        assertTrue("private key must match certificate", valid)
+    }
+
+    @Test
+    fun wrongPasswordThrows() {
+        assertThrows(Exception::class.java) {
+            Pkcs12Reader.read(fixture(), "wrongpass".toCharArray())
+        }
+    }
+
+    @Test
+    fun garbageBytesThrows() {
+        assertThrows(Exception::class.java) {
+            Pkcs12Reader.read("not a p12 file at all".toByteArray(), "x".toCharArray())
+        }
+    }
+}

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

@@ -127,6 +127,29 @@ class DatabaseRepoTest {
         assertEquals(listOf(98248), settingsRepo.satelliteTypeIdsByType["SatNOGS"])
     }
 
+    @Test
+    fun `remote update persists All source type ids`() = runTest(dispatcher) {
+        // Regression: "All" (CelesTrak active) is a real TLE source type whose
+        // ids must be persisted on sync — the old `if (type == "All") return`
+        // silently dropped them, making the "All" filter resolve to nothing.
+        val allUrl = Sources.satelliteDataUrls.getValue("All")
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[allUrl] = { validCsvStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(allUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["All"])
+    }
+
     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
@@ -167,7 +190,8 @@ private class FakeLocalSource : ILocalSource {
 
     override suspend fun getEntriesTotal(): Int = insertedEntries.size
 
-    override suspend fun getEntriesList(): List<SatItem> = emptyList()
+    override suspend fun getEntriesList(): List<SatItem> =
+        insertedEntries.map { SatItem(it.catnum, it.name) }
 
     override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
 
@@ -180,6 +204,8 @@ private class FakeLocalSource : ILocalSource {
     }
 
     override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+    override suspend fun getIdsWithModesAndUplink(modes: List<String>): List<Int> = emptyList()
+    override suspend fun getIdsWithModesAndAmateur(modes: List<String>): List<Int> = emptyList()
 
     override suspend fun getRadiosTotal(): Int = insertedRadios.size
 
@@ -272,6 +298,8 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou
     override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
 
     override fun getSatelliteOffset(catnum: Int): String = ""
+    override fun getSatelliteMode(catnum: Int): String = ""
+    override fun setSatelliteMode(catnum: Int, mode: String) {}
 
     override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
 
@@ -312,6 +340,10 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou
     override fun setRoamedGrids(grids: Set<String>) {
         roamedGrids.value = grids
     }
+
+    override fun getMarkedGridStations(): Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> = emptyMap()
+
+    override fun setMarkedGridStations(stations: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>) = Unit
 }
 
 private fun defaultDataSourcesSettings(): DataSourcesSettings {

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

@@ -169,6 +169,53 @@ class LoTWRepositoryTest {
         assertTrue(repo.parseConfirmedGridQsos(report(qso1, ground))!!.values.all { it.all { q -> q.myGrid == "OL62" } })
     }
 
+    @Test
+    fun parseQsosCapturesMyVuccGridsMultiGridStation() {
+        // A station location (台址) can span several grids: LoTW emits
+        // <MY_VUCC_GRIDS> (comma-separated) with MY_GRIDSQUARE absent. Both
+        // grids must land in myGrids, and myGrid (back-compat) = the first.
+        val qso = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n<MODE:2>CW\n" +
+            "<MY_VUCC_GRIDS:11>OM60,OM50\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        val parsed = result["NL47"]!!.first()
+        assertEquals(setOf("OM60", "OM50"), parsed.myGrids)
+        assertEquals("OM60", parsed.myGrid)
+        // 6-char fields are truncated to 4 like every other grid path.
+        val six = "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<MY_VUCC_GRIDS:17>OM60IL70,OM50MA20\n<GRIDSQUARE:4>OK48\n<EOR>\n"
+        assertEquals(setOf("OM60", "OM50"), repo.parseConfirmedGridQsos(report(six))!!["OK48"]!!.first().myGrids)
+    }
+
+    @Test
+    fun parseQsosBuildsStationKeyFromMyFields() {
+        // 台址 identity = the MY_* station snapshot (callsign + dxcc + state +
+        // CQ/ITU + IOTA + country). A record with the full snapshot yields the
+        // stable key the operated-grid selector groups by.
+        val qso = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<STATION_CALLSIGN:6>BH6RJD\n<MY_DXCC:3>318\n<MY_STATE:11>JS // Jiangsu\n" +
+            "<MY_CQ_ZONE:2>24\n<MY_ITU_ZONE:2>44\n<MY_COUNTRY:5>CHINA\n" +
+            "<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val parsed = repo.parseConfirmedGridQsos(report(qso))!!["NL47"]!!.first()
+        assertEquals("BH6RJD", parsed.myCallsign)
+        assertEquals("BH6RJD|318|JS|24|44||CHINA", parsed.stationKey)
+    }
+
+    @Test
+    fun parseQsosStationKeyDistinguishesLocationsUnderSameCallsign() {
+        // One callsign can own several 台址 (e.g. BH6RJD with a Hubei location
+        // and a Zhejiang location); different MY_STATE -> different stationKey.
+        val hb = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<STATION_CALLSIGN:6>BH6RJD\n<MY_STATE:11>HB // Hubei\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val zj = "<CALL:5>BG7ZFK\n<QSO_DATE:8>20260819\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n" +
+            "<STATION_CALLSIGN:6>BH6RJD\n<MY_STATE:11>ZJ // Zhejiang\n<GRIDSQUARE:4>OK48\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(hb, zj))!!
+        assertTrue(result["NL47"]!!.first().stationKey != result["OK48"]!!.first().stationKey)
+    }
+
     // endregion
 
     // region parseRoamedGrids (MY_GRIDSQUARE = grids the account operated from)
@@ -224,6 +271,30 @@ class LoTWRepositoryTest {
         assertNull(repo.parseRoamedGrids("<HTML>Username/password incorrect</HTML>"))
     }
 
+    @Test
+    fun parseRoamedGridsCollectsMyVuccGrids() {
+        // Multi-grid 台址: MY_VUCC_GRIDS carries the extra grids (MY_GRIDSQUARE
+        // may be absent); every field must reach the roamed set for the stripes.
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<MY_VUCC_GRIDS:11>OM60,OM50\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        assertEquals(setOf("OM60", "OM50"), repo.parseRoamedGrids(report(qso)))
+        // Combined with MY_GRIDSQUARE the union is kept.
+        val both = "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<MY_GRIDSQUARE:4>OL62\n<MY_VUCC_GRIDS:11>OM60,OM50\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        assertEquals(setOf("OL62", "OM60", "OM50"), repo.parseRoamedGrids(report(both)))
+    }
+
+    @Test
+    fun parseRoamedGridsUppercasesLowercaseMyGrid() {
+        // LoTW emits the <eor> tag lowercase, so field CASE is not guaranteed:
+        // a lowercase MY_GRIDSQUARE must still match the overlay's uppercase
+        // labels (regression: take(4) without .uppercase() silently dropped
+        // stripes for lowercase grids).
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>IO-86\n" +
+            "<MY_GRIDSQUARE:4>ol62\n<GRIDSQUARE:4>PM95\n<EOR>\n"
+        assertEquals(setOf("OL62"), repo.parseRoamedGrids(report(qso)))
+    }
+
     // endregion
 
     // region failure classification (fetchReportBody -> LoTWResult mapping)

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

@@ -112,22 +112,181 @@ class SelectionRepoSearchTest {
         assertTrue(repo.getEntriesFlow().first().isEmpty())
     }
 
-    private fun createRepo(items: List<SatItem>): ISelectionRepo {
+    @Test
+    fun `FM virtual type shows only hardcoded FM satellites`() = runTest {
+        // AO-123 ASRTU-1 (61781) is on the hardcoded FM list; a random
+        // satellite (99999) is not.
+        val items = sampleItems + SatItem(catnum = 61781, name = "ASRTU-1")
+        val repo = createRepo(items)
+        repo.setTypes(listOf("AMSAT Live FM"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(setOf(25544, 61781), results.map { it.catnum }.toSet())
+    }
+
+    @Test
+    fun `Linear virtual type shows only hardcoded linear satellites`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setTypes(listOf("AMSAT Live Linear"))
+        val results = repo.getEntriesFlow().first()
+        // Hardcoded linear list: RS-44 (44909), FO-29 (24278), AO-7 (7530),
+        // AO-73 (39444), JO-97 (43803). Present in the sample DB: 7530, 39444, 43803.
+        assertEquals(setOf(7530, 39444, 43803), results.map { it.catnum }.toSet())
+    }
+
+    @Test
+    fun `SSTV virtual type shows only satellites with SSTV radios`() = runTest {
+        val repo = createRepo(
+            items = sampleItems,
+            sstvIds = listOf(43803)
+        )
+        repo.setTypes(listOf("Live SSTV"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(43803), results.map { it.catnum })
+    }
+
+    @Test
+    fun `SSTV virtual type uses the amateur-only radio query`() = runTest {
+        // The repo delegates to getIdsWithModesAndAmateur: the fake returns
+        // only catnums the DAO would have filtered to Amateur service (43803).
+        val repo = createRepo(
+            items = sampleItems,
+            sstvIds = listOf(43803)
+        )
+        repo.setTypes(listOf("Live SSTV"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(43803), results.map { it.catnum })
+    }
+
+    @Test
+    fun `SSTV virtual type excludes rocket-body debris by name`() = runTest {
+        // 60239 is "ARIANE 6 R/B" (launcher debris carrying an amateur SSTV
+        // payload); it must be dropped even though its radio is Amateur.
+        val items = sampleItems + SatItem(catnum = 60239, name = "ARIANE 6 R/B")
+        val repo = createRepo(
+            items = items,
+            sstvIds = listOf(43803, 60239)
+        )
+        repo.setTypes(listOf("Live SSTV"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(43803), results.map { it.catnum })
+    }
+
+    @Test
+    fun `multiple virtual types union their satellites`() = runTest {
+        val repo = createRepo(
+            items = sampleItems,
+            sstvIds = listOf(43803)
+        )
+        repo.setTypes(listOf("AMSAT Live FM", "Live SSTV"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(setOf(25544, 43803), results.map { it.catnum }.toSet())
+    }
+
+    @Test
+    fun `clearing types restores full list`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setTypes(listOf("AMSAT Live FM"))
+        assertTrue(repo.getEntriesFlow().first().isNotEmpty())
+        repo.setTypes(emptyList())
+        assertEquals(sampleItems.size, repo.getEntriesFlow().first().size)
+    }
+
+    @Test
+    fun `virtual type with no matching satellites shows empty not everything`() = runTest {
+        // 硬编码 FM 列表 (27607/25544/61781) 里没有样本库中的卫星时, 选虚拟
+        // 类型应显示空列表, 而非全部卫星.
+        val items = listOf(SatItem(catnum = 7530, name = "AO-7 (AMSAT-OSCAR 7)"))
+        val repo = createRepo(items)
+        repo.setTypes(listOf("AMSAT Live FM"))
+        assertTrue(repo.getEntriesFlow().first().isEmpty())
+    }
+
+    @Test
+    fun `virtual type combined with regular type unions both lists`() = runTest {
+        val repo = createRepo(items = sampleItems)
+        repo.setTypes(listOf("AMSAT Live FM", "AMSAT Live Linear"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(
+            setOf(25544, 7530, 39444, 43803),
+            results.map { it.catnum }.toSet()
+        )
+    }
+
+    @Test
+    fun `types list has virtual transponder types first and keeps All`() {
+        val repo = createRepo(sampleItems)
+        val types = repo.getTypesList()
+        assertTrue(types.size >= 4)
+        assertEquals("AMSAT Live FM", types[0])
+        assertEquals("AMSAT Live Linear", types[1])
+        assertEquals("Live SSTV", types[2])
+        // "All" must be kept in the list (first original type shown after virtual ones).
+        assertTrue("All" in types)
+    }
+
+    @Test
+    fun `All type resolves to persisted CelesTrak active ids`() = runTest {
+        // Regression: "All" is a real TLE source type (CelesTrak active). Its
+        // ids are persisted on sync like any other type; selecting it must
+        // show the synced satellites, NOT an empty list.
+        val fake = FakeSettingsRepoForSearch()
+        fake.setSatelliteTypeIds("All", sampleItems.map { it.catnum })
+        val repo = SelectionRepo(
+            dispatcher = Dispatchers.Unconfined,
+            localSource = FakeLocalSourceForSearch(sampleItems),
+            settingsRepo = fake
+        )
+        repo.setTypes(listOf("All"))
+        val results = repo.getEntriesFlow().first()
+        assertEquals(sampleItems.map { it.catnum }.toSet(), results.map { it.catnum }.toSet())
+    }
+
+    @Test
+    fun `getTypesList excludes only the Other placeholder`() = runTest {
+        val repo = createRepo(sampleItems)
+        val types = repo.getTypesList()
+        // All real TLE source types must be selectable, including "All"
+        // (CelesTrak active) and "ARISS" (removed by the old removeAt(0)).
+        assertTrue("All" in types)
+        assertTrue("ARISS" in types)
+        assertTrue("R4UAB" in types)
+        assertTrue("SatNOGS" in types)
+        assertTrue("Other" !in types)
+    }
+
+    @Test
+    fun `all types shows all items`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setTypes(emptyList()) // "All" = no type filtering
+        val results = repo.getEntriesFlow().first()
+        assertEquals(sampleItems.size, results.size)
+        assertEquals(sampleItems.map { it.catnum }.toSet(), results.map { it.catnum }.toSet())
+    }
+
+    private fun createRepo(
+        items: List<SatItem>,
+        sstvIds: List<Int> = emptyList()
+    ): ISelectionRepo {
         return SelectionRepo(
             dispatcher = Dispatchers.Unconfined,
-            localSource = FakeLocalSourceForSearch(items),
+            localSource = FakeLocalSourceForSearch(items, sstvIds),
             settingsRepo = FakeSettingsRepoForSearch()
         )
     }
 }
 
-private class FakeLocalSourceForSearch(private val items: List<SatItem>) : ILocalSource {
+private class FakeLocalSourceForSearch(
+    private val items: List<SatItem>,
+    private val sstvIds: List<Int> = emptyList()
+) : ILocalSource {
     override suspend fun getEntriesTotal(): Int = items.size
     override suspend fun getEntriesList(): List<SatItem> = items
     override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
     override suspend fun insertEntries(entries: List<OrbitalData>) = Unit
     override suspend fun deleteEntries() = Unit
-    override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+    override suspend fun getIdsWithModes(modes: List<String>): List<Int> = sstvIds
+    override suspend fun getIdsWithModesAndUplink(modes: List<String>): List<Int> = sstvIds
+    override suspend fun getIdsWithModesAndAmateur(modes: List<String>): List<Int> = sstvIds
     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
@@ -136,6 +295,7 @@ private class FakeLocalSourceForSearch(private val items: List<SatItem>) : ILoca
 }
 
 private class FakeSettingsRepoForSearch : ISettingsRepo {
+    private val typeIds = mutableMapOf<String, List<Int>>()
     override val appVersionName: String = "test"
     override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
     override val selectedTypes: StateFlow<List<String>> = MutableStateFlow(emptyList())
@@ -170,8 +330,12 @@ private class FakeSettingsRepoForSearch : ISettingsRepo {
     override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean = true
     override fun setStationPosition(): Boolean = true
     override fun setStationPosition(locator: String): Boolean = true
-    override fun getSatelliteTypesIds(types: List<String>): List<Int> = emptyList()
-    override fun setSatelliteTypeIds(type: String, ids: List<Int>) = Unit
+    override fun getSatelliteTypesIds(types: List<String>): List<Int> =
+        types.flatMap { typeIds[it].orEmpty() }.distinct()
+
+    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
+        typeIds[type] = ids
+    }
     override fun updateDatabaseState(state: DatabaseState) = Unit
     override fun updateRCSettings(settings: RCSettings) = Unit
     override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) = Unit
@@ -179,6 +343,8 @@ private class FakeSettingsRepoForSearch : ISettingsRepo {
     override fun updateDataSourcesStatus(status: Map<String, Int>) = Unit
     override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
     override fun getSatelliteOffset(catnum: Int): String = ""
+    override fun getSatelliteMode(catnum: Int): String = ""
+    override fun setSatelliteMode(catnum: Int, mode: String) {}
     override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
     override fun getAmSatCallsign(): String = ""
     override fun setAmSatCallsign(callsign: String) = Unit
@@ -189,6 +355,8 @@ private class FakeSettingsRepoForSearch : ISettingsRepo {
     override fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>) = Unit
     override fun getRoamedGrids(): Set<String> = emptySet()
     override fun setRoamedGrids(grids: Set<String>) = Unit
+    override fun getMarkedGridStations(): Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> = emptyMap()
+    override fun setMarkedGridStations(stations: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>) = Unit
     override fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) = Unit
     override fun getLastLotwSyncDate(): String = ""
     override fun setLastLotwSyncDate(date: String) = Unit

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/logbook/AdifCodec.kt

@@ -0,0 +1,163 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.domain.logbook
+
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+/** Small ADI codec for the logbook's actual field set (ADIF 3.1.7). */
+object AdifCodec {
+    private val utc = TimeZone.getTimeZone("UTC")
+
+    fun encode(records: List<QsoRecord>): String = buildString {
+        append(field("ADIF_VER", "3.1.7"))
+        append(field("PROGRAMID", "Look4Sat"))
+        append("<EOH>\r\n")
+        records.forEach { record ->
+            val startDate = format(record.startUtcMillis, "yyyyMMdd")
+            val startTime = format(record.startUtcMillis, "HHmmss")
+            append(field("QSO_DATE", startDate))
+            append(field("TIME_ON", startTime))
+            record.endUtcMillis?.let {
+                append(field("QSO_DATE_OFF", format(it, "yyyyMMdd")))
+                append(field("TIME_OFF", format(it, "HHmmss")))
+            }
+            append(field("CALL", record.theirCallsign))
+            append(field("STATION_CALLSIGN", record.myCallsign))
+            appendOptional("MODE", record.mode)
+            appendOptional("SUBMODE", record.submode)
+            appendOptional("GRIDSQUARE", record.theirGrid)
+            appendOptional("MY_GRIDSQUARE", record.myGrid)
+            appendOptional("RST_SENT", record.sentReport)
+            appendOptional("RST_RCVD", record.receivedReport)
+            record.txFrequencyHz?.let { append(field("FREQ", hzToMhz(it))) }
+            record.rxFrequencyHz?.let { append(field("FREQ_RX", hzToMhz(it))) }
+            appendOptional("BAND", record.band)
+            appendOptional("BAND_RX", record.rxBand)
+            appendOptional("PROP_MODE", record.propagationMode.ifBlank { if (record.satelliteName.isNotBlank()) "SAT" else "" })
+            appendOptional("SAT_NAME", record.satelliteName)
+            appendOptional("SAT_MODE", record.satelliteMode)
+            if (record.lotwConfirmed) append(field("LOTW_QSL_RCVD", "Y"))
+            if (record.lotwReceived) append(field("LOTW_QSL_SENT", "Y"))
+            appendOptional("LOTW_QSLRDATE", record.lotwQslDate)
+            appendOptional("VUCC_GRIDS", record.vuccGrids.joinToString(","))
+            record.dxcc?.let { append(field("DXCC", it.toString())) }
+            appendOptional("COUNTRY", record.country)
+            record.cqZone?.let { append(field("CQZ", it.toString())) }
+            appendOptional("STATE", record.region)
+            appendOptional("COMMENT", record.comment)
+            appendOptional("APP_LOOK4SAT_TRANSPONDER", record.transponderName)
+            record.passAosUtcMillis?.let { append(field("APP_LOOK4SAT_PASS_AOS", it.toString())) }
+            append(field("APP_LOOK4SAT_AUTOMATIC", if (record.automatic) "Y" else "N"))
+            append(field("APP_LOOK4SAT_STATUS", record.status.name))
+            append("<EOR>\r\n")
+        }
+    }
+
+    fun decode(content: String): List<QsoRecord> = decodeRecords(splitRecords(content))
+
+    fun decodeRecords(records: List<Map<String, String>>): List<QsoRecord> = records.mapNotNull { values ->
+        val call = values["CALL"].orEmpty().trim().uppercase(Locale.US)
+        val date = values["QSO_DATE"].orEmpty()
+        val time = values["TIME_ON"].orEmpty()
+        if (call.isBlank() || date.length != 8 || time.length !in setOf(4, 6)) return@mapNotNull null
+        val start = parse(date, time) ?: return@mapNotNull null
+        val end = values["QSO_DATE_OFF"]?.let { endDate ->
+            values["TIME_OFF"]?.let { endTime -> parse(endDate, endTime) }
+        }
+        QsoRecord(
+            startUtcMillis = start,
+            endUtcMillis = end,
+            theirCallsign = call,
+            myCallsign = values["STATION_CALLSIGN"].orEmpty().uppercase(Locale.US),
+            theirGrid = values["GRIDSQUARE"].orEmpty().uppercase(Locale.US),
+            myGrid = values["MY_GRIDSQUARE"].orEmpty().uppercase(Locale.US),
+            sentReport = values["RST_SENT"].orEmpty(),
+            receivedReport = values["RST_RCVD"].orEmpty(),
+            txFrequencyHz = mhzToHz(values["FREQ"]),
+            rxFrequencyHz = mhzToHz(values["FREQ_RX"]),
+            band = values["BAND"].orEmpty(),
+            rxBand = values["BAND_RX"].orEmpty(),
+            mode = values["MODE"].orEmpty(),
+            submode = values["SUBMODE"].orEmpty(),
+            satelliteName = values["SAT_NAME"].orEmpty(),
+            transponderName = values["APP_LOOK4SAT_TRANSPONDER"].orEmpty(),
+            satelliteMode = values["SAT_MODE"].orEmpty(),
+            passAosUtcMillis = values["APP_LOOK4SAT_PASS_AOS"]?.toLongOrNull(),
+            automatic = values["APP_LOOK4SAT_AUTOMATIC"].equals("Y", true),
+            status = values["APP_LOOK4SAT_STATUS"]?.let { runCatching { QsoStatus.valueOf(it) }.getOrNull() }
+                ?: QsoStatus.COMPLETE,
+            propagationMode = values["PROP_MODE"].orEmpty().trim().uppercase(Locale.US),
+            lotwConfirmed = values["LOTW_QSL_RCVD"].equals("Y", true),
+            lotwReceived = values["LOTW_QSL_SENT"].equals("Y", true),
+            lotwQslDate = values["LOTW_QSLRDATE"].orEmpty(),
+            vuccGrids = values["VUCC_GRIDS"].orEmpty().split(',').map { it.trim().uppercase(Locale.US) }
+                .filter { it.matches(Regex("[A-R]{2}[0-9]{2}([A-X]{2}([0-9]{2})?)?")) }.distinct(),
+            dxcc = values["DXCC"]?.toIntOrNull(),
+            country = values["COUNTRY"].orEmpty(),
+            cqZone = values["CQZ"]?.toIntOrNull()?.takeIf { it in 1..40 },
+            region = values["STATE"].orEmpty().substringBefore(" // ").trim().uppercase(Locale.US),
+            comment = values["COMMENT"].orEmpty()
+        )
+    }
+
+    private fun splitRecords(content: String): List<Map<String, String>> {
+        val records = mutableListOf<Map<String, String>>()
+        var values = linkedMapOf<String, String>()
+        var index = 0
+        while (index < content.length) {
+            val start = content.indexOf('<', index)
+            if (start < 0) break
+            val end = content.indexOf('>', start + 1)
+            if (end < 0) break
+            val descriptor = content.substring(start + 1, end)
+            val parts = descriptor.split(':')
+            val name = parts.first().trim().uppercase(Locale.US)
+            index = end + 1
+            when (name) {
+                "EOH" -> values.clear()
+                "EOR" -> {
+                    if (values.isNotEmpty()) records += values.toMap()
+                    values = linkedMapOf()
+                }
+                else -> {
+                    val length = parts.getOrNull(1)?.toIntOrNull() ?: continue
+                    if (length < 0 || index + length > content.length) continue
+                    values[name] = content.substring(index, index + length)
+                    index += length
+                }
+            }
+        }
+        return records
+    }
+
+    private fun StringBuilder.appendOptional(name: String, value: String) {
+        if (value.isNotBlank()) append(field(name, value))
+    }
+
+    private fun field(name: String, value: String): String = "<$name:${value.length}>$value"
+
+    private fun hzToMhz(value: Long): String = String.format(Locale.US, "%.6f", value / 1_000_000.0)
+
+    private fun mhzToHz(value: String?): Long? = value?.toDoubleOrNull()?.let { (it * 1_000_000.0).toLong() }
+
+    private fun format(value: Long, pattern: String): String =
+        SimpleDateFormat(pattern, Locale.US).apply { timeZone = utc }.format(Date(value))
+
+    private fun parse(date: String, time: String): Long? = runCatching {
+        val normalizedTime = if (time.length == 4) "${time}00" else time
+        SimpleDateFormat("yyyyMMddHHmmss", Locale.US).apply {
+            isLenient = false
+            timeZone = utc
+        }.parse(date + normalizedTime)?.time
+    }.getOrNull()
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/logbook/IQsoRepository.kt

@@ -0,0 +1,25 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.domain.logbook
+
+import kotlinx.coroutines.flow.Flow
+
+interface IQsoRepository {
+    val records: Flow<List<QsoRecord>>
+
+    suspend fun find(id: Long): QsoRecord?
+    suspend fun save(record: QsoRecord): Long
+    suspend fun delete(id: Long)
+    suspend fun markUploaded(ids: List<Long>)
+    suspend fun exportAdi(ids: Set<Long>? = null, includeIncomplete: Boolean = false): String
+    suspend fun importAdi(content: String): AdifImportResult
+    suspend fun mergeConfirmed(records: List<QsoRecord>): AdifImportResult
+    suspend fun mergeLoTW(records: List<QsoRecord>): AdifImportResult
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/logbook/LoTWReportBridge.kt

@@ -0,0 +1,28 @@
+package com.rtbishop.look4sat.core.domain.logbook
+
+import com.rtbishop.look4sat.core.domain.model.GridQso
+
+/** Bridge a LoTW report QSO (confirmed, download side) into a logbook record
+ *  so the logbook can show downloaded confirmations and mark local uploads
+ *  as confirmed (matched by [sameConfirmedContact]). */
+fun GridQso.toConfirmedRecord(accountCallsign: String): QsoRecord = QsoRecord(
+    startUtcMillis = epochMs,
+    theirCallsign = call,
+    myCallsign = accountCallsign.trim().uppercase(),
+    myGrid = (myGrids.firstOrNull() ?: myGrid).orEmpty(),
+    vuccGrids = myGrids.toList(),
+    band = bandUp,
+    rxBand = bandDown,
+    mode = mode,
+    // On satellites, MODE=MFSK means FT4 (ADIF pairing); keep the sub-mode so
+    // confirmations match local FT4 records (mode=MFSK, submode=FT4).
+    submode = if (mode.equals("MFSK", true)) "FT4" else "",
+    satelliteName = satName,
+    propagationMode = "SAT",
+    status = QsoStatus.COMPLETE,
+    lotwConfirmed = true,
+    dxcc = dxcc,
+    country = country.orEmpty(),
+    cqZone = cqz,
+    region = state.orEmpty()
+)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/logbook/QsoConfirmationMerge.kt

@@ -0,0 +1,70 @@
+package com.rtbishop.look4sat.core.domain.logbook
+
+import java.util.Locale
+import kotlin.math.abs
+
+/** LoTW official name vs SatNOGS name ("SO-50 (SaudiOSCAR 50)"): compare the
+ *  parenthetical-free prefix so local records and downloaded confirmations match. */
+fun satMatchKey(name: String): String = name.substringBefore('(').trim().uppercase(Locale.US)
+
+/** LoTW omits frequency and may round time to a minute. Only merge an unambiguous contact. */
+fun sameConfirmedContact(local: QsoRecord, remote: QsoRecord): Boolean =
+    local.theirCallsign.trim().equals(remote.theirCallsign.trim(), true) &&
+        (local.myCallsign.isBlank() || remote.myCallsign.isBlank() || local.myCallsign.equals(remote.myCallsign, true)) &&
+        satMatchKey(local.satelliteName) == satMatchKey(remote.satelliteName) &&
+        local.isSatellite == remote.isSatellite &&
+        local.displayMode == remote.displayMode &&
+        (local.band.isBlank() || remote.band.isBlank() || local.band.equals(remote.band, true)) &&
+        abs(local.startUtcMillis - remote.startUtcMillis) < 60_000L
+
+fun QsoRecord.confirmationLookupKey(): String = listOf(
+    theirCallsign.trim().uppercase(Locale.US), satMatchKey(satelliteName), displayMode
+).joinToString("|")
+
+fun QsoRecord.withConfirmation(confirmed: QsoRecord): QsoRecord = copy(
+    myCallsign = myCallsign.ifBlank { confirmed.myCallsign },
+    theirGrid = confirmed.theirGrid.ifBlank { theirGrid },
+    myGrid = myGrid.ifBlank { confirmed.myGrid },
+    sentReport = sentReport.ifBlank { confirmed.sentReport },
+    receivedReport = receivedReport.ifBlank { confirmed.receivedReport },
+    txFrequencyHz = txFrequencyHz ?: confirmed.txFrequencyHz,
+    rxFrequencyHz = rxFrequencyHz ?: confirmed.rxFrequencyHz,
+    band = band.ifBlank { confirmed.band },
+    rxBand = rxBand.ifBlank { confirmed.rxBand },
+    propagationMode = propagationMode.ifBlank { confirmed.propagationMode },
+    status = QsoStatus.COMPLETE,
+    lotwConfirmed = lotwConfirmed || confirmed.lotwConfirmed,
+    lotwReceived = lotwReceived || confirmed.lotwReceived || confirmed.lotwConfirmed,
+    lotwQslDate = confirmed.lotwQslDate.ifBlank { lotwQslDate },
+    vuccGrids = confirmed.vuccGrids.ifEmpty { vuccGrids },
+    dxcc = confirmed.dxcc ?: dxcc,
+    country = confirmed.country.ifBlank { country },
+    cqZone = confirmed.cqZone ?: cqZone,
+    region = confirmed.region.ifBlank { region }
+)
+
+val QsoRecord.displayMode: String
+    get() {
+        // Satellite FT4 is MODE=MFSK + SUBMODE=FT4; any other mode keeps its own
+        // label even when a stale submode default ("FT4") was persisted.
+        val label = if (mode.equals("MFSK", true) && submode.isNotBlank()) submode else mode
+        return label.trim().uppercase(Locale.US)
+    }
+
+val QsoRecord.isSatellite: Boolean
+    get() = propagationMode.equals("SAT", true) || (propagationMode.isBlank() && satelliteName.isNotBlank())
+
+fun frequencyBand(hz: Long?): String = when (hz) {
+    null -> ""
+    in 28_000_000L..29_700_000L -> "10M"
+    in 50_000_000L..54_000_000L -> "6M"
+    in 144_000_000L..148_000_000L -> "2M"
+    in 219_000_000L..225_000_000L -> "1.25M"
+    in 420_000_000L..450_000_000L -> "70CM"
+    in 902_000_000L..928_000_000L -> "33CM"
+    in 1_240_000_000L..1_300_000_000L -> "23CM"
+    in 2_300_000_000L..2_450_000_000L -> "13CM"
+    in 5_650_000_000L..5_925_000_000L -> "6CM"
+    in 10_000_000_000L..10_500_000_000L -> "3CM"
+    else -> ""
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/logbook/QsoModels.kt

@@ -0,0 +1,49 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.domain.logbook
+
+enum class QsoStatus { DRAFT, COMPLETE, ABORTED }
+
+data class QsoRecord(
+    val id: Long = 0L,
+    val startUtcMillis: Long,
+    val endUtcMillis: Long? = null,
+    val theirCallsign: String,
+    val myCallsign: String,
+    val theirGrid: String = "",
+    val myGrid: String = "",
+    val sentReport: String = "",
+    val receivedReport: String = "",
+    val txFrequencyHz: Long? = null,
+    val rxFrequencyHz: Long? = null,
+    val band: String = "",
+    val rxBand: String = "",
+    val mode: String = "FM",
+    val submode: String = "",
+    val satelliteName: String = "",
+    val transponderName: String = "",
+    val satelliteMode: String = "",
+    val passAosUtcMillis: Long? = null,
+    val automatic: Boolean = false,
+    val status: QsoStatus = QsoStatus.DRAFT,
+    val propagationMode: String = if (satelliteName.isNotBlank()) "SAT" else "",
+    val lotwConfirmed: Boolean = false,
+    val lotwUploaded: Boolean = false,
+    val lotwReceived: Boolean = false,
+    val lotwQslDate: String = "",
+    val vuccGrids: List<String> = emptyList(),
+    val dxcc: Int? = null,
+    val country: String = "",
+    val cqZone: Int? = null,
+    val region: String = "",
+    val comment: String = ""
+)
+
+data class AdifImportResult(val imported: Int, val skipped: Int, val updated: Int = 0)

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

@@ -49,8 +49,27 @@ data class GridQso(
     val country: String? = null,
     val cqz: Int? = null,
     val state: String? = null,
-    /** 4-char grid the station itself operated from (ADIF MY_GRIDSQUARE). */
-    val myGrid: String? = null
+    /** 4-char grid the station itself operated from (ADIF MY_GRIDSQUARE).
+     *  Kept as the first entry of [myGrids] for backward compatibility with
+     *  consumers that predate multi-grid station locations. */
+    val myGrid: String? = null,
+    /** Every 4-char grid the station operated from for this QSO — ADIF
+     *  <MY_GRIDSQUARE> plus every field of <MY_VUCC_GRIDS> (a comma-separated
+     *  list LoTW emits when one station location roams across several grid
+     *  squares; MY_GRIDSQUARE may be absent on those records). A station
+     *  location (台址) can legitimately span multiple grids, and the map's
+     *  stripes and the operated-grid selector must show all of them. */
+    val myGrids: Set<String> = emptySet(),
+    /** Callsign of the station location this QSO was logged under (ADIF
+     *  <STATION_CALLSIGN>; e.g. "BH6RJD", "BH6RJD/P"). NOT the 台址 identity
+     *  on its own — one callsign can have several station locations. */
+    val myCallsign: String? = null,
+    /** Stable key of the station location (台址) this QSO was logged under,
+     *  derived from the MY_* station fields (STATION_CALLSIGN + MY_DXCC +
+     *  MY_STATE + MY_CQ_ZONE + MY_ITU_ZONE + MY_IOTA + MY_COUNTRY), so the
+     *  operated-grid selector can group QSOs per 台址 and show each 台址 with
+     *  its full grid set. Null for data synced before this field existed. */
+    val stationKey: String? = null
 ) {
     /** Short uplink/downlink band label ("U/V", "V/A"), or "" when unknown. */
     val bandLabel: String

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

@@ -0,0 +1,31 @@
+/*
+ * 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
+
+/**
+ * A station the user marked in a gridsquare they have NOT yet worked — a
+ * reminder to try to contact that callsign. Stored per 4-char grid (one mark
+ * per grid).
+ *
+ * @param call      the callsign the user wants to work (uppercase)
+ * @param epochMs   the moment the mark was created, UTC milliseconds
+ */
+data class MarkedStation(
+    val call: String,
+    val epochMs: Long
+)

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

@@ -33,6 +33,10 @@ data class SatRadio(
     @SerialName("uplink_mode") val uplinkMode: String?,
     @SerialName("invert") val isInverted: Boolean,
     @SerialName("norad_cat_id") val catnum: Int?,
+    /** Service class from the transceiver source ("Amateur"/"Unknown" etc.).
+     *  Used by the SSTV virtual filter to tell amateur satellites apart from
+     *  debris / weather birds (TIROS) / launcher stages (Ariane 6 R/B). */
+    @SerialName("service") val service: String? = null,
     /** Set for manually imported transceivers, which remote updates must not replace. */
     val isCustom: Boolean = false
 )

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

@@ -75,9 +75,23 @@ data class OtherSettings(
      *  ephemeris auto-update; only effective after at least one manual sync). */
     val stateOfAutoLotwSync: Boolean = true,
     /** 指南针手动航向偏置(度, -180..180): 雷达方位 = 传感器方位 + 磁偏角 + 该偏置. */
-    val compassOffsetDegrees: Float = 0f
+    val compassOffsetDegrees: Float = 0f,
+    val mapSource: String = MapSource.OSM,
+    val tiandituKey: String = ""
 )
 
+object MapSource {
+    const val OSM = "osm"
+    const val TIANDITU_VECTOR = "tianditu_vector"
+    const val TIANDITU_IMAGE = "tianditu_image"
+    private const val LEGACY_TIANDITU = "tianditu"
+
+    fun normalize(source: String): String = when (source) {
+        OSM, TIANDITU_VECTOR, TIANDITU_IMAGE -> source
+        LEGACY_TIANDITU -> TIANDITU_VECTOR
+        else -> OSM
+    }
+}
 data class DataSourcesSettings(
     val satelliteUrls: List<String>,
     val transceiversUrls: List<String>,

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

@@ -0,0 +1,101 @@
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+
+interface ILoTWUploadRepository {
+    suspend fun certificate(): LoTWCertificate?
+    suspend fun station(): LoTWStation?
+    suspend fun importCertificate(data: ByteArray, password: CharArray): LoTWCertificate
+    suspend fun saveCertificatePassword(password: CharArray): LoTWCertificate
+    suspend fun saveStation(station: LoTWStation): LoTWStation
+    suspend fun removeCertificate()
+    /** Region field (State/Province/Prefecture…) and national CQZ/ITUZ map for a DXCC entity. */
+    suspend fun stationMeta(dxcc: Int): LoTWStationMeta
+    suspend fun audit(records: List<QsoRecord>): LoTWUploadAudit
+    suspend fun prepare(records: List<QsoRecord>, resubmit: Boolean): LoTWUploadPreview
+    suspend fun upload(previewId: String): LoTWUploadResult
+    fun discardPreview()
+}
+
+data class LoTWCertificate(
+    val callsign: String,
+    val dxcc: Int,
+    val serial: String,
+    val expires: String,
+    val firstQsoDate: String,
+    val lastQsoDate: String,
+    val passwordSaved: Boolean = false
+)
+
+/** The location is explicitly confirmed for the selected contacts, not inferred from today's GPS. */
+data class LoTWStation(
+    val grid: String = "",
+    val cqZone: String = "",
+    val ituZone: String = "",
+    val region: String = "",
+    val county: String = "",
+    val iota: String = ""
+)
+
+/** One (ITU:CQ) pair from a LoTW zonemap, e.g. Guangdong is 44:24. */
+data class LoTWZonePair(val itu: Int, val cq: Int)
+
+/** One selectable region code with the zones it maps to (cross-zone regions carry several pairs). */
+data class LoTWRegionOption(val code: String, val name: String, val zones: List<LoTWZonePair>)
+
+/** Country-dependent region field (US_STATE, CN_PROVINCE, …) with its selectable options. */
+data class LoTWRegionField(val id: String, val label: String, val options: List<LoTWRegionOption>)
+
+/**
+ * Everything the station-location UI needs for one DXCC entity:
+ * the region field to show (null when the country has none) and the national
+ * zonemap (used to prefill CQZ/ITUZ when the country has a single zone pair).
+ */
+data class LoTWStationMeta(
+    val regionField: LoTWRegionField? = null,
+    val countryZones: List<LoTWZonePair> = emptyList()
+)
+
+data class LoTWUploadPreview(
+    val id: String,
+    val callsign: String,
+    val dxcc: Int,
+    val grid: String,
+    val count: Int,
+    val skipped: Int,
+    val firstUtc: String,
+    val lastUtc: String,
+    val contacts: List<String>,
+    val unknownSkipped: Int = 0,
+    /** Un-signable records (invalid call/date/…) skipped instead of aborting the batch. */
+    val unavailableSkipped: Int = 0,
+    /** Ids of the records that actually made it into this TQ8 batch. Only these
+     *  may be marked "uploaded" after an accepted POST — never the full candidate list. */
+    val submittedIds: List<Long> = emptyList()
+)
+
+/** Local comparison against downloaded LoTW receipt flags and this app's durable upload receipts. */
+data class LoTWUploadAudit(
+    val total: Int,
+    val pending: Int,
+    val uploaded: Int,
+    val unknown: Int,
+    val unavailable: Int
+)
+
+sealed interface LoTWUploadResult {
+    data class Accepted(val count: Int) : LoTWUploadResult
+    data class Rejected(val message: String = "") : LoTWUploadResult
+    /** May have reached LoTW. Do not retry automatically. */
+    data object Unknown : LoTWUploadResult
+    data object ExpiredPreview : LoTWUploadResult
+}
+
+class LoTWOperationException(val reason: LoTWProblem, val detail: String = "") : Exception(reason.name)
+
+enum class LoTWProblem {
+    CERTIFICATE_PASSWORD, CERTIFICATE_INVALID, CERTIFICATE_EXPIRED, CERTIFICATE_MISSING,
+    CERTIFICATE_FORMAT, STORAGE, EMPTY_SELECTION, CALLSIGN_MISMATCH, QSO_DATE, STATION_GRID,
+    STATION_REGION, STATION_ZONE, STATION_IOTA, MODE, BAND, SATELLITE, INVALID_CONTACT,
+    LOCATION_MISMATCH, TOO_MANY_CONTACTS
+}

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

@@ -16,6 +16,7 @@
  * 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.logbook.IQsoRepository
 import com.rtbishop.look4sat.core.domain.model.SatRadio
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
 import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
@@ -34,6 +35,8 @@ interface IMainContainer {
     val updateRepo: IUpdateRepository
     val wavelogRepo: IWavelogRepository
     val lotwRepo: com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
+    val qsoRepository: IQsoRepository
+    val lotwUploadRepository: ILoTWUploadRepository
     val radioTrackingService: IRadioTrackingService
     val mutualPassData: StateFlow<MutualPassData>
     fun setMutualPassData(data: MutualPassData)

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

@@ -65,4 +65,19 @@ interface ISatelliteRepo {
 
     /** Fetch radio transceivers for a satellite by its catalog number. */
     suspend fun getRadiosWithId(id: Int): List<SatRadio>
+
+    /** Satellite catnums whose radios carry any of the given downlink modes.
+     *  Empty modes -> empty result; used to filter the mutual-match satellite
+     *  set to transponder satellites (FM voice / linear). */
+    suspend fun getSatelliteIdsWithModes(modes: List<String>): List<Int>
+
+    /** Like [getSatelliteIdsWithModes] but only matches records with an uplink
+     *  (real transponders), excluding downlink-only beacons/telemetry that share
+     *  the same mode label. Used by the FM/Linear fallback filter. */
+    suspend fun getSatelliteIdsWithModesAndUplink(modes: List<String>): List<Int>
+
+    /** Like [getSatelliteIdsWithModes] but only matches records whose service
+     *  class is "Amateur", so SSTV never matches weather birds (TIROS),
+     *  launcher debris or other non-amateur transmitters. */
+    suspend fun getSatelliteIdsWithModesAndAmateur(modes: List<String>): List<Int>
 }

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

@@ -89,6 +89,12 @@ interface ISettingsRepo {
     fun setSatelliteOffset(catnum: Int, offset: String)
     //endregion
 
+    //region # Per-satellite logbook mode preset settings
+    /** Last selected logbook mode (CW/SSB/FT4) for a satellite; empty when unset. */
+    fun getSatelliteMode(catnum: Int): String
+    fun setSatelliteMode(catnum: Int, mode: String)
+    //endregion
+
     //region # AMSAT status report settings
     fun getAmSatCallsign(): String
     fun setAmSatCallsign(callsign: String)
@@ -105,6 +111,11 @@ interface ISettingsRepo {
     /** Distinct 4-char gridsquares the account operated from (LoTW <MY_GRIDSQUARE>). */
     fun getRoamedGrids(): Set<String>
     fun setRoamedGrids(grids: Set<String>)
+    /** Stations the user marked as "want to contact" in unworked gridsquares
+     *  (grid -> ordered list of marks; the first is the pinned/top one). The
+     *  whole grid clears automatically once it becomes worked. */
+    fun getMarkedGridStations(): Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>
+    fun setMarkedGridStations(stations: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>)
     //endregion
 
     //region # LoTW confirmed-grids settings

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

@@ -29,6 +29,8 @@ interface ILocalSource {
     suspend fun insertEntries(entries: List<OrbitalData>)
     suspend fun deleteEntries()
     suspend fun getIdsWithModes(modes: List<String>): List<Int>
+    suspend fun getIdsWithModesAndUplink(modes: List<String>): List<Int>
+    suspend fun getIdsWithModesAndAmateur(modes: List<String>): List<Int>
     suspend fun getRadiosTotal(): Int
     suspend fun getRadiosWithId(id: Int): List<SatRadio>
     suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean = false)

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

@@ -21,6 +21,8 @@ object Sources {
     val satelliteDataUrls = mapOf(
         "LAPAN-A2" to "https://www.kaggle.com/api/v1/datasets/download/muazamnugroho/lapan-a2-satellite-two-line-element-tle-dataset/LAPAN-A2_TLE_latest.txt",
         "R4UAB" to "https://r4uab.ru/satonline.txt",
+        "BI4PYM AutoTLE (GitHub)" to "https://raw.githubusercontent.com/BI4PYM/AutoTLE/refs/heads/master/AutoTLE.txt",
+        "BI4PYM AutoTLE (Mirror)" to "https://autotle.bi4pym.cn/AutoTLE.txt",
         "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
         "SatNOGS" to "https://db.satnogs.org/api/tle/?format=3le",
         "Amateur" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=csv",
@@ -55,4 +57,25 @@ object Sources {
         "SatNOGS" to "https://db.satnogs.org/api/transmitters/?format=json&status=active",
         "R4UAB" to "https://r4uab.ru/transmitters.json"
     )
+    /**
+     * Hardcoded AMSAT Live FM satellites (NORAD catnums):
+     * SO-50 (27607), ISS ZARYA (25544), AO-123 ASRTU-1 (61781).
+     * Replaces the AMSAT live-page fetch: stable on any network, no
+     * sync-time dependency, no stale-list or timeout failure modes.
+     */
+    val amSatFmCatnums = setOf(27607, 25544, 61781)
+
+    /**
+     * Hardcoded AMSAT Live linear (SSB/CW) satellites:
+     * RS-44 (44909), FO-29 (24278), AO-7 (7530),
+     * AO-73 FUNcube-1 (39444), JO-97 JY1SAT (43803).
+     */
+    val amSatLinearCatnums = setOf(44909, 24278, 7530, 39444, 43803)
+
+    /** Virtual satellite-selection types: transponder/activity filters shown
+     *  at the top of the type picker. They resolve to live lists (hardcoded
+     *  FM/Linear catnum sets or mode=SSTV radios) instead of persisted
+     *  per-type IDs, and are mutually exclusive with the regular TLE-source
+     *  types in the picker. */
+    val virtualTypeNames = listOf("AMSAT Live FM", "AMSAT Live Linear", "Live SSTV")
 }

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/logbook/AdifCodecTest.kt

@@ -0,0 +1,86 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.domain.logbook
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class AdifCodecTest {
+
+    @Test
+    fun encodeDecode_roundTrip() {
+        val record = QsoRecord(
+            startUtcMillis = 1_700_000_000_000L,
+            endUtcMillis = 1_700_000_000_100L,
+            theirCallsign = "BG5JVM",
+            myCallsign = "BA7OPF",
+            theirGrid = "OM60",
+            myGrid = "OL62TI",
+            sentReport = "59",
+            receivedReport = "59",
+            txFrequencyHz = 145_850_000L,
+            rxFrequencyHz = 436_805_000L,
+            band = "2M",
+            rxBand = "70CM",
+            mode = "FM",
+            satelliteName = "SO-50",
+            satelliteMode = "FM",
+            propagationMode = "SAT",
+            status = QsoStatus.COMPLETE,
+            lotwConfirmed = true,
+            lotwQslDate = "2026-09-20",
+            vuccGrids = listOf("OM60", "OM50")
+        )
+        val decoded = AdifCodec.decode(AdifCodec.encode(listOf(record))).single()
+        assertEquals(record.startUtcMillis, decoded.startUtcMillis)
+        assertEquals(record.theirCallsign, decoded.theirCallsign)
+        assertEquals(record.myCallsign, decoded.myCallsign)
+        assertEquals(record.satelliteName, decoded.satelliteName)
+        assertEquals("2M", decoded.band)
+        assertEquals("70CM", decoded.rxBand)
+        assertTrue(decoded.lotwConfirmed)
+        assertEquals(listOf("OM60", "OM50"), decoded.vuccGrids)
+    }
+
+    @Test
+    fun decode_lotwStyleReportFields() {
+        // LoTW report subset: lowercase eor, alphabetical fields, VUCC_GRIDS list.
+        val adi = """
+            <EOH>
+            <CALL:6>BH6RJD
+            <QSO_DATE:8>20260916
+            <TIME_ON:6>051300
+            <MODE:2>FM
+            <SAT_NAME:5>SO-50
+            <PROP_MODE:3>SAT
+            <BAND:3>2M
+            <BAND_RX:4>70CM
+            <GRIDSQUARE:4>OM60
+            <MY_GRIDSQUARE:8>OM60IL70
+            <VUCC_GRIDS:9>OM60,OM50
+            <STATION_CALLSIGN:6>BH6RJD
+            <DXCC:3>318
+            <COUNTRY:5>China
+            <LOTW_QSL_RCVD:1>Y
+            <eor>
+        """.trimIndent()
+        val records = AdifCodec.decode(adi)
+        assertEquals(1, records.size)
+        val record = records.single()
+        assertEquals("BH6RJD", record.theirCallsign)
+        assertEquals("SO-50", record.satelliteName)
+        assertEquals("FM", record.displayMode)
+        assertEquals("OM60IL70", record.myGrid)
+        assertEquals(listOf("OM60", "OM50"), record.vuccGrids)
+        assertTrue(record.lotwConfirmed)
+        assertTrue(record.isSatellite)
+    }
+}

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/logbook/LogbookMergeTest.kt

@@ -0,0 +1,136 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.domain.logbook
+
+import com.rtbishop.look4sat.core.domain.model.GridQso
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class LogbookMergeTest {
+
+    private val local = QsoRecord(
+        startUtcMillis = 1_700_000_000_000L,
+        theirCallsign = "bg5jvm",
+        myCallsign = "ba7opf",
+        txFrequencyHz = 145_850_000L,
+        mode = "FM",
+        submode = "",
+        satelliteName = "SO-50 (SaudiOSCAR 50)",
+        propagationMode = "SAT",
+        status = QsoStatus.COMPLETE
+    )
+
+    private val confirmed = QsoRecord(
+        startUtcMillis = 1_700_000_000_000L,
+        theirCallsign = "BG5JVM",
+        myCallsign = "BA7OPF",
+        mode = "FM",
+        submode = "",
+        satelliteName = "SO-50",
+        propagationMode = "SAT",
+        status = QsoStatus.COMPLETE,
+        lotwConfirmed = true,
+        vuccGrids = listOf("OM60", "OM50")
+    )
+
+    @Test
+    fun satMatchKey_stripsParenthetical() {
+        assertEquals("SO-50", satMatchKey("SO-50 (SaudiOSCAR 50)"))
+        assertEquals("SO-50", satMatchKey("SO-50"))
+        assertEquals("AO-91", satMatchKey("AO-91 (FUNcube-1)"))
+        assertEquals("IO-86", satMatchKey("IO-86"))
+    }
+
+    @Test
+    fun sameConfirmedContact_matchesAcrossSatNOGSAndOfficialName() {
+        assertTrue(sameConfirmedContact(local, confirmed))
+    }
+
+    @Test
+    fun sameConfirmedContact_rejectsDifferentSatellite() {
+        val other = confirmed.copy(satelliteName = "AO-91")
+        assertFalse(sameConfirmedContact(local, other))
+    }
+
+    @Test
+    fun sameConfirmedContact_rejectsTimeSkew() {
+        val skewed = confirmed.copy(startUtcMillis = confirmed.startUtcMillis + 120_000L)
+        assertFalse(sameConfirmedContact(local, skewed))
+    }
+
+    @Test
+    fun confirmationLookupKey_usesNormalizedSatellite() {
+        assertEquals(local.confirmationLookupKey(), confirmed.confirmationLookupKey())
+    }
+
+    @Test
+    fun withConfirmation_marksConfirmedAndMergesVuccGrids() {
+        val merged = local.withConfirmation(confirmed)
+        assertTrue(merged.lotwConfirmed)
+        assertTrue(merged.lotwReceived)
+        assertEquals(listOf("OM60", "OM50"), merged.vuccGrids)
+        // Local myCallsign is kept when present; only blanks are backfilled.
+        assertEquals("ba7opf", merged.myCallsign)
+    }
+
+    @Test
+    fun toConfirmedRecord_mapsGridQso() {
+        val qso = GridQso(
+            call = "BH6RJD",
+            epochMs = 1_700_000_000_000L,
+            satName = "SO-50",
+            mode = "FM",
+            bandUp = "70CM",
+            bandDown = "2M",
+            dxcc = 318,
+            country = "China",
+            cqz = 24,
+            state = "GD",
+            myGrid = "OM60",
+            myGrids = setOf("OM60", "OM50")
+        )
+        val record = qso.toConfirmedRecord("ba7opf")
+        assertEquals("BH6RJD", record.theirCallsign)
+        assertEquals("BA7OPF", record.myCallsign)
+        assertEquals("OM60", record.myGrid)
+        assertEquals(listOf("OM60", "OM50"), record.vuccGrids)
+        assertTrue(record.lotwConfirmed)
+        assertTrue(record.isSatellite)
+        assertEquals("70CM", record.band)
+        assertEquals("2M", record.rxBand)
+    }
+
+    @Test
+    fun frequencyBand_edges() {
+        assertEquals("2M", frequencyBand(144_000_000L))
+        assertEquals("70CM", frequencyBand(450_000_000L))
+        assertEquals("10M", frequencyBand(29_000_000L))
+        assertEquals("", frequencyBand(null))
+    }
+
+    @Test
+    fun displayMode_prefersSubmode() {
+        val ft4 = QsoRecord(startUtcMillis = 0, theirCallsign = "x", myCallsign = "y", mode = "MFSK", submode = "FT4")
+        assertEquals("FT4", ft4.displayMode)
+        assertEquals("FM", local.displayMode)
+    }
+
+    @Test
+    fun displayMode_ignoresStaleSubmodeForOtherModes() {
+        // Regression: records persisted with the old default submode="FT4" must not
+        // show FT4 when the actual mode is FM/CW/SSB.
+        val staleFm = QsoRecord(startUtcMillis = 0, theirCallsign = "x", myCallsign = "y", mode = "FM", submode = "FT4")
+        val staleCw = QsoRecord(startUtcMillis = 0, theirCallsign = "x", myCallsign = "y", mode = "CW", submode = "FT4")
+        assertEquals("FM", staleFm.displayMode)
+        assertEquals("CW", staleCw.displayMode)
+    }
+}

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/repository/LoTWGridSyncTest.kt

@@ -21,6 +21,7 @@ import com.rtbishop.look4sat.core.domain.model.DatabaseState
 import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
 import com.rtbishop.look4sat.core.domain.model.GridQso
 import com.rtbishop.look4sat.core.domain.model.LoTWSettings
+import com.rtbishop.look4sat.core.domain.model.MarkedStation
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
@@ -261,6 +262,9 @@ class LoTWGridSyncTest {
         override fun setWorkedGridQsos(qsos: Map<String, List<GridQso>>) { workedGridQsos = qsos }
         override fun getRoamedGrids(): Set<String> = roamedGrids
         override fun setRoamedGrids(grids: Set<String>) { roamedGrids = grids }
+        private var markedGridStations: Map<String, List<MarkedStation>> = emptyMap()
+        override fun getMarkedGridStations(): Map<String, List<MarkedStation>> = markedGridStations
+        override fun setMarkedGridStations(stations: Map<String, List<MarkedStation>>) { markedGridStations = stations }
         override fun getLastLotwSyncDate(): String = lastSyncDate
         override fun setLastLotwSyncDate(date: String) { lastSyncDate = date }
         override fun getLastLotwSyncCallsign(): String = lastSyncCallsign
@@ -281,6 +285,8 @@ class LoTWGridSyncTest {
         override fun updateDataSourcesStatus(status: Map<String, Int>) = TODO()
         override fun updateRadioControlSettings(settings: RadioControlSettings) = TODO()
         override fun getSatelliteOffset(catnum: Int): String = ""
+        override fun getSatelliteMode(catnum: Int): String = ""
+        override fun setSatelliteMode(catnum: Int, mode: String) {}
         override fun setSatelliteOffset(catnum: Int, offset: String) = TODO()
         override fun getAmSatCallsign(): String = ""
         override fun setAmSatCallsign(callsign: String) = TODO()

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

@@ -17,9 +17,15 @@
  */
 package com.rtbishop.look4sat.core.presentation
 
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.animate
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.MarqueeSpacing
+import androidx.compose.foundation.background
 import androidx.compose.foundation.basicMarquee
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -29,7 +35,9 @@ import androidx.compose.foundation.layout.RowScope
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.statusBarsPadding
@@ -49,16 +57,28 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.compositionLocalOf
+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.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
 import androidx.compose.ui.input.nestedscroll.NestedScrollSource
 import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.hideFromAccessibility
@@ -82,6 +102,8 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalData
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import java.text.SimpleDateFormat
 import java.util.Date
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
 import java.util.Locale
 import java.util.TimeZone
 
@@ -447,6 +469,134 @@ fun isVerticalLayout(): Boolean = !hasEnoughWidth()
 fun Modifier.infiniteMarquee(): Modifier =
     basicMarquee(iterations = Int.MAX_VALUE, spacing = MarqueeSpacing(16.dp))
 
+/** 共享的滑动行展开状态：同一列表内同时只允许一行展开（短信式联动）。 */
+class SwipeController {
+    var openKey by mutableStateOf<String?>(null)
+        private set
+    fun open(key: String) {
+        openKey = key
+    }
+    fun close() {
+        openKey = null
+    }
+}
+
+@Composable
+fun rememberSwipeController(): SwipeController = remember { SwipeController() }
+
+/** 短信式滑动行：右划露出 [revealButton]（默认红底垃圾桶+文字），点击按钮触发 [revealAction]。
+ *  通过 [controller] 联动：滑开新行时其他行自动收回；点按已展开的行内容也可收回（无涟漪）。 */
+@Composable
+fun SwipeRevealRow(
+    key: String,
+    controller: SwipeController,
+    modifier: Modifier = Modifier,
+    revealWidth: Dp = 64.dp,
+    revealAction: () -> Unit,
+    revealButton: @Composable () -> Unit = {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(MaterialTheme.colorScheme.error),
+            contentAlignment = Alignment.Center
+        ) {
+            Icon(
+                painter = painterResource(R.drawable.ic_delete),
+                contentDescription = null,
+                tint = Color.White,
+                modifier = Modifier.size(24.dp)
+            )
+        }
+    },
+    content: @Composable () -> Unit
+) {
+    val density = LocalDensity.current
+    val revealPx = with(density) { revealWidth.toPx() }
+    var offsetX by remember { mutableFloatStateOf(0f) }
+    var settleJob by remember { mutableStateOf<Job?>(null) }
+    val scope = rememberCoroutineScope()
+    val haptics = LocalHapticFeedback.current
+    val isOpen = controller.openKey == key
+
+    fun settle(target: Float) {
+        settleJob?.cancel()
+        settleJob = scope.launch {
+            animate(offsetX, target, animationSpec = tween(durationMillis = 200, easing = FastOutSlowInEasing)) { value, _ ->
+                offsetX = value
+            }
+        }
+    }
+
+    // 另一行展开（或全部收回）时，本行随之收回。
+    LaunchedEffect(controller.openKey) {
+        if (!isOpen && offsetX < 0f) settle(0f)
+    }
+
+    Box(modifier.fillMaxWidth().clipToBounds()) {
+        // 背景删除按钮：初始位于内容右侧屏幕外，与内容同步平移（跟手滑入）。
+        // 父 Box clipToBounds 裁剪容器外部分——即便外层 item 带 padding、按钮
+        // 左缘落在容器外的屏幕内，也因裁剪而不可见、不可点。
+        Box(
+            modifier = Modifier
+                .align(Alignment.CenterEnd)
+                .fillMaxHeight()
+                .width(revealWidth)
+                .offset(x = revealWidth)
+                .graphicsLayer { translationX = offsetX }
+                .clickable {
+                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+                    controller.close()
+                    settle(0f)
+                    revealAction()
+                }
+        ) { revealButton() }
+        // 前景内容：右划平移露出按钮
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .graphicsLayer { translationX = offsetX }
+                .pointerInput(revealPx) {
+                    detectHorizontalDragGestures(
+                        onDragStart = { settleJob?.cancel() },
+                        onHorizontalDrag = { change, dragAmount ->
+                            change.consume()
+                            offsetX = (offsetX + dragAmount).coerceIn(-revealPx, 0f)
+                        },
+                        onDragEnd = {
+                            if (offsetX < -revealPx / 2) {
+                                controller.open(key)
+                                haptics.performHapticFeedback(HapticFeedbackType.SegmentTick)
+                                settle(-revealPx)
+                            } else {
+                                controller.close()
+                                settle(0f)
+                            }
+                        },
+                        onDragCancel = {
+                            if (offsetX < -revealPx / 2) {
+                                controller.open(key)
+                                settle(-revealPx)
+                            } else {
+                                controller.close()
+                                settle(0f)
+                            }
+                        }
+                    )
+                }
+                // 已展开的行，点按内容直接收回（无涟漪，避免整行出现点击反馈）
+                .clickable(
+                    interactionSource = remember { MutableInteractionSource() },
+                    indication = null
+                ) {
+                    if (isOpen) {
+                        controller.close()
+                        settle(0f)
+                    }
+                }
+        ) { content() }
+    }
+}
+
 @Composable
 fun Modifier.layoutPadding(): Modifier {
     val spacing = LocalSpacing.current.extraSmall

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

@@ -0,0 +1,20 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <!-- 冖 (秃宝盖): 顶横 + 两侧短竖, 笔画型 -->
+    <path
+        android:pathData="M5,4 L19,4 M5,4 L5,8.5 M19,4 L19,8.5"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="2"
+        android:strokeLineCap="round"
+        android:fillColor="#00000000" />
+    <!-- 笔画型向上箭头 ↑: 竖杆 + 两斜线箭头头 -->
+    <path
+        android:pathData="M12,9 L12,20 M12,9 L7.5,14 M12,9 L16.5,14"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="2"
+        android:strokeLineCap="round"
+        android:fillColor="#00000000" />
+</vector>

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

@@ -88,7 +88,7 @@
     <!-- Map screen -->
     <string name="map_prev">Önceki</string>
     <string name="map_next">Sonraki</string>
-    <string name="map_copyright" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_osm" translatable="false">© OpenStreetMap contributors</string>
     <string name="map_azimuth">Azimut: %.1f°</string>
     <string name="map_elevation">Yükseklik açısı: %.1f°</string>
     <string name="map_altitude">İrtifa: %.0f km</string>
@@ -209,7 +209,8 @@
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
         \n• Libre Space Foundation (SatNOGS)
-        \n• BG7NTA BG5JSU (CW decoding feature)</string>
+        \n• BG7NTA BG5JSU (CW decoding feature)
+        \n• BH2VSQ BG5JSU (TianDiTu rendering support)</string>
     <string name="prefs_outro_license">Bu uygulama herhangi bir garanti sunmaz</string>
 
 </resources>

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

@@ -28,7 +28,7 @@
     <string name="pass_filter_title">筛选过境</string>
     <string name="pass_filter_elev">仰角值</string>
     <string name="pass_filter_hours">提前时间</string>
-    <string name="pass_filter_history_hours">先前时间</string>
+    <string name="pass_filter_history_hours">历史过境时间</string>
     <string name="pass_filter_aos_time">AOS 时间段</string>
     <string name="pass_filter_invert_time">反选 AOS 时间段</string>
     <string name="pass_filter_deep_space">DeepSpace（周期 &gt;225分钟）</string>
@@ -41,7 +41,7 @@
     <string name="pass_welcome_message">请务必在设置中通过GPS、经纬度或QTH定位您的位置\n建议至少每周更新一次数据库，以确保预测结果的准确性</string>
 
     <!-- AMSAT Status screen -->
-    <string name="pass_whatsnew_message">4.4.6 以来的全部更新（4.4.7 系列）：\n\n• 网格模式地图：LoTW 已确认网格绿色填充、漫游网格蓝色条纹、当前网格加粗框；右上角网格/卫星模式开关。\n\n• 首通呼号（VUCC 视图）：绿格显示该格最早通联的呼号，非绿格空白。\n\n• worked 网格可按操作网格筛选（含“全部”）；点击网格弹出 QSO 明细；每格 QSO 计数。\n\n• 各操作网格独立 VUCC 计数；极区网格标签；反经线修复；漫游条纹密度一致。\n\n• WAPC/WAJA 地图标签随系统语言。\n\n• 网格模式视口与筛选跨页保持。\n\n• LoTW 同步：账号直连、全量/增量模式、实时进度、可取消、启动自动同步（独立开关）、设置页显示上次同步时间。\n\n• 历史过境：过境筛选可回看过去数小时（先前时间）。\n\n• 指南针校准：8 字动作精度指示 + 手动航向偏置。\n\n• AMSAT 状态页：连续相同状态报告计数。\n\n• 过境/雷达：UTC 切换重算过境；日出日落与仰角颜色修复；卫星模糊搜索；相互过境页滚动保持、跟随 UTC、雷达快捷入口。\n\n• CW 解码器支持 32/64 位设备；Android 17 (API 37) 适配。</string>
+    <string name="pass_whatsnew_message">4.4.6 以来的全部更新（4.4.7 系列）：\n\n• 网格模式地图：LoTW 已确认网格绿色填充、漫游网格蓝色条纹、当前网格加粗框；右上角网格/卫星模式开关。\n\n• 首通呼号（VUCC 视图）：绿格显示该格最早通联的呼号，非绿格空白。\n\n• worked 网格可按操作网格筛选（含“全部”）；点击网格弹出 QSO 明细；每格 QSO 计数。\n\n• 各操作网格独立 VUCC 计数；极区网格标签；反经线修复；漫游条纹密度一致。\n\n• WAPC/WAJA 地图标签随系统语言。\n\n• 网格模式视口与筛选跨页保持。\n\n• LoTW 同步：账号直连、全量/增量模式、实时进度、可取消、启动自动同步（独立开关）、设置页显示上次同步时间。\n\n• 历史过境：过境筛选可回看过去数小时（历史过境时间）。\n\n• 指南针校准：8 字动作精度指示 + 手动航向偏置。\n\n• AMSAT 状态页：连续相同状态报告计数。\n\n• 过境/雷达：UTC 切换重算过境；日出日落与仰角颜色修复；卫星模糊搜索；相互过境页滚动保持、跟随 UTC、雷达快捷入口。\n\n• CW 解码器支持 32/64 位设备；Android 17 (API 37) 适配。</string>
 
 <string name="nav_amsat">AMSAT</string>
     <string name="amsat_title">AMSAT 卫星状态</string>
@@ -130,6 +130,14 @@
     <string name="grid_qso_count_many">%d QSOs</string>
     <string name="grid_qso_first">首通</string>
     <string name="grid_qso_no_sat">卫星未知</string>
+    <string name="grid_qso_match">匹配</string>
+    <!-- 未通联网格中的“标记想通联的电台”提醒 -->
+    <string name="grid_mark_station">标记你想通联的电台</string>
+    <string name="grid_mark_callsign">呼号</string>
+    <string name="grid_mark_confirm">标记</string>
+    <string name="grid_mark_label">标记</string>
+    <string name="grid_mark_delete">删除标记</string>
+    <string name="grid_mark_pin">置顶</string>
     <string name="map_visible">日照中</string>
 
     <!-- Settings screen -->
@@ -183,6 +191,36 @@
     <string name="lotw_sync_progress_qso">本次同步 %1$d 条 QSO，预计还需 %2$d 秒</string>
     <string name="prefs_locator_text">使用梅登黑德网格设置站点位置</string>
 
+    <string name="btn_delete">删除</string>
+    <string name="prefs_logbook_title">日志本</string>
+    <string name="prefs_logbook_count">%1$d 条记录 — 本地通联与 LoTW 确认</string>
+    <string name="prefs_logbook_empty">暂无记录 — 在雷达页 Log 标签记录通联</string>
+    <string name="prefs_logbook_close">关闭</string>
+    <string name="prefs_logbook_upload">上传</string>
+    <string name="prefs_logbook_upload_title">上传到 LoTW</string>
+    <string name="prefs_logbook_upload_confirm">确认上传</string>
+    <string name="prefs_lotw_upload_title">LoTW 上传证书</string>
+    <string name="prefs_lotw_upload_configured">证书已导入 · 台址网格 %1$s</string>
+    <string name="prefs_lotw_upload_not_configured">未配置 — 导入 TrustedQSL 证书后即可上传通联</string>
+    <string name="prefs_lotw_upload_busy">处理中…</string>
+    <string name="prefs_lotw_upload_cert_hint">导入你的 TrustedQSL .p12 证书（与 TQSL 同款）用于签名上传通联。密码仅加密保存在手机本地。</string>
+    <string name="prefs_lotw_upload_password">证书密码</string>
+    <string name="prefs_lotw_upload_import">选择 .p12 文件</string>
+    <string name="prefs_lotw_upload_import_confirm">导入</string>
+    <string name="prefs_lotw_upload_error_password">证书密码错误，请检查 TQSL 导出 .p12 时设置的密码</string>
+    <string name="prefs_lotw_upload_error_expired">证书已过期或尚未生效</string>
+    <string name="prefs_lotw_upload_error_invalid">不是有效的 LoTW 证书文件</string>
+    <string name="prefs_lotw_upload_error_format">不支持的 .p12 加密，请用 TQSL 默认加密重新导出后再试</string>
+    <string name="prefs_lotw_upload_error_format_alg">不支持的 .p12 加密（%1$s），请用 TQSL 默认加密重新导出后再试</string>
+    <string name="prefs_lotw_upload_error_unknown">导入失败，请重试</string>
+    <string name="prefs_lotw_upload_cert_info">%1$s · DXCC %2$d · 有效期至 %3$s</string>
+    <string name="prefs_lotw_upload_remove">移除证书</string>
+    <string name="prefs_lotw_upload_station_title">台址</string>
+    <string name="prefs_lotw_upload_region_hint">未选择</string>
+    <string name="prefs_lotw_upload_grid">网格（逗号分隔，可多格）</string>
+    <string name="prefs_lotw_upload_save">保存</string>
+    <string name="prefs_lotw_upload_close">关闭</string>
+
     <string name="prefs_data_title">卫星数据更新</string>
     <string name="prefs_data_entries">卫星：%s</string>
     <string name="prefs_data_radios">收发器：%s</string>
@@ -239,6 +277,15 @@
     <string name="rc_enable_switch">启用 CAT 控制</string>
 
     <string name="prefs_other_title">其他设置</string>
+    <string name="prefs_map_title">地图设置</string>
+    <string name="prefs_map_configure">配置地图</string>
+    <string name="prefs_map_source_title">地图来源</string>
+    <string name="prefs_map_source_osm">离线 OSM 地图</string>
+    <string name="prefs_map_source_tianditu_vector">天地图（矢量）</string>
+    <string name="prefs_map_source_tianditu_image">天地图（影像）</string>
+    <string name="prefs_map_tianditu_key">天地图访问密钥</string>
+    <string name="prefs_map_tianditu_key_help">使用天地图前，需先在天地图开发者控制台申请服务端应用 Key。</string>
+    <string name="prefs_map_tianditu_key_required">选择天地图需要填写访问密钥；保存密钥前将继续使用离线 OSM 地图。</string>
     <string name="prefs_other_switch_utc">以 UTC 时间显示</string>
     <string name="prefs_other_switch_update">启用卫星数据自动更新</string>
     <string name="prefs_other_switch_lotw_sync">自动同步 LoTW 已确认网格</string>
@@ -274,7 +321,10 @@
         \n• Dr T.S. Kelso (Celestrak)
         \n• Libre Space Foundation (SatNOGS)
         \n• xdsopl 和 Robot36 贡献者!
-        \n• BG7NTA BG5JSU（CW解码功能）</string>
+        \n• BG7NTA BG5JSU（CW解码功能）
+        \n• BH2VSQ BG5JSU（天地图渲染支持）
+        \n• BG5JSU（LoTW上传支持）
+    </string>
     <string name="prefs_outro_license">该应用程序不提供任何保修.</string>
 
     <!-- 匹配页 Mutual match page -->
@@ -300,6 +350,9 @@
     <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_filter_transponder">转发器</string>
+    <string name="mutual_filter_fm">FM</string>
+    <string name="mutual_filter_linear">线性</string>
     <string name="mutual_calculating">计算中…</string>
     <string name="mutual_query">查询匹配</string>
     <string name="mutual_elevation_you">你：%d°</string>

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

@@ -128,7 +128,8 @@
     <!-- Map screen -->
     <string name="map_prev">Prev</string>
     <string name="map_next">Next</string>
-    <string name="map_copyright" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_osm" translatable="false">© OpenStreetMap contributors</string>
+    <string name="map_copyright_tianditu" translatable="false">© Tianditu</string>
     <string name="map_grid_mode">Grid mode</string>
     <string name="map_satellite_mode">Satellite mode</string>
     <string name="map_first_call_mode">First call</string>
@@ -150,6 +151,14 @@
     <string name="grid_qso_count_many">%d QSOs</string>
     <string name="grid_qso_first">First</string>
     <string name="grid_qso_no_sat">satellite unknown</string>
+    <string name="grid_qso_match">Match</string>
+    <!-- Mark-a-station reminder in unworked grids -->
+    <string name="grid_mark_station">Mark a station you want to contact</string>
+    <string name="grid_mark_callsign">Callsign</string>
+    <string name="grid_mark_confirm">Mark</string>
+    <string name="grid_mark_label">Marked</string>
+    <string name="grid_mark_delete">Remove mark</string>
+    <string name="grid_mark_pin">Pin to top</string>
     <string name="map_visible">Visible</string>
 
     <!-- Settings screen -->
@@ -213,6 +222,36 @@
     <string name="lotw_sync_progress_qso">Syncing %1$d QSOs, ~%2$d s remaining</string>
     <string name="prefs_locator_text">Set station\'s position using locator</string>
 
+    <string name="btn_delete">Delete</string>
+    <string name="prefs_logbook_title">Logbook</string>
+    <string name="prefs_logbook_count">%1$d records — local QSOs and LoTW confirmations</string>
+    <string name="prefs_logbook_empty">No records yet — record QSOs from the Radar Log tab</string>
+    <string name="prefs_logbook_close">Close</string>
+    <string name="prefs_logbook_upload">Upload</string>
+    <string name="prefs_logbook_upload_title">Upload to LoTW</string>
+    <string name="prefs_logbook_upload_confirm">Upload</string>
+    <string name="prefs_lotw_upload_title">LoTW upload certificate</string>
+    <string name="prefs_lotw_upload_configured">Certificate imported · station grid %1$s</string>
+    <string name="prefs_lotw_upload_not_configured">Not configured — import your TrustedQSL certificate to upload QSOs</string>
+    <string name="prefs_lotw_upload_busy">Working…</string>
+    <string name="prefs_lotw_upload_cert_hint">Import your TrustedQSL .p12 certificate (same one you use in TQSL) to sign and upload QSOs. The password is stored encrypted on this device only.</string>
+    <string name="prefs_lotw_upload_password">Certificate password</string>
+    <string name="prefs_lotw_upload_import">Choose .p12 file</string>
+    <string name="prefs_lotw_upload_import_confirm">Import</string>
+    <string name="prefs_lotw_upload_error_password">Incorrect certificate password. Check the password you set when exporting the .p12 from TQSL.</string>
+    <string name="prefs_lotw_upload_error_expired">Certificate is expired or not yet valid.</string>
+    <string name="prefs_lotw_upload_error_invalid">Not a valid LoTW certificate file.</string>
+    <string name="prefs_lotw_upload_error_format">Unsupported .p12 encryption. Re-export from TQSL and try again.</string>
+    <string name="prefs_lotw_upload_error_format_alg">Unsupported .p12 encryption (%1$s). Re-export from TQSL and try again.</string>
+    <string name="prefs_lotw_upload_error_unknown">Import failed. Try again.</string>
+    <string name="prefs_lotw_upload_cert_info">%1$s · DXCC %2$d · expires %3$s</string>
+    <string name="prefs_lotw_upload_remove">Remove certificate</string>
+    <string name="prefs_lotw_upload_station_title">Station location</string>
+    <string name="prefs_lotw_upload_region_hint">Not selected</string>
+    <string name="prefs_lotw_upload_grid">Grid(s), comma-separated</string>
+    <string name="prefs_lotw_upload_save">Save</string>
+    <string name="prefs_lotw_upload_close">Close</string>
+
     <string name="prefs_data_title">Satellite data</string>
     <string name="prefs_data_entries">Satellites: %s</string>
     <string name="prefs_data_radios">Transceivers: %s</string>
@@ -268,6 +307,15 @@
     <string name="prefs_net_perm_error">Check your network permission</string>
 
     <string name="prefs_other_title">Other settings</string>
+    <string name="prefs_map_title">Map settings</string>
+    <string name="prefs_map_configure">Configure map</string>
+    <string name="prefs_map_source_title">Map source</string>
+    <string name="prefs_map_source_osm">Offline OSM</string>
+    <string name="prefs_map_source_tianditu_vector">TianDiTu vector</string>
+    <string name="prefs_map_source_tianditu_image">TianDiTu imagery</string>
+    <string name="prefs_map_tianditu_key">TianDiTu access key</string>
+    <string name="prefs_map_tianditu_key_help">Request a server-side application key from the TianDiTu developer console before using TianDiTu maps.</string>
+    <string name="prefs_map_tianditu_key_required">A TianDiTu key is required. Offline OSM remains active until it is entered.</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_lotw_sync">Auto-sync LoTW confirmed grids</string>
@@ -304,6 +352,8 @@
         \n* Libre Space Foundation (SatNOGS)
         \n* xdsopl and Robot36 contributors!
         \n* BG7NTA BG5JSU (CW decoding feature)
+        \n* BH2VSQ BG5JSU (TianDiTu rendering support)
+        \n* BG5JSU (LoTW upload support)
     </string>
     <string name="prefs_outro_license">The app comes with no warranty</string>
 
@@ -330,6 +380,9 @@
     <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_filter_transponder">Transponders</string>
+    <string name="mutual_filter_fm">FM</string>
+    <string name="mutual_filter_linear">Linear</string>
     <string name="mutual_calculating">Calculating…</string>
     <string name="mutual_query">Query Match</string>
     <string name="mutual_elevation_you">You: %d°</string>

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

@@ -46,15 +46,16 @@ class MaidenheadGridOverlay : Overlay() {
         style = Paint.Style.STROKE
         color = Color.argb(160, 255, 224, 130)
     }
+    // 网格标签与首通呼号标签同字号 (用户要求 2026-09-21: 字体一样大)
     private val labelPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        textSize = 26f
+        textSize = LABEL_TEXT_SIZE
         style = android.graphics.Paint.Style.FILL
         color = Color.argb(220, 255, 224, 130)
         setShadowLayer(3f, 2f, 2f, Color.BLACK)
     }
-    // 首通呼号标签: 比 4 字符网格代码略小, 以容纳更长的呼号(如 BG2GQG).
+    // 首通呼号标签: 与网格标签同字号.
     private val firstCallPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-        textSize = 20f
+        textSize = LABEL_TEXT_SIZE
         style = android.graphics.Paint.Style.FILL
         color = Color.argb(230, 255, 224, 130)
         setShadowLayer(3f, 2f, 2f, Color.BLACK)
@@ -63,6 +64,11 @@ class MaidenheadGridOverlay : Overlay() {
         style = android.graphics.Paint.Style.FILL
         color = Color.argb(90, 76, 217, 100)
     }
+    // 标记(想通联)网格填充: 红色, 透明度与绿色 workedPaint 一致(alpha 90).
+    private val markedPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = android.graphics.Paint.Style.FILL
+        color = Color.argb(90, 255, 59, 48)
+    }
     private val roamStripePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
         style = Paint.Style.STROKE
         strokeWidth = 14f
@@ -86,6 +92,12 @@ class MaidenheadGridOverlay : Overlay() {
     /** Worked gridsquares (4-char, uppercase) to highlight, e.g. {"OL62", "PM95"}. */
     var workedGrids: Set<String> = emptySet()
 
+    /** Marked gridsquares (4-char, uppercase) — unworked grids the user has
+     *  marked stations they want to contact in; drawn red, same alpha as the
+     *  green worked fill. Value is the ordered mark list (first = pinned);
+     *  label mode shows the FIRST marked callsign. */
+    var markedGrids: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> = emptyMap()
+
     /** Grid-mode first-call labels: label worked (green) cells with the first
      *  callsign worked in that grid instead of the Maidenhead code; non-worked
      *  cells get no label at all. Only meaningful at sub-square zoom. */
@@ -188,6 +200,9 @@ class MaidenheadGridOverlay : Overlay() {
                         if (cellLabel(lat, lon, zoom) in workedGrids) {
                             canvas.drawRect(xLeft, yTop, xRight, yBottom, workedPaint)
                         }
+                        if (cellLabel(lat, lon, zoom) in markedGrids) {
+                            canvas.drawRect(xLeft, yTop, xRight, yBottom, markedPaint)
+                        }
                     }
                 }
             } else {
@@ -214,6 +229,22 @@ class MaidenheadGridOverlay : Overlay() {
                         canvas.drawRect(xLeft, yTop, xRight, yBottom, workedPaint)
                     }
                 }
+                for (grid in markedGrids.keys) {
+                    val cell = gridCellBounds(grid) ?: continue
+                    for (turn in -colRepeats..colRepeats) {
+                        val dLon = turn * 360.0
+                        if (cell.lonRight + dLon <= leftLon || cell.lonLeft + dLon >= rightLon) continue
+                        val yTop = projectionToY(projection, cell.latTop) ?: continue
+                        val yBottom = projectionToY(projection, cell.latBottom) ?: continue
+                        val xLeftBase = projectionToX(projection, cell.lonLeft, centerLon, worldWidthPx) ?: continue
+                        val xRightBase = projectionToX(projection, cell.lonRight, centerLon, worldWidthPx) ?: continue
+                        val xLeft = xLeftBase + turn * worldWidthPx.toFloat()
+                        val xRight = xRightBase + turn * worldWidthPx.toFloat()
+                        if (xRight < 0f || xLeft > canvas.width) continue
+                        if (yBottom < 0f || yTop > canvas.height) continue
+                        canvas.drawRect(xLeft, yTop, xRight, yBottom, markedPaint)
+                    }
+                }
             }
         }
 
@@ -362,21 +393,15 @@ class MaidenheadGridOverlay : Overlay() {
         // Labels: centered in each cell, only when the cell is large enough on
         // screen to hold a label (avoid clutter at low zoom).
         // Field (2-char) labels show at every zoom, subject only to the pixel-
-        // size check below; sub-square (4-char) labels only from LABEL_ZOOM_SUB
-        // (one level above the grid lines, so zoom 6 shows lines but no names).
+        // size check below; sub-square (4-char) labels appear together with the
+        // grid LINES at GRID_ZOOM_SUB (user req 2026-09-21: 与首通呼号同一显示缩放).
         // First-call labels replace the 4-char grid codes and only exist at
         // sub-square zoom; at field zoom NO labels are drawn at all (the user
         // requirement is that non-worked cells carry no grid characters).
-        // Show as soon as the 4-char grid LINES appear (GRID_ZOOM_SUB), not
-        // only at the name-label zoom — user req 2026-09-21.
         if (showFirstCallLabels && zoom < GRID_ZOOM_SUB) return
-        // First-call labels gate on the grid-LINE zoom; normal labels keep the
-        // name-label zoom (one level above the lines).
-        val showLabels = if (showFirstCallLabels) {
-            zoom >= GRID_ZOOM_SUB
-        } else {
-            zoom >= LABEL_ZOOM_SUB || cellLat == FIELD_LAT
-        }
+        // 网格标签与首通呼号同一显示缩放 (用户要求 2026-09-21): 子方块(4字符)
+        // 标签与首通呼号都在网格线出现的 GRID_ZOOM_SUB 同时显示, 不再晚一档.
+        val showLabels = zoom >= GRID_ZOOM_SUB || cellLat == FIELD_LAT
         if (!showLabels) return
         // Estimate on-screen cell height to avoid clutter at low zoom:
         // project two points 1° apart in latitude and measure the pixel distance.
@@ -384,10 +409,9 @@ class MaidenheadGridOverlay : Overlay() {
         val y2 = projectionToY(projection, 1.0)
         if (y1 == null || y2 == null) return
         val pixelsPerDegree = Math.abs(y2 - y1)
-        // First-call labels must appear as soon as the 4-char grid LINES do
-        // (zoom 6.0), where 1° cells are ~45 px on the equator — below the
-        // 48 px normal-label threshold. Relax the pixel gate for this mode only.
-        val minCellPx = if (showFirstCallLabels) MIN_LABEL_CELL_PX * 0.6f else MIN_LABEL_CELL_PX
+        // 两种模式同一像素门限: GRID_ZOOM_SUB 处 1° 格约 45px, 低于 48px
+        // 常规阈值, 统一用放宽的 0.6x 门限, 保证网格标签与首通呼号同时出现.
+        val minCellPx = MIN_LABEL_CELL_PX * 0.6f
         if (pixelsPerDegree * cellLat < minCellPx) return
 
         val activePaint = if (showFirstCallLabels) firstCallPaint else labelPaint
@@ -420,12 +444,15 @@ class MaidenheadGridOverlay : Overlay() {
                 if (xRight < 0f || xLeft > canvas.width) continue
                 val label = cellLabel(lat, lon, zoom)
                 if (showFirstCallLabels) {
-                    // 首通呼号模式: 只有绿格(worked)标注该格第一个通联的呼号,
-                    // 非绿格空着不写网格字符.
-                    if (label in workedGrids) {
-                        firstCallsByGrid[label]?.let { call ->
+                    // 首通呼号模式: 绿格(worked)标注该格第一个通联的呼号, 红格(marked)
+                    // 标注用户标记想通联的呼号, 均淡黄文字; 其它格空着不写网格字符.
+                    when {
+                        label in workedGrids -> firstCallsByGrid[label]?.let { call ->
                             canvas.drawText(call, (xLeft + xRight) / 2f, yCenter, firstCallPaint)
                         }
+                        label in markedGrids -> markedGrids[label]?.firstOrNull()?.let { station ->
+                            canvas.drawText(station.call, (xLeft + xRight) / 2f, yCenter, firstCallPaint)
+                        }
                     }
                 } else {
                     canvas.drawText(label, (xLeft + xRight) / 2f, yCenter, labelPaint)
@@ -547,9 +574,8 @@ class MaidenheadGridOverlay : Overlay() {
         // the sub-square grid is too dense to read; 6 roughly doubles the
         // on-screen size of each square.
         const val GRID_ZOOM_SUB = 6.0
-        // Zoom at which the 4-char sub-square names appear (one level above the
-        // grid lines: zoom 6 = lines only, zoom 6.5+ = lines + names).
-        const val LABEL_ZOOM_SUB = 6.5
+        // 网格标签与首通呼号标签统一字号 (用户要求 2026-09-21: 字体一样大).
+        const val LABEL_TEXT_SIZE = 20f
         const val MIN_LABEL_CELL_PX = 48f
         const val MAX_OVERSHOOT_PX = 64
         /** Center-to-center spacing of the roamed-grid zebra stripes, in px. */

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

@@ -31,10 +31,12 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.IntrinsicSize
 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.heightIn
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.lazy.items
@@ -46,10 +48,13 @@ import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.ElevatedCard
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.FilterChipDefaults
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -63,6 +68,7 @@ import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.draw.scale
 import androidx.compose.ui.graphics.Color as ComposeColor
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
@@ -79,6 +85,7 @@ import androidx.lifecycle.viewmodel.compose.viewModel
 import com.rtbishop.look4sat.core.domain.model.AwardCalculator
 import com.rtbishop.look4sat.core.domain.model.AwardProgress
 import com.rtbishop.look4sat.core.domain.model.AwardType
+import com.rtbishop.look4sat.core.domain.model.MapSource
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
@@ -90,31 +97,40 @@ import com.rtbishop.look4sat.core.presentation.TimerRow
 import com.rtbishop.look4sat.core.presentation.TopBar
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import com.rtbishop.look4sat.core.presentation.layoutPadding
+import org.osmdroid.tileprovider.MapTileProviderBasic
+import org.osmdroid.tileprovider.tilesource.OnlineTileSourceBase
 import org.osmdroid.tileprovider.tilesource.XYTileSource
 import org.osmdroid.events.DelayedMapListener
 import org.osmdroid.events.MapListener
 import org.osmdroid.events.ScrollEvent
 import org.osmdroid.events.ZoomEvent
 import org.osmdroid.util.GeoPoint
+import org.osmdroid.util.MapTileIndex
 import org.osmdroid.views.CustomZoomButtonsController
 import org.osmdroid.views.MapView
 import org.osmdroid.views.overlay.FolderOverlay
 import org.osmdroid.views.overlay.Marker
 import org.osmdroid.views.overlay.Polyline
+import org.osmdroid.views.overlay.TilesOverlay
+import java.net.URLEncoder
 
 // Overlay indices
-private const val OVERLAY_GRID = 0
-private const val OVERLAY_STATION = 1
-private const val OVERLAY_TRACK = 2
-private const val OVERLAY_FOOTPRINT = 3
-private const val OVERLAY_POSITIONS = 4
-private const val OVERLAY_TERMINATOR = 5
-private const val OVERLAY_SUN = 6
-private const val OVERLAY_MOON = 7
-private const val OVERLAY_COUNT = 8
+private const val OVERLAY_TDT_LABELS = 0
+private const val OVERLAY_GRID = 1
+private const val OVERLAY_STATION = 2
+private const val OVERLAY_TRACK = 3
+private const val OVERLAY_FOOTPRINT = 4
+private const val OVERLAY_POSITIONS = 5
+private const val OVERLAY_TERMINATOR = 6
+private const val OVERLAY_SUN = 7
+private const val OVERLAY_MOON = 8
+private const val OVERLAY_COUNT = 9
 
 private val minLat = MapView.getTileSystem().minLatitude
 private val maxLat = MapView.getTileSystem().maxLatitude
+private val offlineTileSource = XYTileSource("tiles", 0, 6, 256, ".webp", emptyArray<String>())
+private const val OFFLINE_MAX_ZOOM = 7.0
+private const val TIANDITU_MAX_ZOOM = 18.0
 private val trackPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
     strokeWidth = 3f
     style = Paint.Style.STROKE
@@ -145,7 +161,13 @@ private val moonIconPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
 
 @Composable
 fun MapDestination(
-    mapFilterViewModel: MapFilterViewModel
+    mapFilterViewModel: MapFilterViewModel,
+    // Invoked with the tapped grid when the QSO dialog's "Match" button is
+    // pressed: navigate to the match page pre-filled for that grid.
+    onMatchGrid: (String) -> Unit = {},
+    // True while the map "Match" query is running (the page only navigates
+    // once the query finished, so the match page opens with results ready).
+    matchCalculating: Boolean = false
 ) {
     val context = LocalContext.current
     val container = (context.applicationContext as IContainerProvider).getMainContainer()
@@ -182,7 +204,7 @@ fun MapDestination(
             viewModel.onAction(MapAction.SetVisible(false))
         }
     }
-    MapScreen(uiState, viewModel::onAction, mapView, mapFilterViewModel)
+    MapScreen(uiState, viewModel::onAction, mapView, mapFilterViewModel, onMatchGrid, matchCalculating)
 }
 
 @Composable
@@ -190,11 +212,15 @@ private fun MapScreen(
     uiState: MapState,
     onAction: (MapAction) -> Unit,
     mapView: MapView,
-    mapFilterViewModel: MapFilterViewModel
+    mapFilterViewModel: MapFilterViewModel,
+    onMatchGrid: (String) -> Unit,
+    matchCalculating: Boolean
 ) {
     val rotateMod = Modifier.rotate(180f)
     val timeString = uiState.mapData?.aosTime ?: "00:00:00"
     val isTimeAos = uiState.mapData?.isTimeAos ?: true
+    val usesTianditu = tiandituLayers(uiState.mapSource) != null && uiState.tiandituKey.isNotBlank()
+    val copyrightResId = if (usesTianditu) R.string.map_copyright_tianditu else R.string.map_copyright_osm
 
     // Tapped worked grid -> centered QSO dialog. Local UI state: the map is the
     // only consumer and it resets when leaving the page.
@@ -202,19 +228,6 @@ private fun MapScreen(
     // Selected award filter. Lives in an Activity-scoped ViewModel so it
     // survives page switches; defaults to VUCC only once per process (cold start).
     var selectedAward by mapFilterViewModel.selectedAward
-    // Six-award progress derived from the confirmed QSO store; recomputed when
-    // the store changes (LoTW/Wavelog sync).
-    // Per operated-grid VUCC breakdown: myGrid -> set of worked grids worked from it.
-    val vuccByMyGrid: Map<String, Set<String>> = remember(uiState.workedGridQsos) {
-        val m = mutableMapOf<String, MutableSet<String>>()
-        for ((grid, qsos) in uiState.workedGridQsos) {
-            for (q in qsos) {
-                val mg = q.myGrid ?: continue
-                m.getOrPut(mg) { mutableSetOf() }.add(grid)
-            }
-        }
-        m
-    }
     // First callsign worked in each grid (earliest QSO by time), used by the
     // "首通呼号" label mode — derived from the same QSO store as the worked fills.
     val firstCallsByGrid: Map<String, String> = remember(uiState.workedGridQsos) {
@@ -222,26 +235,47 @@ private fun MapScreen(
             qsos.minByOrNull { it.epochMs }?.let { grid to it.call }
         }.toMap()
     }
-    // Selected operated grid for VUCC counting; defaults to the grid with the
-    // most worked grids. Null when the store carries no per-QSO myGrid data
-    // (requires a LoTW resync) — then VUCC falls back to the global count.
-    var selectedMyGrid by remember(vuccByMyGrid) {
-        mutableStateOf(vuccByMyGrid.maxByOrNull { it.value.size }?.key)
+    // 台址名单: QSOs grouped by the 台址's GRID SET. A station location (台址)
+    // can span several grids (MY_GRIDSQUARE + MY_VUCC_GRIDS), and QSOs whose
+    // location covers the same grid set belong to the same 台址; groups with an
+    // identical grid set merge (they are VUCC-equivalent — the MY_* snapshot
+    // can differ between records of the same physical 台址 when LoTW omits
+    // optional fields). Data synced before multi-grid support falls back to
+    // one group per grid, preserving the old selector exactly.
+    val stationGroups: List<StationGroup> = remember(uiState.workedGridQsos) {
+        val byGridSet = LinkedHashMap<String, Pair<Set<String>, MutableSet<String>>>()
+        for ((grid, qsos) in uiState.workedGridQsos) {
+            for (q in qsos) {
+                val gs = q.myGrids.ifEmpty { q.myGrid?.let { setOf(it) }.orEmpty() }
+                if (gs.isEmpty()) continue
+                val key = gs.sorted().joinToString(",")
+                byGridSet.getOrPut(key) { gs to mutableSetOf() }.second.add(grid)
+            }
+        }
+        byGridSet.map { (key, v) -> StationGroup(id = key, grids = v.first, worked = v.second) }
+            .sortedByDescending { it.workedCount }
     }
-    val awardProgress: List<AwardProgress> = remember(uiState.workedGridQsos, vuccByMyGrid, selectedMyGrid) {
-        val vuccGrids = selectedMyGrid?.let { vuccByMyGrid[it].orEmpty() }
+    // Selected 台址 for VUCC counting; defaults to the group with the most
+    // worked grids. Null = "All" (every 台址 combined). Empty when the store
+    // carries no per-QSO myGrid data (requires a LoTW resync) — the selector
+    // is hidden then and VUCC falls back to the global count.
+    var selectedStationId by remember(stationGroups) {
+        mutableStateOf(stationGroups.maxByOrNull { it.workedCount }?.id)
+    }
+    val awardProgress: List<AwardProgress> = remember(uiState.workedGridQsos, stationGroups, selectedStationId) {
         val base = AwardCalculator.calculate(uiState.workedGridQsos)
-        if (vuccGrids == null) base
+        val worked = stationGroups.firstOrNull { it.id == selectedStationId }?.worked
+        if (worked == null) base
         else base.map { p ->
-            if (p.type == AwardType.VUCC) p.copy(workedKeys = vuccGrids, count = vuccGrids.size) else p
+            if (p.type == AwardType.VUCC) p.copy(workedKeys = worked, count = worked.size) else p
         }
     }
-    // Worked grids drawn on the map: filtered by the selected operated grid
-    // (null = all operated grids). Drives both the green fills and the tap
-    // listener below, so switching the selector changes which cells are green.
-    val workedGrids = remember(uiState.workedGrids, vuccByMyGrid, selectedMyGrid) {
-        if (selectedMyGrid == null) uiState.workedGrids
-        else vuccByMyGrid[selectedMyGrid] ?: emptySet()
+    // Worked grids drawn on the map: filtered by the selected 台址 (null = all).
+    // Drives both the green fills and the tap listener below, so switching the
+    // selector changes which cells are green.
+    val workedGrids = remember(uiState.workedGrids, stationGroups, selectedStationId) {
+        if (selectedStationId == null) uiState.workedGrids
+        else stationGroups.firstOrNull { it.id == selectedStationId }?.worked ?: emptySet()
     }
     val isGridMode = uiState.isGridMode
     // True when this composition restored a saved viewport. Only grid mode
@@ -258,10 +292,11 @@ private fun MapScreen(
                 if (!isGridMode || p == null) return false
                 val zoom = mapView.zoomLevelDouble
                 // Allow tapping worked cells as soon as the 4-char grid LINES
-                // appear (GRID_ZOOM_SUB), not only when labels show (LABEL_ZOOM_SUB).
+                // appear (GRID_ZOOM_SUB); grid labels now appear at that zoom too.
                 if (zoom < MaidenheadGridOverlay.GRID_ZOOM_SUB) return false
                 val grid = gridOfPoint(p.latitude, p.longitude) ?: return false
-                if (grid !in workedGrids) return false
+                // Every grid is tappable: worked grids show their confirmed QSOs,
+                // unworked grids open the same dialog with an empty list.
                 selectedGrid = grid
                 return true
             }
@@ -285,6 +320,9 @@ private fun MapScreen(
         val firstPos = uiState.track?.firstOrNull()?.firstOrNull() ?: return@LaunchedEffect
         mapView.controller.animateTo(GeoPoint(firstPos.latitude, firstPos.longitude))
     }
+    LaunchedEffect(uiState.mapSource, uiState.tiandituKey) {
+        configureTileSources(mapView, uiState.mapSource, uiState.tiandituKey)
+    }
     Column(modifier = Modifier.layoutPadding(), verticalArrangement = Arrangement.spacedBy(6.dp)) {
         val isVertical = isVerticalLayout()
         if (isGridMode) {
@@ -347,7 +385,8 @@ private fun MapScreen(
                             centerOnStation = shouldCenter,
                             // 首通呼号标签只作用于 VUCC 视图(用户要求); "All"/其他奖状不过滤.
                             showFirstCallLabels = uiState.showFirstCallLabels && selectedAward == AwardType.VUCC,
-                            firstCallsByGrid = firstCallsByGrid
+                            firstCallsByGrid = firstCallsByGrid,
+                            markedGrids = uiState.markedGrids
                         )
                         if (!shouldCenter || uiState.stationPosition != null) {
                             prevGridMode = uiState.isGridMode
@@ -366,17 +405,18 @@ private fun MapScreen(
                 }
                 uiState.mapData?.let { mapData ->
                     if (!uiState.isGridMode) {
-                        if (isVertical) MapDataCard(mapData) else MapDataCards(mapData)
+                        if (isVertical) MapDataCard(mapData, copyrightResId)
+                        else MapDataCards(mapData, copyrightResId)
                     }
                 }
-                // Top-left: operated-grid selector for VUCC counting (grid mode only).
+                // Top-left: 台址 selector for VUCC counting (grid mode only).
                 // Shown whenever per-grid QSO data exists; "All" (null) is available.
-                if (uiState.isGridMode && selectedAward == AwardType.VUCC && vuccByMyGrid.isNotEmpty()) {
+                if (uiState.isGridMode && selectedAward == AwardType.VUCC && stationGroups.isNotEmpty()) {
                     VuccGridSelector(
-                        options = vuccByMyGrid,
+                        stations = stationGroups,
                         allCount = uiState.workedGrids.size,
-                        selected = selectedMyGrid,
-                        onSelect = { selectedMyGrid = it },
+                        selected = selectedStationId,
+                        onSelect = { selectedStationId = it },
                         modifier = Modifier
                             .align(Alignment.TopStart)
                             .padding(8.dp)
@@ -407,13 +447,20 @@ private fun MapScreen(
         }
     }
     // Centered dialog listing the tapped worked grid's confirmed satellite QSOs.
-    // Dismissed by tapping outside (no explicit close button).
+    // Dismissed by tapping outside (no explicit close button). Unworked grids
+    // open the same dialog with an empty list plus a mark-a-station reminder.
     selectedGrid?.let { grid ->
         WorkedGridQsoDialog(
             grid = grid,
             qsos = uiState.workedGridQsos[grid].orEmpty().sortedBy { it.epochMs },
+            marked = uiState.markedGrids[grid].orEmpty(),
             isUtc = uiState.isUtc,
-            onDismiss = { selectedGrid = null }
+            matchCalculating = matchCalculating,
+            onDismiss = { selectedGrid = null },
+            onMatch = { onMatchGrid(grid) },
+            onMark = { call -> onAction(MapAction.SetMarkedStation(grid, call)) },
+            onRemoveMark = { call -> onAction(MapAction.RemoveMarkedStation(grid, call)) },
+            onPinMark = { call -> onAction(MapAction.PinMarkedStation(grid, call)) }
         )
     }
 }
@@ -424,9 +471,17 @@ private fun MapScreen(
 private fun WorkedGridQsoDialog(
     grid: String,
     qsos: List<com.rtbishop.look4sat.core.domain.model.GridQso>,
+    marked: List<com.rtbishop.look4sat.core.domain.model.MarkedStation>,
     isUtc: Boolean,
-    onDismiss: () -> Unit
+    matchCalculating: Boolean,
+    onDismiss: () -> Unit,
+    onMatch: () -> Unit,
+    onMark: (String) -> Unit,
+    onRemoveMark: (String) -> Unit,
+    onPinMark: (String) -> Unit
 ) {
+    var showMarkInput by remember { mutableStateOf(false) }
+    var callInput by remember { mutableStateOf("") }
     androidx.compose.ui.window.Dialog(onDismissRequest = onDismiss) {
         // Centered card, ~85% width, internal scroll for long lists.
         Card(
@@ -434,48 +489,202 @@ private fun WorkedGridQsoDialog(
             modifier = Modifier.fillMaxWidth(0.88f)
         ) {
             Column {
-                // Header: grid + counts
-                Column(Modifier.padding(horizontal = 16.dp, vertical = 10.dp)) {
-                    Text(
-                        text = grid,
-                        style = MaterialTheme.typography.titleLarge,
-                        color = MaterialTheme.colorScheme.primary,
-                        fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace
-                    )
-                    val distinctCalls = qsos.map { it.call }.distinct().size
-                    Text(
-                        text = stringResource(R.string.grid_qso_calls_count, distinctCalls, qsos.size),
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
+                // Header: grid + counts on the left, "Match" action on the right
+                // (jumps to the match page pre-filled with this grid).
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.padding(start = 16.dp, end = 8.dp, top = 4.dp, bottom = 4.dp)
+                ) {
+                    Column(Modifier.weight(1f)) {
+                        Text(
+                            text = grid,
+                            style = MaterialTheme.typography.titleLarge,
+                            color = MaterialTheme.colorScheme.primary,
+                            fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace
+                        )
+                        val distinctCalls = qsos.map { it.call }.distinct().size
+                        Text(
+                            text = stringResource(R.string.grid_qso_calls_count, distinctCalls, qsos.size),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                    TextButton(
+                        enabled = !matchCalculating,
+                        onClick = {
+                            onDismiss()
+                            onMatch()
+                        }
+                    ) {
+                        if (matchCalculating) {
+                            CircularProgressIndicator(
+                                modifier = Modifier.size(18.dp),
+                                strokeWidth = 2.dp
+                            )
+                        } else {
+                            Icon(
+                                painter = painterResource(R.drawable.ic_radio_tower),
+                                contentDescription = null,
+                                modifier = Modifier.size(18.dp)
+                            )
+                        }
+                        Spacer(Modifier.width(4.dp))
+                        Text(stringResource(R.string.grid_qso_match))
+                    }
                 }
                 androidx.compose.material3.HorizontalDivider()
-                if (qsos.isEmpty()) {
-                    Text(
-                        text = stringResource(R.string.grid_qso_no_sat),
-                        style = MaterialTheme.typography.bodySmall,
-                        modifier = Modifier.padding(16.dp)
-                    )
-                } else {
-                    // Group by callsign preserving first-contact order (list is
-                    // already sorted oldest-first); expandable rows.
-                    val grouped = remember(qsos) {
-                        qsos.groupBy { it.call }.entries.sortedBy { it.value.first().epochMs }
+                Column(
+                    Modifier
+                        .heightIn(max = 380.dp)
+                        .verticalScroll(rememberScrollState())
+                ) {
+                    // Marked stations show first as red reminder rows: pale-yellow
+                    // callsign, "标记" in the count column, the marking date in the
+                    // date column, a small pin icon (first = pinned, grey; others
+                    // pale yellow) and a delete icon to remove the mark.
+                    val showPin = marked.size > 1
+                    marked.forEachIndexed { index, station ->
+                        MarkedStationRow(
+                            marked = station,
+                            isPinned = index == 0,
+                            showPin = showPin,
+                            isUtc = isUtc,
+                            onRemoveMark = { onRemoveMark(station.call) },
+                            onPinMark = { onPinMark(station.call) }
+                        )
+                        androidx.compose.material3.HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.3f))
                     }
-                    Column(
-                        Modifier
-                            .heightIn(max = 380.dp)
-                            .verticalScroll(rememberScrollState())
-                    ) {
+                    if (qsos.isNotEmpty()) {
+                        // Group by callsign preserving first-contact order (list is
+                        // already sorted oldest-first); expandable rows.
+                        val grouped = remember(qsos) {
+                            qsos.groupBy { it.call }.entries.sortedBy { it.value.first().epochMs }
+                        }
                         grouped.forEach { (call, callQsos) ->
                             WorkedGridCallRow(call, callQsos = callQsos, isUtc = isUtc)
                             androidx.compose.material3.HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.3f))
                         }
                     }
+                    // Unworked grids: offer to mark a station the user wants to
+                    // contact in this grid (a reminder, cleared when worked).
+                    if (qsos.isEmpty()) {
+                        TextButton(
+                            onClick = {
+                                callInput = ""
+                                showMarkInput = true
+                            },
+                            modifier = Modifier.fillMaxWidth()
+                        ) {
+                            Icon(
+                                painter = painterResource(R.drawable.ic_add),
+                                contentDescription = null,
+                                modifier = Modifier.size(18.dp)
+                            )
+                            Spacer(Modifier.width(4.dp))
+                            Text(stringResource(R.string.grid_mark_station))
+                        }
+                    }
                 }
             }
         }
     }
+    // Mark-a-station input dialog: enter a callsign as a reminder.
+    if (showMarkInput) {
+        androidx.compose.material3.AlertDialog(
+            onDismissRequest = { showMarkInput = false },
+            title = { Text(stringResource(R.string.grid_mark_station)) },
+            text = {
+                androidx.compose.material3.OutlinedTextField(
+                    value = callInput,
+                    onValueChange = { callInput = it.uppercase() },
+                    label = { Text(stringResource(R.string.grid_mark_callsign)) },
+                    singleLine = true
+                )
+            },
+            confirmButton = {
+                TextButton(
+                    enabled = callInput.isNotBlank(),
+                    onClick = {
+                        onMark(callInput)
+                        showMarkInput = false
+                    }
+                ) { Text(stringResource(R.string.grid_mark_confirm)) }
+            },
+            dismissButton = {
+                TextButton(onClick = { showMarkInput = false }) { Text(stringResource(R.string.btn_cancel)) }
+            }
+        )
+    }
+}
+
+@Composable
+private fun MarkedStationRow(
+    marked: com.rtbishop.look4sat.core.domain.model.MarkedStation,
+    isPinned: Boolean,
+    showPin: Boolean,
+    isUtc: Boolean,
+    onRemoveMark: () -> Unit,
+    onPinMark: () -> Unit
+) {
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)
+    ) {
+        Text(
+            text = marked.call,
+            style = MaterialTheme.typography.titleMedium,
+            fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace,
+            color = ComposeColor(0xFFFFE082),
+            maxLines = 1,
+            overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis,
+            modifier = Modifier.weight(1f)
+        )
+        // "标记" column: pin icon (only when the grid has multiple marks) sits
+        // left of the label; pinned (first) row's icon is grey, others pale
+        // yellow — tapping moves that mark to the top.
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.Center,
+            modifier = Modifier.weight(1f)
+        ) {
+            if (showPin) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_pin),
+                    contentDescription = stringResource(R.string.grid_mark_pin),
+                    tint = if (isPinned) ComposeColor(0xFF9E9E9E) else ComposeColor(0xFFFFE082),
+                    modifier = Modifier
+                        .size(18.dp)
+                        .clickable(onClick = onPinMark)
+                )
+                Spacer(Modifier.width(2.dp))
+            }
+            Text(
+                text = stringResource(R.string.grid_mark_label),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = androidx.compose.ui.text.style.TextAlign.Center
+            )
+        }
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.End,
+            modifier = Modifier.weight(1f)
+        ) {
+            Text(
+                text = formatDate(marked.epochMs, isUtc),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            Icon(
+                painter = painterResource(R.drawable.ic_delete),
+                contentDescription = stringResource(R.string.grid_mark_delete),
+                tint = MaterialTheme.colorScheme.error,
+                modifier = Modifier
+                    .size(18.dp)
+                    .clickable(onClick = onRemoveMark)
+            )
+        }
+    }
 }
 
 @Composable
@@ -497,7 +706,7 @@ private fun WorkedGridCallRow(
                 text = call,
                 style = MaterialTheme.typography.titleMedium,
                 fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace,
-                color = MaterialTheme.colorScheme.tertiary,
+                color = ComposeColor(0xFFFFE082),
                 maxLines = 1,
                 overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis,
                 modifier = Modifier.weight(1f)
@@ -576,11 +785,11 @@ private fun formatTime(epochMs: Long, isUtc: Boolean): String {
 
 // region Map data composables
 @Composable
-private fun MapDataCard(data: MapData) {
+private fun MapDataCard(data: MapData, copyrightResId: Int) {
     val textColor = MaterialTheme.colorScheme.primary
     val cardColors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLowest)
     Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        Text(text = stringResource(R.string.map_copyright), fontSize = 14.sp)
+        Text(text = stringResource(copyrightResId), fontSize = 14.sp)
         Card(colors = cardColors) {
             Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
                 MapDataRow(
@@ -618,7 +827,7 @@ private fun MapDataRow(
 }
 
 @Composable
-private fun MapDataCards(data: MapData) {
+private fun MapDataCards(data: MapData, copyrightResId: Int) {
     val cardColors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLowest)
     val paddingMod = Modifier
         .padding(horizontal = 8.dp, vertical = 4.dp)
@@ -645,7 +854,7 @@ private fun MapDataCards(data: MapData) {
             }
         }
         Text(
-            text = stringResource(R.string.map_copyright),
+            text = stringResource(copyrightResId),
             fontSize = 14.sp,
             modifier = Modifier.align(Alignment.BottomCenter)
         )
@@ -696,22 +905,42 @@ private fun AwardChipsRow(
 }
 
 /**
- * Compact pill toggle for switching between satellite view and grid mode,
+ * One 台址 shown by the operated-grid selector. A 台址 is a station location
+ * and can span SEVERAL grids (MY_GRIDSQUARE + MY_VUCC_GRIDS); groups are keyed
+ * by the 台址's full grid set, so a multi-grid 台址 is one entry listing all
+ * its grids. Data synced before multi-grid support falls back to one group
+ * per grid.
+ */
+private data class StationGroup(
+    /** Grid-set key (sorted 4-char grids joined by ","). */
+    val id: String,
+    /** Full grid set of this 台址 (1..n 4-char grids). */
+    val grids: Set<String>,
+    /** Distinct worked grids worked under this 台址 (any of its grids). */
+    val worked: Set<String>
+) {
+    val workedCount: Int get() = worked.size
+    /** Selector label: the grids themselves — "OL62" for a single-grid 台址,
+     *  "OM60,PM01" for a multi-grid one (matches how 台址 are described). */
+    val label: String get() = grids.sorted().joinToString(",")
+}
+
+/** Compact pill toggle for switching between satellite view and grid mode,
  * floated over the map's top-right corner. The label reflects the active
  * mode ("Grid mode" when ON, "Satellite mode" when OFF). Semi-transparent
- * background keeps the map readable underneath.
- */
+ * background keeps the map readable underneath. */
 @Composable
 private fun VuccGridSelector(
-    options: Map<String, Set<String>>,
+    stations: List<StationGroup>,
     allCount: Int,
     selected: String?,
     onSelect: (String?) -> Unit,
     modifier: Modifier = Modifier
 ) {
     var expanded by remember { mutableStateOf(false) }
-    // Most-worked grid first; selection is made on tap. "All" sits last.
-    val sorted = remember(options) { options.entries.sortedByDescending { it.value.size } }
+    // Most-worked 台址 first; selection is made on tap. "All" sits last.
+    val sorted = remember(stations) { stations.sortedByDescending { it.workedCount } }
+    val selectedLabel = stations.firstOrNull { it.id == selected }?.label
     Surface(
         color = ComposeColor.Black.copy(alpha = 0.45f),
         shape = RoundedCornerShape(8.dp),
@@ -729,8 +958,8 @@ private fun VuccGridSelector(
                     .padding(start = 10.dp, end = 6.dp, top = 4.dp, bottom = 4.dp)
             ) {
                 Text(
-                    text = if (selected == null) "All ($allCount)"
-                    else "$selected (${options[selected]?.size ?: 0})",
+                    text = if (selectedLabel == null) "All ($allCount)"
+                    else "$selectedLabel (${stations.firstOrNull { it.id == selected }?.workedCount ?: 0})",
                     color = ComposeColor.White,
                     fontSize = 12.sp,
                     fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace
@@ -744,20 +973,20 @@ private fun VuccGridSelector(
             }
             if (expanded) {
                 androidx.compose.material3.HorizontalDivider(color = ComposeColor.White.copy(alpha = 0.2f))
-                sorted.forEach { (grid, grids) ->
+                sorted.forEach { station ->
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
                         modifier = Modifier
                             .fillMaxWidth()
                             .clickable {
-                                onSelect(grid)
+                                onSelect(station.id)
                                 expanded = false
                             }
                             .padding(horizontal = 10.dp, vertical = 3.dp)
                     ) {
                         Text(
-                            text = "$grid (${grids.size})",
-                            color = if (grid == selected) MaterialTheme.colorScheme.primary else ComposeColor.White,
+                            text = "${station.label} (${station.workedCount})",
+                            color = if (station.id == selected) MaterialTheme.colorScheme.primary else ComposeColor.White,
                             fontSize = 12.sp,
                             fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace
                         )
@@ -860,6 +1089,100 @@ private fun FirstCallToggle(
 
 // endregion
 
+// region Tile sources
+private var configuredTileMapView: MapView? = null
+private var configuredTileSource: String? = null
+
+private fun configureTileSources(mapView: MapView, mapSource: String, tiandituKey: String) {
+    val key = tiandituKey.trim()
+    val layers = tiandituLayers(mapSource)
+    val sourceKey = if (layers == null || key.isBlank()) MapSource.OSM else "${layers.base}:$key"
+    if (configuredTileMapView === mapView && configuredTileSource == sourceKey) return
+
+    configuredTileMapView = mapView
+    configuredTileSource = sourceKey
+    (mapView.overlays.getOrNull(OVERLAY_TDT_LABELS) as? TilesOverlay)?.onDetach(mapView)
+
+    if (layers == null || key.isBlank()) {
+        mapView.setUseDataConnection(false)
+        mapView.setTileSource(offlineTileSource)
+        mapView.maxZoomLevel = OFFLINE_MAX_ZOOM
+        mapView.overlayManager.tilesOverlay.applyTileOverlayDefaults(createColorFilter())
+        mapView.overlays[OVERLAY_TDT_LABELS] = FolderOverlay()
+        requestTileRefresh(mapView)
+        return
+    }
+
+    mapView.setUseDataConnection(true)
+    mapView.setTileSource(TiandituTileSource(layer = layers.base, key = key))
+    mapView.maxZoomLevel = TIANDITU_MAX_ZOOM
+    mapView.overlayManager.tilesOverlay.applyTileOverlayDefaults(null)
+    mapView.overlays[OVERLAY_TDT_LABELS] = TilesOverlay(
+        MapTileProviderBasic(mapView.context, TiandituTileSource(layer = layers.label, key = key)),
+        mapView.context
+    ).apply {
+        applyTileOverlayDefaults(null)
+        setUseDataConnection(true)
+    }
+    requestTileRefresh(mapView)
+}
+
+private data class TiandituLayers(val base: String, val label: String)
+
+private fun tiandituLayers(mapSource: String): TiandituLayers? = when (MapSource.normalize(mapSource)) {
+    MapSource.TIANDITU_VECTOR -> TiandituLayers(base = "vec", label = "cva")
+    MapSource.TIANDITU_IMAGE -> TiandituLayers(base = "img", label = "cia")
+    else -> null
+}
+
+private fun TilesOverlay.applyTileOverlayDefaults(colorFilter: ColorMatrixColorFilter?) {
+    setColorFilter(colorFilter)
+    setLoadingBackgroundColor(Color.TRANSPARENT)
+    setLoadingLineColor(Color.TRANSPARENT)
+}
+
+private fun requestTileRefresh(mapView: MapView) {
+    mapView.post {
+        mapView.requestLayout()
+        mapView.invalidate()
+    }
+}
+
+private fun buildTiandituWmtsUrl(
+    baseUrl: String,
+    layer: String,
+    zoom: Int,
+    row: Int,
+    col: Int,
+    encodedKey: String
+): String = "$baseUrl?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=$layer" +
+    "&STYLE=default&TILEMATRIXSET=w&FORMAT=tiles&TILEMATRIX=$zoom&TILEROW=$row&TILECOL=$col&tk=$encodedKey"
+
+private class TiandituTileSource(
+    private val layer: String,
+    key: String
+) : OnlineTileSourceBase(
+    "tianditu-wmts-https-$layer",
+    1,
+    TIANDITU_MAX_ZOOM.toInt(),
+    256,
+    ".png",
+    Array(8) { index -> "https://t$index.tianditu.gov.cn/${layer}_w/wmts" },
+    "Tianditu"
+) {
+    private val encodedKey = URLEncoder.encode(key, Charsets.UTF_8.name())
+
+    override fun getTileURLString(pMapTileIndex: Long): String = buildTiandituWmtsUrl(
+        baseUrl = getBaseUrl(),
+        layer = layer,
+        zoom = MapTileIndex.getZoom(pMapTileIndex),
+        row = MapTileIndex.getY(pMapTileIndex),
+        col = MapTileIndex.getX(pMapTileIndex),
+        encodedKey = encodedKey
+    )
+}
+// endregion
+
 // region Map overlay helpers
 
 /**
@@ -903,7 +1226,8 @@ private fun setGridMode(
     stationPosition: GeoPos?,
     centerOnStation: Boolean = false,
     showFirstCallLabels: Boolean = false,
-    firstCallsByGrid: Map<String, String> = emptyMap()
+    firstCallsByGrid: Map<String, String> = emptyMap(),
+    markedGrids: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> = emptyMap()
 ) {
     try {
         val gridOverlay = mapView.overlays[OVERLAY_GRID]
@@ -914,6 +1238,7 @@ private fun setGridMode(
             // 首通呼号模式: 绿格标注第一个通联的呼号, 非绿格不显示标签.
             gridOverlay.showFirstCallLabels = showFirstCallLabels
             gridOverlay.firstCallsByGrid = firstCallsByGrid
+            gridOverlay.markedGrids = markedGrids
             // ownGrid must be set on EVERY update — the position is available
             // regardless of whether this frame centers (centering happens only
             // on entry, but passing null here would wipe the bold outline).
@@ -925,6 +1250,7 @@ private fun setGridMode(
                 this.roamedGrids = roamedGrids
                 this.showFirstCallLabels = showFirstCallLabels
                 this.firstCallsByGrid = firstCallsByGrid
+                this.markedGrids = markedGrids
                 this.ownGrid = ownGridOf(stationPosition)
             }
         }
@@ -1275,7 +1601,6 @@ private fun rememberMapViewWithLifecycle(
     mapFilterViewModel: MapFilterViewModel,
     restoreViewport: Boolean
 ): MapView {
-    val tileSource = XYTileSource("tiles", 0, 6, 256, ".webp", emptyArray<String>())
     val context = LocalContext.current
     val isVertical = isVerticalLayout()
     val mapView = remember {
@@ -1287,9 +1612,9 @@ private fun rememberMapViewWithLifecycle(
             // draws a full-height artifact line whenever its X range crosses
             // the screen at low zoom. The map must never repeat vertically.
             setVerticalMapRepetitionEnabled(false)
-            setTileSource(tileSource)
+            setTileSource(offlineTileSource)
             minZoomLevel = getMinZoom(resources.displayMetrics.heightPixels, isVertical)
-            maxZoomLevel = 7.0
+            maxZoomLevel = OFFLINE_MAX_ZOOM
             // Restore the viewport the user left on the previous visit, but only
             // in grid mode: satellite mode intentionally keeps its original
             // behavior (default center, then follows the selected satellite).
@@ -1334,6 +1659,8 @@ private fun clearMapCaches() {
     lastPositions = null
     lastAction = null
     lastMapView = null
+    configuredTileMapView = null
+    configuredTileSource = null
 }
 
 @Composable

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

@@ -21,11 +21,14 @@ import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.model.MapSource
 
 data class MapState(
     val mapData: MapData? = null,
     val isLightUi: Boolean = false,
     val isUtc: Boolean = false,
+    val mapSource: String = MapSource.OSM,
+    val tiandituKey: String = "",
     val isGridMode: Boolean = false,
     /** Grid mode: label worked (green) cells with the first callsign worked in
      *  that grid instead of the grid code; non-worked cells get no label. */
@@ -34,6 +37,9 @@ data class MapState(
     val workedGridQsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> = emptyMap(),
     /** 4-char gridsquares the station operated from (LoTW MY_GRIDSQUARE) — blue stripes. */
     val roamedGrids: Set<String> = emptySet(),
+    /** Stations the user marked in unworked gridsquares (grid -> ordered list;
+     *  first = pinned/top) — red fill. */
+    val markedGrids: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> = emptyMap(),
     val stationPosition: GeoPos? = null,
     val orbitalPass: OrbitalPass,
     val track: List<List<GeoPos>>? = null,
@@ -52,6 +58,9 @@ sealed interface MapAction {
     data class SelectDefaultItem(val catnum: Int) : MapAction
     data class ToggleGridMode(val value: Boolean) : MapAction
     data class ToggleFirstCallLabels(val value: Boolean) : MapAction
+    data class SetMarkedStation(val grid: String, val call: String) : MapAction
+    data class RemoveMarkedStation(val grid: String, val call: String) : MapAction
+    data class PinMarkedStation(val grid: String, val call: String) : MapAction
     data class SetVisible(val isVisible: Boolean) : MapAction
 }
 

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

@@ -63,6 +63,8 @@ class MapViewModel(
         MapState(
             isLightUi = settingsRepo.otherSettings.value.stateOfLightTheme,
             isUtc = settingsRepo.otherSettings.value.stateOfUtc,
+            mapSource = settingsRepo.otherSettings.value.mapSource,
+            tiandituKey = settingsRepo.otherSettings.value.tiandituKey,
             orbitalPass = defaultPass
         )
     )
@@ -82,6 +84,8 @@ class MapViewModel(
                 _uiState.update {
                     it.copy(
                         isUtc = settings.stateOfUtc,
+                        mapSource = settings.mapSource,
+                        tiandituKey = settings.tiandituKey,
                         isGridMode = settings.stateOfMapGrid,
                         showFirstCallLabels = settings.stateOfMapFirstCall
                     )
@@ -90,11 +94,19 @@ class MapViewModel(
         }
         viewModelScope.launch {
             settingsRepo.wavelogSettings.collectLatest { _ ->
+                val workedGrids = settingsRepo.getWorkedGrids()
+                val markedGrids = settingsRepo.getMarkedGridStations()
+                // Marked stations auto-clear once their grid becomes worked:
+                // the reminder has served its purpose (user req: 网格变绿后标记自动清除).
+                val stale = markedGrids.keys.filter { it in workedGrids }
+                val activeMarks = if (stale.isEmpty()) markedGrids else markedGrids - stale.toSet()
+                if (stale.isNotEmpty()) settingsRepo.setMarkedGridStations(activeMarks)
                 _uiState.update {
                     it.copy(
-                        workedGrids = settingsRepo.getWorkedGrids(),
+                        workedGrids = workedGrids,
                         workedGridQsos = settingsRepo.getWorkedGridQsos(),
-                        roamedGrids = settingsRepo.getRoamedGrids()
+                        roamedGrids = settingsRepo.getRoamedGrids(),
+                        markedGrids = activeMarks
                     )
                 }
             }
@@ -112,6 +124,38 @@ class MapViewModel(
             is MapAction.SelectDefaultItem -> selectDefaultSatellite(action.catnum)
             is MapAction.ToggleGridMode -> settingsRepo.updateOtherSettings { it.copy(stateOfMapGrid = action.value) }
             is MapAction.ToggleFirstCallLabels -> settingsRepo.updateOtherSettings { it.copy(stateOfMapFirstCall = action.value) }
+            is MapAction.SetMarkedStation -> {
+                val call = action.call.trim().uppercase()
+                val existing = settingsRepo.getMarkedGridStations()
+                val current = existing[action.grid].orEmpty()
+                // 重复呼号忽略: 同一网格已标记过的呼号不再重复添加.
+                val updated = if (current.any { it.call == call }) existing
+                else existing + (action.grid to current + com.rtbishop.look4sat.core.domain.model.MarkedStation(
+                    call = call,
+                    epochMs = System.currentTimeMillis()
+                ))
+                settingsRepo.setMarkedGridStations(updated)
+                _uiState.update { it.copy(markedGrids = updated) }
+            }
+            is MapAction.RemoveMarkedStation -> {
+                val existing = settingsRepo.getMarkedGridStations()
+                val current = existing[action.grid].orEmpty()
+                val remaining = current.filterNot { it.call == action.call }
+                val updated = if (remaining.isEmpty()) existing - action.grid
+                else existing + (action.grid to remaining)
+                settingsRepo.setMarkedGridStations(updated)
+                _uiState.update { it.copy(markedGrids = updated) }
+            }
+            is MapAction.PinMarkedStation -> {
+                val existing = settingsRepo.getMarkedGridStations()
+                val current = existing[action.grid].orEmpty()
+                val target = current.firstOrNull { it.call == action.call }
+                if (target != null) {
+                    val updated = existing + (action.grid to listOf(target) + current.filterNot { it.call == action.call })
+                    settingsRepo.setMarkedGridStations(updated)
+                    _uiState.update { it.copy(markedGrids = updated) }
+                }
+            }
             is MapAction.SetVisible -> isScreenVisible.value = action.isVisible
         }
     }

feature/mutual/build.gradle.kts

@@ -4,4 +4,20 @@ plugins {
 
 android {
     namespace = "com.rtbishop.look4sat.feature.mutual"
-}
+    testOptions {
+        unitTests {
+            // Robolectric needs real Android resources for Compose UI tests.
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+dependencies {
+    testImplementation(libs.test.junit4)
+    testImplementation(libs.test.coroutines)
+    testImplementation(libs.robolectric)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.compose.ui.test.junit4)
+    testImplementation(libs.compose.navigation3)
+    debugImplementation(libs.compose.debug.manifest)
+}

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

@@ -17,6 +17,7 @@
  */
 package com.rtbishop.look4sat.feature.mutual
 
+import android.util.Log
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.expandVertically
 import androidx.compose.animation.shrinkVertically
@@ -54,11 +55,13 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
@@ -77,6 +80,7 @@ import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
 import java.util.TimeZone
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.distinctUntilChanged
 
 @Composable
@@ -157,7 +161,7 @@ fun MutualScreen(
             viewModel = viewModel,
             state = state,
             isVertical = isVertical,
-            onQuery = viewModel::queryMutualPasses,
+            onQuery = { viewModel.queryMutualPasses() },
             onSelectPass = viewModel::onSelectPass,
             onNavigateToRadar = navigateToRadar,
             onStationALat = viewModel::onStationALat,
@@ -170,6 +174,8 @@ fun MutualScreen(
             onStationBMinElev = viewModel::onStationBMinElev,
             onUseCurrentPosition = viewModel::onUseCurrentPosition,
             onHoursAhead = viewModel::onHoursAhead,
+            onFilterFM = viewModel::onFilterFM,
+            onFilterLinear = viewModel::onFilterLinear,
             onClearError = viewModel::clearError
         )
     }
@@ -193,6 +199,8 @@ private fun MutualContent(
     onStationBMinElev: (Double) -> Unit,
     onUseCurrentPosition: () -> Unit,
     onHoursAhead: (Int) -> Unit,
+    onFilterFM: (Boolean) -> Unit,
+    onFilterLinear: (Boolean) -> Unit,
     onClearError: () -> Unit
 ) {
     val timeFormat = remember(state.isUtc) {
@@ -220,8 +228,24 @@ private fun MutualContent(
             }
     }
 
+    // Set once the list has actually been laid out. The prefill scroll only
+    // fires after this, because on a real device the Mutual entry appears
+    // through the NavDisplay transition and LaunchedEffect alone can run
+    // before the list is measurable (the scroll then never lands and the
+    // page stays at the top). onGloballyPositioned fires on the first real
+    // layout, so the subsequent scrollToItem always has a measured list.
+    var listReady by remember { mutableStateOf(false) }
+    Log.d(TAG, "composed: scrollToTimeRange=${state.scrollToTimeRange} matchIndex=${if (state.errorMessage != null) 2 else 1} listReady=$listReady")
+
     LazyColumn(
-        modifier = Modifier.fillMaxSize(),
+        modifier = Modifier
+            .fillMaxSize()
+            .onGloballyPositioned {
+                if (!listReady) {
+                    Log.d(TAG, "lazy list laid out, opening prefill scroll gate")
+                    listReady = true
+                }
+            },
         state = listState,
         verticalArrangement = Arrangement.spacedBy(6.dp)
     ) {
@@ -246,7 +270,7 @@ private fun MutualContent(
         }
 
         // Input form
-        item {
+        item(key = "stationInputs") {
             Column(
                 modifier = Modifier.fillMaxWidth(),
                 verticalArrangement = Arrangement.spacedBy(6.dp)
@@ -323,16 +347,25 @@ private fun MutualContent(
                         )
                     }
                 }
-
-                MatchSearchCard(
-                    hoursAhead = state.hoursAhead,
-                    isCalculating = state.isCalculating,
-                    onHoursAhead = onHoursAhead,
-                    onQuery = onQuery
-                )
             }
         }
 
+        // Time range + query card. Its own LazyColumn item so a prefill from
+        // the map (grid-QSO dialog "Match" button) can scroll the page exactly
+        // to the time-range selector.
+        item(key = "matchSearch") {
+            MatchSearchCard(
+                hoursAhead = state.hoursAhead,
+                isCalculating = state.isCalculating,
+                filterFM = state.filterFM,
+                filterLinear = state.filterLinear,
+                onFilterFM = onFilterFM,
+                onFilterLinear = onFilterLinear,
+                onHoursAhead = onHoursAhead,
+                onQuery = onQuery
+            )
+        }
+
         // Results
         itemsIndexed(state.mutualPasses) { index, pass ->
             val mutualData = MutualPassData(
@@ -364,8 +397,44 @@ private fun MutualContent(
             )
         }
     }
+
+    // Prefill from the map's grid-QSO dialog "Match" button: once the page is
+    // laid out, jump straight to the time-range card. Index accounts for the
+    // optional error card at the top (error = 0, station inputs = 1, time
+    // range = 2; else 1). scrollToItem is used instead of initializing the
+    // LazyListState at index 1: the constructor parameter is ignored by this
+    // Compose version (verified in tests), while scrollToItem lands correctly.
+    val matchSearchIndex = if (state.errorMessage != null) 2 else 1
+    LaunchedEffect(state.scrollToTimeRange, matchSearchIndex, listReady) {
+        Log.d(TAG, "scroll effect: scrollToTimeRange=${state.scrollToTimeRange} matchIndex=$matchSearchIndex listReady=$listReady")
+        if (state.scrollToTimeRange && listReady) {
+            // Keep trying until the scroll really lands: on a device the first
+            // frame only contains the station cards + time-range card, which
+            // can be shorter than the viewport (no scroll range), so a single
+            // scrollToItem does nothing. When the async query results arrive
+            // the list grows past one screen and the scroll becomes possible.
+            for (attempt in 0 until 20) {
+                Log.d(TAG, "attempting scrollToItem($matchSearchIndex) #$attempt")
+                try {
+                    listState.scrollToItem(matchSearchIndex)
+                } catch (t: Throwable) {
+                    Log.e(TAG, "scrollToItem($matchSearchIndex) threw", t)
+                    break
+                }
+                if (listState.firstVisibleItemIndex == matchSearchIndex) {
+                    Log.d(TAG, "scroll landed at $matchSearchIndex on attempt #$attempt")
+                    break
+                }
+                delay(100)
+            }
+            viewModel.consumeScrollToTimeRange()
+            Log.d(TAG, "scrollToTimeRange consumed")
+        }
+    }
 }
 
+private const val TAG = "Look4SatMutual"
+
 @Composable
 private fun MutualStatusChip(state: MutualUiState) {
     val colorScheme = MaterialTheme.colorScheme
@@ -509,6 +578,10 @@ private fun StationInputCard(
 private fun MatchSearchCard(
     hoursAhead: Int,
     isCalculating: Boolean,
+    filterFM: Boolean,
+    filterLinear: Boolean,
+    onFilterFM: (Boolean) -> Unit,
+    onFilterLinear: (Boolean) -> Unit,
     onHoursAhead: (Int) -> Unit,
     onQuery: () -> Unit,
     modifier: Modifier = Modifier
@@ -535,6 +608,28 @@ private fun MatchSearchCard(
                     )
                 }
             }
+            // 转发器类型筛选: 只匹配 AMSAT Live 清单里的 FM 话音 / 线性转发器卫星,
+            // 防止选入大量无转发器卫星占用匹配页.
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = stringResource(R.string.mutual_filter_transponder),
+                    style = MaterialTheme.typography.labelLarge
+                )
+                FilterChip(
+                    selected = filterFM,
+                    onClick = { onFilterFM(!filterFM) },
+                    label = { Text(stringResource(R.string.mutual_filter_fm)) }
+                )
+                FilterChip(
+                    selected = filterLinear,
+                    onClick = { onFilterLinear(!filterLinear) },
+                    label = { Text(stringResource(R.string.mutual_filter_linear)) }
+                )
+            }
             Button(
                 onClick = onQuery,
                 enabled = !isCalculating,

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

@@ -26,6 +26,7 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.Sources
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
 import com.rtbishop.look4sat.core.domain.utility.qthToPosition
 import kotlinx.coroutines.CoroutineDispatcher
@@ -40,6 +41,8 @@ import kotlinx.coroutines.withContext
 import kotlin.math.PI
 import kotlin.math.roundToInt
 
+private const val TAG = "Look4SatMutual"
+
 data class MutualUiState(
     val stationALat: String = "",
     val stationALon: String = "",
@@ -50,12 +53,28 @@ data class MutualUiState(
     val stationBGrid: String = "",
     val stationBMinElev: Double = 10.0,
     val hoursAhead: Int = 24,
+    /** 历史过境回看窗口(小时), 跟随主页面 Passes 设置; 匹配查询从
+     *  now-hoursBefore 开始, 使设置过历史回看时匹配页也包含历史过境. */
+    val hoursBefore: Int = 0,
+    /** 转发器类型筛选: 只匹配搭载 FM 话音转发器的卫星. 默认开启. */
+    val filterFM: Boolean = true,
+    /** 转发器类型筛选: 只匹配搭载线性(USB/LSB/CW/SSB)转发器的卫星. 默认开启. */
+    val filterLinear: Boolean = true,
     val mutualPasses: List<MutualPass> = emptyList(),
     val isCalculating: Boolean = false,
     val hasSearched: Boolean = false,
     val selectedPassIndex: Int = -1,
     val isUtc: Boolean = false,
-    val errorMessage: String? = null
+    val errorMessage: String? = null,
+    // One-shot flag set by prefillMatchFromGrid() (map grid → Match button):
+    // the page scrolls to the time-range card after the first layout, then
+    // consumeScrollToTimeRange() clears it.
+    val scrollToTimeRange: Boolean = false,
+    // One-shot flag set by prefillMatchFromGrid(): the map page waits for the
+    // pre-filled query to finish, then navigates to the match page so the very
+    // first frame already contains the results (time-range card + pass curves,
+    // no scroll flicker). consumePendingNavigation() clears it.
+    val pendingNavigation: Boolean = false
 )
 
 class MutualViewModel(
@@ -97,6 +116,12 @@ class MutualViewModel(
                 _uiState.update { it.copy(isUtc = settings.stateOfUtc) }
             }
         }
+        // 历史过境回看窗口跟随主页面 Passes 设置 (设置里改小时数, 匹配页同步生效)
+        viewModelScope.launch {
+            settingsRepo.passesSettings.collectLatest { settings ->
+                _uiState.update { it.copy(hoursBefore = settings.hoursBefore) }
+            }
+        }
     }
 
     fun onStationALat(value: String) {
@@ -181,9 +206,54 @@ class MutualViewModel(
         ) }
     }
     fun onHoursAhead(value: Int) = _uiState.update { it.copy(hoursAhead = value) }
+    fun onFilterFM(value: Boolean) = _uiState.update { it.copy(filterFM = value) }
+    fun onFilterLinear(value: Boolean) = _uiState.update { it.copy(filterLinear = value) }
     fun onSelectPass(index: Int) = _uiState.update { it.copy(selectedPassIndex = index) }
 
-    fun queryMutualPasses() {
+    /**
+     * Pre-fill the match page for a target grid picked from the map's grid-QSO
+     * dialog ("Match" button): set the opposite-station grid (with its
+     * coordinates), reset the time range to 24h, start the query immediately
+     * so results are ready when the page opens, and flag the page to scroll
+     * straight to the time-range card once it is laid out.
+     */
+    fun prefillMatchFromGrid(grid: String) {
+        val g = grid.trim().uppercase()
+        val pos = qthToPosition(g)
+        android.util.Log.d(TAG, "prefillMatchFromGrid('$g')")
+        _uiState.update {
+            it.copy(
+                stationBGrid = g,
+                stationBLat = pos?.let { p -> "%.4f".format(p.latitude) } ?: it.stationBLat,
+                stationBLon = pos?.let { p -> "%.4f".format(p.longitude) } ?: it.stationBLon,
+                hoursAhead = 24,
+                scrollToTimeRange = true,
+                pendingNavigation = true
+            )
+        }
+        queryMutualPasses()
+    }
+
+    fun consumePendingNavigation() {
+        android.util.Log.d(TAG, "consumePendingNavigation")
+        _uiState.update { it.copy(pendingNavigation = false) }
+    }
+
+    fun consumeScrollToTimeRange() {
+        android.util.Log.d(TAG, "consumeScrollToTimeRange")
+        _uiState.update { it.copy(scrollToTimeRange = false) }
+    }
+
+    /**
+     * Run a mutual-pass query. `initialScrollIndex` non-null forces the list
+     * to rebuild at that position (legacy callers); null keeps the current
+     * scroll position, so re-running a query from the match page does not
+     * jump back to the top. The previous results stay on screen while the
+     * query runs (the list keeps its height, so the scroll position is not
+     * clamped away); they are replaced — possibly with empty — when the new
+     * results arrive.
+     */
+    fun queryMutualPasses(initialScrollIndex: Int? = null) {
         val state = _uiState.value
 
         // Resolve positions from lat/lon or grid
@@ -201,29 +271,64 @@ class MutualViewModel(
             return
         }
 
+        // 转发器类型筛选: 至少勾选一种(默认 FM + Linear 都开), 否则提示不查询.
+        // 防止用户选入大量无转发器卫星占用匹配页.
+        if (!state.filterFM && !state.filterLinear) {
+            _uiState.update { it.copy(errorMessage = "Select at least one transponder type (FM / Linear) to run the match.") }
+            return
+        }
+        // AMSAT Live 清单(同步自 AMSAT "Live FM/Linear Satellites" 页面)是本过滤的
+        // 权威来源: 只匹配当前在轨且话音/线性转发器实际工作的卫星. 清单为空
+        // (从未成功同步过)时回退到数据库 downlinkMode 过滤, 避免首启匹配页空结果.
+        // 过滤本身在下面的协程里执行 (getSatelliteIdsWithModes 是 suspend).
+
         _uiState.update {
             it.copy(
                 isCalculating = true,
                 hasSearched = true,
                 errorMessage = null,
-                mutualPasses = emptyList(),
+                // Deliberately keep mutualPasses: clearing it would shrink the
+                // list below one screen and clamp the scroll position away.
+                // The stale results are replaced when the new ones arrive.
                 selectedPassIndex = -1
             )
         }
-        // The results list is about to be replaced, so the scroll position must
-        // not leak from the previous query's list.
-        listScrollIndex = 0
-        listScrollOffset = 0
+        // Scroll position: an explicit initialScrollIndex overrides (legacy
+        // callers start at a fixed spot); null keeps the current position so
+        // re-querying does not jump back to the top.
+        if (initialScrollIndex != null) {
+            listScrollIndex = initialScrollIndex
+            listScrollOffset = 0
+        }
         queryGeneration += 1
 
         viewModelScope.launch {
-            val time = System.currentTimeMillis()
+            val now = System.currentTimeMillis()
+            // 转发器类型筛选: 使用硬编码 AMSAT Live 清单 (见 Sources):
+            // FM = {SO-50, ISS ZARYA, AO-123}, Linear = {RS-44, FO-29,
+            // AO-7, AO-73, JO-97}. 不再依赖 AMSAT 网页同步: 任何网络下都
+            // 稳定, 没有旧脏列表/超时/同步失败清空等问题.
+            val allowed = buildSet {
+                if (state.filterFM) addAll(Sources.amSatFmCatnums)
+                if (state.filterLinear) addAll(Sources.amSatLinearCatnums)
+            }
+            val filteredSatellites = satellites.filter { it.data.catnum in allowed }
+            // 历史回看: 查询窗口起点 = now - hoursBefore (跟随主页面 Passes 设置),
+            // 终点 = now + hoursAhead 不变.
+            val time = now - state.hoursBefore * 60L * 60L * 1000L
             val minElevA = state.stationAMinElev
             val minElevB = state.stationBMinElev
             val hours = state.hoursAhead
 
-            val results = withContext(computeDispatcher) {
-                findMutualPasses(satellites, posA, posB, minElevA, minElevB, time, hours)
+            val results = try {
+                withContext(computeDispatcher) {
+                    findMutualPasses(filteredSatellites, posA, posB, minElevA, minElevB, time, hours, state.hoursBefore)
+                }
+            } catch (t: Throwable) {
+                // Never leave the query stuck in "calculating" (which would also
+                // block the pending map→match navigation forever).
+                android.util.Log.e(TAG, "findMutualPasses threw", t)
+                emptyList()
             }
 
             val errorMsg = if (results.isEmpty()) {
@@ -262,15 +367,20 @@ class MutualViewModel(
         satellites: List<OrbitalObject>,
         posA: GeoPos, posB: GeoPos,
         minElevADeg: Double, minElevBDeg: Double,
-        time: Long, hours: Int
+        time: Long, hours: Int, hoursBefore: Int
     ): List<MutualPass> {
-        val endTime = time + hours * 60L * 60L * 1000L
+        // 终点始终是 now + hoursAhead; 起点已由调用方下移 hoursBefore 小时,
+        // 因此这里的 endTime 要在起点之上补回 hoursBefore, 保证窗口 = [now-hb, now+h].
+        val endTime = time + (hoursBefore + hours) * 60L * 60L * 1000L
         val sampleInterval = 5_000L
 
         // Use the main page's pass list for AOS/LOS times, then sample the curves
         // using the actual positions. The passes list is already computed by getLeoPass
         // and its AOS/LOS times match the Passes page exactly.
-        val existingPasses = satelliteRepo.passes.value
+        // The satellites argument may be a subset (transponder-type filter), so
+        // only passes belonging to the filtered satellites are reused.
+        val allowedCatnums = satellites.map { it.data.catnum }.toSet()
+        val existingPasses = satelliteRepo.passes.value.filter { it.catNum in allowedCatnums }
         val results = findMutualPassesFromList(existingPasses, satellites, posA, posB,
             minElevADeg, minElevBDeg, time, endTime, sampleInterval)
         if (results.isNotEmpty()) return results

feature/mutual/src/test/java/com/rtbishop/look4sat/feature/mutual/Fakes.kt

@@ -44,13 +44,18 @@ class FakeSatelliteRepo(
     override suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos> = TODO()
     override suspend fun getRadios(sat: OrbitalObject, pos: GeoPos, radios: List<SatRadio>, time: Long): List<SatRadio> = TODO()
     override suspend fun getRadiosWithId(id: Int): List<SatRadio> = TODO()
+    override suspend fun getSatelliteIdsWithModes(modes: List<String>): List<Int> = emptyList()
+    override suspend fun getSatelliteIdsWithModesAndUplink(modes: List<String>): List<Int> = emptyList()
+    override suspend fun getSatelliteIdsWithModesAndAmateur(modes: List<String>): List<Int> = emptyList()
 }
 
 /**
  * Test fake for ISettingsRepo. Only [stationPosition] is backed by mutable
  * state; everything else the ViewModel never touches fails loudly.
  */
-class FakeSettingsRepo(initialPosition: GeoPos = GeoPos(23.13, 113.26)) : ISettingsRepo {
+class FakeSettingsRepo(
+    initialPosition: GeoPos = GeoPos(23.13, 113.26)
+) : ISettingsRepo {
 
     override val stationPosition = MutableStateFlow(initialPosition)
 
@@ -115,6 +120,8 @@ class FakeSettingsRepo(initialPosition: GeoPos = GeoPos(23.13, 113.26)) : ISetti
     override fun setWorkedGridQsos(qsos: Map<String, List<GridQso>>) = TODO()
     override fun getRoamedGrids(): Set<String> = TODO()
     override fun setRoamedGrids(grids: Set<String>) = TODO()
+    override fun getMarkedGridStations(): Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>> = emptyMap()
+    override fun setMarkedGridStations(stations: Map<String, List<com.rtbishop.look4sat.core.domain.model.MarkedStation>>) = Unit
     override fun updateLoTWSettings(settings: LoTWSettings) = TODO()
     override fun getLastLotwSyncDate(): String = ""
     override fun setLastLotwSyncDate(date: String) = Unit

feature/mutual/src/test/java/com/rtbishop/look4sat/feature/mutual/MutualMatchPrefillScrollTest.kt

@@ -0,0 +1,291 @@
+package com.rtbishop.look4sat.feature.mutual
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.navigation3.runtime.NavBackStack
+import androidx.navigation3.runtime.NavKey
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.runtime.rememberNavBackStack
+import androidx.navigation3.ui.NavDisplay
+import com.rtbishop.look4sat.core.presentation.Screen
+import kotlinx.coroutines.delay
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+/**
+ * Verifies the map grid-QSO dialog "Match" prefill: after
+ * [MutualViewModel.prefillMatchFromGrid] the page opens with the time-range
+ * card at the top and the 24h query auto-started.
+ *
+ * Note: `LazyListState(firstVisibleItemIndex = 1)` is deliberately NOT used to
+ * position the page. In this Compose version (BOM 2026.06.01 / ui 1.11.x) the
+ * constructor parameter is ignored — the list still starts at item 0 — while
+ * `listState.scrollToItem(1)` from a LaunchedEffect lands correctly. See
+ * [scrollToItemLandsAtTop] below, which guards the scrollToItem mechanism.
+ *
+ * Robolectric quirk: `assertIsNotDisplayed()` is unreliable here (a node
+ * scrolled fully out of the viewport can still report "displayed"), so the
+ * prefill test asserts the time-range card IS displayed (positive assertion)
+ * rather than that the station card is NOT.
+ */
+@RunWith(RobolectricTestRunner::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(sdk = [34], qualifiers = "w411dp-h891dp-port")
+class MutualMatchPrefillScrollTest {
+
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    @Test
+    fun sanity_textRenders() {
+        composeRule.setContent {
+            MaterialTheme {
+                Text("sanity-check-text")
+            }
+        }
+        composeRule.onNodeWithText("sanity-check-text").assertIsDisplayed()
+    }
+
+    @Test
+    fun scrollToItemLandsAtTop() {
+        // Guards the mechanism the prefill relies on: scrollToItem(1) from a
+        // LaunchedEffect moves item 1 to the top of the viewport.
+        composeRule.setContent {
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    val state = remember { LazyListState(firstVisibleItemIndex = 0) }
+                    LaunchedEffect(Unit) { state.scrollToItem(1) }
+                    LazyColumn(state = state) {
+                        item { Text("min-item-0") }
+                        item { Text("min-item-1") }
+                        item { Text("min-item-2") }
+                    }
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        composeRule.onNodeWithText("min-item-1").assertIsDisplayed()
+    }
+
+    @Test
+    fun defaultOpen_showsStationInputsAtTop() {
+        val vm = MutualViewModel(FakeSatelliteRepo(), FakeSettingsRepo())
+        composeRule.setContent {
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    MutualScreen(viewModel = vm)
+                }
+            }
+        }
+        // Without a prefill the list starts at item 0 (station inputs).
+        composeRule.onNodeWithText("Your Station").assertIsDisplayed()
+    }
+
+    @Test
+    fun prefillFromMap_opensAtTimeRangeCard() {
+        val vm = MutualViewModel(FakeSatelliteRepo(), FakeSettingsRepo())
+        // Same call the map grid-QSO "Match" button makes.
+        vm.prefillMatchFromGrid("OL62")
+
+        composeRule.setContent {
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    MutualScreen(viewModel = vm)
+                }
+            }
+        }
+
+        composeRule.waitForIdle()
+
+        // The time-range card must be visible at the top of the page after the
+        // prefill scroll.
+        composeRule.onNodeWithText("Time range").assertIsDisplayed()
+        // The snapshotFlow write-back stores the scrolled position in the VM.
+        // It equals 1 only if scrollToItem(1) REALLY scrolled the station card
+        // out. If the list content is shorter than the viewport there is no
+        // scroll range, scrollToItem cannot move, and this stays 0 — that is
+        // exactly the device symptom ("page stays at the top").
+        org.junit.Assert.assertEquals(
+            "list must have actually scrolled to item 1 (content shorter than viewport?)",
+            1, vm.listScrollIndex
+        )
+    }
+
+    @Test
+    fun prefillAutoStartsQueryAndFillsState() {
+        val vm = MutualViewModel(FakeSatelliteRepo(), FakeSettingsRepo())
+        vm.prefillMatchFromGrid("OL62")
+        val s = vm.uiState.value
+        // Query auto-started: with the empty-satellite fake the query reaches
+        // the "no satellite data" guard (rather than never being triggered),
+        // proving prefillMatchFromGrid kicks off queryMutualPasses.
+        assertTrue(
+            "auto-query should reach the satellite guard: gridA=${s.stationAGrid} " +
+                "gridB=${s.stationBGrid} err=${s.errorMessage}",
+            s.errorMessage?.contains("satellite", ignoreCase = true) == true
+        )
+        // ...and the target grid + 24h range pre-filled.
+        org.junit.Assert.assertEquals("OL62", s.stationBGrid)
+        org.junit.Assert.assertEquals(24, s.hoursAhead)
+        // ...and navigation to the match page is pending until the query done.
+        assertTrue("navigation should be pending", s.pendingNavigation)
+        // The early-return guard means the query finished immediately (no
+        // satellites): the map page must now be free to navigate.
+        org.junit.Assert.assertFalse("query finished -> not calculating", s.isCalculating)
+        vm.consumePendingNavigation()
+        org.junit.Assert.assertFalse("consume clears pending navigation", vm.uiState.value.pendingNavigation)
+    }
+
+    @Test
+    fun navDisplayEntryAfterPrefill_scrollsToTimeRange() {
+        // The Mutual screen composed inside a NavDisplay entry (back stack
+        // [Mutual]) right after prefillMatchFromGrid.
+        val vm = MutualViewModel(FakeSatelliteRepo(), FakeSettingsRepo())
+        vm.prefillMatchFromGrid("OL62")
+        composeRule.setContent {
+            val backStack = rememberNavBackStack(Screen.Mutual)
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    NavDisplay(
+                        backStack = backStack,
+                        onBack = { backStack.removeLastOrNull() },
+                        entryProvider = entryProvider {
+                            entry<Screen.Mutual> { MutualScreen(viewModel = vm) }
+                        }
+                    )
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        composeRule.onNodeWithText("Time range").assertIsDisplayed()
+    }
+
+    @Test
+    fun navDisplay_switchToMutualEntry_scrollsToTimeRange() {
+        // Closest device path: start on the Map entry, then push the Mutual
+        // entry (what the map "Match" button does). NavDisplay runs a real
+        // fade transition while the Mutual screen composes.
+        val vm = MutualViewModel(FakeSatelliteRepo(), FakeSettingsRepo())
+        vm.prefillMatchFromGrid("OL62")
+        val backStackRef = mutableStateOf<NavBackStack<NavKey>?>(null)
+        composeRule.setContent {
+            val backStack = rememberNavBackStack(Screen.Map)
+            backStackRef.value = backStack
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    NavDisplay(
+                        backStack = backStack,
+                        onBack = { backStack.removeLastOrNull() },
+                        entryProvider = entryProvider {
+                            entry<Screen.Map> { Text("MAP PAGE") }
+                            entry<Screen.Mutual> { MutualScreen(viewModel = vm) }
+                        }
+                    )
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        // Push Mutual like onMatchGrid does, so the transition composes
+        // MutualScreen with scrollToTimeRange already set.
+        composeRule.runOnIdle { backStackRef.value?.add(Screen.Mutual) }
+        composeRule.waitForIdle()
+        composeRule.onNodeWithText("Time range").assertIsDisplayed()
+    }
+
+    @Test
+    fun scrollRetriesUntilContentGrows() {
+        // Reproduces the real-device mechanism: the first frame's content
+        // (item 0 short) is shorter than the viewport, so scrollToItem(1) has
+        // no range and cannot move. Then the content grows (async results)
+        // past one screen; the retry loop must land on item 1.
+        composeRule.setContent {
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    val tall = mutableStateOf(false)
+                    LaunchedEffect(Unit) { delay(300); tall.value = true }
+                    val state = remember { LazyListState() }
+                    LaunchedEffect(state) {
+                        // Same retry loop MutualScreen uses for the prefill.
+                        for (attempt in 0 until 20) {
+                            state.scrollToItem(1)
+                            if (state.firstVisibleItemIndex == 1) return@LaunchedEffect
+                            delay(100)
+                        }
+                    }
+                    LazyColumn(state = state) {
+                        item {
+                            if (tall.value) Spacer(modifier = Modifier.height(900.dp))
+                            else Spacer(modifier = Modifier.height(40.dp))
+                        }
+                        item { Text("target-item") }
+                    }
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        composeRule.onNodeWithText("target-item").assertIsDisplayed()
+        // Confirm the list really scrolled (station card equivalent is gone).
+        // We can't read listState from here, so use the VM-style probe: none —
+        // the target visible + viewport tall enough implies item 1 on top.
+    }
+
+    @Test
+    fun keepPositionAcrossTabs_thenMapMatchPrefill_scrollsToTimeRange() {
+        // User hypothesis: the "keep scroll position across tab switches"
+        // machinery (listState remember(queryGeneration) + snapshotFlow
+        // write-back) interferes with the prefill auto-scroll. Reproduce the
+        // full journey: first visit -> scroll a bit -> leave -> return
+        // (position restored) -> leave -> enter via map Match button.
+        val vm = MutualViewModel(FakeSatelliteRepo(), FakeSettingsRepo())
+        val showMutual = mutableStateOf(true)
+
+        // First visit (e.g. bottom nav), user scrolls a little; the
+        // snapshotFlow write-back stored index/offset in the VM.
+        composeRule.setContent {
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    if (showMutual.value) MutualScreen(viewModel = vm)
+                }
+            }
+        }
+        composeRule.waitForIdle()
+        vm.listScrollIndex = 0
+        vm.listScrollOffset = 40
+
+        // Leave the page (tab switch destroys the composition).
+        showMutual.value = false
+        composeRule.waitForIdle()
+
+        // Re-enter: keep-position restores the scroll offset.
+        showMutual.value = true
+        composeRule.waitForIdle()
+
+        // Leave again, then enter via the map grid-QSO Match button.
+        showMutual.value = false
+        composeRule.waitForIdle()
+        vm.prefillMatchFromGrid("OL62")
+        showMutual.value = true
+        composeRule.waitForIdle()
+
+        composeRule.onNodeWithText("Time range").assertIsDisplayed()
+    }
+}

feature/mutual/src/test/java/com/rtbishop/look4sat/feature/mutual/MutualViewModelTest.kt

@@ -285,4 +285,101 @@ class MutualViewModelTest {
 
         assertNull(vm.uiState.value.errorMessage)
     }
+
+    @Test
+    fun `requery keeps scroll position and stale results while running`() = runTest(mainDispatcherRule.dispatcher.scheduler) {
+        val windows = TestOrbits.findPassWindows()
+        assertTrue("fixture must produce ISS windows", windows.isNotEmpty())
+        val vm = createVm(
+            satellites = listOf(TestOrbits.ISS),
+            passes = windows
+        )
+        vm.onStationBGrid("OL62")
+        queryAndSettle(vm)
+        assertTrue("fixture must yield passes", vm.uiState.value.mutualPasses.isNotEmpty())
+
+        // The user scrolled into the results; the snapshotFlow write-back has
+        // stored this position in the VM.
+        vm.listScrollIndex = 4
+        vm.listScrollOffset = 137
+
+        // Re-run the query from the match page ("query" button).
+        vm.queryMutualPasses()
+
+        // While the query runs, the old results stay on screen (the list keeps
+        // its height, so the scroll position is not clamped away)...
+        assertTrue("stale results kept while calculating", vm.uiState.value.mutualPasses.isNotEmpty())
+        // ...and the scroll position must not be reset to the top.
+        assertEquals(4, vm.listScrollIndex)
+        assertEquals(137, vm.listScrollOffset)
+
+        advanceUntilIdle()
+        assertFalse(vm.uiState.value.isCalculating)
+        assertTrue("fresh results replace the stale ones", vm.uiState.value.mutualPasses.isNotEmpty())
+        // Position intact after the query settled.
+        assertEquals(4, vm.listScrollIndex)
+        assertEquals(137, vm.listScrollOffset)
+    }
+
+    // --------------------------------------------- transponder filters (AMSAT)
+
+    @Test
+    fun `both filters off sets an error and does not search`() = runTest(mainDispatcherRule.dispatcher.scheduler) {
+        val windows = TestOrbits.findPassWindows()
+        val vm = createVm(satellites = listOf(TestOrbits.ISS), passes = windows)
+        vm.onStationBGrid("OL62")
+        vm.onFilterFM(false)
+        vm.onFilterLinear(false)
+
+        queryAndSettle(vm)
+
+        assertEquals(
+            "Select at least one transponder type (FM / Linear) to run the match.",
+            vm.uiState.value.errorMessage
+        )
+        assertFalse(vm.uiState.value.hasSearched)
+    }
+
+    @Test
+    fun `hardcoded AMSAT filter restricts results to listed catnums`() = runTest(mainDispatcherRule.dispatcher.scheduler) {
+        val windows = TestOrbits.findPassWindows(hoursAhead = 24) +
+            TestOrbits.findPassWindows(sat = TestOrbits.ISS_VARIANT, hoursAhead = 24)
+        assertTrue("fixture must produce windows", windows.isNotEmpty())
+        // ISS (25544) is on the hardcoded FM list (Sources.amSatFmCatnums);
+        // ISS_VARIANT (25545) is not.
+        val vm = createVm(
+            satellites = listOf(TestOrbits.ISS, TestOrbits.ISS_VARIANT),
+            passes = windows
+        )
+        vm.onStationBGrid("OL62")
+        vm.onHoursAhead(24)
+
+        queryAndSettle(vm)
+
+        val state = vm.uiState.value
+        assertNull(state.errorMessage)
+        assertTrue(state.mutualPasses.isNotEmpty())
+        assertTrue("only hardcoded FM-listed satellites should appear", state.mutualPasses.all { it.catNum == 25544 })
+    }
+
+    @Test
+    fun `turning FM off excludes FM-listed satellites under Linear filter`() = runTest(mainDispatcherRule.dispatcher.scheduler) {
+        val windows = TestOrbits.findPassWindows(hoursAhead = 24) +
+            TestOrbits.findPassWindows(sat = TestOrbits.ISS_VARIANT, hoursAhead = 24)
+        // ISS (25544) is on the hardcoded FM list but NOT on the hardcoded
+        // Linear list; with FM off and Linear on, no satellite passes.
+        val vm = createVm(
+            satellites = listOf(TestOrbits.ISS, TestOrbits.ISS_VARIANT),
+            passes = windows
+        )
+        vm.onStationBGrid("OL62")
+        vm.onHoursAhead(24)
+        vm.onFilterFM(false)
+
+        queryAndSettle(vm)
+
+        val state = vm.uiState.value
+        // 空结果会设置 "No mutual passes found" 提示, 这是正常行为而非筛选错误.
+        assertTrue(state.mutualPasses.isEmpty())
+    }
 }

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

@@ -30,12 +30,15 @@ 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.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.ElevatedCard
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.HorizontalDivider
@@ -145,11 +148,16 @@ private fun PassesScreen(
             onAccept = dismiss,
             titleFontSize = 18
         ) { padding ->
+            // The changelog is long; keep the dialog frame fixed and let the
+            // text scroll inside it (matches the update-checker page pattern).
             Text(
                 text = stringResource(R.string.pass_whatsnew_message),
                 fontSize = 16.sp,
                 color = MaterialTheme.colorScheme.onSurface,
-                modifier = Modifier.padding(horizontal = padding)
+                modifier = Modifier
+                    .padding(horizontal = padding)
+                    .heightIn(max = 360.dp)
+                    .verticalScroll(rememberScrollState())
             )
         }
     }

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

@@ -96,8 +96,12 @@ class PassesViewModel(
                     val timeNow = System.currentTimeMillis()
                     val isUtc = _uiState.value.isUtc
                     val showDeepSpace = _uiState.value.showDeepSpace
+                    // 历史过境窗口: 已结束的过境保留到超过 hoursBefore 小时后消失;
+                    // DeepSpace 保持原行为(始终显示). hoursBefore=0 时过境一结束即消失.
+                    val historyCutoff = timeNow - _uiState.value.hoursBefore * 3600_000L
                     val filtered = allPasses
                         .let { if (showDeepSpace) it else it.filter { pass -> !pass.isDeepSpace } }
+                        .filter { pass -> pass.isDeepSpace || pass.losTime >= historyCutoff }
                     val processed = computePassProgress(filtered, timeNow)
                     val (nextPass, nextTime, isAos) = resolveNextPass(processed, timeNow)
                     val sunTimes = computeSunTimes(processed, isUtc)
@@ -339,9 +343,10 @@ class PassesViewModel(
 
     private fun refreshPasses() = viewModelScope.launch {
         val settings = settingsRepo.passesSettings.value
+        // 下拉刷新也保留历史过境窗口, 否则刷新即丢 history (与筛选/启动计算口径一致)
         satelliteRepo.calculatePasses(
-            time = System.currentTimeMillis(),
-            hoursAhead = settings.hoursAhead,
+            time = System.currentTimeMillis() - settings.hoursBefore * 60L * 60L * 1000L,
+            hoursAhead = settings.hoursBefore + settings.hoursAhead,
             minElevation = settings.minElevation,
             aosStartMinute = settings.aosStartMinute,
             aosEndMinute = settings.aosEndMinute,

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

@@ -0,0 +1,315 @@
+/*
+ * 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.radar
+
+import android.content.Intent
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.platform.LocalClipboardManager
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.displayMode
+import com.rtbishop.look4sat.core.presentation.SwipeController
+import com.rtbishop.look4sat.core.presentation.SwipeRevealRow
+import com.rtbishop.look4sat.core.presentation.rememberSwipeController
+import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
+import com.rtbishop.look4sat.core.presentation.EmptyListCard
+
+private const val LOG_WINDOW_MS = 24 * 3_600_000L
+
+@Composable
+fun LogPage(
+    uiState: RadarState,
+    logViewModel: LogViewModel,
+    modifier: Modifier = Modifier
+) {
+    val logUiState by logViewModel.uiState.collectAsStateWithLifecycle()
+    val records by logViewModel.records.collectAsStateWithLifecycle(initialValue = emptyList())
+    val swipeController = rememberSwipeController()
+
+    val selectedRadio = remember(uiState.transceivers.transmitters, uiState.transceivers.selectedUuid) {
+        uiState.transceivers.transmitters.firstOrNull { it.uuid == uiState.transceivers.selectedUuid }
+    }
+    // Linear if the satellite carries ANY named linear transponder — same test
+    // that gates the Calculator tab (RadarScreen), so the mode selector and the
+    // calculator always appear together regardless of which entry is selected.
+    val isLinear = uiState.transceivers.transmitters.any(DopplerFrequencyCalculator::isNamedLinearTransponder)
+    val catnum = uiState.currentPass?.catNum ?: selectedRadio?.catnum ?: 0
+    val satName = uiState.currentPass?.name?.trim().orEmpty()
+
+    LaunchedEffect(catnum) {
+        if (catnum != 0) logViewModel.selectSatellite(catnum)
+    }
+
+    val txHz = uiState.calculatorTxHz ?: remember(selectedRadio) {
+        selectedRadio?.uplinkLow?.let { low ->
+            selectedRadio.uplinkHigh?.let { high -> (low + high) / 2 } ?: low
+        }
+    }
+    val rxHz = uiState.calculatorRxHz ?: remember(selectedRadio) {
+        selectedRadio?.downlinkLow?.let { low ->
+            selectedRadio.downlinkHigh?.let { high -> (low + high) / 2 } ?: low
+        }
+    }
+    val mode = if (isLinear) logUiState.selectedMode.ifBlank { "CW" } else "FM"
+    val now = System.currentTimeMillis()
+    val recent = records
+        .filter { it.satelliteName.trim().equals(satName, true) && it.startUtcMillis > now - LOG_WINDOW_MS }
+        .sortedByDescending { it.startUtcMillis }
+    val maxElev = uiState.currentPass?.maxElevation ?: 0.0
+
+    Column(modifier = modifier.fillMaxSize().padding(8.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        Row(horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically) {
+            OutlinedTextField(
+                value = logUiState.callsignInput,
+                onValueChange = logViewModel::updateCallsign,
+                modifier = Modifier.weight(1f),
+                placeholder = { Text("Callsign", fontSize = 14.sp) },
+                singleLine = true,
+                keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
+                    capitalization = KeyboardCapitalization.Characters,
+                    imeAction = ImeAction.Done
+                ),
+                keyboardActions = androidx.compose.foundation.text.KeyboardActions(onDone = {
+                    logViewModel.record(satName, mode, txHz, rxHz, logUiState.stationGrid)
+                })
+            )
+            Button(
+                onClick = { logViewModel.record(satName, mode, txHz, rxHz, logUiState.stationGrid) },
+                enabled = logUiState.callsignInput.isNotBlank() && satName.isNotBlank()
+            ) { Text("Log") }
+        }
+        if (isLinear) {
+            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                listOf("CW", "SSB", "FT4").forEach { candidate ->
+                    FilterChip(
+                        selected = mode == candidate,
+                        onClick = { logViewModel.selectMode(catnum, candidate) },
+                        label = { Text(candidate, fontSize = 13.sp) }
+                    )
+                }
+            }
+        } else {
+            Text("FM", style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        }
+
+        if (recent.isEmpty()) {
+            EmptyListCard(message = "No QSOs yet — type a callsign and tap Log")
+        } else {
+            LazyColumn(modifier = Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+                items(recent, key = { it.id }) { record ->
+                    LogRecordRow(record, swipeController, onDelete = { logViewModel.delete(record.id) })
+                }
+            }
+        }
+
+        Row(horizontalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) {
+            OutlinedButton(
+                onClick = { logViewModel.generatePost(satName, maxElev) },
+                enabled = recent.isNotEmpty(),
+                modifier = Modifier.weight(1f)
+            ) { Text("生成通联记录", fontSize = 13.sp) }
+            OutlinedButton(
+                onClick = logViewModel::prepareUpload,
+                enabled = !logUiState.busy,
+                modifier = Modifier.weight(1f)
+            ) { Text("上传 LoTW", fontSize = 13.sp) }
+        }
+        if (logUiState.busy) {
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                CircularProgressIndicator(modifier = Modifier.padding(4.dp), strokeWidth = 2.dp)
+                Text("Working…", fontSize = 13.sp)
+            }
+        }
+    }
+
+    logUiState.postText?.let { text ->
+        val clipboard = LocalClipboardManager.current
+        val context = LocalContext.current
+        PostDialog(
+            text = text,
+            onDismiss = logViewModel::dismissPost,
+            onCopy = {
+                clipboard.setText(AnnotatedString(text))
+                logViewModel.dismissPost()
+            },
+            onShare = {
+                val send = Intent(Intent.ACTION_SEND).apply {
+                    type = "text/plain"
+                    putExtra(Intent.EXTRA_TEXT, text)
+                }
+                context.startActivity(Intent.createChooser(send, "Share QSO log"))
+                logViewModel.dismissPost()
+            }
+        )
+    }
+
+    logUiState.preview?.let { preview ->
+        UploadPreviewDialog(
+            preview = preview,
+            busy = logUiState.busy,
+            onConfirm = logViewModel::confirmUpload,
+            onDismiss = logViewModel::dismissPreview
+        )
+    }
+
+    if (logUiState.message.isNotBlank()) {
+        AlertDialog(
+            onDismissRequest = logViewModel::clearMessage,
+            title = { Text("LoTW Upload") },
+            text = { Text(logUiState.message) },
+            confirmButton = {
+                TextButton(onClick = logViewModel::clearMessage) { Text("OK") }
+            }
+        )
+    }
+}
+
+@Composable
+private fun LogRecordRow(record: QsoRecord, swipeController: SwipeController, onDelete: () -> Unit) {
+    val time = remember(record.startUtcMillis) {
+        java.text.SimpleDateFormat("HH:mm'Z'", java.util.Locale.US).apply {
+            timeZone = java.util.TimeZone.getTimeZone("UTC")
+        }.format(java.util.Date(record.startUtcMillis))
+    }
+    // 右划露出删除按钮（短信式）；整行点击不再删除。
+    SwipeRevealRow(
+        key = record.id.toString(),
+        controller = swipeController,
+        revealAction = onDelete,
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp, vertical = 2.dp),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(text = "$time ", fontSize = 14.sp, maxLines = 1)
+                Text(
+                    text = record.theirCallsign,
+                    fontSize = 14.sp,
+                    fontFamily = FontFamily.Monospace,
+                    color = Color(0xFFFFE082),
+                    maxLines = 1
+                )
+                Text(text = "  ${record.displayMode}", fontSize = 14.sp, maxLines = 1)
+            }
+            when {
+                record.lotwConfirmed -> Text("QSL", fontSize = 12.sp, color = Color(0xFFFFE082), fontFamily = FontFamily.Monospace)
+                record.lotwUploaded -> Text("UP", fontSize = 12.sp, color = Color(0xFFFFE082), fontFamily = FontFamily.Monospace)
+                else -> Text("", fontSize = 12.sp)
+            }
+        }
+    }
+}
+
+@Composable
+private fun PostDialog(
+    text: String,
+    onDismiss: () -> Unit,
+    onCopy: () -> Unit,
+    onShare: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text("通联记录") },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                Text(text, fontSize = 13.sp)
+                Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                    TextButton(onClick = onCopy) { Text("Copy") }
+                    TextButton(onClick = onShare) { Text("Share") }
+                }
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text("Close") } }
+    )
+}
+
+@Composable
+private fun UploadPreviewDialog(
+    preview: com.rtbishop.look4sat.core.domain.repository.LoTWUploadPreview,
+    busy: Boolean,
+    onConfirm: () -> Unit,
+    onDismiss: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text("上传到 LoTW") },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                Text("${preview.callsign}  DXCC ${preview.dxcc}  Grid ${preview.grid}", fontSize = 13.sp)
+                Text("${preview.count} QSO(s) · ${
+                    java.text.SimpleDateFormat("MM-dd HH:mm", java.util.Locale.US).apply {
+                        timeZone = java.util.TimeZone.getTimeZone("UTC")
+                    }.format(java.util.Date(preview.firstUtc.let {
+                        runCatching { java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", java.util.Locale.US).apply {
+                            timeZone = java.util.TimeZone.getTimeZone("UTC")
+                        }.parse(it).time }.getOrDefault(System.currentTimeMillis())
+                    }))
+                } – ${
+                    java.text.SimpleDateFormat("MM-dd HH:mm", java.util.Locale.US).apply {
+                        timeZone = java.util.TimeZone.getTimeZone("UTC")
+                    }.format(java.util.Date(preview.lastUtc.let {
+                        runCatching { java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", java.util.Locale.US).apply {
+                            timeZone = java.util.TimeZone.getTimeZone("UTC")
+                        }.parse(it).time }.getOrDefault(System.currentTimeMillis())
+                    }))
+                }Z", fontSize = 13.sp)
+                if (preview.skipped > 0 || preview.unknownSkipped > 0 || preview.unavailableSkipped > 0) {
+                    val parts = buildList {
+                        if (preview.skipped > 0) add("${preview.skipped} already uploaded/duplicate")
+                        if (preview.unknownSkipped > 0) add("${preview.unknownSkipped} unknown result")
+                        if (preview.unavailableSkipped > 0) add("${preview.unavailableSkipped} un-uploadable")
+                    }
+                    Text(parts.joinToString(" · "), fontSize = 12.sp, color = MaterialTheme.colorScheme.error)
+                }
+                Text(preview.contacts.joinToString("\n") { it }, fontSize = 12.sp, maxLines = 8)
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onConfirm, enabled = !busy) { Text("确认上传") }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text("Cancel") }
+        }
+    )
+}

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

@@ -0,0 +1,215 @@
+/*
+ * 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.radar
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
+import com.rtbishop.look4sat.core.domain.logbook.IQsoRepository
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.QsoStatus
+import com.rtbishop.look4sat.core.domain.logbook.displayMode
+import com.rtbishop.look4sat.core.domain.logbook.frequencyBand
+import com.rtbishop.look4sat.core.domain.repository.ILoTWUploadRepository
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.LoTWOperationException
+import com.rtbishop.look4sat.core.domain.repository.LoTWUploadPreview
+import com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+data class LogUiState(
+    val callsignInput: String = "",
+    /** Current logbook mode for the selected satellite (FM/CW/SSB/FT4). */
+    val selectedMode: String = "",
+    /** Station callsign from the imported LoTW certificate ("" when none). */
+    val certificateCallsign: String = "",
+    /** Primary grid of the LoTW upload station location ("" when none). */
+    val stationGrid: String = "",
+    val preview: LoTWUploadPreview? = null,
+    /** User-facing upload / record message ("" when none). */
+    val message: String = "",
+    val postText: String? = null,
+    val busy: Boolean = false
+)
+
+class LogViewModel(
+    private val qsoRepository: IQsoRepository,
+    private val lotwUploadRepository: ILoTWUploadRepository,
+    private val settingsRepo: ISettingsRepo
+) : ViewModel() {
+
+    val records: Flow<List<QsoRecord>> = qsoRepository.records
+
+    private val _uiState = MutableStateFlow(LogUiState())
+    val uiState: StateFlow<LogUiState> = _uiState
+
+    // Record ids submitted in the most recent prepare → upload cycle, so a
+    // successful POST can mark them "uploaded" (distinct from "confirmed").
+    private var lastUploadedIds: List<Long> = emptyList()
+
+    init {
+        viewModelScope.launch {
+            val cert = lotwUploadRepository.certificate()
+            val station = lotwUploadRepository.station()
+            _uiState.update {
+                it.copy(
+                    certificateCallsign = cert?.callsign.orEmpty(),
+                    stationGrid = station?.grid.orEmpty()
+                )
+            }
+        }
+    }
+
+    fun updateCallsign(value: String) =
+        _uiState.update { it.copy(callsignInput = value.uppercase(Locale.US)) }
+
+    /** Load the per-satellite mode preset when the selected satellite changes. */
+    fun selectSatellite(catnum: Int) {
+        val preset = settingsRepo.getSatelliteMode(catnum)
+        _uiState.update { it.copy(selectedMode = preset) }
+    }
+
+    fun selectMode(catnum: Int, mode: String) {
+        _uiState.update { it.copy(selectedMode = mode) }
+        settingsRepo.setSatelliteMode(catnum, mode)
+    }
+
+    fun record(satName: String, mode: String, txHz: Long?, rxHz: Long?, myGrid: String) {
+        val call = _uiState.value.callsignInput.trim()
+        if (call.isEmpty()) return
+        val normalizedMode = mode.ifBlank { "FM" }.uppercase(Locale.US)
+        val now = System.currentTimeMillis()
+        val record = QsoRecord(
+            startUtcMillis = now,
+            endUtcMillis = now,
+            theirCallsign = call,
+            myCallsign = _uiState.value.certificateCallsign,
+            myGrid = myGrid.take(6).uppercase(Locale.US),
+            txFrequencyHz = txHz,
+            rxFrequencyHz = rxHz,
+            band = frequencyBand(txHz),
+            rxBand = frequencyBand(rxHz),
+            mode = if (normalizedMode == "FT4") "MFSK" else normalizedMode,
+            submode = normalizedMode.takeIf { it == "FT4" }.orEmpty(),
+            satelliteName = satName,
+            satelliteMode = normalizedMode,
+            status = QsoStatus.COMPLETE,
+            propagationMode = "SAT"
+        )
+        viewModelScope.launch { qsoRepository.save(record) }
+        _uiState.update { it.copy(callsignInput = "") }
+    }
+
+    fun delete(id: Long) = viewModelScope.launch { qsoRepository.delete(id) }
+
+    /** English social post from the recorded QSOs of the current satellite (last 24h). */
+    fun generatePost(satName: String, maxElev: Double) {
+        viewModelScope.launch {
+            val now = System.currentTimeMillis()
+            val list = qsoRepository.records.first()
+                .filter { it.satelliteName.trim().equals(satName.trim(), true) }
+                .filter { it.startUtcMillis > now - 24 * 3_600_000L }
+                .sortedBy { it.startUtcMillis }
+            if (list.isEmpty()) return@launch
+            val shortName = satName.substringBefore('(').trim().uppercase(Locale.US)
+            val utc = SimpleDateFormat("yyyyMMdd|HH:mm'Z'", Locale.US).apply {
+                timeZone = TimeZone.getTimeZone("UTC")
+            }
+            val firstLine = "🛰️ $shortName | ${utc.format(Date(list.first().startUtcMillis))}"
+            val elLine = "🔺 EL ${String.format(Locale.US, "%.1f", maxElev)}° | ${list.size} QSOs"
+            val modeLines = list.groupBy { it.displayMode }
+                .map { (mode, qsos) -> "📡 $mode: ${qsos.joinToString(" ") { it.theirCallsign }}" }
+                .joinToString("\n")
+            val currentGrid = settingsRepo.stationPosition.value.qthLocator.take(6)
+            val logLine = "📍 Log: ${_uiState.value.stationGrid.take(4)} | Current: $currentGrid"
+            val viaLine = "via Look4Sat — TNX de ${_uiState.value.certificateCallsign}"
+            val tag = "#HamRadio #SatelliteQSO #" + shortName.filter { it.isLetterOrDigit() }
+            val text = listOf(firstLine, elLine, modeLines, "", logLine, viaLine, tag).joinToString("\n")
+            _uiState.update { it.copy(postText = text) }
+        }
+    }
+
+    fun dismissPost() = _uiState.update { it.copy(postText = null) }
+
+    fun prepareUpload() {
+        if (_uiState.value.busy) return
+        viewModelScope.launch {
+            _uiState.update { it.copy(busy = true, message = "") }
+            try {
+                val all = qsoRepository.records.first()
+                // Only local (non-confirmed) records are candidates for upload;
+                // LoTW-imported confirmations are the feedback side.
+                val pending = all.filter { !it.lotwConfirmed && it.status == QsoStatus.COMPLETE }
+                val audit = lotwUploadRepository.audit(pending)
+                if (audit.pending == 0) {
+                    val msg = when {
+                        audit.unavailable > 0 -> "${audit.unavailable} QSO(s) can't be uploaded (invalid call/date — check the logbook)"
+                        audit.unknown > 0 -> "${audit.unknown} QSO(s) had an unknown upload result — not retried automatically"
+                        else -> "No pending QSOs to upload"
+                    }
+                    _uiState.update { it.copy(busy = false, message = msg) }
+                    return@launch
+                }
+                val preview = lotwUploadRepository.prepare(pending, false)
+                // Only the records that actually made it into the TQ8 may be
+                // marked uploaded later — never the whole candidate list.
+                lastUploadedIds = preview.submittedIds
+                _uiState.update { it.copy(busy = false, preview = preview) }
+            } catch (e: LoTWOperationException) {
+                _uiState.update { it.copy(busy = false, message = "Upload unavailable: ${e.reason}") }
+            } catch (_: Exception) {
+                _uiState.update { it.copy(busy = false, message = "Upload failed") }
+            }
+        }
+    }
+
+    fun confirmUpload() {
+        val preview = _uiState.value.preview ?: return
+        viewModelScope.launch {
+            _uiState.update { it.copy(busy = true) }
+            val result = lotwUploadRepository.upload(preview.id)
+            if (result is LoTWUploadResult.Accepted && lastUploadedIds.isNotEmpty()) {
+                // Mark the submitted QSOs as uploaded (distinct from confirmed).
+                qsoRepository.markUploaded(lastUploadedIds)
+                lastUploadedIds = emptyList()
+            }
+            val msg = when (result) {
+                is LoTWUploadResult.Accepted -> "Uploaded ${result.count} QSO(s) — accepted by LoTW"
+                is LoTWUploadResult.Rejected -> "Rejected: ${result.message}"
+                LoTWUploadResult.Unknown -> "Unknown result — will not auto-retry"
+                LoTWUploadResult.ExpiredPreview -> "Preview expired — tap upload again"
+            }
+            _uiState.update { it.copy(busy = false, preview = null, message = msg) }
+        }
+    }
+
+    fun dismissPreview() = _uiState.update { it.copy(preview = null) }
+
+    fun clearMessage() = _uiState.update { it.copy(message = "") }
+
+    companion object {
+        fun factory(container: IMainContainer) = viewModelFactory {
+            initializer {
+                LogViewModel(container.qsoRepository, container.lotwUploadRepository, container.settingsRepo)
+            }
+        }
+    }
+}

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

@@ -30,12 +30,14 @@ import androidx.compose.animation.core.tween
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 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.navigationBars
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.pager.HorizontalPager
@@ -74,7 +76,6 @@ import com.rtbishop.look4sat.core.presentation.TimerRow
 import com.rtbishop.look4sat.core.presentation.TopBar
 import com.rtbishop.look4sat.core.presentation.formatFrequency
 import com.rtbishop.look4sat.core.presentation.getDefaultPass
-import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import com.rtbishop.look4sat.core.presentation.layoutPadding
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.delay
@@ -83,14 +84,19 @@ import kotlin.math.PI
 private enum class RadarPage(val title: String) {
     Transceivers("Transceivers"),
     Calculator("Calculator"),
+    Log("Log"),
     Sstv("SSTV")
 }
 
+/** Compact pager strip height in split-screen / small windows. */
+private val COMPACT_PAGER_HEIGHT = 132.dp
+
 @Composable
 fun RadarDestination(navigateUp: () -> Unit) {
     val context = LocalContext.current
     val container = (context.applicationContext as IContainerProvider).getMainContainer()
     val viewModel: RadarViewModel = viewModel(factory = RadarViewModel.factory(container))
+    val logViewModel: LogViewModel = viewModel(factory = LogViewModel.factory(container))
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
     val mutualData by container.mutualPassData.collectAsStateWithLifecycle()
     val navigateUpAndClearMutual = {
@@ -127,7 +133,7 @@ fun RadarDestination(navigateUp: () -> Unit) {
         viewModel.onAction(RadarAction.SstvPermissionResult(granted))
         viewModel.onAction(RadarAction.CwPermissionResult(granted))
     }
-    RadarScreen(uiState, viewModel::onAction, navigateUpAndClearMutual, mutualData, requestMicPermission = {
+    RadarScreen(uiState, viewModel::onAction, navigateUpAndClearMutual, mutualData, logViewModel, requestMicPermission = {
         permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
     })
 }
@@ -138,6 +144,7 @@ private fun RadarScreen(
     onAction: (RadarAction) -> Unit,
     navigateUp: () -> Unit,
     mutualData: MutualPassData,
+    logViewModel: LogViewModel,
     requestMicPermission: () -> Unit
 ) {
     val upcomingPass = uiState.currentPass ?: getDefaultPass()
@@ -169,36 +176,54 @@ private fun RadarScreen(
                 time = it.time
             )
         }
-    Column(
+    BoxWithConstraints(
         modifier = Modifier
             .layoutPadding()
             .padding(bottom = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding())
-            .keepScreenOn(),
-        verticalArrangement = Arrangement.spacedBy(6.dp)
+            .keepScreenOn()
     ) {
-        val isVertical = isVerticalLayout()
-        if (isVertical) {
-            TopBar {
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
+        // Measure the ACTUAL window constraints instead of the window size
+        // class: currentWindowAdaptiveInfo() often reports the full-screen
+        // size in split-screen / multi-window, so the compact branch never
+        // triggered there. maxHeight/maxWidth are the real window bounds.
+        val isVertical = maxWidth < 600.dp
+        // In split-screen / small windows the vertical space is scarce: let the
+        // radar card fill ALL remaining space so the square plot is as large as
+        // possible, and give the pager a compact fixed strip — its pages are all
+        // scrollable, so nothing gets clipped. Full-screen layouts keep the 1:1 split.
+        val compact = isVertical && maxHeight < 480.dp
+        Column(
+            modifier = Modifier.fillMaxSize(),
+            verticalArrangement = Arrangement.spacedBy(6.dp)
+        ) {
+            if (isVertical) {
+                TopBar {
+                    IconCard(action = navigateUp, resId = R.drawable.ic_back)
+                    TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
+                    IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
+                }
+                TopBar { NextPassRow(pass = upcomingPass, isUtc = uiState.isUtc) }
+            } else {
+                TopBar {
+                    IconCard(action = navigateUp, resId = R.drawable.ic_back)
+                    TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
+                    NextPassRow(pass = upcomingPass, modifier = Modifier.weight(1f), isUtc = uiState.isUtc)
+                    IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
+                }
             }
-            TopBar { NextPassRow(pass = upcomingPass, isUtc = uiState.isUtc) }
-        } else {
-            TopBar {
-                IconCard(action = navigateUp, resId = R.drawable.ic_back)
-                TimerRow(timeString = uiState.currentTime, isTimeAos = uiState.isTimeAos)
-                NextPassRow(pass = upcomingPass, modifier = Modifier.weight(1f), isUtc = uiState.isUtc)
-                IconCard(action = addToCalendar, resId = R.drawable.ic_calendar)
-            }
-        }
-        if (isVertical) {
-            RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
-            PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
-        } else {
-            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
-                PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
+            if (isVertical) {
+                if (compact) {
+                    RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
+                    PagerCard(uiState, onAction, logViewModel, requestMicPermission, Modifier.height(COMPACT_PAGER_HEIGHT))
+                } else {
+                    RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
+                    PagerCard(uiState, onAction, logViewModel, requestMicPermission, Modifier.weight(1f))
+                }
+            } else {
+                Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                    RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
+                    PagerCard(uiState, onAction, logViewModel, requestMicPermission, Modifier.weight(1f))
+                }
             }
         }
     }
@@ -208,6 +233,7 @@ private fun RadarScreen(
 private fun PagerCard(
     uiState: RadarState,
     onAction: (RadarAction) -> Unit,
+    logViewModel: LogViewModel,
     requestMicPermission: () -> Unit,
     modifier: Modifier = Modifier
 ) {
@@ -218,6 +244,7 @@ private fun PagerCard(
         buildList {
             add(RadarPage.Transceivers)
             if (hasCalculatorPage) add(RadarPage.Calculator)
+            add(RadarPage.Log)
             add(RadarPage.Sstv)
         }
     }
@@ -261,6 +288,10 @@ private fun PagerCard(
                         onAction = onAction,
                         requestMicPermission = requestMicPermission
                     )
+                    RadarPage.Log -> LogPage(
+                        uiState = uiState,
+                        logViewModel = logViewModel
+                    )
                     RadarPage.Sstv -> SstvPage(
                         sstv = uiState.sstv,
                         dopplerFrequency = uiState.transceivers.selectedFrequency?.let { formatFrequency(it) },

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

@@ -70,7 +70,11 @@ data class RadarState(
     val mutualMaxElev: Double = 10.0,
     val mutualLabelA: String = "你",
     val mutualLabelB: String = "友台",
-    val calculatorOffsetKHz: String = ""
+    val calculatorOffsetKHz: String = "",
+    /** Current calculator TX/RX frequencies (linear transponder), synced from the
+     *  Calculator tab so the Log tab records at the same frequencies. */
+    val calculatorTxHz: Long? = null,
+    val calculatorRxHz: Long? = null
 )
 
 enum class SstvStatus { Idle, Recording }
@@ -128,4 +132,5 @@ sealed interface RadarAction {
 
     // Calculator actions
     data class ChangeCalculatorOffset(val offsetKHz: String) : RadarAction
+    data class UpdateCalculatorFrequency(val txHz: Long?, val rxHz: Long?) : RadarAction
 }

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

@@ -327,6 +327,12 @@ class RadarViewModel(
                 }
                 _uiState.update { it.copy(calculatorOffsetKHz = action.offsetKHz) }
             }
+            is RadarAction.UpdateCalculatorFrequency -> {
+                _uiState.update {
+                    if (it.calculatorTxHz == action.txHz && it.calculatorRxHz == action.rxHz) it
+                    else it.copy(calculatorTxHz = action.txHz, calculatorRxHz = action.rxHz)
+                }
+            }
         }
     }
 

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

@@ -66,6 +66,7 @@ import androidx.compose.material3.CardDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -215,6 +216,7 @@ fun CalculatorPage(
             orbitalPos = orbitalPos,
             offsetKHz = calculatorOffsetKHz,
             onOffsetChange = { onAction(RadarAction.ChangeCalculatorOffset(it)) },
+            onFrequencyChange = { tx, rx -> onAction(RadarAction.UpdateCalculatorFrequency(tx, rx)) },
             modifier = Modifier.fillMaxWidth()
         )
 
@@ -569,6 +571,7 @@ private fun DopplerFrequencyCalculator(
     orbitalPos: OrbitalPos?,
     offsetKHz: String = "",
     onOffsetChange: (String) -> Unit = {},
+    onFrequencyChange: (Long, Long) -> Unit = { _, _ -> },
     modifier: Modifier = Modifier
 ) {
     if (orbitalPos == null || !DopplerFrequencyCalculator.isLinearTransponder(transponder)) return
@@ -579,6 +582,12 @@ private fun DopplerFrequencyCalculator(
     var passbandPosition by rememberSaveable(transponder.uuid) { mutableStateOf(0.5f) }
     var stepSizeKHz by remember { mutableIntStateOf(1) }
 
+    // Sync the calculator's current frequencies upward after every recomposition,
+    // so the Log tab records at the same TX/RX the operator is listening on.
+    SideEffect {
+        if (txFrequencyHz != 0L && rxFrequencyHz != 0L) onFrequencyChange(txFrequencyHz, rxFrequencyHz)
+    }
+
     val offsetHz = offsetKHz.toDoubleOrNull()?.let { it * 1000 }?.toLong() ?: 0L
 
     val txLow = transponder.uplinkLow ?: return

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

@@ -42,6 +42,7 @@ import androidx.compose.ui.unit.dp
 import com.rtbishop.look4sat.core.presentation.MainTheme
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.SharedDialog
+import com.rtbishop.look4sat.core.domain.source.Sources
 
 @Preview(showBackground = true)
 @Composable
@@ -54,9 +55,20 @@ private fun MultiTypesDialogPreview() {
 internal fun MultiTypesDialog(
     allTypes: List<String>, types: List<String>, cancel: () -> Unit, accept: (List<String>) -> Unit
 ) {
+    // 虚拟类型(转发器/活动筛选)与普通 TLE 源类型互斥: 勾虚拟类型时取消普通类型,
+    // 勾普通类型时取消虚拟类型. 虚拟类型之间可多选组合.
+    val virtualTypes = Sources.virtualTypeNames
     val selected = remember { mutableStateOf(types.toSet()) }
     val toggle = { type: String ->
-        selected.value = if (type in selected.value) selected.value - type else selected.value + type
+        selected.value = if (type in selected.value) {
+            selected.value - type
+        } else if (type in virtualTypes) {
+            // 勾选虚拟类型: 移除所有普通类型, 保留已勾的虚拟类型.
+            (selected.value.filterTo(mutableSetOf()) { it in virtualTypes }) + type
+        } else {
+            // 勾选普通类型: 移除所有虚拟类型, 保留已勾的普通类型.
+            (selected.value.filterTo(mutableSetOf()) { it !in virtualTypes }) + type
+        }
     }
     val onAccept = { accept(selected.value.toList()) }
     SharedDialog(title = stringResource(R.string.sat_type_title), onCancel = cancel, onAccept = onAccept) {

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

@@ -177,6 +177,7 @@ private fun SatellitesScreen(
                 )
             }
         }
+        // 转发器/活动筛选已在"卫星类型"对话框前三个选项中体现(AMSAT Live FM/Linear, Live SSTV).
         ElevatedCard(modifier = Modifier.fillMaxSize()) {
             val emptyMessage = stringResource(R.string.sat_empty_list_message)
             when {

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

@@ -0,0 +1,326 @@
+/*
+ * 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.settings
+
+import android.net.Uri
+import android.provider.OpenableColumns
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+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.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.domain.repository.LoTWCertificate
+import com.rtbishop.look4sat.core.domain.repository.LoTWStation
+import com.rtbishop.look4sat.core.domain.repository.LoTWStationMeta
+import com.rtbishop.look4sat.core.presentation.CardButton
+import com.rtbishop.look4sat.core.presentation.LocalSpacing
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+
+@Composable
+fun LoTWUploadCard(
+    hasCertificate: Boolean,
+    stationGrid: String,
+    showUploadConfigDialog: () -> Unit
+) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth().clickable { showUploadConfigDialog() }) {
+        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
+            Text(
+                text = stringResource(R.string.prefs_lotw_upload_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(
+                text = if (hasCertificate) {
+                    stringResource(R.string.prefs_lotw_upload_configured, stationGrid)
+                } else {
+                    stringResource(R.string.prefs_lotw_upload_not_configured)
+                },
+                style = MaterialTheme.typography.bodySmall,
+                maxLines = 2
+            )
+        }
+    }
+}
+
+@Composable
+fun LoTWUploadConfigDialog(
+    certificate: LoTWCertificate?,
+    station: LoTWStation?,
+    stationMeta: LoTWStationMeta?,
+    busy: Boolean,
+    error: LoTWUploadError?,
+    errorDetail: String = "",
+    onDismiss: () -> Unit,
+    onImport: (ByteArray, CharArray) -> Unit,
+    onRemove: () -> Unit,
+    onSaveStation: (LoTWStation) -> Unit
+) {
+    var password by remember { mutableStateOf("") }
+    var selectedFile by remember { mutableStateOf<Uri?>(null) }
+    var grid by remember { mutableStateOf(station?.grid.orEmpty()) }
+    var cqZone by remember { mutableStateOf(station?.cqZone.orEmpty()) }
+    var ituZone by remember { mutableStateOf(station?.ituZone.orEmpty()) }
+    var iota by remember { mutableStateOf(station?.iota.orEmpty()) }
+    var region by remember { mutableStateOf(station?.region.orEmpty()) }
+    // Countries whose national zonemap has exactly one pair (e.g. Germany, India) get
+    // their CQZ/ITUZ prefilled; multi-zone countries are left blank to avoid a wrong
+    // default that would mislead (e.g. Guangdong would show the Heilongjiang zone).
+    LaunchedEffect(stationMeta) {
+        val meta = stationMeta ?: return@LaunchedEffect
+        val zones = meta.countryZones
+        if (zones.size == 1 && cqZone.isBlank() && ituZone.isBlank()) {
+            cqZone = zones[0].cq.toString()
+            ituZone = zones[0].itu.toString()
+        }
+        // A region saved under a previous certificate (different DXCC) no longer
+        // applies — clear it so saving doesn't fail validation.
+        val metaRegion = meta.regionField
+        if (metaRegion != null && region.isNotBlank() && metaRegion.options.none { it.code == region }) {
+            region = ""
+        }
+    }
+    val regionField = stationMeta?.regionField
+    val selectedRegionName = regionField?.options?.firstOrNull { it.code == region }?.name.orEmpty()
+    val context = LocalContext.current
+
+    // Pick the file first, then ask for the password — matches normal usage.
+    val filePicker = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocument()) { uri ->
+        if (uri != null) selectedFile = uri
+    }
+
+    fun displayName(uri: Uri): String = runCatching {
+        context.contentResolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)?.use { cursor ->
+            if (cursor.moveToFirst()) cursor.getString(0) else null
+        }
+    }.getOrNull() ?: uri.lastPathSegment.orEmpty()
+
+    SharedDialog(
+        title = stringResource(R.string.prefs_lotw_upload_title),
+        onDismissRequest = onDismiss,
+        onCancel = onDismiss,
+        onAccept = null
+    ) {
+        Column(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+            verticalArrangement = Arrangement.spacedBy(6.dp)
+        ) {
+            if (busy) {
+                Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    CircularProgressIndicator(modifier = Modifier.height(20.dp), strokeWidth = 2.dp)
+                    Text(stringResource(R.string.prefs_lotw_upload_busy), fontSize = 13.sp)
+                }
+            }
+            if (certificate == null) {
+            Text(stringResource(R.string.prefs_lotw_upload_cert_hint), fontSize = 13.sp)
+            CardButton(
+                onClick = { filePicker.launch(arrayOf("*/*")) },
+                text = stringResource(R.string.prefs_lotw_upload_import),
+                isEnabled = !busy,
+                modifier = Modifier.fillMaxWidth()
+            )
+            error?.let {
+                Text(
+                    text = when {
+                        it == LoTWUploadError.FORMAT && errorDetail.isNotBlank() ->
+                            stringResource(R.string.prefs_lotw_upload_error_format_alg, errorDetail)
+                        it == LoTWUploadError.FORMAT -> stringResource(R.string.prefs_lotw_upload_error_format)
+                        else -> stringResource(
+                            when (it) {
+                                LoTWUploadError.PASSWORD -> R.string.prefs_lotw_upload_error_password
+                                LoTWUploadError.EXPIRED -> R.string.prefs_lotw_upload_error_expired
+                                LoTWUploadError.INVALID_FILE -> R.string.prefs_lotw_upload_error_invalid
+                                LoTWUploadError.UNKNOWN -> R.string.prefs_lotw_upload_error_unknown
+                                LoTWUploadError.FORMAT -> R.string.prefs_lotw_upload_error_format
+                            }
+                        )
+                    },
+                    color = MaterialTheme.colorScheme.error,
+                    fontSize = 12.sp
+                )
+            }
+            selectedFile?.let { uri ->
+                Text(
+                    text = displayName(uri),
+                    fontSize = 12.sp,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = MaterialTheme.colorScheme.primary
+                )
+                OutlinedTextField(
+                    value = password,
+                    onValueChange = { password = it },
+                    label = { Text(stringResource(R.string.prefs_lotw_upload_password), fontSize = 13.sp) },
+                    singleLine = true,
+                    visualTransformation = PasswordVisualTransformation(),
+                    modifier = Modifier.fillMaxWidth()
+                )
+                CardButton(
+                    onClick = {
+                        val bytes = runCatching {
+                            context.contentResolver.openInputStream(uri)?.use { it.readBytes() }
+                        }.getOrNull()
+                        if (bytes != null && bytes.isNotEmpty()) {
+                            onImport(bytes, password.toCharArray())
+                            password = ""
+                            selectedFile = null
+                        }
+                    },
+                    text = stringResource(R.string.prefs_lotw_upload_import_confirm),
+                    isEnabled = password.isNotBlank() && !busy,
+                    modifier = Modifier.fillMaxWidth()
+                )
+            }
+        } else {
+            Text(stringResource(R.string.prefs_lotw_upload_cert_info, certificate.callsign, certificate.dxcc, certificate.expires), fontSize = 13.sp)
+            OutlinedButton(onClick = onRemove, enabled = !busy) {
+                Text(stringResource(R.string.prefs_lotw_upload_remove), fontSize = 13.sp)
+            }
+        }
+        Text(stringResource(R.string.prefs_lotw_upload_station_title), style = MaterialTheme.typography.titleSmall)
+        // Grid field accepts a comma-separated multi-grid set (e.g. "OL62,OL72").
+        OutlinedTextField(
+            value = grid,
+            onValueChange = { grid = it.uppercase() },
+            label = { Text(stringResource(R.string.prefs_lotw_upload_grid), fontSize = 13.sp) },
+            singleLine = true,
+            keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(capitalization = KeyboardCapitalization.Characters),
+            modifier = Modifier.fillMaxWidth()
+        )
+        // Country-specific region field (US_STATE, CN_PROVINCE, …) shown only when
+        // the certificate's DXCC entity defines one; selecting it fills CQZ/ITUZ.
+        // Drawn as a plain Box (not OutlinedTextField): a read-only text field's
+        // internal gesture handler consumes the tap, so clickable never fires.
+        // Options expand inline inside the sheet (no Popup/Dialog window stacking).
+        if (regionField != null) {
+            var regionExpanded by remember { mutableStateOf(false) }
+            val fieldShape = MaterialTheme.shapes.extraSmall
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .clip(fieldShape)
+                    .background(MaterialTheme.colorScheme.surface)
+                    .border(1.dp, MaterialTheme.colorScheme.outline, fieldShape)
+                    .clickable { regionExpanded = !regionExpanded }
+                    .padding(horizontal = 12.dp, vertical = 8.dp)
+            ) {
+                Column {
+                    Text(regionField.label, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    Spacer(modifier = Modifier.height(3.dp))
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        Text(
+                            text = if (region.isBlank()) {
+                                stringResource(R.string.prefs_lotw_upload_region_hint)
+                            } else {
+                                "$region — $selectedRegionName"
+                            },
+                            fontSize = 16.sp,
+                            color = if (region.isBlank()) {
+                                MaterialTheme.colorScheme.onSurfaceVariant
+                            } else {
+                                MaterialTheme.colorScheme.onSurface
+                            },
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                            modifier = Modifier.weight(1f)
+                        )
+                        Text(
+                            text = if (regionExpanded) "▴" else "▾",
+                            fontSize = 14.sp,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+            }
+            AnimatedVisibility(visible = regionExpanded) {
+                LazyColumn(modifier = Modifier.fillMaxWidth().heightIn(max = 280.dp)) {
+                    items(regionField.options, key = { it.code }) { option ->
+                        DropdownMenuItem(
+                            text = { Text("${option.code} — ${option.name}", fontSize = 13.sp) },
+                            onClick = {
+                                region = option.code
+                                regionExpanded = false
+                                option.zones.firstOrNull()?.let { zone ->
+                                    cqZone = zone.cq.toString()
+                                    ituZone = zone.itu.toString()
+                                }
+                            }
+                        )
+                    }
+                }
+            }
+        }
+        Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+            OutlinedTextField(
+                value = cqZone,
+                onValueChange = { cqZone = it },
+                label = { Text("CQZ", fontSize = 12.sp) },
+                singleLine = true,
+                modifier = Modifier.weight(1f)
+            )
+            OutlinedTextField(
+                value = ituZone,
+                onValueChange = { ituZone = it },
+                label = { Text("ITUZ", fontSize = 12.sp) },
+                singleLine = true,
+                modifier = Modifier.weight(1f)
+            )
+            OutlinedTextField(
+                value = iota,
+                onValueChange = { iota = it.uppercase() },
+                label = { Text("IOTA", fontSize = 12.sp) },
+                singleLine = true,
+                modifier = Modifier.weight(1f)
+            )
+        }
+        CardButton(
+            onClick = { onSaveStation(LoTWStation(grid, cqZone, ituZone, region, "", iota)) },
+            text = stringResource(R.string.prefs_lotw_upload_save),
+            isEnabled = grid.isNotBlank() && !busy,
+            modifier = Modifier.fillMaxWidth()
+        )
+        }
+    }
+}

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

@@ -0,0 +1,219 @@
+/*
+ * 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.settings
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.domain.logbook.QsoRecord
+import com.rtbishop.look4sat.core.domain.logbook.displayMode
+import com.rtbishop.look4sat.core.domain.logbook.frequencyBand
+import com.rtbishop.look4sat.core.presentation.LocalSpacing
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+import com.rtbishop.look4sat.core.presentation.SwipeController
+import com.rtbishop.look4sat.core.presentation.SwipeRevealRow
+import com.rtbishop.look4sat.core.presentation.rememberSwipeController
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+@Composable
+fun LogbookCard(recordCount: Int, showLogbookDialog: () -> Unit) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth().clickable { showLogbookDialog() }) {
+        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
+            Text(
+                text = stringResource(R.string.prefs_logbook_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(
+                text = stringResource(R.string.prefs_logbook_count, recordCount),
+                style = MaterialTheme.typography.bodySmall,
+                maxLines = 2
+            )
+        }
+    }
+}
+
+@Composable
+fun LogbookDialog(
+    records: List<QsoRecord>,
+    uploadBusy: Boolean,
+    uploadMessage: String,
+    preview: com.rtbishop.look4sat.core.domain.repository.LoTWUploadPreview?,
+    onDismiss: () -> Unit,
+    onDelete: (Long) -> Unit,
+    onUpload: () -> Unit,
+    onConfirmUpload: () -> Unit,
+    onDismissPreview: () -> Unit,
+    onDismissMessage: () -> Unit
+) {
+    val swipeController = rememberSwipeController()
+    SharedDialog(
+        title = stringResource(R.string.prefs_logbook_title),
+        onDismissRequest = onDismiss,
+        onCancel = onDismiss,
+        onAccept = onUpload,
+        acceptText = stringResource(R.string.prefs_logbook_upload),
+        acceptEnabled = !uploadBusy
+    ) {
+        Column(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+            verticalArrangement = Arrangement.spacedBy(2.dp)
+        ) {
+            if (records.isEmpty()) {
+                Text(stringResource(R.string.prefs_logbook_empty), fontSize = 14.sp)
+            } else {
+                LazyColumn(
+                    modifier = Modifier.fillMaxWidth().heightIn(max = 420.dp),
+                    verticalArrangement = Arrangement.spacedBy(2.dp)
+                ) {
+                    items(records, key = { it.id }) { record ->
+                        LogbookRow(record, swipeController, onDelete = { onDelete(record.id) })
+                    }
+                }
+            }
+        }
+    }
+
+    if (preview != null) {
+        LogbookUploadPreviewDialog(
+            preview = preview,
+            busy = uploadBusy,
+            onConfirm = onConfirmUpload,
+            onDismiss = onDismissPreview
+        )
+    }
+    if (uploadMessage.isNotBlank()) {
+        AlertDialog(
+            onDismissRequest = onDismissMessage,
+            title = { Text("LoTW Upload") },
+            text = { Text(uploadMessage) },
+            confirmButton = {
+                TextButton(onClick = onDismissMessage) { Text("OK") }
+            }
+        )
+    }
+}
+
+@Composable
+private fun LogbookUploadPreviewDialog(
+    preview: com.rtbishop.look4sat.core.domain.repository.LoTWUploadPreview,
+    busy: Boolean,
+    onConfirm: () -> Unit,
+    onDismiss: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.prefs_logbook_upload_title)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                Text("${preview.callsign}  DXCC ${preview.dxcc}  Grid ${preview.grid}", fontSize = 13.sp)
+                Text(
+                    "${preview.count} QSO(s) · ${preview.firstUtc} – ${preview.lastUtc}",
+                    fontSize = 13.sp
+                )
+                if (preview.skipped > 0 || preview.unknownSkipped > 0 || preview.unavailableSkipped > 0) {
+                    val parts = buildList {
+                        if (preview.skipped > 0) add("${preview.skipped} already uploaded/duplicate")
+                        if (preview.unknownSkipped > 0) add("${preview.unknownSkipped} unknown result")
+                        if (preview.unavailableSkipped > 0) add("${preview.unavailableSkipped} un-uploadable")
+                    }
+                    Text(parts.joinToString(" · "), fontSize = 12.sp, color = MaterialTheme.colorScheme.error)
+                }
+                Text(preview.contacts.joinToString("\n") { it }, fontSize = 12.sp, maxLines = 8)
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onConfirm, enabled = !busy) {
+                Text(stringResource(R.string.prefs_logbook_upload_confirm))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.btn_cancel)) }
+        }
+    )
+}
+
+@Composable
+private fun LogbookRow(record: QsoRecord, swipeController: SwipeController, onDelete: () -> Unit) {
+    val time = remember(record.startUtcMillis) {
+        SimpleDateFormat("MM-dd HH:mm'Z'", Locale.US).apply {
+            timeZone = TimeZone.getTimeZone("UTC")
+        }.format(Date(record.startUtcMillis))
+    }
+    val satShort = record.satelliteName.substringBefore('(').trim()
+    val band = record.band.ifBlank { frequencyBand(record.txFrequencyHz) }
+    // 右划露出删除按钮（短信式）；整行点击不再删除。
+    SwipeRevealRow(
+        key = record.id.toString(),
+        controller = swipeController,
+        revealAction = onDelete,
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        // Row style mirrors the worked-grid QSO details on the map: callsign in
+        // monospace titleMedium, summary line in bodySmall with " · " separators.
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 4.dp, vertical = 8.dp)
+        ) {
+            Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
+                Text(
+                    text = record.theirCallsign,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontFamily = FontFamily.Monospace,
+                    color = Color(0xFFFFE082),
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    modifier = Modifier.weight(1f)
+                )
+                if (record.lotwConfirmed) {
+                    Text(text = "QSL", fontSize = 13.sp, color = Color(0xFFFFE082), fontFamily = FontFamily.Monospace)
+                } else if (record.lotwUploaded) {
+                    Text(text = "UP", fontSize = 13.sp, color = Color(0xFFFFE082), fontFamily = FontFamily.Monospace)
+                }
+            }
+            Text(
+                text = listOf(satShort, record.displayMode, band, time).filter { it.isNotBlank() }.joinToString(" · "),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                modifier = Modifier.padding(top = 3.dp)
+            )
+        }
+    }
+}

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

@@ -0,0 +1,119 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.feature.settings
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.unit.dp
+import com.rtbishop.look4sat.core.domain.model.MapSource
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.SharedDialog
+
+@Composable
+fun MapSettingsDialog(
+    settings: OtherSettings,
+    onDismiss: () -> Unit,
+    onSave: (mapSource: String, tiandituKey: String) -> Unit
+) {
+    var selectedSource by rememberSaveable {
+        mutableStateOf(MapSource.normalize(settings.mapSource))
+    }
+    var tiandituKey by rememberSaveable { mutableStateOf(settings.tiandituKey) }
+
+    SharedDialog(
+        title = stringResource(R.string.prefs_map_title),
+        onDismissRequest = onDismiss,
+        onCancel = onDismiss,
+        onAccept = { onSave(selectedSource, tiandituKey) }
+    ) { padding ->
+        Column(
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier.padding(horizontal = padding)
+        ) {
+            Text(
+                text = stringResource(R.string.prefs_map_source_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            FlowRow(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                MapSourceChip(
+                    selected = selectedSource == MapSource.OSM,
+                    label = stringResource(R.string.prefs_map_source_osm),
+                    onClick = { selectedSource = MapSource.OSM }
+                )
+                MapSourceChip(
+                    selected = selectedSource == MapSource.TIANDITU_VECTOR,
+                    label = stringResource(R.string.prefs_map_source_tianditu_vector),
+                    onClick = { selectedSource = MapSource.TIANDITU_VECTOR }
+                )
+                MapSourceChip(
+                    selected = selectedSource == MapSource.TIANDITU_IMAGE,
+                    label = stringResource(R.string.prefs_map_source_tianditu_image),
+                    onClick = { selectedSource = MapSource.TIANDITU_IMAGE }
+                )
+            }
+            Text(
+                text = stringResource(R.string.prefs_map_tianditu_key_help),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            OutlinedTextField(
+                value = tiandituKey,
+                onValueChange = { tiandituKey = it },
+                label = { Text(stringResource(R.string.prefs_map_tianditu_key)) },
+                visualTransformation = PasswordVisualTransformation(),
+                keyboardOptions = KeyboardOptions(
+                    keyboardType = KeyboardType.Password,
+                    imeAction = ImeAction.Done
+                ),
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth()
+            )
+            if (selectedSource != MapSource.OSM && tiandituKey.isBlank()) {
+                Text(
+                    text = stringResource(R.string.prefs_map_tianditu_key_required),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.error
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun MapSourceChip(selected: Boolean, label: String, onClick: () -> Unit) {
+    FilterChip(selected = selected, onClick = onClick, label = { Text(label) })
+}

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

@@ -99,6 +99,7 @@ fun SettingsDestination() {
 @Composable
 private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) -> Unit) {
     var showUpdateChecker by rememberSaveable { mutableStateOf(false) }
+    var showMapSettings by rememberSaveable { mutableStateOf(false) }
     if (showUpdateChecker) {
         UpdateCheckerScreen(
             currentVersion = uiState.appVersionName,
@@ -129,6 +130,17 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
         }
     )
 
+    if (showMapSettings) {
+        MapSettingsDialog(
+            settings = uiState.otherSettings,
+            onDismiss = { showMapSettings = false },
+            onSave = { mapSource, tiandituKey ->
+                onAction(SettingsAction.UpdateMapSettings(mapSource, tiandituKey))
+                showMapSettings = false
+            }
+        )
+    }
+
     // Dialogs
     if (dialogs.position) {
         PositionDialog(
@@ -249,6 +261,34 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
             onSyncIncremental = { onAction(SettingsAction.SyncLoTWGrids(it, LoTWSyncMode.Incremental)) }
         )
     }
+    if (dialogs.logbook) {
+        LogbookDialog(
+            records = uiState.logbookRecords,
+            uploadBusy = uiState.logbookUploadBusy,
+            uploadMessage = uiState.logbookUploadMessage,
+            preview = uiState.logbookPreview,
+            onDismiss = { dialogs.logbook = false },
+            onDelete = { onAction(SettingsAction.DeleteLogbookRecord(it)) },
+            onUpload = { onAction(SettingsAction.PrepareLogbookUpload) },
+            onConfirmUpload = { onAction(SettingsAction.ConfirmLogbookUpload) },
+            onDismissPreview = { onAction(SettingsAction.DismissLogbookPreview) },
+            onDismissMessage = { onAction(SettingsAction.ClearLogbookMessage) }
+        )
+    }
+    if (dialogs.lotwUpload) {
+        LoTWUploadConfigDialog(
+            certificate = uiState.lotwCertificate,
+            station = uiState.lotwStation,
+            stationMeta = uiState.lotwStationMeta,
+            busy = uiState.lotwUploadBusy,
+            error = uiState.lotwUploadError,
+            errorDetail = uiState.lotwUploadErrorDetail,
+            onDismiss = { dialogs.lotwUpload = false },
+            onImport = { bytes, password -> onAction(SettingsAction.ImportLoTWCertificate(bytes, password)) },
+            onRemove = { onAction(SettingsAction.RemoveLoTWCertificate) },
+            onSaveStation = { onAction(SettingsAction.SaveLoTWStation(it)) }
+        )
+    }
 
     // URLs for top bar
     val uriHandler = LocalUriHandler.current
@@ -353,6 +393,19 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
                     onRadioControlClick = { dialogs.radioControl = true }
                 )
             }
+            item {
+                LogbookCard(
+                    recordCount = uiState.logbookRecords.size,
+                    showLogbookDialog = { dialogs.logbook = true }
+                )
+            }
+            item {
+                LoTWUploadCard(
+                    hasCertificate = uiState.lotwCertificate != null,
+                    stationGrid = uiState.lotwStation?.grid.orEmpty(),
+                    showUploadConfigDialog = { onAction(SettingsAction.LoadLoTWUploadStatus); dialogs.lotwUpload = true }
+                )
+            }
             item {
                 LoTWCard(
                     settings = uiState.lotwSettings,
@@ -368,6 +421,7 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
                     onAction = onAction
                 )
             }
+            item { MapSettingsCard(onClick = { showMapSettings = true }) }
             item { CardCredits() }
             item(span = { GridItemSpan(maxLineSpan) }) {
                 CardButton(
@@ -558,6 +612,24 @@ private fun OtherCardPreview() = MainTheme {
     OtherCard(settings = values, onCompassCalibration = {}, onAction = {})
 }
 
+@Composable
+private fun MapSettingsCard(onClick: () -> Unit) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 6.dp)) {
+            Text(
+                text = stringResource(R.string.prefs_map_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(6.dp))
+            CardButton(
+                onClick = onClick,
+                text = stringResource(R.string.prefs_map_configure),
+                modifier = Modifier.fillMaxWidth()
+            )
+        }
+    }
+}
+
 @Composable
 private fun OtherCard(
     settings: OtherSettings,
@@ -864,6 +936,8 @@ private class DialogVisibility {
     var wavelog by mutableStateOf(false)
     var lotw by mutableStateOf(false)
     var compassCalibration by mutableStateOf(false)
+    var logbook by mutableStateOf(false)
+    var lotwUpload by mutableStateOf(false)
 }
 
 @Composable
@@ -871,7 +945,7 @@ private fun rememberDialogVisibility(): DialogVisibility {
     return rememberSaveable(saver = run {
         androidx.compose.runtime.saveable.Saver(
             save = {
-                listOf(it.position, it.locator, it.dataSources, it.network, it.bluetooth, it.radioControl, it.wavelog, it.lotw, it.compassCalibration)
+                listOf(it.position, it.locator, it.dataSources, it.network, it.bluetooth, it.radioControl, it.wavelog, it.lotw, it.compassCalibration, it.logbook, it.lotwUpload)
             },
             restore = {
                 DialogVisibility().apply {
@@ -879,6 +953,8 @@ private fun rememberDialogVisibility(): DialogVisibility {
                     network = it[3]; bluetooth = it[4]; radioControl = it[5]; wavelog = it[6]
                     lotw = it.getOrElse(7) { false }
                     compassCalibration = it.getOrElse(8) { false }
+                    logbook = it.getOrElse(9) { false }
+                    lotwUpload = it.getOrElse(10) { false }
                 }
             }
         )

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

@@ -68,6 +68,24 @@ data class SettingsState(
     val lotwError: LoTWError? = null,
     /** Epoch ms of the last successful LoTW sync (0 = never) — shown like the ephemeris update time. */
     val lotwLastSyncEpochMs: Long = 0L,
+    /** Logbook (QSO records + LoTW confirmations), newest first. */
+    val logbookRecords: List<com.rtbishop.look4sat.core.domain.logbook.QsoRecord> = emptyList(),
+    /** Imported LoTW upload certificate (null when none). */
+    val lotwCertificate: com.rtbishop.look4sat.core.domain.repository.LoTWCertificate? = null,
+    /** LoTW upload station location (null when unset). */
+    val lotwStation: com.rtbishop.look4sat.core.domain.repository.LoTWStation? = null,
+    /** Region-field options and national zonemap for the certificate's DXCC entity. */
+    val lotwStationMeta: com.rtbishop.look4sat.core.domain.repository.LoTWStationMeta? = null,
+    val lotwUploadBusy: Boolean = false,
+    /** Last certificate import outcome; shown inside the upload config dialog. */
+    val lotwUploadError: LoTWUploadError? = null,
+    /** Parser detail for FORMAT errors (e.g. the unsupported algorithm name). */
+    val lotwUploadErrorDetail: String = "",
+    /** One-click logbook upload: prepared preview awaiting confirmation. */
+    val logbookPreview: com.rtbishop.look4sat.core.domain.repository.LoTWUploadPreview? = null,
+    val logbookUploadBusy: Boolean = false,
+    /** User-facing upload message shown inside the logbook dialog ("" = none). */
+    val logbookUploadMessage: String = "",
     /** 指南针校准精度等级 (校准对话框进度条). */
     val compassAccuracy: CompassAccuracy = CompassAccuracy.UNRELIABLE,
     /** 校正后航向(度, 含磁偏角+手动偏置), 校准对话框实时显示. */
@@ -84,6 +102,8 @@ sealed interface LoTWError {
     data class Network(val detail: String) : LoTWError
 }
 
+enum class LoTWUploadError { PASSWORD, INVALID_FILE, EXPIRED, FORMAT, UNKNOWN }
+
 sealed interface SettingsAction {
     // Position
     data object SetGpsPosition : SettingsAction
@@ -108,6 +128,7 @@ sealed interface SettingsAction {
     data class SetCompassOffset(val degrees: Float) : SettingsAction
     data class ToggleLightTheme(val value: Boolean) : SettingsAction
     data class ToggleNightMode(val value: Boolean) : SettingsAction
+    data class UpdateMapSettings(val mapSource: String, val tiandituKey: String) : SettingsAction
 
     // Remote control
     data class UpdateRC(val settings: RCSettings) : SettingsAction
@@ -129,6 +150,20 @@ sealed interface SettingsAction {
     /** Abort an in-flight LoTW sync (wrong button / changed mind). */
     data object CancelLoTWSync : SettingsAction
 
+    // Logbook (QSO records + LoTW confirmations)
+    data object RefreshLogbook : SettingsAction
+    data class DeleteLogbookRecord(val id: Long) : SettingsAction
+    data object PrepareLogbookUpload : SettingsAction
+    data object ConfirmLogbookUpload : SettingsAction
+    data object DismissLogbookPreview : SettingsAction
+    data object ClearLogbookMessage : SettingsAction
+
+    // LoTW upload configuration (certificate + station)
+    data object LoadLoTWUploadStatus : SettingsAction
+    data class ImportLoTWCertificate(val bytes: ByteArray, val password: CharArray) : SettingsAction
+    data object RemoveLoTWCertificate : SettingsAction
+    data class SaveLoTWStation(val station: com.rtbishop.look4sat.core.domain.repository.LoTWStation) : SettingsAction
+
     // Update checker
     data object CheckForUpdate : SettingsAction
     data object DownloadUpdate : SettingsAction

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

@@ -37,9 +37,11 @@ import com.rtbishop.look4sat.core.domain.repository.resolveLoTWSyncMode
 import com.rtbishop.look4sat.core.domain.repository.IWavelogRepository
 import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import com.rtbishop.look4sat.core.domain.utility.VersionComparator
+import com.rtbishop.look4sat.core.domain.logbook.toConfirmedRecord
 import com.rtbishop.look4sat.core.presentation.R
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import java.io.File
@@ -50,6 +52,8 @@ class SettingsViewModel(
     private val updateRepo: IUpdateRepository,
     private val wavelogRepo: IWavelogRepository,
     private val lotwRepo: com.rtbishop.look4sat.core.domain.repository.ILoTWRepository,
+    private val qsoRepository: com.rtbishop.look4sat.core.domain.logbook.IQsoRepository,
+    private val lotwUploadRepository: com.rtbishop.look4sat.core.domain.repository.ILoTWUploadRepository,
     private val sensorsRepo: ISensorsRepo,
     private val apkFile: File,
     private val showToast: IShowToast
@@ -154,6 +158,15 @@ class SettingsViewModel(
                 _uiState.update { it.copy(lotwSettings = settings) }
             }
         }
+        viewModelScope.launch {
+            qsoRepository.records.collect { records ->
+                _uiState.update { it.copy(logbookRecords = records) }
+            }
+        }
+        // Load the LoTW upload certificate + station once at startup so the
+        // settings card reflects the real state on first frame (previously it
+        // stayed "not imported" until the config dialog was opened).
+        loadLoTWUploadStatus()
     }
 
 
@@ -186,6 +199,9 @@ class SettingsViewModel(
             }
             is SettingsAction.ToggleLightTheme -> settingsRepo.updateOtherSettings { it.copy(stateOfLightTheme = action.value) }
             is SettingsAction.ToggleNightMode -> settingsRepo.updateOtherSettings { it.copy(stateOfNightMode = action.value) }
+            is SettingsAction.UpdateMapSettings -> settingsRepo.updateOtherSettings {
+                it.copy(mapSource = action.mapSource, tiandituKey = action.tiandituKey)
+            }
             // Remote control & data sources
             is SettingsAction.UpdateRC -> settingsRepo.updateRCSettings(action.settings)
             is SettingsAction.UpdateRadioControl -> settingsRepo.updateRadioControlSettings(action.settings)
@@ -197,6 +213,18 @@ class SettingsViewModel(
             is SettingsAction.UpdateLoTW -> settingsRepo.updateLoTWSettings(action.settings)
             is SettingsAction.SyncLoTWGrids -> syncLoTWGrids(action.settings, action.mode)
             SettingsAction.CancelLoTWSync -> cancelLoTWSync()
+            // Logbook
+            SettingsAction.RefreshLogbook -> refreshLogbook()
+            is SettingsAction.DeleteLogbookRecord -> viewModelScope.launch { qsoRepository.delete(action.id) }
+            SettingsAction.PrepareLogbookUpload -> prepareLogbookUpload()
+            SettingsAction.ConfirmLogbookUpload -> confirmLogbookUpload()
+            SettingsAction.DismissLogbookPreview -> dismissLogbookPreview()
+            SettingsAction.ClearLogbookMessage -> clearLogbookMessage()
+            // LoTW upload configuration
+            SettingsAction.LoadLoTWUploadStatus -> loadLoTWUploadStatus()
+            is SettingsAction.ImportLoTWCertificate -> importLoTWCertificate(action.bytes, action.password)
+            SettingsAction.RemoveLoTWCertificate -> removeLoTWCertificate()
+            is SettingsAction.SaveLoTWStation -> saveLoTWStation(action.station)
             // Update checker
             SettingsAction.CheckForUpdate -> checkForUpdate()
             SettingsAction.DownloadUpdate -> downloadUpdate()
@@ -260,6 +288,13 @@ class SettingsViewModel(
                     // by call + QSO time); full: the fresh report replaces it all.
                     // Shared with the automatic sync on app start (MainApplication).
                     val mergedGridsCount = applyLoTWGridResult(settingsRepo, result, effectiveMode, callsign)
+                    // Feed the logbook: imported confirmations show up in 日志本 and
+                    // match local uploads (sameConfirmedContact) to mark them confirmed.
+                    viewModelScope.launch {
+                        val confirmed = result.qsos.values.flatten()
+                            .map { it.toConfirmedRecord(callsign) }
+                        qsoRepository.mergeLoTW(confirmed)
+                    }
                     _uiState.update { state ->
                         state.copy(
                             lotwSyncing = false, lotwSyncMode = null, lotwProgress = null,
@@ -309,6 +344,124 @@ class SettingsViewModel(
 
     // endregion
 
+    // region Logbook + LoTW upload configuration
+
+    private fun refreshLogbook() {
+        viewModelScope.launch {
+            _uiState.update { it.copy(logbookRecords = qsoRepository.records.first()) }
+        }
+    }
+
+    // Record ids submitted in the most recent logbook prepare → upload cycle, so a
+    // successful POST can mark them "uploaded" (distinct from "confirmed").
+    private var lastLogbookUploadIds: List<Long> = emptyList()
+
+    private fun prepareLogbookUpload() {
+        if (_uiState.value.logbookUploadBusy) return
+        viewModelScope.launch {
+            _uiState.update { it.copy(logbookUploadBusy = true, logbookUploadMessage = "") }
+            try {
+                val all = qsoRepository.records.first()
+                // Only local (non-confirmed) records are candidates for upload;
+                // LoTW-imported confirmations are the feedback side.
+                val pending = all.filter { !it.lotwConfirmed && it.status == com.rtbishop.look4sat.core.domain.logbook.QsoStatus.COMPLETE }
+                val audit = lotwUploadRepository.audit(pending)
+                if (audit.pending == 0) {
+                    val msg = when {
+                        audit.unavailable > 0 -> "${audit.unavailable} QSO(s) can't be uploaded (invalid call/date — check the logbook)"
+                        audit.unknown > 0 -> "${audit.unknown} QSO(s) had an unknown upload result — not retried automatically"
+                        else -> "No pending QSOs to upload"
+                    }
+                    _uiState.update { it.copy(logbookUploadBusy = false, logbookUploadMessage = msg) }
+                    return@launch
+                }
+                val preview = lotwUploadRepository.prepare(pending, false)
+                // Only the records that actually made it into the TQ8 may be
+                // marked uploaded later — never the whole candidate list.
+                lastLogbookUploadIds = preview.submittedIds
+                _uiState.update { it.copy(logbookUploadBusy = false, logbookPreview = preview) }
+            } catch (e: com.rtbishop.look4sat.core.domain.repository.LoTWOperationException) {
+                _uiState.update { it.copy(logbookUploadBusy = false, logbookUploadMessage = "Upload unavailable: ${e.reason}") }
+            } catch (_: Exception) {
+                _uiState.update { it.copy(logbookUploadBusy = false, logbookUploadMessage = "Upload failed") }
+            }
+        }
+    }
+
+    private fun confirmLogbookUpload() {
+        val preview = _uiState.value.logbookPreview ?: return
+        viewModelScope.launch {
+            _uiState.update { it.copy(logbookUploadBusy = true) }
+            val result = lotwUploadRepository.upload(preview.id)
+            if (result is com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult.Accepted && lastLogbookUploadIds.isNotEmpty()) {
+                qsoRepository.markUploaded(lastLogbookUploadIds)
+                lastLogbookUploadIds = emptyList()
+            }
+            val msg = when (result) {
+                is com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult.Accepted -> "Uploaded ${result.count} QSO(s) — accepted by LoTW"
+                is com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult.Rejected -> "Rejected: ${result.message}"
+                com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult.Unknown -> "Unknown result — will not auto-retry"
+                com.rtbishop.look4sat.core.domain.repository.LoTWUploadResult.ExpiredPreview -> "Preview expired — tap upload again"
+            }
+            _uiState.update { it.copy(logbookUploadBusy = false, logbookPreview = null, logbookUploadMessage = msg) }
+        }
+    }
+
+    private fun dismissLogbookPreview() = _uiState.update { it.copy(logbookPreview = null) }
+
+    private fun clearLogbookMessage() = _uiState.update { it.copy(logbookUploadMessage = "") }
+
+    private fun loadLoTWUploadStatus() {
+        viewModelScope.launch {
+            val cert = lotwUploadRepository.certificate()
+            val station = lotwUploadRepository.station()
+            // Config parsing failure must never crash the dialog — degrade to no meta.
+            val meta = cert?.let { runCatching { lotwUploadRepository.stationMeta(it.dxcc) }.getOrNull() }
+            _uiState.update { it.copy(lotwCertificate = cert, lotwStation = station, lotwStationMeta = meta, lotwUploadBusy = false) }
+        }
+    }
+
+    private fun importLoTWCertificate(bytes: ByteArray, password: CharArray) {
+        viewModelScope.launch {
+            _uiState.update { it.copy(lotwUploadBusy = true, lotwUploadError = null) }
+            try {
+                val cert = lotwUploadRepository.importCertificate(bytes, password)
+                _uiState.update { it.copy(lotwCertificate = cert, lotwUploadBusy = false, lotwUploadError = null) }
+            } catch (e: com.rtbishop.look4sat.core.domain.repository.LoTWOperationException) {
+                val error = when (e.reason) {
+                    com.rtbishop.look4sat.core.domain.repository.LoTWProblem.CERTIFICATE_PASSWORD -> LoTWUploadError.PASSWORD
+                    com.rtbishop.look4sat.core.domain.repository.LoTWProblem.CERTIFICATE_EXPIRED -> LoTWUploadError.EXPIRED
+                    com.rtbishop.look4sat.core.domain.repository.LoTWProblem.CERTIFICATE_FORMAT -> LoTWUploadError.FORMAT
+                    else -> LoTWUploadError.INVALID_FILE
+                }
+                _uiState.update { it.copy(lotwUploadBusy = false, lotwUploadError = error, lotwUploadErrorDetail = e.detail) }
+            } catch (_: Exception) {
+                _uiState.update { it.copy(lotwUploadBusy = false, lotwUploadError = LoTWUploadError.UNKNOWN, lotwUploadErrorDetail = "") }
+            }
+        }
+    }
+
+    private fun removeLoTWCertificate() {
+        viewModelScope.launch {
+            lotwUploadRepository.removeCertificate()
+            _uiState.update { it.copy(lotwCertificate = null, lotwStation = null, lotwStationMeta = null) }
+        }
+    }
+
+    private fun saveLoTWStation(station: com.rtbishop.look4sat.core.domain.repository.LoTWStation) {
+        viewModelScope.launch {
+            _uiState.update { it.copy(lotwUploadBusy = true) }
+            try {
+                val saved = lotwUploadRepository.saveStation(station)
+                _uiState.update { it.copy(lotwStation = saved, lotwUploadBusy = false) }
+            } catch (_: Exception) {
+                _uiState.update { it.copy(lotwUploadBusy = false) }
+            }
+        }
+    }
+
+    // endregion
+
     // region Update checker
 
     private fun checkForUpdate() {
@@ -444,6 +597,8 @@ class SettingsViewModel(
                     updateRepo = container.updateRepo,
                     wavelogRepo = container.wavelogRepo,
                     lotwRepo = container.lotwRepo,
+                    qsoRepository = container.qsoRepository,
+                    lotwUploadRepository = container.lotwUploadRepository,
                     sensorsRepo = container.provideSensorsRepo(),
                     apkFile = File(context.cacheDir, "look4sat-update.apk"),
                     showToast = container.provideShowToast()

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
 [versions]
 #noinspection UnusedVersionCatalogEntry
-appVersionCode = "484"
+appVersionCode = "529"
 #noinspection UnusedVersionCatalogEntry
-appVersionName = "4.4.7-ba7opf.11.3"
+appVersionName = "4.4.7-ba7opf.17.6"
 #noinspection UnusedVersionCatalogEntry
 compileSdk = "37"
 #noinspection UnusedVersionCatalogEntry
@@ -33,6 +33,8 @@ other-okhttp = "5.4.0"
 other-osmdroid = "6.1.20"
 
 test-junit4 = "4.13.2"
+robolectric = "4.16"
+androidx-test-core = "1.7.0"
 
 androidTest-junit = "1.3.0"
 androidTest-espresso = "3.7.0"
@@ -79,6 +81,9 @@ other-osmdroid = { module = "org.osmdroid:osmdroid-android", version.ref = "othe
 
 test-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlin-coroutines" }
 test-junit4 = { module = "junit:junit", version.ref = "test-junit4" }
+robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
+androidx-test-core = { module = "androidx.test:core-ktx", version.ref = "androidx-test-core" }
+compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
 # Real org.json for unit tests (android.jar stub throws "not mocked")
 test-json = { module = "org.json:json", version = "20240303" }