Autocompletion fallback

app/src/main/java/be/scri/App.kt

@@ -17,6 +17,7 @@ import androidx.compose.foundation.pager.HorizontalPager
 import androidx.compose.foundation.pager.PagerState
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
@@ -38,7 +39,9 @@ import be.scri.ui.screens.SelectTranslationSourceLanguageScreen
 import be.scri.ui.screens.ThirdPartyScreen
 import be.scri.ui.screens.WikimediaScreen
 import be.scri.ui.screens.about.AboutScreen
+import be.scri.ui.screens.download.CheckUpdateActions
 import be.scri.ui.screens.download.DataDownloadViewModel
+import be.scri.ui.screens.download.DownloadActions
 import be.scri.ui.screens.download.DownloadDataScreen
 import be.scri.ui.screens.settings.SettingsScreen
 import be.scri.ui.theme.ScribeTheme
@@ -82,8 +85,21 @@ fun ScribeApp(
     val downloadStates = downloadViewModel.downloadStates
     val onDownloadAction = downloadViewModel::handleDownloadAction
     val onDownloadAll = downloadViewModel::handleDownloadAllLanguages
-    val inititalizeStates = downloadViewModel::initializeStates
-    val checkAllForUpdates = downloadViewModel::checkAllForUpdates
+    val initializeStates = downloadViewModel::initializeStates
+    val downloadActions =
+        DownloadActions(
+            downloadStates = downloadStates,
+            onDownloadAction = onDownloadAction,
+            onDownloadAll = onDownloadAll,
+            initializeStates = initializeStates,
+        )
+    val checkUpdateState by downloadViewModel.checkUpdateState.collectAsState()
+    val checkUpdateActions =
+        CheckUpdateActions(
+            checkUpdateState = checkUpdateState,
+            checkForNewData = downloadViewModel::checkForNewData,
+            cancelCheckForNewData = downloadViewModel::cancelCheckForNewData,
+        )
 
     ScribeTheme(
         useDarkTheme = isDarkTheme,
@@ -213,11 +229,9 @@ fun ScribeApp(
                                 "translation_language_detail/$language",
                             )
                         },
-                        downloadStates = downloadStates,
-                        onDownloadAction = onDownloadAction,
-                        onDownloadAll = onDownloadAll,
-                        initializeStates = inititalizeStates,
-                        checkAllForUpdates = checkAllForUpdates,
+                        isDarkTheme = isDarkTheme,
+                        downloadActions = downloadActions,
+                        checkUpdateActions = checkUpdateActions,
                         modifier = Modifier.padding(innerPadding),
                     )
                 }

app/src/main/java/be/scri/data/remote/DynamicDbHelper.kt

