Update autocorrect

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

@@ -41,6 +41,7 @@ import com.urik.keyboard.service.EnglishPronounI
 import com.urik.keyboard.service.InputMethod
 import com.urik.keyboard.service.InputStateManager
 import com.urik.keyboard.service.LanguageManager
+import com.urik.keyboard.service.LastAutocorrection
 import com.urik.keyboard.service.OutputBridge
 import com.urik.keyboard.service.PostCommitReplacementState
 import com.urik.keyboard.service.ProcessingResult
@@ -1150,6 +1151,7 @@ class UrikInputMethodService :
             }
 
             inputState.postCommitReplacementState = null
+            inputState.lastAutocorrection = null
 
             inputState.isActivelyEditing = true
 
@@ -1272,6 +1274,7 @@ class UrikInputMethodService :
                     inputState.postCommitReplacementState = null
                     swipeKeyboardView?.clearSuggestions()
                 }
+                inputState.lastAutocorrection = null
 
                 if (inputState.spellConfirmationState == SpellConfirmationState.AWAITING_CONFIRMATION) {
                     outputBridge.beginBatchEdit()
@@ -2062,11 +2065,22 @@ class UrikInputMethodService :
                             inputState.displayBuffer = word
                             inputState.composingRegionStart = wordStart
 
-                            suggestionPipeline.requestSuggestions(
-                                buffer = word,
-                                inputMethod = InputMethod.TYPED,
-                                isCharacterInput = false
-                            )
+                            val autocorrection = inputState.lastAutocorrection
+                            if (autocorrection != null &&
+                                word.equals(autocorrection.correctedWord, ignoreCase = true)
+                            ) {
+                                outputBridge.setComposingText(autocorrection.originalTypedWord, 1)
+                                inputState.displayBuffer = autocorrection.originalTypedWord
+                                inputState.pendingSuggestions = emptyList()
+                                swipeKeyboardView?.clearSuggestions()
+                            } else {
+                                inputState.lastAutocorrection = null
+                                suggestionPipeline.requestSuggestions(
+                                    buffer = word,
+                                    inputMethod = InputMethod.TYPED,
+                                    isCharacterInput = false
+                                )
+                            }
                         } else {
                             coordinateStateClear()
                         }
@@ -2192,7 +2206,10 @@ class UrikInputMethodService :
                             return@launch
                         }
 
