0.5.0 - Optimizations and better session management

Reviewed-on: atridad/OpenClimb#2

.idea/misc.xml

@@ -1,5 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="temurin-21" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="temurin-21" project-jdk-type="JavaSDK" />
 </project>

app/build.gradle.kts

@@ -8,14 +8,14 @@ plugins {
 
 android {
     namespace = "com.atridad.openclimb"
-    compileSdk = 35
+    compileSdk = 36
 
     defaultConfig {
         applicationId = "com.atridad.openclimb"
         minSdk = 31
-        targetSdk = 35
+        targetSdk = 36
-        versionCode = 7
+        versionCode = 13
-        versionName = "0.4.0"
+        versionName = "0.5.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -30,12 +30,20 @@ android {
         }
     }
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_17
     }
     kotlinOptions {
-        jvmTarget = "11"
+        jvmTarget = "17"
     }
+    
+    // Ensure consistent JVM toolchain across all tasks
+    java {
+        toolchain {
+            languageVersion.set(JavaLanguageVersion.of(17))
+        }
+    }
+    
     buildFeatures {
         compose = true
     }
@@ -79,8 +87,14 @@ dependencies {
     
     // Testing
     testImplementation(libs.junit)
+    testImplementation(libs.mockk)
+    testImplementation(libs.kotlinx.coroutines.test)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(libs.androidx.test.core)
+    androidTestImplementation(libs.androidx.test.ext)
+    androidTestImplementation(libs.androidx.test.runner)
+    androidTestImplementation(libs.androidx.test.rules)
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.ui.test.junit4)
     debugImplementation(libs.androidx.ui.tooling)

app/src/main/java/com/atridad/openclimb/ui/OpenClimbApp.kt

