iOS 2.4.2 - Fixed Swipe Action Colours

Reviewed-on: #6

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 = 48
+        versionName = "2.4.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -38,7 +38,10 @@ android {
 
     java { toolchain { languageVersion.set(JavaLanguageVersion.of(17)) } }
 
-    buildFeatures { compose = true }
+    buildFeatures {
+        compose = true
+        buildConfig = true
+    }
 }
 
 kotlin { compilerOptions { jvmTarget.set(JvmTarget.JVM_17) } }

android/app/src/main/AndroidManifest.xml

@@ -27,6 +27,7 @@
 
     <!-- Permissions for notifications and foreground service -->
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.POST_PROMOTED_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
 

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

@@ -3,7 +3,7 @@ package com.atridad.ascently.data.health
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.SharedPreferences
-import android.util.Log
+import com.atridad.ascently.utils.AppLogger
 import androidx.activity.result.contract.ActivityResultContract
 import androidx.health.connect.client.HealthConnectClient
 import androidx.health.connect.client.PermissionController
@@ -31,7 +31,7 @@ import kotlinx.coroutines.flow.flow
 class HealthConnectManager(private val context: Context) {
 
     private val preferences: SharedPreferences =
-            context.getSharedPreferences("health_connect_prefs", Context.MODE_PRIVATE)
+        context.getSharedPreferences("health_connect_prefs", Context.MODE_PRIVATE)
 
     private val _isEnabled = MutableStateFlow(preferences.getBoolean("enabled", false))
     private val _hasPermissions = MutableStateFlow(preferences.getBoolean("permissions", false))
@@ -46,27 +46,26 @@ class HealthConnectManager(private val context: Context) {
         private const val TAG = "HealthConnectManager"
 
         val REQUIRED_PERMISSIONS =
-                setOf(
-                        HealthPermission.getReadPermission(ExerciseSessionRecord::class),
-                        HealthPermission.getWritePermission(ExerciseSessionRecord::class),
-                        HealthPermission.getReadPermission(HeartRateRecord::class),
-                        HealthPermission.getWritePermission(HeartRateRecord::class),
-                        HealthPermission.getReadPermission(TotalCaloriesBurnedRecord::class),
-                        HealthPermission.getWritePermission(TotalCaloriesBurnedRecord::class)
-                )
+            setOf(
+                HealthPermission.getReadPermission(ExerciseSessionRecord::class),
+                HealthPermission.getWritePermission(ExerciseSessionRecord::class),
+                HealthPermission.getReadPermission(HeartRateRecord::class),
+                HealthPermission.getWritePermission(HeartRateRecord::class),
+                HealthPermission.getReadPermission(TotalCaloriesBurnedRecord::class),
+                HealthPermission.getWritePermission(TotalCaloriesBurnedRecord::class)
+            )
     }
 
     private val healthConnectClient by lazy {
         try {
             HealthConnectClient.getOrCreate(context)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to create Health Connect client", e)
+            AppLogger.e(TAG, e) { "Failed to create Health Connect client" }
             _isCompatible.value = false
             null
         }
     }
 
-    /** Check if Health Connect is available on this device */
     fun isHealthConnectAvailable(): Flow<Boolean> = flow {
         try {
             if (!_isCompatible.value) {
@@ -76,16 +75,12 @@ class HealthConnectManager(private val context: Context) {
             val status = HealthConnectClient.getSdkStatus(context)
             emit(status == HealthConnectClient.SDK_AVAILABLE)
         } catch (e: Exception) {
-            Log.e(TAG, "Error checking Health Connect availability", e)
+            AppLogger.e(TAG, e) { "Error checking Health Connect availability" }
             _isCompatible.value = false
             emit(false)
         }
     }
 
-    /**
-     * 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
@@ -95,91 +90,85 @@ class HealthConnectManager(private val context: Context) {
             try {
                 val alreadyHasPermissions = hasAllPermissions()
                 if (!alreadyHasPermissions) {
-                    Log.d(TAG, "Health Connect enabled - permissions will be requested by UI")
+                    AppLogger.d(TAG) { "Health Connect enabled - permissions will be requested by UI" }
                 }
             } catch (e: Exception) {
-                Log.w(TAG, "Error checking permissions when enabling Health Connect", e)
+                AppLogger.w(TAG, e) { "Error checking permissions when enabling Health Connect" }
             }
         } else if (!enabled) {
             setPermissionsGranted(false)
         }
     }
 
-    /** 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) {
                 return false
             }
             val grantedPermissions =
-                    healthConnectClient!!.permissionController.getGrantedPermissions()
+                healthConnectClient!!.permissionController.getGrantedPermissions()
             val hasAll =
-                    REQUIRED_PERMISSIONS.all { permission ->
-                        grantedPermissions.contains(permission)
-                    }
+                REQUIRED_PERMISSIONS.all { permission ->
+                    grantedPermissions.contains(permission)
+                }
             setPermissionsGranted(hasAll)
             hasAll
         } catch (e: Exception) {
-            Log.e(TAG, "Error checking permissions", e)
+            AppLogger.e(TAG, e) { "Error checking permissions" }
             setPermissionsGranted(false)
             false
         }
     }
 
-    /** Check if Health Connect is ready for use */
     suspend fun isReady(): Boolean {
         return try {
             if (!_isEnabled.value || !_isCompatible.value || healthConnectClient == null)
-                    return false
+                return false
 
             val isAvailable =
-                    HealthConnectClient.getSdkStatus(context) == HealthConnectClient.SDK_AVAILABLE
+                HealthConnectClient.getSdkStatus(context) == HealthConnectClient.SDK_AVAILABLE
             val hasPerms = if (isAvailable) hasAllPermissions() else false
             isAvailable && hasPerms
         } catch (e: Exception) {
-            Log.e(TAG, "Error checking Health Connect readiness", e)
+            AppLogger.e(TAG, e) { "Error checking Health Connect readiness" }
             false
         }
     }
 
-    /** 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()
         } catch (e: Exception) {
-            Log.e(TAG, "Error getting required permissions", e)
+            AppLogger.e(TAG, e) { "Error getting required permissions" }
             emptySet()
         }
     }
 
-    /** Sync a completed climbing session to Health Connect (only when auto-sync is enabled) */
     @SuppressLint("RestrictedApi")
     suspend fun syncCompletedSession(
-            session: ClimbSession,
-            gymName: String,
-            attemptCount: Int = 0
+        session: ClimbSession,
+        gymName: String,
+        attemptCount: Int = 0
     ): Result<Unit> {
         return try {
             if (!isReady() || !_autoSync.value) {
                 return Result.failure(
-                        IllegalStateException("Health Connect not ready or auto-sync disabled")
+                    IllegalStateException("Health Connect not ready or auto-sync disabled")
                 )
             }
 
             if (session.status != SessionStatus.COMPLETED) {
                 return Result.failure(
-                        IllegalArgumentException("Only completed sessions can be synced")
+                    IllegalArgumentException("Only completed sessions can be synced")
                 )
             }
 
@@ -188,29 +177,29 @@ class HealthConnectManager(private val context: Context) {
 
             if (startTime == null || endTime == null) {
                 return Result.failure(
-                        IllegalArgumentException("Session must have valid start and end times")
+                    IllegalArgumentException("Session must have valid start and end times")
                 )
             }
 
-            Log.d(TAG, "Attempting to sync session '${session.id}' to Health Connect...")
+            AppLogger.d(TAG) { "Attempting to sync session '${session.id}' to Health Connect..." }
 
             val records = mutableListOf<androidx.health.connect.client.records.Record>()
 
             try {
                 val exerciseSession =
-                        ExerciseSessionRecord(
-                                startTime = startTime,
-                                startZoneOffset =
-                                        ZoneOffset.systemDefault().rules.getOffset(startTime),
-                                endTime = endTime,
-                                endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
-                                exerciseType =
-                                        ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING,
-                                title = "Rock Climbing at $gymName"
-                        )
+                    ExerciseSessionRecord(
+                        startTime = startTime,
+                        startZoneOffset =
+                            ZoneOffset.systemDefault().rules.getOffset(startTime),
+                        endTime = endTime,
+                        endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
+                        exerciseType =
+                            ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING,
+                        title = "Rock Climbing at $gymName"
+                    )
                 records.add(exerciseSession)
             } catch (e: Exception) {
-                Log.w(TAG, "Failed to create exercise session record", e)
+                AppLogger.w(TAG, e) { "Failed to create exercise session record" }
             }
 
             try {
@@ -219,109 +208,105 @@ class HealthConnectManager(private val context: Context) {
 
                 if (estimatedCalories > 0) {
                     val caloriesRecord =
-                            TotalCaloriesBurnedRecord(
-                                    startTime = startTime,
-                                    startZoneOffset =
-                                            ZoneOffset.systemDefault().rules.getOffset(startTime),
-                                    endTime = endTime,
-                                    endZoneOffset =
-                                            ZoneOffset.systemDefault().rules.getOffset(endTime),
-                                    energy = Energy.calories(estimatedCalories)
-                            )
+                        TotalCaloriesBurnedRecord(
+                            startTime = startTime,
+                            startZoneOffset =
+                                ZoneOffset.systemDefault().rules.getOffset(startTime),
+                            endTime = endTime,
+                            endZoneOffset =
+                                ZoneOffset.systemDefault().rules.getOffset(endTime),
+                            energy = Energy.calories(estimatedCalories)
+                        )
                     records.add(caloriesRecord)
                 }
             } catch (e: Exception) {
-                Log.w(TAG, "Failed to create calories record", e)
+                AppLogger.w(TAG, e) { "Failed to create calories record" }
             }
 
             try {
                 val heartRateRecord = createHeartRateRecord(startTime, endTime, attemptCount)
                 heartRateRecord?.let { records.add(it) }
             } catch (e: Exception) {
-                Log.w(TAG, "Failed to create heart rate record", e)
+                AppLogger.w(TAG, e) { "Failed to create heart rate record" }
             }
 
             if (records.isNotEmpty() && healthConnectClient != null) {
-                Log.d(TAG, "Writing ${records.size} records to Health Connect...")
+                AppLogger.d(TAG) { "Writing ${records.size} records to Health Connect..." }
                 healthConnectClient!!.insertRecords(records)
-                Log.i(
-                        TAG,
-                        "Successfully synced ${records.size} records for session '${session.id}' to Health Connect"
-                )
+                AppLogger.i(TAG) {
+                    "Successfully synced ${records.size} records for session '${session.id}' to Health Connect"
+                }
 
                 preferences
-                        .edit()
-                        .putString("last_sync_success", DateFormatUtils.nowISO8601())
-                        .apply()
+                    .edit()
+                    .putString("last_sync_success", DateFormatUtils.nowISO8601())
+                    .apply()
             } else {
                 val reason =
-                        when {
-                            records.isEmpty() -> "No records created"
-                            healthConnectClient == null -> "Health Connect client unavailable"
-                            else -> "Unknown reason"
-                        }
-                Log.w(TAG, "Sync failed for session '${session.id}': $reason")
+                    when {
+                        records.isEmpty() -> "No records created"
+                        healthConnectClient == null -> "Health Connect client unavailable"
+                        else -> "Unknown reason"
+                    }
+                AppLogger.w(TAG) { "Sync failed for session '${session.id}': $reason" }
                 return Result.failure(Exception("Sync failed: $reason"))
             }
 
             Result.success(Unit)
         } catch (e: Exception) {
-            Log.e(TAG, "Error syncing climbing session to Health Connect", e)
+            AppLogger.e(TAG, e) { "Error syncing climbing session to Health Connect" }
             Result.failure(e)
         }
     }
 
-    /** Auto-sync a completed session if enabled - this is the only way to sync sessions */
     suspend fun autoSyncCompletedSession(
-            session: ClimbSession,
-            gymName: String,
-            attemptCount: Int = 0
+        session: ClimbSession,
+        gymName: String,
+        attemptCount: Int = 0
     ): Result<Unit> {
         return if (_autoSync.value && isReady() && session.status == SessionStatus.COMPLETED) {
-            Log.d(TAG, "Auto-syncing completed session '${session.id}' to Health Connect...")
+            AppLogger.d(TAG) { "Auto-syncing completed session '${session.id}' to Health Connect..." }
             syncCompletedSession(session, gymName, attemptCount)
         } else {
             val reason =
-                    when {
-                        session.status != SessionStatus.COMPLETED -> "session not completed"
-                        !_autoSync.value -> "auto-sync disabled"
-                        !isReady() -> "Health Connect not ready"
-                        else -> "unknown reason"
-                    }
-            Log.d(TAG, "Auto-sync skipped for session '${session.id}': $reason")
+                when {
+                    session.status != SessionStatus.COMPLETED -> "session not completed"
+                    !_autoSync.value -> "auto-sync disabled"
+                    !isReady() -> "Health Connect not ready"
+                    else -> "unknown reason"
+                }
+            AppLogger.d(TAG) { "Auto-sync skipped for session '${session.id}': $reason" }
             Result.success(Unit)
         }
     }
 
-    /** Estimate calories burned during climbing */
     private fun estimateCaloriesForClimbing(durationMinutes: Long, attemptCount: Int): Double {
         val baseCaloriesPerMinute = 8.0
         val intensityMultiplier =
-                when {
-                    attemptCount >= 20 -> 1.3
-                    attemptCount >= 10 -> 1.1
-                    else -> 0.9
-                }
+            when {
+                attemptCount >= 20 -> 1.3
+                attemptCount >= 10 -> 1.1
+                else -> 0.9
+            }
         return durationMinutes * baseCaloriesPerMinute * intensityMultiplier
     }
 
-    /** Create heart rate data */
     @SuppressLint("RestrictedApi")
     private fun createHeartRateRecord(
-            startTime: Instant,
-            endTime: Instant,
-            attemptCount: Int
+        startTime: Instant,
+        endTime: Instant,
+        attemptCount: Int
     ): HeartRateRecord? {
         return try {
             val samples = mutableListOf<HeartRateRecord.Sample>()
             val intervalMinutes = 5L
 
             val baseHeartRate =
-                    when {
-                        attemptCount >= 20 -> 155L
-                        attemptCount >= 10 -> 145L
-                        else -> 135L
-                    }
+                when {
+                    attemptCount >= 20 -> 155L
+                    attemptCount >= 10 -> 145L
+                    else -> 135L
+                }
 
             var currentTime = startTime
             while (currentTime.isBefore(endTime)) {
@@ -335,21 +320,19 @@ class HealthConnectManager(private val context: Context) {
             if (samples.isEmpty()) return null
 
             HeartRateRecord(
-                    startTime = startTime,
-                    startZoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime),
-                    endTime = endTime,
-                    endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
-                    samples = samples
+                startTime = startTime,
+                startZoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime),
+                endTime = endTime,
+                endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
+                samples = samples
             )
         } catch (e: Exception) {
-            Log.e(TAG, "Error creating heart rate record", e)
+            AppLogger.e(TAG, e) { "Error creating heart rate record" }
             null
         }
     }
 
-    /** 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

@@ -13,6 +13,7 @@ import com.atridad.ascently.data.format.DeletedItem
 import com.atridad.ascently.data.model.*
 import com.atridad.ascently.data.state.DataStateManager
 import com.atridad.ascently.utils.DateFormatUtils
+import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.utils.ZipExportImportUtils
 import java.io.File
 import kotlinx.coroutines.flow.Flow
@@ -26,7 +27,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
     private val attemptDao = database.attemptDao()
     private val dataStateManager = DataStateManager(context)
     private val deletionPreferences: SharedPreferences =
-            context.getSharedPreferences("deleted_items", Context.MODE_PRIVATE)
+        context.getSharedPreferences("deleted_items", Context.MODE_PRIVATE)
 
     private var autoSyncCallback: (() -> Unit)? = null
 
@@ -43,11 +44,13 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         dataStateManager.updateDataState()
         triggerAutoSync()
     }
+
     suspend fun updateGym(gym: Gym) {
         gymDao.updateGym(gym)
         dataStateManager.updateDataState()
         triggerAutoSync()
     }
+
     suspend fun deleteGym(gym: Gym) {
         gymDao.deleteGym(gym)
         trackDeletion(gym.id, "gym")
@@ -63,10 +66,12 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         problemDao.insertProblem(problem)
         dataStateManager.updateDataState()
     }
+
     suspend fun updateProblem(problem: Problem) {
         problemDao.updateProblem(problem)
         dataStateManager.updateDataState()
     }
+
     suspend fun deleteProblem(problem: Problem) {
         problemDao.deleteProblem(problem)
         trackDeletion(problem.id, "problem")
@@ -77,7 +82,8 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
     fun getAllSessions(): Flow<List<ClimbSession>> = sessionDao.getAllSessions()
     suspend fun getSessionById(id: String): ClimbSession? = sessionDao.getSessionById(id)
     fun getSessionsByGym(gymId: String): Flow<List<ClimbSession>> =
-            sessionDao.getSessionsByGym(gymId)
+        sessionDao.getSessionsByGym(gymId)
+
     suspend fun getActiveSession(): ClimbSession? = sessionDao.getActiveSession()
     fun getActiveSessionFlow(): Flow<ClimbSession?> = sessionDao.getActiveSessionFlow()
     suspend fun insertSession(session: ClimbSession) {
@@ -88,6 +94,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             triggerAutoSync()
         }
     }
+
     suspend fun updateSession(session: ClimbSession) {
         sessionDao.updateSession(session)
         dataStateManager.updateDataState()
@@ -96,12 +103,14 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             triggerAutoSync()
         }
     }
+
     suspend fun deleteSession(session: ClimbSession) {
         sessionDao.deleteSession(session)
         trackDeletion(session.id, "session")
         dataStateManager.updateDataState()
         triggerAutoSync()
     }
+
     suspend fun getLastUsedGym(): Gym? {
         val recentSessions = sessionDao.getRecentSessions(1).first()
         return if (recentSessions.isNotEmpty()) {
@@ -114,17 +123,21 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
     // Attempt operations
     fun getAllAttempts(): Flow<List<Attempt>> = attemptDao.getAllAttempts()
     fun getAttemptsBySession(sessionId: String): Flow<List<Attempt>> =
-            attemptDao.getAttemptsBySession(sessionId)
+        attemptDao.getAttemptsBySession(sessionId)
+
     fun getAttemptsByProblem(problemId: String): Flow<List<Attempt>> =
-            attemptDao.getAttemptsByProblem(problemId)
+        attemptDao.getAttemptsByProblem(problemId)
+
     suspend fun insertAttempt(attempt: Attempt) {
         attemptDao.insertAttempt(attempt)
         dataStateManager.updateDataState()
     }
+
     suspend fun updateAttempt(attempt: Attempt) {
         attemptDao.updateAttempt(attempt)
         dataStateManager.updateDataState()
     }
+
     suspend fun deleteAttempt(attempt: Attempt) {
         attemptDao.deleteAttempt(attempt)
         trackDeletion(attempt.id, "attempt")
@@ -141,38 +154,38 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             validateDataIntegrity(allGyms, allProblems, allSessions, allAttempts)
 
             val backupData =
-                    ClimbDataBackup(
-                            exportedAt = DateFormatUtils.nowISO8601(),
-                            version = "2.0",
-                            formatVersion = "2.0",
-                            gyms = allGyms.map { BackupGym.fromGym(it) },
-                            problems = allProblems.map { BackupProblem.fromProblem(it) },
-                            sessions = allSessions.map { BackupClimbSession.fromClimbSession(it) },
-                            attempts = allAttempts.map { BackupAttempt.fromAttempt(it) }
-                    )
+                ClimbDataBackup(
+                    exportedAt = DateFormatUtils.nowISO8601(),
+                    version = "2.0",
+                    formatVersion = "2.0",
+                    gyms = allGyms.map { BackupGym.fromGym(it) },
+                    problems = allProblems.map { BackupProblem.fromProblem(it) },
+                    sessions = allSessions.map { BackupClimbSession.fromClimbSession(it) },
+                    attempts = allAttempts.map { BackupAttempt.fromAttempt(it) }
+                )
 
             val referencedImagePaths = allProblems.flatMap { it.imagePaths }.toSet()
             val validImagePaths =
-                    referencedImagePaths
-                            .filter { imagePath ->
-                                try {
-                                    val imageFile =
-                                            com.atridad.ascently.utils.ImageUtils.getImageFile(
-                                                    context,
-                                                    imagePath
-                                            )
-                                    imageFile.exists() && imageFile.length() > 0
-                                } catch (_: Exception) {
-                                    false
-                                }
-                            }
-                            .toSet()
+                referencedImagePaths
+                    .filter { imagePath ->
+                        try {
+                            val imageFile =
+                                com.atridad.ascently.utils.ImageUtils.getImageFile(
+                                    context,
+                                    imagePath
+                                )
+                            imageFile.exists() && imageFile.length() > 0
+                        } catch (_: Exception) {
+                            false
+                        }
+                    }
+                    .toSet()
 
             ZipExportImportUtils.createExportZipToUri(
-                    context = context,
-                    uri = uri,
-                    exportData = backupData,
-                    referencedImagePaths = validImagePaths
+                context = context,
+                uri = uri,
+                exportData = backupData,
+                referencedImagePaths = validImagePaths
             )
         } catch (e: Exception) {
             throw Exception("Export failed: ${e.message}")
@@ -192,11 +205,11 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             }
 
             val importData =
-                    try {
-                        json.decodeFromString<ClimbDataBackup>(importResult.jsonContent)
-                    } catch (e: Exception) {
-                        throw Exception("Invalid data format: ${e.message}")
-                    }
+                try {
+                    json.decodeFromString<ClimbDataBackup>(importResult.jsonContent)
+                } catch (e: Exception) {
+                    throw Exception("Invalid data format: ${e.message}")
+                }
 
             validateImportData(importData)
 
@@ -214,17 +227,17 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             }
 
             val updatedBackupProblems =
-                    ZipExportImportUtils.updateProblemImagePaths(
-                            importData.problems,
-                            importResult.importedImagePaths
-                    )
+                ZipExportImportUtils.updateProblemImagePaths(
+                    importData.problems,
+                    importResult.importedImagePaths
+                )
 
             updatedBackupProblems.forEach { backupProblem ->
                 try {
                     problemDao.insertProblem(backupProblem.toProblem())
                 } catch (e: Exception) {
                     throw Exception(
-                            "Failed to import problem '${backupProblem.name}': ${e.message}"
+                        "Failed to import problem '${backupProblem.name}': ${e.message}"
                     )
                 }
             }
@@ -251,26 +264,18 @@ 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())
+            DeletedItem(id = itemId, type = itemType, deletedAt = DateFormatUtils.nowISO8601())
         currentDeletions.add(newDeletion)
 
         val json = json.encodeToString(newDeletion)
@@ -300,23 +305,23 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
     }
 
     private fun validateDataIntegrity(
-            gyms: List<Gym>,
-            problems: List<Problem>,
-            sessions: List<ClimbSession>,
-            attempts: List<Attempt>
+        gyms: List<Gym>,
+        problems: List<Problem>,
+        sessions: List<ClimbSession>,
+        attempts: List<Attempt>
     ) {
         val gymIds = gyms.map { it.id }.toSet()
         val invalidProblems = problems.filter { it.gymId !in gymIds }
         if (invalidProblems.isNotEmpty()) {
             throw Exception(
-                    "Data integrity error: ${invalidProblems.size} problems reference non-existent gyms"
+                "Data integrity error: ${invalidProblems.size} problems reference non-existent gyms"
             )
         }
 
         val invalidSessions = sessions.filter { it.gymId !in gymIds }
         if (invalidSessions.isNotEmpty()) {
             throw Exception(
-                    "Data integrity error: ${invalidSessions.size} sessions reference non-existent gyms"
+                "Data integrity error: ${invalidSessions.size} sessions reference non-existent gyms"
             )
         }
 
@@ -324,10 +329,10 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         val sessionIds = sessions.map { it.id }.toSet()
 
         val invalidAttempts =
-                attempts.filter { it.problemId !in problemIds || it.sessionId !in sessionIds }
+            attempts.filter { it.problemId !in problemIds || it.sessionId !in sessionIds }
         if (invalidAttempts.isNotEmpty()) {
             throw Exception(
-                    "Data integrity error: ${invalidAttempts.size} attempts reference non-existent problems or sessions"
+                "Data integrity error: ${invalidAttempts.size} attempts reference non-existent problems or sessions"
             )
         }
     }
@@ -342,9 +347,9 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         }
 
         if (importData.gyms.size > 1000 ||
-                        importData.problems.size > 10000 ||
-                        importData.sessions.size > 10000 ||
-                        importData.attempts.size > 100000
+            importData.problems.size > 10000 ||
+            importData.sessions.size > 10000 ||
+            importData.attempts.size > 100000
         ) {
             throw Exception("Import data is too large: possible corruption or malicious file")
         }
@@ -394,10 +399,10 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             if (imagesDir.exists() && imagesDir.isDirectory) {
                 val deletedCount = imagesDir.listFiles()?.size ?: 0
                 imagesDir.deleteRecursively()
-                android.util.Log.i("ClimbRepository", "Cleared $deletedCount image files")
+                AppLogger.i("ClimbRepository") { "Cleared $deletedCount image files" }
             }
         } catch (e: Exception) {
-            android.util.Log.w("ClimbRepository", "Failed to clear some images: ${e.message}")
+            AppLogger.w("ClimbRepository", e) { "Failed to clear some images: ${e.message}" }
         }
     }
 }

android/app/src/main/java/com/atridad/ascently/data/state/DataStateManager.kt

@@ -2,8 +2,8 @@ package com.atridad.ascently.data.state
 
 import android.content.Context
 import android.content.SharedPreferences
-import android.util.Log
 import androidx.core.content.edit
+import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.utils.DateFormatUtils
 
 /**
@@ -20,13 +20,13 @@ class DataStateManager(context: Context) {
     }
 
     private val prefs: SharedPreferences =
-            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
 
     init {
         if (!isInitialized()) {
             updateDataState()
             markAsInitialized()
-            Log.d(TAG, "DataStateManager initialized with timestamp: ${getLastModified()}")
+            AppLogger.d(TAG) { "DataStateManager initialized with timestamp: ${getLastModified()}" }
         }
     }
 
@@ -37,7 +37,7 @@ class DataStateManager(context: Context) {
     fun updateDataState() {
         val now = DateFormatUtils.nowISO8601()
         prefs.edit { putString(KEY_LAST_MODIFIED, now) }
-        Log.d(TAG, "Data state updated to: $now")
+        AppLogger.d(TAG) { "Data state updated to: $now" }
     }
 
     /**
@@ -46,7 +46,7 @@ class DataStateManager(context: Context) {
      */
     fun getLastModified(): String {
         return prefs.getString(KEY_LAST_MODIFIED, DateFormatUtils.nowISO8601())
-                ?: DateFormatUtils.nowISO8601()
+            ?: DateFormatUtils.nowISO8601()
     }
 
     /** Checks if the data state has been initialized. */

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

@@ -0,0 +1,741 @@
+package com.atridad.ascently.data.sync
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import androidx.annotation.RequiresPermission
+import androidx.core.content.edit
+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.ClimbDataBackup
+import com.atridad.ascently.data.repository.ClimbRepository
+import com.atridad.ascently.data.state.DataStateManager
+import com.atridad.ascently.utils.AppLogger
+import com.atridad.ascently.utils.DateFormatUtils
+import com.atridad.ascently.utils.ImageNamingUtils
+import com.atridad.ascently.utils.ImageUtils
+import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+
+class AscentlySyncProvider(
+    private val context: Context,
+    private val repository: ClimbRepository
+) : SyncProvider {
+
+    override val type: SyncProviderType = SyncProviderType.SERVER
+
+    private val dataStateManager = DataStateManager(context)
+
+    companion object {
+        private const val TAG = "AscentlySyncProvider"
+    }
+
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+
+    private val httpClient =
+        OkHttpClient.Builder()
+            .connectTimeout(45, TimeUnit.SECONDS)
+            .readTimeout(90, TimeUnit.SECONDS)
+            .writeTimeout(90, TimeUnit.SECONDS)
+            .build()
+
+    private val json = Json {
+        prettyPrint = true
+        ignoreUnknownKeys = true
+        explicitNulls = false
+        coerceInputValues = true
+    }
+
+    private val _isConnected = MutableStateFlow(false)
+    override val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
+
+    private val _isConfigured = MutableStateFlow(false)
+    override val isConfigured: StateFlow<Boolean> = _isConfigured.asStateFlow()
+
+    private var isOfflineMode = false
+
+    private object Keys {
+        const val SERVER_URL = "server_url"
+        const val AUTH_TOKEN = "auth_token"
+        const val IS_CONNECTED = "is_connected"
+        const val LAST_SYNC_TIME = "last_sync_time"
+        const val OFFLINE_MODE = "offline_mode"
+    }
+
+    init {
+        loadInitialState()
+        updateConfiguredState()
+    }
+
+    private fun loadInitialState() {
+        _isConnected.value = sharedPreferences.getBoolean(Keys.IS_CONNECTED, false)
+        isOfflineMode = sharedPreferences.getBoolean(Keys.OFFLINE_MODE, false)
+    }
+
+    private fun updateConfiguredState() {
+        _isConfigured.value = serverUrl.isNotBlank() && authToken.isNotBlank()
+    }
+
+    var serverUrl: String
+        get() = sharedPreferences.getString(Keys.SERVER_URL, "") ?: ""
+        set(value) {
+            sharedPreferences.edit { putString(Keys.SERVER_URL, value) }
+            updateConfiguredState()
+            _isConnected.value = false
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+        }
+
+    var authToken: String
+        get() = sharedPreferences.getString(Keys.AUTH_TOKEN, "") ?: ""
+        set(value) {
+            sharedPreferences.edit { putString(Keys.AUTH_TOKEN, value) }
+            updateConfiguredState()
+            _isConnected.value = false
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+        }
+
+    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
+    private fun isNetworkAvailable(): Boolean {
+        val connectivityManager =
+            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val network = connectivityManager.activeNetwork ?: return false
+        val activeNetwork = connectivityManager.getNetworkCapabilities(network) ?: return false
+        return when {
+            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
+            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
+            else -> false
+        }
+    }
+
+    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
+    override suspend fun sync() {
+        if (isOfflineMode) {
+            AppLogger.d(TAG) { "Sync skipped: Offline mode is enabled." }
+            return
+        }
+        if (!isNetworkAvailable()) {
+            AppLogger.d(TAG) { "Sync skipped: No internet connection." }
+            throw SyncException.NetworkError("No internet connection.")
+        }
+        if (!_isConfigured.value) {
+            throw SyncException.NotConfigured
+        }
+        if (!_isConnected.value) {
+            throw SyncException.NotConnected
+        }
+
+        val localBackup = createBackupFromRepository()
+        val serverBackup = downloadData()
+
+        val hasLocalData =
+            localBackup.gyms.isNotEmpty() ||
+                    localBackup.problems.isNotEmpty() ||
+                    localBackup.sessions.isNotEmpty() ||
+                    localBackup.attempts.isNotEmpty()
+
+        val hasServerData =
+            serverBackup.gyms.isNotEmpty() ||
+                    serverBackup.problems.isNotEmpty() ||
+                    serverBackup.sessions.isNotEmpty() ||
+                    serverBackup.attempts.isNotEmpty()
+
+        val lastSyncTimeStr = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
+        if (hasLocalData && hasServerData && lastSyncTimeStr != null) {
+            AppLogger.d(TAG) { "Using delta sync for incremental updates" }
+            performDeltaSync(lastSyncTimeStr)
+        } else {
+            when {
+                !hasLocalData && hasServerData -> {
+                    AppLogger.d(TAG) { "No local data found, performing full restore from server" }
+                    val imagePathMapping = syncImagesFromServer(serverBackup)
+                    importBackupToRepository(serverBackup, imagePathMapping)
+                    AppLogger.d(TAG) { "Full restore completed" }
+                }
+
+                hasLocalData && !hasServerData -> {
+                    AppLogger.d(TAG) { "No server data found, uploading local data to server" }
+                    uploadData(localBackup)
+                    syncImagesForBackup(localBackup)
+                    AppLogger.d(TAG) { "Initial upload completed" }
+                }
+
+                hasLocalData && hasServerData -> {
+                    AppLogger.d(TAG) { "Both local and server data exist, merging (server wins)" }
+                    mergeDataSafely(serverBackup)
+                    AppLogger.d(TAG) { "Merge completed" }
+                }
+
+                else -> {
+                    AppLogger.d(TAG) { "No data to sync" }
+                }
+            }
+        }
+
+        val now = DateFormatUtils.nowISO8601()
+        sharedPreferences.edit { putString(Keys.LAST_SYNC_TIME, now) }
+    }
+
+    override fun disconnect() {
+        serverUrl = ""
+        authToken = ""
+        _isConnected.value = false
+        sharedPreferences.edit {
+            remove(Keys.LAST_SYNC_TIME)
+            putBoolean(Keys.IS_CONNECTED, false)
+        }
+        updateConfiguredState()
+    }
+
+    private suspend fun performDeltaSync(lastSyncTimeStr: String) {
+        AppLogger.d(TAG) { "Starting delta sync with lastSyncTime=$lastSyncTimeStr" }
+
+        val lastSyncDate = parseISO8601(lastSyncTimeStr) ?: Date(0)
+
+        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
+            }
+
+        AppLogger.d(TAG) {
+            "Delta sync sending: gyms=${modifiedGyms.size}, problems=${modifiedProblems.size}, sessions=${modifiedSessions.size}, attempts=${modifiedAttempts.size}, deletions=${modifiedDeletions.size}"
+        }
+
+        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")
+                }
+            }
+
+        AppLogger.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}"
+        }
+
+        applyDeltaResponse(deltaResponse)
+        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 (_: Exception) {
+            null
+        }
+    }
+
+    private suspend fun applyDeltaResponse(response: DeltaSyncResponse) {
+        // SyncService handles the "isSyncing" state to prevent recursive sync triggers
+        // when the repository is modified during a sync operation.
+
+        try {
+            // Merge and apply deletions first to prevent resurrection
+            val allDeletions = repository.getDeletedItems() + response.deletedItems
+            val uniqueDeletions = allDeletions.distinctBy { "${it.type}:${it.id}" }
+
+            AppLogger.d(TAG) { "Applying ${uniqueDeletions.size} deletion records before merging data" }
+            applyDeletions(uniqueDeletions)
+
+            // Build deleted item lookup set
+            val deletedItemSet = uniqueDeletions.map { "${it.type}:${it.id}" }.toSet()
+
+            // Download images for new/modified problems from server
+            val imagePathMapping = mutableMapOf<String, String>()
+            for (problem in response.problems) {
+                if (deletedItemSet.contains("problem:${problem.id}")) {
+                    continue
+                }
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (e: Exception) {
+                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
+                    }
+                }
+            }
+
+            // Merge gyms
+            val existingGyms = repository.getAllGyms().first()
+            for (backupGym in response.gyms) {
+                if (deletedItemSet.contains("gym:${backupGym.id}")) {
+                    continue
+                }
+                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) {
+                if (deletedItemSet.contains("problem:${backupProblem.id}")) {
+                    continue
+                }
+                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) {
+                if (deletedItemSet.contains("session:${backupSession.id}")) {
+                    continue
+                }
+                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) {
+                if (deletedItemSet.contains("attempt:${backupAttempt.id}")) {
+                    continue
+                }
+                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 again for safety
+            applyDeletions(uniqueDeletions)
+
+            // Update deletion records
+            repository.clearDeletedItems()
+            uniqueDeletions.forEach { repository.trackDeletion(it.id, it.type) }
+        } catch (e: Exception) {
+            AppLogger.e(TAG, e) { "Error applying delta response" }
+            throw e
+        }
+    }
+
+    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
+
+        AppLogger.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()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .get()
+                .build()
+
+        return withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        val body = response.body?.string()
+                        if (!body.isNullOrEmpty()) {
+                            json.decodeFromString(body)
+                        } else {
+                            ClimbDataBackup(
+                                exportedAt = DateFormatUtils.nowISO8601(),
+                                gyms = emptyList(),
+                                problems = emptyList(),
+                                sessions = emptyList(),
+                                attempts = emptyList()
+                            )
+                        }
+                    } else {
+                        handleHttpError(response.code)
+                    }
+                }
+            } catch (e: IOException) {
+                throw SyncException.NetworkError(e.message ?: "Network error")
+            }
+        }
+    }
+
+    private suspend fun uploadData(backup: ClimbDataBackup) {
+        val requestBody =
+            json.encodeToString(backup).toRequestBody("application/json".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .put(requestBody)
+                .build()
+
+        withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (!response.isSuccessful) {
+                        handleHttpError(response.code)
+                    }
+                }
+            } catch (e: IOException) {
+                throw SyncException.NetworkError(e.message ?: "Network error")
+            }
+        }
+    }
+
+    private suspend fun syncImagesFromServer(backup: ClimbDataBackup): Map<String, String> {
+        val imagePathMapping = mutableMapOf<String, String>()
+        val totalImages = backup.problems.sumOf { it.imagePaths?.size ?: 0 }
+        AppLogger.d(TAG) { "Starting image download from server for $totalImages images" }
+
+        withContext(Dispatchers.IO) {
+            backup.problems.forEach { problem ->
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (_: SyncException.ImageNotFound) {
+                        AppLogger.w(TAG) { "Image not found on server: $imagePath" }
+                    } catch (e: CancellationException) {
+                        throw e
+                    } catch (e: Exception) {
+                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
+                    }
+                }
+            }
+        }
+        return imagePathMapping
+    }
+
+    private suspend fun downloadImage(serverFilename: String): String? {
+        val request =
+            Request.Builder()
+                .url("$serverUrl/images/download?filename=$serverFilename")
+                .header("Authorization", "Bearer $authToken")
+                .build()
+
+        return withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        response.body?.bytes()?.let {
+                            ImageUtils.saveImageFromBytesWithFilename(context, it, serverFilename)
+                        }
+                    } else {
+                        if (response.code == 404) throw SyncException.ImageNotFound
+                        null
+                    }
+                }
+            } catch (e: IOException) {
+                AppLogger.e(TAG, e) { "Network error downloading image $serverFilename" }
+                null
+            }
+        }
+    }
+
+    private suspend fun syncImagesForBackup(backup: ClimbDataBackup) {
+        AppLogger.d(TAG) { "Starting image sync for backup with ${backup.problems.size} problems" }
+        withContext(Dispatchers.IO) {
+            backup.problems.forEach { problem ->
+                problem.imagePaths?.forEach { localPath ->
+                    val filename = localPath.substringAfterLast('/')
+                    uploadImage(localPath, filename)
+                }
+            }
+        }
+    }
+
+    private suspend fun uploadImage(localPath: String, filename: String) {
+        val file = ImageUtils.getImageFile(context, localPath)
+        if (!file.exists()) {
+            AppLogger.w(TAG) { "Local image file not found, cannot upload: $localPath" }
+            return
+        }
+
+        val requestBody = file.readBytes().toRequestBody("application/octet-stream".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/images/upload?filename=$filename")
+                .header("Authorization", "Bearer $authToken")
+                .post(requestBody)
+                .build()
+
+        withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        AppLogger.d(TAG) { "Successfully uploaded image: $filename" }
+                    } else {
+                        AppLogger.w(TAG) {
+                            "Failed to upload image $filename. Server responded with ${response.code}"
+                        }
+                    }
+                }
+            } catch (e: IOException) {
+                AppLogger.e(TAG, e) { "Network error uploading image $filename" }
+            }
+        }
+    }
+
+    private suspend fun createBackupFromRepository(): ClimbDataBackup {
+        return withContext(Dispatchers.Default) {
+            ClimbDataBackup(
+                exportedAt = dataStateManager.getLastModified(),
+                gyms = repository.getAllGyms().first().map { BackupGym.fromGym(it) },
+                problems =
+                    repository.getAllProblems().first().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
+                        }
+                    },
+                sessions =
+                    repository.getAllSessions().first().map {
+                        BackupClimbSession.fromClimbSession(it)
+                    },
+                attempts =
+                    repository.getAllAttempts().first().map {
+                        BackupAttempt.fromAttempt(it)
+                    },
+                deletedItems = repository.getDeletedItems()
+            )
+        }
+    }
+
+    private suspend fun importBackupToRepository(
+        backup: ClimbDataBackup,
+        imagePathMapping: Map<String, String>
+    ) {
+        val gyms = backup.gyms.map { it.toGym() }
+        val problems =
+            backup.problems.map { backupProblem ->
+                val imagePaths = backupProblem.imagePaths
+                val updatedImagePaths =
+                    imagePaths?.map { oldPath -> imagePathMapping[oldPath] ?: oldPath }
+                backupProblem.copy(imagePaths = updatedImagePaths).toProblem()
+            }
+        val sessions = backup.sessions.map { it.toClimbSession() }
+        val attempts = backup.attempts.map { it.toAttempt() }
+
+        repository.resetAllData()
+
+        gyms.forEach { repository.insertGymWithoutSync(it) }
+        problems.forEach { repository.insertProblemWithoutSync(it) }
+        sessions.forEach { repository.insertSessionWithoutSync(it) }
+        attempts.forEach { repository.insertAttemptWithoutSync(it) }
+
+        repository.clearDeletedItems()
+    }
+
+    private suspend fun mergeDataSafely(serverBackup: ClimbDataBackup) {
+        AppLogger.d(TAG) { "Server data will overwrite local data. Performing full restore." }
+        val imagePathMapping = syncImagesFromServer(serverBackup)
+        importBackupToRepository(serverBackup, imagePathMapping)
+    }
+
+    private fun handleHttpError(code: Int): Nothing {
+        when (code) {
+            401 -> throw SyncException.Unauthorized
+            in 500..599 -> throw SyncException.ServerError(code)
+            else -> throw SyncException.InvalidResponse("HTTP error code: $code")
+        }
+    }
+
+    override suspend fun testConnection() {
+        if (!_isConfigured.value) {
+            _isConnected.value = false
+            throw SyncException.NotConfigured
+        }
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .head()
+                .build()
+        try {
+            withContext(Dispatchers.IO) {
+                httpClient.newCall(request).execute().use { response ->
+                    _isConnected.value = response.isSuccessful || response.code == 405
+                }
+            }
+            if (!_isConnected.value) {
+                throw SyncException.NotConnected
+            }
+        } catch (e: Exception) {
+            _isConnected.value = false
+            throw SyncException.NetworkError(e.message ?: "Connection error")
+        } finally {
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, _isConnected.value) }
+        }
+    }
+}

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/SyncException.kt

