Code cleanup, dep updates etc (#535)

Author: urikdev

app/build.gradle.kts

@@ -2,7 +2,6 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     id("com.android.application")
-    id("org.jetbrains.kotlin.android")
     id("org.jetbrains.kotlin.plugin.serialization")
     id("com.google.devtools.ksp")
     id("com.google.dagger.hilt.android")

app/src/main/java/com/urik/keyboard/KeyboardConstants.kt

@@ -3,7 +3,6 @@ package com.urik.keyboard
 object KeyboardConstants {
     object CacheConstants {
         const val PROCESSING_CACHE_MAX_SIZE = 200
-        const val PROCESSING_CACHE_CLEANUP_THRESHOLD = 250
         const val CACHE_TTL_MS = 300000L
 
         const val SUGGESTION_CACHE_SIZE = 500
@@ -65,12 +64,10 @@ object KeyboardConstants {
         const val COMPLETION_LENGTH_WEIGHT = 0.70
         const val COMPLETION_FREQUENCY_WEIGHT = 0.30
         const val COMPLETION_CONFIDENCE_MIN = 0.50
-        const val COMPLETION_CONFIDENCE_MAX = 0.84
 
         const val SYMSPELL_DISTANCE_WEIGHT = 0.45
         const val SYMSPELL_FREQUENCY_WEIGHT = 0.05
         const val SYMSPELL_CONFIDENCE_MIN = 0.0
-        const val SYMSPELL_CONFIDENCE_MAX = 0.70
         const val MAX_DICT_FREQUENCY = 30_000_000.0
 
         const val SAME_LENGTH_BONUS = 0.10
@@ -224,13 +221,10 @@ object KeyboardConstants {
         const val MAX_WORD_INPUT_LENGTH = 50
         const val MAX_CURSOR_POSITION_CHARS = 1000
         const val WORD_BOUNDARY_CONTEXT_LENGTH = 64
-        const val PARAGRAPH_CONTEXT_LENGTH = 256
     }
 
     object SelectionTrackingConstants {
         const val NON_SEQUENTIAL_JUMP_THRESHOLD = 5
-        const val CURSOR_VALIDATION_TOLERANCE = 1
-        const val MAX_COMPOSING_REGION_VALIDATION_DELAY_MS = 50L
     }
 
     object InputTimingConstants {

app/src/main/java/com/urik/keyboard/UrikInputMethodService.kt

@@ -1,7 +1,6 @@
 package com.urik.keyboard
 
 import android.annotation.SuppressLint
-import android.content.Context
 import android.graphics.Color
 import android.inputmethodservice.InputMethodService
 import android.os.Build
@@ -147,7 +146,7 @@ class UrikInputMethodService :
     private var postureDetector: com.urik.keyboard.service.PostureDetector? = null
 
     private val inputMethodManager: android.view.inputmethod.InputMethodManager by lazy {
-        getSystemService(Context.INPUT_METHOD_SERVICE) as android.view.inputmethod.InputMethodManager
+        getSystemService(INPUT_METHOD_SERVICE) as android.view.inputmethod.InputMethodManager
     }
 
     private var serviceJob = SupervisorJob()
@@ -423,7 +422,6 @@ class UrikInputMethodService :
      * Learns word and invalidates relevant caches.
      *
      * @param word Word to learn
-     * @param inputMethod Source of the word (TYPED, SWIPED, SELECTED_FROM_SUGGESTION)
      * @return True if learning succeeded or is disabled
      */
     private suspend fun recordWordUsage(word: String) {
@@ -2455,7 +2453,7 @@ class UrikInputMethodService :
         if (wordStart < 0) return null
 
         if (paragraphBoundary >= 0) {
-            val paragraphStartInText = textBeforeCursor.length - textInParagraph.length
+            textBeforeCursor.length - textInParagraph.length
             val absoluteParagraphBoundary = cursorPosition - textInParagraph.length
             if (wordStart < absoluteParagraphBoundary) {
                 return null
@@ -2465,15 +2463,6 @@ class UrikInputMethodService :
         return Triple(wordStart, cursorPosition, word)
     }
 
-    /**
-     * Extracts word before cursor using boundary detection.
-     *
-     * @param textBeforeCursor Text before cursor position
-     * @return Pair of (word, boundary index) or null if no valid word found
-     */
-    private fun extractWordBeforeCursor(textBeforeCursor: String): Pair<String, Int>? =
-        BackspaceUtils.extractWordBeforeCursor(textBeforeCursor)
-
     /**
      * Handles space key press.
      */
@@ -3106,6 +3095,8 @@ class UrikInputMethodService :
 
     override fun onDestroy() {
         serviceJob.cancel()
+        serviceJob = SupervisorJob()
+        serviceScope = CoroutineScope(Dispatchers.Main + serviceJob)
 
         observerJobs.forEach { it.cancel() }
         observerJobs.clear()

app/src/main/java/com/urik/keyboard/data/WordFrequencyRepository.kt

@@ -9,12 +9,32 @@ import com.urik.keyboard.utils.CacheMemoryManager
 import com.urik.keyboard.utils.ErrorLogger
 import com.urik.keyboard.utils.ManagedCache
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import javax.inject.Singleton
 
+private data class PendingFrequencyUpdate(
+    val languageTag: String,
+    val wordNormalized: String,
+    var incrementCount: Int = 1,
+)
+
+private data class PendingBigramUpdate(
+    val languageTag: String,
+    val wordANormalized: String,
+    val wordBNormalized: String,
+    var incrementCount: Int = 1,
+)
+
 @Singleton
 class WordFrequencyRepository
     @Inject
@@ -41,6 +61,18 @@ class WordFrequencyRepository
         @Volatile
         private var topBigramsCache = ConcurrentHashMap<String, Map<String, List<String>>>()
 
+        private val writeScope = CoroutineScope(SupervisorJob() + ioDispatcher)
+        private var frequencyFlushJob: Job? = null
+        private var bigramFlushJob: Job? = null
+        private val frequencyWriteMutex = Mutex()
+        private val bigramWriteMutex = Mutex()
+        private val pendingFrequencyUpdates = ConcurrentHashMap<String, PendingFrequencyUpdate>()
+        private val pendingBigramUpdates = ConcurrentHashMap<String, PendingBigramUpdate>()
+
+        private companion object {
+            const val WRITE_DEBOUNCE_MS = 300L
+        }
+
         private fun normalizeWord(
             word: String,
             languageTag: String,
@@ -51,38 +83,67 @@ class WordFrequencyRepository
             normalizedWord: String,
         ): String = "${languageTag}_$normalizedWord"
 
-        suspend fun incrementFrequency(
+        fun incrementFrequency(
             word: String,
             languageTag: String,
-        ): Result<Unit> =
-            withContext(ioDispatcher) {
-                try {
-                    if (word.isBlank()) {
-                        return@withContext Result.success(Unit)
-                    }
+        ): Result<Unit> {
+            if (word.isBlank()) {
+                return Result.success(Unit)
+            }
 
-                    val normalized = normalizeWord(word, languageTag)
-                    val cacheKey = buildCacheKey(languageTag, normalized)
+            val normalized = normalizeWord(word, languageTag)
+            val cacheKey = buildCacheKey(languageTag, normalized)
 
-                    userWordFrequencyDao.incrementFrequency(
-                        languageTag = languageTag,
-                        wordNormalized = normalized,
-                        lastUsed = System.currentTimeMillis(),
-                    )
+            frequencyCache.invalidate(cacheKey)
 
-                    frequencyCache.invalidate(cacheKey)
+            pendingFrequencyUpdates.compute(cacheKey) { _, existing ->
+                existing?.apply { incrementCount++ }
+                    ?: PendingFrequencyUpdate(languageTag, normalized)
+            }
 
-                    Result.success(Unit)
-                } catch (e: Exception) {
-                    ErrorLogger.logException(
-                        component = "WordFrequencyRepository",
-                        severity = ErrorLogger.Severity.HIGH,
-                        exception = e,
-                        context = mapOf("operation" to "incrementFrequency"),
-                    )
-                    Result.failure(e)
+            scheduleFrequencyFlush()
+
+            return Result.success(Unit)
+        }
+
+        private fun scheduleFrequencyFlush() {
+            frequencyFlushJob?.cancel()
+            frequencyFlushJob =
+                writeScope.launch {
+                    delay(WRITE_DEBOUNCE_MS)
+                    flushPendingFrequencyUpdates()
+                }
+        }
+
+        private suspend fun flushPendingFrequencyUpdates() {
+            frequencyWriteMutex.withLock {
+                if (pendingFrequencyUpdates.isEmpty()) return
+
+                val updates = pendingFrequencyUpdates.toMap()
+                pendingFrequencyUpdates.clear()
+
+                val timestamp = System.currentTimeMillis()
+
+                updates.values.forEach { update ->
+                    try {
+                        repeat(update.incrementCount) {
+                            userWordFrequencyDao.incrementFrequency(
+                                languageTag = update.languageTag,
+                                wordNormalized = update.wordNormalized,
+                                lastUsed = timestamp,
+                            )
+                        }
+                    } catch (e: Exception) {
+                        ErrorLogger.logException(
+                            component = "WordFrequencyRepository",
+                            severity = ErrorLogger.Severity.HIGH,
+                            exception = e,
+                            context = mapOf("operation" to "flushPendingFrequencyUpdates"),
+                        )
+                    }
                 }
             }
+        }
 
         suspend fun getFrequency(
             word: String,
@@ -179,65 +240,80 @@ class WordFrequencyRepository
                 }
             }
 
-        suspend fun clearAllFrequencies(): Result<Unit> =
-            withContext(ioDispatcher) {
-                try {
-                    userWordFrequencyDao.clearAll()
-                    frequencyCache.invalidateAll()
-                    Result.success(Unit)
-                } catch (e: Exception) {
-                    ErrorLogger.logException(
-                        component = "WordFrequencyRepository",
-                        severity = ErrorLogger.Severity.HIGH,
-                        exception = e,
-                        context = mapOf("operation" to "clearAllFrequencies"),
-                    )
-                    Result.failure(e)
-                }
-            }
-
         fun clearCache() {
             frequencyCache.invalidateAll()
             bigramCache.invalidateAll()
             topBigramsCache.clear()
+            pendingFrequencyUpdates.clear()
+            pendingBigramUpdates.clear()
         }
 
-        suspend fun recordBigram(
+        fun recordBigram(
             wordA: String,
             wordB: String,
             languageTag: String,
-        ): Result<Unit> =
-            withContext(ioDispatcher) {
-                try {
-                    if (wordA.isBlank() || wordB.isBlank()) {
-                        return@withContext Result.success(Unit)
-                    }
+        ): Result<Unit> {
+            if (wordA.isBlank() || wordB.isBlank()) {
+                return Result.success(Unit)
+            }
 
-                    val normalizedA = normalizeWord(wordA, languageTag)
-                    val normalizedB = normalizeWord(wordB, languageTag)
-                    val cacheKey = buildBigramCacheKey(languageTag, normalizedA)
+            val normalizedA = normalizeWord(wordA, languageTag)
+            val normalizedB = normalizeWord(wordB, languageTag)
+            val cacheKey = buildBigramCacheKey(languageTag, normalizedA)
+            val bigramKey = "${languageTag}_${normalizedA}_$normalizedB"
 
-                    userWordBigramDao.incrementBigram(
-                        languageTag = languageTag,
-                        wordANormalized = normalizedA,
-                        wordBNormalized = normalizedB,
-                        lastUsed = System.currentTimeMillis(),
-                    )
+            bigramCache.invalidate(cacheKey)
+            topBigramsCache.remove(languageTag)
+
+            pendingBigramUpdates.compute(bigramKey) { _, existing ->
+                existing?.apply { incrementCount++ }
+                    ?: PendingBigramUpdate(languageTag, normalizedA, normalizedB)
+            }
 
-                    bigramCache.invalidate(cacheKey)
-                    topBigramsCache.remove(languageTag)
+            scheduleBigramFlush()
 
-                    Result.success(Unit)
-                } catch (e: Exception) {
-                    ErrorLogger.logException(
-                        component = "WordFrequencyRepository",
-                        severity = ErrorLogger.Severity.HIGH,
-                        exception = e,
-                        context = mapOf("operation" to "recordBigram"),
-                    )
-                    Result.failure(e)
+            return Result.success(Unit)
+        }
+
+        private fun scheduleBigramFlush() {
+            bigramFlushJob?.cancel()
+            bigramFlushJob =
+                writeScope.launch {
+                    delay(WRITE_DEBOUNCE_MS)
+                    flushPendingBigramUpdates()
+                }
+        }
+
+        private suspend fun flushPendingBigramUpdates() {
+            bigramWriteMutex.withLock {
+                if (pendingBigramUpdates.isEmpty()) return
+
+                val updates = pendingBigramUpdates.toMap()
+                pendingBigramUpdates.clear()
+
+                val timestamp = System.currentTimeMillis()
+
+                updates.values.forEach { update ->
+                    try {
+                        repeat(update.incrementCount) {
+                            userWordBigramDao.incrementBigram(
+                                languageTag = update.languageTag,
+                                wordANormalized = update.wordANormalized,
+                                wordBNormalized = update.wordBNormalized,
+                                lastUsed = timestamp,
+                            )
+                        }
+                    } catch (e: Exception) {
+                        ErrorLogger.logException(
+                            component = "WordFrequencyRepository",
+                            severity = ErrorLogger.Severity.HIGH,
+                            exception = e,
+                            context = mapOf("operation" to "flushPendingBigramUpdates"),
+                        )
+                    }
                 }
             }
+        }
 
         suspend fun getBigramPredictions(
             wordA: String,
@@ -308,24 +384,6 @@ class WordFrequencyRepository
                 }
             }
 
-        suspend fun clearAllBigrams(): Result<Unit> =
-            withContext(ioDispatcher) {
-                try {
-                    userWordBigramDao.clearAll()
-                    bigramCache.invalidateAll()
-                    topBigramsCache.clear()
-                    Result.success(Unit)
-                } catch (e: Exception) {
-                    ErrorLogger.logException(
-                        component = "WordFrequencyRepository",
-                        severity = ErrorLogger.Severity.HIGH,
-                        exception = e,
-                        context = mapOf("operation" to "clearAllBigrams"),
-                    )
-                    Result.failure(e)
-                }
-            }
-
         private fun buildBigramCacheKey(
             languageTag: String,
             normalizedWordA: String,