chore: bump version to 4.4.6-ba7opf.9.8

test(lotw): VUCC up to 4 grids in one contact; clarify comment
feat(map): tap worked grid at zoom>=7 to show per-grid satellite QSO dialog
2026-10-02 03:15:37 +00:00 · 2026-09-08 02:56:16 +08:00 · 2026-09-08 02:51:24 +08:00 · 2026-09-08 02:47:54 +08:00 · 2026-09-08 02:09:25 +08:00 · 2026-09-08 01:55:40 +08:00
36 changed files with 2106 additions and 81 deletions
@@ -1,7 +1,19 @@
+import java.io.FileInputStream
+import java.util.Properties
+
 plugins {
    alias(libs.plugins.convention.applicationPlugin)
 }

+// Release signing credentials live in local.properties (gitignored) or
+// environment variables — never hardcode passwords in VCS.
+val releaseProps = Properties().apply {
+    val propsFile = rootProject.file("local.properties")
+    if (propsFile.exists()) FileInputStream(propsFile).use { load(it) }
+}
+fun releaseCred(name: String): String =
+    releaseProps.getProperty(name) ?: System.getenv(name) ?: ""
+
 android {
    namespace = libs.versions.packageName.get()
    defaultConfig {
@@ -11,9 +23,9 @@ android {
    signingConfigs {
        create("release") {
            storeFile = file(System.getProperty("user.home") + "/my-release-key.jks")
-            storePassword = "look4sat123"
-            keyAlias = "look4sat"
-            keyPassword = "look4sat123"
+            storePassword = releaseCred("RELEASE_STORE_PASSWORD")
+            keyAlias = releaseCred("RELEASE_KEY_ALIAS").ifEmpty { "look4sat" }
+            keyPassword = releaseCred("RELEASE_KEY_PASSWORD")
        }
    }
    buildTypes {
@@ -36,6 +36,8 @@ import com.rtbishop.look4sat.core.data.repository.SelectionRepo
 import com.rtbishop.look4sat.core.data.repository.SensorsRepo
 import com.rtbishop.look4sat.core.data.repository.SettingsRepo
 import com.rtbishop.look4sat.core.data.repository.UpdateRepository
+import com.rtbishop.look4sat.core.data.repository.LoTWRepository
+import com.rtbishop.look4sat.core.data.repository.WavelogRepository
 import com.rtbishop.look4sat.core.data.source.LocalSource
 import com.rtbishop.look4sat.core.data.source.RemoteSource
 import com.rtbishop.look4sat.core.data.usecase.AddToCalendar
@@ -48,10 +50,12 @@ import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.IRadioController
 import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
 import com.rtbishop.look4sat.core.domain.repository.IReporter
+import com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
 import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.IWavelogRepository
 import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
@@ -81,6 +85,8 @@ class MainContainer(private val context: Context) : IMainContainer {
    override val databaseRepo = provideDatabaseRepo()
    override val amSatRepo by lazy { AmSatRepository(remoteSource, appScope) }
    override val updateRepo by lazy { UpdateRepository(remoteSource) }
+    override val wavelogRepo: IWavelogRepository by lazy { WavelogRepository() }
+    override val lotwRepo: ILoTWRepository by lazy { LoTWRepository() }
    override val radioTrackingService: IRadioTrackingService by lazy {
        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
        RadioTrackingService(appScope, manager, satelliteRepo, settingsRepo)
@@ -0,0 +1,270 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+
+/**
+ * Fetches confirmed gridsquares directly from ARRL LoTW via the official report endpoint:
+ *   GET https://lotw.arrl.org/lotwuser/lotwreport.adi?login=<call>&password=<pwd>
+ *       &qso_query=1&qso_qsl=yes&qso_qsldetail=yes&qso_mydetail=yes&qso_qslsince=<date>
+ *
+ * Only QSL_RCVD=Y records are returned by LoTW for qso_qsl=yes, so every grid in the
+ * report is a *confirmed* grid (green on the map). GRIDSQUARE may be a 4- or 6-char
+ * 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.
+ */
+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() }
+                connection.disconnect()
+                if (body.contains(" password=") && !body.startsWith("ARRL")) return@withContext null
+                parseConfirmedGrids(body)
+            } catch (e: Exception) {
+                println("LoTWRepository fetch failure: $e")
+                null
+            }
+        }
+
+    override suspend fun fetchConfirmedGridQsos(
+        callsign: String,
+        password: String
+    ): Pair<Set<String>, Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>>? {
+        // Single report fetch: grids are derived from the same body as the
+        // per-QSO detail (avoids a second ARRL hit and keeps the two datasets
+        // perfectly consistent).
+        val body = fetchReportBody(callsign, password) ?: return null
+        val grids = parseConfirmedGrids(body) ?: return null
+        val qsos = parseConfirmedGridQsos(body) ?: return null
+        return grids to qsos
+    }
+
+    private fun fetchReportBody(callsign: String, password: String): String? {
+        val call = callsign.trim().uppercase()
+        val pwd = password.trim()
+        if (call.isBlank() || pwd.isBlank()) return null
+        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
+            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 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() }
+            connection.disconnect()
+            if (body.contains(" password=") && !body.startsWith("ARRL")) return null
+            body
+        } catch (e: Exception) {
+            println("LoTWRepository fetch failure: $e")
+            null
+        }
+    }
+
+    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
+        // marker as failure so the caller can show a sensible message.
+        // LoTW answers with ADIF text; on bad credentials it returns a short error
+        // page without an <eoh> header terminator. Real reports always carry <eoh>
+        // (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()
+            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
+    }
+
+    private companion object {
+        const val BASE_URL = "https://lotw.arrl.org/lotwuser/lotwreport.adi"
+    }
+}
@@ -29,6 +29,7 @@ import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
 import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
