chore: bump version to 4.4.6-ba7opf.9.9

LoTW sync: distinguish failure causes (bad credentials / rate limit / timeout / network)
Rate limit classification per ARRL policy (one download in progress per user id; HTTP 503 'Page request limit' observed on throttled pulls) and the HTML login-error page returned for wrong credentials. Settings screen now shows a specific message per cause instead of one generic 'check callsign/password/network'.
2026-10-02 19:17:21 +00:00 · 2026-09-08 04:17:52 +08:00 · 2026-09-08 04:07:03 +08:00 · 2026-09-08 03:44:21 +08:00 · 2026-09-08 03:25:12 +08:00 · 2026-09-08 03:19:40 +08:00
16 changed files with 934 additions and 111 deletions
@@ -18,11 +18,15 @@
 package com.rtbishop.look4sat.core.data.repository

 import com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
+import com.rtbishop.look4sat.core.domain.repository.LoTWResult
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.net.HttpURLConnection
+import java.net.SocketTimeoutException
 import java.net.URL
 import java.net.URLEncoder
+import java.io.IOException
+import javax.net.ssl.SSLException

 /**
 * Fetches confirmed gridsquares directly from ARRL LoTW via the official report endpoint:
@@ -34,57 +38,194 @@ import java.net.URLEncoder
 * value; VUCC_GRIDS ("EN52en,EN53fa") also yields 4-char fields. All values are
 * truncated/expanded to the 4-char form used by the map overlay.
 *
- * ARRL rate-limits the report endpoint (roughly once per hour per account), which is
- * fine for a manual sync button.
+ * ARRL rate-limits the report endpoint: one download in progress per user id, and
+ * frequent full-report pulls get refused. Failures are reported with an explicit
+ * cause (see LoTWResult) so the UI can tell the user what to do next.
 */
 class LoTWRepository : ILoTWRepository {

-    override suspend fun fetchConfirmedGrids(callsign: String, password: String): Set<String>? =
-        withContext(Dispatchers.IO) {
-            val call = callsign.trim().uppercase()
-            val pwd = password.trim()
-            if (call.isBlank() || pwd.isBlank()) return@withContext null
-            // qso_qslsince with an early date forces a FULL confirmed-QSL report.
-            // Without it, LoTW applies a "system supplied default" since-date and
-            // only returns confirmations newer than the account's last query —
-            // subsequent syncs would return an empty/incremental report.
-            val since = "2000-01-01"
-            val query = buildString {
-                append("login=").append(URLEncoder.encode(call, "UTF-8"))
-                append("&password=").append(URLEncoder.encode(pwd, "UTF-8"))
-                append("&qso_query=1&qso_qsl=yes&qso_qsldetail=yes&qso_mydetail=yes")
-                append("&qso_qslsince=").append(URLEncoder.encode(since, "UTF-8"))
-            }
-            try {
-                val connection = URL("$BASE_URL?$query").openConnection() as HttpURLConnection
-                // ARRL can be slow to accept connections from mobile networks
-                // (long TLS handshakes across the Pacific, occasional server-side
-                // queueing). 30s connect + 120s read gives the request enough
-                // headroom; the sync button stays disabled meanwhile so users
-                // see progress rather than a hung dialog.
-                connection.connectTimeout = 30_000
-                connection.readTimeout = 120_000
-                connection.requestMethod = "GET"
-                connection.setRequestProperty("Accept-Encoding", "gzip")
-                connection.instanceFollowRedirects = true
-                val code = connection.responseCode
-                if (code !in 200..299) {
-                    connection.disconnect()
-                    return@withContext null
-                }
-                val stream = connection.inputStream
-                val body = ("gzip".equals(connection.contentEncoding, ignoreCase = true))
-                    .let { gz -> if (gz) java.util.zip.GZIPInputStream(stream) else stream }
-                    .bufferedReader().use { it.readText() }
+    override suspend fun fetchConfirmedGrids(callsign: String, password: String): LoTWResult =
+        fetchReportBody(callsign, password).fold(
+            onSuccess = { body -> parseBoth(body)?.let { LoTWResult.Success(it.first, it.second) }
+                ?: LoTWResult.RateLimited },
+            onFailure = { toResult(it) }
+        )
+
+    override suspend fun fetchConfirmedGridQsos(
+        callsign: String,
+        password: String
+    ): LoTWResult = fetchReportBody(callsign, password).fold(
+        onSuccess = { body -> parseBoth(body)?.let { LoTWResult.Success(it.first, it.second) }
+            ?: LoTWResult.RateLimited },
+        onFailure = { toResult(it) }
+    )
+
+    internal fun toResult(e: Throwable): LoTWResult = when (e) {
+        is CredentialsException -> LoTWResult.BadCredentials
+        is RateLimitException -> LoTWResult.RateLimited
+        is TimeoutException -> LoTWResult.Timeout
+        else -> LoTWResult.NetworkError(e.message ?: e.javaClass.simpleName)
+    }
+
+    /** Single report fetch feeding both the grid set and the per-QSO detail. */
+    private fun parseBoth(body: String): Pair<Set<String>, Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>>? {
+        val grids = parseConfirmedGrids(body) ?: return null
+        val qsos = parseConfirmedGridQsos(body) ?: return null
+        return grids to qsos
+    }
+
+    private fun fetchReportBody(callsign: String, password: String): Result<String> {
+        val call = callsign.trim().uppercase()
+        val pwd = password.trim()
+        if (call.isBlank() || pwd.isBlank()) return Result.failure(IOException("empty credentials"))
+        // qso_qslsince with an early date forces a FULL confirmed-QSL report.
+        // Without it, LoTW applies a "system supplied default" since-date and
+        // only returns confirmations newer than the account's last query —
+        // subsequent syncs would return an empty/incremental report.
+        val since = "2000-01-01"
+        val query = buildString {
+            append("login=").append(URLEncoder.encode(call, "UTF-8"))
+            append("&password=").append(URLEncoder.encode(pwd, "UTF-8"))
+            append("&qso_query=1&qso_qsl=yes&qso_qsldetail=yes&qso_mydetail=yes")
+            append("&qso_qslsince=").append(URLEncoder.encode(since, "UTF-8"))
+        }
+        return try {
+            val connection = URL("$BASE_URL?$query").openConnection() as HttpURLConnection
+            // ARRL can be slow to accept connections from mobile networks
+            // (long TLS handshakes across the Pacific, occasional server-side
+            // queueing). 30s connect + 120s read gives the request enough
+            // headroom; the sync button stays disabled meanwhile so users
+            // see progress rather than a hung dialog.
+            connection.connectTimeout = 30_000
+            connection.readTimeout = 120_000
+            connection.requestMethod = "GET"
+            connection.setRequestProperty("Accept-Encoding", "gzip")
+            connection.instanceFollowRedirects = true
+            val code = connection.responseCode
+            if (code !in 200..299) {
                connection.disconnect()
-                if (body.contains(" password=") && !body.startsWith("ARRL")) return@withContext null
-                parseConfirmedGrids(body)
-            } catch (e: Exception) {
-                println("LoTWRepository fetch failure: $e")
-                null
+                // Observed in the wild (CQRLOG #2422): LoTW answers a throttled
+                // report pull with HTTP 503 "Page request limit".
+                return if (code == 503 || code == 429) Result.failure(RateLimitException())
+                else Result.failure(IOException("HTTP $code"))
+            }
+            val stream = connection.inputStream
+            val body = ("gzip".equals(connection.contentEncoding, ignoreCase = true))
+                .let { gz -> if (gz) java.util.zip.GZIPInputStream(stream) else stream }
+                .bufferedReader().use { it.readText() }
+            connection.disconnect()
+            when {
+                // Login failure: HTTP 200 + HTML login page with the error text.
+                body.contains("incorrect", ignoreCase = true) &&
+                    body.contains("assword", ignoreCase = true) -> Result.failure(CredentialsException())
+                // Any other non-ADIF body: rate-limit refusal / server error page.
+                !body.contains("<eoh>", ignoreCase = true) -> Result.failure(RateLimitException())
+                else -> Result.success(body)
+            }
+        } catch (e: SocketTimeoutException) {
+            Result.failure(TimeoutException(e.message ?: "timed out"))
+        } catch (e: SSLException) {
+            Result.failure(IOException("TLS: ${e.message ?: "handshake failed"}"))
+        } catch (e: Exception) {
+            println("LoTWRepository fetch failure: $e")
+            Result.failure(IOException(e.message ?: e.javaClass.simpleName))
+        }
+    }
+
+    internal class CredentialsException : Exception("bad callsign/password")
+    internal class RateLimitException : Exception("report refused (rate limit / server error)")
+    internal class TimeoutException(message: String) : Exception(message)
+
+    internal fun parseConfirmedGridQsos(
+        body: String
+    ): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>? {
+        if (!body.contains("<eoh>", ignoreCase = true)) return null
+        // One ADIF record = fields up to <EOR>. We buffer the fields we care
+        // about, then emit a GridQso on <EOR> when the record is a satellite
+        // QSO (PROP_MODE=SAT) carrying a grid.
+        val result = mutableMapOf<String, MutableList<com.rtbishop.look4sat.core.domain.model.GridQso>>()
+        var propMode: String? = null
+        var call = ""
+        var qsoDate = ""
+        var timeOn = ""
+        var satName = ""
+        var mode = ""
+        var bandUp = ""
+        var bandDown = ""
+        val gridsInRecord = mutableListOf<String>()
+
+        fun emitRecord() {
+            if (propMode != "SAT" || gridsInRecord.isEmpty()) return
+            val epochMs = adifTimestampToEpoch(qsoDate, timeOn)
+            val qso = com.rtbishop.look4sat.core.domain.model.GridQso(
+                call = call, epochMs = epochMs, satName = satName,
+                mode = mode, bandUp = bandUp, bandDown = bandDown
+            )
+            for (grid in gridsInRecord) {
+                result.getOrPut(grid) { mutableListOf() }.add(qso)
            }
        }

+        fun resetRecord() {
+            propMode = null; call = ""; qsoDate = ""; timeOn = ""
+            satName = ""; mode = ""; bandUp = ""; bandDown = ""
+            gridsInRecord.clear()
+        }
+
+        for (raw in body.lineSequence()) {
+            val line = raw.trim()
+            when {
+                line.equals("<EOR>", ignoreCase = true) -> {
+                    emitRecord()
+                    resetRecord()
+                }
+                line.startsWith("<PROP_MODE:") ->
+                    propMode = adifValue(line).uppercase()
+                line.startsWith("<CALL:") ->
+                    call = adifValue(line).uppercase()
+                line.startsWith("<QSO_DATE:") ->
+                    qsoDate = adifValue(line)
+                line.startsWith("<TIME_ON:") ->
+                    timeOn = adifValue(line)
+                line.startsWith("<SAT_NAME:") ->
+                    satName = adifValue(line)
+                line.startsWith("<MODE:") ->
+                    mode = adifValue(line)
+                line.startsWith("<BAND_RX:") ->
+                    bandUp = adifValue(line).uppercase()
+                line.startsWith("<BAND:") && !line.startsWith("<BAND_RX:") ->
+                    bandDown = adifValue(line).uppercase()
+                line.startsWith("<GRIDSQUARE:") || line.startsWith("<VUCC_GRIDS:") -> {
+                    // VUCC_GRIDS holds a comma-separated list of grids
+                    // ("EN52en,EN53fa"), up to four for contacts spanning
+                    // several squares; split and keep every 4-char field.
+                    adifValue(line).split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) gridsInRecord.add(field.take(4))
+                    }
+                }
+            }
+        }
+        return result
+    }
+
+    /** ADIF field value: "<GRIDSQUARE:4>OL62" -> "OL62". */
+    private fun adifValue(line: String): String =
+        line.substringAfter('>').substringBefore("E<").trim()
+
+    /** "20260820" + "1130" (or "113000") -> UTC epoch ms; 0 when unparseable. */
+    private fun adifTimestampToEpoch(date: String, time: String): Long = try {
+        val d = date.trim()
+        val t = time.trim().padEnd(6, '0').take(6)
+        val fmt = java.time.format.DateTimeFormatterBuilder()
+            .appendPattern("yyyyMMddHHmmss")
+            .toFormatter()
+            .withZone(java.time.ZoneOffset.UTC)
+        java.time.Instant.from(fmt.parse(d + t)).toEpochMilli()
+    } catch (_: Exception) {
+        0L
+    }
+
    internal fun parseConfirmedGrids(body: String): Set<String>? {
        // LoTW answers with ADIF text; on bad credentials it returns a short error page
        // containing "password=?" or an <eoh>-less block. Treat anything without a header
@@ -94,14 +235,33 @@ class LoTWRepository : ILoTWRepository {
        // (LoTW writes it lowercase). Match case-insensitively to be safe.
        if (!body.contains("<eoh>", ignoreCase = true)) return null
        val grids = mutableSetOf<String>()
+        // ADIF fields of one QSO record span multiple lines and are terminated by
+        // <EOR>. Satellite QSOs carry <PROP_MODE:3>SAT (plus <SAT_NAME>); ground
+        // QSOs omit it. Grid fields (GRIDSQUARE / VUCC_GRIDS) must only be
+        // collected for records whose PROP_MODE is SAT, otherwise the map mixes
+        // in terrestrial contacts.
+        var propMode: String? = null
        for (raw in body.lineSequence()) {
            val line = raw.trim()
-            val value = when {
-                line.startsWith("<GRIDSQUARE:") -> line.substringAfter('>')
-                line.startsWith("<VUCC_GRIDS:") -> line.substringAfter('>')
-                else -> continue
-            }.substringBefore("E<").trim().uppercase()
-            if (value.length >= 4) grids.add(value.take(4))
+            when {
+                line.equals("<EOR>", ignoreCase = true) -> propMode = null
+                line.startsWith("<PROP_MODE:") -> {
+                    propMode = line.substringAfter('>').substringBefore("E<").trim().uppercase()
+                }
+                line.startsWith("<GRIDSQUARE:") || line.startsWith("<VUCC_GRIDS:") -> {
+                    if (propMode == "SAT") {
+                        // VUCC_GRIDS holds a comma-separated PAIR of grids
+                        // ("EN52en,EN53fa") for contacts spanning two squares —
+                        // split on ',' and take the 4-char field of each, or the
+                        // second grid is silently dropped.
+                        val value = line.substringAfter('>').substringBefore("E<")
+                        value.split(',').forEach { grid ->
+                            val field = grid.trim().uppercase()
+                            if (field.length >= 4) grids.add(field.take(4))
+                        }
+                    }
+                }
+            }
        }
        return grids
    }
@@ -179,6 +179,57 @@ class SettingsRepo(
        preferences.edit { putString(keyWorkedGrids, array.toString()) }
    }

+    // Confirmed satellite QSOs per worked gridsquare, persisted as a single JSON
+    // object: {"OL62":[{"c":call,"t":epochMs,"s":sat,"m":mode,"bu":up,"bd":down}]}.
+    private val keyWorkedGridQsos = "workedGridQsos"
+
+    override fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> {
+        val json = preferences.getString(keyWorkedGridQsos, 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.GridQso>>()
+            for (grid in root.keys()) {
+                val array = root.optJSONArray(grid) ?: continue
+                val list = (0 until array.length()).mapNotNull { i ->
+                    val o = array.optJSONObject(i) ?: return@mapNotNull null
+                    com.rtbishop.look4sat.core.domain.model.GridQso(
+                        call = o.optString("c"),
+                        epochMs = o.optLong("t"),
+                        satName = o.optString("s"),
+                        mode = o.optString("m"),
+                        bandUp = o.optString("bu"),
+                        bandDown = o.optString("bd")
+                    )
+                }
+                if (list.isNotEmpty()) result[grid] = list
+            }
+            result
+        } catch (_: Exception) {
+            emptyMap()
+        }
+    }
+
+    override fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>) {
+        val root = org.json.JSONObject()
+        for ((grid, list) in qsos) {
+            val array = org.json.JSONArray()
+            for (q in list) {
+                array.put(
+                    org.json.JSONObject()
+                        .put("c", q.call)
+                        .put("t", q.epochMs)
+                        .put("s", q.satName)
+                        .put("m", q.mode)
+                        .put("bu", q.bandUp)
+                        .put("bd", q.bandDown)
+                )
+            }
+            root.put(grid, array)
+        }
+        preferences.edit { putString(keyWorkedGridQsos, root.toString()) }
+    }
+
    // LoTW credentials (stored locally on the device only)
    private val keyLoTWCall = "lotwCallsign"
    private val keyLoTWPass = "lotwPassword"
@@ -19,6 +19,7 @@ package com.rtbishop.look4sat.core.data.repository

 import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
 import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.GridQso
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
@@ -214,7 +215,10 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou
    )

    override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