@@ -0,0 +1,21 @@
+package com.atridad.ascently.data.sync
+
+import java.io.IOException
+import java.io.Serializable
+
+sealed class SyncException(message: String) : IOException(message), Serializable {
+    object NotConfigured :
+        SyncException("Sync is not configured. Please set server URL and auth token.")
+
+    object NotConnected : SyncException("Not connected to server. Please test connection first.")
+
+    object Unauthorized : SyncException("Unauthorized. Please check your auth token.")
+
+    object ImageNotFound : SyncException("Image not found on server")
+
+    data class ServerError(val code: Int) : SyncException("Server error: HTTP $code")
+    data class InvalidResponse(val details: String) :
+        SyncException("Invalid server response: $details")
+
+    data class NetworkError(val details: String) : SyncException("Network error: $details")
+}

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

@@ -0,0 +1,18 @@
+package com.atridad.ascently.data.sync
+
+import kotlinx.coroutines.flow.StateFlow
+
+interface SyncProvider {
+    val type: SyncProviderType
+    val isConfigured: StateFlow<Boolean>
+    val isConnected: StateFlow<Boolean>
+    
+    suspend fun sync()
+    suspend fun testConnection()
+    fun disconnect()
+}
+
+enum class SyncProviderType {
+    NONE,
+    SERVER
+}

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

@@ -2,24 +2,9 @@ package com.atridad.ascently.data.sync
 
 import android.content.Context
 import android.content.SharedPreferences
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import android.util.Log
-import androidx.annotation.RequiresPermission
 import androidx.core.content.edit
-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.ClimbDataBackup
 import com.atridad.ascently.data.repository.ClimbRepository