@@ -81,6 +82,7 @@ class SettingsRepo(
    private val keyStateOfUtc = "stateOfUtc"
    private val keyStateOfLightTheme = "stateOfLightTheme"
    private val keyStateOfNightMode = "stateOfNightMode"
+    private val keyStateOfMapGrid = "stateOfMapGrid"
    private val keyStationAltitude = "stationAltitude"
    private val keyStationLatitude = "stationLatitude"
    private val keyStationLongitude = "stationLongitude"
@@ -137,7 +139,124 @@ class SettingsRepo(
    }
    //endregion

-    //region # Passes filter settings
+    //region # Wavelog worked-grids settings
+    private val keyWavelogUrl = "wavelogUrl"
+    private val keyWavelogToken = "wavelogToken"
+    private val keyWorkedGrids = "workedGrids"
+
+    private val _wavelogSettings = MutableStateFlow(getWavelogSettings())
+    override val wavelogSettings: StateFlow<WavelogSettings> = _wavelogSettings
+
+    override fun updateWavelogSettings(settings: WavelogSettings) {
+        preferences.edit {
+            putString(keyWavelogUrl, settings.url.trim())
+            putString(keyWavelogToken, settings.token.trim())
+        }
+        _wavelogSettings.value = settings.copy(url = settings.url.trim(), token = settings.token.trim())
+    }
+
+    private fun getWavelogSettings(): WavelogSettings = WavelogSettings(
+        url = preferences.getString(keyWavelogUrl, null).orEmpty(),
+        token = preferences.getString(keyWavelogToken, null).orEmpty()
+    )
+
+    override fun getWorkedGrids(): Set<String> {
+        val json = preferences.getString(keyWorkedGrids, null).orEmpty()
+        if (json.isBlank()) return emptySet()
+        return try {
+            val array = org.json.JSONArray(json)
+            (0 until array.length()).mapNotNull { i ->
+                array.optString(i).takeIf { it.isNotBlank() }
+            }.toSet()
+        } catch (_: Exception) {
+            emptySet()
+        }
+    }
+
+    override fun setWorkedGrids(grids: Set<String>) {
+        val array = org.json.JSONArray()
+        grids.sorted().forEach { array.put(it) }
+        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"
+
+    override val lotwSettings: kotlinx.coroutines.flow.StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings>
+        get() = _lotwSettings
+    private val _lotwSettings = MutableStateFlow(getLoTWSettings())
+
+    override fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) {
+        preferences.edit {
+            putString(keyLoTWCall, settings.callsign.trim().uppercase())
+            putString(keyLoTWPass, settings.password)
+        }
+        _lotwSettings.value = settings.copy(
+            callsign = settings.callsign.trim().uppercase(),
+            password = settings.password
+        )
+    }
+
+    private fun getLoTWSettings(): com.rtbishop.look4sat.core.domain.model.LoTWSettings =
+        com.rtbishop.look4sat.core.domain.model.LoTWSettings(
+            callsign = preferences.getString(keyLoTWCall, null).orEmpty(),
+            password = preferences.getString(keyLoTWPass, null).orEmpty()
+        )
+    //endregion
+
+    //region # Transceivers settings
    private val _passesSettings = MutableStateFlow(getPassesSettings())
    override val passesSettings: StateFlow<PassesSettings> = _passesSettings

@@ -371,6 +490,7 @@ class SettingsRepo(
                putBoolean(keyStateOfUtc, new.stateOfUtc)
                putBoolean(keyStateOfLightTheme, new.stateOfLightTheme)
                putBoolean(keyStateOfNightMode, new.stateOfNightMode)
+                putBoolean(keyStateOfMapGrid, new.stateOfMapGrid)
                putBoolean(keyShouldSeeWarning, new.shouldSeeWarning)
                putBoolean(keyShouldSeeWhatsNew, new.shouldSeeWhatsNew)
                putString(keySstvMode, new.sstvMode)
@@ -388,6 +508,7 @@ class SettingsRepo(
        stateOfUtc = preferences.getBoolean(keyStateOfUtc, false),
        stateOfLightTheme = preferences.getBoolean(keyStateOfLightTheme, false),
        stateOfNightMode = preferences.getBoolean(keyStateOfNightMode, false),
+        stateOfMapGrid = preferences.getBoolean(keyStateOfMapGrid, false),
        shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
        sstvMode = preferences.getString(keySstvMode, null) ?: "Auto",
@@ -5,7 +5,6 @@ import com.rtbishop.look4sat.core.domain.repository.IUpdateRepository
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import org.json.JSONObject
 import java.io.File

 class UpdateRepository(
@@ -13,15 +12,25 @@ class UpdateRepository(
 ) : IUpdateRepository {

    override suspend fun getLatestRelease(): LatestRelease? = withContext(Dispatchers.IO) {
-        val result = remoteSource.getNetworkStream(LATEST_RELEASE_URL)
-        val stream = result.stream ?: return@withContext null
-        try {
-            val json = stream.bufferedReader().use { it.readText() }
-            parseRelease(json)
-        } catch (e: Exception) {
-            println("UpdateRepository parse failure: $e")
-            null
+        // Use the GitHub releases web page instead of the REST API endpoint:
+        // the API endpoint is rate-limited to 60 requests/hour per IP, which is
+        // quickly exhausted on shared egress IPs (e.g. VPN proxies), causing 403
+        // failures. The web endpoint redirects to the latest tag with no such limit.
+        // When GitHub is unreachable (common on mainland-China networks without a
+        // proxy), fall back to community GitHub accelerator mirrors that proxy the
+        // same page; each mirror resolves the identical tag and asset URLs.
+        for (baseUrl in LATEST_RELEASE_URLS) {
+            val result = remoteSource.getNetworkStream(baseUrl)
+            val stream = result.stream ?: continue
+            val parsed = try {
+                parseRelease(stream.bufferedReader().use { it.readText() }, baseUrl)
+            } catch (e: Exception) {
+                println("UpdateRepository parse failure: $e")
+                null
+            }
+            if (parsed != null) return@withContext parsed
        }
+        null
    }

    override suspend fun downloadApk(url: String, dest: File): Boolean = withContext(Dispatchers.IO) {
@@ -37,31 +46,59 @@ class UpdateRepository(
        }
    }

-    private fun parseRelease(json: String): LatestRelease? {
-        val obj = JSONObject(json)
-        val tag = obj.optString("tag_name")
-        if (tag.isBlank()) return null
-        val assets = obj.optJSONArray("assets")
-        var apkUrl: String? = null
-        if (assets != null) {
-            for (i in 0 until assets.length()) {
-                val asset = assets.optJSONObject(i) ?: continue
-                val name = asset.optString("name", "")
-                if (name.endsWith(".apk")) {
-                    apkUrl = asset.optString("browser_download_url", "").ifBlank { null }
-                    if (apkUrl != null) break
-                }
-            }
+    private fun parseRelease(html: String, sourceUrl: String): LatestRelease? {
+        // The redirect target is the latest release's tag page. Extract the tag
+        // from the og:url meta tag ("…/releases/tag/v4.4.6-ba7opf.8") — stable and
+        // unambiguous. The <title> also holds the release name, but that is free
+        // text and cannot be used to build the asset URL.
+        val ogUrl = Regex("<meta\\s+property=\"og:url\"\\s+content=\"([^\"]*)\"").find(html)
+            ?.groupValues?.get(1) ?: return null
+        val tag = Regex("/releases/tag/(v[0-9][0-9A-Za-z.\\-]*)$").find(ogUrl)
+            ?.groupValues?.get(1) ?: return null
+        val title = Regex("<title>(.*?)</title>", RegexOption.DOT_MATCHES_ALL)
+            .find(html)?.groupValues?.get(1)?.trim()
+            ?.substringBefore("·")?.removePrefix("Release")?.trim() ?: tag
+        // Release notes live in the page's markdown-body section (first occurrence
+        // is the release description). Strip HTML tags for plain-text display.
+        val raw = Regex("<div[^>]*class=\"[^\"]*markdown-body[^\"]*\"[^>]*>(.*?)</div>", RegexOption.DOT_MATCHES_ALL)
+            .find(html)?.groupValues?.get(1) ?: ""
+        val body = raw.replace(Regex("<[^>]+>"), "")
+            .replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
+            .replace("&quot;", "\"").replace("&#39;", "'")
+            .trim()
+        // The release APK asset follows the fixed naming scheme used by the build:
+        // Look4Sat-<tag without leading v>-release.apk. When the page was fetched
+        // through an accelerator mirror (https://<mirror>/https://github.com/...),
+        // download through the same mirror — raw github.com is unreachable on the
+        // networks that needed the mirror in the first place.
+        val mirrorPrefix = sourceUrl.substringBefore("https://github.com")
+        val apkUrl = if (mirrorPrefix.isEmpty()) {
+            "$DOWNLOAD_BASE_URL/$tag/Look4Sat-${tag.removePrefix("v")}-release.apk"
+        } else {
+            "${mirrorPrefix}https://github.com/atsunatsu/Look4Sat/releases/download/$tag/Look4Sat-${tag.removePrefix("v")}-release.apk"
        }
        return LatestRelease(
            versionTag = tag,
-            title = obj.optString("name", ""),
-            body = obj.optString("body", ""),
+            title = title,
+            body = body,
            apkUrl = apkUrl
        )
    }

    private companion object {
-        const val LATEST_RELEASE_URL = "https://api.github.com/repos/atsunatsu/Look4Sat/releases/latest"
+        // Web pages are used instead of api.github.com to avoid the 60 req/hour
+        // anonymous rate limit (see getLatestRelease above). The GitHub URL is
+        // tried first; if it is unreachable (no proxy on mainland networks) the
+        // accelerator mirrors are tried in order. Download URLs always point at
+        // the mirrors too — raw github.com release downloads are equally blocked
+        // without a proxy, so a mirror-resolved tag must be downloaded via the
+        // same mirror.
+        val LATEST_RELEASE_URLS = listOf(
+            "https://github.com/atsunatsu/Look4Sat/releases/latest",
+            "https://ghfast.top/https://github.com/atsunatsu/Look4Sat/releases/latest",
+            "https://gh.llkk.cc/https://github.com/atsunatsu/Look4Sat/releases/latest",
+            "https://github.moeyy.xyz/https://github.com/atsunatsu/Look4Sat/releases/latest"
+        )
+        const val DOWNLOAD_BASE_URL = "https://github.com/atsunatsu/Look4Sat/releases/download"
    }
 }
@@ -0,0 +1,97 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.repository.IWavelogRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Fetches the list of worked gridsquares from a self-hosted Wavelog instance.
+ *
+ * Uses the Wavelog v1 API endpoint (verified against Wavelog 3.0.2):
+ *   POST {base}/index.php/api/logbook_get_worked_grids
+ *   Body: {"key": "<api key>", "logbook_id": "<logbook id>"}
+ *   Response 201: JSON array of 4-char gridsquares, e.g. ["JN47","JO30"]
+ *   (see Wavelog Api.php logbook_get_worked_grids / Api_model::get_grids_worked_in_logbook)
+ *
+ * The token field carries "<api_key>:<logbook_id>" so one credential line
+ * configures both values (the dialog explains this to the user).
+ */
+class WavelogRepository : IWavelogRepository {
+
+    override suspend fun fetchWorkedGrids(url: String, token: String): Set<String>? = withContext(Dispatchers.IO) {
+        val parts = token.trim().split(":")
+        val apiKey = parts.getOrNull(0)?.trim().orEmpty()
+        val logbookId = parts.getOrNull(1)?.trim().orEmpty()
+        if (url.isBlank() || apiKey.isBlank() || logbookId.isBlank()) return@withContext null
+        val base = url.trim().trimEnd('/')
+        val requestUrl = "$base/index.php/api/logbook_get_worked_grids"
+        try {
+            val connection = java.net.URL(requestUrl).openConnection() as java.net.HttpURLConnection
+            connection.connectTimeout = 10_000
+            connection.readTimeout = 15_000
+            connection.requestMethod = "POST"
+            connection.doOutput = true
+            connection.setRequestProperty("Content-Type", "application/json")
+            val body = JSONObject().apply {
+                put("key", apiKey)
+                put("logbook_id", logbookId)
+            }.toString().toByteArray()
+            connection.outputStream.use { it.write(body) }
+            val code = connection.responseCode
+            if (code !in 200..299) {
+                connection.disconnect()
+                return@withContext null
+            }
+            val response = connection.inputStream.bufferedReader().use { it.readText() }
+            connection.disconnect()
+            parseWorkedGrids(response)
+        } catch (e: Exception) {
+            println("WavelogRepository fetch failure: $e")
+            null
+        }
+    }
+
+    internal fun parseWorkedGrids(body: String): Set<String>? {
+        return try {
+            val array = when {
+                body.trimStart().startsWith("[") -> JSONArray(body)
+                else -> {
+                    // Tolerate {"grids": [...]} wrappers too
+                    JSONObject(body).optJSONArray("grids") ?: return null
+                }
+            }
+            val result = mutableSetOf<String>()
+            for (i in 0 until array.length()) {
+                val grid = array.optString(i, "").trim().uppercase()
+                // Keep only well-formed 4-character Maidenhead squares (e.g. OL62)
+                if (grid.length == 4 && grid[0] in 'A'..'R' && grid[1] in 'A'..'R'
+                    && grid[2] in '0'..'9' && grid[3] in '0'..'9'
+                ) {
+                    result.add(grid)
+                }
+            }
+            result
+        } catch (_: Exception) {
+            null
+        }
+    }
+}
@@ -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,131 @@
+package com.rtbishop.look4sat.core.data.repository
+
+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
+}
@@ -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()
+    }
+}
@@ -59,6 +59,7 @@ data class OtherSettings(
    val stateOfUtc: Boolean,
    val stateOfLightTheme: Boolean,
    val stateOfNightMode: Boolean = false,
+    val stateOfMapGrid: Boolean = false,
    val shouldSeeWarning: Boolean,
    val shouldSeeWhatsNew: Boolean,
    val sstvMode: String = "Auto",
@@ -76,6 +77,20 @@ data class DataSourcesSettings(
    fun isTransceiverEnabled(index: Int): Boolean = transceiversEnabled.getOrElse(index) { true }
 }

+data class WavelogSettings(
+    val url: String = "",
+    val token: String = ""
+) {
+    val isConfigured: Boolean get() = url.isNotBlank() && token.isNotBlank()
+}
+
+data class LoTWSettings(
+    val callsign: String = "",
+    val password: String = ""
+) {
+    val isConfigured: Boolean get() = callsign.isNotBlank() && password.isNotBlank()
+}
+
 data class RadioControlSettings(
    val enabled: Boolean,
    val radioModel: String,
@@ -0,0 +1,38 @@
+/*
+ * 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
+
+/** Fetches confirmed gridsquares directly from ARRL LoTW. */
+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).
+     */
+    suspend fun fetchConfirmedGrids(callsign: String, password: String): Set<String>?
+
+    /**
+     * Same report, but keeps the per-QSO detail of every confirmed satellite
+     * QSO (call / time / satellite / mode / bands), grouped by worked 4-char
+     * gridsquare. Returns null on any failure.
+     */
+    suspend fun fetchConfirmedGridQsos(
+        callsign: String,
+        password: String
+    ): Pair<Set<String>, Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>>?
+}
@@ -32,6 +32,8 @@ interface IMainContainer {
    val databaseRepo: IDatabaseRepo
    val amSatRepo: IAmSatRepository
    val updateRepo: IUpdateRepository
+    val wavelogRepo: IWavelogRepository
+    val lotwRepo: com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
    val radioTrackingService: IRadioTrackingService
    val mutualPassData: StateFlow<MutualPassData>
    fun setMutualPassData(data: MutualPassData)
@@ -23,6 +23,7 @@ import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
 import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import kotlinx.coroutines.flow.StateFlow

@@ -92,4 +93,19 @@ interface ISettingsRepo {
    fun getAmSatCallsign(): String
    fun setAmSatCallsign(callsign: String)
    //endregion
+
+    //region # Wavelog worked-grids settings
+    val wavelogSettings: StateFlow<WavelogSettings>
+    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
+    val lotwSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings>
+    fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings)
+    //endregion
 }
@@ -0,0 +1,28 @@
+/*
+ * 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
+
+/** Fetches worked gridsquares from a self-hosted Wavelog instance (API v2). */
+interface IWavelogRepository {
+
+    /**
+     * Fetch worked grids for the configured Wavelog URL/token.
+     * Returns the grid set, or null on any failure.
+     */
+    suspend fun fetchWorkedGrids(url: String, token: String): Set<String>?
+}
@@ -19,6 +19,8 @@ package com.rtbishop.look4sat.core.domain.source

 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",
        "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",
@@ -46,7 +48,6 @@ object Sources {
        "Amsat" to "https://amsat.org/tle/current/nasabare.txt",
        "Classified" to "https://www.mmccants.org/tles/classfd.zip",
        "McCants" to "https://www.mmccants.org/tles/inttles.zip",
-        "R4UAB" to "https://r4uab.ru/satonline.txt",
        "ARISS" to "https://live.ariss.org/iss.txt",
        "Other" to "" // key for sats filter
    )
@@ -2,11 +2,12 @@ package com.rtbishop.look4sat.core.domain.utility

 /**
 * Compares two version strings of the form "<major>.<minor>.<patch>[-<build>]" used by the
- * BA7OPF fork releases (e.g. "4.4.6-ba7opf.6" or "v4.4.6-ba7opf.7").
+ * BA7OPF fork releases (e.g. "4.4.6-ba7opf.6" or "v4.4.6-ba7opf.9.1").
 *
 * The comparison is done on the numeric version segments first; when the base versions are
- * equal, the trailing build number (if any) decides. This lets a "4.4.6-ba7opf.7" release be
- * detected as newer than "4.4.6-ba7opf.6" while "4.5.0" trumps any "4.4.x" build.
+ * equal, the trailing build numbers of the suffix decide. All numeric segments of the suffix
+ * are compared as a sequence, so multi-level suffixes work correctly:
+ * "4.4.6-ba7opf.9.1" > "4.4.6-ba7opf.9" > "4.4.6-ba7opf.8".
 */
 object VersionComparator {

@@ -20,25 +21,28 @@ object VersionComparator {
            val k = curr.first.getOrElse(i) { 0 }
            if (c != k) return c > k
        }
-        return cand.second > curr.second
+        val maxBuild = maxOf(cand.second.size, curr.second.size)
+        for (i in 0 until maxBuild) {
+            val c = cand.second.getOrElse(i) { 0 }
+            val k = curr.second.getOrElse(i) { 0 }
+            if (c != k) return c > k
+        }
+        return false
    }

    /**
-     * Parses a version string into (numeric base segments, trailing build number).
-     * "v4.4.6-ba7opf.7" -> ([4,4,6], 7); "4.4.6" -> ([4,4,6], 0); "4.4.6-ba7opf" -> ([4,4,6], 0).
+     * Parses a version string into (numeric base segments, numeric suffix segments).
+     * "v4.4.6-ba7opf.9.1" -> ([4,4,6], [9,1]); "4.4.6-ba7opf.8" -> ([4,4,6], [8]);
+     * "4.4.6" -> ([4,4,6], []); "4.4.6-ba7opf" -> ([4,4,6], []).
     */
-    fun parse(version: String): Pair<List<Int>, Int> {
+    fun parse(version: String): Pair<List<Int>, List<Int>> {
        val cleaned = version.trim().removePrefix("v")
        val dashIndex = cleaned.indexOf('-')
        val basePart = if (dashIndex >= 0) cleaned.substring(0, dashIndex) else cleaned
        val suffixPart = if (dashIndex >= 0) cleaned.substring(dashIndex + 1) else ""
        val base = basePart.split('.').mapNotNull { it.toIntOrNull() }
-        // The build number is the trailing numeric segment of the suffix (e.g. "ba7opf.7" -> 7).
-        val build = suffixPart
-            .split('.')
-            .lastOrNull()
-            ?.toIntOrNull()
-            ?: 0
+        // All numeric segments of the suffix, in order (e.g. "ba7opf.9.1" -> [9, 1]).
+        val build = suffixPart.split('.').mapNotNull { it.toIntOrNull() }
        return base to build
    }
 }
@@ -40,9 +40,19 @@ class VersionComparatorTest {
    }

    @Test
-    fun `parse extracts base and build number`() {
-        assertEquals(listOf(4, 4, 6) to 7, VersionComparator.parse("v4.4.6-ba7opf.7"))
-        assertEquals(listOf(4, 4, 6) to 0, VersionComparator.parse("4.4.6"))
-        assertEquals(listOf(4, 4, 6) to 0, VersionComparator.parse("4.4.6-ba7opf"))
+    fun `multi level suffixes compare correctly`() {
+        // The .9.1 hotfix case that exposed the old single-build-number logic.
+        assertTrue(VersionComparator.isNewer("4.4.6-ba7opf.9.1", "4.4.6-ba7opf.9"))
+        assertTrue(VersionComparator.isNewer("v4.4.6-ba7opf.9.1", "4.4.6-ba7opf.8"))
+        assertFalse(VersionComparator.isNewer("4.4.6-ba7opf.9", "4.4.6-ba7opf.9.1"))
+        assertTrue(VersionComparator.isNewer("4.4.6-ba7opf.10", "4.4.6-ba7opf.9.1"))
+    }
+
+    @Test
+    fun `parse extracts base and suffix segments`() {
+        assertEquals(listOf(4, 4, 6) to listOf(7), VersionComparator.parse("v4.4.6-ba7opf.7"))
+        assertEquals(listOf(4, 4, 6) to listOf(9, 1), VersionComparator.parse("v4.4.6-ba7opf.9.1"))
+        assertEquals(listOf(4, 4, 6) to emptyList<Int>(), VersionComparator.parse("4.4.6"))
+        assertEquals(listOf(4, 4, 6) to emptyList<Int>(), VersionComparator.parse("4.4.6-ba7opf"))
    }
 }
@@ -210,12 +210,20 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
 }

@Composable
-fun CardButton(onClick: () -> Unit, text: String, modifier: Modifier = Modifier) {
+fun CardButton(
+    onClick: () -> Unit,
+    text: String,
+    modifier: Modifier = Modifier,
+    isEnabled: Boolean = true
+) {
    ElevatedButton(
        onClick = onClick,
+        enabled = isEnabled,
        colors = ButtonDefaults.buttonColors(
            containerColor = MaterialTheme.colorScheme.surfaceVariant,
-            contentColor = MaterialTheme.colorScheme.onSurfaceVariant
+            contentColor = MaterialTheme.colorScheme.onSurfaceVariant,
+            disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+            disabledContentColor = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f)
        ),
        shape = MaterialTheme.shapes.small,
        modifier = modifier,
@@ -316,9 +324,21 @@ fun InfoDialog(

@Composable
 fun SharedDialog(
-    title: String, onCancel: () -> Unit, onAccept: () -> Unit, content: @Composable () -> Unit
+    title: String,
+    onCancel: () -> Unit,
+    onAccept: () -> Unit,
+    acceptText: String? = null,
+    acceptEnabled: Boolean = true,
+    content: @Composable () -> Unit
 ) {
-    SharedDialog(title = title, onDismissRequest = onCancel, onCancel = onCancel, onAccept = onAccept) { _ ->
+    SharedDialog(
+        title = title,
+        onDismissRequest = onCancel,
+        onCancel = onCancel,
+        onAccept = onAccept,
+        acceptText = acceptText,
+        acceptEnabled = acceptEnabled
+    ) { _ ->
        content()
    }
 }
@@ -329,6 +349,8 @@ fun SharedDialog(
    onDismissRequest: () -> Unit,
    onCancel: (() -> Unit)? = null,
    onAccept: (() -> Unit)? = null,
+    acceptText: String? = null,
+    acceptEnabled: Boolean = true,
    titleFontSize: Int = 16,
    titleTextAlign: TextAlign = if (onCancel != null && onAccept != null) TextAlign.Center else TextAlign.Start,
    content: @Composable (padding: Dp) -> Unit
@@ -356,7 +378,11 @@ fun SharedDialog(
                    .padding(horizontal = if (onCancel != null && onAccept != null) padding else 0.dp)
            )
            if (onAccept != null) {
-                CardButton(onClick = onAccept, text = stringResource(R.string.btn_accept))
+                CardButton(
+                    onClick = onAccept,
+                    text = acceptText ?: stringResource(R.string.btn_accept),
+                    isEnabled = acceptEnabled
+                )
            }
        }
        content(padding)
@@ -0,0 +1,142 @@
+package com.rtbishop.look4sat.core.presentation
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.rotate
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+/**
+ * Format a Maidenhead locator for display. Per IARU convention and the user's
+ * preference: field letters (1-2) and square digits (3-4) uppercase, sub-square
+ * letters (5-6 of a 6/8-char locator) lowercase, e.g. "OL62" / "OL62kl".
+ */
+fun formatGridDisplay(grid: String): String? {
+    val g = grid.trim().uppercase()
+    if (g.length !in listOf(4, 6, 8) || g.any { !it.isLetterOrDigit() }) return null
+    if (g.length == 4) return g
+    if (g.length == 6) return g.take(4) + g.drop(4).lowercase()
+    return g.take(4) + g.drop(4).take(2).lowercase() + g.drop(6)
+}
+
+/**
+ * Top-bar chip for the mutual-match screen: navigation needle (rotated by the
+ * great-circle bearing to the target grid, 0 deg = north), grid locator and
+ * distance. Shows a dimmed placeholder when no target grid is entered.
+ */
+@Composable
+fun GridTargetChip(
+    grid: String?,
+    distanceKm: Double?,
+    bearingDeg: Double?,
+    modifier: Modifier = Modifier
+) {
+    val configured = grid != null && distanceKm != null && bearingDeg != null
+    // The app's signature accent yellow (MaterialTheme primary in both themes).
+    val accent = MaterialTheme.colorScheme.primary
+    val placeholder = MaterialTheme.colorScheme.onSurfaceVariant
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        modifier = modifier
+            .height(36.dp)
+            .background(
+                color = MaterialTheme.colorScheme.surface.copy(alpha = if (configured) 0.9f else 0.45f),
+                shape = RoundedCornerShape(12.dp)
+            )
+            .padding(horizontal = 12.dp)
+    ) {
+        NavigationNeedle(
+            bearingDeg = bearingDeg ?: 0.0,
+            color = if (configured) accent else placeholder,
+            dimmed = !configured,
+            modifier = Modifier.size(22.dp)
+        )
+        Text(
+            text = grid?.let { formatGridDisplay(it) } ?: "----",
+            fontSize = 15.sp,
+            fontWeight = FontWeight.Bold,
+            fontFamily = FontFamily.Monospace,
+            color = if (configured) accent else placeholder,
+            letterSpacing = 1.sp
+        )
+        Text(
+            text = distanceKm?.let { "${"%,.0f".format(it)} km" } ?: "-- km",
+            fontSize = 14.sp,
+            color = MaterialTheme.colorScheme.onSurface,
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 2.dp)
+        )
+    }
+}
+
+/**
+ * Map-style navigation needle: slim triangular pointer whose tip points at
+ * [bearingDeg] (0 = north/up, clockwise positive).
+ */
+@Composable
+private fun NavigationNeedle(
+    bearingDeg: Double,
+    color: Color,
+    dimmed: Boolean,
+    modifier: Modifier = Modifier
+) {
+    Canvas(modifier = modifier) {
+        val cx = size.width / 2f
+        val cy = size.height / 2f
+        val r = size.minDimension / 2f
+        if (dimmed) {
+            drawCircle(color = color, radius = r * 0.92f, style = Stroke(width = 1.5f))
+        }
+        rotate(degrees = bearingDeg.toFloat(), pivot = Offset(cx, cy)) {
+            val path = Path().apply {
+                moveTo(cx, cy - r * 0.9f)          // tip (north before rotation)
+                lineTo(cx - r * 0.42f, cy + r * 0.55f)
+                lineTo(cx, cy + r * 0.28f)
+                lineTo(cx + r * 0.42f, cy + r * 0.55f)
+                close()
+            }
+            drawPath(path, color = color)
+        }
+    }
+}
+
+/** Great-circle distance in km between two positions. */
+fun greatCircleDistanceKm(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
+    val rad = Math.PI / 180.0
+    val dLat = (lat2 - lat1) * rad
+    val dLon = (lon2 - lon1) * rad
+    val a = sin(dLat / 2) * sin(dLat / 2) +
+        cos(lat1 * rad) * cos(lat2 * rad) * sin(dLon / 2) * sin(dLon / 2)
+    return 6371.0 * 2 * kotlin.math.atan2(kotlin.math.sqrt(a), kotlin.math.sqrt(1 - a))
+}
+
+/** Initial great-circle bearing in degrees (0 = north, clockwise). */
+fun greatCircleBearingDeg(lat1: Double, lon1: Double, lat2: Double, lon2: Double): Double {
+    val rad = Math.PI / 180.0
+    val dLon = (lon2 - lon1) * rad
+    val y = sin(dLon) * cos(lat2 * rad)
+    val x = cos(lat1 * rad) * sin(lat2 * rad) -
+        sin(lat1 * rad) * cos(lat2 * rad) * cos(dLon)
+    return (Math.atan2(y, x) / rad + 360.0) % 360.0
+}
@@ -150,6 +150,7 @@
    <string name="prefs_other_switch_sweep">Habilitar animaciones radar</string>
    <string name="prefs_other_switch_sensors">Usar sensores para rotar vista de radar</string>
    <string name="prefs_other_switch_night_mode">Activar filtro nocturno rojo</string>
+    <string name="prefs_other_switch_map_grid">Mostrar cuadrícula Maidenhead en el mapa</string>

    <string name="prefs_highlight_title">Resaltado de elevación</string>
    <string name="prefs_highlight_low">Baja &lt; %1$d°</string>
@@ -149,6 +149,7 @@
    <string name="prefs_other_switch_sweep">Показывать анимацию радара</string>
    <string name="prefs_other_switch_sensors">Использовать сенсоры устройства</string>
    <string name="prefs_other_switch_night_mode">Включить красный ночной фильтр</string>
+    <string name="prefs_other_switch_map_grid">Показывать сетку Maidenhead на карте</string>

    <string name="prefs_highlight_title">Подсветка высоты</string>
    <string name="prefs_highlight_low">Низко &lt; %1$d°</string>
@@ -150,6 +150,7 @@
    <string name="prefs_other_switch_sweep">radar sweep සජීවිකරණය සබල කරන්න</string>
    <string name="prefs_other_switch_sensors">Radar දර්ශනය කරකැවීමට සංවේදක භාවිතා කරන්න </string>
    <string name="prefs_other_switch_night_mode">රතු රාත්‍රී පෙරහන සබල කරන්න</string>
+    <string name="prefs_other_switch_map_grid">සිතියමේ Maidenhead ජාලකය පෙන්වන්න</string>

    <string name="prefs_highlight_title">උස් උද්දීපනය</string>
    <string name="prefs_highlight_low">අඩු &lt; %1$d°</string>
@@ -192,6 +192,7 @@
    <string name="prefs_other_switch_sweep">Radar taramasını etkinleştir</string>
    <string name="prefs_other_switch_sensors">Radar görünümünü döndürmek için sensörleri kullan</string>
    <string name="prefs_other_switch_night_mode">Kırmızı gece filtresini etkinleştir</string>
+    <string name="prefs_other_switch_map_grid">Haritada Maidenhead ızgarasını göster</string>

    <string name="prefs_highlight_title">Elevasyon vurgusu</string>
    <string name="prefs_highlight_low">Düşük &lt; %1$d°</string>
@@ -150,6 +150,7 @@
    <string name="prefs_other_switch_sweep">Показувати анімацію радара</string>
    <string name="prefs_other_switch_sensors">Використовувати сенсори пристрою</string>
    <string name="prefs_other_switch_night_mode">Увімкнути червоний нічний фільтр</string>
+    <string name="prefs_other_switch_map_grid">Показувати сітку Maidenhead на мапі</string>

    <string name="prefs_highlight_title">Підсвічування висоти</string>
    <string name="prefs_highlight_low">Низько &lt; %1$d°</string>
@@ -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 -->
@@ -139,6 +143,23 @@
    <string name="prefs_station_lat_text">输入站点的纬度</string>
    <string name="prefs_station_lon_text">输入站点的经度</string>
    <string name="prefs_locator_title">QTH 网格</string>
+    <string name="prefs_wavelog_title">Wavelog 已通联网格</string>
+    <string name="prefs_wavelog_configure">配置</string>
+    <string name="prefs_wavelog_configured">已从 Wavelog 同步 — 通联 %1$d 个网格</string>
+    <string name="prefs_wavelog_not_configured">未配置 — 连接你的 Wavelog 日志以在地图上高亮已通联网格</string>
+    <string name="prefs_wavelog_url">Wavelog 地址</string>
+    <string name="prefs_wavelog_token">API key ：日志 ID</string>
+    <string name="prefs_wavelog_hint">已同步网格数：%1$d。格式：API key:日志ID。填好直接点同步，会自动保存并拉取。</string>
+    <string name="prefs_wavelog_sync">立即同步</string>
+    <string name="prefs_wavelog_syncing">同步中…</string>
+    <string name="prefs_lotw_title">LoTW 已确认网格</string>
+    <string name="prefs_lotw_callsign">LoTW 呼号</string>
+    <string name="prefs_lotw_password">LoTW 密码</string>
+    <string name="prefs_lotw_hint">直接从 ARRL LoTW 拉取该呼号已确认 QSO 的网格并覆盖本地已存集合（当前 %1$d 个）。密码仅保存在手机本地。点"同步"会自动保存凭据并拉取。</string>
+    <string name="prefs_lotw_sync">同步</string>
+    <string name="prefs_lotw_syncing">同步中…</string>
+    <string name="prefs_lotw_configured">已从 LoTW 同步 — 共 %1$d 个网格</string>
+    <string name="prefs_lotw_not_configured">未配置 — 直接登录 ARRL LoTW 拉取已确认 QSO 的网格，无需自建服务器</string>
    <string name="prefs_locator_text">使用梅登黑德网格设置站点位置</string>

    <string name="prefs_data_title">卫星数据更新</string>
@@ -202,6 +223,7 @@
    <string name="prefs_other_switch_sweep">启用雷达扫描动画</string>
    <string name="prefs_other_switch_sensors">使用传感器旋转雷达视图</string>
    <string name="prefs_other_switch_night_mode">启用红色夜间模式</string>
+    <string name="prefs_other_switch_map_grid">地图显示 Maidenhead 网格</string>

    <string name="prefs_highlight_title">仰角高亮</string>
    <string name="prefs_highlight_low">低 &lt; %1$d°</string>
@@ -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 -->
@@ -174,6 +178,23 @@
    <string name="prefs_station_lat_text">Set your ground station\'s latitude</string>
    <string name="prefs_station_lon_text">Set your ground station\'s longitude</string>
    <string name="prefs_locator_title">QTH locator settings</string>
+    <string name="prefs_wavelog_title">Wavelog worked grids</string>
+    <string name="prefs_wavelog_configure">Configure</string>
+    <string name="prefs_wavelog_configured">Synced from Wavelog — %1$d grids worked</string>
+    <string name="prefs_wavelog_not_configured">Not configured — connect your Wavelog logbook to highlight worked grids on the map</string>
+    <string name="prefs_wavelog_url">Wavelog URL</string>
+    <string name="prefs_wavelog_token">API key : logbook ID</string>
+    <string name="prefs_wavelog_hint">Worked grids synced: %1$d. Format: API key, colon, logbook ID. Just tap Sync — credentials are saved automatically.</string>
+    <string name="prefs_wavelog_sync">Sync now</string>
+    <string name="prefs_wavelog_syncing">Syncing…</string>
+    <string name="prefs_lotw_title">LoTW confirmed grids</string>
+    <string name="prefs_lotw_callsign">LoTW callsign</string>
+    <string name="prefs_lotw_password">LoTW password</string>
+    <string name="prefs_lotw_hint">Fetch confirmed-QSO grids directly from ARRL LoTW for this callsign and replace the stored set (currently %1$d). The password is stored on this device only. Tapping Sync saves the credentials and fetches in one step.</string>
+    <string name="prefs_lotw_sync">Sync</string>
+    <string name="prefs_lotw_syncing">Syncing…</string>
+    <string name="prefs_lotw_configured">Synced from LoTW — %1$d grids total</string>
+    <string name="prefs_lotw_not_configured">Not configured — pull confirmed grids directly from ARRL LoTW, no self-hosted server needed</string>
    <string name="prefs_locator_text">Set station\'s position using locator</string>

    <string name="prefs_data_title">Satellite data</string>
@@ -236,6 +257,7 @@
    <string name="prefs_other_switch_sweep">Enable radar sweep animation</string>
    <string name="prefs_other_switch_sensors">Use sensors to rotate radar view</string>
    <string name="prefs_other_switch_night_mode">Enable red night mode filter</string>
+    <string name="prefs_other_switch_map_grid">Show Maidenhead grid on map</string>

    <string name="prefs_highlight_title">Elevation highlight</string>
    <string name="prefs_highlight_low">Low &lt; %1$d°</string>
@@ -0,0 +1,337 @@
+/*
+ * 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.map
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import org.osmdroid.views.MapView
+import org.osmdroid.views.Projection
+import org.osmdroid.views.overlay.Overlay
+import kotlin.math.ceil
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Maidenhead locator grid overlay, drawn directly on the map canvas.
+ *
+ * Zoom levels (map maxZoom = 7):
+ *  - zoom < GRID_ZOOM_SUB: 10° x 20° fields with 2-character labels (e.g. "PM")
+ *  - zoom >= GRID_ZOOM_SUB: 1° x 2° squares with 4-character labels (e.g. "PM95")
+ *
+ * All geometry is computed per-frame from the projection, so the overlay
+ * stays correct while panning/zooming. Grid lines that cross the antimeridian
+ * are drawn in segments clamped to the visible bounding box.
+ */
+class MaidenheadGridOverlay : Overlay() {
+
+    private val linePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        strokeWidth = 1.5f
+        style = Paint.Style.STROKE
+        color = Color.argb(160, 255, 224, 130)
+    }
+    private val labelPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        textSize = 26f
+        style = android.graphics.Paint.Style.FILL
+        color = Color.argb(220, 255, 224, 130)
+        setShadowLayer(3f, 2f, 2f, Color.BLACK)
+    }
+    private val workedPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = android.graphics.Paint.Style.FILL
+        color = Color.argb(90, 76, 217, 100)
+    }
+    private val ownLinePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        strokeWidth = 4.5f
+        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()
+
+    /** 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
+
+    override fun draw(canvas: Canvas, mapView: MapView, shadow: Boolean) {
+        if (shadow || !isEnabled) return
+        val projection = mapView.projection
+        val zoom = mapView.zoomLevelDouble
+        canvasWidthPx = canvas.width.toFloat()
+        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
+        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)
+        // Longitude: osmdroid normalizes to [-180, 180), so when the view
+        // straddles the antimeridian (e.g. left edge 170°E, right edge 170°W)
+        // the raw min/max swap sides and the bounding box spans the wrong way
+        // (center on the Pacific → grid painted 180° off-screen). Unwrap by
+        // shifting one edge by +360° so left < right again.
+        var lonA = north.longitude
+        var lonB = south.longitude
+        if (lonA > lonB) {
+            val t = lonA; lonA = lonB; lonB = t
+        }
+        if (lonB - lonA > 180.0) lonA += 360.0
+        val leftLon = lonA
+        val rightLon = lonB
+
+        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)
+        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.
+        //  - Field zoom (two-char labels): do NOT fill whole fields; instead fill
+        //    the individual 2°x1° squares that were worked, without drawing the
+        //    square grid lines — so you see green patches inside the field.
+        if (workedGrids.isNotEmpty()) {
+            if (zoom >= GRID_ZOOM_SUB) {
+                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)
+                    val yBottom = projectionToY(projection, lat)
+                    if (yTop == null || yBottom == null) continue
+                    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
+                        if (cellLabel(lat, lon, zoom) in workedGrids) {
+                            canvas.drawRect(xLeft, yTop, xRight, yBottom, workedPaint)
+                        }
+                    }
+                }
+            } else {
+                for (grid in workedGrids) {
+                    val cell = gridCellBounds(grid) ?: continue
+                    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 (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)
+        }
+        // Horizontal lines (parallels)
+        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)
+        }
+
+        // The station's own grid square: redraw its four borders thicker on top.
+        // 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 firstCol..lastCol) {
+                    val lon = col * cellLon
+                    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
+                    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).
+        // 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.
+        val y1 = projectionToY(projection, 0.0)
+        val y2 = projectionToY(projection, 1.0)
+        if (y1 == null || y2 == null) return
+        val pixelsPerDegree = Math.abs(y2 - y1)
+        if (pixelsPerDegree * cellLat < MIN_LABEL_CELL_PX) return
+
+        labelPaint.textAlign = Paint.Align.CENTER
+        val fontMetrics = labelPaint.fontMetrics
+        val textHalfHeight = (fontMetrics.descent + fontMetrics.ascent) / 2f
+        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
+            val yCenter = (yTop + yBottom) / 2f - textHalfHeight
+            if (yBottom < 0f || yTop > canvas.height) continue
+            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
+                val label = cellLabel(lat, lon, zoom)
+                canvas.drawText(label, (xLeft + xRight) / 2f, yCenter, labelPaint)
+            }
+        }
+    }
+
+    /** X pixel for a longitude (meridians are vertical in Web Mercator). */
+    private fun projectionToX(projection: Projection, lon: Double, centerLon: Double, worldWidthPx: Double): Float? {
+        // Do NOT use osmdroid's toPixels() here: at low zoom its wrap-around
+        // logic (getCloserPixel) mis-projects longitudes far from the view
+        // center, which makes meridians vanish while panning. Mercator X is
+        // linear in longitude, so compute it directly:
+        //   x = screenCenterX + (lon - centerLon) / 360 * worldWidthPx
+        var delta = lon - centerLon
+        while (delta > 180.0) delta -= 360.0
+        while (delta < -180.0) delta += 360.0
+        val geo = org.osmdroid.util.GeoPoint(0.0, centerLon)
+        val p = projection.toPixels(geo, null)
+        return (p.x + delta / 360.0 * worldWidthPx).toFloat()
+    }
+
+    /** Y pixel for a latitude, or null when outside the viewport. */
+    private fun projectionToY(projection: Projection, lat: Double): Float? {
+        val geo = org.osmdroid.util.GeoPoint(lat, 0.0)
+        val p = projection.toPixels(geo, null)
+        return p.y.toFloat()
+    }
+
+    private fun cellLabel(lat: Double, lon: Double, zoom: Double): String {
+        // Maidenhead field: longitude 20° fields A-R starting at -180,
+        // latitude 10° fields A-R starting at -90.
+        val lonNorm = normalizeLon(lon)
+        val latNorm = lat.coerceIn(-90.0, 89.999)
+        val fieldLon = ((lonNorm + 180.0) / FIELD_LON).toInt()
+        val fieldLat = ((latNorm + 90.0) / FIELD_LAT).toInt()
+        val field = "${'A' + fieldLon}${'A' + fieldLat}"
+        if (zoom < GRID_ZOOM_SUB) return field
+        // Square: 2° x 1° digits
+        val squareLon = (((lonNorm + 180.0) % FIELD_LON) / SUB_SQUARE_LON).toInt()
+        val squareLat = (((latNorm + 90.0) % FIELD_LAT) / SUB_SQUARE_LAT).toInt()
+        return "$field$squareLon$squareLat"
+    }
+
+    /**
+     * Geographic bounds of a 4-char Maidenhead square (e.g. "OL62"):
+     * 2° wide in longitude, 1° tall in latitude.
+     */
+    private fun gridCellBounds(grid: String): CellBounds? {
+        val g = grid.trim().uppercase()
+        if (g.length < 4) return null
+        val fieldLon = g[0] - 'A'
+        val fieldLat = g[1] - 'A'
+        val sqLon = g[2] - '0'
+        val sqLat = g[3] - '0'
+        if (fieldLon !in 0..17 || fieldLat !in 0..17 || sqLon !in 0..9 || sqLat !in 0..9) return null
+        val lonLeft = -180.0 + fieldLon * FIELD_LON + sqLon * SUB_SQUARE_LON
+        val latBottom = -90.0 + fieldLat * FIELD_LAT + sqLat * SUB_SQUARE_LAT
+        return CellBounds(lonLeft, lonLeft + SUB_SQUARE_LON, latBottom, latBottom + SUB_SQUARE_LAT)
+    }
+
+    private data class CellBounds(
+        val lonLeft: Double,
+        val lonRight: Double,
+        val latBottom: Double,
+        val latTop: Double
+    )
+
+    private fun normalizeLon(lon: Double): Double {
+        var l = lon % 360.0
+        if (l >= 180.0) l -= 360.0
+        if (l < -180.0) l += 360.0
+        return l
+    }
+
+    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
+        // 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
@@ -42,7 +46,9 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.rotate
@@ -80,14 +86,15 @@ import org.osmdroid.views.overlay.Marker
 import org.osmdroid.views.overlay.Polyline

 // Overlay indices
-private const val OVERLAY_STATION = 0
-private const val OVERLAY_TRACK = 1
-private const val OVERLAY_FOOTPRINT = 2
-private const val OVERLAY_POSITIONS = 3
-private const val OVERLAY_TERMINATOR = 4
-private const val OVERLAY_SUN = 5
-private const val OVERLAY_MOON = 6
-private const val OVERLAY_COUNT = 7
+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 val minLat = MapView.getTileSystem().minLatitude
 private val maxLat = MapView.getTileSystem().maxLatitude
@@ -135,7 +142,41 @@ 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
+        // track update, so skip the tracking animation entirely.
+        if (uiState.isGridMode) return@LaunchedEffect
        val firstPos = uiState.track?.firstOrNull()?.firstOrNull() ?: return@LaunchedEffect
        mapView.controller.animateTo(GeoPoint(firstPos.latitude, firstPos.longitude))
    }
@@ -158,24 +199,190 @@ private fun MapScreen(uiState: MapState, onAction: (MapAction) -> Unit, mapView:
        }
        ElevatedCard(modifier = Modifier.weight(1f)) {
            Box(contentAlignment = Alignment.BottomCenter) {
+                // Track grid-mode transitions; initial value false so that entering
+                // the map page with grid mode already ON also centers the map.
+                var prevGridMode by remember { mutableStateOf(false) }
                AndroidView({ mapView }) { view ->
-                    uiState.stationPosition?.let { setStationPosition(it, view) }
-                    uiState.track?.let { setSatelliteTrack(it, view) }
-                    uiState.footprint?.let { setFootprint(it, view) }
-                    uiState.positions?.let { setPositions(it, view) { item -> onAction(MapAction.SelectItem(item)) } }
-                    setTerminator(uiState.sunLatDeg, uiState.sunLonDeg, view)
-                    setSubSolarPoint(uiState.sunLatDeg, uiState.sunLonDeg, view)
-                    setMoonPosition(uiState.moonLatDeg, uiState.moonLonDeg, view)
+                    // Center on the station grid whenever entering grid mode.
+                    // Only mark the transition as consumed once a real position
+                    // was available; otherwise a first frame with a null
+                    // stationPosition would swallow the centering forever.
+                    val shouldCenter = uiState.isGridMode && !prevGridMode
+                    setGridMode(
+                        uiState.isGridMode, uiState.workedGrids, view,
+                        if (shouldCenter) uiState.stationPosition else null
+                    )
+                    if (!shouldCenter || uiState.stationPosition != null) {
+                        prevGridMode = uiState.isGridMode
+                    }
+                    if (!uiState.isGridMode) {
+                        uiState.stationPosition?.let { setStationPosition(it, view) }
+                        uiState.track?.let { setSatelliteTrack(it, view) }
+                        uiState.footprint?.let { setFootprint(it, view) }
+                        uiState.positions?.let { setPositions(it, view) { item -> onAction(MapAction.SelectItem(item)) } }
+                        setTerminator(uiState.sunLatDeg, uiState.sunLonDeg, view)
+                        setSubSolarPoint(uiState.sunLatDeg, uiState.sunLonDeg, view)
+                        setMoonPosition(uiState.moonLatDeg, uiState.moonLonDeg, view)
+                    }
                    view.invalidate()
                }
                uiState.mapData?.let { mapData ->
-                    if (isVertical) MapDataCard(mapData) else MapDataCards(mapData)
+                    if (!uiState.isGridMode) {
+                        if (isVertical) MapDataCard(mapData) else MapDataCards(mapData)
+                    }
+                }
+            }
+        }
+    }
+    // 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) {
@@ -261,6 +468,75 @@ private fun MapDataCards(data: MapData) {
 // endregion

 // region Map overlay helpers
+
+/** Toggle the grid-mode layer visibility on/off without recreating any overlay. */
+private fun setGridMode(
+    gridMode: Boolean,
+    workedGrids: Set<String>,
+    mapView: MapView,
+    stationPosition: GeoPos?
+) {
+    try {
+        val gridOverlay = mapView.overlays[OVERLAY_GRID]
+        if (gridOverlay is MaidenheadGridOverlay) {
+            gridOverlay.isEnabled = gridMode
+            gridOverlay.workedGrids = workedGrids
+            gridOverlay.ownGrid = ownGridOf(stationPosition)
+        } else {
+            mapView.overlays[OVERLAY_GRID] = MaidenheadGridOverlay().apply {
+                isEnabled = gridMode
+                this.workedGrids = workedGrids
+                this.ownGrid = ownGridOf(stationPosition)
+            }
+        }
+        // Satellite-related layers are hidden in grid mode; the grid overlay
+        // itself is controlled by its own enabled flag.
+        for (index in OVERLAY_STATION..OVERLAY_MOON) {
+            mapView.overlays.getOrNull(index)?.isEnabled = !gridMode
+        }
+        // Entering grid mode: center on the station's current grid square,
+        // 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
+            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.post { mapView.controller.setCenter(GeoPoint(centerLat, centerLon)) }
+        }
+    } catch (e: Exception) {
+        println(e)
+    }
+}
+
+/** The station's 4-char Maidenhead gridsquare, e.g. "OL62", or null without a position. */
+private fun ownGridOf(stationPosition: GeoPos?): String? {
+    val pos = stationPosition ?: return null
+    val lat = pos.latitude
+    val lon = pos.longitude
+    val fieldLat = ((lat + 90.0) / 10.0).toInt().coerceIn(0, 17)
+    val fieldLon = ((lon + 180.0) / 20.0).toInt().coerceIn(0, 17)
+    val subLat = ((lat + 90.0) % 10.0).toInt()
+    val subLon = ((lon + 180.0) % 20.0 / 2.0).toInt()
+    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]
@@ -500,6 +776,7 @@ private fun rememberMapViewWithLifecycle(): MapView {
            overlayManager.tilesOverlay.setColorFilter(createColorFilter())
            setScrollableAreaLimitLatitude(maxLat, minLat, 0)
            overlays.addAll(Array(OVERLAY_COUNT) { FolderOverlay() })
+            overlays[OVERLAY_GRID] = MaidenheadGridOverlay()
        }
    }
    val lifecycleObserver = rememberMapViewLifecycleObserver(mapView)
