feat(lotw): full/incremental sync modes with live progress and time estimate

Two explicit sync buttons in the LoTW dialog: - Full sync: qso_qslsince=2000-01-01, fresh report replaces all stored data. - Incremental merge: since=last successful sync date, merged into the stored set (grids union, QSOs deduped by call + time). First sync / callsign change automatically falls back to full replace so no stale grids from another account linger. Progress & estimates: - Report body is now streamed; the header's <APP_LoTW_NUMREC> gives the real QSL count, total size is estimated as NUMREC * 720 B (measured), and the UI shows a determinate bar with 'N QSOs, ~X s remaining' once known. - Pre-sync hint shows the measured rate (~8 s per 100 QSOs). - readTimeout raised to 600 s (stall timeout, not a total cap — huge accounts legitimately take 30+ min at ARRL's ~10 KB/s stream rate); connectTimeout raised to 60 s (a busy server took 36.5 s to accept a connection). Also: ISettingsRepo gains last-sync date/callsign bookkeeping, and the mutual test fake implements the new members.
2026-10-02 03:15:37 +00:00 · 2026-09-16 14:34:00 +08:00
1 parent 7a865fffd7
commit fc028f852c
@@ -50,6 +50,7 @@ import androidx.compose.material3.Checkbox
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
+import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.OutlinedTextField
@@ -228,23 +229,23 @@ fun LoTWDialog(
    initialSettings: com.rtbishop.look4sat.core.domain.model.LoTWSettings,
    workedGridsCount: Int,
    isSyncing: Boolean,
+    syncMode: LoTWSyncMode?,
+    progress: com.rtbishop.look4sat.core.domain.repository.LoTWProgress?,
    message: String?,
    dismiss: () -> Unit,
    onSave: (com.rtbishop.look4sat.core.domain.model.LoTWSettings) -> Unit,
-    onSync: (com.rtbishop.look4sat.core.domain.model.LoTWSettings) -> Unit
+    onSyncFull: (com.rtbishop.look4sat.core.domain.model.LoTWSettings) -> Unit,
+    onSyncIncremental: (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),
+        onDismissRequest = dismiss,
        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
+        // The two sync buttons below are the primary actions: saving
+        // credentials and fetching confirmed grids happen in one step.
+        onAccept = null
    ) {
        OutlinedTextField(
            value = call.value,
@@ -268,12 +269,51 @@ fun LoTWDialog(
            style = MaterialTheme.typography.bodySmall,
            modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
        )
-        Text(
-            text = stringResource(R.string.prefs_lotw_sync_duration_hint),
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
-        )
+        if (isSyncing) {
+            // Live progress: once the report header reveals the record count,
+            // switch to "N QSOs, ~X s remaining" with a determinate bar.
+            val progressText = when {
+                progress == null ||
+                    progress.phase == com.rtbishop.look4sat.core.domain.repository.LoTWPhase.Connecting ->
+                    stringResource(R.string.lotw_sync_progress_connecting)
+                progress.qsoCount > 0 && progress.remainingSeconds > 0 ->
+                    stringResource(R.string.lotw_sync_progress_qso, progress.qsoCount, progress.remainingSeconds)
+                progress.qsoCount > 0 ->
+                    stringResource(R.string.lotw_sync_progress_count, progress.qsoCount)
+                else -> stringResource(R.string.lotw_sync_progress_downloading)
+            }
+            Text(
+                text = progressText,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+            )
+            if (progress != null && progress.expectedBytes > 0) {
+                LinearProgressIndicator(
+                    progress = { progress.fraction },
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large)
+                )
+            } else {
+                LinearProgressIndicator(
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large)
+                )
+            }
+        } else {
+            // Pre-sync estimate: rate per 100 QSOs (measured ~8 s at ARRL's
+            // ~10 KB/s stream rate), plus the fixed server-side generation time.
+            Text(
+                text = stringResource(R.string.lotw_sync_rate_hint),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+            )
+            Text(
+                text = stringResource(R.string.prefs_lotw_sync_duration_hint),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
+            )
+        }
        if (message != null) {
            Text(
                text = message,
@@ -282,6 +322,21 @@ fun LoTWDialog(
                modifier = Modifier.padding(horizontal = LocalSpacing.current.large)
            )
        }
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier.fillMaxWidth().padding(horizontal = LocalSpacing.current.large)
+        ) {
+            CardButton(
+                onClick = { onSyncFull(com.rtbishop.look4sat.core.domain.model.LoTWSettings(call.value, pass.value)) },
+                text = stringResource(R.string.lotw_sync_full),
+                isEnabled = !isSyncing
+            )
+            CardButton(
+                onClick = { onSyncIncremental(com.rtbishop.look4sat.core.domain.model.LoTWSettings(call.value, pass.value)) },
+                text = stringResource(R.string.lotw_sync_incremental),
+                isEnabled = !isSyncing
+            )
+        }
        Spacer(modifier = Modifier.height(0.dp))
    }
 }