-        OtherSettings(false, false, false, false, false, false, false, false)
+        OtherSettings(
+            false, false, false, false, false, false, false,
+            shouldSeeWarning = false, shouldSeeWhatsNew = false
+        )
    )

    override val dataSourcesSettings: MutableStateFlow<DataSourcesSettings> = MutableStateFlow(dataSources)
@@ -270,6 +274,28 @@ private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSou
    override fun getAmSatCallsign(): String = ""

    override fun setAmSatCallsign(callsign: String) = Unit
+
+    override val wavelogSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.WavelogSettings> =
+        MutableStateFlow(com.rtbishop.look4sat.core.domain.model.WavelogSettings())
+
+    override fun updateWavelogSettings(settings: com.rtbishop.look4sat.core.domain.model.WavelogSettings) = Unit
+
+    override fun getWorkedGrids(): Set<String> = emptySet()
+
+    private val workedGrids = MutableStateFlow(emptySet<String>())
+
+    override fun setWorkedGrids(grids: Set<String>) {
+        workedGrids.value = grids
+    }
+
+    override val lotwSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings> =
+        MutableStateFlow(com.rtbishop.look4sat.core.domain.model.LoTWSettings())
+
+    override fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) = Unit
+
+    override fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> = emptyMap()
+
+    override fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>) = Unit
 }

 private fun defaultDataSourcesSettings(): DataSourcesSettings {
@@ -0,0 +1,156 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.repository.LoTWResult
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class LoTWRepositoryTest {
+
+    private val repo = LoTWRepository()
+
+    private fun report(vararg records: String): String =
+        buildString {
+            append("<ADIF_VERS:5>3.1.4\n")
+            append("<PROGRAMID:8>look4sat\n")
+            append("<eoh>\n")
+            records.forEach { append(it).append("\n") }
+        }
+
+    @Test
+    fun parseRejectsBodyWithoutEoh() {
+        assertNull(repo.parseConfirmedGrids("<HTML>Username/password incorrect</HTML>"))
+    }
+
+    @Test
+    fun parseCollectsOnlySatelliteGrids() {
+        // Satellite QSO: PROP_MODE SAT, confirmed, opponent grid.
+        val satQso = "<CALL:6>BA7OPF\n" +
+            "<QSO_DATE:8>20260820\n" +
+            "<PROP_MODE:3>SAT\n" +
+            "<SAT_NAME:5>FO-29\n" +
+            "<GRIDSQUARE:4>NL47\n" +
+            "<EOR>\n"
+        // Ground QSO: same grid but no PROP_MODE -> must be excluded.
+        val groundQso = "<CALL:6>BA7OPF\n" +
+            "<QSO_DATE:8>20260821\n" +
+            "<GRIDSQUARE:4>NL47\n" +
+            "<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso, groundQso))
+        assertEquals(setOf("NL47"), result)
+    }
+
+    @Test
+    fun parseSupportsVuccGridPairsAndSixCharGrids() {
+        val satQso = "<PROP_MODE:3>SAT\n" +
+            "<SAT_NAME:5>SO-50\n" +
+            "<GRIDSQUARE:6>OM60IL\n" +
+            "<VUCC_GRIDS:11>EN52en,EN53fa\n" +
+            "<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso))
+        assertEquals(setOf("OM60", "EN52", "EN53"), result)
+    }
+
+    @Test
+    fun parsePropModeDoesNotLeakAcrossRecords() {
+        // PROP_MODE SAT record first, then a ground QSO with a grid — the second
+        // record must not inherit the satellite flag after its own <EOR>.
+        val satQso = "<PROP_MODE:3>SAT\n<GRIDSQUARE:4>OL62\n<EOR>\n"
+        val groundQso = "<GRIDSQUARE:4>PM00\n<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso, groundQso))
+        assertEquals(setOf("OL62"), result)
+    }
+
+    @Test
+    fun parseReturnsEmptySetForReportWithoutGrids() {
+        val satQso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>AO-07\n<EOR>\n"
+        assertEquals(emptySet<String>(), repo.parseConfirmedGrids(report(satQso)))
+    }
+
+    // region parseConfirmedGridQsos
+
+    private val satQsoFull = "<CALL:5>A50QO\n" +
+        "<QSO_DATE:8>20260820\n" +
+        "<TIME_ON:6>113045\n" +
+        "<PROP_MODE:3>SAT\n" +
+        "<SAT_NAME:5>FO-29\n" +
+        "<MODE:2>CW\n" +
+        "<BAND:3>70CM\n" +
+        "<BAND_RX:3>2M\n" +
+        "<GRIDSQUARE:4>NL47\n" +
+        "<EOR>\n"
+
+    @Test
+    fun parseQsosExtractsSatelliteDetail() {
+        val result = repo.parseConfirmedGridQsos(report(satQsoFull))!!
+        val qsos = result["NL47"]!!
+        assertEquals(1, qsos.size)
+        val qso = qsos[0]
+        assertEquals("A50QO", qso.call)
+        assertEquals("FO-29", qso.satName)
+        assertEquals("CW", qso.mode)
+        assertEquals("2M", qso.bandUp)
+        assertEquals("70CM", qso.bandDown)
+        assertEquals("V/U", qso.bandLabel)
+        assertEquals(2026, java.time.Instant.ofEpochMilli(qso.epochMs).atZone(java.time.ZoneOffset.UTC).year)
+    }
+
+    @Test
+    fun parseQsosExcludesGroundQsos() {
+        val groundQso = "<CALL:6>BA7OPF\n<QSO_DATE:8>20260821\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(satQsoFull, groundQso))!!
+        assertEquals(1, result["NL47"]!!.size)
+    }
+
+    @Test
+    fun parseQsosVuccPairFeedsBothGrids() {
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n" +
+            "<QSO_DATE:8>20260819\n<TIME_ON:4>1231\n" +
+            "<VUCC_GRIDS:11>EN52en,EN53fa\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        assertEquals(setOf("EN52", "EN53"), result.keys)
+        assertEquals(result["EN52"]!!.first(), result["EN53"]!!.first())
+    }
+
+    @Test
+    fun parseQsosVuccQuadrupleFeedsAllFourGrids() {
+        // VUCC allows up to four grids in one contact.
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n" +
+            "<QSO_DATE:8>20260819\n<TIME_ON:4>1231\n" +
+            "<VUCC_GRIDS:23>EN52en,EN53fa,EN42gj,EN43kh\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        assertEquals(setOf("EN52", "EN53", "EN42", "EN43"), result.keys)
+        result.values.forEach { assertEquals(1, it.size) }
+    }
+
+    @Test
+    fun parseQsosRejectsBodyWithoutEoh() {
+        assertNull(repo.parseConfirmedGridQsos("<HTML>Username/password incorrect</HTML>"))
+    }
+
+    // endregion
+
+    // region failure classification (fetchReportBody -> LoTWResult mapping)
+
+    @Test
+    fun failureClassificationMapsEachException() {
+        // LoTWRepository.toResult() must keep each failure cause distinct so
+        // the UI can show a specific message per cause.
+        assertEquals(
+            LoTWResult.BadCredentials,
+            repo.toResult(LoTWRepository.CredentialsException())
+        )
+        assertEquals(
+            LoTWResult.RateLimited,
+            repo.toResult(LoTWRepository.RateLimitException())
+        )
+        assertEquals(
+            LoTWResult.Timeout,
+            repo.toResult(LoTWRepository.TimeoutException("read timed out"))
+        )
+        val net = repo.toResult(java.io.IOException("HTTP 500"))
+        assertEquals(LoTWResult.NetworkError("HTTP 500"), net)
+    }
+
+    // endregion
+}
@@ -0,0 +1,64 @@
+/*
+ * 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
+
+/**
+ * One confirmed satellite QSO as reported by LoTW, kept per worked gridsquare
+ * so the map can show, for any worked grid, which callsigns were worked there
+ * and when.
+ *
+ * @param call      opposite station callsign (as logged by the opposite op)
+ * @param epochMs   QSO date+time in UTC milliseconds
+ * @param satName   satellite name (e.g. "FO-29")
+ * @param mode      ADIF mode (FM / CW / SSB ...)
+ * @param bandUp    uplink band as reported by LoTW (BAND_RX: "70CM", "2M", "10M"...)
+ * @param bandDown  downlink band (BAND: "2M", "70CM"...) — may be empty when
+ *                  LoTW did not include it
+ */
+data class GridQso(
+    val call: String,
+    val epochMs: Long,
+    val satName: String,
+    val mode: String,
+    val bandUp: String,
+    val bandDown: String
+) {
+    /** Short uplink/downlink band label ("U/V", "V/A"), or "" when unknown. */
+    val bandLabel: String
+        get() {
+            val up = bandAbbrev(bandUp)
+            val down = bandAbbrev(bandDown)
+            return when {
+                up.isNotEmpty() && down.isNotEmpty() -> "$up/$down"
+                up.isNotEmpty() -> up
+                else -> ""
+            }
+        }
+
+    private fun bandAbbrev(band: String): String = when (band.trim().uppercase()) {
+        "70CM" -> "U"
+        "2M" -> "V"
+        "10M" -> "A"
+        "6M" -> "V"
+        "1.2G" -> "L"
+        "2.4G" -> "S"
+        "23CM" -> "L"
+        "13CM" -> "S"
+        else -> band.trim().uppercase()
+    }
+}
@@ -22,7 +22,17 @@ interface ILoTWRepository {

    /**
     * Fetch all confirmed (QSL_RCVD=Y) gridsquares for the given LoTW account.
-     * Returns the 4-char grid set, or null on any failure (network / bad credentials).
+     * Returns the 4-char grid set with an explicit failure cause on error.
     */
-    suspend fun fetchConfirmedGrids(callsign: String, password: String): Set<String>?
+    suspend fun fetchConfirmedGrids(callsign: String, password: String): LoTWResult
+
+    /**
+     * Same report, but keeps the per-QSO detail of every confirmed satellite
+     * QSO (call / time / satellite / mode / bands), grouped by worked 4-char
+     * gridsquare. Failure cause is kept explicit.
+     */
+    suspend fun fetchConfirmedGridQsos(
+        callsign: String,
+        password: String
+    ): LoTWResult
 }
@@ -99,6 +99,9 @@ interface ISettingsRepo {
    fun updateWavelogSettings(settings: WavelogSettings)
    fun getWorkedGrids(): Set<String>
    fun setWorkedGrids(grids: Set<String>)
+    /** Confirmed satellite QSOs grouped by worked 4-char gridsquare (map tap detail). */
+    fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>
+    fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>)
    //endregion

    //region # LoTW confirmed-grids settings
@@ -0,0 +1,45 @@
+/*
+ * 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.repository
+
+/** Result of a LoTW report fetch, with the failure cause kept explicit. */
+sealed class LoTWResult {
+
+    /** Report downloaded and parsed successfully. */
+    data class Success(
+        val grids: Set<String>,
+        val qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>
+    ) : LoTWResult()
+
+    /** HTTP 200 but LoTW replied with its login-error page (bad callsign/password). */
+    data object BadCredentials : LoTWResult()
+
+    /**
+     * Report endpoint refused the request without a usable error page. LoTW
+     * limits downloads to one in progress per user id and flags accounts that
+     * pull the full report too often; the server answers those with a bare
+     * non-ADIF body (no <eoh>).
+     */
+    data object RateLimited : LoTWResult()
+
+    /** Connect/read timed out — typically a slow route to the ARRL servers. */
+    data object Timeout : LoTWResult()
+
+    /** Any other network-level failure (DNS, TLS, connection reset, HTTP 5xx). */
+    data class NetworkError(val detail: String) : LoTWResult()
+}
@@ -118,6 +118,10 @@
    <string name="map_period">周期：% .0f min</string>
    <string name="map_velocity">速度：%.2f km/s</string>
    <string name="map_visibility">能见度：%s</string>
+    <!-- Worked-grid QSO dialog -->
+    <string name="grid_qso_calls_count">%d 个呼号 · %d 次通联</string>
+    <string name="grid_qso_first">首通</string>
+    <string name="grid_qso_no_sat">卫星未知</string>
    <string name="map_visible">日照中</string>

    <!-- Settings screen -->
@@ -143,6 +143,10 @@
    <string name="map_period">Period: %.0f min</string>
    <string name="map_velocity">Velocity: %.2f km/s</string>
    <string name="map_visibility">Visibility: %s</string>
+    <!-- Worked-grid QSO dialog -->
+    <string name="grid_qso_calls_count">%d callsigns · %d QSOs</string>
+    <string name="grid_qso_first">First</string>
+    <string name="grid_qso_no_sat">satellite unknown</string>
    <string name="map_visible">Visible</string>

    <!-- Settings screen -->
@@ -61,6 +61,11 @@ class MaidenheadGridOverlay : Overlay() {
        style = Paint.Style.STROKE
        color = Color.argb(255, 90, 200, 255)
    }
+    private val selectedLinePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        strokeWidth = 4.5f
+        style = Paint.Style.STROKE
+        color = Color.argb(255, 76, 217, 100)
+    }

    /** Worked gridsquares (4-char, uppercase) to highlight, e.g. {"OL62", "PM95"}. */
    var workedGrids: Set<String> = emptySet()