@@ -26,6 +26,9 @@ data class MapState(
    val mapData: MapData? = null,
    val isLightUi: Boolean = false,
    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,
@@ -74,11 +74,22 @@ class MapViewModel(
    init {
        viewModelScope.launch {
            settingsRepo.otherSettings.collectLatest { settings ->
-                _uiState.update { it.copy(isUtc = settings.stateOfUtc) }
+                _uiState.update { it.copy(isUtc = settings.stateOfUtc, isGridMode = settings.stateOfMapGrid) }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.wavelogSettings.collectLatest { _ ->
+                _uiState.update {
+                    it.copy(
+                        workedGrids = settingsRepo.getWorkedGrids(),
+                        workedGridQsos = settingsRepo.getWorkedGridQsos()
+                    )
+                }
            }
        }
        val (selectedCatNum, _) = satelliteRepo.selectedPass.value
        selectDefaultSatellite(if (selectedCatNum != 0) selectedCatNum else -1)
+        getStationPosition()
    }

    fun onAction(action: MapAction) {
@@ -63,6 +63,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.repository.TrackSampleData
+import com.rtbishop.look4sat.core.presentation.GridTargetChip
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.ScreenColumn
 import com.rtbishop.look4sat.core.presentation.TopBar
@@ -88,7 +89,8 @@ fun MutualScreen(
                    Text(
                        text = stringResource(R.string.mutual_title),
                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
+                        fontWeight = FontWeight.Bold,
+                        modifier = Modifier.padding(start = 12.dp)
                    )
                },
                bottomInfo = {
@@ -98,7 +100,9 @@ fun MutualScreen(
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        maxLines = 1,
                        overflow = TextOverflow.Ellipsis,
-                        modifier = Modifier.weight(1f)
+                        modifier = Modifier
+                            .weight(1f)
+                            .padding(start = 12.dp)
                    )
                },
                endAction = {
@@ -114,7 +118,29 @@ fun MutualScreen(
                                strokeWidth = 2.dp
                            )
                        }
-                        MutualStatusChip(state)
+                        // Target-grid chip: station B grid (station A defaults to
+                        // the user's own position), bearing/distance from A to B.
+                        val gridB = state.stationBGrid.trim().uppercase()
+                        val posA = com.rtbishop.look4sat.core.domain.utility.qthToPosition(state.stationAGrid)
+                            ?: state.stationALat.toDoubleOrNull()?.let { lat ->
+                                state.stationALon.toDoubleOrNull()?.let { lon ->
+                                    com.rtbishop.look4sat.core.domain.predict.GeoPos(lat, lon)
+                                }
+                            }
+                        val posB = com.rtbishop.look4sat.core.domain.utility.qthToPosition(gridB)
+                        if (posA != null && posB != null) {
+                            GridTargetChip(
+                                grid = gridB,
+                                distanceKm = com.rtbishop.look4sat.core.presentation.greatCircleDistanceKm(
+                                    posA.latitude, posA.longitude, posB.latitude, posB.longitude
+                                ),
+                                bearingDeg = com.rtbishop.look4sat.core.presentation.greatCircleBearingDeg(
+                                    posA.latitude, posA.longitude, posB.latitude, posB.longitude
+                                )
+                            )
+                        } else {
+                            GridTargetChip(grid = null, distanceKm = null, bearingDeg = null)
+                        }
                    }
                }
            )
@@ -51,6 +51,7 @@ import androidx.compose.material3.FilterChip
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
@@ -155,6 +156,130 @@ fun LocatorDialog(qthLocator: String, dismiss: () -> Unit, save: (String) -> Uni
    }
 }