@@ -204,14 +204,28 @@ private fun SettingsScreen(uiState: SettingsState, onAction: (SettingsAction) ->
        )
    }
    if (dialogs.lotw) {
+        // LoTW sync failures are typed codes from the ViewModel; render them
+        // through string resources so the dialog follows the system language.
+        val lotwErrorMessage = uiState.lotwError?.let { error ->
+            when (error) {
+                LoTWError.NotConfigured -> stringResource(R.string.lotw_sync_error_not_configured)
+                LoTWError.BadCredentials -> stringResource(R.string.lotw_sync_error_credentials)
+                LoTWError.RateLimited -> stringResource(R.string.lotw_sync_error_rate_limited)
+                LoTWError.Timeout -> stringResource(R.string.lotw_sync_error_timeout)
+                is LoTWError.Network -> stringResource(R.string.lotw_sync_error_network, error.detail)
+            }
+        }
        LoTWDialog(
            initialSettings = uiState.lotwSettings,
            workedGridsCount = uiState.workedGridsCount,
            isSyncing = uiState.lotwSyncing,
-            message = uiState.lotwMessage,
+            syncMode = uiState.lotwSyncMode,
+            progress = uiState.lotwProgress,
+            message = lotwErrorMessage,
            dismiss = { dialogs.lotw = false },
            onSave = { onAction(SettingsAction.UpdateLoTW(it)) },
-            onSync = { onAction(SettingsAction.SyncLoTWGrids(it)) }
+            onSyncFull = { onAction(SettingsAction.SyncLoTWGrids(it, LoTWSyncMode.Full)) },
+            onSyncIncremental = { onAction(SettingsAction.SyncLoTWGrids(it, LoTWSyncMode.Incremental)) }
        )
    }

@@ -61,10 +61,24 @@ data class SettingsState(
    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 lotwSyncMode: LoTWSyncMode? = null,
+    val lotwProgress: com.rtbishop.look4sat.core.domain.repository.LoTWProgress? = null,
+    val lotwError: LoTWError? = null,
    val updateChecker: UpdateCheckerState = UpdateCheckerState()
 )

