1.1.1 - More fixes for notification reliabilityyyyy

app/build.gradle.kts

@@ -14,8 +14,8 @@ android {
         applicationId = "com.atridad.openclimb"
         minSdk = 33
         targetSdk = 36
-        versionCode = 15
+        versionCode = 16
-        versionName = "1.0.1"
+        versionName = "1.1.1"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/AndroidManifest.xml

@@ -12,7 +12,6 @@
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
     
     <application
         android:allowBackup="true"
@@ -52,7 +51,8 @@
             android:name=".service.SessionTrackingService"
             android:enabled="true"
             android:exported="false"
-            android:foregroundServiceType="specialUse">
+            android:foregroundServiceType="specialUse"
+            android:description="@string/session_tracking_service_description">
             <meta-data
                 android:name="android.app.foreground_service_type"
                 android:value="specialUse" />

app/src/main/java/com/atridad/openclimb/data/database/dao/AttemptDao.kt

@@ -53,6 +53,9 @@ interface AttemptDao {
     @Query("SELECT COUNT(*) FROM attempts")
     suspend fun getAttemptsCount(): Int
     
+    @Query("DELETE FROM attempts")
+    suspend fun deleteAllAttempts()
+    
     @Query("SELECT COUNT(*) FROM attempts WHERE sessionId = :sessionId")
     suspend fun getAttemptsCountBySession(sessionId: String): Int
     

app/src/main/java/com/atridad/openclimb/data/database/dao/ClimbSessionDao.kt

@@ -59,6 +59,9 @@ interface ClimbSessionDao {
     @Query("SELECT * FROM climb_sessions WHERE status = 'ACTIVE' ORDER BY date DESC LIMIT 1")
     suspend fun getActiveSession(): ClimbSession?
     
+    @Query("DELETE FROM climb_sessions")
+    suspend fun deleteAllSessions()
+    
     @Query("SELECT * FROM climb_sessions WHERE status = 'ACTIVE' ORDER BY date DESC LIMIT 1")
     fun getActiveSessionFlow(): Flow<ClimbSession?>
 }

app/src/main/java/com/atridad/openclimb/data/database/dao/GymDao.kt

@@ -37,4 +37,7 @@ interface GymDao {
     
     @Query("SELECT * FROM gyms WHERE name LIKE '%' || :searchQuery || '%' OR location LIKE '%' || :searchQuery || '%'")
     fun searchGyms(searchQuery: String): Flow<List<Gym>>
+    
+    @Query("DELETE FROM gyms")
+    suspend fun deleteAllGyms()
 }

app/src/main/java/com/atridad/openclimb/data/database/dao/ProblemDao.kt

@@ -59,4 +59,10 @@ interface ProblemDao {
         ORDER BY updatedAt DESC
     """)
     fun searchProblems(searchQuery: String): Flow<List<Problem>>
+    
+    @Query("SELECT COUNT(*) FROM problems")
+    suspend fun getProblemsCount(): Int
+    
+    @Query("DELETE FROM problems")
+    suspend fun deleteAllProblems()
 }

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

@@ -64,181 +64,148 @@ class ClimbRepository(
     
 
     
-    // JSON Export
+    // ZIP Export with images - Single format for reliability
-    suspend fun exportAllDataToJson(directory: File? = null): File {
-        val exportDir = directory ?: File(context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS), "OpenClimb")
-        if (!exportDir.exists()) {
-            exportDir.mkdirs()
-        }
-        
-        val timestamp = LocalDateTime.now().toString().replace(":", "-").replace(".", "-")
-        val exportFile = File(exportDir, "openclimb_export_$timestamp.json")
-        
-        val allGyms = gymDao.getAllGyms().first()
-        val allProblems = problemDao.getAllProblems().first()
-        val allSessions = sessionDao.getAllSessions().first()
-        val allAttempts = attemptDao.getAllAttempts().first()
-        
-        val exportData = ClimbDataExport(
-            exportedAt = LocalDateTime.now().toString(),
-            gyms = allGyms,
-            problems = allProblems,
-            sessions = allSessions,
-            attempts = allAttempts
-        )
-        
-        val jsonString = json.encodeToString(exportData)
-        exportFile.writeText(jsonString)
-        
-        return exportFile
-    }
-    
-    suspend fun exportAllDataToUri(context: Context, uri: android.net.Uri) {
-        val gyms = gymDao.getAllGyms().first()
-        val problems = problemDao.getAllProblems().first()
-        val sessions = sessionDao.getAllSessions().first()
-        val attempts = attemptDao.getAllAttempts().first()
-        
-        val exportData = ClimbDataExport(
-            exportedAt = LocalDateTime.now().toString(),
-            gyms = gyms,
-            problems = problems,
-            sessions = sessions,
-            attempts = attempts
-        )
-        
-        val jsonString = json.encodeToString(exportData)
-        
-        context.contentResolver.openOutputStream(uri)?.use { outputStream ->
-            outputStream.write(jsonString.toByteArray())
-        } ?: throw Exception("Could not open output stream")
-    }
-    
-    suspend fun importDataFromJson(file: File) {
-        try {
-            val jsonContent = file.readText()
-            val importData = json.decodeFromString<ClimbDataExport>(jsonContent)
-            
-            // Import gyms
-            importData.gyms.forEach { gym ->
-                try {
-                    gymDao.insertGym(gym)
-                } catch (_: Exception) {
-                    // If insertion fails, update instead
-                    gymDao.updateGym(gym)
-                }
-            }
-            
-            // Import problems
-            importData.problems.forEach { problem ->
-                try {
-                    problemDao.insertProblem(problem)
-                } catch (_: Exception) {
-                    problemDao.updateProblem(problem)
-                }
-            }
-            
-            // Import sessions
-            importData.sessions.forEach { session ->
-                try {
-                    sessionDao.insertSession(session)
-                } catch (_: Exception) {
-                    sessionDao.updateSession(session)
-                }
-            }
-            
-            // Import attempts
-            importData.attempts.forEach { attempt ->
-                try {
-                    attemptDao.insertAttempt(attempt)
-                } catch (_: Exception) {
-                    attemptDao.updateAttempt(attempt)
-                }
-            }
-            
-        } catch (e: Exception) {
-            throw Exception("Failed to import data: ${e.message}")
-        }
-    }
-    
-    // ZIP Export with images
     suspend fun exportAllDataToZip(directory: File? = null): File {
-        val allGyms = gymDao.getAllGyms().first()
+        try {
-        val allProblems = problemDao.getAllProblems().first()
+            // Collect all data with proper error handling
-        val allSessions = sessionDao.getAllSessions().first()
+            val allGyms = gymDao.getAllGyms().first()
-        val allAttempts = attemptDao.getAllAttempts().first()
+            val allProblems = problemDao.getAllProblems().first()
+            val allSessions = sessionDao.getAllSessions().first()
+            val allAttempts = attemptDao.getAllAttempts().first()
             
-        val exportData = ClimbDataExport(
+            // Validate data integrity before export
-            exportedAt = LocalDateTime.now().toString(),
+            validateDataIntegrity(allGyms, allProblems, allSessions, allAttempts)
-            gyms = allGyms,
-            problems = allProblems,
-            sessions = allSessions,
-            attempts = allAttempts
-        )
             
-        // Collect all referenced image paths
+            val exportData = ClimbDataExport(
-        val referencedImagePaths = allProblems.flatMap { it.imagePaths }.toSet()
+                exportedAt = LocalDateTime.now().toString(),
+                version = "1.0",
+                gyms = allGyms,
+                problems = allProblems,
+                sessions = allSessions,
+                attempts = allAttempts
+            )
             
-        return ZipExportImportUtils.createExportZip(
+            // Collect all referenced image paths and validate they exist
-            context = context,
+            val referencedImagePaths = allProblems.flatMap { it.imagePaths }.toSet()
-            exportData = exportData,
+            val validImagePaths = referencedImagePaths.filter { imagePath ->
-            referencedImagePaths = referencedImagePaths,
+                try {
-            directory = directory
+                    val imageFile = com.atridad.openclimb.utils.ImageUtils.getImageFile(context, imagePath)
-        )
+                    imageFile.exists() && imageFile.length() > 0
+                } catch (e: Exception) {
+                    false
+                }
+            }.toSet()
+            
+            // Log any missing images for debugging
+            val missingImages = referencedImagePaths - validImagePaths
+            if (missingImages.isNotEmpty()) {
+                android.util.Log.w("ClimbRepository", "Some referenced images are missing: $missingImages")
+            }
+            
+            return ZipExportImportUtils.createExportZip(
+                context = context,
+                exportData = exportData,
+                referencedImagePaths = validImagePaths,
+                directory = directory
+            )
+        } catch (e: Exception) {
+            throw Exception("Export failed: ${e.message}")
+        }
     }
     
     suspend fun exportAllDataToZipUri(context: Context, uri: android.net.Uri) {
-        val gyms = gymDao.getAllGyms().first()
+        try {
-        val problems = problemDao.getAllProblems().first()
+            // Collect all data with proper error handling
-        val sessions = sessionDao.getAllSessions().first()
+            val allGyms = gymDao.getAllGyms().first()
-        val attempts = attemptDao.getAllAttempts().first()
+            val allProblems = problemDao.getAllProblems().first()
+            val allSessions = sessionDao.getAllSessions().first()
+            val allAttempts = attemptDao.getAllAttempts().first()
             
-        val exportData = ClimbDataExport(
+            // Validate data integrity before export
-            exportedAt = LocalDateTime.now().toString(),
+            validateDataIntegrity(allGyms, allProblems, allSessions, allAttempts)
-            gyms = gyms,
-            problems = problems,
-            sessions = sessions,
-            attempts = attempts
-        )
             
-        // Collect all image paths
+            val exportData = ClimbDataExport(
-        val referencedImagePaths = problems.flatMap { it.imagePaths }.toSet()
+                exportedAt = LocalDateTime.now().toString(),
+                version = "1.0",
+                gyms = allGyms,
+                problems = allProblems,
+                sessions = allSessions,
+                attempts = allAttempts
+            )
             
-        ZipExportImportUtils.createExportZipToUri(
+            // Collect all referenced image paths and validate they exist
-            context = context,
+            val referencedImagePaths = allProblems.flatMap { it.imagePaths }.toSet()
-            uri = uri,
+            val validImagePaths = referencedImagePaths.filter { imagePath ->
-            exportData = exportData,
+                try {
-            referencedImagePaths = referencedImagePaths
+                    val imageFile = com.atridad.openclimb.utils.ImageUtils.getImageFile(context, imagePath)
-        )
+                    imageFile.exists() && imageFile.length() > 0
+                } catch (e: Exception) {
+                    false
+                }
+            }.toSet()
+            
+            ZipExportImportUtils.createExportZipToUri(
+                context = context,
+                uri = uri,
+                exportData = exportData,
+                referencedImagePaths = validImagePaths
+            )
+        } catch (e: Exception) {
+            throw Exception("Export failed: ${e.message}")
+        }
     }
     
     suspend fun importDataFromZip(file: File) {
         try {
-            val importResult = ZipExportImportUtils.extractImportZip(context, file)
+            // Validate the ZIP file
-            val importData = json.decodeFromString<ClimbDataExport>(importResult.jsonContent)
+            if (!file.exists() || file.length() == 0L) {
+                throw Exception("Invalid ZIP file: file is empty or doesn't exist")
+            }
             
-            // Update problem image paths with the new imported paths
+            // Extract and validate the ZIP contents
+            val importResult = ZipExportImportUtils.extractImportZip(context, file)
+            
+            // Validate JSON content
+            if (importResult.jsonContent.isBlank()) {
+                throw Exception("Invalid ZIP file: no data.json found or empty content")
+            }
+            
+            // Parse and validate the data structure
+            val importData = try {
+                json.decodeFromString<ClimbDataExport>(importResult.jsonContent)
+            } catch (e: Exception) {
+                throw Exception("Invalid data format: ${e.message}")
+            }
+            
+            // Validate data integrity
+            validateImportData(importData)
+            
+            // Clear existing data to avoid conflicts
+            attemptDao.deleteAllAttempts()
+            sessionDao.deleteAllSessions()
+            problemDao.deleteAllProblems()
+            gymDao.deleteAllGyms()
+            
+            // Import gyms first (problems depend on gyms)
+            importData.gyms.forEach { gym ->
+                try {
+                    gymDao.insertGym(gym)
+                } catch (e: Exception) {
+                    throw Exception("Failed to import gym ${gym.name}: ${e.message}")
+                }
+            }
+            
+            // Import problems with updated image paths
             val updatedProblems = ZipExportImportUtils.updateProblemImagePaths(
                 importData.problems,
                 importResult.importedImagePaths
             )
             
-            // Import gyms
-            importData.gyms.forEach { gym ->
-                try {
-                    gymDao.insertGym(gym)
-                } catch (e: Exception) {
-                    // If insertion fails update instead
-                    gymDao.updateGym(gym)
-                }
-            }
-            
-            // Import problems with updated image paths
             updatedProblems.forEach { problem ->
                 try {
                     problemDao.insertProblem(problem)
                 } catch (e: Exception) {
-                    problemDao.updateProblem(problem)
+                    throw Exception("Failed to import problem ${problem.name}: ${e.message}")
                 }
             }
             
@@ -247,21 +214,100 @@ class ClimbRepository(
                 try {
                     sessionDao.insertSession(session)
                 } catch (e: Exception) {
-                    sessionDao.updateSession(session)
+                    throw Exception("Failed to import session: ${e.message}")
                 }
             }
             
-            // Import attempts
+            // Import attempts last (depends on problems and sessions)
             importData.attempts.forEach { attempt ->
                 try {
                     attemptDao.insertAttempt(attempt)
                 } catch (e: Exception) {
-                    attemptDao.updateAttempt(attempt)
+                    throw Exception("Failed to import attempt: ${e.message}")
                 }
             }
             
         } catch (e: Exception) {
-            throw Exception("Failed to import data: ${e.message}")
+            throw Exception("Import failed: ${e.message}")
+        }
+    }
+    
+    private fun validateDataIntegrity(
+        gyms: List<Gym>,
+        problems: List<Problem>,
+        sessions: List<ClimbSession>,
+        attempts: List<Attempt>
+    ) {
+        // Validate that all problems reference valid gyms
+        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")
+        }
+        
+        // Validate that all sessions reference valid gyms
+        val invalidSessions = sessions.filter { it.gymId !in gymIds }
+        if (invalidSessions.isNotEmpty()) {
+            throw Exception("Data integrity error: ${invalidSessions.size} sessions reference non-existent gyms")
+        }
+        
+        // Validate that all attempts reference valid problems and sessions
+        val problemIds = problems.map { it.id }.toSet()
+        val sessionIds = sessions.map { it.id }.toSet()
+        
+        val invalidAttempts = 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")
+        }
+    }
+    
+    private fun validateImportData(importData: ClimbDataExport) {
+        if (importData.gyms.isEmpty()) {
+            throw Exception("Import data is invalid: no gyms found")
+        }
+        
+        if (importData.version.isBlank()) {
+            throw Exception("Import data is invalid: no version information")
+        }
+        
+        // Check for reasonable data sizes to prevent malicious imports
+        if (importData.gyms.size > 1000 || 
+            importData.problems.size > 10000 || 
+            importData.sessions.size > 10000 || 
+            importData.attempts.size > 100000) {
+            throw Exception("Import data is too large: possible corruption or malicious file")
+        }
+    }
+    
+    suspend fun resetAllData() {
+        try {
+            // Clear all data from database
+            attemptDao.deleteAllAttempts()
+            sessionDao.deleteAllSessions()
+            problemDao.deleteAllProblems()
+            gymDao.deleteAllGyms()
+            
+            // Clear all images from storage
+            clearAllImages()
+            
+        } catch (e: Exception) {
+            throw Exception("Reset failed: ${e.message}")
+        }
+    }
+    
+    private fun clearAllImages() {
+        try {
+            // Get the images directory
+            val imagesDir = File(context.filesDir, "images")
+            if (imagesDir.exists() && imagesDir.isDirectory) {
+                val deletedCount = imagesDir.listFiles()?.size ?: 0
+                imagesDir.deleteRecursively()
+                android.util.Log.i("ClimbRepository", "Cleared $deletedCount image files")
+            }
+        } catch (e: Exception) {
+            android.util.Log.w("ClimbRepository", "Failed to clear some images: ${e.message}")
         }
     }
 }
@@ -269,6 +315,7 @@ class ClimbRepository(
 @kotlinx.serialization.Serializable
 data class ClimbDataExport(
     val exportedAt: String,
+    val version: String = "1.0",
     val gyms: List<Gym>,
     val problems: List<Problem>,
     val sessions: List<ClimbSession>,

app/src/main/java/com/atridad/openclimb/service/SessionTrackingService.kt

@@ -7,7 +7,6 @@ import android.app.Service
 import android.content.Context
 import android.content.Intent
 import android.os.IBinder
-import android.os.PowerManager
 import androidx.core.app.NotificationCompat
 import com.atridad.openclimb.MainActivity
 import com.atridad.openclimb.R
@@ -17,13 +16,13 @@ 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 var wakeLock: PowerManager.WakeLock? = null
     
     private lateinit var repository: ClimbRepository
     private lateinit var notificationManager: NotificationManager
@@ -58,7 +57,6 @@ class SessionTrackingService : Service() {
         notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
         
         createNotificationChannel()
-        acquireWakeLock()
     }
     
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -87,59 +85,51 @@ class SessionTrackingService : Service() {
                 }
             }
         }
-        // Return START_STICKY to restart service if it gets killed
+
-        return START_STICKY
+        return START_REDELIVER_INTENT
     }
     
     override fun onTaskRemoved(rootIntent: Intent?) {
         super.onTaskRemoved(rootIntent)
-        // If the app is removed from recent tasks, ensure the service keeps running
-        // This helps maintain the notification even if the user swipes away the app
-    }
-    
-    override fun onLowMemory() {
-        super.onLowMemory()
-        // Don't stop the service on low memory, just log it
-        // The notification is important for user experience
     }
     
     override fun onBind(intent: Intent?): IBinder? = null
     
     private fun startSessionTracking(sessionId: String) {
-        // Cancel any existing jobs
         notificationJob?.cancel()
         monitoringJob?.cancel()
         
-        // Start the main notification update job
+        try {
+            createAndShowNotification(sessionId)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        
         notificationJob = serviceScope.launch {
             try {
-                // Initial notification update
+                if (!isNotificationActive()) {
-                updateNotification(sessionId)
+                    delay(1000L)
+                    createAndShowNotification(sessionId)
+                }
                 
-                // Update every 2 seconds for better performance
                 while (isActive) {
-                    delay(2000L)
+                    delay(5000L)
                     updateNotification(sessionId)
                 }
             } catch (e: Exception) {
-                // Log error and continue
                 e.printStackTrace()
             }
         }
         
-        // Start the monitoring job that ensures notification stays active
         monitoringJob = serviceScope.launch {
             try {
                 while (isActive) {
-                    delay(5000L) // Check every 5 seconds
+                    delay(10000L)
                     
-                    // Verify the notification is still active
                     if (!isNotificationActive()) {
-                        // Notification was dismissed, recreate it
                         updateNotification(sessionId)
                     }
                     
-                    // Verify the session is still active
                     val session = repository.getSessionById(sessionId)
                     if (session == null || session.status != com.atridad.openclimb.data.model.SessionStatus.ACTIVE) {
                         stopSessionTracking()
@@ -155,7 +145,6 @@ class SessionTrackingService : Service() {
     private fun stopSessionTracking() {
         notificationJob?.cancel()
         monitoringJob?.cancel()
-        releaseWakeLock()
         stopForeground(STOP_FOREGROUND_REMOVE)
         stopSelf()
     }
@@ -171,14 +160,37 @@ class SessionTrackingService : Service() {
     
     private suspend fun updateNotification(sessionId: String) {
         try {
-            val session = repository.getSessionById(sessionId)
+            createAndShowNotification(sessionId)
+        } catch (e: Exception) {
+            e.printStackTrace()
+
+            try {
+                delay(10000L)
+                createAndShowNotification(sessionId)
+            } catch (retryException: Exception) {
+                retryException.printStackTrace()
+                stopSessionTracking()
+            }
+        }
+    }
+    
+    private fun createAndShowNotification(sessionId: String) {
+        try {
+            val session = runBlocking {
+                repository.getSessionById(sessionId)
+            }
             if (session == null || session.status != com.atridad.openclimb.data.model.SessionStatus.ACTIVE) {
                 stopSessionTracking()
                 return
             }
             
-            val gym = repository.getGymById(session.gymId)
+            val gym = runBlocking {
-            val attempts = repository.getAttemptsBySession(sessionId).firstOrNull() ?: emptyList()
+                repository.getGymById(session.gymId)
+            }
+            
+            val attempts = runBlocking {
+                repository.getAttemptsBySession(sessionId).firstOrNull() ?: emptyList()
+            }
             
             val duration = session.startTime?.let { startTime ->
                 try {
@@ -205,7 +217,7 @@ class SessionTrackingService : Service() {
                 .setSmallIcon(R.drawable.ic_mountains)
                 .setOngoing(true)
                 .setAutoCancel(false)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                 .setCategory(NotificationCompat.CATEGORY_SERVICE)
                 .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
                 .setContentIntent(createOpenAppIntent())
@@ -221,24 +233,13 @@ class SessionTrackingService : Service() {
                 )
                 .build()
             
-            // Always start foreground to ensure service stays alive
             startForeground(NOTIFICATION_ID, notification)
             
-            // Also notify separately to ensure it's visible
             notificationManager.notify(NOTIFICATION_ID, notification)
             
         } catch (e: Exception) {
             e.printStackTrace()
-            // Don't stop the service on notification errors, just log them
+            throw e
-            // Try to restart the notification after a delay
-            try {
-                delay(5000L)
-                updateNotification(sessionId)
-            } catch (retryException: Exception) {
-                retryException.printStackTrace()
-                // If retry fails, stop the service to prevent infinite loops
-                stopSessionTracking()
-            }
         }
     }
     
@@ -269,50 +270,23 @@ class SessionTrackingService : Service() {
         val channel = NotificationChannel(
             CHANNEL_ID,
             "Session Tracking",
-            NotificationManager.IMPORTANCE_LOW
+            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)
     }
     
-    private fun acquireWakeLock() {
-        try {
-            val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
-            wakeLock = powerManager.newWakeLock(
-                PowerManager.PARTIAL_WAKE_LOCK,
-                "OpenClimb:SessionTrackingWakeLock"
-            ).apply {
-                acquire(10*60*1000L) // 10 minutes timeout
-            }
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-    }
-    
-    private fun releaseWakeLock() {
-        try {
-            wakeLock?.let {
-                if (it.isHeld) {
-                    it.release()
-                }
-            }
-            wakeLock = null
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-    }
-    
     override fun onDestroy() {
         super.onDestroy()
         notificationJob?.cancel()
         monitoringJob?.cancel()
-        releaseWakeLock()
         serviceScope.cancel()
     }
 }

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

@@ -26,12 +26,16 @@ fun SettingsScreen(
 ) {
     val uiState by viewModel.uiState.collectAsState()
     val context = LocalContext.current
+    
+    // State for reset confirmation dialog
+    var showResetDialog by remember { mutableStateOf(false) }
+    
     val packageInfo = remember {
         context.packageManager.getPackageInfo(context.packageName, 0)
     }
     val appVersion = packageInfo.versionName
     
-    // File picker launcher for import - accepts both ZIP and JSON files
+    // File picker launcher for import - only accepts ZIP files
     val importLauncher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.GetContent()
     ) { uri ->
@@ -46,9 +50,13 @@ fun SettingsScreen(
                     } else null
                 } ?: "import_file"
                 
-                val extension = fileName.substringAfterLast(".", "")
+                // Only allow ZIP files
-                val tempFileName = if (extension.isNotEmpty()) "temp_import.$extension" else "temp_import"
+                if (!fileName.lowercase().endsWith(".zip")) {
-                val tempFile = File(context.cacheDir, tempFileName)
+                    viewModel.setError("Only ZIP files are supported for import. Please use a ZIP file exported from OpenClimb.")
+                    return@let
+                }
+                
+                val tempFile = File(context.cacheDir, "temp_import.zip")
                 
                 inputStream?.use { input ->
                     tempFile.outputStream().use { output ->
@@ -62,7 +70,7 @@ fun SettingsScreen(
         }
     }
     
-    // File picker launcher for export - save location (ZIP format with images)
+    // File picker launcher for export - ZIP format with images
     val exportZipLauncher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.CreateDocument("application/zip")
     ) { uri ->
@@ -75,19 +83,6 @@ fun SettingsScreen(
         }
     }
     
-    // JSON export launcher
-    val exportJsonLauncher = rememberLauncherForActivityResult(
-        contract = ActivityResultContracts.CreateDocument("application/json")
-    ) { uri ->
-        uri?.let {
-            try {
-                viewModel.exportDataToUri(context, uri)
-            } catch (e: Exception) {
-                viewModel.setError("Failed to save file: ${e.message}")
-            }
-        }
-    }
-    
     LazyColumn(
         modifier = Modifier
             .fillMaxSize()
@@ -179,19 +174,13 @@ fun SettingsScreen(
                         )
                     ) {
                         ListItem(
-                            headlineContent = { Text("Export Data Only") },
+                            headlineContent = { Text("Import Data") },
-                            supportingContent = { Text("Export climbing data to JSON without images") },
+                            supportingContent = { Text("Import climbing data from ZIP file (recommended format)") },
-                            leadingContent = { Icon(Icons.Default.Share, contentDescription = null) },
+                            leadingContent = { Icon(Icons.Default.Add, contentDescription = null) },
                             trailingContent = {
                                 TextButton(
                                     onClick = { 
-                                        val defaultFileName = "openclimb_export_${
+                                        importLauncher.launch("application/zip")
-                                            java.time.LocalDateTime.now()
-                                                .toString()
-                                                .replace(":", "-")
-                                                .replace(".", "-")
-                                        }.json"
-                                        exportJsonLauncher.launch(defaultFileName)
                                     },
                                     enabled = !uiState.isLoading
                                 ) {
@@ -201,7 +190,7 @@ fun SettingsScreen(
                                             strokeWidth = 2.dp
                                         )
                                     } else {
-                                        Text("Export JSON")
+                                        Text("Import")
                                     }
                                 }
                             }
@@ -213,17 +202,17 @@ fun SettingsScreen(
                     Card(
                         shape = RoundedCornerShape(12.dp),
                         colors = CardDefaults.cardColors(
-                            containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f)
+                            containerColor = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
                         )
                     ) {
                         ListItem(
-                            headlineContent = { Text("Import Data") },
+                            headlineContent = { Text("Reset All Data") },
-                            supportingContent = { Text("Import climbing data from ZIP or JSON file") },
+                            supportingContent = { Text("Permanently delete all gyms, problems, sessions, attempts, and images") },
-                            leadingContent = { Icon(Icons.Default.Add, contentDescription = null) },
+                            leadingContent = { Icon(Icons.Default.Delete, contentDescription = null, tint = MaterialTheme.colorScheme.error) },
                             trailingContent = {
                                 TextButton(
                                     onClick = { 
-                                        importLauncher.launch("*/*")
+                                        showResetDialog = true
                                     },
                                     enabled = !uiState.isLoading
                                 ) {
@@ -233,7 +222,7 @@ fun SettingsScreen(
                                             strokeWidth = 2.dp
                                         )
                                     } else {
-                                        Text("Import")
+                                        Text("Reset", color = MaterialTheme.colorScheme.error)
                                     }
                                 }
                             }
@@ -390,4 +379,51 @@ fun SettingsScreen(
             }
         }
     }
+    
+    // Reset confirmation dialog
+    if (showResetDialog) {
+        AlertDialog(
+            onDismissRequest = { showResetDialog = false },
+            title = { Text("Reset All Data") },
+            text = {
+                Column {
+                    Text("Are you sure you want to reset all data?")
+                    Spacer(modifier = Modifier.height(8.dp))
+                    Text(
+                        text = "This will permanently delete:",
+                        style = MaterialTheme.typography.bodySmall,
+                        fontWeight = FontWeight.Medium
+                    )
+                    Spacer(modifier = Modifier.height(4.dp))
+                    Text(
+                        text = "• All gyms and their information\n• All problems and their images\n• All climbing sessions\n• All attempts and progress data",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.error
+                    )
+                    Spacer(modifier = Modifier.height(8.dp))
+                    Text(
+                        text = "This action cannot be undone. Consider exporting your data first.",
+                        style = MaterialTheme.typography.bodySmall,
+                        fontWeight = FontWeight.Medium,
+                        color = MaterialTheme.colorScheme.error
+                    )
+                }
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        viewModel.resetAllData()
+                        showResetDialog = false
+                    }
+                ) {
+                    Text("Reset All Data", color = MaterialTheme.colorScheme.error)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showResetDialog = false }) { 
+                    Text("Cancel") 
+                }
+            }
+        )
+    }
 }

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

@@ -242,23 +242,7 @@ class ClimbViewModel(
     fun getAttemptsByProblem(problemId: String): Flow<List<Attempt>> = 
         repository.getAttemptsByProblem(problemId)
 
-    fun exportDataToUri(context: Context, uri: android.net.Uri) {
+
-        viewModelScope.launch {
-            try {
-                _uiState.value = _uiState.value.copy(isLoading = true)
-                repository.exportAllDataToUri(context, uri)
-                _uiState.value = _uiState.value.copy(
-                    isLoading = false,
-                    message = "Data exported successfully"
-                )
-            } catch (e: Exception) {
-                _uiState.value = _uiState.value.copy(
-                    isLoading = false,
-                    error = "Export failed: ${e.message}"
-                )
-            }
-        }
-    }
 
     fun exportDataToZipUri(context: Context, uri: android.net.Uri) {
         viewModelScope.launch {
@@ -283,13 +267,13 @@ class ClimbViewModel(
             try {
                 _uiState.value = _uiState.value.copy(isLoading = true)
                 
-                // Check if it's a ZIP file or JSON file
+                // Only support ZIP format for reliability
-                if (file.name.lowercase().endsWith(".zip")) {
+                if (!file.name.lowercase().endsWith(".zip")) {
-                    repository.importDataFromZip(file)
+                    throw Exception("Only ZIP files are supported for import. Please use a ZIP file exported from OpenClimb.")
-                } else {
-                    repository.importDataFromJson(file)
                 }
                 
+                repository.importDataFromZip(file)
+                
                 _uiState.value = _uiState.value.copy(
                     isLoading = false,
                     message = "Data imported successfully from ${file.name}"
@@ -316,6 +300,26 @@ class ClimbViewModel(
         _uiState.value = _uiState.value.copy(error = message)
     }
     
+    fun resetAllData() {
+        viewModelScope.launch {
+            try {
+                _uiState.value = _uiState.value.copy(isLoading = true)
+                
+                repository.resetAllData()
+                
+                _uiState.value = _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}"
+                )
+            }
+        }
+    }
+    
     // Share operations
     suspend fun generateSessionShareCard(
         context: Context,

app/src/main/java/com/atridad/openclimb/utils/ZipExportImportUtils.kt

@@ -15,6 +15,7 @@ object ZipExportImportUtils {
     
     private const val DATA_JSON_FILENAME = "data.json"
     private const val IMAGES_DIR_NAME = "images"
+    private const val METADATA_FILENAME = "metadata.txt"
     
     /**
      * Creates a ZIP file containing the JSON data and all referenced images
@@ -38,37 +39,67 @@ object ZipExportImportUtils {
         val timestamp = LocalDateTime.now().toString().replace(":", "-").replace(".", "-")
         val zipFile = File(exportDir, "openclimb_export_$timestamp.zip")
         
-        ZipOutputStream(FileOutputStream(zipFile)).use { zipOut ->
+        try {
-            // Add JSON data file
+            ZipOutputStream(FileOutputStream(zipFile)).use { zipOut ->
-            val json = Json { prettyPrint = true }
+                // Add metadata file first
-            val jsonString = json.encodeToString(com.atridad.openclimb.data.repository.ClimbDataExport.serializer(), exportData)
+                val metadata = createMetadata(exportData, referencedImagePaths)
+                val metadataEntry = ZipEntry(METADATA_FILENAME)
+                zipOut.putNextEntry(metadataEntry)
+                zipOut.write(metadata.toByteArray())
+                zipOut.closeEntry()
                 
-            val jsonEntry = ZipEntry(DATA_JSON_FILENAME)
+                // Add JSON data file
-            zipOut.putNextEntry(jsonEntry)
+                val json = Json { 
-            zipOut.write(jsonString.toByteArray())
+                    prettyPrint = true 
-            zipOut.closeEntry()
+                    ignoreUnknownKeys = true
-            
-            // Add images
-            referencedImagePaths.forEach { imagePath ->
-                try {
-                    val imageFile = ImageUtils.getImageFile(context, imagePath)
-                    if (imageFile.exists()) {
-                        val imageEntry = ZipEntry("$IMAGES_DIR_NAME/${imageFile.name}")
-                        zipOut.putNextEntry(imageEntry)
-                        
-                        FileInputStream(imageFile).use { imageInput ->
-                            imageInput.copyTo(zipOut)
-                        }
-                        zipOut.closeEntry()
-                    }
-                } catch (e: Exception) {
-                    // Log error but continue with other images
-                    e.printStackTrace()
                 }
-            }
+                val jsonString = json.encodeToString(com.atridad.openclimb.data.repository.ClimbDataExport.serializer(), exportData)
-        }
                 
-        return zipFile
+                val jsonEntry = ZipEntry(DATA_JSON_FILENAME)
+                zipOut.putNextEntry(jsonEntry)
+                zipOut.write(jsonString.toByteArray())
+                zipOut.closeEntry()
+                
+                // Add images with validation
+                var successfulImages = 0
+                referencedImagePaths.forEach { imagePath ->
+                    try {
+                        val imageFile = ImageUtils.getImageFile(context, imagePath)
+                        if (imageFile.exists() && imageFile.length() > 0) {
+                            val imageEntry = ZipEntry("$IMAGES_DIR_NAME/${imageFile.name}")
+                            zipOut.putNextEntry(imageEntry)
+                            
+                            FileInputStream(imageFile).use { imageInput ->
+                                imageInput.copyTo(zipOut)
+                            }
+                            zipOut.closeEntry()
+                            successfulImages++
+                        } else {
+                            android.util.Log.w("ZipExportImportUtils", "Image file not found or empty: $imagePath")
+                        }
+                    } catch (e: Exception) {
+                        android.util.Log.e("ZipExportImportUtils", "Failed to add image $imagePath: ${e.message}")
+                    }
+                }
+                
+                // Log export summary
+                android.util.Log.i("ZipExportImportUtils", "Export completed: ${successfulImages}/${referencedImagePaths.size} images included")
+            }
+            
+            // Validate the created ZIP file
+            if (!zipFile.exists() || zipFile.length() == 0L) {
+                throw IOException("Failed to create ZIP file: file is empty or doesn't exist")
+            }
+            
+            return zipFile
+            
+        } catch (e: Exception) {
+            // Clean up failed export
+            if (zipFile.exists()) {
+                zipFile.delete()
+            }
+            throw IOException("Failed to create export ZIP: ${e.message}")
+        }
     }
     
     /**
@@ -84,37 +115,73 @@ object ZipExportImportUtils {
         exportData: com.atridad.openclimb.data.repository.ClimbDataExport,
         referencedImagePaths: Set<String>
     ) {
-        context.contentResolver.openOutputStream(uri)?.use { outputStream ->
+        try {
-            ZipOutputStream(outputStream).use { zipOut ->
+            context.contentResolver.openOutputStream(uri)?.use { outputStream ->
-                // Add JSON data file
+                ZipOutputStream(outputStream).use { zipOut ->
-                val json = Json { prettyPrint = true }
+                    // Add metadata file first
-                val jsonString = json.encodeToString(com.atridad.openclimb.data.repository.ClimbDataExport.serializer(), exportData)
+                    val metadata = createMetadata(exportData, referencedImagePaths)
+                    val metadataEntry = ZipEntry(METADATA_FILENAME)
+                    zipOut.putNextEntry(metadataEntry)
+                    zipOut.write(metadata.toByteArray())
+                    zipOut.closeEntry()
                     
-                val jsonEntry = ZipEntry(DATA_JSON_FILENAME)
+                    // Add JSON data file
-                zipOut.putNextEntry(jsonEntry)
+                    val json = Json { 
-                zipOut.write(jsonString.toByteArray())
+                        prettyPrint = true 
-                zipOut.closeEntry()
+                        ignoreUnknownKeys = true
-                
-                // Add images
-                referencedImagePaths.forEach { imagePath ->
-                    try {
-                        val imageFile = ImageUtils.getImageFile(context, imagePath)
-                        if (imageFile.exists()) {
-                            val imageEntry = ZipEntry("$IMAGES_DIR_NAME/${imageFile.name}")
-                            zipOut.putNextEntry(imageEntry)
-                            
-                            FileInputStream(imageFile).use { imageInput ->
-                                imageInput.copyTo(zipOut)
-                            }
-                            zipOut.closeEntry()
-                        }
-                    } catch (e: Exception) {
-                        // Log error but continue with other images
-                        e.printStackTrace()
                     }
+                    val jsonString = json.encodeToString(com.atridad.openclimb.data.repository.ClimbDataExport.serializer(), exportData)
+                    
+                    val jsonEntry = ZipEntry(DATA_JSON_FILENAME)
+                    zipOut.putNextEntry(jsonEntry)
+                    zipOut.write(jsonString.toByteArray())
+                    zipOut.closeEntry()
+                    
+                    // Add images with validation
+                    var successfulImages = 0
+                    referencedImagePaths.forEach { imagePath ->
+                        try {
+                            val imageFile = ImageUtils.getImageFile(context, imagePath)
+                            if (imageFile.exists() && imageFile.length() > 0) {
+                                val imageEntry = ZipEntry("$IMAGES_DIR_NAME/${imageFile.name}")
+                                zipOut.putNextEntry(imageEntry)
+                                
+                                FileInputStream(imageFile).use { imageInput ->
+                                    imageInput.copyTo(zipOut)
+                                }
+                                zipOut.closeEntry()
+                                successfulImages++
+                            }
+                        } catch (e: Exception) {
+                            android.util.Log.e("ZipExportImportUtils", "Failed to add image $imagePath: ${e.message}")
+                        }
+                    }
+                    
+                    android.util.Log.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: com.atridad.openclimb.data.repository.ClimbDataExport,
+        referencedImagePaths: Set<String>
+    ): String {
+        return buildString {
+            appendLine("OpenClimb Export Metadata")
+            appendLine("=======================")
+            appendLine("Export Date: ${exportData.exportedAt}")
+            appendLine("Version: ${exportData.version}")
+            appendLine("Gyms: ${exportData.gyms.size}")
+            appendLine("Problems: ${exportData.problems.size}")
+            appendLine("Sessions: ${exportData.sessions.size}")
+            appendLine("Attempts: ${exportData.attempts.size}")
+            appendLine("Referenced Images: ${referencedImagePaths.size}")
+            appendLine("Format: ZIP with embedded JSON data and images")
+        }
     }
     
     /**
@@ -133,50 +200,89 @@ object ZipExportImportUtils {
      */
     fun extractImportZip(context: Context, zipFile: File): ImportResult {
         var jsonContent = ""
+        var metadataContent = ""
         val importedImagePaths = mutableMapOf<String, String>()
+        var foundRequiredFiles = mutableSetOf<String>()
         
-        ZipInputStream(FileInputStream(zipFile)).use { zipIn ->
+        try {
-            var entry = zipIn.nextEntry
+            ZipInputStream(FileInputStream(zipFile)).use { zipIn ->
+                var entry = zipIn.nextEntry
                 
-            while (entry != null) {
+                while (entry != null) {
-                when {
+                    when {
-                    entry.name == DATA_JSON_FILENAME -> {
+                        entry.name == METADATA_FILENAME -> {
-                        // Read JSON data
+                            // Read metadata for validation
-                        jsonContent = zipIn.readBytes().toString(Charsets.UTF_8)
+                            metadataContent = zipIn.readBytes().toString(Charsets.UTF_8)
-                    }
+                            foundRequiredFiles.add("metadata")
-                    
+                            android.util.Log.i("ZipExportImportUtils", "Found metadata: ${metadataContent.lines().take(3).joinToString()}")
-                    entry.name.startsWith("$IMAGES_DIR_NAME/") && !entry.isDirectory -> {
-                        // Extract image file
-                        val originalFilename = entry.name.substringAfter("$IMAGES_DIR_NAME/")
-                        
-                        // Create temporary file to hold the extracted image
-                        val tempFile = File.createTempFile("import_image_", "_$originalFilename", context.cacheDir)
-                        
-                        FileOutputStream(tempFile).use { output ->
-                            zipIn.copyTo(output)
                         }
                         
-                        // Import the image to permanent storage
+                        entry.name == DATA_JSON_FILENAME -> {
-                        val newPath = ImageUtils.importImageFile(context, tempFile)
+                            // Read JSON data
-                        if (newPath != null) {
+                            jsonContent = zipIn.readBytes().toString(Charsets.UTF_8)
-                            importedImagePaths[originalFilename] = newPath
+                            foundRequiredFiles.add("data")
                         }
                         
-                        // Clean up temp file
+                        entry.name.startsWith("$IMAGES_DIR_NAME/") && !entry.isDirectory -> {
-                        tempFile.delete()
+                            // Extract image file
+                            val originalFilename = entry.name.substringAfter("$IMAGES_DIR_NAME/")
+                            
+                            try {
+                                // Create temporary file to hold the extracted image
+                                val tempFile = File.createTempFile("import_image_", "_$originalFilename", context.cacheDir)
+                                
+                                FileOutputStream(tempFile).use { output ->
+                                    zipIn.copyTo(output)
+                                }
+                                
+                                // Validate the extracted image
+                                if (tempFile.exists() && tempFile.length() > 0) {
+                                    // Import the image to permanent storage
+                                    val newPath = ImageUtils.importImageFile(context, tempFile)
+                                    if (newPath != null) {
+                                        importedImagePaths[originalFilename] = newPath
+                                        android.util.Log.d("ZipExportImportUtils", "Successfully imported image: $originalFilename -> $newPath")
+                                    } else {
+                                        android.util.Log.w("ZipExportImportUtils", "Failed to import image: $originalFilename")
+                                    }
+                                } else {
+                                    android.util.Log.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}")
+                            }
+                        }
+                        
+                        else -> {
+                            android.util.Log.d("ZipExportImportUtils", "Skipping ZIP entry: ${entry.name}")
+                        }
                     }
+                    
+                    zipIn.closeEntry()
+                    entry = zipIn.nextEntry
                 }
-                
-                zipIn.closeEntry()
-                entry = zipIn.nextEntry
             }
-        }
             
-        if (jsonContent.isEmpty()) {
+            // Validate that we found the required files
-            throw IOException("No data.json file found in the ZIP archive")
+            if (!foundRequiredFiles.contains("data")) {
-        }
+                throw IOException("Invalid ZIP file: data.json not found")
+            }
             
-        return ImportResult(jsonContent, importedImagePaths)
+            if (jsonContent.isBlank()) {
+                throw IOException("Invalid ZIP file: data.json is empty")
+            }
+            
+            android.util.Log.i("ZipExportImportUtils", "Import extraction completed: ${importedImagePaths.size} images processed")
+            
+            return ImportResult(jsonContent, importedImagePaths)
+            
+        } catch (e: Exception) {
+            throw IOException("Failed to extract import ZIP: ${e.message}")
+        }
     }
 
     /**

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

@@ -1,3 +1,4 @@
 <resources>
     <string name="app_name">OpenClimb</string>
+    <string name="session_tracking_service_description">Tracks active climbing sessions and displays session information in the notification area</string>
 </resources>