+@Composable
+fun WavelogDialog(
+    initialSettings: com.rtbishop.look4sat.core.domain.model.WavelogSettings,
+    workedGridsCount: Int,
+    isSyncing: Boolean,
+    message: String?,
+    dismiss: () -> Unit,
+    onSave: (com.rtbishop.look4sat.core.domain.model.WavelogSettings) -> Unit,
+    onSync: (com.rtbishop.look4sat.core.domain.model.WavelogSettings) -> Unit
+) {
+    val url = rememberSaveable { mutableStateOf(initialSettings.url) }
+    val token = rememberSaveable { mutableStateOf(initialSettings.token) }
+    SharedDialog(
+        title = stringResource(R.string.prefs_wavelog_title),
+        onCancel = dismiss,
+        onAccept = {
+            onSave(com.rtbishop.look4sat.core.domain.model.WavelogSettings(url.value, token.value))
+            dismiss()
+        }
+    ) {
+        OutlinedTextField(
+            value = url.value,
+            onValueChange = { url.value = it },
+            label = { Text(text = stringResource(id = R.string.prefs_wavelog_url)) },
+            placeholder = { Text(text = "http://192.168.1.10") },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+        )
+        OutlinedTextField(
+            value = token.value,
+            onValueChange = { token.value = it },
+            label = { Text(text = stringResource(id = R.string.prefs_wavelog_token)) },
+            placeholder = { Text(text = "abcdef123456:1") },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+        )
+        Text(
+            text = stringResource(R.string.prefs_wavelog_hint, workedGridsCount),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+        )
+        if (message != null) {
+            Text(
+                text = message,
+                color = MaterialTheme.colorScheme.error,
+                style = MaterialTheme.typography.bodySmall,
+                modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+            )
+        }
+        // Sync uses the values typed in the fields directly — saving and syncing
+        // happen in one step, no need to close and reopen the dialog.
+        Row(
+            horizontalArrangement = Arrangement.End,
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large)
+        ) {
+            TextButton(
+                onClick = { onSync(com.rtbishop.look4sat.core.domain.model.WavelogSettings(url.value, token.value)) },
+                enabled = !isSyncing
+            ) {
+                Text(text = if (isSyncing) stringResource(R.string.prefs_wavelog_syncing)
+                else stringResource(R.string.prefs_wavelog_sync))
+            }
+        }
+        Spacer(modifier = Modifier.height(0.dp))
+    }
+}
+
+@Composable
+fun LoTWDialog(
+    initialSettings: com.rtbishop.look4sat.core.domain.model.LoTWSettings,
+    workedGridsCount: Int,
+    isSyncing: Boolean,
+    message: String?,
+    dismiss: () -> Unit,
+    onSave: (com.rtbishop.look4sat.core.domain.model.LoTWSettings) -> Unit,
+    onSync: (com.rtbishop.look4sat.core.domain.model.LoTWSettings) -> Unit
+) {
+    val call = rememberSaveable { mutableStateOf(initialSettings.callsign) }
+    val pass = rememberSaveable { mutableStateOf(initialSettings.password) }
+    SharedDialog(
+        title = stringResource(R.string.prefs_lotw_title),
+        onCancel = dismiss,
+        // The confirm button IS the sync action: saving credentials and
+        // fetching confirmed grids happen in one step.
+        onAccept = {
+            onSync(com.rtbishop.look4sat.core.domain.model.LoTWSettings(call.value, pass.value))
+        },
+        acceptText = stringResource(if (isSyncing) R.string.prefs_lotw_syncing else R.string.prefs_lotw_sync),
+        acceptEnabled = !isSyncing
+    ) {
+        OutlinedTextField(
+            value = call.value,
+            onValueChange = { call.value = it.uppercase() },
+            label = { Text(text = stringResource(id = R.string.prefs_lotw_callsign)) },
+            placeholder = { Text(text = "BA7OPF") },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+        )
+        OutlinedTextField(
+            value = pass.value,
+            onValueChange = { pass.value = it },
+            label = { Text(text = stringResource(id = R.string.prefs_lotw_password)) },
+            placeholder = { Text(text = "********") },
+            visualTransformation = androidx.compose.ui.text.input.PasswordVisualTransformation(),
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large),
+        )
+        Text(
+            text = stringResource(R.string.prefs_lotw_hint, workedGridsCount),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+        )
+        if (message != null) {
+            Text(
+                text = message,
+                color = MaterialTheme.colorScheme.error,
+                style = MaterialTheme.typography.bodySmall,
+                modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+            )
+        }
+        Spacer(modifier = Modifier.height(0.dp))
+    }
+}
+
@Preview(showBackground = true)
@Composable
 private fun TransceiversDialogPreview() {
@@ -63,6 +63,8 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.presentation.CardButton
@@ -201,6 +203,17 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
            onSave = { onAction(SettingsAction.UpdateRadioControl(it)) }
        )
    }