-                        if (currentSettings.autocorrectionEnabled && displaySuggestions.isNotEmpty()) {
+                        if (currentSettings.autocorrectionEnabled &&
+                            displaySuggestions.isNotEmpty() &&
+                            inputState.lastAutocorrection == null
+                        ) {
                             val topSuggestion = displaySuggestions.first()
                             if (isSafeForAutocorrect(topSuggestion)) {
                                 val originalWord = inputState.displayBuffer
@@ -2209,8 +2226,12 @@ class UrikInputMethodService :
                                             originalWord = originalWord,
                                             committedWord = topSuggestion
                                         )
-                                    inputState.pendingSuggestions =
-                                        displaySuggestions.drop(1) + listOf(originalWord)
+                                    inputState.lastAutocorrection =
+                                        LastAutocorrection(
+                                            originalTypedWord = originalWord,
+                                            correctedWord = topSuggestion
+                                        )
+                                    inputState.pendingSuggestions = listOf(originalWord)
                                     swipeKeyboardView?.updateSuggestions(inputState.pendingSuggestions)
 
                                     val textBefore = outputBridge.safeGetTextBeforeCursor(50)

app/src/main/java/com/urik/keyboard/service/InputStateManager.kt

@@ -9,6 +9,8 @@ enum class SpellConfirmationState {
 
 data class PostCommitReplacementState(val originalWord: String, val committedWord: String)
 
+data class LastAutocorrection(val originalTypedWord: String, val correctedWord: String)
+
 interface ViewCallback {
     fun clearSuggestions()
 
@@ -113,6 +115,10 @@ class InputStateManager(
     var postCommitReplacementState: PostCommitReplacementState? = null
         internal set
 
+    @Volatile
+    var lastAutocorrection: LastAutocorrection? = null
+        internal set
+
     val selectionStateTracker = SelectionStateTracker()
 
     val requiresDirectCommit: Boolean
@@ -170,6 +176,7 @@ class InputStateManager(
         spellConfirmationState = SpellConfirmationState.NORMAL
         pendingWordForLearning = null
         postCommitReplacementState = null
+        lastAutocorrection = null
         viewCallback.clearSuggestions()
         composingRegionStart = -1
         composingReassertionCount = 0
@@ -209,6 +216,7 @@ class InputStateManager(
         spellConfirmationState = SpellConfirmationState.NORMAL
         pendingWordForLearning = null
         postCommitReplacementState = null
+        lastAutocorrection = null
         viewCallback.clearSuggestions()
         composingRegionStart = -1
         lastKnownCursorPosition = -1

app/src/test/java/com/urik/keyboard/service/InputStateManagerTest.kt

@@ -0,0 +1,96 @@
+package com.urik.keyboard.service
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+
+class InputStateManagerTest {
+    private var suggestionsCleared = false
+    private var lastSuggestions: List<String> = emptyList()
+
+    private lateinit var stateManager: InputStateManager
+
+    @Before
+    fun setup() {
+        suggestionsCleared = false
+        lastSuggestions = emptyList()
+
+        val viewCallback = object : ViewCallback {
+            override fun clearSuggestions() {
+                suggestionsCleared = true
+            }
+
+            override fun updateSuggestions(suggestions: List<String>) {
+                lastSuggestions = suggestions
+            }
+        }
+
+        stateManager = InputStateManager(
+            viewCallback = viewCallback,
+            onShiftStateChanged = {},
+            isCapsLockOn = { false },
+            cancelDebounceJob = {}
+        )
+    }
+
+    @Test
+    fun `lastAutocorrection persists independently of postCommitReplacementState`() {
+        stateManager.lastAutocorrection = LastAutocorrection("teh", "the")
+        stateManager.postCommitReplacementState = PostCommitReplacementState("teh", "the")
+
+        stateManager.postCommitReplacementState = null
+
+        assertNotNull(stateManager.lastAutocorrection)
+        assertEquals("teh", stateManager.lastAutocorrection?.originalTypedWord)
+        assertEquals("the", stateManager.lastAutocorrection?.correctedWord)
+    }
+
+    @Test
+    fun `clearInternalStateOnly clears lastAutocorrection`() {
+        stateManager.lastAutocorrection = LastAutocorrection("teh", "the")
+
+        stateManager.clearInternalStateOnly()
+
+        assertNull(stateManager.lastAutocorrection)
+    }
+
+    @Test
+    fun `invalidateComposingState clears lastAutocorrection`() {
+        stateManager.lastAutocorrection = LastAutocorrection("teh", "the")
+
+        stateManager.invalidateComposingState()
+
+        assertNull(stateManager.lastAutocorrection)
+    }
+
+    @Test
+    fun `clearInternalStateOnly clears postCommitReplacementState`() {
+        stateManager.postCommitReplacementState = PostCommitReplacementState("teh", "the")
+
+        stateManager.clearInternalStateOnly()
+
+        assertNull(stateManager.postCommitReplacementState)
+    }
+
+    @Test
+    fun `clearBigramPredictions does not affect lastAutocorrection`() {
+        stateManager.lastAutocorrection = LastAutocorrection("teh", "the")
+        stateManager.isShowingBigramPredictions = true
+
+        stateManager.clearBigramPredictions()
+
+        assertNotNull(stateManager.lastAutocorrection)
+    }
+
+    @Test
+    fun `clearSpellConfirmationFields does not affect lastAutocorrection`() {
+        stateManager.lastAutocorrection = LastAutocorrection("teh", "the")
+        stateManager.spellConfirmationState = SpellConfirmationState.AWAITING_CONFIRMATION
+
+        stateManager.clearSpellConfirmationFields()
+
+        assertNotNull(stateManager.lastAutocorrection)
+    }
+}