+/** What a LoTW sync button does: pull everything, or only new QSLs since the last sync. */
+enum class LoTWSyncMode { Full, Incremental }
+
+/** LoTW sync failure, kept as a translatable code until the UI renders it. */
+sealed interface LoTWError {
+    data object NotConfigured : LoTWError
+    data object BadCredentials : LoTWError
+    data object RateLimited : LoTWError
+    data object Timeout : LoTWError
+    data class Network(val detail: String) : LoTWError
+}
+
 sealed interface SettingsAction {
    // Position
    data object SetGpsPosition : SettingsAction
@@ -99,7 +113,10 @@ sealed interface 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
+    data class SyncLoTWGrids(
+        val settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings,
+        val mode: LoTWSyncMode
+    ) : SettingsAction

    // Update checker
    data object CheckForUpdate : SettingsAction
@@ -158,7 +158,7 @@ class SettingsViewModel(
            is SettingsAction.SyncWorkedGrids -> syncWorkedGrids(action.settings)
            // LoTW confirmed grids
            is SettingsAction.UpdateLoTW -> settingsRepo.updateLoTWSettings(action.settings)
-            is SettingsAction.SyncLoTWGrids -> syncLoTWGrids(action.settings)
+            is SettingsAction.SyncLoTWGrids -> syncLoTWGrids(action.settings, action.mode)
            // Update checker
            SettingsAction.CheckForUpdate -> checkForUpdate()
            SettingsAction.DownloadUpdate -> downloadUpdate()
@@ -191,61 +191,115 @@ class SettingsViewModel(
        }
    }

-    private fun syncLoTWGrids(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) {
+    private fun syncLoTWGrids(
+        settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings,
+        mode: LoTWSyncMode
+    ) {
        if (!settings.isConfigured) {
-            _uiState.update { it.copy(lotwMessage = "LoTW callsign/password not configured") }
+            _uiState.update { it.copy(lotwError = LoTWError.NotConfigured) }
            return
        }
        // Persist the credentials first, then sync with the freshly-typed values.
        settingsRepo.updateLoTWSettings(settings)
-        _uiState.update { it.copy(lotwSyncing = true, lotwMessage = null) }
+        // Incremental only makes sense for the same callsign as the last sync;
+        // a first sync, an unknown/empty record or a callsign change must fall
+        // back to a full report so no stale grids from another account linger.
+        val callsign = settings.callsign.trim().uppercase()
+        val lastCallsign = settingsRepo.getLastLotwSyncCallsign()
+        val effectiveMode = if (mode == LoTWSyncMode.Incremental &&
+            lastCallsign.isNotBlank() && lastCallsign == callsign
+        ) LoTWSyncMode.Incremental else LoTWSyncMode.Full
+        val since = if (effectiveMode == LoTWSyncMode.Incremental) {
+            settingsRepo.getLastLotwSyncDate()
+        } else ""
+        _uiState.update {
+            it.copy(lotwSyncing = true, lotwSyncMode = effectiveMode, lotwProgress = null, lotwError = null)
+        }
        viewModelScope.launch {
-            when (val result = lotwRepo.fetchConfirmedGridQsos(settings.callsign, settings.password)) {
+            val result = lotwRepo.fetchConfirmedGridQsos(callsign, settings.password, since) { progress ->
+                _uiState.update { it.copy(lotwProgress = progress) }
+            }
+            when (result) {
                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.Success -> {
-                    // Wavelog entry removed: LoTW is now the only source, so the
-                    // synced set fully replaces the stored worked grids.
-                    settingsRepo.setWorkedGrids(result.grids)
-                    settingsRepo.setWorkedGridQsos(result.qsos)
-                    settingsRepo.setRoamedGrids(result.roamedGrids)
+                    // Incremental: merge new grids/QSOs into the stored set (dedup
+                    // by call + QSO time); full: the fresh report replaces it all.
+                    val existingGrids = settingsRepo.getWorkedGrids()
+                    val existingQsos = settingsRepo.getWorkedGridQsos()
+                    val existingRoamed = settingsRepo.getRoamedGrids()
+                    val mergedGrids = if (effectiveMode == LoTWSyncMode.Incremental) {
+                        existingGrids + result.grids
+                    } else result.grids
+                    val mergedQsos = if (effectiveMode == LoTWSyncMode.Incremental) {
+                        mergeGridQsos(existingQsos, result.qsos)
+                    } else result.qsos
+                    val mergedRoamed = if (effectiveMode == LoTWSyncMode.Incremental) {
+                        existingRoamed + result.roamedGrids
+                    } else result.roamedGrids
+                    settingsRepo.setWorkedGrids(mergedGrids)
+                    settingsRepo.setWorkedGridQsos(mergedQsos)
+                    settingsRepo.setRoamedGrids(mergedRoamed)
+                    // Remember when/what we synced, so the next incremental pull
+                    // asks LoTW for only the confirmations since today.
+                    val today = java.text.SimpleDateFormat("yyyyMMdd", java.util.Locale.US)
+                        .apply { timeZone = java.util.TimeZone.getTimeZone("UTC") }
+                        .format(java.util.Date())
+                    settingsRepo.setLastLotwSyncDate(today)
+                    settingsRepo.setLastLotwSyncCallsign(callsign)
                    _uiState.update { state ->
                        state.copy(
-                            lotwSyncing = false, workedGridsCount = result.grids.size,
-                            lotwMessage = null
+                            lotwSyncing = false, lotwSyncMode = null, lotwProgress = null,
+                            workedGridsCount = mergedGrids.size, lotwError = null
                        )
                    }
                }
                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.BadCredentials ->
                    _uiState.update { state ->
                        state.copy(
-                            lotwSyncing = false,
-                            lotwMessage = "LoTW sync failed — callsign or password incorrect"
+                            lotwSyncing = false, lotwSyncMode = null, lotwProgress = null,
+                            lotwError = LoTWError.BadCredentials
                        )
                    }
                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.RateLimited ->
                    _uiState.update { state ->
                        state.copy(
-                            lotwSyncing = false,
-                            lotwMessage = "LoTW sync failed — rate limited by server, wait a few minutes and retry"
+                            lotwSyncing = false, lotwSyncMode = null, lotwProgress = null,
+                            lotwError = LoTWError.RateLimited
                        )
                    }
                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.Timeout ->
                    _uiState.update { state ->
                        state.copy(
-                            lotwSyncing = false,
-                            lotwMessage = "LoTW sync failed — connection timed out, try another network"
+                            lotwSyncing = false, lotwSyncMode = null, lotwProgress = null,
+                            lotwError = LoTWError.Timeout
                        )
                    }
                is com.rtbishop.look4sat.core.domain.repository.LoTWResult.NetworkError ->
                    _uiState.update { state ->
                        state.copy(
-                            lotwSyncing = false,
-                            lotwMessage = "LoTW sync failed — network error (${result.detail})"
+                            lotwSyncing = false, lotwSyncMode = null, lotwProgress = null,
+                            lotwError = LoTWError.Network(result.detail)
                        )
                    }
            }
        }
    }

+    /** Merge fresh QSO detail into existing per-grid lists, dedup by call + QSO time. */
+    private fun mergeGridQsos(
+        existing: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>,
+        fresh: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>
+    ): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> {
+        val merged = existing.mapValues { (_, list) -> list.toMutableList() }.toMutableMap()
+        fresh.forEach { (grid, list) ->
+            val target = merged.getOrPut(grid) { mutableListOf() }
+            val known = target.mapTo(mutableSetOf()) { it.call to it.epochMs }
+            list.forEach { qso ->
+                if (known.add(qso.call to qso.epochMs)) target.add(qso)
+            }
+        }
+        return merged
+    }
+
    // endregion

    // region Update checker