+    if (dialogs.lotw) {
+        LoTWDialog(
+            initialSettings = uiState.lotwSettings,
+            workedGridsCount = uiState.workedGridsCount,
+            isSyncing = uiState.lotwSyncing,
+            message = uiState.lotwMessage,
+            dismiss = { dialogs.lotw = false },
+            onSave = { onAction(SettingsAction.UpdateLoTW(it)) },
+            onSync = { onAction(SettingsAction.SyncLoTWGrids(it)) }
+        )
+    }

    // URLs for top bar
    val uriHandler = LocalUriHandler.current
@@ -305,6 +318,13 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
                    onRadioControlClick = { dialogs.radioControl = true }
                )
            }
+            item {
+                LoTWCard(
+                    settings = uiState.lotwSettings,
+                    workedGridsCount = uiState.workedGridsCount,
+                    showLoTWDialog = { dialogs.lotw = true }
+                )
+            }
            item { OtherCard(uiState.otherSettings, onAction) }
            item { CardCredits() }
            item(span = { GridItemSpan(maxLineSpan) }) {
@@ -489,6 +509,7 @@ private fun OtherCardPreview() = MainTheme {
        stateOfUtc = false,
        stateOfLightTheme = false,
        stateOfNightMode = false,
+        stateOfMapGrid = false,
        shouldSeeWarning = false,
        shouldSeeWhatsNew = false
    )
@@ -500,7 +521,7 @@ private fun OtherCard(settings: OtherSettings, onAction: (SettingsAction) -> Uni
    ElevatedCard(
        modifier = Modifier
            .fillMaxWidth()
-            .height(268.dp)
+            .height(312.dp)
    ) {
        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
            Text(
@@ -522,6 +543,9 @@ private fun OtherCard(settings: OtherSettings, onAction: (SettingsAction) -> Uni
            SwitchRow(R.string.prefs_other_switch_night_mode, settings.stateOfNightMode) {
                onAction(SettingsAction.ToggleNightMode(it))
            }
+            SwitchRow(R.string.prefs_other_switch_map_grid, settings.stateOfMapGrid) {
+                onAction(SettingsAction.ToggleMapGrid(it))
+            }
        }
    }
 }
@@ -538,6 +562,38 @@ private fun SwitchRow(labelResId: Int, checked: Boolean, onCheckedChange: (Boole
    }
 }

+@Composable
+private fun LoTWCard(
+    settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings,
+    workedGridsCount: Int,
+    showLoTWDialog: () -> Unit
+) {
+    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Column(modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) {
+            Text(
+                text = stringResource(id = R.string.prefs_lotw_title),
+                color = MaterialTheme.colorScheme.primary
+            )
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(
+                text = if (settings.isConfigured) {
+                    stringResource(R.string.prefs_lotw_configured, workedGridsCount)
+                } else {
+                    stringResource(R.string.prefs_lotw_not_configured)
+                },
+                style = MaterialTheme.typography.bodySmall,
+                maxLines = 2
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            CardButton(
+                onClick = showLoTWDialog,
+                text = stringResource(id = R.string.prefs_wavelog_configure),
+                modifier = Modifier.fillMaxWidth()
+            )
+        }
+    }
+}
+
@Composable
 private fun formatUpdateTime(updateTime: Long): String {
    val timePattern = stringResource(id = R.string.prefs_updated_time)
@@ -657,6 +713,8 @@ private class DialogVisibility {
    var network by mutableStateOf(false)
    var bluetooth by mutableStateOf(false)
    var radioControl by mutableStateOf(false)
+    var wavelog by mutableStateOf(false)
+    var lotw by mutableStateOf(false)
 }

@Composable
@@ -664,12 +722,13 @@ 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)
+                listOf(it.position, it.locator, it.dataSources, it.network, it.bluetooth, it.radioControl, it.wavelog, it.lotw)
            },
            restore = {
                DialogVisibility().apply {
                    position = it[0]; locator = it[1]; dataSources = it[2]
-                    network = it[3]; bluetooth = it[4]; radioControl = it[5]
+                    network = it[3]; bluetooth = it[4]; radioControl = it[5]; wavelog = it[6]
+                    lotw = it.getOrElse(7) { false }
                }
            }
        )