@@ -68,6 +73,9 @@ class MaidenheadGridOverlay : Overlay() {
    /** The station's own 4-char gridsquare, drawn with a distinct outline. */
    var ownGrid: String? = null

+    /** The currently tapped worked grid (4-char) highlighted with a distinct outline, or null. */
+    var selectedGrid: String? = null
+
    /** Viewport width, refreshed each draw; used by projectionToX bounds. */
    private var canvasWidthPx = 1080f

@@ -79,28 +87,43 @@ class MaidenheadGridOverlay : Overlay() {
        val cellLat = if (zoom >= GRID_ZOOM_SUB) SUB_SQUARE_LAT else FIELD_LAT
        val cellLon = if (zoom >= GRID_ZOOM_SUB) SUB_SQUARE_LON else FIELD_LON

-        // Visible bounding box in geographic coordinates
+        // Visible bounding box. Do NOT derive longitude bounds from the left/
+        // right edge pixels: osmdroid normalizes them to [-180,180), which both
+        // garbles antimeridian-crossing views AND makes any global view (span
+        // > 180°) look like an antimeridian crossing — unwrapping then produced
+        // an inverted range and ALL meridians vanished at low zoom. Instead
+        // anchor on the view-center longitude and expand by the half-width in
+        // degrees; the range is continuous (may exceed ±180) and cell indices
+        // beyond 18 wrap correctly via normalizeLon().
        val north = projection.fromPixels(0, 0)
        val south = projection.fromPixels(canvas.width, canvas.height)
        val topLat = max(north.latitude, south.latitude).coerceIn(-90.0, 90.0)
        val bottomLat = min(north.latitude, south.latitude).coerceIn(-90.0, 90.0)
-        val leftLon = min(north.longitude, south.longitude)
-        val rightLon = max(north.longitude, south.longitude)
+        val worldWidthPx = 256.0 * Math.pow(2.0, zoom)
+        val viewCenter = projection.fromPixels(canvas.width / 2, canvas.height / 2)
+        val centerLon = viewCenter.longitude
+        val halfSpanDeg = (canvas.width / 2.0) / worldWidthPx * 360.0
+        val leftLon = centerLon - halfSpanDeg
+        val rightLon = centerLon + halfSpanDeg

        val firstRow = floor(bottomLat / cellLat).toInt()
        val lastRow = ceil(topLat / cellLat).toInt()
-        // Longitude cell indices may exceed the [-180, 180) range when the view
-        // crosses the antimeridian; index arithmetic still works (PMxx at 360° == same grid)
+        // Longitude cell indices are in the continuous unwrapped space and may
+        // exceed the [-180, 180) range when the view crosses the antimeridian
+        // or spans world repeats; labels normalize each cell back.
        val firstCol = floor(leftLon / cellLon).toInt()
        val lastCol = ceil(rightLon / cellLon).toInt()
-        val centerLon = (leftLon + rightLon) / 2.0
-        // World width in screen pixels for the current zoom (256 px per tile,
-        // 2^zoom tiles across the whole 360° world). Used by the custom
-        // Mercator-X computation in projectionToX.
-        val worldWidthPx = 256.0 * Math.pow(2.0, zoom)
+        // At low zoom the world is narrower than the viewport and osmdroid shows
+        // repeating copies on both sides. The visible bounding box spans more
+        // than 360° of longitude there; extend the column range by whole world
+        // turns so meridians, fills and labels tile across the repeats too.
+        val worldTurns = ceil(((rightLon - leftLon) / 360.0) - 1e-9).toInt().coerceAtLeast(0)
+        val colRepeats = if (worldTurns > 0) worldTurns else 0

        // The station's own grid square (4-char, only meaningful at sub-square zoom)
        val ownCell = ownGrid?.takeIf { zoom >= GRID_ZOOM_SUB }
+        // The tapped worked grid gets a distinct outline (same zoom gate).
+        val selectedCell = selectedGrid?.takeIf { zoom >= GRID_ZOOM_SUB }

        // Worked-grid highlight fills.
        //  - Sub-square zoom: fill each worked 4-char cell directly.
@@ -117,7 +140,7 @@ class MaidenheadGridOverlay : Overlay() {
                    val yTop = projectionToY(projection, topLatCell)
                    val yBottom = projectionToY(projection, lat)
                    if (yTop == null || yBottom == null) continue
-                    for (col in firstCol..lastCol) {
+                    for (turn in -colRepeats..colRepeats) for (col in firstCol..lastCol) {
                        val lon = col * cellLon
                        val xLeft = projectionToX(projection, lon, centerLon, worldWidthPx) ?: continue
                        val xRight = projectionToX(projection, lon + cellLon, centerLon, worldWidthPx) ?: continue
@@ -130,64 +153,99 @@ class MaidenheadGridOverlay : Overlay() {
            } else {
                for (grid in workedGrids) {
                    val cell = gridCellBounds(grid) ?: continue
-                    if (cell.lonRight <= leftLon || cell.lonLeft >= rightLon ||
-                        cell.latTop <= bottomLat || cell.latBottom >= topLat
-                    ) continue
-                    val yTop = projectionToY(projection, cell.latTop) ?: continue
-                    val yBottom = projectionToY(projection, cell.latBottom) ?: continue
-                    val xLeft = projectionToX(projection, cell.lonLeft, centerLon, worldWidthPx) ?: continue
-                    val xRight = projectionToX(projection, cell.lonRight, centerLon, worldWidthPx) ?: continue
-                    if (xRight < 0f || xLeft > canvas.width) continue
-                    if (yBottom < 0f || yTop > canvas.height) continue
-                    canvas.drawRect(xLeft, yTop, xRight, yBottom, workedPaint)
+                    for (turn in -colRepeats..colRepeats) {
+                        // Shift the cell by whole world turns to cover repeats.
+                        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 xLeft = projectionToX(projection, cell.lonLeft + dLon, centerLon, worldWidthPx) ?: continue
+                        val xRight = projectionToX(projection, cell.lonRight + dLon, centerLon, worldWidthPx) ?: continue
+                        if (xRight < 0f || xLeft > canvas.width) continue
+                        if (yBottom < 0f || yTop > canvas.height) continue
+                        canvas.drawRect(xLeft, yTop, xRight, yBottom, workedPaint)
+                    }
                }
            }
        }

-        // Vertical lines (meridians)
-        for (col in firstCol..lastCol) {
+        // Vertical lines (meridians), segmented per cell row so that worked
+        // grid cells stay line-free (same look as field-zoom fills: green
+        // patches without square grid lines). Only relevant at sub-square
+        // zoom; at field zoom cellLabel() yields 2-char fields which never
+        // match the 4-char workedGrids, so all lines draw.
+        for (turn in -colRepeats..colRepeats) for (col in firstCol..lastCol) {
            val lon = col * cellLon
            val x = projectionToX(projection, lon, centerLon, worldWidthPx)
            if (x == null) continue
-            canvas.drawLine(x, 0f, x, canvas.height.toFloat(), linePaint)
+            for (row in firstRow..lastRow) {
+                val lat = row * cellLat
+                if (lat < -90.0 || lat >= 90.0) continue
+                val topLatCell = lat + cellLat
+                if (topLatCell > 90.0) continue
+                val yTop = projectionToY(projection, topLatCell) ?: continue
+                val yBottom = projectionToY(projection, lat) ?: continue
+                // This meridian is a border of the cell on its right (col)
+                // and of the cell on its left (col-1); skip the segment if
+                // either cell is a worked grid.
+                val workedHere =
+                    cellLabel(lat, lon, zoom) in workedGrids ||
+                        cellLabel(lat, lon - cellLon, zoom) in workedGrids
+                if (workedHere) continue
+                canvas.drawLine(x, yTop, x, yBottom, linePaint)
+            }
        }
-        // Horizontal lines (parallels)
+        // Horizontal lines (parallels), segmented per cell column so worked
+        // cells have no lines through them either.
        for (row in firstRow..lastRow) {
            val lat = row * cellLat
            if (lat <= -90.0 || lat >= 90.0) continue
            val y = projectionToY(projection, lat)
            if (y == null) continue
-            canvas.drawLine(0f, y, canvas.width.toFloat(), y, linePaint)
+            for (turn in -colRepeats..colRepeats) for (col in firstCol..lastCol) {
+                val lon = col * cellLon
+                val xLeft = projectionToX(projection, lon, centerLon, worldWidthPx) ?: continue
+                val xRight = projectionToX(projection, lon + cellLon, centerLon, worldWidthPx) ?: continue
+                if (xRight < 0f || xLeft > canvas.width) continue
+                // This parallel borders the cell above (row) and below
+                // (row-1); skip the segment if either is worked.
+                val workedHere =
+                    cellLabel(lat, lon, zoom) in workedGrids ||
+                        cellLabel(lat - cellLat, lon, zoom) in workedGrids
+                if (workedHere) continue
+                canvas.drawLine(xLeft, y, xRight, y, linePaint)
+            }
        }

        // The station's own grid square: redraw its four borders thicker on top.
-        if (ownCell != null) {
-            val ownColIdx = firstCol..lastCol
+        // The tapped worked grid gets the same treatment in a different color.
+        if (ownCell != null || selectedCell != null) {
            for (row in firstRow..lastRow) {
                val lat = row * cellLat
                if (lat < -90.0 || lat >= 90.0) continue
-                for (col in ownColIdx) {
+                for (col in firstCol..lastCol) {
                    val lon = col * cellLon
-                    if (cellLabel(lat, lon, zoom) != ownCell) continue
+                    val label = cellLabel(lat, lon, zoom)
+                    if (label != ownCell && label != selectedCell) continue
                    val yTop = projectionToY(projection, lat + cellLat) ?: continue
                    val yBottom = projectionToY(projection, lat) ?: continue
                    val xLeft = projectionToX(projection, lon, centerLon, worldWidthPx) ?: continue
                    val xRight = projectionToX(projection, lon + cellLon, centerLon, worldWidthPx) ?: continue
-                    canvas.drawLine(xLeft, yTop, xRight, yTop, ownLinePaint)
-                    canvas.drawLine(xLeft, yBottom, xRight, yBottom, ownLinePaint)
-                    canvas.drawLine(xLeft, yTop, xLeft, yBottom, ownLinePaint)
-                    canvas.drawLine(xRight, yTop, xRight, yBottom, ownLinePaint)
+                    val paint = if (label == selectedCell) selectedLinePaint else ownLinePaint
+                    canvas.drawLine(xLeft, yTop, xRight, yTop, paint)
+                    canvas.drawLine(xLeft, yBottom, xRight, yBottom, paint)
+                    canvas.drawLine(xLeft, yTop, xLeft, yBottom, paint)
+                    canvas.drawLine(xRight, yTop, xRight, yBottom, paint)
                }
            }
        }

        // Labels: centered in each cell, only when the cell is large enough on
-        // screen to hold a label (avoid clutter at low zoom)
-        val showLabels = when {
-            zoom >= GRID_ZOOM_SUB -> true
-            zoom >= FIELD_ZOOM_LABELS -> true
-            else -> false
-        }
+        // 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).
+        val showLabels = zoom >= LABEL_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.
@@ -209,7 +267,7 @@ class MaidenheadGridOverlay : Overlay() {
            val yBottom = projectionToY(projection, lat) ?: continue
            val yCenter = (yTop + yBottom) / 2f - textHalfHeight
            if (yBottom < 0f || yTop > canvas.height) continue
-            for (col in firstCol..lastCol) {
+            for (turn in -colRepeats..colRepeats) for (col in firstCol..lastCol) {
                val lon = col * cellLon
                val xLeft = projectionToX(projection, lon, centerLon, worldWidthPx) ?: continue
                val xRight = projectionToX(projection, lon + cellLon, centerLon, worldWidthPx) ?: continue
@@ -288,13 +346,19 @@ class MaidenheadGridOverlay : Overlay() {
        return l
    }

-    private companion object {
+    internal companion object {
        const val FIELD_LAT = 10.0
        const val FIELD_LON = 20.0
        const val SUB_SQUARE_LAT = 1.0
        const val SUB_SQUARE_LON = 2.0
-        const val GRID_ZOOM_SUB = 5.0
-        const val FIELD_ZOOM_LABELS = 3.0
+        // Zoom at which the 2°x1° sub-square grid lines/fills appear.
+        // 5.0 → 6.0: at zoom 5 a full field spans too little screen width and
+        // 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 7+ = lines + names).
+        const val LABEL_ZOOM_SUB = 7.0
        const val MIN_LABEL_CELL_PX = 48f
        const val MAX_OVERSHOOT_PX = 64
    }
@@ -25,14 +25,18 @@ import android.graphics.Paint
 import android.graphics.Rect
 import android.graphics.drawable.Drawable
 import androidx.collection.LruCache
+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.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.ElevatedCard
@@ -138,6 +142,36 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
    val timeString = uiState.mapData?.aosTime ?: "00:00:00"
    val isTimeAos = uiState.mapData?.isTimeAos ?: true

+    // Tapped worked grid -> centered QSO dialog. Local UI state: the map is the
+    // only consumer and it resets when leaving the page.
+    var selectedGrid by remember { mutableStateOf<String?>(null) }
+    // Attach the tap listener whenever grid mode / worked grids change.
+    val workedGrids = uiState.workedGrids
+    val isGridMode = uiState.isGridMode
+    DisposableEffect(isGridMode, workedGrids) {
+        val receiver = object : org.osmdroid.events.MapEventsReceiver {
+            override fun singleTapConfirmedHelper(p: GeoPoint?): Boolean {
+                if (!isGridMode || p == null) return false
+                val zoom = mapView.zoomLevelDouble
+                if (zoom < MaidenheadGridOverlay.LABEL_ZOOM_SUB) return false
+                val grid = gridOfPoint(p.latitude, p.longitude) ?: return false
+                if (grid !in workedGrids) return false
+                selectedGrid = grid
+                return true
+            }
+
+            override fun longPressHelper(p: GeoPoint?): Boolean = false
+        }
+        val eventsOverlay = org.osmdroid.views.overlay.MapEventsOverlay(receiver)
+        mapView.overlays.add(eventsOverlay)
+        onDispose { mapView.overlays.remove(eventsOverlay) }
+    }
+    // Keep the overlay's selected highlight in sync with the dialog.
+    LaunchedEffect(selectedGrid) {
+        (mapView.overlays.getOrNull(OVERLAY_GRID) as? MaidenheadGridOverlay)?.selectedGrid = selectedGrid
+        mapView.invalidate()
+    }
+
    LaunchedEffect(uiState.track) {
        // In grid mode the map is centered on the local grid square; following
        // the satellite subpoint here would override that centering on every
@@ -200,8 +234,155 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
            }
        }
    }
+    // Centered dialog listing the tapped worked grid's confirmed satellite QSOs.
+    // Dismissed by tapping outside (no explicit close button).
+    selectedGrid?.let { grid ->
+        WorkedGridQsoDialog(
+            grid = grid,
+            qsos = uiState.workedGridQsos[grid].orEmpty().sortedBy { it.epochMs },
+            isUtc = uiState.isUtc,
+            onDismiss = { selectedGrid = null }
+        )
+    }
 }

+// region Worked-grid QSO dialog
+
+@Composable
+private fun WorkedGridQsoDialog(
+    grid: String,
+    qsos: List<com.rtbishop.look4sat.core.domain.model.GridQso>,
+    isUtc: Boolean,
+    onDismiss: () -> Unit
+) {
+    androidx.compose.ui.window.Dialog(onDismissRequest = onDismiss) {
+        // Centered card, ~85% width, internal scroll for long lists.
+        Card(
+            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainerLow),
+            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
+                    )
+                }
+                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())
+                    ) {
+                        grouped.forEach { (call, callQsos) ->
+                            WorkedGridCallRow(call, callQsos = callQsos, isUtc = isUtc)
+                            androidx.compose.material3.HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.3f))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun WorkedGridCallRow(
+    call: String,
+    callQsos: List<com.rtbishop.look4sat.core.domain.model.GridQso>,
+    isUtc: Boolean,
+) {
+    var expanded by remember { mutableStateOf(false) }
+    val first = callQsos.first()
+    Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { expanded = !expanded }
+        ) {
+            Text(
+                text = call,
+                style = MaterialTheme.typography.titleMedium,
+                fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace,
+                color = MaterialTheme.colorScheme.tertiary,
+                modifier = Modifier.weight(1f)
+            )
+            Text(
+                text = formatDate(first.epochMs, isUtc),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            Text(
+                text = if (expanded) " ▴" else " ▾",
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.primary
+            )
+        }
+        // First-QSO summary line, always visible.
+        Text(
+            text = stringResource(R.string.grid_qso_first) + " · " + qsoSummary(first, isUtc),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.padding(top = 3.dp)
+        )
+        // Subsequent QSOs in this grid, revealed on expand.
+        if (expanded && callQsos.size > 1) {
+            callQsos.drop(1).forEachIndexed { index, qso ->
+                val ordinal = "${index + 2}"
+                Text(
+                    text = "$ordinal " + qsoSummary(qso, isUtc),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.padding(top = 3.dp)
+                )
+            }
+        }
+    }
+}
+
+private fun qsoSummary(qso: com.rtbishop.look4sat.core.domain.model.GridQso, isUtc: Boolean): String {
+    val sat = qso.satName.ifBlank { "?" }
+    val mode = qso.mode.ifBlank { "?" }
+    val band = qso.bandLabel
+    val time = formatTime(qso.epochMs, isUtc)
+    return listOf(sat, mode, band, time).filter { it.isNotBlank() }.joinToString(" · ")
+}
+
+private fun formatDate(epochMs: Long, isUtc: Boolean): String {
+    if (epochMs <= 0L) return "--"
+    val zone = if (isUtc) java.time.ZoneOffset.UTC else java.time.ZoneId.systemDefault()
+    return java.time.Instant.ofEpochMilli(epochMs).atZone(zone)
+        .format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd"))
+}
+
+private fun formatTime(epochMs: Long, isUtc: Boolean): String {
+    if (epochMs <= 0L) return "--:--"
+    val zone = if (isUtc) java.time.ZoneOffset.UTC else java.time.ZoneId.systemDefault()
+    return java.time.Instant.ofEpochMilli(epochMs).atZone(zone)
+        .format(java.time.format.DateTimeFormatter.ofPattern(if (isUtc) "HH:mm'Z'" else "HH:mm"))
+}
+// endregion
+
 // region Map data composables
@Composable
 private fun MapDataCard(data: MapData) {
@@ -314,16 +495,23 @@ private fun setGridMode(
            mapView.overlays.getOrNull(index)?.isEnabled = !gridMode
        }
        // Entering grid mode: center on the station's current grid square,
-        // keeping the current zoom level unchanged.
+        // keeping the current zoom level unchanged. post{} is essential: on the
+        // first composition this runs before MapView's first layout, and a
+        // setCenter issued pre-layout is discarded when the view lays out —
+        // the map then keeps its default center forever.
        if (gridMode) {
            val pos = stationPosition ?: return
            val lat = pos.latitude
            val lon = pos.longitude
+            // Maidenhead field indices: field 0 spans -90..-80° lat and
+            // -180..-160° lon, so the field-center must be offset by those
+            // bases — omitting them maps e.g. OL62's field center to
+            // 115°N/290°E (an ocean a hemisphere away) instead of 25°N/110°E.
            val fieldLat = ((lat + 90.0) / 10.0).toInt().coerceIn(0, 17)
            val fieldLon = ((lon + 180.0) / 20.0).toInt().coerceIn(0, 17)
-            val centerLat = fieldLat * 10.0 + 5.0
-            val centerLon = fieldLon * 20.0 + 10.0
-            mapView.controller.setCenter(GeoPoint(centerLat, centerLon))
+            val centerLat = fieldLat * 10.0 + 5.0 - 90.0
+            val centerLon = fieldLon * 20.0 + 10.0 - 180.0
+            mapView.post { mapView.controller.setCenter(GeoPoint(centerLat, centerLon)) }
        }
    } catch (e: Exception) {
        println(e)
@@ -342,6 +530,17 @@ private fun ownGridOf(stationPosition: GeoPos?): String? {
    return "${'A' + fieldLon}${'A' + fieldLat}$subLon$subLat"
 }

+/** The 4-char Maidenhead gridsquare containing the given point, or null outside the grid. */
+private fun gridOfPoint(latitude: Double, longitude: Double): String? {
+    if (latitude < -90.0 || latitude >= 90.0) return null
+    val lon = ((longitude + 180.0) % 360.0 + 360.0) % 360.0 - 180.0
+    val fieldLat = ((latitude + 90.0) / 10.0).toInt().coerceIn(0, 17)
+    val fieldLon = ((lon + 180.0) / 20.0).toInt().coerceIn(0, 17)
+    val subLat = ((latitude + 90.0) % 10.0).toInt()
+    val subLon = ((lon + 180.0) % 20.0 / 2.0).toInt()
+    return "${'A' + fieldLon}${'A' + fieldLat}$subLon$subLat"
+}
+
 private fun setStationPosition(stationPos: GeoPos, mapView: MapView) {
    try {
        val overlay = mapView.overlays[OVERLAY_STATION]
@@ -28,6 +28,7 @@ data class MapState(
    val isUtc: Boolean = false,
    val isGridMode: Boolean = false,
    val workedGrids: Set<String> = emptySet(),
+    val workedGridQsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> = emptyMap(),
    val stationPosition: GeoPos? = null,
    val orbitalPass: OrbitalPass,
    val track: List<List<GeoPos>>? = null,
@@ -79,7 +79,12 @@ class MapViewModel(
        }
        viewModelScope.launch {
            settingsRepo.wavelogSettings.collectLatest { _ ->
-                _uiState.update { it.copy(workedGrids = settingsRepo.getWorkedGrids()) }
+                _uiState.update {
+                    it.copy(
+                        workedGrids = settingsRepo.getWorkedGrids(),
+                        workedGridQsos = settingsRepo.getWorkedGridQsos()
+                    )
+                }
            }
        }
        val (selectedCatNum, _) = satelliteRepo.selectedPass.value
@@ -201,16 +201,47 @@ class SettingsViewModel(
        settingsRepo.updateLoTWSettings(settings)
        _uiState.update { it.copy(lotwSyncing = true, lotwMessage = null) }
        viewModelScope.launch {
-            val lotwGrids = lotwRepo.fetchConfirmedGrids(settings.callsign, settings.password)
-            _uiState.update { state ->
-                if (lotwGrids == null) {
-                    state.copy(lotwSyncing = false, lotwMessage = "LoTW sync failed — check callsign/password/network")
-                } else {
+            when (val result = lotwRepo.fetchConfirmedGridQsos(settings.callsign, settings.password)) {
+                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.Success -> {
                    // Wavelog entry removed: LoTW is now the only source, so the
                    // synced set fully replaces the stored worked grids.
-                    settingsRepo.setWorkedGrids(lotwGrids)
-                    state.copy(lotwSyncing = false, workedGridsCount = lotwGrids.size, lotwMessage = null)
+                    settingsRepo.setWorkedGrids(result.grids)
+                    settingsRepo.setWorkedGridQsos(result.qsos)
+                    _uiState.update { state ->
+                        state.copy(
+                            lotwSyncing = false, workedGridsCount = result.grids.size,
+                            lotwMessage = null
+                        )
+                    }
                }
+                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.BadCredentials ->
+                    _uiState.update { state ->
+                        state.copy(
+                            lotwSyncing = false,
+                            lotwMessage = "LoTW sync failed — callsign or password incorrect"
+                        )
+                    }
+                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.RateLimited ->
+                    _uiState.update { state ->
+                        state.copy(
+                            lotwSyncing = false,
+                            lotwMessage = "LoTW sync failed — rate limited by server, wait a few minutes and retry"
+                        )
+                    }
+                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.Timeout ->
+                    _uiState.update { state ->
+                        state.copy(
+                            lotwSyncing = false,
+                            lotwMessage = "LoTW sync failed — connection timed out, try another network"
+                        )
+                    }
+                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.NetworkError ->
+                    _uiState.update { state ->
+                        state.copy(
+                            lotwSyncing = false,
+                            lotwMessage = "LoTW sync failed — network error (${result.detail})"
+                        )
+                    }
            }
        }
    }
@@ -1,8 +1,8 @@
 [versions]
 #noinspection UnusedVersionCatalogEntry
-appVersionCode = "459"
+appVersionCode = "460"
 #noinspection UnusedVersionCatalogEntry
-appVersionName = "4.4.6-ba7opf.9.7"
+appVersionName = "4.4.6-ba7opf.9.9"
 #noinspection UnusedVersionCatalogEntry
 compileSdk = "37"
 #noinspection UnusedVersionCatalogEntry
Author	SHA1	Message	Date
atsunatsu	42a6ffa4c9	chore: bump version to 4.4.6-ba7opf.9.9	2026-09-08 04:17:52 +08:00
atsunatsu	cf1d8e6539	LoTW sync: distinguish failure causes (bad credentials / rate limit / timeout / network) Rate limit classification per ARRL policy (one download in progress per user id; HTTP 503 'Page request limit' observed on throttled pulls) and the HTML login-error page returned for wrong credentials. Settings screen now shows a specific message per cause instead of one generic 'check callsign/password/network'.	2026-09-08 04:07:03 +08:00
atsunatsu	ab8b072f1f	fix(map): worked cells at sub-square zoom stay line-free — grid lines skip worked segments Lines (alpha 160 yellow) were drawn AFTER the worked fills (alpha 90 green), so at zoom>=6 every worked cell's four borders got yellow-on-green composited — the cells looked brighter than the same cells at field zoom (no square lines there). Segments bordering a worked cell are now skipped in both meridian and parallel passes.	2026-09-08 03:44:21 +08:00
atsunatsu	1d4036e3d0	fix(map): vertical grid lines vanish at global views — bbox now anchored on view center, not left/right edge pixels The antimeridian unwrap (span > 180 => shift left edge +360) misfired on every global view (span is legitimately > 180): the range inverted and the meridian loop drew nothing. Anchor the bbox on the view-center longitude plus half viewport width in degrees instead; continuous unwrapped range handles both antimeridian crossing and world repeats.	2026-09-08 03:25:12 +08:00
atsunatsu	ab22244f86	fix(map): grid-mode field center offset by -90/-180 base Maidenhead field index 0 spans -90..-80 lat / -180..-160 lon, so the field-center must subtract those bases. Without them, entering grid mode centered a hemisphere away (OL62 -> 115N/290E instead of 25N/110E).	2026-09-08 03:19:40 +08:00
atsunatsu	3b0874d707	chore: bump version to 4.4.6-ba7opf.9.8	2026-09-08 02:56:16 +08:00
atsunatsu	2c5b1479f1	test(lotw): VUCC up to 4 grids in one contact; clarify comment	2026-09-08 02:51:24 +08:00
atsunatsu	39d4498a54	feat(map): tap worked grid at zoom>=7 to show per-grid satellite QSO dialog - LoTW sync now stores per-QSO detail (call/time/sat/mode/bands) grouped by gridsquare (PROP_MODE=SAT only), single JSON blob in SharedPreferences - GridQso model derives band label (V/U, U/V, V/A...) from BAND_RX/BAND - Tap detection via osmdroid MapEventsOverlay; selected grid outlined green - Centered dialog: calls sorted by first-contact time, first-QSO summary, expandable call rows list subsequent QSOs in that grid; tap outside closes	2026-09-08 02:47:54 +08:00
atsunatsu	9ed2aebc9d	fix(lotw): only collect satellite QSO grids (PROP_MODE=SAT); keep both grids of VUCC_GRIDS pairs	2026-09-08 02:09:25 +08:00
atsunatsu	72d5e13acf	tune(map): 4-char sub-square labels at zoom>=7; zoom 6 shows grid lines only	2026-09-08 01:55:40 +08:00
atsunatsu	736dc23aae	chore(map): drop unused FIELD_ZOOM_LABELS constant	2026-09-08 01:52:01 +08:00
atsunatsu	052ba79c94	fix(map): field labels visible at all zooms (pixel-size gated), not gated by FIELD_ZOOM_LABELS	2026-09-08 01:51:14 +08:00
atsunatsu	cb648caf65	tune(map): raise thresholds — sub-square grid lines at zoom>=6 (was 5), field labels at zoom>=4 (was 3)	2026-09-08 01:48:24 +08:00
atsunatsu	05170541ed	fix(map): grid mode centering via view.post (first-layout reset); antimeridian unwrap of visible bbox fixes Pacific-centered vanishing grid; tile meridians/fills across world repeats at low zoom	2026-09-08 01:39:21 +08:00