@@ -17,7 +17,7 @@ import be.scri.data.model.DataResponse
 class DynamicDbHelper(
     context: Context,
     language: String,
-) : SQLiteOpenHelper(context, "$language.db", null, 1) {
+) : SQLiteOpenHelper(context, "${language.uppercase()}LanguageData.sqlite", null, 1) {
     override fun onCreate(db: SQLiteDatabase) {
         // Tables are created dynamically via syncDatabase from API contract.
     }
@@ -36,35 +36,34 @@ class DynamicDbHelper(
      */
     fun syncDatabase(response: DataResponse) {
         val db = writableDatabase
+        try {
+            db.beginTransaction()
 
-        // Create Tables.
-        response.contract.fields.forEach { (tableName, columns) ->
-            val colDefinition = columns.keys.joinToString(", ") { "$it TEXT" }
-            db.execSQL("CREATE TABLE IF NOT EXISTS $tableName (id INTEGER PRIMARY KEY AUTOINCREMENT, $colDefinition)")
-            db.execSQL("DELETE FROM $tableName") // clear old data
-        }
+            response.contract.fields.forEach { (tableName, columns) ->
+                val colDefinition = columns.keys.joinToString(", ") { "$it TEXT" }
+                db.execSQL("DROP TABLE IF EXISTS $tableName")
+                db.execSQL(
+                    "CREATE TABLE $tableName " +
+                        "(id INTEGER PRIMARY KEY AUTOINCREMENT, $colDefinition)",
+                )
+            }
 
-        // Insert Data with Transaction.
-        db.beginTransaction()
-        try {
             response.data.forEach { (tableName, rows) ->
-
+                val cv = ContentValues()
                 rows.forEach { row ->
-                    val cv = ContentValues()
+                    cv.clear()
                     row.forEach { (key, value) ->
                         cv.put(key, value?.toString() ?: "")
                     }
-                    val result = db.insert(tableName, null, cv)
-                    if (result == -1L) {
-                        Log.e("SCRIBE_DB", "Failed to insert row into $tableName")
-                    }
+                    db.insert(tableName, null, cv)
                 }
             }
             db.setTransactionSuccessful()
         } catch (e: SQLiteException) {
             Log.e("SCRIBE_DB", "Error during insert: ${e.message}")
         } finally {
             db.endTransaction()
+            db.close()
         }
     }
 }

app/src/main/java/be/scri/helpers/DatabaseFileManager.kt

@@ -37,7 +37,19 @@ class DatabaseFileManager(
      */
     fun getLanguageDatabase(language: String): SQLiteDatabase? {
         val dbName = "${language}LanguageData.sqlite"
-        return getDatabase(dbName, "data/$dbName")
+        val dbFile = context.getDatabasePath(dbName)
+
+        if (!dbFile.exists()) {
+            Log.w(TAG, "Database $dbName not found. User needs to download data first")
+            return null
+        }
+
+        return try {
+            SQLiteDatabase.openDatabase(dbFile.path, null, SQLiteDatabase.OPEN_READONLY)
+        } catch (e: SQLiteException) {
+            Log.e(TAG, "Failed to open database $dbName", e)
+            null
+        }
     }
 
     /**

app/src/main/java/be/scri/helpers/data/AutoSuggestionDataManager.kt

@@ -17,6 +17,7 @@ class AutoSuggestionDataManager(
         val suggestionMap = HashMap<String, List<String>>()
         val columnsToSelect = listOf("word", "autosuggestion_0", "autosuggestion_1", "autosuggestion_2")
 
+        if (!db.tableExists("autosuggestions")) return suggestionMap
         db.rawQuery("SELECT * FROM autosuggestions LIMIT 1", null).use { tempCursor ->
             for (column in columnsToSelect) {
                 if (tempCursor.getColumnIndex(column) == -1) {

app/src/main/java/be/scri/helpers/data/AutocompletionDataManager.kt

@@ -7,32 +7,62 @@ import be.scri.helpers.DatabaseFileManager
  * This class manages the autocomplete system.
  * It loads words from a language-specific SQLite database,
  * and stores them in a Trie data structure for fast prefix-based lookup.
+ * If the `autocomplete_lexicon` table/Trie is not available, it falls back to caching all noun words.
  */
 class AutocompletionDataManager(
     private val fileManager: DatabaseFileManager,
 ) {
     private val trie = Trie()
+    private var trieLoaded = false
+    private val nounWords = mutableListOf<String>()
 
     /**
      * Loads all words from the language-specific database into the trie.
+     * If the `autocomplete_lexicon` table/Trie is not present, it loads noun words from the specified columns instead.
      *
      * @param language The language code (e.g. "en", "id") for which to load words.
+     * @param numbersColumns Column names from the contract's `numbers` map.
      */
-    fun loadWords(language: String) {
-        val db = fileManager.getLanguageDatabase(language)
-        db?.rawQuery("SELECT word FROM autocomplete_lexicon", null).use { cursor ->
-            val wordIndex = cursor!!.getColumnIndex("word")
-            while (cursor.moveToNext()) {
-                val word = cursor.getString(wordIndex)?.lowercase()?.trim()
-                if (!word.isNullOrEmpty()) {
-                    trie.insert(word)
+    fun loadWords(
+        language: String,
+        numbersColumns: List<String> = emptyList(),
+    ) {
+        val db = fileManager.getLanguageDatabase(language) ?: return
+
+        db.use { database ->
+            if (database.tableExists("autocomplete_lexicon")) {
+                database.rawQuery("SELECT word FROM autocomplete_lexicon", null).use { cursor ->
+                    val wordIndex = cursor.getColumnIndex("word")
+                    while (cursor.moveToNext()) {
+                        val word = cursor.getString(wordIndex)?.lowercase()?.trim()
+                        if (!word.isNullOrEmpty()) {
+                            trie.insert(word)
+                        }
+                    }
+                }
+                trieLoaded = true
+            } else if (database.tableExists("nouns") && numbersColumns.isNotEmpty()) {
+                val unionQuery =
+                    numbersColumns.joinToString(" UNION ") { column ->
+                        "SELECT DISTINCT $column AS word FROM nouns WHERE $column IS NOT NULL AND $column != ''"
+                    } + " ORDER BY word ASC"
+
+                database.rawQuery(unionQuery, null).use { cursor ->
+                    val wordIndex = cursor.getColumnIndex("word")
+                    while (cursor.moveToNext()) {
+                        val word = cursor.getString(wordIndex)?.lowercase()?.trim()
+                        if (!word.isNullOrEmpty()) {
+                            nounWords.add(word)
+                        }
+                    }
                 }
             }
         }
     }
 
     /**
      * Returns autocomplete suggestions for a given prefix.
+     * Uses the Trie if loaded, otherwise filters the cached noun word list.
      *
      * @param prefix The starting text to search for (e.g. "ap").
      * @param limit  The maximum number of suggestions to return (default: 3).
@@ -42,5 +72,24 @@ class AutocompletionDataManager(
     fun getAutocompletions(
         prefix: String,
         limit: Int = 3,
-    ): List<String> = trie.searchPrefix(prefix, limit)
+    ): List<String> =
+        if (trieLoaded) {
+            trie.searchPrefix(prefix, limit)
+        } else {
+            getAutocompletionsFromNouns(prefix, limit)
+        }
+
+    /**
+     * Filters the cached noun word list to find matches that start with the given prefix.
+     */
+    private fun getAutocompletionsFromNouns(
+        prefix: String,
+        limit: Int,
+    ): List<String> {
+        if (nounWords.isEmpty() || prefix.isBlank()) return emptyList()
+        val normalizedPrefix = prefix.lowercase().trim()
+        return nounWords
+            .filter { it.startsWith(normalizedPrefix) }
+            .take(limit)
+    }
 }

app/src/main/java/be/scri/helpers/data/ConjugateDataManager.kt

@@ -92,6 +92,15 @@ class ConjugateDataManager(
     ): String {
         if (form.isNullOrEmpty()) return ""
         return fileManager.getLanguageDatabase(language)?.use { db ->
+            if (!db.tableExists("verbs")) {
+                return ""
+            }
+
+            val columnName = if (language == "SV") "verb" else "infinitive"
+            if (!db.columnExists("verbs", columnName)) {
+                return ""
+            }
+
             getVerbCursor(db, word, language)?.use { cursor ->
                 getConjugatedValueFromCursor(cursor, form, language)
             }

app/src/main/java/be/scri/helpers/data/EmojiDataManager.kt

@@ -29,6 +29,8 @@ class EmojiDataManager(
         val db = fileManager.getLanguageDatabase(language) ?: return emojiMap
 
         db.use {
+            if (!it.tableExists("emoji_keywords")) return emojiMap
+
             it.rawQuery("SELECT MAX(LENGTH(word)) FROM emoji_keywords", null).use { cursor ->
                 if (cursor.moveToFirst()) {
                     maxKeywordLength = cursor.getInt(0)

app/src/main/java/be/scri/helpers/data/PrepositionDataManager.kt

@@ -28,6 +28,7 @@ class PrepositionDataManager(
             return hashMapOf()
         }
         return fileManager.getLanguageDatabase(language)?.use { db ->
+            if (!db.tableExists("prepositions")) return@use hashMapOf()
             db.rawQuery("SELECT preposition, grammaticalCase FROM prepositions", null).use { cursor ->
                 processCursor(cursor)
             } // handle case where cursor is null

app/src/main/java/be/scri/helpers/data/SQLiteExtensions.kt

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package be.scri.helpers.data
+
+import android.database.sqlite.SQLiteDatabase
+
+fun SQLiteDatabase.tableExists(tableName: String): Boolean =
+    rawQuery(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='$tableName'",
+        null,
+    ).use { it.moveToFirst() }
+
+fun SQLiteDatabase.columnExists(
+    tableName: String,
+    columnName: String,
+): Boolean =
+    rawQuery("PRAGMA table_info($tableName)", null).use { cursor ->
+        if (cursor.moveToFirst()) {
+            val nameIndex = cursor.getColumnIndex("name")
+            do {
+                if (cursor.getString(nameIndex) == columnName) {
+                    return true
+                }
+            } while (cursor.moveToNext())
+        }
+        false
+    }

app/src/main/java/be/scri/services/GeneralKeyboardIME.kt

@@ -502,7 +502,11 @@ abstract class GeneralKeyboardIME(
                 ?.toSet()
         nounKeywords = dbManagers.genderManager.findGenderOfWord(languageAlias, dataContract)
         suggestionWords = dbManagers.suggestionManager.getSuggestions(languageAlias)
-        autocompletionManager.loadWords(languageAlias)
+        val numbersColumns =
+            dataContract?.numbers?.let { map ->
+                (map.keys + map.values).distinct()
+            } ?: emptyList()
+        autocompletionManager.loadWords(languageAlias, numbersColumns)
         caseAnnotation = dbManagers.prepositionManager.getCaseAnnotations(languageAlias)
 
         val tempConjugateOutput = dbManagers.conjugateDataManager.getTheConjugateLabels(languageAlias, dataContract, "describe")