@@ -22,6 +22,7 @@ import com.rtbishop.look4sat.core.domain.model.LatestRelease
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
 import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import java.io.File

@@ -54,6 +55,13 @@ data class SettingsState(
    val radioControlSettings: RadioControlSettings,
    val dataSourcesSettings: DataSourcesSettings,
    val dataSourcesStatus: Map<String, Int> = emptyMap(),
+    val wavelogSettings: WavelogSettings = WavelogSettings(),
+    val workedGridsCount: Int = 0,
+    val wavelogSyncing: Boolean = false,
+    val wavelogMessage: String? = null,
+    val lotwSettings: com.rtbishop.look4sat.core.domain.model.LoTWSettings = com.rtbishop.look4sat.core.domain.model.LoTWSettings(),
+    val lotwSyncing: Boolean = false,
+    val lotwMessage: String? = null,
    val updateChecker: UpdateCheckerState = UpdateCheckerState()
 )

@@ -77,6 +85,7 @@ sealed interface SettingsAction {
    data class ToggleSensor(val value: Boolean) : SettingsAction
    data class ToggleLightTheme(val value: Boolean) : SettingsAction
    data class ToggleNightMode(val value: Boolean) : SettingsAction
+    data class ToggleMapGrid(val value: Boolean) : SettingsAction

    // Remote control
    data class UpdateRC(val settings: RCSettings) : SettingsAction
@@ -85,6 +94,14 @@ sealed interface SettingsAction {
    // Data sources
    data class UpdateDataSources(val settings: DataSourcesSettings) : SettingsAction

+    // Wavelog worked grids
+    data class UpdateWavelog(val settings: WavelogSettings) : SettingsAction
+    data class SyncWorkedGrids(val settings: WavelogSettings) : SettingsAction
+
+    // LoTW confirmed grids
+    data class UpdateLoTW(val settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) : SettingsAction
+    data class SyncLoTWGrids(val settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) : SettingsAction
+
    // Update checker
    data object CheckForUpdate : SettingsAction
    data object DownloadUpdate : SettingsAction
@@ -23,9 +23,11 @@ import androidx.lifecycle.viewModelScope
 import androidx.lifecycle.viewmodel.initializer
 import androidx.lifecycle.viewmodel.viewModelFactory
 import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.repository.IUpdateRepository
+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.presentation.R
@@ -39,6 +41,8 @@ class SettingsViewModel(
    private val databaseRepo: IDatabaseRepo,
    private val settingsRepo: ISettingsRepo,
    private val updateRepo: IUpdateRepository,
+    private val wavelogRepo: IWavelogRepository,
+    private val lotwRepo: com.rtbishop.look4sat.core.domain.repository.ILoTWRepository,
    private val apkFile: File,
    private val showToast: IShowToast
 ) : ViewModel() {
@@ -54,7 +58,9 @@ class SettingsViewModel(
            rcSettings = settingsRepo.rcSettings.value,
            radioControlSettings = settingsRepo.radioControlSettings.value,
            dataSourcesSettings = settingsRepo.dataSourcesSettings.value,
-            dataSourcesStatus = settingsRepo.dataSourcesStatus.value
+            dataSourcesStatus = settingsRepo.dataSourcesStatus.value,
+            wavelogSettings = settingsRepo.wavelogSettings.value,
+            workedGridsCount = settingsRepo.getWorkedGrids().size
        )
    )

@@ -107,6 +113,16 @@ class SettingsViewModel(
                _uiState.update { it.copy(radioControlSettings = settings) }
            }
        }
+        viewModelScope.launch {
+            settingsRepo.wavelogSettings.collect { settings ->
+                _uiState.update { it.copy(wavelogSettings = settings) }
+            }
+        }
+        viewModelScope.launch {
+            settingsRepo.lotwSettings.collect { settings ->
+                _uiState.update { it.copy(lotwSettings = settings) }
+            }
+        }
    }