-import com.atridad.ascently.data.state.DataStateManager
-import com.atridad.ascently.utils.DateFormatUtils
-import com.atridad.ascently.utils.ImageNamingUtils
-import com.atridad.ascently.utils.ImageUtils
-import java.io.IOException
-import java.io.Serializable
-import java.util.concurrent.TimeUnit
+import com.atridad.ascently.utils.AppLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -28,42 +13,21 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-import kotlinx.serialization.json.Json
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
 
 class SyncService(private val context: Context, private val repository: ClimbRepository) {
 
-    private val dataStateManager = DataStateManager(context)
-    private val syncMutex = Mutex()
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val syncMutex = Mutex()
 
     companion object {
         private const val TAG = "SyncService"
     }
 
-    private val sharedPreferences: SharedPreferences =
-            context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
-
-    private val httpClient =
-            OkHttpClient.Builder()
-                    .connectTimeout(45, TimeUnit.SECONDS)
-                    .readTimeout(90, TimeUnit.SECONDS)
-                    .writeTimeout(90, TimeUnit.SECONDS)
-                    .build()
-
-    private val json = Json {
-        prettyPrint = true
-        ignoreUnknownKeys = true
-        explicitNulls = false
-    }
+    // Currently we only support one provider, but this allows for future expansion
+    private val provider: SyncProvider = AscentlySyncProvider(context, repository)
 
     // State
     private val _isSyncing = MutableStateFlow(false)
@@ -75,11 +39,9 @@ class SyncService(private val context: Context, private val repository: ClimbRep
     private val _syncError = MutableStateFlow<String?>(null)
     val syncError: StateFlow<String?> = _syncError.asStateFlow()
 
-    private val _isConnected = MutableStateFlow(false)
-    val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
-
-    private val _isConfigured = MutableStateFlow(false)
-    val isConfiguredFlow: StateFlow<Boolean> = _isConfigured.asStateFlow()
+    // Delegate to provider
+    val isConnected: StateFlow<Boolean> = provider.isConnected
+    val isConfiguredFlow: StateFlow<Boolean> = provider.isConfigured
 
     private val _isTesting = MutableStateFlow(false)
     val isTesting: StateFlow<Boolean> = _isTesting.asStateFlow()
@@ -87,56 +49,40 @@ class SyncService(private val context: Context, private val repository: ClimbRep
     private val _isAutoSyncEnabled = MutableStateFlow(true)
     val isAutoSyncEnabled: StateFlow<Boolean> = _isAutoSyncEnabled.asStateFlow()
 
-    private var isOfflineMode = false
-
     // Debounced sync properties
     private var syncJob: Job? = null
     private var pendingChanges = false
     private val syncDebounceDelay = 2000L // 2 seconds
 
-    // Configuration keys
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+
     private object Keys {
-        const val SERVER_URL = "server_url"
-        const val AUTH_TOKEN = "auth_token"
-        const val IS_CONNECTED = "is_connected"
         const val LAST_SYNC_TIME = "last_sync_time"
         const val AUTO_SYNC_ENABLED = "auto_sync_enabled"
-        const val OFFLINE_MODE = "offline_mode"
     }
 
     init {
         loadInitialState()
-        updateConfiguredState()
         repository.setAutoSyncCallback { serviceScope.launch { triggerAutoSync() } }
     }
 
     private fun loadInitialState() {
         _lastSyncTime.value = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
-        _isConnected.value = sharedPreferences.getBoolean(Keys.IS_CONNECTED, false)
         _isAutoSyncEnabled.value = sharedPreferences.getBoolean(Keys.AUTO_SYNC_ENABLED, true)
-        isOfflineMode = sharedPreferences.getBoolean(Keys.OFFLINE_MODE, false)
-    }
-
-    private fun updateConfiguredState() {
-        _isConfigured.value = serverUrl.isNotBlank() && authToken.isNotBlank()
     }
 
+    // Proxy properties for Ascently provider configuration
     var serverUrl: String
-        get() = sharedPreferences.getString(Keys.SERVER_URL, "") ?: ""
+        get() = (provider as? AscentlySyncProvider)?.serverUrl ?: ""
         set(value) {
-            sharedPreferences.edit { putString(Keys.SERVER_URL, value) }
-            updateConfiguredState()
-            _isConnected.value = false
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+            (provider as? AscentlySyncProvider)?.serverUrl = value
         }
 
     var authToken: String
-        get() = sharedPreferences.getString(Keys.AUTH_TOKEN, "") ?: ""
+        get() = (provider as? AscentlySyncProvider)?.authToken ?: ""
         set(value) {
-            sharedPreferences.edit { putString(Keys.AUTH_TOKEN, value) }
-            updateConfiguredState()
-            _isConnected.value = false
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+            (provider as? AscentlySyncProvider)?.authToken = value
         }
 
     fun setAutoSyncEnabled(enabled: Boolean) {
@@ -144,83 +90,21 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         sharedPreferences.edit { putBoolean(Keys.AUTO_SYNC_ENABLED, enabled) }
     }
 
-    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
-    private fun isNetworkAvailable(): Boolean {
-        val connectivityManager =
-                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-        val network = connectivityManager.activeNetwork ?: return false
-        val activeNetwork = connectivityManager.getNetworkCapabilities(network) ?: return false
-        return when {
-            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
-            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
-            else -> false
-        }
-    }
-
-    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
     suspend fun syncWithServer() {
-        if (isOfflineMode) {
-            Log.d(TAG, "Sync skipped: Offline mode is enabled.")
-            return
-        }
-        if (!isNetworkAvailable()) {
-            _syncError.value = "No internet connection."
-            Log.d(TAG, "Sync skipped: No internet connection.")
-            return
-        }
-        if (!_isConfigured.value) {
+        if (!isConfiguredFlow.value) {
             throw SyncException.NotConfigured
         }
-        if (!_isConnected.value) {
-            throw SyncException.NotConnected
-        }
 
         syncMutex.withLock {
             _isSyncing.value = true
             _syncError.value = null
 
             try {
-                val localBackup = createBackupFromRepository()
-                val serverBackup = downloadData()
-
-                val hasLocalData =
-                        localBackup.gyms.isNotEmpty() ||
-                                localBackup.problems.isNotEmpty() ||
-                                localBackup.sessions.isNotEmpty() ||
-                                localBackup.attempts.isNotEmpty()
-
-                val hasServerData =
-                        serverBackup.gyms.isNotEmpty() ||
-                                serverBackup.problems.isNotEmpty() ||
-                                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")
-                    }
-                }
-
-                val now = DateFormatUtils.nowISO8601()
-                _lastSyncTime.value = now
-                sharedPreferences.edit { putString(Keys.LAST_SYNC_TIME, now) }
+                provider.sync()
+                
+                // Update last sync time from shared prefs (provider updates it)
+                _lastSyncTime.value = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
+                
             } catch (e: Exception) {
                 _syncError.value = e.message
                 throw e
@@ -230,269 +114,21 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         }
     }
 
-    private suspend fun downloadData(): ClimbDataBackup {
-        val request =
-                Request.Builder()
-                        .url("$serverUrl/sync")
-                        .header("Authorization", "Bearer $authToken")
-                        .get()
-                        .build()
-
-        return withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        val body = response.body?.string()
-                        if (!body.isNullOrEmpty()) {
-                            json.decodeFromString(body)
-                        } else {
-                            ClimbDataBackup(
-                                    exportedAt = DateFormatUtils.nowISO8601(),
-                                    gyms = emptyList(),
-                                    problems = emptyList(),
-                                    sessions = emptyList(),
-                                    attempts = emptyList()
-                            )
-                        }
-                    } else {
-                        handleHttpError(response.code)
-                    }
-                }
-            } catch (e: IOException) {
-                throw SyncException.NetworkError(e.message ?: "Network error")
-            }
-        }
-    }
-
-    private suspend fun uploadData(backup: ClimbDataBackup) {
-        val requestBody =
-                json.encodeToString(backup).toRequestBody("application/json".toMediaType())
-
-        val request =
-                Request.Builder()
-                        .url("$serverUrl/sync")
-                        .header("Authorization", "Bearer $authToken")
-                        .post(requestBody)
-                        .build()
-
-        withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (!response.isSuccessful) {
-                        handleHttpError(response.code)
-                    }
-                }
-            } catch (e: IOException) {
-                throw SyncException.NetworkError(e.message ?: "Network error")
-            }
-        }
-    }
-
-    private suspend fun syncImagesFromServer(backup: ClimbDataBackup): Map<String, String> {
-        val imagePathMapping = mutableMapOf<String, String>()
-        val totalImages = backup.problems.sumOf { it.imagePaths?.size ?: 0 }
-        Log.d(TAG, "Starting image download from server for $totalImages images")
-
-        withContext(Dispatchers.IO) {
-            backup.problems.forEach { problem ->
-                problem.imagePaths?.forEach { imagePath ->
-                    val serverFilename = imagePath.substringAfterLast('/')
-                    try {
-                        val localImagePath = downloadImage(serverFilename)
-                        if (localImagePath != null) {
-                            imagePathMapping[imagePath] = localImagePath
-                        }
-                    } catch (_: SyncException.ImageNotFound) {
-                        Log.w(TAG, "Image not found on server: $imagePath")
-                    } catch (e: Exception) {
-                        Log.w(TAG, "Failed to download image $imagePath: ${e.message}")
-                    }
-                }
-            }
-        }
-        return imagePathMapping
-    }
-
-    private suspend fun downloadImage(serverFilename: String): String? {
-        val request =
-                Request.Builder()
-                        .url("$serverUrl/images/download?filename=$serverFilename")
-                        .header("Authorization", "Bearer $authToken")
-                        .build()
-
-        return withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        response.body?.bytes()?.let {
-                            ImageUtils.saveImageFromBytesWithFilename(context, it, serverFilename)
-                        }
-                    } else {
-                        if (response.code == 404) throw SyncException.ImageNotFound
-                        null
-                    }
-                }
-            } catch (e: IOException) {
-                Log.e(TAG, "Network error downloading image $serverFilename", e)
-                null
-            }
-        }
-    }
-
-    private suspend fun syncImagesForBackup(backup: ClimbDataBackup) {
-        Log.d(TAG, "Starting image sync for backup with ${backup.problems.size} problems")
-        withContext(Dispatchers.IO) {
-            backup.problems.forEach { problem ->
-                problem.imagePaths?.forEach { localPath ->
-                    val filename = localPath.substringAfterLast('/')
-                    uploadImage(localPath, filename)
-                }
-            }
-        }
-    }
-
-    private suspend fun uploadImage(localPath: String, filename: String) {
-        val file = ImageUtils.getImageFile(context, localPath)
-        if (!file.exists()) {
-            Log.w(TAG, "Local image file not found, cannot upload: $localPath")
-            return
-        }
-
-        val requestBody = file.readBytes().toRequestBody("application/octet-stream".toMediaType())
-
-        val request =
-                Request.Builder()
-                        .url("$serverUrl/images/upload?filename=$filename")
-                        .header("Authorization", "Bearer $authToken")
-                        .post(requestBody)
-                        .build()
-
-        withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        Log.d(TAG, "Successfully uploaded image: $filename")
-                    } else {
-                        Log.w(
-                                TAG,
-                                "Failed to upload image $filename. Server responded with ${response.code}"
-                        )
-                    }
-                }
-            } catch (e: IOException) {
-                Log.e(TAG, "Network error uploading image $filename", e)
-            }
-        }
-    }
-
-    private suspend fun createBackupFromRepository(): ClimbDataBackup {
-        return withContext(Dispatchers.Default) {
-            ClimbDataBackup(
-                    exportedAt = dataStateManager.getLastModified(),
-                    gyms = repository.getAllGyms().first().map { BackupGym.fromGym(it) },
-                    problems =
-                            repository.getAllProblems().first().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
-                                }
-                            },
-                    sessions =
-                            repository.getAllSessions().first().map {
-                                BackupClimbSession.fromClimbSession(it)
-                            },
-                    attempts =
-                            repository.getAllAttempts().first().map {
-                                BackupAttempt.fromAttempt(it)
-                            },
-                    deletedItems = repository.getDeletedItems()
-            )
-        }
-    }
-
-    private suspend fun importBackupToRepository(
-            backup: ClimbDataBackup,
-            imagePathMapping: Map<String, String>
-    ) {
-        val gyms = backup.gyms.map { it.toGym() }
-        val problems =
-                backup.problems.map { backupProblem ->
-                    val imagePaths = backupProblem.imagePaths
-                    val updatedImagePaths =
-                            imagePaths?.map { oldPath -> imagePathMapping[oldPath] ?: oldPath }
-                    backupProblem.copy(imagePaths = updatedImagePaths).toProblem()
-                }
-        val sessions = backup.sessions.map { it.toClimbSession() }
-        val attempts = backup.attempts.map { it.toAttempt() }
-
-        repository.resetAllData()
-
-        gyms.forEach { repository.insertGymWithoutSync(it) }
-        problems.forEach { repository.insertProblemWithoutSync(it) }
-        sessions.forEach { repository.insertSessionWithoutSync(it) }
-        attempts.forEach { repository.insertAttemptWithoutSync(it) }
-
-        repository.clearDeletedItems()
-    }
-
-    private suspend fun mergeDataSafely(serverBackup: ClimbDataBackup) {
-        Log.d(TAG, "Server data will overwrite local data. Performing full restore.")
-        val imagePathMapping = syncImagesFromServer(serverBackup)
-        importBackupToRepository(serverBackup, imagePathMapping)
-    }
-
-    private fun handleHttpError(code: Int): Nothing {
-        when (code) {
-            401 -> throw SyncException.Unauthorized
-            in 500..599 -> throw SyncException.ServerError(code)
-            else -> throw SyncException.InvalidResponse("HTTP error code: $code")
-        }
-    }
-
     suspend fun testConnection() {
-        if (!_isConfigured.value) {
-            _isConnected.value = false
-            _syncError.value = "Server URL or Auth Token is not set."
-            return
-        }
         _isTesting.value = true
         _syncError.value = null
-
-        val request =
-                Request.Builder()
-                        .url("$serverUrl/sync")
-                        .header("Authorization", "Bearer $authToken")
-                        .head()
-                        .build()
         try {
-            withContext(Dispatchers.IO) {
-                httpClient.newCall(request).execute().use { response ->
-                    _isConnected.value = response.isSuccessful || response.code == 405
-                }
-            }
-            if (!_isConnected.value) {
-                _syncError.value = "Connection failed. Check URL and token."
-            }
+            provider.testConnection()
         } catch (e: Exception) {
-            _isConnected.value = false
             _syncError.value = "Connection error: ${e.message}"
+            throw e
         } finally {
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, _isConnected.value) }
             _isTesting.value = false
         }
     }
 
     fun triggerAutoSync() {
-        if (!_isConfigured.value || !_isConnected.value || !_isAutoSyncEnabled.value) {
+        if (!isConfiguredFlow.value || !isConnected.value || !_isAutoSyncEnabled.value) {
             return
         }
         if (_isSyncing.value) {
@@ -501,45 +137,25 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         }
         syncJob?.cancel()
         syncJob =
-                serviceScope.launch {
-                    delay(syncDebounceDelay)
-                    try {
-                        syncWithServer()
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Auto-sync failed", e)
-                    }
-                    if (pendingChanges) {
-                        pendingChanges = false
-                        triggerAutoSync()
-                    }
+            serviceScope.launch {
+                delay(syncDebounceDelay)
+                try {
+                    syncWithServer()
+                } catch (e: Exception) {
+                    AppLogger.e(TAG, e) { "Auto-sync failed" }
                 }
+                if (pendingChanges) {
+                    pendingChanges = false
+                    triggerAutoSync()
+                }
+            }
     }
 
     fun clearConfiguration() {
         syncJob?.cancel()
-        serverUrl = ""
-        authToken = ""
+        provider.disconnect()
         setAutoSyncEnabled(true)
         _lastSyncTime.value = null
-        _isConnected.value = false
         _syncError.value = null
-        sharedPreferences.edit { clear() }
-        updateConfiguredState()
     }
 }
-
-sealed class SyncException(message: String) : IOException(message), Serializable {
-    object NotConfigured :
-            SyncException("Sync is not configured. Please set server URL and auth token.")
-
-    object NotConnected : SyncException("Not connected to server. Please test connection first.")
-
-    object Unauthorized : SyncException("Unauthorized. Please check your auth token.")
-
-    object ImageNotFound : SyncException("Image not found on server")
-
-    data class ServerError(val code: Int) : SyncException("Server error: HTTP $code")
-    data class InvalidResponse(val details: String) :
-            SyncException("Invalid server response: $details")
-    data class NetworkError(val details: String) : SyncException("Network error: $details")
-}

android/app/src/main/java/com/atridad/ascently/service/SessionTrackingService.kt

@@ -6,41 +6,47 @@ import android.app.PendingIntent
 import android.app.Service
 import android.content.Context
 import android.content.Intent
+import android.os.Build
+import android.os.Bundle
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import com.atridad.ascently.MainActivity
 import com.atridad.ascently.R
 import com.atridad.ascently.data.database.AscentlyDatabase
 import com.atridad.ascently.data.repository.ClimbRepository
+import com.atridad.ascently.utils.AppLogger
+import com.atridad.ascently.widget.ClimbStatsWidgetProvider
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.temporal.ChronoUnit
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.firstOrNull
-import java.time.LocalDateTime
-import java.time.temporal.ChronoUnit
 import kotlinx.coroutines.runBlocking
 
 class SessionTrackingService : Service() {
-    
+
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private var notificationJob: Job? = null
     private var monitoringJob: Job? = null
-    
+
     private lateinit var repository: ClimbRepository
     private lateinit var notificationManager: NotificationManager
-    
+
     companion object {
+        private const val LOG_TAG = "SessionTrackingService"
         const val NOTIFICATION_ID = 1001
         const val CHANNEL_ID = "session_tracking_channel"
         const val ACTION_START_SESSION = "start_session"
         const val ACTION_STOP_SESSION = "stop_session"
         const val EXTRA_SESSION_ID = "session_id"
-        
+
         fun createStartIntent(context: Context, sessionId: String): Intent {
             return Intent(context, SessionTrackingService::class.java).apply {
                 action = ACTION_START_SESSION
                 putExtra(EXTRA_SESSION_ID, sessionId)
             }
         }
-        
+
         fun createStopIntent(context: Context, sessionId: String): Intent {
             return Intent(context, SessionTrackingService::class.java).apply {
                 action = ACTION_STOP_SESSION
@@ -48,17 +54,17 @@ class SessionTrackingService : Service() {
             }
         }
     }
-    
+
     override fun onCreate() {
         super.onCreate()
-        
+
         val database = AscentlyDatabase.getDatabase(this)
         repository = ClimbRepository(database, this)
         notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
-        
+
         createNotificationChannel()
     }
-    
+
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         when (intent?.action) {
             ACTION_START_SESSION -> {
@@ -67,16 +73,24 @@ class SessionTrackingService : Service() {
                     startSessionTracking(sessionId)
                 }
             }
+
             ACTION_STOP_SESSION -> {
                 val sessionId = intent.getStringExtra(EXTRA_SESSION_ID)
                 serviceScope.launch {
                     try {
-                        val targetSession = when {
-                            sessionId != null -> repository.getSessionById(sessionId)
-                            else -> repository.getActiveSession()
-                        }
-                        if (targetSession != null && targetSession.status == com.atridad.ascently.data.model.SessionStatus.ACTIVE) {
-                            val completed = with(com.atridad.ascently.data.model.ClimbSession) { targetSession.complete() }
+                        val targetSession =
+                            when {
+                                sessionId != null -> repository.getSessionById(sessionId)
+                                else -> repository.getActiveSession()
+                            }
+                        if (targetSession != null &&
+                            targetSession.status ==
+                            com.atridad.ascently.data.model.SessionStatus.ACTIVE
+                        ) {
+                            val completed =
+                                with(com.atridad.ascently.data.model.ClimbSession) {
+                                    targetSession.complete()
+                                }
                             repository.updateSession(completed)
                         }
                     } finally {
@@ -90,61 +104,71 @@ class SessionTrackingService : Service() {
     }
 
     override fun onBind(intent: Intent?): IBinder? = null
-    
+
     private fun startSessionTracking(sessionId: String) {
         notificationJob?.cancel()
         monitoringJob?.cancel()
-        
+
         try {
             createAndShowNotification(sessionId)
+            // Update widget when session tracking starts
+            ClimbStatsWidgetProvider.updateAllWidgets(this)
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e(LOG_TAG, e) { "Failed to initialize session tracking notification" }
         }
-        
-        notificationJob = serviceScope.launch {
-            try {
-                if (!isNotificationActive()) {
-                    delay(1000L)
-                    createAndShowNotification(sessionId)
-                }
-                
-                while (isActive) {
-                    delay(5000L)
-                    updateNotification(sessionId)
-                }
-            } catch (e: Exception) {
-                e.printStackTrace()
-            }
-        }
-        
-        monitoringJob = serviceScope.launch {
-            try {
-                while (isActive) {
-                    delay(10000L)
-                    
+
+        notificationJob =
+            serviceScope.launch {
+                try {
                     if (!isNotificationActive()) {
+                        delay(1000L)
+                        createAndShowNotification(sessionId)
+                    }
+
+                    while (isActive) {
+                        delay(5000L)
                         updateNotification(sessionId)
                     }
-                    
-                    val session = repository.getSessionById(sessionId)
-                    if (session == null || session.status != com.atridad.ascently.data.model.SessionStatus.ACTIVE) {
-                        stopSessionTracking()
-                        break
-                    }
+                } catch (e: Exception) {
+                    AppLogger.e(LOG_TAG, e) { "Notification updater loop crashed" }
+                }
+            }
+
+        monitoringJob =
+            serviceScope.launch {
+                try {
+                    while (isActive) {
+                        delay(10000L)
+
+                        if (!isNotificationActive()) {
+                            updateNotification(sessionId)
+                        }
+
+                        val session = repository.getSessionById(sessionId)
+                        if (session == null ||
+                            session.status !=
+                            com.atridad.ascently.data.model.SessionStatus
+                                .ACTIVE
+                        ) {
+                            stopSessionTracking()
+                            break
+                        }
+                    }
+                } catch (e: Exception) {
+                    AppLogger.e(LOG_TAG, e) { "Session monitoring loop crashed" }
                 }
-            } catch (e: Exception) {
-                e.printStackTrace()
             }
-        }
     }
-    
+
     private fun stopSessionTracking() {
         notificationJob?.cancel()
         monitoringJob?.cancel()
         stopForeground(STOP_FOREGROUND_REMOVE)
         stopSelf()
+        // Update widget when session tracking stops
+        ClimbStatsWidgetProvider.updateAllWidgets(this)
     }
-    
+
     private fun isNotificationActive(): Boolean {
         return try {
             val activeNotifications = notificationManager.activeNotifications
@@ -153,97 +177,134 @@ class SessionTrackingService : Service() {
             false
         }
     }
-    
+
     private suspend fun updateNotification(sessionId: String) {
         try {
             createAndShowNotification(sessionId)
+            // Update widget when notification updates
+            ClimbStatsWidgetProvider.updateAllWidgets(this)
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e(LOG_TAG, e) { "Failed to update notification; retrying in 10s" }
 
             try {
                 delay(10000L)
                 createAndShowNotification(sessionId)
             } catch (retryException: Exception) {
-                retryException.printStackTrace()
+                AppLogger.e(LOG_TAG, retryException) { "Retrying notification update failed" }
                 stopSessionTracking()
             }
         }
     }
-    
+
     private fun createAndShowNotification(sessionId: String) {
         try {
-            val session = runBlocking {
-                repository.getSessionById(sessionId)
-            }
-            if (session == null || session.status != com.atridad.ascently.data.model.SessionStatus.ACTIVE) {
+            val session = runBlocking { repository.getSessionById(sessionId) }
+            if (session == null ||
+                session.status != com.atridad.ascently.data.model.SessionStatus.ACTIVE
+            ) {
                 stopSessionTracking()
                 return
             }
-            
-            val gym = runBlocking {
-                repository.getGymById(session.gymId)
-            }
-            
+
+            val gym = runBlocking { repository.getGymById(session.gymId) }
+
             val attempts = runBlocking {
                 repository.getAttemptsBySession(sessionId).firstOrNull() ?: emptyList()
             }
-            
-            val duration = session.startTime?.let { startTime ->
-                try {
-                    val start = LocalDateTime.parse(startTime)
-                    val now = LocalDateTime.now()
-                    val totalSeconds = ChronoUnit.SECONDS.between(start, now)
-                    val hours = totalSeconds / 3600
-                    val minutes = (totalSeconds % 3600) / 60
-                    val seconds = totalSeconds % 60
-                    
-                    when {
-                        hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
-                        minutes > 0 -> "${minutes}m ${seconds}s"
-                        else -> "${totalSeconds}s"
+
+            val notificationBuilder =
+                NotificationCompat.Builder(this, CHANNEL_ID)
+                    .setSmallIcon(R.drawable.ic_mountains)
+                    .setOngoing(true)
+                    .setAutoCancel(false)
+                    .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                    .setCategory(NotificationCompat.CATEGORY_SERVICE)
+                    .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                    .setContentIntent(createOpenAppIntent())
+                    .addAction(
+                        R.drawable.ic_mountains,
+                        "Open Session",
+                        createOpenAppIntent()
+                    )
+                    .addAction(
+                        android.R.drawable.ic_menu_close_clear_cancel,
+                        "End Session",
+                        createStopPendingIntent(sessionId)
+                    )
+
+            // Use Live Update
+            if (Build.VERSION.SDK_INT >= 36) {
+                val startTimeMillis =
+                    session.startTime?.let { startTime ->
+                        try {
+                            val start = LocalDateTime.parse(startTime)
+                            val zoneId = ZoneId.systemDefault()
+                            start.atZone(zoneId).toInstant().toEpochMilli()
+                        } catch (_: Exception) {
+                            System.currentTimeMillis()
+                        }
                     }
-                } catch (_: Exception) {
-                    "Active"
-                }
-            } ?: "Active"
-            
-            val notification = NotificationCompat.Builder(this, CHANNEL_ID)
-                .setContentTitle("Climbing Session Active")
-                .setContentText("${gym?.name ?: "Gym"} • $duration • ${attempts.size} attempts")
-                .setSmallIcon(R.drawable.ic_mountains)
-                .setOngoing(true)
-                .setAutoCancel(false)
-                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
-                .setCategory(NotificationCompat.CATEGORY_SERVICE)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setContentIntent(createOpenAppIntent())
-                .addAction(
-                    R.drawable.ic_mountains,
-                    "Open Session",
-                    createOpenAppIntent()
-                )
-                .addAction(
-                    android.R.drawable.ic_menu_close_clear_cancel,
-                    "End Session",
-                    createStopPendingIntent(sessionId)
-                )
-                .build()
-            
+                        ?: System.currentTimeMillis()
+
+                notificationBuilder
+                    .setContentTitle("Climbing Session Active")
+                    .setContentText(
+                        "${gym?.name ?: "Gym"} • ${attempts.size} attempts"
+                    )
+                    .setWhen(startTimeMillis)
+                    .setUsesChronometer(true)
+                    .setShowWhen(true)
+
+                val extras = Bundle()
+                extras.putBoolean("android.extra.REQUEST_PROMOTED_ONGOING", true)
+                notificationBuilder.setExtras(extras)
+            } else {
+                // Fallback for older versions
+                val duration =
+                    session.startTime?.let { startTime ->
+                        try {
+                            val start = LocalDateTime.parse(startTime)
+                            val now = LocalDateTime.now()
+                            val totalSeconds = ChronoUnit.SECONDS.between(start, now)
+                            val hours = totalSeconds / 3600
+                            val minutes = (totalSeconds % 3600) / 60
+                            val seconds = totalSeconds % 60
+
+                            when {
+                                hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
+                                minutes > 0 -> "${minutes}m ${seconds}s"
+                                else -> "${totalSeconds}s"
+                            }
+                        } catch (_: Exception) {
+                            "Active"
+                        }
+                    }
+                        ?: "Active"
+
+                notificationBuilder
+                    .setContentTitle("Climbing Session Active")
+                    .setContentText(
+                        "${gym?.name ?: "Gym"} • $duration • ${attempts.size} attempts"
+                    )
+            }
+
+            val notification = notificationBuilder.build()
+
             startForeground(NOTIFICATION_ID, notification)
-            
+
             notificationManager.notify(NOTIFICATION_ID, notification)
-            
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e(LOG_TAG, e) { "Failed to build session tracking notification" }
             throw e
         }
     }
-    
+
     private fun createOpenAppIntent(): PendingIntent {
-        val intent = Intent(this, MainActivity::class.java).apply {
-            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
-            action = "OPEN_SESSION"
-        }
+        val intent =
+            Intent(this, MainActivity::class.java).apply {
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+                action = "OPEN_SESSION"
+            }
         return PendingIntent.getActivity(
             this,
             0,
@@ -251,7 +312,7 @@ class SessionTrackingService : Service() {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
         )
     }
-    
+
     private fun createStopPendingIntent(sessionId: String): PendingIntent {
         val intent = createStopIntent(this, sessionId)
         return PendingIntent.getService(
@@ -261,24 +322,26 @@ class SessionTrackingService : Service() {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
         )
     }
-    
+
     private fun createNotificationChannel() {
-        val channel = NotificationChannel(
-            CHANNEL_ID,
-            "Session Tracking",
-            NotificationManager.IMPORTANCE_DEFAULT
-        ).apply {
-            description = "Shows active climbing session information"
-            setShowBadge(false)
-            lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-            enableLights(false)
-            enableVibration(false)
-            setSound(null, null)
-        }
+        val channel =
+            NotificationChannel(
+                CHANNEL_ID,
+                "Session Tracking",
+                NotificationManager.IMPORTANCE_DEFAULT
+            )
+                .apply {
+                    description = "Shows active climbing session information"
+                    setShowBadge(false)
+                    lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+                    enableLights(false)
+                    enableVibration(false)
+                    setSound(null, null)
+                }
 
         notificationManager.createNotificationChannel(channel)
     }
-    
+
     override fun onDestroy() {
         super.onDestroy()
         notificationJob?.cancel()

android/app/src/main/java/com/atridad/ascently/ui/AscentlyApp.kt

@@ -26,15 +26,16 @@ import com.atridad.ascently.ui.components.NotificationPermissionDialog
 import com.atridad.ascently.ui.screens.*
 import com.atridad.ascently.ui.viewmodel.ClimbViewModel
 import com.atridad.ascently.ui.viewmodel.ClimbViewModelFactory
+import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.utils.AppShortcutManager
 import com.atridad.ascently.utils.NotificationPermissionUtils
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun AscentlyApp(
-        shortcutAction: String? = null,
-        lastUsedGymId: String? = null,
-        onShortcutActionProcessed: () -> Unit = {}
+    shortcutAction: String? = null,
+    lastUsedGymId: String? = null,
+    onShortcutActionProcessed: () -> Unit = {}
 ) {
     val navController = rememberNavController()
     val context = LocalContext.current
@@ -45,26 +46,26 @@ fun AscentlyApp(
     val repository = remember { ClimbRepository(database, context) }
     val syncService = remember { SyncService(context, repository) }
     val viewModel: ClimbViewModel =
-            viewModel(factory = ClimbViewModelFactory(repository, syncService, context))
+        viewModel(factory = ClimbViewModelFactory(repository, syncService, context))
 
     var showNotificationPermissionDialog by remember { mutableStateOf(false) }
     var hasCheckedNotificationPermission by remember { mutableStateOf(false) }
 
     val permissionLauncher =
-            rememberLauncherForActivityResult(
-                    contract = ActivityResultContracts.RequestPermission()
-            ) { isGranted: Boolean ->
-                if (!isGranted) {
-                    showNotificationPermissionDialog = false
-                }
+        rememberLauncherForActivityResult(
+            contract = ActivityResultContracts.RequestPermission()
+        ) { isGranted: Boolean ->
+            if (!isGranted) {
+                showNotificationPermissionDialog = false
             }
+        }
 
     LaunchedEffect(Unit) {
         if (!hasCheckedNotificationPermission) {
             hasCheckedNotificationPermission = true
 
             if (NotificationPermissionUtils.shouldRequestNotificationPermission() &&
-                            !NotificationPermissionUtils.isNotificationPermissionGranted(context)
+                !NotificationPermissionUtils.isNotificationPermissionGranted(context)
             ) {
                 showNotificationPermissionDialog = true
             }
@@ -86,10 +87,10 @@ fun AscentlyApp(
 
     LaunchedEffect(activeSession, gyms, lastUsedGym) {
         AppShortcutManager.updateShortcuts(
-                context = context,
-                hasActiveSession = activeSession != null,
-                hasGyms = gyms.isNotEmpty(),
-                lastUsedGym = if (activeSession == null && gyms.size > 1) lastUsedGym else null
+            context = context,
+            hasActiveSession = activeSession != null,
+            hasGyms = gyms.isNotEmpty(),
+            lastUsedGym = if (activeSession == null && gyms.size > 1) lastUsedGym else null
         )
     }
 
@@ -101,6 +102,7 @@ fun AscentlyApp(
                     launchSingleTop = true
                 }
             }
+
             AppShortcutManager.ACTION_END_SESSION -> {
                 navController.navigate(Screen.Sessions) {
                     popUpTo(0) { inclusive = true }
@@ -114,51 +116,36 @@ fun AscentlyApp(
 
     LaunchedEffect(shortcutAction, activeSession, gyms, lastUsedGym) {
         if (shortcutAction == AppShortcutManager.ACTION_START_SESSION && gyms.isNotEmpty()) {
-            android.util.Log.d(
-                    "AscentlyApp",
-                    "Processing shortcut action: activeSession=$activeSession, gyms.size=${gyms.size}, lastUsedGymId=$lastUsedGymId, lastUsedGym=${lastUsedGym?.name}"
-            )
+            AppLogger.d("AscentlyApp") { "Processing shortcut action: activeSession=$activeSession, gyms.size=${gyms.size}, lastUsedGymId=$lastUsedGymId, lastUsedGym=${lastUsedGym?.name}" }
 
             if (activeSession == null) {
                 if (NotificationPermissionUtils.shouldRequestNotificationPermission() &&
-                                !NotificationPermissionUtils.isNotificationPermissionGranted(
-                                        context
-                                )
+                    !NotificationPermissionUtils.isNotificationPermissionGranted(
+                        context
+                    )
                 ) {
-                    android.util.Log.d("AscentlyApp", "Showing notification permission dialog")
+                    AppLogger.d("AscentlyApp") { "Showing notification permission dialog" }
                     showNotificationPermissionDialog = true
                 } else {
                     if (gyms.size == 1) {
-                        android.util.Log.d(
-                                "AscentlyApp",
-                                "Starting session with single gym: ${gyms.first().name}"
-                        )
+                        AppLogger.d("AscentlyApp") { "Starting session with single gym: ${gyms.first().name}" }
                         viewModel.startSession(context, gyms.first().id)
                     } else {
                         val targetGym =
-                                lastUsedGymId?.let { gymId -> gyms.find { it.id == gymId } }
-                                        ?: lastUsedGym
+                            lastUsedGymId?.let { gymId -> gyms.find { it.id == gymId } }
+                                ?: lastUsedGym
 
                         if (targetGym != null) {
-                            android.util.Log.d(
-                                    "AscentlyApp",
-                                    "Starting session with target gym: ${targetGym.name}"
-                            )
+                            AppLogger.d("AscentlyApp") { "Starting session with target gym: ${targetGym.name}" }
                             viewModel.startSession(context, targetGym.id)
                         } else {
-                            android.util.Log.d(
-                                    "AscentlyApp",
-                                    "No target gym found, navigating to selection"
-                            )
+                            AppLogger.d("AscentlyApp") { "No target gym found, navigating to selection" }
                             navController.navigate(Screen.AddEditSession())
                         }
                     }
                 }
             } else {
-                android.util.Log.d(
-                        "AscentlyApp",
-                        "Active session already exists: ${activeSession?.id}"
-                )
+                AppLogger.d("AscentlyApp") { "Active session already exists: ${activeSession?.id}" }
             }
 
             onShortcutActionProcessed()
@@ -168,79 +155,79 @@ fun AscentlyApp(
     var fabConfig by remember { mutableStateOf<FabConfig?>(null) }
 
     Scaffold(
-            bottomBar = { AscentlyBottomNavigation(navController = navController) },
-            floatingActionButton = {
-                fabConfig?.let { config ->
-                    FloatingActionButton(
-                            onClick = config.onClick,
-                            containerColor = MaterialTheme.colorScheme.primary
-                    ) {
-                        Icon(
-                                imageVector = config.icon,
-                                contentDescription = config.contentDescription
-                        )
-                    }
+        bottomBar = { AscentlyBottomNavigation(navController = navController) },
+        floatingActionButton = {
+            fabConfig?.let { config ->
+                FloatingActionButton(
+                    onClick = config.onClick,
+                    containerColor = MaterialTheme.colorScheme.primary
+                ) {
+                    Icon(
+                        imageVector = config.icon,
+                        contentDescription = config.contentDescription
+                    )
                 }
             }
+        }
     ) { innerPadding ->
         NavHost(
-                navController = navController,
-                startDestination = Screen.Sessions,
-                modifier = Modifier.padding(innerPadding)
+            navController = navController,
+            startDestination = Screen.Sessions,
+            modifier = Modifier.padding(innerPadding)
         ) {
             composable<Screen.Sessions> {
                 LaunchedEffect(gyms, activeSession) {
                     fabConfig =
-                            if (gyms.isNotEmpty() && activeSession == null) {
-                                FabConfig(
-                                        icon = Icons.Default.PlayArrow,
-                                        contentDescription = "Start Session",
-                                        onClick = {
-                                            if (NotificationPermissionUtils
-                                                            .shouldRequestNotificationPermission() &&
-                                                            !NotificationPermissionUtils
-                                                                    .isNotificationPermissionGranted(
-                                                                            context
-                                                                    )
-                                            ) {
-                                                showNotificationPermissionDialog = true
-                                            } else {
-                                                navController.navigate(Screen.AddEditSession())
-                                            }
-                                        }
-                                )
-                            } else {
-                                null
-                            }
+                        if (gyms.isNotEmpty() && activeSession == null) {
+                            FabConfig(
+                                icon = Icons.Default.PlayArrow,
+                                contentDescription = "Start Session",
+                                onClick = {
+                                    if (NotificationPermissionUtils
+                                            .shouldRequestNotificationPermission() &&
+                                        !NotificationPermissionUtils
+                                            .isNotificationPermissionGranted(
+                                                context
+                                            )
+                                    ) {
+                                        showNotificationPermissionDialog = true
+                                    } else {
+                                        navController.navigate(Screen.AddEditSession())
+                                    }
+                                }
+                            )
+                        } else {
+                            null
+                        }
                 }
                 SessionsScreen(
-                        viewModel = viewModel,
-                        onNavigateToSessionDetail = { sessionId ->
-                            navController.navigate(Screen.SessionDetail(sessionId))
-                        }
+                    viewModel = viewModel,
+                    onNavigateToSessionDetail = { sessionId ->
+                        navController.navigate(Screen.SessionDetail(sessionId))
+                    }
                 )
             }
 
             composable<Screen.Problems> {
                 LaunchedEffect(gyms) {
                     fabConfig =
-                            if (gyms.isNotEmpty()) {
-                                FabConfig(
-                                        icon = Icons.Default.Add,
-                                        contentDescription = "Add Problem",
-                                        onClick = {
-                                            navController.navigate(Screen.AddEditProblem())
-                                        }
-                                )
-                            } else {
-                                null
-                            }
+                        if (gyms.isNotEmpty()) {
+                            FabConfig(
+                                icon = Icons.Default.Add,
+                                contentDescription = "Add Problem",
+                                onClick = {
+                                    navController.navigate(Screen.AddEditProblem())
+                                }
+                            )
+                        } else {
+                            null
+                        }
                 }
                 ProblemsScreen(
-                        viewModel = viewModel,
-                        onNavigateToProblemDetail = { problemId ->
-                            navController.navigate(Screen.ProblemDetail(problemId))
-                        }
+                    viewModel = viewModel,
+                    onNavigateToProblemDetail = { problemId ->
+                        navController.navigate(Screen.ProblemDetail(problemId))
+                    }
                 )
             }
 
@@ -252,17 +239,17 @@ fun AscentlyApp(
             composable<Screen.Gyms> {
                 LaunchedEffect(Unit) {
                     fabConfig =
-                            FabConfig(
-                                    icon = Icons.Default.Add,
-                                    contentDescription = "Add Gym",
-                                    onClick = { navController.navigate(Screen.AddEditGym()) }
-                            )
+                        FabConfig(
+                            icon = Icons.Default.Add,
+                            contentDescription = "Add Gym",
+                            onClick = { navController.navigate(Screen.AddEditGym()) }
+                        )
                 }
                 GymsScreen(
-                        viewModel = viewModel,
-                        onNavigateToGymDetail = { gymId ->
-                            navController.navigate(Screen.GymDetail(gymId))
-                        }
+                    viewModel = viewModel,
+                    onNavigateToGymDetail = { gymId ->
+                        navController.navigate(Screen.GymDetail(gymId))
+                    }
                 )
             }
 
@@ -275,12 +262,12 @@ fun AscentlyApp(
                 val args = backStackEntry.toRoute<Screen.SessionDetail>()
                 LaunchedEffect(Unit) { fabConfig = null }
                 SessionDetailScreen(
-                        sessionId = args.sessionId,
-                        viewModel = viewModel,
-                        onNavigateBack = { navController.popBackStack() },
-                        onNavigateToProblemDetail = { problemId ->
-                            navController.navigate(Screen.ProblemDetail(problemId))
-                        }
+                    sessionId = args.sessionId,
+                    viewModel = viewModel,
+                    onNavigateBack = { navController.popBackStack() },
+                    onNavigateToProblemDetail = { problemId ->
+                        navController.navigate(Screen.ProblemDetail(problemId))
+                    }
                 )
             }
 
@@ -288,12 +275,12 @@ fun AscentlyApp(
                 val args = backStackEntry.toRoute<Screen.ProblemDetail>()
                 LaunchedEffect(Unit) { fabConfig = null }
                 ProblemDetailScreen(
-                        problemId = args.problemId,
-                        viewModel = viewModel,
-                        onNavigateBack = { navController.popBackStack() },
-                        onNavigateToEdit = { problemId ->
-                            navController.navigate(Screen.AddEditProblem(problemId = problemId))
-                        }
+                    problemId = args.problemId,
+                    viewModel = viewModel,
+                    onNavigateBack = { navController.popBackStack() },
+                    onNavigateToEdit = { problemId ->
+                        navController.navigate(Screen.AddEditProblem(problemId = problemId))
+                    }
                 )
             }
 
@@ -301,18 +288,18 @@ fun AscentlyApp(
                 val args = backStackEntry.toRoute<Screen.GymDetail>()
                 LaunchedEffect(Unit) { fabConfig = null }
                 GymDetailScreen(
-                        gymId = args.gymId,
-                        viewModel = viewModel,
-                        onNavigateBack = { navController.popBackStack() },
-                        onNavigateToEdit = { gymId ->
-                            navController.navigate(Screen.AddEditGym(gymId = gymId))
-                        },
-                        onNavigateToSessionDetail = { sessionId ->
-                            navController.navigate(Screen.SessionDetail(sessionId))
-                        },
-                        onNavigateToProblemDetail = { problemId ->
-                            navController.navigate(Screen.ProblemDetail(problemId))
-                        }
+                    gymId = args.gymId,
+                    viewModel = viewModel,
+                    onNavigateBack = { navController.popBackStack() },
+                    onNavigateToEdit = { gymId ->
+                        navController.navigate(Screen.AddEditGym(gymId = gymId))
+                    },
+                    onNavigateToSessionDetail = { sessionId ->
+                        navController.navigate(Screen.SessionDetail(sessionId))
+                    },
+                    onNavigateToProblemDetail = { problemId ->
+                        navController.navigate(Screen.ProblemDetail(problemId))
+                    }
                 )
             }
 
@@ -320,9 +307,9 @@ fun AscentlyApp(
                 val args = backStackEntry.toRoute<Screen.AddEditGym>()
                 LaunchedEffect(Unit) { fabConfig = null }
                 AddEditGymScreen(
-                        gymId = args.gymId,
-                        viewModel = viewModel,
-                        onNavigateBack = { navController.popBackStack() }
+                    gymId = args.gymId,
+                    viewModel = viewModel,
+                    onNavigateBack = { navController.popBackStack() }
                 )
             }
 
@@ -330,10 +317,10 @@ fun AscentlyApp(
                 val args = backStackEntry.toRoute<Screen.AddEditProblem>()
                 LaunchedEffect(Unit) { fabConfig = null }
                 AddEditProblemScreen(
-                        problemId = args.problemId,
-                        gymId = args.gymId,
-                        viewModel = viewModel,
-                        onNavigateBack = { navController.popBackStack() }
+                    problemId = args.problemId,
+                    gymId = args.gymId,
+                    viewModel = viewModel,
+                    onNavigateBack = { navController.popBackStack() }
                 )
             }
 
@@ -341,22 +328,22 @@ fun AscentlyApp(
                 val args = backStackEntry.toRoute<Screen.AddEditSession>()
                 LaunchedEffect(Unit) { fabConfig = null }
                 AddEditSessionScreen(
-                        sessionId = args.sessionId,
-                        gymId = args.gymId,
-                        viewModel = viewModel,
-                        onNavigateBack = { navController.popBackStack() }
+                    sessionId = args.sessionId,
+                    gymId = args.gymId,
+                    viewModel = viewModel,
+                    onNavigateBack = { navController.popBackStack() }
                 )
             }
         }
 
         if (showNotificationPermissionDialog) {
             NotificationPermissionDialog(
-                    onDismiss = { showNotificationPermissionDialog = false },
-                    onRequestPermission = {
-                        permissionLauncher.launch(
-                                NotificationPermissionUtils.getNotificationPermissionString()
-                        )
-                    }
+                onDismiss = { showNotificationPermissionDialog = false },
+                onRequestPermission = {
+                    permissionLauncher.launch(
+                        NotificationPermissionUtils.getNotificationPermissionString()
+                    )
+                }
             )
         }
     }
@@ -370,34 +357,34 @@ fun AscentlyBottomNavigation(navController: NavHostController) {
     NavigationBar {
         bottomNavigationItems.forEach { item ->
             val isSelected =
-                    when (item.screen) {
-                        is Screen.Sessions -> currentRoute?.contains("Session") == true
-                        is Screen.Problems -> currentRoute?.contains("Problem") == true
-                        is Screen.Gyms -> currentRoute?.contains("Gym") == true
-                        is Screen.Analytics -> currentRoute?.contains("Analytics") == true
-                        is Screen.Settings -> currentRoute?.contains("Settings") == true
-                        else -> currentRoute?.contains(item.screen::class.simpleName ?: "") == true
-                    }
+                when (item.screen) {
+                    is Screen.Sessions -> currentRoute?.contains("Session") == true
+                    is Screen.Problems -> currentRoute?.contains("Problem") == true
+                    is Screen.Gyms -> currentRoute?.contains("Gym") == true
+                    is Screen.Analytics -> currentRoute?.contains("Analytics") == true
+                    is Screen.Settings -> currentRoute?.contains("Settings") == true
+                    else -> currentRoute?.contains(item.screen::class.simpleName ?: "") == true
+                }
 
             NavigationBarItem(
-                    icon = { Icon(item.icon, contentDescription = item.label) },
-                    label = { Text(item.label) },
-                    selected = isSelected,
-                    onClick = {
-                        navController.navigate(item.screen) {
-                            popUpTo(0) { inclusive = true }
-                            launchSingleTop = true
-                            // Don't restore state - always start fresh when switching tabs
-                            restoreState = false
-                        }
+                icon = { Icon(item.icon, contentDescription = item.label) },
+                label = { Text(item.label) },
+                selected = isSelected,
+                onClick = {
+                    navController.navigate(item.screen) {
+                        popUpTo(0) { inclusive = true }
+                        launchSingleTop = true
+                        // Don't restore state - always start fresh when switching tabs
+                        restoreState = false
                     }
+                }
             )
         }
     }
 }
 
 data class FabConfig(
-        val icon: androidx.compose.ui.graphics.vector.ImageVector,
-        val contentDescription: String,
-        val onClick: () -> Unit
+    val icon: androidx.compose.ui.graphics.vector.ImageVector,
+    val contentDescription: String,
+    val onClick: () -> Unit
 )

android/app/src/main/java/com/atridad/ascently/ui/screens/DetailScreens.kt

@@ -31,6 +31,7 @@ import androidx.compose.ui.window.Dialog
 import com.atridad.ascently.data.model.*
 import com.atridad.ascently.ui.components.FullscreenImageViewer
 import com.atridad.ascently.ui.components.ImageDisplaySection
+import com.atridad.ascently.ui.components.ImagePicker
 import com.atridad.ascently.ui.theme.CustomIcons
 import com.atridad.ascently.ui.viewmodel.ClimbViewModel
 import com.atridad.ascently.utils.DateFormatUtils
@@ -1489,6 +1490,7 @@ fun EnhancedAddAttemptDialog(
     // New problem creation state
     var newProblemName by remember { mutableStateOf("") }
     var newProblemGrade by remember { mutableStateOf("") }
+    var newProblemImagePaths by remember { mutableStateOf<List<String>>(emptyList()) }
     var selectedClimbType by remember { mutableStateOf(ClimbType.BOULDER) }
     var selectedDifficultySystem by remember {
         mutableStateOf(gym.difficultySystems.firstOrNull() ?: DifficultySystem.V_SCALE)
@@ -1690,7 +1692,14 @@ fun EnhancedAddAttemptDialog(
                                             color = MaterialTheme.colorScheme.onSurface
                                     )
 
-                                    IconButton(onClick = { showCreateProblem = false }) {
+                                    IconButton(
+                                            onClick = {
+                                                showCreateProblem = false
+                                                newProblemName = ""
+                                                newProblemGrade = ""
+                                                newProblemImagePaths = emptyList()
+                                            }
+                                    ) {
                                         Icon(
                                                 Icons.AutoMirrored.Filled.ArrowBack,
                                                 contentDescription = "Back",
@@ -1905,6 +1914,21 @@ fun EnhancedAddAttemptDialog(
                                         }
                                     }
                                 }
+
+                                // Photos Section
+                                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                                    Text(
+                                            text = "Photos (Optional)",
+                                            style = MaterialTheme.typography.bodyLarge,
+                                            fontWeight = FontWeight.Medium,
+                                            color = MaterialTheme.colorScheme.onSurface
+                                    )
+                                    ImagePicker(
+                                            imageUris = newProblemImagePaths,
+                                            onImagesChanged = { newProblemImagePaths = it },
+                                            maxImages = 5
+                                    )
+                                }
                             }
                         }
                     }
@@ -2069,7 +2093,9 @@ fun EnhancedAddAttemptDialog(
                                                                                 null
                                                                             },
                                                                     climbType = selectedClimbType,
-                                                                    difficulty = difficulty
+                                                                    difficulty = difficulty,
+                                                                    imagePaths =
+                                                                            newProblemImagePaths
                                                             )
 
                                                     onProblemCreated(newProblem)
@@ -2087,6 +2113,12 @@ fun EnhancedAddAttemptDialog(
                                                                     notes = notes.ifBlank { null }
                                                             )
                                                     onAttemptAdded(attempt)
+
+                                                    // Reset form
+                                                    newProblemName = ""
+                                                    newProblemGrade = ""
+                                                    newProblemImagePaths = emptyList()
+                                                    showCreateProblem = false
                                                 }
                                             } else {
                                                 // Create attempt for selected problem

android/app/src/main/java/com/atridad/ascently/ui/screens/SessionsScreen.kt

@@ -1,16 +1,24 @@
 package com.atridad.ascently.ui.screens
 
+import android.content.Context
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.List
+import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.CheckCircle
 import androidx.compose.material.icons.filled.Warning
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.font.FontWeight
@@ -23,6 +31,17 @@ import com.atridad.ascently.ui.components.ActiveSessionBanner
 import com.atridad.ascently.ui.components.SyncIndicator
 import com.atridad.ascently.ui.viewmodel.ClimbViewModel
 import com.atridad.ascently.utils.DateFormatUtils
+import java.time.LocalDate
+import java.time.YearMonth
+import java.time.format.DateTimeFormatter
+import java.time.format.TextStyle
+import java.util.Locale
+import androidx.core.content.edit
+
+enum class ViewMode {
+    LIST,
+    CALENDAR
+}
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -33,7 +52,15 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
     val activeSession by viewModel.activeSession.collectAsState()
     val uiState by viewModel.uiState.collectAsState()
 
-    // Filter out active sessions from regular session list
+    val sharedPreferences =
+            context.getSharedPreferences("SessionsPreferences", Context.MODE_PRIVATE)
+    val savedViewMode = sharedPreferences.getString("view_mode", "LIST")
+    var viewMode by remember {
+        mutableStateOf(if (savedViewMode == "CALENDAR") ViewMode.CALENDAR else ViewMode.LIST)
+    }
+    var selectedMonth by remember { mutableStateOf(YearMonth.now()) }
+    var selectedDate by remember { mutableStateOf<LocalDate?>(LocalDate.now()) }
+
     val completedSessions = sessions.filter { it.status == SessionStatus.COMPLETED }
     val activeSessionGym = activeSession?.let { session -> gyms.find { it.id == session.gymId } }
 
@@ -55,12 +82,30 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
                     fontWeight = FontWeight.Bold,
                     modifier = Modifier.weight(1f)
             )
+
+            IconButton(
+                    onClick = {
+                        viewMode =
+                                if (viewMode == ViewMode.LIST) ViewMode.CALENDAR else ViewMode.LIST
+                        selectedDate = null
+                        sharedPreferences.edit { putString("view_mode", viewMode.name) }
+                    }
+            ) {
+                Icon(
+                        imageVector =
+                                if (viewMode == ViewMode.LIST) Icons.Default.CalendarMonth
+                                else Icons.AutoMirrored.Filled.List,
+                        contentDescription =
+                                if (viewMode == ViewMode.LIST) "Calendar View" else "List View",
+                        tint = MaterialTheme.colorScheme.primary
+                )
+            }
+
             SyncIndicator(isSyncing = viewModel.syncService.isSyncing)
         }
 
         Spacer(modifier = Modifier.height(16.dp))
 
-        // Active session banner
         ActiveSessionBanner(
                 activeSession = activeSession,
                 gym = activeSessionGym,
@@ -83,20 +128,35 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
                     actionText = ""
             )
         } else {
-            LazyColumn {
-                items(completedSessions) { session ->
-                    SessionCard(
-                            session = session,
-                            gymName = gyms.find { it.id == session.gymId }?.name ?: "Unknown Gym",
-                            onClick = { onNavigateToSessionDetail(session.id) }
+            when (viewMode) {
+                ViewMode.LIST -> {
+                    LazyColumn {
+                        items(completedSessions) { session ->
+                            SessionCard(
+                                    session = session,
+                                    gymName = gyms.find { it.id == session.gymId }?.name
+                                                    ?: "Unknown Gym",
+                                    onClick = { onNavigateToSessionDetail(session.id) }
+                            )
+                            Spacer(modifier = Modifier.height(8.dp))
+                        }
+                    }
+                }
+                ViewMode.CALENDAR -> {
+                    CalendarView(
+                            sessions = completedSessions,
+                            gyms = gyms,
+                        selectedMonth = selectedMonth,
+                            onMonthChange = { selectedMonth = it },
+                            selectedDate = selectedDate,
+                            onDateSelected = { selectedDate = it },
+                            onNavigateToSessionDetail = onNavigateToSessionDetail
                     )
-                    Spacer(modifier = Modifier.height(8.dp))
                 }
             }
         }
     }
 
-    // Show UI state messages and errors
     uiState.message?.let { message ->
         LaunchedEffect(message) {
             kotlinx.coroutines.delay(5000)
@@ -245,6 +305,234 @@ fun EmptyStateMessage(
     }
 }
 
+@Composable
+fun CalendarView(
+        sessions: List<ClimbSession>,
+        gyms: List<com.atridad.ascently.data.model.Gym>,
+        selectedMonth: YearMonth,
+        onMonthChange: (YearMonth) -> Unit,
+        selectedDate: LocalDate?,
+        onDateSelected: (LocalDate?) -> Unit,
+        onNavigateToSessionDetail: (String) -> Unit
+) {
+    val sessionsByDate =
+            remember(sessions) {
+                sessions.groupBy {
+                    try {
+                        java.time.Instant.parse(it.date)
+                                .atZone(java.time.ZoneId.systemDefault())
+                                .toLocalDate()
+                    } catch (_: Exception) {
+                        LocalDate.parse(it.date, DateTimeFormatter.ISO_LOCAL_DATE)
+                    }
+                }
+            }
+
+    val firstDayOfMonth = selectedMonth.atDay(1)
+    val daysInMonth = selectedMonth.lengthOfMonth()
+    val firstDayOfWeek = firstDayOfMonth.dayOfWeek.value % 7
+    val totalCells =
+            ((firstDayOfWeek + daysInMonth) / 7.0).let {
+                if (it == it.toInt().toDouble()) it.toInt() * 7 else (it.toInt() + 1) * 7
+            }
+    val numRows = totalCells / 7
+
+    LazyColumn(modifier = Modifier.fillMaxSize()) {
+        item {
+            Card(
+                    modifier = Modifier.fillMaxWidth(),
+                    colors =
+                            CardDefaults.cardColors(
+                                    containerColor = MaterialTheme.colorScheme.surfaceVariant
+                            )
+            ) {
+                Column(
+                        modifier =
+                                Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 12.dp),
+                        horizontalAlignment = Alignment.CenterHorizontally
+                ) {
+                    Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        IconButton(onClick = { onMonthChange(selectedMonth.minusMonths(1)) }) {
+                            Text("‹", style = MaterialTheme.typography.headlineMedium)
+                        }
+
+                        Text(
+                                text =
+                                        "${selectedMonth.month.getDisplayName(TextStyle.FULL, Locale.getDefault())} ${selectedMonth.year}",
+                                style = MaterialTheme.typography.titleMedium,
+                                fontWeight = FontWeight.Bold
+                        )
+
+                        IconButton(onClick = { onMonthChange(selectedMonth.plusMonths(1)) }) {
+                            Text("›", style = MaterialTheme.typography.headlineMedium)
+                        }
+                    }
+
+                    Spacer(modifier = Modifier.height(8.dp))
+
+                    Button(
+                            onClick = {
+                                val today = LocalDate.now()
+                                onMonthChange(YearMonth.from(today))
+                                onDateSelected(today)
+                            },
+                            shape = RoundedCornerShape(50),
+                            colors =
+                                    ButtonDefaults.buttonColors(
+                                            containerColor = MaterialTheme.colorScheme.primary
+                                    ),
+                            contentPadding = PaddingValues(horizontal = 20.dp, vertical = 8.dp)
+                    ) {
+                        Text(
+                                text = "Today",
+                                style = MaterialTheme.typography.labelLarge,
+                                fontWeight = FontWeight.SemiBold
+                        )
+                    }
+                }
+            }
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            Row(modifier = Modifier.fillMaxWidth()) {
+                listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat").forEach { day ->
+                    Text(
+                            text = day,
+                            modifier = Modifier.weight(1f),
+                            textAlign = TextAlign.Center,
+                            style = MaterialTheme.typography.labelSmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            fontWeight = FontWeight.Bold
+                    )
+                }
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+        }
+
+        items(numRows) { rowIndex ->
+            Row(modifier = Modifier.fillMaxWidth()) {
+                for (colIndex in 0 until 7) {
+                    val index = rowIndex * 7 + colIndex
+                    val dayNumber = index - firstDayOfWeek + 1
+
+                    Box(modifier = Modifier.weight(1f)) {
+                        if (dayNumber in 1..daysInMonth) {
+                            val date = selectedMonth.atDay(dayNumber)
+                            val sessionsOnDate = sessionsByDate[date] ?: emptyList()
+                            val isSelected = date == selectedDate
+                            val isToday = date == LocalDate.now()
+
+                            CalendarDay(
+                                    day = dayNumber,
+                                    hasSession = sessionsOnDate.isNotEmpty(),
+                                    isSelected = isSelected,
+                                    isToday = isToday,
+                                    onClick = {
+                                        if (sessionsOnDate.isNotEmpty()) {
+                                            onDateSelected(if (isSelected) null else date)
+                                        }
+                                    }
+                            )
+                        } else {
+                            Spacer(modifier = Modifier.aspectRatio(1f))
+                        }
+                    }
+                }
+            }
+        }
+
+        if (selectedDate != null) {
+            val sessionsOnSelectedDate = sessionsByDate[selectedDate] ?: emptyList()
+
+            item {
+                Spacer(modifier = Modifier.height(16.dp))
+
+                Text(
+                        text =
+                                "Sessions on ${selectedDate.format(DateTimeFormatter.ofPattern("MMMM d, yyyy"))}",
+                        style = MaterialTheme.typography.titleSmall,
+                        fontWeight = FontWeight.Bold,
+                        modifier = Modifier.padding(vertical = 8.dp)
+                )
+            }
+
+            items(sessionsOnSelectedDate) { session ->
+                SessionCard(
+                        session = session,
+                        gymName = gyms.find { it.id == session.gymId }?.name ?: "Unknown Gym",
+                        onClick = { onNavigateToSessionDetail(session.id) }
+                )
+                Spacer(modifier = Modifier.height(8.dp))
+            }
+
+            item { Spacer(modifier = Modifier.height(16.dp)) }
+        }
+    }
+}
+
+@Composable
+fun CalendarDay(
+        day: Int,
+        hasSession: Boolean,
+        isSelected: Boolean,
+        isToday: Boolean,
+        onClick: () -> Unit
+) {
+    Box(
+            modifier =
+                    Modifier.aspectRatio(1f)
+                            .padding(2.dp)
+                            .clip(CircleShape)
+                            .background(
+                                    when {
+                                        isSelected -> MaterialTheme.colorScheme.primaryContainer
+                                        isToday -> MaterialTheme.colorScheme.secondaryContainer
+                                        else -> Color.Transparent
+                                    }
+                            )
+                            .clickable(enabled = hasSession, onClick = onClick),
+            contentAlignment = Alignment.Center
+    ) {
+        Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Center
+        ) {
+            Text(
+                    text = day.toString(),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color =
+                            when {
+                                isSelected -> MaterialTheme.colorScheme.onPrimaryContainer
+                                isToday -> MaterialTheme.colorScheme.onSecondaryContainer
+                                !hasSession -> MaterialTheme.colorScheme.onSurfaceVariant
+                                else -> MaterialTheme.colorScheme.onSurface
+                            },
+                    fontWeight = if (hasSession || isToday) FontWeight.Bold else FontWeight.Normal
+            )
+
+            if (hasSession) {
+                Box(
+                        modifier =
+                                Modifier.size(6.dp)
+                                        .clip(CircleShape)
+                                        .background(
+                                                if (isSelected) MaterialTheme.colorScheme.primary
+                                                else
+                                                        MaterialTheme.colorScheme.primary.copy(
+                                                                alpha = 0.7f
+                                                        )
+                                        )
+                )
+            }
+        }
+    }
+}
+
 private fun formatDate(dateString: String): String {
     return DateFormatUtils.formatDateForDisplay(dateString)
 }

android/app/src/main/java/com/atridad/ascently/ui/screens/SettingsScreen.kt

@@ -216,9 +216,7 @@ fun SettingsScreen(viewModel: ClimbViewModel) {
                                             // Manual Sync Button
                                             TextButton(
                                                     onClick = {
-                                                        coroutineScope.launch {
-                                                            viewModel.performManualSync()
-                                                        }
+                                                        viewModel.performManualSync()
                                                     },
                                                     enabled = isConnected && !isSyncing
                                             ) {
@@ -583,41 +581,6 @@ fun SettingsScreen(viewModel: ClimbViewModel) {
 
                     Spacer(modifier = Modifier.height(12.dp))
 
-                    Card(
-                            shape = RoundedCornerShape(12.dp),
-                            colors =
-                                    CardDefaults.cardColors(
-                                            containerColor =
-                                                    MaterialTheme.colorScheme.surfaceVariant.copy(
-                                                            alpha = 0.3f
-                                                    )
-                                    )
-                    ) {
-                        ListItem(
-                                headlineContent = {
-                                    Row(
-                                            verticalAlignment = Alignment.CenterVertically,
-                                            horizontalArrangement = Arrangement.spacedBy(8.dp)
-                                    ) {
-                                        Icon(
-                                                painter =
-                                                        painterResource(
-                                                                id = R.drawable.ic_mountains
-                                                        ),
-                                                contentDescription = "Ascently Logo",
-                                                modifier = Modifier.size(24.dp),
-                                                tint = MaterialTheme.colorScheme.primary
-                                        )
-                                        Text("Ascently")
-                                    }
-                                },
-                                supportingContent = { Text("Track your climbing progress") },
-                                leadingContent = {}
-                        )
-                    }
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
                     Card(
                             shape = RoundedCornerShape(12.dp),
                             colors =

android/app/src/main/java/com/atridad/ascently/ui/viewmodel/ClimbViewModel.kt

@@ -8,6 +8,7 @@ import com.atridad.ascently.data.model.*
 import com.atridad.ascently.data.repository.ClimbRepository
 import com.atridad.ascently.data.sync.SyncService
 import com.atridad.ascently.service.SessionTrackingService
+import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.utils.ImageUtils
 import com.atridad.ascently.widget.ClimbStatsWidgetProvider
 import java.io.File
@@ -15,9 +16,9 @@ import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 
 class ClimbViewModel(
-        private val repository: ClimbRepository,
-        val syncService: SyncService,
-        private val context: Context
+    private val repository: ClimbRepository,
+    val syncService: SyncService,
+    private val context: Context
 ) : ViewModel() {
 
     // Health Connect manager
@@ -29,49 +30,49 @@ class ClimbViewModel(
 
     // Data flows
     val gyms =
-            repository
-                    .getAllGyms()
-                    .stateIn(
-                            scope = viewModelScope,
-                            started = SharingStarted.WhileSubscribed(),
-                            initialValue = emptyList()
-                    )
+        repository
+            .getAllGyms()
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(),
+                initialValue = emptyList()
+            )
 
     val problems =
-            repository
-                    .getAllProblems()
-                    .stateIn(
-                            scope = viewModelScope,
-                            started = SharingStarted.WhileSubscribed(),
-                            initialValue = emptyList()
-                    )
+        repository
+            .getAllProblems()
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(),
+                initialValue = emptyList()
+            )
 
     val sessions =
-            repository
-                    .getAllSessions()
-                    .stateIn(
-                            scope = viewModelScope,
-                            started = SharingStarted.WhileSubscribed(),
-                            initialValue = emptyList()
-                    )
+        repository
+            .getAllSessions()
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(),
+                initialValue = emptyList()
+            )
 
     val activeSession =
-            repository
-                    .getActiveSessionFlow()
-                    .stateIn(
-                            scope = viewModelScope,
-                            started = SharingStarted.WhileSubscribed(),
-                            initialValue = null
-                    )
+        repository
+            .getActiveSessionFlow()
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(),
+                initialValue = null
+            )
 
     val attempts =
-            repository
-                    .getAllAttempts()
-                    .stateIn(
-                            scope = viewModelScope,
-                            started = SharingStarted.WhileSubscribed(),
-                            initialValue = emptyList()
-                    )
+        repository
+            .getAllAttempts()
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(),
+                initialValue = emptyList()
+            )
 
     // Gym operations
     fun addGym(gym: Gym, updateWidgets: Boolean = true) {
@@ -124,7 +125,7 @@ class ClimbViewModel(
         problem.imagePaths.forEachIndexed { index, tempPath ->
             if (tempPath.startsWith("temp_")) {
                 val finalPath =
-                        ImageUtils.renameTemporaryImage(context, tempPath, problem.id, index)
+                    ImageUtils.renameTemporaryImage(context, tempPath, problem.id, index)
                 finalImagePaths.add(finalPath ?: tempPath)
             } else {
                 finalImagePaths.add(tempPath)
@@ -176,23 +177,23 @@ class ClimbViewModel(
 
             val allProblems = repository.getAllProblems().first()
             val updatedProblems =
-                    allProblems.map { problem ->
-                        if (problem.imagePaths.isNotEmpty()) {
-                            problem.copy(imagePaths = emptyList())
-                        } else {
-                            problem
-                        }
+                allProblems.map { problem ->
+                    if (problem.imagePaths.isNotEmpty()) {
+                        problem.copy(imagePaths = emptyList())
+                    } else {
+                        problem
                     }
+                }
 
             for (updatedProblem in updatedProblems) {
                 if (updatedProblem.imagePaths !=
-                                allProblems.find { it.id == updatedProblem.id }?.imagePaths
+                    allProblems.find { it.id == updatedProblem.id }?.imagePaths
                 ) {
                     repository.insertProblemWithoutSync(updatedProblem)
                 }
             }
 
-            println("Deleted $deletedCount image files and cleared image references")
+            AppLogger.i("ClimbViewModel") { "Deleted $deletedCount image files and cleared image references" }
         }
     }
 
@@ -225,7 +226,7 @@ class ClimbViewModel(
     }
 
     fun getSessionsByGym(gymId: String): Flow<List<ClimbSession>> =
-            repository.getSessionsByGym(gymId)
+        repository.getSessionsByGym(gymId)
 
     // Get last used gym for shortcut functionality
     suspend fun getLastUsedGym(): Gym? = repository.getLastUsedGym()
@@ -233,41 +234,35 @@ class ClimbViewModel(
     // Active session management
     fun startSession(context: Context, gymId: String, notes: String? = null) {
         viewModelScope.launch {
-            android.util.Log.d("ClimbViewModel", "startSession called with gymId: $gymId")
+            AppLogger.d("ClimbViewModel") { "startSession called with gymId: $gymId" }
 
             if (!com.atridad.ascently.utils.NotificationPermissionUtils
-                            .isNotificationPermissionGranted(context)
+                    .isNotificationPermissionGranted(context)
             ) {
-                android.util.Log.d("ClimbViewModel", "Notification permission not granted")
+                AppLogger.d("ClimbViewModel") { "Notification permission not granted" }
                 _uiState.value =
-                        _uiState.value.copy(
-                                error =
-                                        "Notification permission is required to track your climbing session. Please enable notifications in settings."
-                        )
+                    _uiState.value.copy(
+                        error =
+                            "Notification permission is required to track your climbing session. Please enable notifications in settings."
+                    )
                 return@launch
             }
 
             val existingActive = repository.getActiveSession()
             if (existingActive != null) {
-                android.util.Log.d(
-                        "ClimbViewModel",
-                        "Active session already exists: ${existingActive.id}"
-                )
+                AppLogger.d("ClimbViewModel") { "Active session already exists: ${existingActive.id}" }
                 _uiState.value =
-                        _uiState.value.copy(
-                                error = "There's already an active session. Please end it first."
-                        )
+                    _uiState.value.copy(
+                        error = "There's already an active session. Please end it first."
+                    )
                 return@launch
             }
 
-            android.util.Log.d("ClimbViewModel", "Creating new session")
+            AppLogger.d("ClimbViewModel") { "Creating new session" }
             val newSession = ClimbSession.create(gymId = gymId, notes = notes)
             repository.insertSession(newSession)
 
-            android.util.Log.d(
-                    "ClimbViewModel",
-                    "Starting tracking service for session: ${newSession.id}"
-            )
+            AppLogger.d("ClimbViewModel") { "Starting tracking service for session: ${newSession.id}" }
             // Start the tracking service
             val serviceIntent = SessionTrackingService.createStartIntent(context, newSession.id)
             context.startForegroundService(serviceIntent)
@@ -281,13 +276,13 @@ class ClimbViewModel(
     fun endSession(context: Context, sessionId: String) {
         viewModelScope.launch {
             if (!com.atridad.ascently.utils.NotificationPermissionUtils
-                            .isNotificationPermissionGranted(context)
+                    .isNotificationPermissionGranted(context)
             ) {
                 _uiState.value =
-                        _uiState.value.copy(
-                                error =
-                                        "Notification permission is required to manage your climbing session. Please enable notifications in settings."
-                        )
+                    _uiState.value.copy(
+                        error =
+                            "Notification permission is required to manage your climbing session. Please enable notifications in settings."
+                    )
                 return@launch
             }
 
@@ -313,7 +308,7 @@ class ClimbViewModel(
             val activeSession = repository.getActiveSession()
             if (activeSession != null && activeSession.status == SessionStatus.ACTIVE) {
                 val serviceIntent =
-                        SessionTrackingService.createStartIntent(context, activeSession.id)
+                    SessionTrackingService.createStartIntent(context, activeSession.id)
                 context.startForegroundService(serviceIntent)
             }
         }
@@ -348,32 +343,32 @@ class ClimbViewModel(
     }
 
     fun getAttemptsBySession(sessionId: String): Flow<List<Attempt>> =
-            repository.getAttemptsBySession(sessionId)
+        repository.getAttemptsBySession(sessionId)
 
     fun getAttemptsByProblem(problemId: String): Flow<List<Attempt>> =
-            repository.getAttemptsByProblem(problemId)
+        repository.getAttemptsByProblem(problemId)
 
     fun exportDataToZipUri(context: Context, uri: android.net.Uri) {
         viewModelScope.launch {
             try {
                 _uiState.value =
-                        _uiState.value.copy(
-                                isLoading = true,
-                                message = "Creating ZIP file with images..."
-                        )
+                    _uiState.value.copy(
+                        isLoading = true,
+                        message = "Creating ZIP file with images..."
+                    )
                 repository.exportAllDataToZipUri(context, uri)
                 _uiState.value =
-                        _uiState.value.copy(
-                                isLoading = false,
-                                message =
-                                        "Export complete! Your climbing data and images have been saved."
-                        )
+                    _uiState.value.copy(
+                        isLoading = false,
+                        message =
+                            "Export complete! Your climbing data and images have been saved."
+                    )
             } catch (e: Exception) {
                 _uiState.value =
-                        _uiState.value.copy(
-                                isLoading = false,
-                                error = "Export failed: ${e.message}"
-                        )
+                    _uiState.value.copy(
+                        isLoading = false,
+                        error = "Export failed: ${e.message}"
+                    )
             }
         }
     }
@@ -385,23 +380,23 @@ class ClimbViewModel(
 
                 if (!file.name.lowercase().endsWith(".zip")) {
                     throw Exception(
-                            "Only ZIP files are supported for import. Please use a ZIP file exported from Ascently."
+                        "Only ZIP files are supported for import. Please use a ZIP file exported from Ascently."
                     )
                 }
 
                 repository.importDataFromZip(file)
 
                 _uiState.value =
-                        _uiState.value.copy(
-                                isLoading = false,
-                                message = "Data imported successfully from ${file.name}"
-                        )
+                    _uiState.value.copy(
+                        isLoading = false,
+                        message = "Data imported successfully from ${file.name}"
+                    )
             } catch (e: Exception) {
                 _uiState.value =
-                        _uiState.value.copy(
-                                isLoading = false,
-                                error = "Import failed: ${e.message}"
-                        )
+                    _uiState.value.copy(
+                        isLoading = false,
+                        error = "Import failed: ${e.message}"
+                    )
             }
         }
     }
@@ -416,11 +411,13 @@ class ClimbViewModel(
     }
 
     // Sync-related methods
-    suspend fun performManualSync() {
-        try {
-            syncService.syncWithServer()
-        } catch (e: Exception) {
-            setError("Sync failed: ${e.message}")
+    fun performManualSync() {
+        viewModelScope.launch {
+            try {
+                syncService.syncWithServer()
+            } catch (e: Exception) {
+                setError("Sync failed: ${e.message}")
+            }
         }
     }
 
@@ -448,13 +445,13 @@ class ClimbViewModel(
                 repository.resetAllData()
 
                 _uiState.value =
-                        _uiState.value.copy(
-                                isLoading = false,
-                                message = "All data has been reset successfully"
-                        )
+                    _uiState.value.copy(
+                        isLoading = false,
+                        message = "All data has been reset successfully"
+                    )
             } catch (e: Exception) {
                 _uiState.value =
-                        _uiState.value.copy(isLoading = false, error = "Reset failed: ${e.message}")
+                    _uiState.value.copy(isLoading = false, error = "Reset failed: ${e.message}")
             }
         }
     }
@@ -469,23 +466,20 @@ class ClimbViewModel(
                 val attemptCount = attempts.size
 
                 val result =
-                        healthConnectManager.autoSyncCompletedSession(
-                                session,
-                                gymName,
-                                attemptCount
-                        )
+                    healthConnectManager.autoSyncCompletedSession(
+                        session,
+                        gymName,
+                        attemptCount
+                    )
 
                 result.onFailure { error ->
                     if (healthConnectManager.isReadySync()) {
-                        android.util.Log.w(
-                                "ClimbViewModel",
-                                "Health Connect sync failed: ${error.message}"
-                        )
+                        AppLogger.w("ClimbViewModel") { "Health Connect sync failed: ${error.message}" }
                     }
                 }
             } catch (e: Exception) {
                 if (healthConnectManager.isReadySync()) {
-                    android.util.Log.w("ClimbViewModel", "Health Connect sync error: ${e.message}")
+                    AppLogger.w("ClimbViewModel") { "Health Connect sync error: ${e.message}" }
                 }
             }
         }
@@ -493,7 +487,7 @@ class ClimbViewModel(
 }
 
 data class ClimbUiState(
-        val isLoading: Boolean = false,
-        val message: String? = null,
-        val error: String? = null
+    val isLoading: Boolean = false,
+    val message: String? = null,
+    val error: String? = null
 )

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

@@ -0,0 +1,48 @@
+package com.atridad.ascently.utils
+
+import android.util.Log
+import com.atridad.ascently.BuildConfig
+
+object AppLogger {
+
+    private const val DEFAULT_TAG = "Ascently"
+
+    enum class Level(val androidLevel: Int) {
+        DEBUG(Log.DEBUG),
+        INFO(Log.INFO),
+        WARN(Log.WARN),
+        ERROR(Log.ERROR)
+    }
+
+    fun d(tag: String = DEFAULT_TAG, messageProvider: () -> String) {
+        log(Level.DEBUG, tag, messageProvider)
+    }
+
+    fun i(tag: String = DEFAULT_TAG, messageProvider: () -> String) {
+        log(Level.INFO, tag, messageProvider)
+    }
+
+    fun w(tag: String = DEFAULT_TAG, throwable: Throwable? = null, messageProvider: () -> String) {
+        log(Level.WARN, tag, messageProvider, throwable)
+    }
+
+    fun e(tag: String = DEFAULT_TAG, throwable: Throwable? = null, messageProvider: () -> String) {
+        log(Level.ERROR, tag, messageProvider, throwable)
+    }
+
+    private fun log(
+        level: Level,
+        tag: String,
+        messageProvider: () -> String,
+        throwable: Throwable? = null
+    ) {
+        if (!BuildConfig.DEBUG) return
+
+        val message = messageProvider()
+        if (throwable != null) {
+            Log.println(level.androidLevel, tag, "$message\n${Log.getStackTraceString(throwable)}")
+        } else {
+            Log.println(level.androidLevel, tag, message)
+        }
+    }
+}

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

@@ -6,7 +6,6 @@ import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.ImageDecoder
 import android.net.Uri
-import android.util.Log
 import androidx.core.graphics.scale
 import androidx.exifinterface.media.ExifInterface
 import java.io.File
@@ -30,17 +29,17 @@ object ImageUtils {
 
     /** Saves an image from a URI while preserving EXIF orientation data */
     private fun saveImageWithExif(
-            context: Context,
-            imageUri: Uri,
-            originalBitmap: Bitmap,
-            outputFile: File
+        context: Context,
+        imageUri: Uri,
+        originalBitmap: Bitmap,
+        outputFile: File
     ): Boolean {
         return try {
             // Get EXIF data from original image
             val originalExif =
-                    context.contentResolver.openInputStream(imageUri)?.use { input ->
-                        ExifInterface(input)
-                    }
+                context.contentResolver.openInputStream(imageUri)?.use { input ->
+                    ExifInterface(input)
+                }
 
             // Compress and save the bitmap
             val compressedBitmap = compressImage(originalBitmap)
@@ -73,7 +72,7 @@ object ImageUtils {
             compressedBitmap.recycle()
             true
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e("ImageUtils", e) { "Error saving image with EXIF data" }
             false
         }
     }
@@ -86,11 +85,11 @@ object ImageUtils {
 
         // Calculate the scaling factor
         val scaleFactor =
-                if (width > height) {
-                    if (width > MAX_IMAGE_SIZE) MAX_IMAGE_SIZE.toFloat() / width else 1f
-                } else {
-                    if (height > MAX_IMAGE_SIZE) MAX_IMAGE_SIZE.toFloat() / height else 1f
-                }
+            if (width > height) {
+                if (width > MAX_IMAGE_SIZE) MAX_IMAGE_SIZE.toFloat() / width else 1f
+            } else {
+                if (height > MAX_IMAGE_SIZE) MAX_IMAGE_SIZE.toFloat() / height else 1f
+            }
 
         return if (scaleFactor < 1f) {
             val newWidth = (width * scaleFactor).toInt()
@@ -119,7 +118,7 @@ object ImageUtils {
             val file = getImageFile(context, relativePath)
             file.delete()
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e("ImageUtils", e) { "Failed to delete image: $relativePath" }
             false
         }
     }
@@ -137,7 +136,7 @@ object ImageUtils {
             sourceFile.copyTo(destFile, overwrite = true)
             "$IMAGES_DIR/$filename"
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e("ImageUtils", e) { "Failed to import image from source: ${sourceFile.name}" }
             null
         }
     }
@@ -148,16 +147,16 @@ object ImageUtils {
             val imagesDir = getImagesDirectory(context)
             imagesDir.listFiles()?.mapNotNull { file ->
                 if (file.isFile &&
-                                (file.extension == "jpg" ||
-                                        file.extension == "jpeg" ||
-                                        file.extension == "png")
+                    (file.extension == "jpg" ||
+                            file.extension == "jpeg" ||
+                            file.extension == "png")
                 ) {
                     "$IMAGES_DIR/${file.name}"
                 } else null
             }
-                    ?: emptyList()
+                ?: emptyList()
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e("ImageUtils", e) { "Failed to enumerate images directory" }
             emptyList()
         }
     }
@@ -178,50 +177,47 @@ object ImageUtils {
 
             tempFilename
         } catch (e: Exception) {
-            Log.e("ImageUtils", "Error saving temporary image from URI", e)
+            AppLogger.e("ImageUtils", e) { "Error saving temporary image from URI" }
             null
         }
     }
 
     /** Renames a temporary image */
     fun renameTemporaryImage(
-            context: Context,
-            tempFilename: String,
-            problemId: String,
-            imageIndex: Int
+        context: Context,
+        tempFilename: String,
+        problemId: String,
+        imageIndex: Int
     ): String? {
         return try {
             val tempFile = File(getImagesDirectory(context), tempFilename)
             if (!tempFile.exists()) {
-                Log.e("ImageUtils", "Temporary file does not exist: $tempFilename")
+                AppLogger.e("ImageUtils") { "Temporary file does not exist: $tempFilename" }
                 return null
             }
 
             val deterministicFilename =
-                    ImageNamingUtils.generateImageFilename(problemId, imageIndex)
+                ImageNamingUtils.generateImageFilename(problemId, imageIndex)
             val finalFile = File(getImagesDirectory(context), deterministicFilename)
 
             if (tempFile.renameTo(finalFile)) {
-                Log.d(
-                        "ImageUtils",
-                        "Renamed temporary image: $tempFilename -> $deterministicFilename"
-                )
+                AppLogger.d("ImageUtils") { "Renamed temporary image: $tempFilename -> $deterministicFilename" }
                 deterministicFilename
             } else {
-                Log.e("ImageUtils", "Failed to rename temporary image: $tempFilename")
+                AppLogger.e("ImageUtils") { "Failed to rename temporary image: $tempFilename" }
                 null
             }
         } catch (e: Exception) {
-            Log.e("ImageUtils", "Error renaming temporary image", e)
+            AppLogger.e("ImageUtils", e) { "Error renaming temporary image" }
             null
         }
     }
 
     /** Saves image data with a specific filename */
     fun saveImageFromBytesWithFilename(
-            context: Context,
-            imageData: ByteArray,
-            filename: String
+        context: Context,
+        imageData: ByteArray,
+        filename: String
     ): String? {
         return try {
             val imageFile = File(getImagesDirectory(context), filename)
@@ -230,7 +226,7 @@ object ImageUtils {
             if (imageData.size > 5 * 1024 * 1024) { // 5MB threshold
                 // For large images, decode, compress, and try to preserve EXIF
                 val bitmap =
-                        BitmapFactory.decodeByteArray(imageData, 0, imageData.size) ?: return null
+                    BitmapFactory.decodeByteArray(imageData, 0, imageData.size) ?: return null
                 val compressedBitmap = compressImage(bitmap)
 
                 // Save compressed image
@@ -249,7 +245,7 @@ object ImageUtils {
                     destExif.saveAttributes()
                 } catch (e: Exception) {
                     // If EXIF preservation fails, continue without it
-                    Log.w("ImageUtils", "Failed to preserve EXIF data: ${e.message}")
+                    AppLogger.w("ImageUtils") { "Failed to preserve EXIF data: ${e.message}" }
                 }
 
                 bitmap.recycle()
@@ -262,7 +258,7 @@ object ImageUtils {
             // Return relative path
             "$IMAGES_DIR/$filename"
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e("ImageUtils", e) { "Failed to save image from bytes: $filename" }
             null
         }
     }
@@ -275,7 +271,7 @@ object ImageUtils {
 
             orphanedImages.forEach { path -> deleteImage(context, path) }
         } catch (e: Exception) {
-            e.printStackTrace()
+            AppLogger.e("ImageUtils", e) { "Failed to clean up orphaned images" }
         }
     }
 }

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

@@ -2,13 +2,8 @@ package com.atridad.ascently.utils
 
 import android.content.Context
 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 {
@@ -18,7 +13,7 @@ class MigrationManager(private val context: Context) {
     }
 
     private val migrationPrefs: SharedPreferences =
-            context.getSharedPreferences(MIGRATION_PREFS, Context.MODE_PRIVATE)
+        context.getSharedPreferences(MIGRATION_PREFS, Context.MODE_PRIVATE)
 
     /**
      * Perform migration from OpenClimb to Ascently if needed This should be called early in app
@@ -26,11 +21,11 @@ class MigrationManager(private val context: Context) {
      */
     fun migrateIfNeeded() {
         if (migrationPrefs.getBoolean(MIGRATION_COMPLETED_KEY, false)) {
-            Log.d(TAG, "Migration already completed, skipping")
+            AppLogger.d(TAG) { "Migration already completed, skipping" }
             return
         }
 
-        Log.i(TAG, "🔄 Starting migration from OpenClimb to Ascently...")
+        AppLogger.i(TAG) { "🔄 Starting migration from OpenClimb to Ascently..." }
         var migrationCount = 0
 
         // Migrate SharedPreferences
@@ -40,12 +35,9 @@ class MigrationManager(private val context: Context) {
         migrationPrefs.edit { putBoolean(MIGRATION_COMPLETED_KEY, true) }
 
         if (migrationCount > 0) {
-            Log.i(
-                    TAG,
-                    "🎉 Migration completed! Migrated $migrationCount items from OpenClimb to Ascently"
-            )
+            AppLogger.i(TAG) { "🎉 Migration completed! Migrated $migrationCount items from OpenClimb to Ascently" }
         } else {
-            Log.i(TAG, "ℹ️ No OpenClimb data found to migrate")
+            AppLogger.i(TAG) { "ℹ️ No OpenClimb data found to migrate" }
         }
     }
 
@@ -55,12 +47,12 @@ class MigrationManager(private val context: Context) {
 
         // Define preference file migrations
         val preferenceFileMigrations =
-                listOf(
-                        "openclimb_data_state" to "ascently_data_state",
-                        "health_connect_prefs" to "health_connect_prefs", // Keep same name
-                        "deleted_items" to "deleted_items", // Keep same name
-                        "sync_preferences" to "sync_preferences" // Keep same name
-                )
+            listOf(
+                "openclimb_data_state" to "ascently_data_state",
+                "health_connect_prefs" to "health_connect_prefs", // Keep same name
+                "deleted_items" to "deleted_items", // Keep same name
+                "sync_preferences" to "sync_preferences" // Keep same name
+            )
 
         for ((oldFileName, newFileName) in preferenceFileMigrations) {
             if (oldFileName != newFileName) {
@@ -99,10 +91,7 @@ class MigrationManager(private val context: Context) {
             // Clear old preferences
             oldPrefs.edit { clear() }
 
-            Log.d(
-                    TAG,
-                    "✅ Migrated preference file: $oldFileName → $newFileName (${oldPrefs.all.size} keys)"
-            )
+            AppLogger.d(TAG) { "Migrated preference file: $oldFileName → $newFileName (${oldPrefs.all.size} keys)" }
             return oldPrefs.all.size
         }
 
@@ -115,12 +104,12 @@ class MigrationManager(private val context: Context) {
 
         // Check for any openclimb-prefixed keys across all preference files
         val preferencesToCheck =
-                listOf(
-                        "ascently_data_state",
-                        "health_connect_prefs",
-                        "deleted_items",
-                        "sync_preferences"
-                )
+            listOf(
+                "ascently_data_state",
+                "health_connect_prefs",
+                "deleted_items",
+                "sync_preferences"
+            )
 
         for (prefFileName in preferencesToCheck) {
             val prefs = context.getSharedPreferences(prefFileName, Context.MODE_PRIVATE)
@@ -154,7 +143,7 @@ class MigrationManager(private val context: Context) {
                     }
                 }
 
-                Log.d(TAG, "✅ Migrated ${keysToMigrate.size} keys in $prefFileName")
+                AppLogger.d(TAG) { "Migrated ${keysToMigrate.size} keys in $prefFileName" }
                 count += keysToMigrate.size
             }
         }
@@ -170,6 +159,6 @@ class MigrationManager(private val context: Context) {
     /** Reset migration state (for testing purposes) */
     fun resetMigrationState() {
         migrationPrefs.edit { putBoolean(MIGRATION_COMPLETED_KEY, false) }
-        Log.d(TAG, "Migration state reset")
+        AppLogger.d(TAG) { "Migration state reset" }
     }
 }

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

@@ -22,19 +22,19 @@ object ZipExportImportUtils {
 
     /** Creates a ZIP file containing the JSON data and all referenced images */
     fun createExportZip(
-            context: Context,
-            exportData: ClimbDataBackup,
-            referencedImagePaths: Set<String>,
-            directory: File? = null
+        context: Context,
+        exportData: ClimbDataBackup,
+        referencedImagePaths: Set<String>,
+        directory: File? = null
     ): File {
         val exportDir =
-                directory
-                        ?: File(
-                                context.getExternalFilesDir(
-                                        android.os.Environment.DIRECTORY_DOCUMENTS
-                                ),
-                                "Ascently"
-                        )
+            directory
+                ?: File(
+                    context.getExternalFilesDir(
+                        android.os.Environment.DIRECTORY_DOCUMENTS
+                    ),
+                    "Ascently"
+                )
         if (!exportDir.exists()) {
             exportDir.mkdirs()
         }
@@ -52,10 +52,11 @@ object ZipExportImportUtils {
                 zipOut.closeEntry()
 
                 // Add JSON data file
-                val json = Json {
-                    prettyPrint = true
-                    ignoreUnknownKeys = true
-                }
+                val json =
+                    Json {
+                        prettyPrint = true
+                        ignoreUnknownKeys = true
+                    }
                 val jsonString = json.encodeToString(exportData)
 
                 val jsonEntry = ZipEntry(DATA_JSON_FILENAME)
@@ -78,24 +79,21 @@ object ZipExportImportUtils {
                             zipOut.closeEntry()
                             successfulImages++
                         } else {
-                            android.util.Log.w(
-                                    "ZipExportImportUtils",
-                                    "Image file not found or empty: $imagePath"
-                            )
+                            AppLogger.w("ZipExportImportUtils") {
+                                "Image file not found or empty: $imagePath"
+                            }
                         }
                     } catch (e: Exception) {
-                        android.util.Log.e(
-                                "ZipExportImportUtils",
-                                "Failed to add image $imagePath: ${e.message}"
-                        )
+                        AppLogger.e("ZipExportImportUtils", e) {
+                            "Failed to add image $imagePath: ${e.message}"
+                        }
                     }
                 }
 
                 // Log export summary
-                android.util.Log.i(
-                        "ZipExportImportUtils",
-                        "Export completed: ${successfulImages}/${referencedImagePaths.size} images included"
-                )
+                AppLogger.i("ZipExportImportUtils") {
+                    "Export completed: ${successfulImages}/${referencedImagePaths.size} images included"
+                }
             }
 
             // Validate the created ZIP file
@@ -115,10 +113,10 @@ object ZipExportImportUtils {
 
     /** Creates a ZIP file and writes it to a provided URI */
     fun createExportZipToUri(
-            context: Context,
-            uri: android.net.Uri,
-            exportData: ClimbDataBackup,
-            referencedImagePaths: Set<String>
+        context: Context,
+        uri: android.net.Uri,
+        exportData: ClimbDataBackup,
+        referencedImagePaths: Set<String>
     ) {
         try {
             context.contentResolver.openOutputStream(uri)?.use { outputStream ->
@@ -131,10 +129,11 @@ object ZipExportImportUtils {
                     zipOut.closeEntry()
 
                     // Add JSON data file
-                    val json = Json {
-                        prettyPrint = true
-                        ignoreUnknownKeys = true
-                    }
+                    val json =
+                        Json {
+                            prettyPrint = true
+                            ignoreUnknownKeys = true
+                        }
                     val jsonString = json.encodeToString(exportData)
 
                     val jsonEntry = ZipEntry(DATA_JSON_FILENAME)
@@ -158,28 +157,26 @@ object ZipExportImportUtils {
                                 successfulImages++
                             }
                         } catch (e: Exception) {
-                            android.util.Log.e(
-                                    "ZipExportImportUtils",
-                                    "Failed to add image $imagePath: ${e.message}"
-                            )
+                            AppLogger.e("ZipExportImportUtils", e) {
+                                "Failed to add image $imagePath: ${e.message}"
+                            }
                         }
                     }
 
-                    android.util.Log.i(
-                            "ZipExportImportUtils",
-                            "Export to URI completed: ${successfulImages}/${referencedImagePaths.size} images included"
-                    )
+                    AppLogger.i("ZipExportImportUtils") {
+                        "Export to URI completed: ${successfulImages}/${referencedImagePaths.size} images included"
+                    }
                 }
             }
-                    ?: throw IOException("Could not open output stream")
+                ?: throw IOException("Could not open output stream")
         } catch (e: Exception) {
             throw IOException("Failed to create export ZIP to URI: ${e.message}")
         }
     }
 
     private fun createMetadata(
-            exportData: ClimbDataBackup,
-            referencedImagePaths: Set<String>
+        exportData: ClimbDataBackup,
+        referencedImagePaths: Set<String>
     ): String {
         return buildString {
             appendLine("Ascently Export Metadata")
@@ -197,8 +194,8 @@ object ZipExportImportUtils {
 
     /** Data class to hold extraction results */
     data class ImportResult(
-            val jsonContent: String,
-            val importedImagePaths: Map<String, String> // original filename -> new relative path
+        val jsonContent: String,
+        val importedImagePaths: Map<String, String> // original filename -> new relative path
     )
 
     /** Extracts a ZIP file and returns the JSON content and imported image paths */
@@ -217,16 +214,17 @@ object ZipExportImportUtils {
                             // Read metadata for validation
                             val metadataContent = zipIn.readBytes().toString(Charsets.UTF_8)
                             foundRequiredFiles.add("metadata")
-                            android.util.Log.i(
-                                    "ZipExportImportUtils",
-                                    "Found metadata: ${metadataContent.lines().take(3).joinToString()}"
-                            )
+                            AppLogger.i("ZipExportImportUtils") {
+                                "Found metadata: ${metadataContent.lines().take(3).joinToString()}"
+                            }
                         }
+
                         entry.name == DATA_JSON_FILENAME -> {
                             // Read JSON data
                             jsonContent = zipIn.readBytes().toString(Charsets.UTF_8)
                             foundRequiredFiles.add("data")
                         }
+
                         entry.name.startsWith("$IMAGES_DIR_NAME/") && !entry.isDirectory -> {
                             // Extract image file
                             val originalFilename = entry.name.substringAfter("$IMAGES_DIR_NAME/")
@@ -234,11 +232,11 @@ object ZipExportImportUtils {
                             try {
                                 // Create temporary file to hold the extracted image
                                 val tempFile =
-                                        File.createTempFile(
-                                                "import_image_",
-                                                "_$originalFilename",
-                                                context.cacheDir
-                                        )
+                                    File.createTempFile(
+                                        "import_image_",
+                                        "_$originalFilename",
+                                        context.cacheDir
+                                    )
 
                                 FileOutputStream(tempFile).use { output -> zipIn.copyTo(output) }
 
@@ -248,37 +246,33 @@ object ZipExportImportUtils {
                                     val newPath = ImageUtils.importImageFile(context, tempFile)
                                     if (newPath != null) {
                                         importedImagePaths[originalFilename] = newPath
-                                        android.util.Log.d(
-                                                "ZipExportImportUtils",
-                                                "Successfully imported image: $originalFilename -> $newPath"
-                                        )
+                                        AppLogger.d("ZipExportImportUtils") {
+                                            "Successfully imported image: $originalFilename -> $newPath"
+                                        }
                                     } else {
-                                        android.util.Log.w(
-                                                "ZipExportImportUtils",
-                                                "Failed to import image: $originalFilename"
-                                        )
+                                        AppLogger.w("ZipExportImportUtils") {
+                                            "Failed to import image: $originalFilename"
+                                        }
                                     }
                                 } else {
-                                    android.util.Log.w(
-                                            "ZipExportImportUtils",
-                                            "Extracted image is empty: $originalFilename"
-                                    )
+                                    AppLogger.w("ZipExportImportUtils") {
+                                        "Extracted image is empty: $originalFilename"
+                                    }
                                 }
 
                                 // Clean up temp file
                                 tempFile.delete()
                             } catch (e: Exception) {
-                                android.util.Log.e(
-                                        "ZipExportImportUtils",
-                                        "Failed to process image $originalFilename: ${e.message}"
-                                )
+                                AppLogger.e("ZipExportImportUtils", e) {
+                                    "Failed to process image $originalFilename: ${e.message}"
+                                }
                             }
                         }
+
                         else -> {
-                            android.util.Log.d(
-                                    "ZipExportImportUtils",
-                                    "Skipping ZIP entry: ${entry.name}"
-                            )
+                            AppLogger.d("ZipExportImportUtils") {
+                                "Skipping ZIP entry: ${entry.name}"
+                            }
                         }
                     }
 
@@ -296,10 +290,9 @@ object ZipExportImportUtils {
                 throw IOException("Invalid ZIP file: data.json is empty")
             }
 
-            android.util.Log.i(
-                    "ZipExportImportUtils",
-                    "Import extraction completed: ${importedImagePaths.size} images processed"
-            )
+            AppLogger.i("ZipExportImportUtils") {
+                "Import extraction completed: ${importedImagePaths.size} images processed"
+            }
 
             return ImportResult(jsonContent, importedImagePaths)
         } catch (e: Exception) {
@@ -312,16 +305,16 @@ object ZipExportImportUtils {
      * the new ones after import
      */
     fun updateProblemImagePaths(
-            problems: List<BackupProblem>,
-            imagePathMapping: Map<String, String>
+        problems: List<BackupProblem>,
+        imagePathMapping: Map<String, String>
     ): List<BackupProblem> {
         return problems.map { problem ->
             val updatedImagePaths =
-                    (problem.imagePaths ?: emptyList()).mapNotNull { oldPath ->
-                        // Extract filename from the old path
-                        val filename = oldPath.substringAfterLast("/")
-                        imagePathMapping[filename]
-                    }
+                (problem.imagePaths ?: emptyList()).mapNotNull { oldPath ->
+                    // Extract filename from the old path
+                    val filename = oldPath.substringAfterLast("/")
+                    imagePathMapping[filename]
+                }
             problem.withUpdatedImagePaths(updatedImagePaths)
         }
     }

android/app/src/main/java/com/atridad/ascently/widget/ClimbStatsWidgetProvider.kt

@@ -11,6 +11,7 @@ import com.atridad.ascently.MainActivity
 import com.atridad.ascently.R
 import com.atridad.ascently.data.database.AscentlyDatabase
 import com.atridad.ascently.data.repository.ClimbRepository
+import java.time.LocalDate
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -48,53 +49,47 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
                 val database = AscentlyDatabase.getDatabase(context)
                 val repository = ClimbRepository(database, context)
 
-                // Fetch stats data
+                // Get last 7 days date range (rolling period)
+                val today = LocalDate.now()
+                val sevenDaysAgo = today.minusDays(6) // Today + 6 days ago = 7 days total
+
+                // Fetch all sessions and attempts
                 val sessions = repository.getAllSessions().first()
-                val problems = repository.getAllProblems().first()
                 val attempts = repository.getAllAttempts().first()
-                val gyms = repository.getAllGyms().first()
 
-                // Calculate stats
-                val completedSessions = sessions.filter { it.endTime != null }
-
-                // Count problems that have been completed (have at least one successful attempt)
-                val completedProblems =
-                        problems
-                                .filter { problem ->
-                                    attempts.any { attempt ->
-                                        attempt.problemId == problem.id &&
-                                                (attempt.result ==
-                                                        com.atridad.ascently.data.model
-                                                                .AttemptResult.SUCCESS ||
-                                                        attempt.result ==
-                                                                com.atridad.ascently.data.model
-                                                                        .AttemptResult.FLASH)
-                                    }
-                                }
-                                .size
-
-                val favoriteGym =
-                        sessions.groupBy { it.gymId }.maxByOrNull { it.value.size }?.let {
-                                (gymId, _) ->
-                            gyms.find { it.id == gymId }?.name
+                // Filter for last 7 days across all gyms
+                val weekSessions =
+                        sessions.filter { session ->
+                            try {
+                                val sessionDate = LocalDate.parse(session.date.substring(0, 10))
+                                !sessionDate.isBefore(sevenDaysAgo) && !sessionDate.isAfter(today)
+                            } catch (_: Exception) {
+                                false
+                            }
                         }
-                                ?: "No sessions yet"
+
+                val weekSessionIds = weekSessions.map { it.id }.toSet()
+
+                // Count total attempts this week
+                val totalAttempts =
+                        attempts.count { attempt -> weekSessionIds.contains(attempt.sessionId) }
+
+                // Count sessions this week
+                val totalSessions = weekSessions.size
 
                 launch(Dispatchers.Main) {
                     val views = RemoteViews(context.packageName, R.layout.widget_climb_stats)
 
-                    views.setTextViewText(
-                            R.id.widget_total_sessions,
-                            completedSessions.size.toString()
-                    )
-                    views.setTextViewText(
-                            R.id.widget_problems_completed,
-                            completedProblems.toString()
-                    )
-                    views.setTextViewText(R.id.widget_total_problems, problems.size.toString())
-                    views.setTextViewText(R.id.widget_favorite_gym, favoriteGym)
+                    // Set weekly stats
+                    views.setTextViewText(R.id.widget_attempts_value, totalAttempts.toString())
+                    views.setTextViewText(R.id.widget_sessions_value, totalSessions.toString())
 
-                    val intent = Intent(context, MainActivity::class.java)
+                    val intent =
+                            Intent(context, MainActivity::class.java).apply {
+                                flags =
+                                        Intent.FLAG_ACTIVITY_NEW_TASK or
+                                                Intent.FLAG_ACTIVITY_CLEAR_TOP
+                            }
                     val pendingIntent =
                             PendingIntent.getActivity(
                                     context,
@@ -110,10 +105,8 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
             } catch (_: Exception) {
                 launch(Dispatchers.Main) {
                     val views = RemoteViews(context.packageName, R.layout.widget_climb_stats)
-                    views.setTextViewText(R.id.widget_total_sessions, "0")
-                    views.setTextViewText(R.id.widget_problems_completed, "0")
-                    views.setTextViewText(R.id.widget_total_problems, "0")
-                    views.setTextViewText(R.id.widget_favorite_gym, "No data")
+                    views.setTextViewText(R.id.widget_attempts_value, "0")
+                    views.setTextViewText(R.id.widget_sessions_value, "0")
 
                     val intent = Intent(context, MainActivity::class.java)
                     val pendingIntent =

android/app/src/main/res/drawable/ic_checkmark_circle.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M12,2C6.48,2 2,6.48 2,12C2,17.52 6.48,22 12,22C17.52,22 22,17.52 22,12C22,6.48 17.52,2 12,2ZM10,17L5,12L6.41,10.59L10,14.17L17.59,6.58L19,8L10,17Z"/>
+</vector>

android/app/src/main/res/drawable/ic_circle_filled.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M9,11.24V7.5C9,6.12 10.12,5 11.5,5S14,6.12 14,7.5v3.74c1.21,-0.81 2,-2.18 2,-3.74C16,5.01 13.99,3 11.5,3S7,5.01 7,7.5C7,9.06 7.79,10.43 9,11.24zM18.84,15.87l-4.54,-2.26c-0.17,-0.07 -0.35,-0.11 -0.54,-0.11H13v-6C13,6.67 12.33,6 11.5,6S10,6.67 10,7.5v10.74l-3.43,-0.72c-0.08,-0.01 -0.15,-0.03 -0.24,-0.03c-0.31,0 -0.59,0.13 -0.79,0.33l-0.79,0.8l4.94,4.94C9.96,23.83 10.34,24 10.75,24h6.79c0.75,0 1.33,-0.55 1.44,-1.28l0.75,-5.27c0.01,-0.07 0.02,-0.14 0.02,-0.2C19.75,16.63 19.37,16.09 18.84,15.87z"/>
+</vector>

android/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -4,27 +4,6 @@
     android:height="108dp"
     android:viewportWidth="108"
     android:viewportHeight="108">
-    
-    <group
-        android:scaleX="0.7"
-        android:scaleY="0.7"
-        android:translateX="16.2"
-        android:translateY="20">
-        
-        <!-- Left mountain (yellow/amber) -->
-        <path
-            android:fillColor="#FFC107"
-            android:strokeColor="#1C1C1C"
-            android:strokeWidth="3"
-            android:strokeLineJoin="round"
-            android:pathData="M15,70 L35,25 L55,70 Z" />
-        
-        <!-- Right mountain (red) -->
-        <path
-            android:fillColor="#F44336"
-            android:strokeColor="#1C1C1C"
-            android:strokeWidth="3"
-            android:strokeLineJoin="round"
-            android:pathData="M40,70 L65,15 L90,70 Z" />
-    </group>
+    <path android:fillColor="#FFC107" android:pathData="M24.000,78.545 L41.851,38.380 L59.702,78.545 Z" />
+    <path android:fillColor="#F44336" android:pathData="M39.372,78.545 L61.686,29.455 L84.000,78.545 Z" />
 </vector>

android/app/src/main/res/drawable/ic_mountains.xml

@@ -4,29 +4,6 @@
     android:height="24dp"
     android:viewportWidth="24"
     android:viewportHeight="24">
-    
-    <!-- Left mountain (yellow/amber) -->
-    <path
-        android:fillColor="#FFC107"
-        android:pathData="M3,18 L8,9 L13,18 Z" />
-    
-    <!-- Right mountain (red) -->
-    <path
-        android:fillColor="#F44336"
-        android:pathData="M11,18 L16,7 L21,18 Z" />
-    
-    <!-- Black outlines -->
-    <path
-        android:fillColor="@android:color/transparent"
-        android:strokeColor="#1C1C1C"
-        android:strokeWidth="1"
-        android:strokeLineJoin="round"
-        android:pathData="M3,18 L8,9 L13,18" />
-    
-    <path
-        android:fillColor="@android:color/transparent"
-        android:strokeColor="#1C1C1C"
-        android:strokeWidth="1"
-        android:strokeLineJoin="round"
-        android:pathData="M11,18 L16,7 L21,18" />
-</vector>
+    <path android:fillColor="#FFC107" android:pathData="M2.000,20.182 L7.950,6.793 L13.901,20.182 Z" />
+    <path android:fillColor="#F44336" android:pathData="M7.124,20.182 L14.562,3.818 L22.000,20.182 Z" />
+</vector>

android/app/src/main/res/drawable/ic_splash.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M0,0 L108,0 L108,108 L0,108 Z" />
+
+    <path
+        android:fillColor="#FFC107"
+        android:pathData="M24,74 L42,34 L60,74 Z" />
+
+    <path
+        android:fillColor="#F44336"
+        android:pathData="M41,74 L59,24 L84,74 Z" />
+</vector>

android/app/src/main/res/layout/widget_climb_stats.xml

@@ -5,190 +5,84 @@
     android:layout_height="match_parent"
     android:background="@drawable/widget_background"
     android:orientation="vertical"
-    android:padding="12dp">
+    android:padding="12dp"
+    android:gravity="center">
 
-    <!-- Header -->
+    <!-- Header with icon and "Weekly" text -->
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
-        android:gravity="center_vertical"
         android:orientation="horizontal"
+        android:gravity="center_vertical"
         android:layout_marginBottom="12dp">
 
         <ImageView
-            android:layout_width="24dp"
-            android:layout_height="24dp"
+            android:layout_width="28dp"
+            android:layout_height="28dp"
             android:src="@drawable/ic_mountains"
             android:tint="@color/widget_primary"
-            android:layout_marginEnd="8dp" />
-
-        <TextView
-            android:layout_width="0dp"
-            android:layout_height="wrap_content"
-            android:layout_weight="1"
-            android:text="Ascently"
-            android:textSize="16sp"
-            android:textStyle="bold"
-            android:textColor="@color/widget_text_primary" />
+            android:layout_marginEnd="8dp"
+            android:contentDescription="@string/ascently_icon" />
 
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:text="Climbing Stats"
-            android:textSize="12sp"
-            android:textColor="@color/widget_text_secondary" />
+            android:text="@string/weekly"
+            android:textSize="18sp"
+            android:textColor="@color/widget_text_primary" />
 
     </LinearLayout>
 
-    <!-- Stats Grid -->
+    <!-- Attempts Row -->
     <LinearLayout
         android:layout_width="match_parent"
-        android:layout_height="0dp"
-        android:layout_weight="1"
-        android:orientation="vertical"
-        android:gravity="center">
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center_vertical"
+        android:layout_marginBottom="12dp">
 
-        <!-- Top Row -->
-        <LinearLayout
-            android:layout_width="match_parent"
-            android:layout_height="0dp"
-            android:layout_weight="1"
-            android:orientation="horizontal"
-            android:layout_marginBottom="8dp">
+        <ImageView
+            android:layout_width="32dp"
+            android:layout_height="32dp"
+            android:src="@drawable/ic_circle_filled"
+            android:tint="@color/widget_primary"
+            android:layout_marginEnd="12dp"
+            android:contentDescription="Attempts icon" />
 
-            <!-- Sessions Card -->
-            <LinearLayout
-                android:layout_width="0dp"
-                android:layout_height="match_parent"
-                android:layout_weight="1"
-                android:orientation="vertical"
-                android:gravity="center"
-                android:background="@drawable/widget_stat_card_background"
-                android:layout_marginEnd="4dp"
-                android:padding="12dp">
+        <TextView
+            android:id="@+id/widget_attempts_value"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="0"
+            android:textSize="40sp"
+            android:textStyle="bold"
+            android:textColor="@color/widget_text_primary" />
 
-                <TextView
-                    android:id="@+id/widget_total_sessions"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="0"
-                    android:textSize="22sp"
-                    android:textStyle="bold"
-                    android:textColor="@color/widget_primary" />
+    </LinearLayout>
 
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Sessions"
-                    android:textSize="12sp"
-                    android:textColor="@color/widget_text_secondary"
-                    android:layout_marginTop="2dp" />
+    <!-- Sessions Row -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
 
-            </LinearLayout>
+        <ImageView
+            android:layout_width="32dp"
+            android:layout_height="32dp"
+            android:src="@drawable/ic_play_arrow_24"
+            android:tint="@color/widget_primary"
+            android:layout_marginEnd="12dp"
+            android:contentDescription="@string/sessions_icon" />
 
-            <!-- Problems Card -->
-            <LinearLayout
-                android:layout_width="0dp"
-                android:layout_height="match_parent"
-                android:layout_weight="1"
-                android:orientation="vertical"
-                android:gravity="center"
-                android:background="@drawable/widget_stat_card_background"
-                android:layout_marginStart="4dp"
-                android:padding="12dp">
-
-                <TextView
-                    android:id="@+id/widget_problems_completed"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="0"
-                    android:textSize="22sp"
-                    android:textStyle="bold"
-                    android:textColor="@color/widget_primary" />
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Completed"
-                    android:textSize="12sp"
-                    android:textColor="@color/widget_text_secondary"
-                    android:layout_marginTop="2dp" />
-
-            </LinearLayout>
-
-        </LinearLayout>
-
-        <!-- Bottom Row -->
-        <LinearLayout
-            android:layout_width="match_parent"
-            android:layout_height="0dp"
-            android:layout_weight="1"
-            android:orientation="horizontal">
-
-            <!-- Success Rate Card -->
-            <LinearLayout
-                android:layout_width="0dp"
-                android:layout_height="match_parent"
-                android:layout_weight="1"
-                android:orientation="vertical"
-                android:gravity="center"
-                android:background="@drawable/widget_stat_card_background"
-                android:layout_marginEnd="4dp"
-                android:padding="12dp">
-
-                <TextView
-                    android:id="@+id/widget_total_problems"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="0"
-                    android:textSize="22sp"
-                    android:textStyle="bold"
-                    android:textColor="@color/widget_secondary" />
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Problems"
-                    android:textSize="12sp"
-                    android:textColor="@color/widget_text_secondary"
-                    android:layout_marginTop="2dp" />
-
-            </LinearLayout>
-
-            <!-- Favorite Gym Card -->
-            <LinearLayout
-                android:layout_width="0dp"
-                android:layout_height="match_parent"
-                android:layout_weight="1"
-                android:orientation="vertical"
-                android:gravity="center"
-                android:background="@drawable/widget_stat_card_background"
-                android:layout_marginStart="4dp"
-                android:padding="12dp">
-
-                <TextView
-                    android:id="@+id/widget_favorite_gym"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="No gyms"
-                    android:textSize="13sp"
-                    android:textStyle="bold"
-                    android:textColor="@color/widget_accent"
-                    android:gravity="center"
-                    android:maxLines="2"
-                    android:ellipsize="end" />
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Favorite"
-                    android:textSize="12sp"
-                    android:textColor="@color/widget_text_secondary"
-                    android:layout_marginTop="2dp" />
-
-            </LinearLayout>
-
-        </LinearLayout>
+        <TextView
+            android:id="@+id/widget_sessions_value"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/_0"
+            android:textSize="40sp"
+            android:textStyle="bold"
+            android:textColor="@color/widget_text_primary" />
 
     </LinearLayout>
 

android/app/src/main/res/values/strings.xml

@@ -12,5 +12,9 @@
     <string name="shortcut_end_session_disabled">No active session to end</string>
 
     <!-- Widget -->
-    <string name="widget_description">View your climbing stats at a glance</string>
+    <string name="widget_description">View your weekly climbing stats</string>
+    <string name="ascently_icon">Ascently icon</string>
+    <string name="weekly">Weekly</string>
+    <string name="sessions_icon">Sessions icon</string>
+    <string name="_0">0</string>
 </resources>

android/app/src/main/res/values/themes.xml

@@ -4,7 +4,7 @@
 
     <style name="Theme.Ascently.Splash" parent="Theme.Ascently">
         <item name="android:windowSplashScreenBackground">@color/splash_background</item>
-        <item name="android:windowSplashScreenAnimatedIcon">@drawable/ic_mountains</item>
+        <item name="android:windowSplashScreenAnimatedIcon">@drawable/ic_splash</item>
         <item name="android:windowSplashScreenAnimationDuration">200</item>
     </style>
 </resources>

android/app/src/main/res/xml/data_extraction_rules.xml

@@ -5,10 +5,6 @@
 -->
 <data-extraction-rules>
     <cloud-backup>
-        <!-- TODO: Use <include> and <exclude> to control what is backed up.
-        <include .../>
-        <exclude .../>
-        -->
     </cloud-backup>
     <!--
     <device-transfer>

android/app/src/main/res/xml/widget_climb_stats_info.xml

@@ -3,15 +3,14 @@
     android:description="@string/widget_description"
     android:initialKeyguardLayout="@layout/widget_climb_stats"
     android:initialLayout="@layout/widget_climb_stats"
-    android:minWidth="250dp"
-    android:minHeight="180dp"
+    android:minWidth="110dp"
+    android:minHeight="110dp"
+    android:maxResizeWidth="110dp"
+    android:maxResizeHeight="110dp"
     android:previewImage="@drawable/ic_mountains"
     android:previewLayout="@layout/widget_climb_stats"
-    android:resizeMode="horizontal|vertical"
-    android:targetCellWidth="4"
+    android:resizeMode="none"
+    android:targetCellWidth="2"
     android:targetCellHeight="2"
     android:updatePeriodMillis="1800000"
-    android:widgetCategory="home_screen"
-    android:widgetFeatures="reconfigurable"
-    android:maxResizeWidth="320dp"
-    android:maxResizeHeight="240dp" />
+    android:widgetCategory="home_screen" />

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(

android/gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 agp = "8.12.3"
-kotlin = "2.2.20"
+kotlin = "2.2.21"
 coreKtx = "1.17.0"
 junit = "4.13.2"
 junitVersion = "1.3.0"
@@ -9,17 +9,17 @@ androidxTestCore = "1.7.0"
 androidxTestExt = "1.3.0"
 androidxTestRunner = "1.7.0"
 androidxTestRules = "1.7.0"
-lifecycleRuntimeKtx = "2.9.4"
-activityCompose = "1.11.0"
-composeBom = "2025.10.00"
-room = "2.8.2"
-navigation = "2.9.5"
-viewmodel = "2.9.4"
+lifecycleRuntimeKtx = "2.10.0"
+activityCompose = "1.12.0"
+composeBom = "2025.11.01"
+room = "2.8.4"
+navigation = "2.9.6"
+viewmodel = "2.10.0"
 kotlinxSerialization = "1.9.0"
 kotlinxCoroutines = "1.10.2"
 coil = "2.7.0"
 ksp = "2.2.20-2.0.3"
-exifinterface = "1.3.6"
+exifinterface = "1.4.1"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }

branding/.gitignore

@@ -0,0 +1,3 @@
+*.tmp
+.DS_Store
+*.log

branding/generate.py

@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Callable, TypedDict
+from PIL import Image, ImageDraw
+
+
+class Polygon(TypedDict):
+    coords: list[tuple[float, float]]
+    fill: str
+
+
+SCRIPT_DIR = Path(__file__).parent
+PROJECT_ROOT = SCRIPT_DIR.parent
+SOURCE_DIR = SCRIPT_DIR / "source"
+LOGOS_DIR = SCRIPT_DIR / "logos"
+
+
+def parse_svg_polygons(svg_path: Path) -> list[Polygon]:
+    tree = ET.parse(svg_path)
+    root = tree.getroot()
+
+    ns = {"svg": "http://www.w3.org/2000/svg"}
+    polygons = root.findall(".//svg:polygon", ns)
+    if not polygons:
+        polygons = root.findall(".//polygon")
+
+    result: list[Polygon] = []
+    for poly in polygons:
+        points_str = poly.get("points", "").strip()
+        fill = poly.get("fill", "#000000")
+
+        coords: list[tuple[float, float]] = []
+        for pair in points_str.split():
+            x, y = pair.split(",")
+            coords.append((float(x), float(y)))
+
+        result.append({"coords": coords, "fill": fill})
+
+    return result
+
+
+def get_bbox(polygons: list[Polygon]) -> dict[str, float]:
+    all_coords: list[tuple[float, float]] = []
+    for poly in polygons:
+        all_coords.extend(poly["coords"])
+
+    xs = [c[0] for c in all_coords]
+    ys = [c[1] for c in all_coords]
+
+    return {
+        "min_x": min(xs),
+        "max_x": max(xs),
+        "min_y": min(ys),
+        "max_y": max(ys),
+        "width": max(xs) - min(xs),
+        "height": max(ys) - min(ys),
+    }
+
+
+def scale_and_center(
+    polygons: list[Polygon], viewbox_size: float, target_width: float
+) -> list[Polygon]:
+    bbox = get_bbox(polygons)
+
+    scale = target_width / bbox["width"]
+    center = viewbox_size / 2
+
+    scaled_polys: list[Polygon] = []
+    for poly in polygons:
+        scaled_coords = [(x * scale, y * scale) for x, y in poly["coords"]]
+        scaled_polys.append({"coords": scaled_coords, "fill": poly["fill"]})
+
+    scaled_bbox = get_bbox(scaled_polys)
+    current_center_x = (scaled_bbox["min_x"] + scaled_bbox["max_x"]) / 2
+    current_center_y = (scaled_bbox["min_y"] + scaled_bbox["max_y"]) / 2
+
+    offset_x = center - current_center_x
+    offset_y = center - current_center_y
+
+    final_polys: list[Polygon] = []
+    for poly in scaled_polys:
+        final_coords = [(x + offset_x, y + offset_y) for x, y in poly["coords"]]
+        final_polys.append({"coords": final_coords, "fill": poly["fill"]})
+
+    return final_polys
+
+
+def format_svg_points(coords: list[tuple[float, float]]) -> str:
+    return " ".join(f"{x:.3f},{y:.3f}" for x, y in coords)
+
+
+def format_android_path(coords: list[tuple[float, float]]) -> str:
+    points = " ".join(f"{x:.3f},{y:.3f}" for x, y in coords)
+    pairs = points.split()
+    return f"M{pairs[0]} L{pairs[1]} L{pairs[2]} Z"
+
+
+def generate_svg(polygons: list[Polygon], width: int, height: int) -> str:
+    lines = [
+        f'<svg width="{width}" height="{height}" viewBox="0 0 {width} {height}" xmlns="http://www.w3.org/2000/svg">'
+    ]
+    for poly in polygons:
+        points = format_svg_points(poly["coords"])
+        lines.append(f'  <polygon points="{points}" fill="{poly["fill"]}"/>')
+    lines.append("</svg>")
+    return "\n".join(lines)
+
+
+def generate_android_vector(
+    polygons: list[Polygon], width: int, height: int, viewbox: int
+) -> str:
+    lines = [
+        '<?xml version="1.0" encoding="utf-8"?>',
+        '<vector xmlns:android="http://schemas.android.com/apk/res/android"',
+        f'    android:width="{width}dp"',
+        f'    android:height="{height}dp"',
+        f'    android:viewportWidth="{viewbox}"',
+        f'    android:viewportHeight="{viewbox}">',
+    ]
+    for poly in polygons:
+        path = format_android_path(poly["coords"])
+        lines.append(
+            f'    <path android:fillColor="{poly["fill"]}" android:pathData="{path}" />'
+        )
+    lines.append("</vector>")
+    return "\n".join(lines)
+
+
+def rasterize_svg(
+    svg_path: Path,
+    output_path: Path,
+    size: int,
+    bg_color: tuple[int, int, int, int] | None = None,
+    circular: bool = False,
+) -> None:
+    from xml.dom import minidom
+
+    doc = minidom.parse(str(svg_path))
+
+    img = Image.new(
+        "RGBA", (size, size), (255, 255, 255, 0) if bg_color is None else bg_color
+    )
+    draw = ImageDraw.Draw(img)
+
+    svg_elem = doc.getElementsByTagName("svg")[0]
+    viewbox = svg_elem.getAttribute("viewBox").split()
+    if viewbox:
+        vb_width = float(viewbox[2])
+        vb_height = float(viewbox[3])
+        scale_x = size / vb_width
+        scale_y = size / vb_height
+    else:
+        scale_x = scale_y = 1
+
+    def parse_transform(
+        transform_str: str,
+    ) -> Callable[[float, float], tuple[float, float]]:
+        import re
+
+        if not transform_str:
+            return lambda x, y: (x, y)
+
+        transforms: list[tuple[str, list[float]]] = []
+        for match in re.finditer(r"(\w+)\(([^)]+)\)", transform_str):
+            func, args_str = match.groups()
+            args = [float(x) for x in args_str.replace(",", " ").split()]
+            transforms.append((func, args))
+
+        def apply_transforms(x: float, y: float) -> tuple[float, float]:
+            for func, args in transforms:
+                if func == "translate":
+                    x += args[0]
+                    y += args[1] if len(args) > 1 else args[0]
+                elif func == "scale":
+                    x *= args[0]
+                    y *= args[1] if len(args) > 1 else args[0]
+            return x, y
+
+        return apply_transforms
+
+    for g in doc.getElementsByTagName("g"):
+        transform = parse_transform(g.getAttribute("transform"))
+
+        for poly in g.getElementsByTagName("polygon"):
+            points_str = poly.getAttribute("points").strip()
+            fill = poly.getAttribute("fill")
+            if not fill:
+                fill = "#000000"
+
+            coords: list[tuple[float, float]] = []
+            for pair in points_str.split():
+                x, y = pair.split(",")
+                x, y = float(x), float(y)
+                x, y = transform(x, y)
+                coords.append((x * scale_x, y * scale_y))
+
+            draw.polygon(coords, fill=fill)
+
+    for poly in doc.getElementsByTagName("polygon"):
+        if poly.parentNode and getattr(poly.parentNode, "tagName", None) == "g":
+            continue
+
+        points_str = poly.getAttribute("points").strip()
+        fill = poly.getAttribute("fill")
+        if not fill:
+            fill = "#000000"
+
+        coords = []
+        for pair in points_str.split():
+            x, y = pair.split(",")
+            coords.append((float(x) * scale_x, float(y) * scale_y))
+
+        draw.polygon(coords, fill=fill)
+
+    if circular:
+        mask = Image.new("L", (size, size), 0)
+        mask_draw = ImageDraw.Draw(mask)
+        mask_draw.ellipse((0, 0, size, size), fill=255)
+        img.putalpha(mask)
+
+    img.save(output_path)
+
+
+def main() -> None:
+    print("Generating branding assets...")
+
+    logo_svg = SOURCE_DIR / "logo.svg"
+    icon_light = SOURCE_DIR / "icon-light.svg"
+    icon_dark = SOURCE_DIR / "icon-dark.svg"
+    icon_tinted = SOURCE_DIR / "icon-tinted.svg"
+
+    polygons = parse_svg_polygons(logo_svg)
+
+    print("  iOS...")
+    ios_assets = PROJECT_ROOT / "ios/Ascently/Assets.xcassets/AppIcon.appiconset"
+
+    for src, dst in [
+        (icon_light, ios_assets / "app_icon_light_template.svg"),
+        (icon_dark, ios_assets / "app_icon_dark_template.svg"),
+        (icon_tinted, ios_assets / "app_icon_tinted_template.svg"),
+    ]:
+        with open(src) as f:
+            content = f.read()
+        with open(dst, "w") as f:
+            f.write(content)
+
+    img_light = Image.new("RGB", (1024, 1024), (255, 255, 255))
+    draw_light = ImageDraw.Draw(img_light)
+    scaled = scale_and_center(polygons, 1024, int(1024 * 0.7))
+    for poly in scaled:
+        coords = [(x, y) for x, y in poly["coords"]]
+        draw_light.polygon(coords, fill=poly["fill"])
+    img_light.save(ios_assets / "app_icon_1024.png")
+
+    img_dark = Image.new("RGB", (1024, 1024), (26, 26, 26))
+    draw_dark = ImageDraw.Draw(img_dark)
+    for poly in scaled:
+        coords = [(x, y) for x, y in poly["coords"]]
+        draw_dark.polygon(coords, fill=poly["fill"])
+    img_dark.save(ios_assets / "app_icon_1024_dark.png")
+
+    img_tinted = Image.new("RGB", (1024, 1024), (0, 0, 0))
+    draw_tinted = ImageDraw.Draw(img_tinted)
+    for i, poly in enumerate(scaled):
+        coords = [(x, y) for x, y in poly["coords"]]
+        draw_tinted.polygon(coords, fill=(0, 0, 0))
+    img_tinted.save(ios_assets / "app_icon_1024_tinted.png")
+
+    print("  Android...")
+
+    polys_108 = scale_and_center(polygons, 108, 60)
+    android_xml = generate_android_vector(polys_108, 108, 108, 108)
+    (
+        PROJECT_ROOT / "android/app/src/main/res/drawable/ic_launcher_foreground.xml"
+    ).write_text(android_xml)
+
+    polys_24 = scale_and_center(polygons, 24, 20)
+    mountains_xml = generate_android_vector(polys_24, 24, 24, 24)
+    (PROJECT_ROOT / "android/app/src/main/res/drawable/ic_mountains.xml").write_text(
+        mountains_xml
+    )
+
+    for density, size in [
+        ("mdpi", 48),
+        ("hdpi", 72),
+        ("xhdpi", 96),
+        ("xxhdpi", 144),
+        ("xxxhdpi", 192),
+    ]:
+        mipmap_dir = PROJECT_ROOT / f"android/app/src/main/res/mipmap-{density}"
+
+        img = Image.new("RGBA", (size, size), (255, 255, 255, 255))
+        draw = ImageDraw.Draw(img)
+
+        scaled = scale_and_center(polygons, size, int(size * 0.6))
+        for poly in scaled:
+            coords = [(x, y) for x, y in poly["coords"]]
+            draw.polygon(coords, fill=poly["fill"])
+
+        img.save(mipmap_dir / "ic_launcher.webp")
+
+        img_round = Image.new("RGBA", (size, size), (255, 255, 255, 255))
+        draw_round = ImageDraw.Draw(img_round)
+
+        for poly in scaled:
+            coords = [(x, y) for x, y in poly["coords"]]
+            draw_round.polygon(coords, fill=poly["fill"])
+
+        mask = Image.new("L", (size, size), 0)
+        mask_draw = ImageDraw.Draw(mask)
+        mask_draw.ellipse((0, 0, size, size), fill=255)
+        img_round.putalpha(mask)
+
+        img_round.save(mipmap_dir / "ic_launcher_round.webp")
+
+    print("  Docs...")
+
+    polys_32 = scale_and_center(polygons, 32, 26)
+    logo_svg_32 = generate_svg(polys_32, 32, 32)
+    (PROJECT_ROOT / "docs/src/assets/logo.svg").write_text(logo_svg_32)
+    (PROJECT_ROOT / "docs/src/assets/logo-dark.svg").write_text(logo_svg_32)
+
+    polys_256 = scale_and_center(polygons, 256, 208)
+    logo_svg_256 = generate_svg(polys_256, 256, 256)
+    (PROJECT_ROOT / "docs/src/assets/logo-highres.svg").write_text(logo_svg_256)
+
+    logo_32_path = PROJECT_ROOT / "docs/src/assets/logo.svg"
+    rasterize_svg(logo_32_path, PROJECT_ROOT / "docs/public/favicon.png", 32)
+
+    sizes = [16, 32, 48]
+    imgs = []
+    for size in sizes:
+        img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
+        draw = ImageDraw.Draw(img)
+
+        scaled = scale_and_center(polygons, size, int(size * 0.8))
+        for poly in scaled:
+            coords = [(x, y) for x, y in poly["coords"]]
+            draw.polygon(coords, fill=poly["fill"])
+
+        imgs.append(img)
+
+    imgs[0].save(
+        PROJECT_ROOT / "docs/public/favicon.ico",
+        format="ICO",
+        sizes=[(s, s) for s in sizes],
+        append_images=imgs[1:],
+    )
+
+    print("  Logos...")
+
+    LOGOS_DIR.mkdir(exist_ok=True)
+
+    sizes = [64, 128, 256, 512, 1024, 2048]
+    for size in sizes:
+        img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
+        draw = ImageDraw.Draw(img)
+
+        scaled = scale_and_center(polygons, size, int(size * 0.8))
+        for poly in scaled:
+            coords = [(x, y) for x, y in poly["coords"]]
+            draw.polygon(coords, fill=poly["fill"])
+
+        img.save(LOGOS_DIR / f"logo-{size}.png")
+
+    for size in sizes:
+        img = Image.new("RGBA", (size, size), (255, 255, 255, 255))
+        draw = ImageDraw.Draw(img)
+
+        scaled = scale_and_center(polygons, size, int(size * 0.8))
+        for poly in scaled:
+            coords = [(x, y) for x, y in poly["coords"]]
+            draw.polygon(coords, fill=poly["fill"])
+
+        img.save(LOGOS_DIR / f"logo-{size}-white.png")
+
+    for size in sizes:
+        img = Image.new("RGBA", (size, size), (26, 26, 26, 255))
+        draw = ImageDraw.Draw(img)
+
+        scaled = scale_and_center(polygons, size, int(size * 0.8))
+        for poly in scaled:
+            coords = [(x, y) for x, y in poly["coords"]]
+            draw.polygon(coords, fill=poly["fill"])
+
+        img.save(LOGOS_DIR / f"logo-{size}-dark.png")
+
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

branding/generate.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+if ! command -v python3 &> /dev/null; then
+    echo "Error: Python 3 required"
+    exit 1
+fi
+
+python3 "$SCRIPT_DIR/generate.py"

branding/source/icon-dark.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="1024" height="1024" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+  <rect width="1024" height="1024" fill="#1A1A1A" rx="180" ry="180"/>
+  <g transform="translate(512, 512) scale(4.75) translate(-54, -42.5)">
+    <polygon points="8,75 35,14.25 62,75" fill="#FFC107"/>
+    <polygon points="31.25,75 65,0.75 98.75,75" fill="#F44336"/>
+  </g>
+</svg>

branding/source/icon-light.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="1024" height="1024" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+  <rect width="1024" height="1024" fill="#FFFFFF" rx="180" ry="180"/>
+  <g transform="translate(512, 512) scale(4.75) translate(-54, -42.5)">
+    <polygon points="8,75 35,14.25 62,75" fill="#FFC107"/>
+    <polygon points="31.25,75 65,0.75 98.75,75" fill="#F44336"/>
+  </g>
+</svg>

branding/source/icon-tinted.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="1024" height="1024" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+  <rect width="1024" height="1024" fill="transparent" rx="180" ry="180"/>
+  <g transform="translate(512, 512) scale(4.75) translate(-54, -42.5)">
+    <polygon points="8,75 35,14.25 62,75" fill="#000000" opacity="0.8"/>
+    <polygon points="31.25,75 65,0.75 98.75,75" fill="#000000" opacity="0.9"/>
+  </g>
+</svg>

branding/source/logo.svg

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="108" height="108" viewBox="0 0 108 108" xmlns="http://www.w3.org/2000/svg">
+  <polygon points="8,75 35,14.25 62,75" fill="#FFC107"/>
+  <polygon points="31.25,75 65,0.75 98.75,75" fill="#F44336"/>
+</svg>

docs/astro.config.mjs

@@ -40,12 +40,9 @@ export default defineConfig({
           items: [
             { label: "Overview", slug: "sync/overview" },
             { label: "Quick Start", slug: "sync/quick-start" },
+            { label: "API Reference", slug: "sync/api-reference" },
           ],
         },
-        {
-          label: "Reference",
-          autogenerate: { directory: "reference" },
-        },
         {
           label: "Privacy",
           link: "/privacy/",

docs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ascently-docs",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Documentation site for Ascently - FOSS climbing tracking app",
   "repository": {
     "type": "git",
@@ -25,9 +25,13 @@
     "astro": "astro"
   },
   "dependencies": {
-    "@astrojs/node": "^9.5.0",
-    "@astrojs/starlight": "^0.36.0",
-    "astro": "^5.14.5",
-    "sharp": "^0.34.4"
+    "@astrojs/node": "^9.5.1",
+    "@astrojs/starlight": "^0.37.0",
+    "astro": "^5.16.3",
+    "qrcode": "^1.5.4",
+    "sharp": "^0.34.5"
+  },
+  "devDependencies": {
+    "@types/qrcode": "^1.5.6"
   }
 }

docs/pnpm-workspace.yaml

@@ -1,3 +0,0 @@
-onlyBuiltDependencies:
-  - esbuild
-  - sharp

docs/src/assets/logo-dark.svg

@@ -1,15 +1,4 @@
 <svg width="32" height="32" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
-  <!-- Left mountain (amber/yellow) -->
-  <polygon points="6,24 12,8 18,24"
-           fill="#FFC107"
-           stroke="#FFFFFF"
-           stroke-width="1"
-           stroke-linejoin="round"/>
-
-  <!-- Right mountain (red) -->
-  <polygon points="14,24 22,4 30,24"
-           fill="#F44336"
-           stroke="#FFFFFF"
-           stroke-width="1"
-           stroke-linejoin="round"/>
-</svg>
+  <polygon points="3.000,26.636 10.736,9.231 18.471,26.636" fill="#FFC107"/>
+  <polygon points="9.661,26.636 19.331,5.364 29.000,26.636" fill="#F44336"/>
+</svg>

docs/src/assets/logo-highres.svg

@@ -1,15 +1,4 @@
 <svg width="256" height="256" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg">
-  <!-- Left mountain (amber/yellow) -->
-  <polygon points="48,192 96,64 144,192"
-           fill="#FFC107"
-           stroke="#1C1C1C"
-           stroke-width="4"
-           stroke-linejoin="round"/>
-
-  <!-- Right mountain (red) -->
-  <polygon points="112,192 176,32 240,192"
-           fill="#F44336"
-           stroke="#1C1C1C"
-           stroke-width="4"
-           stroke-linejoin="round"/>
-</svg>
+  <polygon points="24.000,213.091 85.884,73.851 147.769,213.091" fill="#FFC107"/>
+  <polygon points="77.289,213.091 154.645,42.909 232.000,213.091" fill="#F44336"/>
+</svg>

docs/src/assets/logo.svg

@@ -1,15 +1,4 @@
 <svg width="32" height="32" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
-  <!-- Left mountain (amber/yellow) -->
-  <polygon points="6,24 12,8 18,24"
-           fill="#FFC107"
-           stroke="#1C1C1C"
-           stroke-width="1"
-           stroke-linejoin="round"/>
-
-  <!-- Right mountain (red) -->
-  <polygon points="14,24 22,4 30,24"
-           fill="#F44336"
-           stroke="#1C1C1C"
-           stroke-width="1"
-           stroke-linejoin="round"/>
-</svg>
+  <polygon points="3.000,26.636 10.736,9.231 18.471,26.636" fill="#FFC107"/>
+  <polygon points="9.661,26.636 19.331,5.364 29.000,26.636" fill="#F44336"/>
+</svg>

docs/src/components/DownloadButtons.astro

@@ -0,0 +1,155 @@
+---
+import { Tabs, TabItem } from "@astrojs/starlight/components";
+import { Card, CardGrid } from "@astrojs/starlight/components";
+import { LinkButton } from "@astrojs/starlight/components";
+import { Badge } from "@astrojs/starlight/components";
+import QRCode from "./QRCode.astro";
+import { downloadLinks, requirements } from "../config";
+
+interface Props {
+    showQR?: boolean;
+}
+
+const { showQR = false } = Astro.props;
+
+const hasLink = (link: string | undefined) => link && link.trim() !== "";
+---
+
+<Tabs syncKey="platform">
+    <TabItem label="Android" icon="star">
+        <CardGrid>
+            {
+                hasLink(downloadLinks.android.playStore) && (
+                    <Card title="Google Play Store" icon="star">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.android.playStore}
+                                variant="primary"
+                                icon="external"
+                            >
+                                Get on Play Store
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.android.playStore}
+                                    size={200}
+                                    alt="QR code for Play Store"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+
+            {
+                hasLink(downloadLinks.android.obtainium) && (
+                    <Card title="Obtainium" icon="rocket">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.android.obtainium}
+                                variant="primary"
+                                icon="external"
+                            >
+                                Get on Obtainium
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.android.obtainium}
+                                    size={200}
+                                    alt="QR code for Obtainium"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+
+            {
+                hasLink(downloadLinks.android.releases) && (
+                    <Card title="Direct Download" icon="download">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.android.releases}
+                                variant="secondary"
+                                icon="external"
+                            >
+                                Download APK
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.android.releases}
+                                    size={200}
+                                    alt="QR code for APK download"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+        </CardGrid>
+
+        <p><strong>Requirements:</strong> {requirements.android}</p>
+    </TabItem>
+
+    <TabItem label="iOS" icon="apple">
+        <CardGrid>
+            {
+                hasLink(downloadLinks.ios.appStore) && (
+                    <Card title="App Store" icon="rocket">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.ios.appStore}
+                                variant="primary"
+                                icon="external"
+                            >
+                                Download on App Store
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.ios.appStore}
+                                    size={200}
+                                    alt="QR code for App Store"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+
+            {
+                hasLink(downloadLinks.ios.testFlight) && (
+                    <Card title="TestFlight Beta" icon="warning">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.ios.testFlight}
+                                variant="secondary"
+                                icon="external"
+                            >
+                                Join TestFlight
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.ios.testFlight}
+                                    size={200}
+                                    alt="QR code for TestFlight"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+        </CardGrid>
+
+        <p><strong>Requirements:</strong> {requirements.ios}</p>
+    </TabItem>
+</Tabs>

docs/src/components/QRCode.astro

@@ -0,0 +1,111 @@
+---
+import * as QR from "qrcode";
+
+interface Props {
+    data: string;
+    size?: number;
+    alt?: string;
+}
+
+const { data, size = 200, alt = "QR Code" } = Astro.props;
+
+// Generate QR code for dark mode
+let darkModeQR = "";
+try {
+    darkModeQR = await QR.toDataURL(data, {
+        width: size,
+        margin: 2,
+        color: {
+            dark: "#FFBF00",
+            light: "#17181C",
+        },
+    });
+} catch (err) {
+    console.error("Failed to generate dark mode QR code:", err);
+}
+
+// Generate QR code for light mode
+let lightModeQR = "";
+try {
+    lightModeQR = await QR.toDataURL(data, {
+        width: size,
+        margin: 2,
+        color: {
+            dark: "#F24B3C",
+            light: "#FFFFFF",
+        },
+    });
+} catch (err) {
+    console.error("Failed to generate light mode QR code:", err);
+}
+
+const uniqueId = `qr-${Math.random().toString(36).substr(2, 9)}`;
+---
+
+{
+    (darkModeQR || lightModeQR) && (
+        <img
+            id={uniqueId}
+            alt={alt}
+            width={size}
+            height={size}
+            data-light-src={lightModeQR}
+            data-dark-src={darkModeQR}
+            style="margin: auto;"
+        />
+    )
+}
+
+<script is:inline define:vars={{ uniqueId, lightModeQR, darkModeQR }}>
+    (function () {
+        const img = document.getElementById(uniqueId);
+        if (!img) return;
+
+        const theme = document.documentElement.getAttribute("data-theme");
+        if (theme === "dark" && darkModeQR) {
+            img.setAttribute("src", darkModeQR);
+        } else if (lightModeQR) {
+            img.setAttribute("src", lightModeQR);
+        }
+    })();
+</script>
+
+<script>
+    function updateQRCodes() {
+        const theme = document.documentElement.getAttribute("data-theme");
+        const qrImages = document.querySelectorAll(
+            "img[data-light-src][data-dark-src]",
+        );
+
+        qrImages.forEach((img) => {
+            const lightSrc = img.getAttribute("data-light-src");
+            const darkSrc = img.getAttribute("data-dark-src");
+
+            if (theme === "dark" && darkSrc) {
+                img.setAttribute("src", darkSrc);
+            } else if (lightSrc) {
+                img.setAttribute("src", lightSrc);
+            }
+        });
+    }
+
+    // Set initial theme on page load
+    updateQRCodes();
+
+    // Watch for theme changes
+    const observer = new MutationObserver((mutations) => {
+        mutations.forEach((mutation) => {
+            if (
+                mutation.type === "attributes" &&
+                mutation.attributeName === "data-theme"
+            ) {
+                updateQRCodes();
+            }
+        });
+    });
+
+    observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ["data-theme"],
+    });
+</script>

docs/src/config.ts

@@ -0,0 +1,17 @@
+export const requirements = {
+  android: "Android 12+",
+  ios: "iOS 17+",
+} as const;
+
+export const downloadLinks = {
+  android: {
+    releases: "https://git.atri.dad/atridad/Ascently/tags?q=Android",
+    obtainium:
+      "https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://git.atri.dad/atridad/Ascently/releases",
+    playStore: "",
+  },
+  ios: {
+    appStore: "https://apps.apple.com/ca/app/ascently/id6753959144",
+    testFlight: "https://testflight.apple.com/join/E2DYRGH8",
+  },
+} as const;

docs/src/content/docs/download.md

@@ -1,26 +0,0 @@
----
-title: Download
-description: Get Ascently on your Android or iOS device
----
-
-## Android
-
-### Option 1: Direct APK Download
-Download the latest APK from the [Releases page](https://git.atri.dad/atridad/Ascently/releases).
-
-### Option 2: Obtainium
-Use Obtainium for automatic updates:
-
-[<img src="https://github.com/ImranR98/Obtainium/blob/main/assets/graphics/badge_obtainium.png?raw=true" alt="Obtainium" height="41">](https://apps.obtainium.imranr.dev/redirect?r=obtainium://app/%7B%22id%22%3A%22com.atridad.ascently%22%2C%22url%22%3A%22https%3A%2F%2Fgit.atri.dad%2Fatridad%2FAscently%2Freleases%22%2C%22author%22%3A%22git.atri.dad%22%2C%22name%22%3A%22Ascently%22%2C%22preferredApkIndex%22%3A0%2C%22additionalSettings%22%3A%22%7B%5C%22intermediateLink%5C%22%3A%5B%5D%2C%5C%22customLinkFilterRegex%5C%22%3A%5C%22%5C%22%2C%5C%22filterByLinkText%5C%22%3Afalse%2C%5C%22skipSort%5C%22%3Afalse%2C%5C%22reverseSort%5C%22%3Afalse%2C%5C%22sortByLastLinkSegment%5C%22%3Afalse%2C%5C%22versionExtractWholePage%5C%22%3Afalse%2C%5C%22requestHeader%5C%22%3A%5B%7B%5C%22requestHeader%5C%22%3A%5C%22User-Agent%3A%20Mozilla%2F5.0%20(Linux%3B%20Android%2010%3B%20K)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F114.0.0.0%20Mobile%20Safari%2F537.36%5C%22%7D%5D%2C%5C%22defaultPseudoVersioningMethod%5C%22%3A%5C%22partialAPKHash%5C%22%2C%5C%22trackOnly%5C%22%3Afalse%2C%5C%22versionExtractionRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22matchGroupToUse%5C%22%3A%5C%22%5C%22%2C%5C%22versionDetection%5C%22%3Afalse%2C%5C%22useVersionCodeAsOSVersion%5C%22%3Afalse%2C%5C%22apkFilterRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22invertAPKFilter%5C%22%3Afalse%2C%5C%22autoApkFilterByArch%5C%22%3Atrue%2C%5C%22appName%5C%22%3A%5C%22Ascently%5C%22%2C%5C%22appAuthor%5C%22%3A%5C%22%5C%22%2C%5C%22shizukuPretendToBeGooglePlay%5C%22%3Afalse%2C%5C%22allowInsecure%5C%22%3Afalse%2C%5C%22exemptFromBackgroundUpdates%5C%22%3Afalse%2C%5C%22skipUpdateNotifications%5C%22%3Afalse%2C%5C%22about%5C%22%3A%5C%22%5C%22%2C%5C%22refreshBeforeDownload%5C%22%3Afalse%7D%22%2C%22overrideSource%22%3Anull%7D)
-
-## iOS
-
-### TestFlight Beta
-Join the TestFlight beta: [https://testflight.apple.com/join/E2DYRGH8](https://testflight.apple.com/join/E2DYRGH8)
-
-### App Store
-App Store release coming soon.
-
-## Requirements
-
-- **Android 12+** or **iOS 17+**

docs/src/content/docs/download.mdx

@@ -0,0 +1,10 @@
+---
+title: Download
+description: Get Ascently on your Android or iOS device
+---
+
+import DownloadButtons from '../../components/DownloadButtons.astro';
+
+Get Ascently on your device and start tracking your climbs today!
+
+<DownloadButtons showQR={true} />

docs/src/content/docs/index.mdx

@@ -40,21 +40,6 @@ Ascently is an **offline-first FOSS** app designed to help climbers track their
 	</Card>
 </CardGrid>
 
-## Requirements
-
-- **Android:** Version 12+
-- **iOS:** Version 17+
-
-## Download
-
-**Android:**
-- Download the latest APK from the [Releases page](https://git.atri.dad/atridad/Ascently/releases)
-- Use [Obtainium](https://apps.obtainium.imranr.dev/redirect?r=obtainium://app/%7B%22id%22%3A%22com.atridad.ascently%22%2C%22url%22%3A%22https%3A%2F%2Fgit.atri.dad%2Fatridad%2FAscently%2Freleases%22%2C%22author%22%3A%22git.atri.dad%22%2C%22name%22%3A%22Ascently%22%2C%22preferredApkIndex%22%3A0%2C%22additionalSettings%22%3A%22%7B%5C%22intermediateLink%5C%22%3A%5B%5D%2C%5C%22customLinkFilterRegex%5C%22%3A%5C%22%5C%22%2C%5C%22filterByLinkText%5C%22%3Afalse%2C%5C%22skipSort%5C%22%3Afalse%2C%5C%22reverseSort%5C%22%3Afalse%2C%5C%22sortByLastLinkSegment%5C%22%3Afalse%2C%5C%22versionExtractWholePage%5C%22%3Afalse%2C%5C%22requestHeader%5C%22%3A%5B%7B%5C%22requestHeader%5C%22%3A%5C%22User-Agent%3A%20Mozilla%2F5.0%20(Linux%3B%20Android%2010%3B%20K)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F114.0.0.0%20Mobile%20Safari%2F537.36%5C%22%7D%5D%2C%5C%22defaultPseudoVersioningMethod%5C%22%3A%5C%22partialAPKHash%5C%22%2C%5C%22trackOnly%5C%22%3Afalse%2C%5C%22versionExtractionRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22matchGroupToUse%5C%22%3A%5C%22%5C%22%2C%5C%22versionDetection%5C%22%3Afalse%2C%5C%22useVersionCodeAsOSVersion%5C%22%3Afalse%2C%5C%22apkFilterRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22invertAPKFilter%5C%22%3Afalse%2C%5C%22autoApkFilterByArch%5C%22%3Atrue%2C%5C%22appName%5C%22%3A%5C%22Ascently%5C%22%2C%5C%22appAuthor%5C%22%3A%5C%22%5C%22%2C%5C%22shizukuPretendToBeGooglePlay%5C%22%3Afalse%2C%5C%22allowInsecure%5C%22%3Afalse%2C%5C%22exemptFromBackgroundUpdates%5C%22%3Afalse%2C%5C%22skipUpdateNotifications%5C%22%3Afalse%2C%5C%22about%5C%22%3A%5C%22%5C%22%2C%5C%22refreshBeforeDownload%5C%22%3Afalse%7D%22%2C%22overrideSource%22%3Anull%7D) for automatic updates
-
-**iOS:**
-- Join the [TestFlight Beta](https://testflight.apple.com/join/E2DYRGH8)
-- App Store release coming soon
-
 ---
 
 *Built with ❤️ by Atridad Lahiji*

docs/src/content/docs/privacy.md

@@ -5,7 +5,7 @@ description: Ascently's Privacy Policy
 
 **Last updated: September 29, 2025**
 
-This Privacy Policy describes our policies and procedures regarding the collection, use, and disclosure of your information when you use my software.
+This Privacy Policy describes my policies and procedures regarding the collection, use, and disclosure of your information when you use my software.
 
 ## No Data Collection
 
@@ -36,7 +36,7 @@ You may optionally integrate with Apple Health or Android Health Connect to impo
 
 This software does not use cookies, tracking pixels, or any other analytics or tracking mechanisms. Your usage of the software is completely private.
 
-## Contact Us
+## Contact
 
 If you have any questions about this Privacy Policy, you can contact me:
 

docs/src/content/docs/reference/example.md

@@ -1,51 +0,0 @@
----
-title: Sync Server API
-description: API endpoints for the Ascently sync server
----
-
-The sync server provides a minimal REST API for data synchronization.
-
-## Authentication
-
-All endpoints require an `Authorization: Bearer <your-auth-token>` header.
-
-## Endpoints
-
-### Data Sync
-
-**GET /sync**
-- Download `ascently.json` file
-- Returns: JSON data file or 404 if no data exists
-
-**POST /sync**
-- Upload `ascently.json` file
-- Body: JSON data
-- Returns: Success confirmation
-
-### Images
-
-**GET /images/{imageName}**
-- Download an image file
-- Returns: Image file or 404 if not found
-
-**POST /images/{imageName}**
-- Upload an image file
-- Body: Image data
-- Returns: Success confirmation
-
-## Example Usage
-
-```bash
-# Download data
-curl -H "Authorization: Bearer your-token" \
-     http://localhost:8080/sync
-
-# Upload data
-curl -X POST \
-     -H "Authorization: Bearer your-token" \
-     -H "Content-Type: application/json" \
-     -d @ascently.json \
-     http://localhost:8080/sync
-```
-
-See `main.go` in the sync directory for implementation details.

docs/src/content/docs/sync/api-reference.md

@@ -0,0 +1,152 @@
+---
+title: API Reference
+description: Complete API documentation for the Ascently sync server
+---
+
+Complete reference for all sync server endpoints.
+
+## Authentication
+
+All endpoints require a bearer token in the `Authorization` header:
+
+```
+Authorization: Bearer your-auth-token
+```
+
+Unauthorized requests return `401 Unauthorized`.
+
+## Endpoints
+
+### Health Check
+
+**`GET /health`**
+
+Check if the server is running.
+
+**Response:**
+```json
+{
+  "status": "ok",
+  "version": "2.0.0"
+}
+```
+
+### Full Sync - Download
+
+**`GET /sync`**
+
+Download the entire dataset from the server.
+
+**Response:**
+```json
+{
+  "exportedAt": "2024-01-15T10:30:00.000Z",
+  "version": "2.0",
+  "formatVersion": "2.0",
+  "gyms": [...],
+  "problems": [...],
+  "sessions": [...],
+  "attempts": [...],
+  "deletedItems": [...]
+}
+```
+
+Returns `200 OK` with the backup data, or `404 Not Found` if no data exists.
+
+### Full Sync - Upload
+
+**`POST /sync`**
+
+Upload your entire dataset to the server. This overwrites all server data.
+
+**Request Body:**
+```json
+{
+  "exportedAt": "2024-01-15T10:30:00.000Z",
+  "version": "2.0",
+  "formatVersion": "2.0",
+  "gyms": [...],
+  "problems": [...],
+  "sessions": [...],
+  "attempts": [...],
+  "deletedItems": [...]
+}
+```
+
+**Response:**
+```
+200 OK
+```
+
+### Delta Sync
+
+**`POST /sync/delta`**
+
+Sync only changed data since your last sync. Much faster than full sync.
+
+**Request Body:**
+```json
+{
+  "lastSyncTime": "2024-01-15T10:00:00.000Z",
+  "gyms": [...],
+  "problems": [...],
+  "sessions": [...],
+  "attempts": [...],
+  "deletedItems": [...]
+}
+```
+
+Include only items modified after `lastSyncTime`. The server merges your changes with its data using last-write-wins based on `updatedAt` timestamps.
+
+**Response:**
+```json
+{
+  "serverTime": "2024-01-15T10:30:00.000Z",
+  "gyms": [...],
+  "problems": [...],
+  "sessions": [...],
+  "attempts": [...],
+  "deletedItems": [...]
+}
+```
+
+Returns only server items modified after your `lastSyncTime`. Save `serverTime` as your new `lastSyncTime` for the next delta sync.
+
+### Image Upload
+
+**`POST /images/upload?filename={name}`**
+
+Upload an image file.
+
+**Query Parameters:**
+- `filename`: Image filename (e.g., `problem_abc123_0.jpg`)
+
+**Request Body:**
+Binary image data (JPEG, PNG, GIF, or WebP)
+
+**Response:**
+```
+200 OK
+```
+
+### Image Download
+
+**`GET /images/download?filename={name}`**
+
+Download an image file.
+
+**Query Parameters:**
+- `filename`: Image filename
+
+**Response:**
+Binary image data with appropriate `Content-Type` header.
+
+Returns `404 Not Found` if the image doesn't exist.
+
+## Notes
+
+- All timestamps are ISO 8601 format with milliseconds
+- Active sessions (status `active`) are excluded from sync
+- Images are stored separately and referenced by filename
+- The server stores everything in a single `ascently.json` file
+- No versioning or history - last write wins

docs/src/content/docs/sync/overview.md

@@ -3,28 +3,49 @@ title: Self-Hosted Sync Overview
 description: Learn about Ascently's optional sync server for cross-device data synchronization
 ---
 
-You can run your own sync server to keep your data in sync across devices. The server is lightweight and easy to set up using Docker.
+Run your own sync server to keep your data in sync across devices. The server is lightweight and easy to set up with Docker.
 
 ## How It Works
 
-This server uses a single `ascently.json` file for your data and a directory for images. The last client to upload wins, overwriting the old data. Authentication is just a static bearer token.
+The server stores your data in a single `ascently.json` file and images in a directory. It's simple: last write wins. Authentication is a static bearer token you set.
 
-## API
+## Features
 
-All endpoints require an `Authorization: Bearer <your-auth-token>` header.
+- **Delta sync**: Only syncs changed data
+- **Image sync**: Automatically syncs problem images
+- **Conflict resolution**: Last-write-wins based on timestamps
+- **Cross-platform**: Works with iOS and Android clients
+- **Privacy**: Your data, your server, no analytics
 
-- `GET /sync`: Download `ascently.json`
-- `POST /sync`: Upload `ascently.json`
-- `GET /images/{imageName}`: Download an image
-- `POST /images/{imageName}`: Upload an image
+## API Endpoints
+
+- `GET /health` - Health check
+- `GET /sync` - Download full dataset
+- `POST /sync` - Upload full dataset
+- `POST /sync/delta` - Sync only changes (recommended)
+- `POST /images/upload?filename={name}` - Upload image
+- `GET /images/download?filename={name}` - Download image
+
+All endpoints require `Authorization: Bearer <your-token>` header.
+
+See the [API Reference](/sync/api-reference/) for complete documentation.
 
 ## Getting Started
 
-The easiest way to get started is with the [Quick Start guide](/sync/quick-start/) using Docker Compose.
+Check out the [Quick Start guide](/sync/quick-start/) to get your server running with Docker Compose.
 
 You'll need:
 - Docker and Docker Compose
 - A secure authentication token
 - A place to store your data
 
-The server will be available at `http://localhost:8080` by default. Configure your clients with your server URL and auth token to start syncing.
+The server will be available at `http://localhost:8080` by default. Configure your Ascently apps with your server URL and auth token to start syncing.
+
+## How Sync Works
+
+1. **First sync**: Client uploads or downloads full dataset
+2. **Subsequent syncs**: Client uses delta sync to only transfer changed data
+3. **Conflicts**: Resolved automatically using timestamps (newer wins)
+4. **Images**: Synced automatically with problem data
+
+Active sessions are excluded from sync until completed.

docs/src/content/docs/sync/quick-start.md

@@ -3,7 +3,7 @@ title: Quick Start
 description: Get your Ascently sync server running with Docker Compose
 ---
 
-Get your Ascently sync server up and running using Docker Compose.
+Get your sync server running in minutes with Docker Compose.
 
 ## Prerequisites
 
@@ -12,50 +12,158 @@ Get your Ascently sync server up and running using Docker Compose.
 
 ## Setup
 
-1. Create a `.env` file with your configuration:
+1. Create a `docker-compose.yml` file:
 
-```env
-IMAGE=git.atri.dad/atridad/ascently-sync:latest
-APP_PORT=8080
-AUTH_TOKEN=your-super-secret-token
-DATA_FILE=/data/ascently.json
-IMAGES_DIR=/data/images
-ROOT_DIR=./ascently-data
+```yaml
+version: '3.8'
+
+services:
+  ascently-sync:
+    image: git.atri.dad/atridad/ascently-sync:latest
+    ports:
+      - "8080:8080"
+    environment:
+      - AUTH_TOKEN=${AUTH_TOKEN}
+      - DATA_FILE=/data/ascently.json
+      - IMAGES_DIR=/data/images
+    volumes:
+      - ./ascently-data:/data
+    restart: unless-stopped
 ```
 
-Set `AUTH_TOKEN` to a long, random string. `ROOT_DIR` is where the server will store its data on your machine.
+2. Create a `.env` file in the same directory:
 
-2. Use the provided `docker-compose.yml` in the `sync/` directory:
+```env
+AUTH_TOKEN=your-super-secret-token-here
+```
+
+Replace `your-super-secret-token-here` with a secure random token (see below).
+
+3. Start the server:
 
 ```bash
-cd sync/
 docker-compose up -d
 ```
 
 The server will be available at `http://localhost:8080`.
 
-## Configure Your Clients
+## Generate a Secure Token
 
-Configure your Ascently apps with:
-- **Server URL**: `http://your-server-ip:8080` (or your domain)
-- **Auth Token**: The token from your `.env` file
-
-Enable sync and perform your first sync to start synchronizing data across devices.
-
-## Generating a Secure Token
-
-Generate a secure authentication token:
+Use this command to generate a secure authentication token:
 
 ```bash
-# On Linux/macOS
 openssl rand -base64 32
 ```
 
-Keep this token secure and don't share it publicly.
+Copy the output and paste it into your `.env` file as the `AUTH_TOKEN`.
 
-## Accessing Remotely
+Keep this token secret and don't commit it to version control.
 
-For remote access, you'll need to:
-- Set up port forwarding on your router (port 8080)
-- Use your public IP address or set up a domain name
-- Consider using HTTPS with a reverse proxy for security
+## Configure Your Apps
+
+Open Ascently on your iOS or Android device:
+
+1. Go to **Settings**
+2. Scroll to **Sync Configuration**
+3. Enter your **Server URL**: `http://your-server-ip:8080`
+4. Enter your **Auth Token**: (the token from your `.env` file)
+5. Tap **Test Connection** to verify it works
+6. Enable **Auto Sync**
+7. Tap **Sync Now** to perform your first sync
+
+Repeat this on all your devices to keep them in sync.
+
+## Verify It's Working
+
+Check the server logs:
+
+```bash
+docker-compose logs -f ascently-sync
+```
+
+You should see logs like:
+
+```
+Delta sync from 192.168.1.100: lastSyncTime=2024-01-15T10:00:00.000Z, gyms=1, problems=5, sessions=2, attempts=10, deletedItems=0
+```
+
+## Remote Access
+
+To access your server remotely:
+
+### Option 1: Port Forwarding
+
+1. Forward port 8080 on your router to your server
+2. Find your public IP address
+3. Use `http://your-public-ip:8080` as the server URL
+
+### Option 2: Domain Name (Recommended)
+
+1. Get a domain name and point it to your server
+2. Set up a reverse proxy (nginx, Caddy, Traefik)
+3. Enable HTTPS with Let's Encrypt
+4. Use `https://sync.yourdomain.com` as the server URL
+
+Example nginx config with HTTPS:
+
+```nginx
+server {
+    listen 443 ssl http2;
+    server_name sync.yourdomain.com;
+
+    ssl_certificate /etc/letsencrypt/live/sync.yourdomain.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/sync.yourdomain.com/privkey.pem;
+
+    location / {
+        proxy_pass http://localhost:8080;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+## Updating
+
+Pull the latest image and restart:
+
+```bash
+docker-compose pull
+docker-compose up -d
+```
+
+Your data is stored in `./ascently-data` and persists across updates.
+
+## Troubleshooting
+
+### Connection Failed
+
+- Check the server is running: `docker-compose ps`
+- Verify the auth token matches on server and client
+- Check firewall settings and port forwarding
+- Test locally first with `http://localhost:8080`
+
+### Sync Errors
+
+- Check server logs: `docker-compose logs ascently-sync`
+- Verify your device has internet connection
+- Try disabling and re-enabling sync
+- Perform a manual sync from Settings
+
+### Data Location
+
+All data is stored in `./ascently-data/`:
+
+```
+ascently-data/
+├── ascently.json    # Your climb data
+└── images/          # Problem images
+```
+
+You can back this up or move it to another server.
+
+## Next Steps
+
+- Read the [API Reference](/sync/api-reference/) for advanced usage
+- Set up automated backups of your `ascently-data` directory
+- Configure HTTPS for secure remote access
+- Monitor server logs for sync activity

ios/Ascently.xcodeproj/LiveActivityManager.swift

@@ -25,7 +25,7 @@ final class LiveActivityManager {
                 pushType: nil
             )
         } catch {
-            print("Failed to start live activity: \(error)")
+            AppLogger.error("Failed to start live activity: \(error)", tag: "LegacyLiveActivityManager")
         }
     }
 

ios/Ascently.xcodeproj/project.pbxproj

@@ -465,7 +465,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 26;
+				CURRENT_PROJECT_VERSION = 36;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -487,7 +487,7 @@
 					"@executable_path/Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
-				MARKETING_VERSION = 2.0.0;
+				MARKETING_VERSION = 2.4.2;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -513,7 +513,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 26;
+				CURRENT_PROJECT_VERSION = 36;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -535,7 +535,7 @@
 					"@executable_path/Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
-				MARKETING_VERSION = 2.0.0;
+				MARKETING_VERSION = 2.4.2;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -602,7 +602,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 26;
+				CURRENT_PROJECT_VERSION = 36;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -613,7 +613,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 2.0.0;
+				MARKETING_VERSION = 2.4.2;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently.SessionStatusLive;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
@@ -632,7 +632,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 26;
+				CURRENT_PROJECT_VERSION = 36;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -643,7 +643,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 2.0.0;
+				MARKETING_VERSION = 2.4.2;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently.SessionStatusLive;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;

ios/Ascently/AppIntents/AscentlyShortcuts.swift

@@ -0,0 +1,24 @@
+import AppIntents
+
+/// Defines the App Shortcuts available in the Shortcuts app.
+struct AscentlyShortcuts: AppShortcutsProvider {
+
+    static var shortcutTileColor: ShortcutTileColor {
+        .teal
+    }
+
+    static var appShortcuts: [AppShortcut] {
+        return [
+            AppShortcut(
+                intent: ToggleSessionIntent(),
+                phrases: [
+                    "Toggle climb in \(.applicationName)",
+                    "Start or stop climb in \(.applicationName)",
+                    "Climb toggle in \(.applicationName)",
+                ],
+                shortTitle: "Toggle Session",
+                systemImageName: "figure.climbing"
+            )
+        ]
+    }
+}

ios/Ascently/AppIntents/SessionIntentSupport.swift

@@ -0,0 +1,111 @@
+import Foundation
+
+/// User-visible errors that can arise while handling session-related intents.
+enum SessionIntentError: LocalizedError {
+    case noRecentGym
+    case noActiveSession
+    case failedToStartSession
+    case failedToEndSession
+
+    var errorDescription: String? {
+        switch self {
+        case .noRecentGym:
+            return "There's no recent gym to start a session with."
+        case .noActiveSession:
+            return "There isn't an active session to end right now."
+        case .failedToStartSession:
+            return "Ascently couldn't start a new session."
+        case .failedToEndSession:
+            return "Ascently couldn't finish the active session."
+        }
+    }
+}
+
+struct SessionIntentSummary: Sendable {
+    let sessionId: UUID
+    let gymName: String
+    let status: SessionStatus
+}
+
+/// Controller for handling session operations from App Intents.
+@MainActor
+final class SessionIntentController {
+
+    private let dataManager: ClimbingDataManager
+
+    init(dataManager: ClimbingDataManager = .shared) {
+        self.dataManager = dataManager
+    }
+
+    /// Starts a new session using the most recently visited gym.
+    func startSessionWithLastUsedGym() async throws -> SessionIntentSummary {
+        // Wait for data to load
+        if dataManager.gyms.isEmpty {
+            try? await Task.sleep(nanoseconds: 500_000_000)
+        }
+
+        guard let lastGym = dataManager.getLastUsedGym() else {
+            logFailure(.noRecentGym, context: "No recorded sessions available")
+            throw SessionIntentError.noRecentGym
+        }
+
+        guard let startedSession = await dataManager.startSessionAsync(gymId: lastGym.id) else {
+            logFailure(.failedToStartSession, context: "Data manager failed to create new session")
+            throw SessionIntentError.failedToStartSession
+        }
+
+        return SessionIntentSummary(
+            sessionId: startedSession.id,
+            gymName: lastGym.name,
+            status: startedSession.status
+        )
+    }
+
+    /// Ends the currently active climbing session, if one exists.
+    func endActiveSession() async throws -> SessionIntentSummary {
+        guard let activeSession = dataManager.activeSession else {
+            logFailure(.noActiveSession, context: "No active session stored in data manager")
+            throw SessionIntentError.noActiveSession
+        }
+
+        guard let completedSession = await dataManager.endSessionAsync(activeSession.id) else {
+            logFailure(
+                .failedToEndSession, context: "Data manager failed to complete active session")
+            throw SessionIntentError.failedToEndSession
+        }
+
+        guard let gym = dataManager.gym(withId: completedSession.gymId) else {
+            logFailure(
+                .failedToEndSession,
+                context: "Gym missing for completed session \(completedSession.id)")
+            throw SessionIntentError.failedToEndSession
+        }
+
+        return SessionIntentSummary(
+            sessionId: completedSession.id,
+            gymName: gym.name,
+            status: completedSession.status
+        )
+    }
+
+    private func logFailure(_ error: SessionIntentError, context: String) {
+        // Log error for debugging
+        print("SessionIntentError: \(error). Context: \(context)")
+    }
+
+    /// Toggles the session state: ends active session if one exists, otherwise starts a new one.
+    func toggleSession() async throws -> (summary: SessionIntentSummary, wasStarted: Bool) {
+        // Wait for data to load
+        if dataManager.gyms.isEmpty {
+            try? await Task.sleep(nanoseconds: 500_000_000)
+        }
+
+        if dataManager.activeSession != nil {
+            let summary = try await endActiveSession()
+            return (summary, false)
+        } else {
+            let summary = try await startSessionWithLastUsedGym()
+            return (summary, true)
+        }
+    }
+}

ios/Ascently/AppIntents/ToggleSessionIntent.swift

@@ -0,0 +1,40 @@
+import AppIntents
+import Foundation
+
+/// Toggles the climbing session state: starts a session if none is active, or ends the current one.
+struct ToggleSessionIntent: AppIntent {
+
+    static var title: LocalizedStringResource {
+        "Toggle Climbing Session"
+    }
+
+    static var description: IntentDescription {
+        IntentDescription(
+            "Starts a new session at your last gym if you're not climbing, or ends your current session if you are."
+        )
+    }
+
+    static var openAppWhenRun: Bool {
+        false
+    }
+
+    func perform() async throws -> some IntentResult & ProvidesDialog {
+        // Wait for app initialization
+        try? await Task.sleep(nanoseconds: 1_000_000_000)
+
+        let controller = await SessionIntentController()
+        let (summary, wasStarted) = try await controller.toggleSession()
+
+        if wasStarted {
+            // Wait for Live Activity
+            try? await Task.sleep(nanoseconds: 500_000_000)
+            return .result(dialog: IntentDialog("Session started at \(summary.gymName). Have an awesome climb!"))
+        } else {
+            return .result(dialog: IntentDialog("Session at \(summary.gymName) ended. Nice work!"))
+        }
+    }
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("Toggle my climbing session")
+    }
+}

ios/Ascently/AscentlyApp.swift

@@ -1,10 +1,25 @@
 import SwiftUI
 
+class AppDelegate: NSObject, UIApplicationDelegate {
+    func application(
+        _ application: UIApplication,
+        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
+    ) -> Bool {
+        return true
+    }
+}
+
 @main
 struct AscentlyApp: App {
+    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+    @Environment(\.scenePhase) private var scenePhase
+    @StateObject private var themeManager = ThemeManager()
+
     var body: some Scene {
         WindowGroup {
             ContentView()
+                .environmentObject(themeManager)
+                .tint(themeManager.accentColor)
         }
     }
 }