Merge pull request #6 from khashyap0803/claude/audit-2026-10-r5

Keep Home figures on a failed read, count the streak once a day, clean-ups

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: khashyap0803

app/src/main/java/com/example/embeddedsystemscareerguide/AppDate.kt

@@ -32,13 +32,13 @@ object AppDate {
 
     /**
      * True if [dateString] (an ISO-8601 `yyyy-MM-dd` date, as written by [todayIso])
-     * is exactly one calendar day before today. Returns false for a blank, malformed,
+     * is exactly one calendar day before [today]. Returns false for a blank, malformed,
      * or unparseable value rather than throwing.
      */
-    fun isYesterday(dateString: String): Boolean {
+    fun isYesterday(dateString: String, today: LocalDate = LocalDate.now()): Boolean {
         if (dateString.isBlank()) return false
         return try {
-            LocalDate.parse(dateString) == LocalDate.now().minusDays(1)
+            LocalDate.parse(dateString) == today.minusDays(1)
         } catch (e: Exception) {
             false
         }

app/src/main/java/com/example/embeddedsystemscareerguide/MainActivity.kt

@@ -13,20 +13,23 @@ import android.view.View
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.widget.Toolbar
 import androidx.core.view.doOnLayout
+import androidx.lifecycle.lifecycleScope
 import androidx.navigation.NavController
 import androidx.navigation.findNavController
 import androidx.navigation.fragment.NavHostFragment
 import androidx.navigation.ui.AppBarConfiguration
 import androidx.navigation.ui.setupActionBarWithNavController
 import com.example.embeddedsystemscareerguide.databinding.ActivityMainBinding
 import com.example.embeddedsystemscareerguide.services.AuthManager
+import com.example.embeddedsystemscareerguide.services.UserProgressSyncService
 import com.example.embeddedsystemscareerguide.ui.assessment.AssessmentActivity
 import com.example.embeddedsystemscareerguide.ui.auth.LoginActivity
 import com.example.embeddedsystemscareerguide.ui.practice.PracticeContentActivity
 import com.example.embeddedsystemscareerguide.ui.widget.RadialFabMenuView
 import com.google.android.material.appbar.AppBarLayout
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.firebase.auth.FirebaseAuth
+import kotlinx.coroutines.launch
 
 class MainActivity : AppCompatActivity() {
 
@@ -85,6 +88,21 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    override fun onStart() {
+        super.onStart()
+        if (FirebaseAuth.getInstance().currentUser == null) return
+
+        // The daily streak, counted once per calendar day whichever screen is open -
+        // including after the app sat in the background past midnight. It used to be
+        // counted only when Learning Path was opened. Home and Learning Path ask too
+        // before reading progress; whichever asks first does it.
+        lifecycleScope.launch {
+            UserProgressSyncService.streakMessage(UserProgressSyncService(this@MainActivity).recordDailyVisit())?.let {
+                android.widget.Toast.makeText(this@MainActivity, it, android.widget.Toast.LENGTH_LONG).show()
+            }
+        }
+    }
+
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         // Previously built by hand with only a Logout entry, which meant
         // action_settings (and therefore nav_settings / SettingsFragment) was

app/src/main/java/com/example/embeddedsystemscareerguide/services/FirestoreManager.kt

@@ -111,11 +111,6 @@ class FirestoreManager private constructor(private val context: Context) {
         internal fun currentStageOf(stages: List<PersonalizedStage>): PersonalizedStage? =
             stages.firstOrNull { !it.isCompleted } ?: stages.lastOrNull()
 
-        /**
-         * Keeps a failed read apart from an empty path. Callers used to turn a failure
-         * into an empty list, so a network or permission error told the student to
-         * take the assessment.
-         */
         /**
          * Every write a retake makes, for one WriteBatch: reset the stage progress,
          * delete the old stages the new path doesn't reuse, save the new stages. A set
@@ -133,6 +128,11 @@ class FirestoreManager private constructor(private val context: Context) {
                 newStages.map { RetakeWrite.SaveStage(it) }
         }
 
+        /**
+         * Keeps a failed read apart from an empty path. Callers used to turn a failure
+         * into an empty list, so a network or permission error told the student to
+         * take the assessment.
+         */
         internal fun pathReadOf(read: Result<List<PersonalizedStage>>): PathRead {
             val stages = read.getOrElse {
                 // getPersonalizedStages hands a cancellation back as a failed Result.
@@ -552,30 +552,6 @@ class FirestoreManager private constructor(private val context: Context) {
         }
     }
 
-    /**
-     * Delete all personalized stages (for regeneration)
-     */
-    suspend fun deleteAllPersonalizedStages(): Boolean = withContext(Dispatchers.IO) {
-        try {
-            val username = getCurrentUsername()
-            val stagesRef = getUserDocRef(username).collection(COLLECTION_PERSONALIZED_STAGES)
-            
-            val docs = stagesRef.get().await()
-            val batch = firestore.batch()
-            
-            docs.documents.forEach { doc ->
-                batch.delete(doc.reference)
-            }
-            
-            batch.commit().await()
-            Log.d(TAG, "Deleted ${docs.size()} personalized stages")
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error deleting stages", e)
-            false
-        }
-    }
-
     // ==================== STAGE CONTENT ====================
 
     /**

app/src/main/java/com/example/embeddedsystemscareerguide/services/GeminiChallengeService.kt

@@ -263,7 +263,7 @@ DO NOT include comments - students should order pure code blocks.
                     )
                 }.shuffled() // Shuffle for the challenge
 
-            Log.i(TAG, "Generated ${result.size} code blocks for problem: $problemStatement")
+            Log.i(TAG, "Generated ${result.size} code blocks for a ${problemStatement.length}-char problem")
             Result.success(result)
         } catch (e: Exception) {
             Log.e(TAG, "Failed to generate code blocks", e)
@@ -1147,7 +1147,8 @@ Return ONLY this JSON (no markdown, no explanation):
         }
 
         if (finalStart == -1 || finalEnd == -1 || finalStart >= finalEnd) {
-            Log.e(TAG, "No valid JSON array found. Cleaned response: ${cleaned.take(500)}")
+            // The reply's length, not its text: Log.e survives R8 into release builds.
+            Log.e(TAG, "No valid JSON array found in the response (${cleaned.length} chars)")
             throw Exception("Invalid JSON array in response. No array brackets found.")
         }
 
@@ -1177,7 +1178,7 @@ Return ONLY this JSON (no markdown, no explanation):
         val start = cleaned.indexOf('{')
         val end = cleaned.lastIndexOf('}')
         if (start == -1 || end == -1 || start >= end) {
-            Log.e(TAG, "No valid JSON object found. Cleaned response: $cleaned")
+            Log.e(TAG, "No valid JSON object found in the response (${cleaned.length} chars)")
             throw Exception("Invalid JSON object in response")
         }
         return cleaned.substring(start, end + 1)

app/src/main/java/com/example/embeddedsystemscareerguide/services/GeminiQuizService.kt

@@ -290,8 +290,8 @@ Generate 5 SHORT questions now:
             val type = object : TypeToken<List<QuizQuestion>>() {}.type
             parsedQuestions = gson.fromJson(cleanJson, type)
         } catch (e: Exception) {
-            Log.e(TAG, "Error parsing quiz response: ${e.message}")
-            Log.e(TAG, "Raw response (first 500 chars): ${response.take(500)}")
+            // The reply's length, not its text: Log.e survives R8 into release builds.
+            Log.e(TAG, "Error parsing quiz response (${response.length} chars): ${e.message}")
 
             // Try an alternative parsing approach - parse question by question
             try {

app/src/main/java/com/example/embeddedsystemscareerguide/services/UserProgressSyncService.kt

@@ -7,10 +7,15 @@ import com.example.embeddedsystemscareerguide.AppConstants
 import com.google.firebase.auth.FirebaseAuth
 import com.google.firebase.firestore.FirebaseFirestore
 import com.google.firebase.firestore.SetOptions
+import com.example.embeddedsystemscareerguide.AppDate
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.tasks.await
 import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.withTimeoutOrNull
+import java.time.LocalDate
 
 /**
  * Service for syncing user progress data between local SharedPreferences and Firebase Firestore.
@@ -84,6 +89,89 @@ class UserProgressSyncService(private val context: Context) {
             "lastUpdated" to now
         )
 
+        /**
+         * The once-a-day streak rule, unchanged from LearningPathFragment: a first
+         * visit keeps the stored streak (at least 1), a second visit the same day
+         * changes nothing, the day after the last visit adds 1, and a longer gap
+         * starts again at 1. The best streak only ever goes up. Null when there is
+         * nothing to write.
+         */
+        internal fun dailyStreak(progress: UserProgress, today: LocalDate): StreakUpdate? {
+            val todayIso = today.toString()
+            val lastVisit = progress.lastVisitDate
+            val consecutive = AppDate.isYesterday(lastVisit, today)
+            val newStreak = when {
+                lastVisit.isEmpty() -> progress.streak.coerceAtLeast(1)
+                lastVisit == todayIso -> progress.streak
+                consecutive -> progress.streak + 1
+                else -> 1
+            }
+            val newBest = maxOf(newStreak, progress.bestStreak)
+            if (newStreak == progress.streak && newBest == progress.bestStreak && lastVisit == todayIso) return null
+            return StreakUpdate(
+                previous = progress.streak,
+                streak = newStreak,
+                bestStreak = newBest,
+                date = todayIso,
+                broken = lastVisit.isNotEmpty() && lastVisit != todayIso && !consecutive
+            )
+        }
+
+        /**
+         * How long the daily update waits for Firestore to confirm the streak write.
+         * Offline a write never confirms, but it is already in the local cache and is
+         * sent on reconnect - and Home and Learning Path wait on this before reading.
+         */
+        internal const val STREAK_SAVE_WAIT_MS = 3_000L
+
+        // Which student's day has been counted, as "username|yyyy-MM-dd". Process-wide,
+        // because each screen makes its own UserProgressSyncService.
+        private val dailyVisitLock = Mutex()
+        private var dailyVisitCounted: String? = null
+
+        /**
+         * Counts today's visit for [key]'s student once: MainActivity asks whenever it
+         * starts, and Home and Learning Path ask before they read progress, so
+         * whichever comes first does the update and the others wait for it and then
+         * find it done. A failed read writes nothing and is tried again next time.
+         *
+         * @return the update, to the one caller that made it; null otherwise
+         */
+        internal suspend fun recordDailyVisit(
+            key: String,
+            today: LocalDate,
+            load: suspend () -> ProgressLoad,
+            save: suspend (StreakUpdate) -> Boolean,
+            saveWaitMs: Long = STREAK_SAVE_WAIT_MS
+        ): StreakUpdate? = dailyVisitLock.withLock {
+            val counted = "$key|$today"
+            if (dailyVisitCounted == counted) return null
+            val progress = when (val read = load()) {
+                is ProgressLoad.Loaded -> read.progress
+                ProgressLoad.Absent -> UserProgress()
+                is ProgressLoad.Failed -> return null
+            }
+            val update = dailyStreak(progress, today)
+            // Unconfirmed after saveWaitMs counts as made: see STREAK_SAVE_WAIT_MS.
+            if (update != null && withTimeoutOrNull(saveWaitMs) { save(update) } == false) return null
+            dailyVisitCounted = counted
+            update
+        }
+
+        /** The toast for a streak update, as Learning Path used to show it, or null for none. */
+        fun streakMessage(update: StreakUpdate?): String? = when {
+            update == null -> null
+            update.broken && update.previous > 1 ->
+                "🔥 Previous streak: ${update.previous} days\nStarting fresh! Let's build a new streak!"
+            update.streak > update.previous -> when (update.streak) {
+                7 -> "🔥 1 WEEK STREAK! Amazing dedication!"
+                14 -> "🔥 2 WEEK STREAK! You're unstoppable!"
+                30 -> "🔥 30 DAY STREAK! Legendary commitment!"
+                else -> if (update.streak % 10 == 0) "🔥 ${update.streak} DAY STREAK! Keep it up!" else null
+            }
+            else -> null
+        }
+
         /**
          * The fields a retake's progress reset writes - and the only ones. XP and
          * the streak are left alone, so the reset needs no read first and can go
@@ -307,6 +395,29 @@ class UserProgressSyncService(private val context: Context) {
         }
     }
 
+    /** Today's streak, as [dailyStreak] works it out. */
+    data class StreakUpdate(
+        val previous: Int,
+        val streak: Int,
+        val bestStreak: Int,
+        val date: String,
+        val broken: Boolean
+    )
+
+    /**
+     * Counts today's visit: the daily streak update, once per calendar day per student.
+     * See the companion's recordDailyVisit.
+     */
+    suspend fun recordDailyVisit(): StreakUpdate? {
+        val username = getCurrentUsername() ?: return null
+        return recordDailyVisit(
+            key = username,
+            today = LocalDate.now(),
+            load = { loadProgressResult() },
+            save = { saveStreak(it.streak, it.bestStreak, it.date) }
+        )
+    }
+
     /**
      * Outcome of a cloud progress read.
      *