@@ -133,10 +149,17 @@ class SettingsViewModel(
            is SettingsAction.ToggleSensor -> settingsRepo.updateOtherSettings { it.copy(stateOfSensors = action.value) }
            is SettingsAction.ToggleLightTheme -> settingsRepo.updateOtherSettings { it.copy(stateOfLightTheme = action.value) }
            is SettingsAction.ToggleNightMode -> settingsRepo.updateOtherSettings { it.copy(stateOfNightMode = action.value) }
+            is SettingsAction.ToggleMapGrid -> settingsRepo.updateOtherSettings { it.copy(stateOfMapGrid = action.value) }
            // Remote control & data sources
            is SettingsAction.UpdateRC -> settingsRepo.updateRCSettings(action.settings)
            is SettingsAction.UpdateRadioControl -> settingsRepo.updateRadioControlSettings(action.settings)
            is SettingsAction.UpdateDataSources -> settingsRepo.updateDataSourcesSettings(action.settings)
+            // Wavelog worked grids
+            is SettingsAction.UpdateWavelog -> settingsRepo.updateWavelogSettings(action.settings)
+            is SettingsAction.SyncWorkedGrids -> syncWorkedGrids(action.settings)
+            // LoTW confirmed grids
+            is SettingsAction.UpdateLoTW -> settingsRepo.updateLoTWSettings(action.settings)
+            is SettingsAction.SyncLoTWGrids -> syncLoTWGrids(action.settings)
            // Update checker
            SettingsAction.CheckForUpdate -> checkForUpdate()
            SettingsAction.DownloadUpdate -> downloadUpdate()
@@ -146,6 +169,56 @@ class SettingsViewModel(
        }
    }

