settings: keep un-flushed edits across reload

reload() clobbered in-memory mutations with the on-disk copy when the
debounced save had not flushed yet, silently reverting font, text size,
colors, etc. It now flushes pending writes instead of re-reading while a
save is pending, and only re-reads external changes when nothing is
pending. Completes commit 201e2b5, which only guarded the sdCardRoot
setter. Also routes the previously silent saveToDisk failures to error.log.

Author: BrandonKowalski

app/src/main/java/dev/cannoli/scorza/settings/SettingsRepository.kt

@@ -31,6 +31,12 @@ class SettingsRepository @Inject constructor(@ApplicationContext private val con
     private val saveHandler = Handler(saveThread.looper)
     private val saveRunnable = Runnable { saveToDisk() }
 
+    // True while an in-memory mutation has not yet been persisted. reload() must not
+    // clobber the json with the on-disk copy while this is set, or un-flushed edits
+    // are lost (the bug behind font/text-size/color changes silently reverting).
+    @Volatile
+    private var pendingSave = false
+
     private inline fun <T> jsonRead(block: JSONObject.() -> T): T = synchronized(jsonLock) { json.block() }
     private inline fun jsonWrite(block: JSONObject.() -> Unit) { synchronized(jsonLock) { json.block() }; scheduleSave() }
 
@@ -68,6 +74,7 @@ class SettingsRepository @Inject constructor(@ApplicationContext private val con
     }
 
     private fun scheduleSave() {
+        pendingSave = true
         saveHandler.removeCallbacks(saveRunnable)
         saveHandler.postDelayed(saveRunnable, 100)
     }
@@ -83,13 +90,22 @@ class SettingsRepository @Inject constructor(@ApplicationContext private val con
 
     private fun saveToDisk() {
         settingsFile?.let { file ->
-            if (!setupCompleted) return
-            if (!hasStoragePermission()) return
+            if (!setupCompleted) {
+                dev.cannoli.scorza.util.ErrorLog.write("settings save skipped: setup not completed (${file.absolutePath})")
+                return
+            }
+            if (!hasStoragePermission()) {
+                dev.cannoli.scorza.util.ErrorLog.write("settings save skipped: no storage permission (${file.absolutePath})")
+                return
+            }
             try {
                 file.parentFile?.mkdirs()
                 synchronized(jsonLock) { file.writeText(json.toString(2)) }
-            } catch (_: IOException) {
-            } catch (_: SecurityException) {
+                pendingSave = false
+            } catch (e: IOException) {
+                dev.cannoli.scorza.util.ErrorLog.error("settings save failed writing ${file.absolutePath}", e)
+            } catch (e: SecurityException) {
+                dev.cannoli.scorza.util.ErrorLog.error("settings save failed writing ${file.absolutePath}", e)
             }
         }
     }
@@ -100,7 +116,9 @@ class SettingsRepository @Inject constructor(@ApplicationContext private val con
     }
 
     fun reload() {
-        loadFromDisk()
+        // Un-flushed local edits are newer than disk; persist them rather than letting
+        // loadFromDisk overwrite them. Only re-read external changes when nothing is pending.
+        if (pendingSave) flush() else loadFromDisk()
     }
 
     fun shutdown() {

app/src/test/java/dev/cannoli/scorza/settings/SettingsRepositoryTest.kt

@@ -0,0 +1,54 @@
+package dev.cannoli.scorza.settings
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class SettingsRepositoryTest {
+
+    @get:Rule val tmp = TemporaryFolder()
+
+    private fun newRepo() = SettingsRepository(ApplicationProvider.getApplicationContext<Context>())
+
+    private fun writeSettingsJson(root: File, json: String) {
+        File(root, "Config").apply { mkdirs() }
+        File(root, "Config/settings.json").writeText(json)
+    }
+
+    @Test fun `reload keeps un-flushed in-memory edits instead of reverting to disk`() {
+        writeSettingsJson(tmp.root, """{"font":"old"}""")
+        val settings = newRepo()
+        settings.sdCardRoot = tmp.root.absolutePath
+        assertEquals("old", settings.font)
+
+        // Edit with the debounced save still pending; disk continues to hold "old".
+        // reload() must not let loadFromDisk clobber the newer in-memory value.
+        settings.font = "new"
+        settings.reload()
+
+        assertEquals("new", settings.font)
+    }
+
+    @Test fun `reload picks up external disk changes when nothing is pending`() {
+        writeSettingsJson(tmp.root, """{"font":"old"}""")
+        val settings = newRepo()
+        settings.sdCardRoot = tmp.root.absolutePath
+        assertEquals("old", settings.font)
+
+        // No pending local edit: a clean reload should still surface a file an
+        // external writer (e.g. the Kitchen web UI) changed underneath us.
+        writeSettingsJson(tmp.root, """{"font":"external"}""")
+        settings.reload()
+
+        assertEquals("external", settings.font)
+    }
+}