[All Platforms] 2.1.0 - Sync Optimizations

android/app/build.gradle.kts

@@ -16,8 +16,8 @@ android {
         applicationId = "com.atridad.ascently"
         minSdk = 31
         targetSdk = 36
-        versionCode = 41
-        versionName = "2.0.1"
+        versionCode = 42
+        versionName = "2.1.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

android/app/src/main/java/com/atridad/ascently/data/format/BackupFormat.kt

@@ -32,13 +32,12 @@ data class BackupGym(
         val supportedClimbTypes: List<ClimbType>,
         val difficultySystems: List<DifficultySystem>,
         @kotlinx.serialization.SerialName("customDifficultyGrades")
-        val customDifficultyGrades: List<String> = emptyList(),
+        val customDifficultyGrades: List<String>? = null,
         val notes: String? = null,
         val createdAt: String,
         val updatedAt: String
 ) {
     companion object {
-        /** Create BackupGym from native Android Gym model */
         fun fromGym(gym: Gym): BackupGym {
             return BackupGym(
                     id = gym.id,
@@ -46,7 +45,7 @@ data class BackupGym(
                     location = gym.location,
                     supportedClimbTypes = gym.supportedClimbTypes,
                     difficultySystems = gym.difficultySystems,
-                    customDifficultyGrades = gym.customDifficultyGrades,
+                    customDifficultyGrades = gym.customDifficultyGrades.ifEmpty { null },
                     notes = gym.notes,
                     createdAt = gym.createdAt,
                     updatedAt = gym.updatedAt
@@ -54,7 +53,6 @@ data class BackupGym(
         }
     }
 
-    /** Convert to native Android Gym model */
     fun toGym(): Gym {
         return Gym(
                 id = id,
@@ -62,7 +60,7 @@ data class BackupGym(
                 location = location,
                 supportedClimbTypes = supportedClimbTypes,
                 difficultySystems = difficultySystems,
-                customDifficultyGrades = customDifficultyGrades,
+                customDifficultyGrades = customDifficultyGrades ?: emptyList(),
                 notes = notes,
                 createdAt = createdAt,
                 updatedAt = updatedAt
@@ -79,7 +77,7 @@ data class BackupProblem(
         val description: String? = null,
         val climbType: ClimbType,
         val difficulty: DifficultyGrade,
-        val tags: List<String> = emptyList(),
+        val tags: List<String>? = null,
         val location: String? = null,
         val imagePaths: List<String>? = null,
         val isActive: Boolean = true,
@@ -89,7 +87,6 @@ data class BackupProblem(
         val updatedAt: String
 ) {
     companion object {
-        /** Create BackupProblem from native Android Problem model */
         fun fromProblem(problem: Problem): BackupProblem {
             return BackupProblem(
                     id = problem.id,
@@ -112,7 +109,6 @@ data class BackupProblem(
         }
     }
 
-    /** Convert to native Android Problem model */
     fun toProblem(): Problem {
         return Problem(
                 id = id,
@@ -121,7 +117,7 @@ data class BackupProblem(
                 description = description,
                 climbType = climbType,
                 difficulty = difficulty,
-                tags = tags,
+                tags = tags ?: emptyList(),
                 location = location,
                 imagePaths = imagePaths ?: emptyList(),
                 isActive = isActive,
@@ -132,7 +128,6 @@ data class BackupProblem(
         )
     }
 
-    /** Create a copy with updated image paths for import processing */
     fun withUpdatedImagePaths(newImagePaths: List<String>): BackupProblem {
         return copy(imagePaths = newImagePaths.ifEmpty { null })
     }
@@ -153,7 +148,6 @@ data class BackupClimbSession(
         val updatedAt: String
 ) {
     companion object {
-        /** Create BackupClimbSession from native Android ClimbSession model */
         fun fromClimbSession(session: ClimbSession): BackupClimbSession {
             return BackupClimbSession(
                     id = session.id,
@@ -170,7 +164,6 @@ data class BackupClimbSession(
         }
     }
 
-    /** Convert to native Android ClimbSession model */
     fun toClimbSession(): ClimbSession {
         return ClimbSession(
                 id = id,
@@ -203,7 +196,6 @@ data class BackupAttempt(
         val updatedAt: String? = null
 ) {
     companion object {
-        /** Create BackupAttempt from native Android Attempt model */
         fun fromAttempt(attempt: Attempt): BackupAttempt {
             return BackupAttempt(
                     id = attempt.id,
@@ -221,7 +213,6 @@ data class BackupAttempt(
         }
     }
 
-    /** Convert to native Android Attempt model */
     fun toAttempt(): Attempt {
         return Attempt(
                 id = id,

android/app/src/main/java/com/atridad/ascently/data/health/HealthConnectStub.kt

@@ -66,7 +66,6 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Check if Health Connect is available on this device */
     fun isHealthConnectAvailable(): Flow<Boolean> = flow {
         try {
             if (!_isCompatible.value) {
@@ -82,10 +81,6 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /**
-     * Enable or disable Health Connect integration and automatically request permissions if
-     * enabling
-     */
     suspend fun setEnabled(enabled: Boolean) {
         preferences.edit().putBoolean("enabled", enabled).apply()
         _isEnabled.value = enabled
@@ -105,13 +100,11 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Update the permissions granted state */
     fun setPermissionsGranted(granted: Boolean) {
         preferences.edit().putBoolean("permissions", granted).apply()
         _hasPermissions.value = granted
     }
 
-    /** Check if all required permissions are granted */
     suspend fun hasAllPermissions(): Boolean {
         return try {
             if (!_isCompatible.value || healthConnectClient == null) {
@@ -132,7 +125,6 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Check if Health Connect is ready for use */
     suspend fun isReady(): Boolean {
         return try {
             if (!_isEnabled.value || !_isCompatible.value || healthConnectClient == null)
@@ -148,12 +140,10 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Get permission request contract */
     fun getPermissionRequestContract(): ActivityResultContract<Set<String>, Set<String>> {
         return PermissionController.createRequestPermissionResultContract()
     }
 
-    /** Get required permissions as strings */
     fun getRequiredPermissions(): Set<String> {
         return try {
             REQUIRED_PERMISSIONS.map { it }.toSet()
@@ -163,7 +153,6 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Sync a completed climbing session to Health Connect (only when auto-sync is enabled) */
     @SuppressLint("RestrictedApi")
     suspend fun syncCompletedSession(
             session: ClimbSession,
@@ -271,7 +260,6 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Auto-sync a completed session if enabled - this is the only way to sync sessions */
     suspend fun autoSyncCompletedSession(
             session: ClimbSession,
             gymName: String,
@@ -293,7 +281,6 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Estimate calories burned during climbing */
     private fun estimateCaloriesForClimbing(durationMinutes: Long, attemptCount: Int): Double {
         val baseCaloriesPerMinute = 8.0
         val intensityMultiplier =
@@ -305,7 +292,6 @@ class HealthConnectManager(private val context: Context) {
         return durationMinutes * baseCaloriesPerMinute * intensityMultiplier
     }
 
-    /** Create heart rate data */
     @SuppressLint("RestrictedApi")
     private fun createHeartRateRecord(
             startTime: Instant,
@@ -347,9 +333,7 @@ class HealthConnectManager(private val context: Context) {
         }
     }
 
-    /** Check if ready for use */
     fun isReadySync(): Boolean {
         return _isEnabled.value && _hasPermissions.value
     }
-
 }

android/app/src/main/java/com/atridad/ascently/data/repository/ClimbRepository.kt

@@ -251,23 +251,15 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         }
     }
 
-    /**
-     * Sets the callback for auto-sync functionality. This should be called by the SyncService to
-     * register itself for auto-sync triggers.
-     */
     fun setAutoSyncCallback(callback: (() -> Unit)?) {
         autoSyncCallback = callback
     }
 
-    /**
-     * Triggers auto-sync if enabled. This is called after any data modification to keep data
-     * synchronized across devices automatically.
-     */
     private fun triggerAutoSync() {
         autoSyncCallback?.invoke()
     }
 
-    private fun trackDeletion(itemId: String, itemType: String) {
+    fun trackDeletion(itemId: String, itemType: String) {
         val currentDeletions = getDeletedItems().toMutableList()
         val newDeletion =
                 DeletedItem(id = itemId, type = itemType, deletedAt = DateFormatUtils.nowISO8601())

android/app/src/main/java/com/atridad/ascently/data/sync/DeltaSyncModels.kt

@@ -0,0 +1,30 @@
+package com.atridad.ascently.data.sync
+
+import com.atridad.ascently.data.format.BackupAttempt
+import com.atridad.ascently.data.format.BackupClimbSession
+import com.atridad.ascently.data.format.BackupGym
+import com.atridad.ascently.data.format.BackupProblem
+import com.atridad.ascently.data.format.DeletedItem
+import kotlinx.serialization.Serializable
+
+/** Request structure for delta sync - sends only changes since last sync */
+@Serializable
+data class DeltaSyncRequest(
+        val lastSyncTime: String,
+        val gyms: List<BackupGym>,
+        val problems: List<BackupProblem>,
+        val sessions: List<BackupClimbSession>,
+        val attempts: List<BackupAttempt>,
+        val deletedItems: List<DeletedItem>
+)
+
+/** Response structure for delta sync - receives only changes from server */
+@Serializable
+data class DeltaSyncResponse(
+        val serverTime: String,
+        val gyms: List<BackupGym>,
+        val problems: List<BackupProblem>,
+        val sessions: List<BackupClimbSession>,
+        val attempts: List<BackupAttempt>,
+        val deletedItems: List<DeletedItem>
+)

android/app/src/main/java/com/atridad/ascently/data/sync/SyncService.kt

@@ -19,6 +19,9 @@ import com.atridad.ascently.utils.ImageNamingUtils
 import com.atridad.ascently.utils.ImageUtils
 import java.io.IOException
 import java.io.Serializable
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -63,6 +66,7 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         prettyPrint = true
         ignoreUnknownKeys = true
         explicitNulls = false
+        coerceInputValues = true
     }
 
     // State
@@ -195,26 +199,33 @@ class SyncService(private val context: Context, private val repository: ClimbRep
                                 serverBackup.sessions.isNotEmpty() ||
                                 serverBackup.attempts.isNotEmpty()
 
-                when {
-                    !hasLocalData && hasServerData -> {
-                        Log.d(TAG, "No local data found, performing full restore from server")
-                        val imagePathMapping = syncImagesFromServer(serverBackup)
-                        importBackupToRepository(serverBackup, imagePathMapping)
-                        Log.d(TAG, "Full restore completed")
-                    }
-                    hasLocalData && !hasServerData -> {
-                        Log.d(TAG, "No server data found, uploading local data to server")
-                        uploadData(localBackup)
-                        syncImagesForBackup(localBackup)
-                        Log.d(TAG, "Initial upload completed")
-                    }
-                    hasLocalData && hasServerData -> {
-                        Log.d(TAG, "Both local and server data exist, merging (server wins)")
-                        mergeDataSafely(serverBackup)
-                        Log.d(TAG, "Merge completed")
-                    }
-                    else -> {
-                        Log.d(TAG, "No data to sync")
+                // If both client and server have been synced before, use delta sync
+                val lastSyncTimeStr = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
+                if (hasLocalData && hasServerData && lastSyncTimeStr != null) {
+                    Log.d(TAG, "Using delta sync for incremental updates")
+                    performDeltaSync(lastSyncTimeStr)
+                } else {
+                    when {
+                        !hasLocalData && hasServerData -> {
+                            Log.d(TAG, "No local data found, performing full restore from server")
+                            val imagePathMapping = syncImagesFromServer(serverBackup)
+                            importBackupToRepository(serverBackup, imagePathMapping)
+                            Log.d(TAG, "Full restore completed")
+                        }
+                        hasLocalData && !hasServerData -> {
+                            Log.d(TAG, "No server data found, uploading local data to server")
+                            uploadData(localBackup)
+                            syncImagesForBackup(localBackup)
+                            Log.d(TAG, "Initial upload completed")
+                        }
+                        hasLocalData && hasServerData -> {
+                            Log.d(TAG, "Both local and server data exist, merging (server wins)")
+                            mergeDataSafely(serverBackup)
+                            Log.d(TAG, "Merge completed")
+                        }
+                        else -> {
+                            Log.d(TAG, "No data to sync")
+                        }
                     }
                 }
 
@@ -230,6 +241,265 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         }
     }
 
+    private suspend fun performDeltaSync(lastSyncTimeStr: String) {
+        Log.d(TAG, "Starting delta sync with lastSyncTime=$lastSyncTimeStr")
+
+        // Parse last sync time to filter modified items
+        val lastSyncDate = parseISO8601(lastSyncTimeStr) ?: Date(0)
+
+        // Collect items modified since last sync
+        val allGyms = repository.getAllGyms().first()
+        val modifiedGyms =
+                allGyms
+                        .filter { gym -> parseISO8601(gym.updatedAt)?.after(lastSyncDate) == true }
+                        .map { BackupGym.fromGym(it) }
+
+        val allProblems = repository.getAllProblems().first()
+        val modifiedProblems =
+                allProblems
+                        .filter { problem ->
+                            parseISO8601(problem.updatedAt)?.after(lastSyncDate) == true
+                        }
+                        .map { problem ->
+                            val backupProblem = BackupProblem.fromProblem(problem)
+                            val normalizedImagePaths =
+                                    problem.imagePaths.mapIndexed { index, _ ->
+                                        ImageNamingUtils.generateImageFilename(problem.id, index)
+                                    }
+                            if (normalizedImagePaths.isNotEmpty()) {
+                                backupProblem.copy(imagePaths = normalizedImagePaths)
+                            } else {
+                                backupProblem
+                            }
+                        }
+
+        val allSessions = repository.getAllSessions().first()
+        val modifiedSessions =
+                allSessions
+                        .filter { session ->
+                            parseISO8601(session.updatedAt)?.after(lastSyncDate) == true
+                        }
+                        .map { BackupClimbSession.fromClimbSession(it) }
+
+        val allAttempts = repository.getAllAttempts().first()
+        val modifiedAttempts =
+                allAttempts
+                        .filter { attempt ->
+                            parseISO8601(attempt.createdAt)?.after(lastSyncDate) == true
+                        }
+                        .map { BackupAttempt.fromAttempt(it) }
+
+        val allDeletions = repository.getDeletedItems()
+        val modifiedDeletions =
+                allDeletions.filter { item ->
+                    parseISO8601(item.deletedAt)?.after(lastSyncDate) == true
+                }
+
+        Log.d(
+                TAG,
+                "Delta sync sending: gyms=${modifiedGyms.size}, problems=${modifiedProblems.size}, sessions=${modifiedSessions.size}, attempts=${modifiedAttempts.size}, deletions=${modifiedDeletions.size}"
+        )
+
+        // Create delta request
+        val deltaRequest =
+                DeltaSyncRequest(
+                        lastSyncTime = lastSyncTimeStr,
+                        gyms = modifiedGyms,
+                        problems = modifiedProblems,
+                        sessions = modifiedSessions,
+                        attempts = modifiedAttempts,
+                        deletedItems = modifiedDeletions
+                )
+
+        val requestBody =
+                json.encodeToString(DeltaSyncRequest.serializer(), deltaRequest)
+                        .toRequestBody("application/json".toMediaType())
+
+        val request =
+                Request.Builder()
+                        .url("$serverUrl/sync/delta")
+                        .header("Authorization", "Bearer $authToken")
+                        .post(requestBody)
+                        .build()
+
+        val deltaResponse =
+                withContext(Dispatchers.IO) {
+                    try {
+                        httpClient.newCall(request).execute().use { response ->
+                            if (response.isSuccessful) {
+                                val body = response.body?.string()
+                                if (!body.isNullOrEmpty()) {
+                                    json.decodeFromString(DeltaSyncResponse.serializer(), body)
+                                } else {
+                                    throw SyncException.InvalidResponse("Empty response body")
+                                }
+                            } else {
+                                handleHttpError(response.code)
+                            }
+                        }
+                    } catch (e: IOException) {
+                        throw SyncException.NetworkError(e.message ?: "Network error")
+                    }
+                }
+
+        Log.d(
+                TAG,
+                "Delta sync received: gyms=${deltaResponse.gyms.size}, problems=${deltaResponse.problems.size}, sessions=${deltaResponse.sessions.size}, attempts=${deltaResponse.attempts.size}, deletions=${deltaResponse.deletedItems.size}"
+        )
+
+        // Apply server changes to local data
+        applyDeltaResponse(deltaResponse)
+
+        // Sync only modified problem images
+        syncModifiedImages(modifiedProblems)
+    }
+
+    private fun parseISO8601(dateString: String): Date? {
+        return try {
+            val format = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US)
+            format.parse(dateString)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private suspend fun applyDeltaResponse(response: DeltaSyncResponse) {
+        // Temporarily disable auto-sync to prevent recursive sync triggers
+        repository.setAutoSyncCallback(null)
+
+        try {
+            // Download images for new/modified problems from server
+            val imagePathMapping = mutableMapOf<String, String>()
+            for (problem in response.problems) {
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (e: Exception) {
+                        Log.w(TAG, "Failed to download image $imagePath: ${e.message}")
+                    }
+                }
+            }
+
+            // Merge gyms - check if exists and compare timestamps
+            val existingGyms = repository.getAllGyms().first()
+            for (backupGym in response.gyms) {
+                val existing = existingGyms.find { it.id == backupGym.id }
+                if (existing == null || backupGym.updatedAt >= existing.updatedAt) {
+                    val gym = backupGym.toGym()
+                    if (existing != null) {
+                        repository.updateGym(gym)
+                    } else {
+                        repository.insertGym(gym)
+                    }
+                }
+            }
+
+            // Merge problems
+            val existingProblems = repository.getAllProblems().first()
+            for (backupProblem in response.problems) {
+                val updatedImagePaths =
+                        backupProblem.imagePaths?.map { oldPath ->
+                            imagePathMapping[oldPath] ?: oldPath
+                        }
+                val problemToMerge = backupProblem.copy(imagePaths = updatedImagePaths)
+                val problem = problemToMerge.toProblem()
+
+                val existing = existingProblems.find { it.id == backupProblem.id }
+                if (existing == null || backupProblem.updatedAt >= existing.updatedAt) {
+                    if (existing != null) {
+                        repository.updateProblem(problem)
+                    } else {
+                        repository.insertProblem(problem)
+                    }
+                }
+            }
+
+            // Merge sessions
+            val existingSessions = repository.getAllSessions().first()
+            for (backupSession in response.sessions) {
+                val session = backupSession.toClimbSession()
+                val existing = existingSessions.find { it.id == backupSession.id }
+                if (existing == null || backupSession.updatedAt >= existing.updatedAt) {
+                    if (existing != null) {
+                        repository.updateSession(session)
+                    } else {
+                        repository.insertSession(session)
+                    }
+                }
+            }
+
+            // Merge attempts
+            val existingAttempts = repository.getAllAttempts().first()
+            for (backupAttempt in response.attempts) {
+                val attempt = backupAttempt.toAttempt()
+                val existing = existingAttempts.find { it.id == backupAttempt.id }
+                if (existing == null || backupAttempt.createdAt >= existing.createdAt) {
+                    if (existing != null) {
+                        repository.updateAttempt(attempt)
+                    } else {
+                        repository.insertAttempt(attempt)
+                    }
+                }
+            }
+
+            // Apply deletions
+            applyDeletions(response.deletedItems)
+
+            // Update deletion records
+            val allDeletions = repository.getDeletedItems() + response.deletedItems
+            repository.clearDeletedItems()
+            allDeletions.distinctBy { "${it.type}:${it.id}" }.forEach {
+                repository.trackDeletion(it.id, it.type)
+            }
+        } finally {
+            // Re-enable auto-sync
+            repository.setAutoSyncCallback { serviceScope.launch { triggerAutoSync() } }
+        }
+    }
+
+    private suspend fun applyDeletions(
+            deletions: List<com.atridad.ascently.data.format.DeletedItem>
+    ) {
+        val existingGyms = repository.getAllGyms().first()
+        val existingProblems = repository.getAllProblems().first()
+        val existingSessions = repository.getAllSessions().first()
+        val existingAttempts = repository.getAllAttempts().first()
+
+        for (item in deletions) {
+            when (item.type) {
+                "gym" -> {
+                    existingGyms.find { it.id == item.id }?.let { repository.deleteGym(it) }
+                }
+                "problem" -> {
+                    existingProblems.find { it.id == item.id }?.let { repository.deleteProblem(it) }
+                }
+                "session" -> {
+                    existingSessions.find { it.id == item.id }?.let { repository.deleteSession(it) }
+                }
+                "attempt" -> {
+                    existingAttempts.find { it.id == item.id }?.let { repository.deleteAttempt(it) }
+                }
+            }
+        }
+    }
+
+    private suspend fun syncModifiedImages(modifiedProblems: List<BackupProblem>) {
+        if (modifiedProblems.isEmpty()) return
+
+        Log.d(TAG, "Syncing images for ${modifiedProblems.size} modified problems")
+
+        for (backupProblem in modifiedProblems) {
+            backupProblem.imagePaths?.forEach { imagePath ->
+                val filename = imagePath.substringAfterLast('/')
+                uploadImage(imagePath, filename)
+            }
+        }
+    }
+
     private suspend fun downloadData(): ClimbDataBackup {
         val request =
                 Request.Builder()

android/app/src/main/java/com/atridad/ascently/utils/MigrationManager.kt

@@ -5,10 +5,6 @@ import android.content.SharedPreferences
 import android.util.Log
 import androidx.core.content.edit
 
-/**
- * Handles migration of data from OpenClimb to Ascently This includes SharedPreferences, database
- * names, and other local storage
- */
 class MigrationManager(private val context: Context) {
 
     companion object {

android/app/src/test/java/com/atridad/openclimb/SyncMergeLogicTest.kt

@@ -457,10 +457,6 @@ class SyncMergeLogicTest {
 
     @Test
     fun `test active sessions excluded from sync`() {
-        // Test scenario: Active sessions should not be included in sync data
-        // This tests the new behavior where active sessions are excluded from sync
-        // until they are completed
-
         val allLocalSessions =
                 listOf(
                         BackupClimbSession(