+    // region Wavelog worked grids
+
+    private fun syncWorkedGrids(settings: WavelogSettings) {
+        if (!settings.isConfigured) {
+            _uiState.update { it.copy(wavelogMessage = "Wavelog URL/token not configured") }
+            return
+        }
+        // Persist the credentials first, then sync with the freshly-typed values.
+        settingsRepo.updateWavelogSettings(settings)
+        _uiState.update { it.copy(wavelogSyncing = true, wavelogMessage = null) }
+        viewModelScope.launch {
+            val grids = wavelogRepo.fetchWorkedGrids(settings.url, settings.token)
+            _uiState.update {
+                if (grids != null) {
+                    settingsRepo.setWorkedGrids(grids)
+                    it.copy(wavelogSyncing = false, workedGridsCount = grids.size, wavelogMessage = null)
+                } else {
+                    it.copy(wavelogSyncing = false, wavelogMessage = "Sync failed — check URL/token/network")
+                }
+            }
+        }
+    }
+
+    private fun syncLoTWGrids(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) {
+        if (!settings.isConfigured) {
+            _uiState.update { it.copy(lotwMessage = "LoTW callsign/password not configured") }
+            return
+        }
+        // Persist the credentials first, then sync with the freshly-typed values.
+        settingsRepo.updateLoTWSettings(settings)
+        _uiState.update { it.copy(lotwSyncing = true, lotwMessage = null) }
+        viewModelScope.launch {
+            val lotwResult = lotwRepo.fetchConfirmedGridQsos(settings.callsign, settings.password)
+            _uiState.update { state ->
+                if (lotwResult == null) {
+                    state.copy(lotwSyncing = false, lotwMessage = "LoTW sync failed — check callsign/password/network")
+                } else {
+                    // Wavelog entry removed: LoTW is now the only source, so the
+                    // synced set fully replaces the stored worked grids.
+                    val (grids, qsos) = lotwResult
+                    settingsRepo.setWorkedGrids(grids)
+                    settingsRepo.setWorkedGridQsos(qsos)
+                    state.copy(lotwSyncing = false, workedGridsCount = grids.size, lotwMessage = null)
+                }
+            }
+        }
+    }
+
+    // endregion
+
    // region Update checker

    private fun checkForUpdate() {
@@ -267,6 +340,8 @@ class SettingsViewModel(
                    databaseRepo = container.databaseRepo,
                    settingsRepo = container.settingsRepo,
                    updateRepo = container.updateRepo,
+                    wavelogRepo = container.wavelogRepo,
+                    lotwRepo = container.lotwRepo,
                    apkFile = File(context.cacheDir, "look4sat-update.apk"),
                    showToast = container.provideShowToast()
                )
@@ -1,8 +1,8 @@
 [versions]
 #noinspection UnusedVersionCatalogEntry
-appVersionCode = "451"
+appVersionCode = "459"
 #noinspection UnusedVersionCatalogEntry
-appVersionName = "4.4.6-ba7opf.7"
+appVersionName = "4.4.6-ba7opf.9.8"
 #noinspection UnusedVersionCatalogEntry
 compileSdk = "37"
 #noinspection UnusedVersionCatalogEntry
Author	SHA1	Message	Date
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
atsunatsu	e75d2dc410	chore: bump version to 4.4.6-ba7opf.9.7	2026-09-08 00:27:17 +08:00
atsunatsu	d55a07bc26	feat(map): fill individual worked 2x1 degree squares green at field zoom without square grid lines	2026-09-08 00:14:05 +08:00
atsunatsu	c372386a77	fix(data): LoTW sync resilience — longer timeouts (30s/120s), gzip transfer, follow redirects; ARRL server-side latency is the bottleneck	2026-09-08 00:05:22 +08:00
atsunatsu	de6ade025c	feat(settings): LoTW dialog — hint rewritten without Wavelog, confirm button is now Sync, remove separate sync button	2026-09-07 23:29:19 +08:00
atsunatsu	2eb6d6cd5b	fix(map): stop satellite tracking animation in grid mode so it stays centered on the local grid	2026-09-07 22:54:19 +08:00
atsunatsu	c09f718aae	feat: mutual chip uses theme primary yellow, plain text distance; top bar text indent; low-zoom meridians via direct Mercator math (bypass osmdroid wrap bug); remove Wavelog sync entry — LoTW is the sole grid source (replace instead of merge)	2026-09-07 19:10:44 +08:00
atsunatsu	a9fe0b74e9	feat: mutual match screen target-grid chip (needle bearing + grid + distance); grid mode centering no longer swallowed when station position is not yet available	2026-09-07 17:54:14 +08:00
atsunatsu	2c9a5b376f	feat: release-notes body in update checker; grid mode centers on station grid on every entry; own grid square drawn with thick outline; low-zoom meridian vanishing while panning fixed	2026-09-07 15:06:33 +08:00
atsunatsu	422e480b2f	release: v4.4.6-ba7opf.9.3	2026-09-07 14:07:57 +08:00
atsunatsu	efd6931abb	fix: LoTW sync — force full report with qso_qslsince (LoTW default only returns new confirmations since last query) and accept lowercase <eoh> header	2026-09-07 13:51:41 +08:00
atsunatsu	c7ca77a943	fix: sync dialogs use typed values directly (save+sync in one step); LoTW card wording; center map on station grid when entering grid mode; center grid labels in cells; update-check falls back to GitHub accelerator mirrors	2026-09-07 07:22:41 +08:00
atsunatsu	be6473e692	feat: LoTW confirmed-grids sync card — fetch confirmed QSO grids directly from ARRL LoTW (lotwreport.adi) and merge with Wavelog grids; credentials stored locally	2026-09-07 06:55:42 +08:00
atsunatsu	75d162301b	fix: meridians vanish at low zoom (osmdroid clips Mercator X; normalize longitude to view center); hide satellite layer and bottom info card in grid mode	2026-09-07 06:28:58 +08:00
atsunatsu	07c09ec3e9	fix: VersionComparator parses multi-level suffixes (4.4.6-ba7opf.9.1) by comparing all numeric segments, not just the last one	2026-09-07 06:11:31 +08:00
atsunatsu	513d50e56a	chore: bump version to 4.4.6-ba7opf.9.1	2026-09-07 06:01:45 +08:00
atsunatsu	366edd8bbb	fix: correct longitude bounds in Maidenhead grid overlay (left/right were swapped, so meridians and worked-grid fills never drew)	2026-09-07 06:01:10 +08:00
atsunatsu	13df0dfcec	fix: Wavelog sync via v1 API logbook_get_worked_grids (3.0.2 has no API v2)	2026-09-07 02:11:40 +08:00
atsunatsu	eb1a5d51a2	chore: bump version to 4.4.6-ba7opf.9	2026-09-07 02:02:36 +08:00
atsunatsu	4e3547649f	feat: Maidenhead grid mode with worked-grid highlights from Wavelog (API v2 grid=all)	2026-09-07 01:42:42 +08:00
atsunatsu	7abbeb6eb3	fix: update check via GitHub web endpoint, avoiding API 60 req/hour rate limit	2026-09-06 21:33:41 +08:00
atsunatsu	5c73d5ed7a	feat: default TLE source order with LAPAN-A2 (Kaggle) first, R4UAB second	2026-09-06 20:18:04 +08:00
atsunatsu	a663ef7f1b	build: read release signing credentials from local.properties/env instead of hardcoding Passwords for the release keystore were committed in plaintext to a public repo. Move them to gitignored local.properties with an environment-variable fallback. Keystore file itself stays in $HOME.	2026-09-05 07:57:33 +08:00