@@ -3,6 +3,7 @@ package com.atridad.openclimb.ui
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
@@ -67,7 +68,7 @@ fun OpenClimbApp() {
                 LaunchedEffect(gyms, activeSession) {
                     fabConfig = if (gyms.isNotEmpty() && activeSession == null) {
                         FabConfig(
-                            icon = Icons.Default.Add,
+                            icon = Icons.Default.PlayArrow,
                             contentDescription = "Start Session",
                             onClick = { 
                                 if (gyms.size == 1) {

app/src/main/java/com/atridad/openclimb/ui/components/ActiveSessionBanner.kt

@@ -3,7 +3,6 @@ package com.atridad.openclimb.ui.components
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
@@ -13,9 +12,10 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import com.atridad.openclimb.data.model.ClimbSession
 import com.atridad.openclimb.data.model.Gym
+import com.atridad.openclimb.ui.theme.CustomIcons
+import kotlinx.coroutines.delay
 import java.time.LocalDateTime
 import java.time.temporal.ChronoUnit
-import kotlinx.coroutines.delay
 
 @Composable
 fun ActiveSessionBanner(
@@ -95,7 +95,7 @@ fun ActiveSessionBanner(
                     )
                 ) {
                     Icon(
-                        Icons.Default.Close,
+                        imageVector = CustomIcons.Stop(MaterialTheme.colorScheme.onError),
                         contentDescription = "End session"
                     )
                 }

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

@@ -31,6 +31,7 @@ import androidx.lifecycle.viewModelScope
 import com.atridad.openclimb.data.model.*
 import com.atridad.openclimb.ui.components.FullscreenImageViewer
 import com.atridad.openclimb.ui.components.ImageDisplaySection
+import com.atridad.openclimb.ui.theme.CustomIcons
 import com.atridad.openclimb.ui.viewmodel.ClimbViewModel
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
@@ -283,8 +284,23 @@ fun SessionDetailScreen(sessionId: String, viewModel: ClimbViewModel, onNavigate
                         }
                     }
 
-                    IconButton(onClick = { showDeleteDialog = true }) {
+                    // Show stop icon for active sessions, delete icon for completed sessions
-                        Icon(Icons.Default.Delete, contentDescription = "Delete")
+                    if (session?.status == SessionStatus.ACTIVE) {
+                        IconButton(onClick = { 
+                            session?.let { s ->
+                                viewModel.endSession(context, s.id)
+                                onNavigateBack()
+                            }
+                        }) {
+                            Icon(
+                                imageVector = CustomIcons.Stop(MaterialTheme.colorScheme.onSurface),
+                                contentDescription = "Stop Session"
+                            )
+                        }
+                    } else {
+                        IconButton(onClick = { showDeleteDialog = true }) {
+                            Icon(Icons.Default.Delete, contentDescription = "Delete")
+                        }
                     }
                 }
             )
@@ -410,79 +426,56 @@ fun SessionDetailScreen(sessionId: String, viewModel: ClimbViewModel, onNavigate
                                     value = "${((successfulAttempts.size.toDouble() / attempts.size) * 100).toInt()}%"
                                 )
                                 
-                                // Show average grade if available
+                            }
-                                val attemptedProblems = problems.filter { it.id in uniqueProblems }
+                            
-                                if (attemptedProblems.isNotEmpty()) {
+                            // Show grade range(s) with better layout
-                                    val boulderProblems = attemptedProblems.filter { it.climbType == ClimbType.BOULDER }
+                            val grades = attemptedProblems.map { it.difficulty }
-                                    val ropeProblems = attemptedProblems.filter { it.climbType == ClimbType.ROPE }
+                            if (grades.isNotEmpty()) {
-                                    
+                                val boulderProblems = attemptedProblems.filter { it.climbType == ClimbType.BOULDER }
-                                    val averageGrade = when {
+                                val ropeProblems = attemptedProblems.filter { it.climbType == ClimbType.ROPE }
-                                        boulderProblems.isNotEmpty() && ropeProblems.isNotEmpty() -> {
+
-                                            val boulderAvg = calculateAverageGrade(boulderProblems)
+                                val boulderRange = if (boulderProblems.isNotEmpty()) {
-                                            val ropeAvg = calculateAverageGrade(ropeProblems)
+                                    val boulderGrades = boulderProblems.map { it.difficulty }
-                                            "${boulderAvg ?: "N/A"} / ${ropeAvg ?: "N/A"}"
+                                    val sorted = boulderGrades.sortedWith { a, b -> a.compareTo(b) }
-                                        }
+                                    "${sorted.first().grade} - ${sorted.last().grade}"
-                                        boulderProblems.isNotEmpty() -> calculateAverageGrade(boulderProblems) ?: "N/A"
+                                } else null
-                                        ropeProblems.isNotEmpty() -> calculateAverageGrade(ropeProblems) ?: "N/A"
+
-                                        else -> "N/A"
+                                val ropeRange = if (ropeProblems.isNotEmpty()) {
+                                    val ropeGrades = ropeProblems.map { it.difficulty }
+                                    val sorted = ropeGrades.sortedWith { a, b -> a.compareTo(b) }
+                                    "${sorted.first().grade} - ${sorted.last().grade}"
+                                } else null
+
+                                if (boulderRange != null && ropeRange != null) {
+                                    Row(
+                                        modifier = Modifier.fillMaxWidth(),
+                                        horizontalArrangement = Arrangement.SpaceEvenly
+                                    ) {
+                                        StatItem(label = "Boulder Range", value = boulderRange)
+                                        StatItem(label = "Rope Range", value = ropeRange)
                                     }
-                                    
-                                    StatItem(
-                                        label = "Average Grade",
-                                        value = averageGrade
-                                    )
                                 } else {
+                                    Row(
+                                        modifier = Modifier.fillMaxWidth(),
+                                        horizontalArrangement = Arrangement.Center
+                                    ) {
+                                        StatItem(
+                                            label = "Grade Range",
+                                            value = boulderRange ?: ropeRange ?: "N/A"
+                                        )
+                                    }
+                                }
+                            } else {
+                                Row(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    horizontalArrangement = Arrangement.Center
+                                ) {
                                     StatItem(
-                                        label = "Average Grade",
+                                        label = "Grade Range",
                                         value = "N/A"
                                     )
                                 }
                             }
-                            
-                            // Show grade range if available
-                            val grades = attemptedProblems.map { it.difficulty }
-                            if (grades.isNotEmpty()) {
-                                // Separate boulder and rope problems
-                                val boulderProblems = attemptedProblems.filter { it.climbType == ClimbType.BOULDER }
-                                val ropeProblems = attemptedProblems.filter { it.climbType == ClimbType.ROPE }
-                                
-                                val gradeRange = when {
-                                    boulderProblems.isNotEmpty() && ropeProblems.isNotEmpty() -> {
-                                        val boulderRange = if (boulderProblems.isNotEmpty()) {
-                                            val boulderGrades = boulderProblems.map { it.difficulty }
-                                            val sortedBoulderGrades = boulderGrades.sortedWith { a, b -> a.compareTo(b) }
-                                            "${sortedBoulderGrades.first().grade} - ${sortedBoulderGrades.last().grade}"
-                                        } else null
-                                        
-                                        val ropeRange = if (ropeProblems.isNotEmpty()) {
-                                            val ropeGrades = ropeProblems.map { it.difficulty }
-                                            val sortedRopeGrades = ropeGrades.sortedWith { a, b -> a.compareTo(b) }
-                                            "${sortedRopeGrades.first().grade} - ${sortedRopeGrades.last().grade}"
-                                        } else null
-                                        
-                                        when {
-                                            boulderRange != null && ropeRange != null -> "$boulderRange / $ropeRange"
-                                            boulderRange != null -> boulderRange
-                                            ropeRange != null -> ropeRange
-                                            else -> "N/A"
-                                        }
-                                    }
-                                    else -> {
-                                        val sortedGrades = grades.sortedWith { a, b -> a.compareTo(b) }
-                                        "${sortedGrades.first().grade} - ${sortedGrades.last().grade}"
-                                    }
-                                }
-                                
-                                StatItem(
-                                    label = "Grade Range",
-                                    value = gradeRange
-                                )
-                            } else {
-                                StatItem(
-                                    label = "Grade Range",
-                                    value = "N/A"
-                                )
-                            }
                         }
                     }
                 }

app/src/main/java/com/atridad/openclimb/ui/theme/CustomIcons.kt

@@ -0,0 +1,25 @@
+package com.atridad.openclimb.ui.theme
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.graphics.vector.path
+import androidx.compose.ui.unit.dp
+
+object CustomIcons {
+    fun Stop(color: Color = Color.Black): ImageVector = ImageVector.Builder(
+        name = "Stop",
+        defaultWidth = 24.dp,
+        defaultHeight = 24.dp,
+        viewportWidth = 24f,
+        viewportHeight = 24f
+    ).path(
+        fill = SolidColor(color)
+    ) {
+        moveTo(6f, 6f)
+        horizontalLineTo(18f)
+        verticalLineTo(18f)
+        horizontalLineTo(6f)
+        close()
+    }.build()
+}

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

@@ -35,40 +35,32 @@ object ImageUtils {
      */
     fun saveImageFromUri(context: Context, imageUri: Uri): String? {
         return try {
-            val inputStream = context.contentResolver.openInputStream(imageUri)
+            // Decode bitmap from a fresh stream to avoid mark/reset dependency
-            inputStream?.use { input ->
+            val originalBitmap = context.contentResolver.openInputStream(imageUri)?.use { input ->
-                // Decode with options to get EXIF data
+                BitmapFactory.decodeStream(input)
-                val options = BitmapFactory.Options().apply {
+            } ?: return null
-                    inJustDecodeBounds = true
+
-                }
+            val orientedBitmap = correctImageOrientation(context, imageUri, originalBitmap)
-                input.reset()
+            val compressedBitmap = compressImage(orientedBitmap)
-                BitmapFactory.decodeStream(input, null, options)
+
-                
+            // Generate unique filename
-                // Reset stream and decode with proper orientation
+            val filename = "${UUID.randomUUID()}.jpg"
-                input.reset()
+            val imageFile = File(getImagesDirectory(context), filename)
-                val originalBitmap = BitmapFactory.decodeStream(input)
+
-                val orientedBitmap = correctImageOrientation(context, imageUri, originalBitmap)
+            // Save compressed image
-                val compressedBitmap = compressImage(orientedBitmap)
+            FileOutputStream(imageFile).use { output ->
-                
+                compressedBitmap.compress(Bitmap.CompressFormat.JPEG, IMAGE_QUALITY, output)
-                // Generate unique filename
-                val filename = "${UUID.randomUUID()}.jpg"
-                val imageFile = File(getImagesDirectory(context), filename)
-                
-                // Save compressed image
-                FileOutputStream(imageFile).use { output ->
-                    compressedBitmap.compress(Bitmap.CompressFormat.JPEG, IMAGE_QUALITY, output)
-                }
-                
-                // Clean up bitmaps
-                originalBitmap.recycle()
-                if (orientedBitmap != originalBitmap) {
-                    orientedBitmap.recycle()
-                }
-                compressedBitmap.recycle()
-                
-                // Return relative path
-                "$IMAGES_DIR/$filename"
             }
+
+            // Clean up bitmaps
+            originalBitmap.recycle()
+            if (orientedBitmap != originalBitmap) {
+                orientedBitmap.recycle()
+            }
+            compressedBitmap.recycle()
+
+            // Return relative path
+            "$IMAGES_DIR/$filename"
         } catch (e: Exception) {
             e.printStackTrace()
             null

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

@@ -24,7 +24,8 @@ object SessionShareUtils {
         val uniqueProblemsCompleted: Int,
         val averageGrade: String?,
         val sessionDuration: String,
-        val topResult: AttemptResult?
+        val topResult: AttemptResult?,
+        val topGrade: String?
     )
     
     fun calculateSessionStats(
@@ -58,6 +59,19 @@ object SessionShareUtils {
             else -> null
         }
         
+        // Determine highest achieved grade (only from completed problems: SUCCESS or FLASH)
+        val completedProblems = problems.filter { it.id in uniqueCompletedProblems }
+        val completedBoulder = completedProblems.filter { it.climbType == ClimbType.BOULDER }
+        val completedRope = completedProblems.filter { it.climbType == ClimbType.ROPE }
+        val topBoulder = highestGradeForProblems(completedBoulder)
+        val topRope = highestGradeForProblems(completedRope)
+        val topGrade = when {
+            topBoulder != null && topRope != null -> "$topBoulder / $topRope"
+            topBoulder != null -> topBoulder
+            topRope != null -> topRope
+            else -> null
+        }
+        
         val duration = if (session.duration != null) "${session.duration}m" else "Unknown"
         val topResult = attempts.maxByOrNull { 
             when (it.result) {
@@ -76,7 +90,8 @@ object SessionShareUtils {
             uniqueProblemsCompleted = uniqueCompletedProblems.size,
             averageGrade = averageGrade,
             sessionDuration = duration,
-            topResult = topResult
+            topResult = topResult,
+            topGrade = topGrade
         )
     }
     
@@ -157,8 +172,8 @@ object SessionShareUtils {
         stats: SessionStats
     ): File? {
         return try {
-            val width = 1080
+            val width = 1242 // 3:4 aspect at higher resolution for better fit
-            val height = 1350
+            val height = 1656
             
             val bitmap = createBitmap(width, height)
             val canvas = Canvas(bitmap)
@@ -212,7 +227,7 @@ object SessionShareUtils {
             }
             
             // Draw main card background
-            val cardRect = RectF(60f, 200f, width - 60f, height - 100f)
+            val cardRect = RectF(60f, 200f, width - 60f, height - 120f)
             canvas.drawRoundRect(cardRect, 40f, 40f, cardPaint)
             
             // Draw content
@@ -233,31 +248,48 @@ object SessionShareUtils {
             // Stats grid
             val statsStartY = yPosition
             val columnWidth = width / 2f
+            val columnMaxTextWidth = columnWidth - 120f
             
             // Left column stats
             var leftY = statsStartY
-            drawStatItem(canvas, columnWidth / 2f, leftY, "Attempts", stats.totalAttempts.toString(), statLabelPaint, statValuePaint)
+            drawStatItemFitting(canvas, columnWidth / 2f, leftY, "Attempts", stats.totalAttempts.toString(), statLabelPaint, statValuePaint, columnMaxTextWidth)
-            leftY += 140f
+            leftY += 120f
-            drawStatItem(canvas, columnWidth / 2f, leftY, "Problems", stats.uniqueProblemsAttempted.toString(), statLabelPaint, statValuePaint)
+            drawStatItemFitting(canvas, columnWidth / 2f, leftY, "Problems", stats.uniqueProblemsAttempted.toString(), statLabelPaint, statValuePaint, columnMaxTextWidth)
-            leftY += 140f
+            leftY += 120f
-            drawStatItem(canvas, columnWidth / 2f, leftY, "Duration", stats.sessionDuration, statLabelPaint, statValuePaint)
+            drawStatItemFitting(canvas, columnWidth / 2f, leftY, "Duration", stats.sessionDuration, statLabelPaint, statValuePaint, columnMaxTextWidth)
             
             // Right column stats
             var rightY = statsStartY
-            drawStatItem(canvas, width - columnWidth / 2f, rightY, "Successful", stats.successfulAttempts.toString(), statLabelPaint, statValuePaint)
+            drawStatItemFitting(canvas, width - columnWidth / 2f, rightY, "Successful", stats.successfulAttempts.toString(), statLabelPaint, statValuePaint, columnMaxTextWidth)
-            rightY += 140f
+            rightY += 120f
-            drawStatItem(canvas, width - columnWidth / 2f, rightY, "Completed", stats.uniqueProblemsCompleted.toString(), statLabelPaint, statValuePaint)
+            drawStatItemFitting(canvas, width - columnWidth / 2f, rightY, "Completed", stats.uniqueProblemsCompleted.toString(), statLabelPaint, statValuePaint, columnMaxTextWidth)
-            rightY += 140f
+            rightY += 120f
             
-            stats.averageGrade?.let { grade ->
+            var rightYAfter = rightY
-                drawStatItem(canvas, width - columnWidth / 2f, rightY, "Avg Grade", grade, statLabelPaint, statValuePaint)
+            stats.topGrade?.let { grade ->
+                drawStatItemFitting(canvas, width - columnWidth / 2f, rightY, "Top Grade", grade, statLabelPaint, statValuePaint, columnMaxTextWidth)
+                rightYAfter += 120f
+            }
+            
+            // Grade range(s)
+            val boulderRange = gradeRangeForProblems(stats.problems.filter { it.climbType == ClimbType.BOULDER })
+            val ropeRange = gradeRangeForProblems(stats.problems.filter { it.climbType == ClimbType.ROPE })
+            val rangesY = kotlin.math.max(leftY, rightYAfter) + 120f
+            if (boulderRange != null && ropeRange != null) {
+                // Two evenly spaced items
+                drawStatItemFitting(canvas, columnWidth / 2f, rangesY, "Boulder Range", boulderRange, statLabelPaint, statValuePaint, columnMaxTextWidth)
+                drawStatItemFitting(canvas, width - columnWidth / 2f, rangesY, "Rope Range", ropeRange, statLabelPaint, statValuePaint, columnMaxTextWidth)
+            } else if (boulderRange != null || ropeRange != null) {
+                // Single centered item
+                val singleRange = boulderRange ?: ropeRange ?: ""
+                drawStatItemFitting(canvas, width / 2f, rangesY, "Grade Range", singleRange, statLabelPaint, statValuePaint, width - 200f)
             }
             
             // Success rate arc
-            if (stats.totalAttempts > 0) {
+            val successRate = if (stats.totalAttempts > 0) {
-                val successRate = (stats.successfulAttempts.toFloat() / stats.totalAttempts) * 100
+                (stats.successfulAttempts.toFloat() / stats.totalAttempts) * 100f
-                drawSuccessRateArc(canvas, width / 2f, height - 280f, successRate, statLabelPaint, statValuePaint)
+            } else 0f
-            }
+            drawSuccessRateArc(canvas, width / 2f, height - 300f, successRate, statLabelPaint, statValuePaint)
             
             // App branding
             val brandingPaint = Paint().apply {
@@ -305,6 +337,41 @@ object SessionShareUtils {
         canvas.drawText(label, x, y + 50f, labelPaint)
     }
     
+    /**
+     * Draws a stat item while fitting the value text to a max width by reducing text size if needed.
+     */
+    private fun drawStatItemFitting(
+        canvas: Canvas,
+        x: Float,
+        y: Float,
+        label: String,
+        value: String,
+        labelPaint: Paint,
+        valuePaint: Paint,
+        maxTextWidth: Float
+    ) {
+        val tempPaint = Paint(valuePaint)
+        var textSize = tempPaint.textSize
+        var textWidth = tempPaint.measureText(value)
+        while (textWidth > maxTextWidth && textSize > 36f) {
+            textSize -= 2f
+            tempPaint.textSize = textSize
+            textWidth = tempPaint.measureText(value)
+        }
+        canvas.drawText(value, x, y, tempPaint)
+        canvas.drawText(label, x, y + 50f, labelPaint)
+    }
+    
+    /**
+     * Returns a range string like "X - Y" for the given problems, based on their difficulty grades.
+     */
+    private fun gradeRangeForProblems(problems: List<Problem>): String? {
+        if (problems.isEmpty()) return null
+        val grades = problems.map { it.difficulty }
+        val sorted = grades.sortedWith { a, b -> a.compareTo(b) }
+        return "${sorted.first().grade} - ${sorted.last().grade}"
+    }
+    
     private fun drawSuccessRateArc(
         canvas: Canvas,
         centerX: Float,
@@ -313,18 +380,18 @@ object SessionShareUtils {
         labelPaint: Paint,
         valuePaint: Paint
     ) {
-        val radius = 80f
+        val radius = 70f
-        val strokeWidth = 16f
+        val strokeWidth = 14f
-        
+
         // Background arc
         val bgPaint = Paint().apply {
-            color = "#40FFFFFF".toColorInt()
+            color = "#30FFFFFF".toColorInt()
             style = Paint.Style.STROKE
             this.strokeWidth = strokeWidth
             isAntiAlias = true
             strokeCap = Paint.Cap.ROUND
         }
-        
+
         // Success arc
         val successPaint = Paint().apply {
             color = "#4CAF50".toColorInt()
@@ -333,20 +400,23 @@ object SessionShareUtils {
             isAntiAlias = true
             strokeCap = Paint.Cap.ROUND
         }
-        
+
         val rect = RectF(centerX - radius, centerY - radius, centerX + radius, centerY + radius)
-        
+
         // Draw background arc (full circle)
         canvas.drawArc(rect, -90f, 360f, false, bgPaint)
-        
+
         // Draw success arc
         val sweepAngle = (successRate / 100f) * 360f
         canvas.drawArc(rect, -90f, sweepAngle, false, successPaint)
-        
+
         // Draw percentage text
         val percentText = "${successRate.roundToInt()}%"
-        canvas.drawText(percentText, centerX, centerY + 10f, valuePaint)
+        canvas.drawText(percentText, centerX, centerY + 8f, valuePaint)
-        canvas.drawText("Success Rate", centerX, centerY + 60f, labelPaint)
+
+        // Draw label below the arc (outside the ring) for better readability
+        val belowLabelPaint = Paint(labelPaint)
+        canvas.drawText("Success Rate", centerX, centerY + radius + 36f, belowLabelPaint)
     }
     
     private fun formatSessionDate(dateString: String): String {
@@ -383,4 +453,48 @@ object SessionShareUtils {
             e.printStackTrace()
         }
     }
+
+    /**
+     * Returns the highest grade string among the given problems, respecting their difficulty system.
+     */
+    private fun highestGradeForProblems(problems: List<Problem>): String? {
+        if (problems.isEmpty()) return null
+        return problems.maxByOrNull { p -> gradeRank(p.difficulty.system, p.difficulty.grade) }?.difficulty?.grade
+    }
+
+    /**
+     * Produces a comparable numeric rank for grades across supported systems.
+     */
+    private fun gradeRank(system: DifficultySystem, grade: String): Double {
+        return when (system) {
+            DifficultySystem.V_SCALE -> {
+                if (grade == "VB") 0.0 else grade.removePrefix("V").toDoubleOrNull() ?: -1.0
+            }
+            DifficultySystem.FONT -> {
+                val list = DifficultySystem.FONT.getAvailableGrades()
+                val idx = list.indexOf(grade.uppercase())
+                if (idx >= 0) idx.toDouble() else grade.filter { it.isDigit() }.toDoubleOrNull() ?: -1.0
+            }
+            DifficultySystem.YDS -> {
+                // Parse 5.X with optional letter a-d
+                val s = grade.lowercase()
+                if (!s.startsWith("5.")) return -1.0
+                val tail = s.removePrefix("5.")
+                val numberPart = tail.takeWhile { it.isDigit() || it == '.' }
+                val letterPart = tail.drop(numberPart.length).firstOrNull()
+                val base = numberPart.toDoubleOrNull() ?: return -1.0
+                val letterWeight = when (letterPart) {
+                    'a' -> 0.0
+                    'b' -> 0.1
+                    'c' -> 0.2
+                    'd' -> 0.3
+                    else -> 0.0
+                }
+                base + letterWeight
+            }
+            DifficultySystem.CUSTOM -> {
+                grade.filter { it.isDigit() || it == '.' || it == '-' }.toDoubleOrNull() ?: -1.0
+            }
+        }
+    }
 }

gradle/libs.versions.toml

@@ -1,10 +1,14 @@
 [versions]
-agp = "8.9.1"
+agp = "8.12.1"
 kotlin = "2.0.21"
 coreKtx = "1.15.0"
 junit = "4.13.2"
 junitVersion = "1.3.0"
 espressoCore = "3.7.0"
+androidxTestCore = "1.6.0"
+androidxTestExt = "1.2.0"
+androidxTestRunner = "1.6.0"
+androidxTestRules = "1.6.0"
 lifecycleRuntimeKtx = "2.9.2"
 activityCompose = "1.10.1"
 composeBom = "2024.09.00"
@@ -21,6 +25,10 @@ androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref =
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
 androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+androidx-test-core = { group = "androidx.test", name = "core", version.ref = "androidxTestCore" }
+androidx-test-ext = { group = "androidx.test.ext", name = "junit", version.ref = "androidxTestExt" }
+androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "androidxTestRunner" }
+androidx-test-rules = { group = "androidx.test", name = "rules", version.ref = "androidxTestRules" }
 androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
 androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
 androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
@@ -48,6 +56,10 @@ kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-
 
 # Coroutines
 kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "kotlinxCoroutines" }
+kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "kotlinxCoroutines" }
+
+# Testing
+mockk = { group = "io.mockk", name = "mockk", version = "1.13.8" }
 
 # Image Loading
 coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Fri Aug 15 11:23:25 MDT 2025
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists