Add pure-Java gesture typing fallback (SwipeGestureEngine)

HeliBoard's gesture typing infrastructure (touch tracking, trail rendering,
settings UI) has always been present, but word matching requires a native
library — either the proprietary Google libjni_latinimegoogle.so or the
open replacement being developed under the NLnet grant (#2226, #668).
Users without a compatible library get no suggestions at all when swiping.

This commit adds SwipeGestureEngine: a self-contained Java implementation
that makes gesture typing work without any native library.

Algorithm (arc-length resampling + L2 distance):
- At index build time, each dictionary word is converted to a normalized
  gesture path: letter key centres are looked up from the live Keyboard
  object, deduplicated, then resampled to 16 evenly-spaced (x,y) points.
  Words are grouped by first letter for fast lookup.
- At gesture end, the raw InputPointers stroke is resampled the same way.
  Candidates are filtered by first/last letter, then ranked by L2 distance
  to their precomputed path with a small log-frequency bonus so common words
  win ties.

Integration points:
- JniUtils: sHaveGestureLib is set to true unconditionally so the gesture
  toggle appears in settings and touch input is routed as batch input.
- Suggest.getSuggestedWordsForBatchInput: builds the index lazily on the
  first gesture (background thread) and caches it; clears on dictionary or
  layout change. Never calls the JNI stub with SESSION_ID_GESTURE.
- Dictionary hierarchy: getAllWordsWithFrequency() added to Dictionary,
  ReadOnlyBinaryDictionary (token-based JNI iteration with probability),
  and DictionaryCollection; DictionaryFacilitator/Impl expose it.

Properties:
- Pure Java, no new dependencies, ~270 lines.
- Layout-aware: key positions are read from the live Keyboard object, so
  any user layout (QWERTY, Dvorak, custom) works correctly.
- Index is rebuilt automatically on layout or dictionary change.
- Coexists with the native library: if a native library is loaded, it takes
  over and this engine is dormant.

This is intentionally a simple baseline — the NLnet native library (#2226)
will eventually supersede it with higher accuracy. Until then this gives
every HeliBoard user working gesture typing out of the box.

Relates to: #668, #2226

Author: simon-liesinger

app/src/main/java/helium314/keyboard/latin/DictionaryFacilitator.java

@@ -19,8 +19,10 @@
 import helium314.keyboard.latin.settings.SettingsValuesForSuggestion;
 import helium314.keyboard.latin.utils.SuggestionResults;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -151,4 +153,14 @@ void unlearnFromUserHistory(final String word,
     void dumpDictionaryForDebug(final String dictName);
 
     @NonNull List<DictionaryStats> getDictionaryStats(final Context context);
+
+    /**
+     * Returns all words with frequencies from the primary main dictionary, for gesture typing
+     * precomputation. Iterates the binary dictionary directly; can be slow on first call.
+     * The default returns an empty map; DictionaryFacilitatorImpl overrides this.
+     */
+    @NonNull
+    default Map<String, Integer> getAllMainDictionaryWordsWithFrequency() {
+        return Collections.emptyMap();
+    }
 }

app/src/main/java/helium314/keyboard/latin/DictionaryFacilitatorImpl.kt

@@ -475,6 +475,9 @@ class DictionaryFacilitatorImpl : DictionaryFacilitator {
         putWordIntoValidSpellingWordCache("unlearnFromUserHistory", word.lowercase(Locale.getDefault()))
     }
 
+    override fun getAllMainDictionaryWordsWithFrequency(): Map<String, Int> =
+        dictionaryGroups[0].getDict(Dictionary.TYPE_MAIN)?.getAllWordsWithFrequency() ?: emptyMap()
+
     // TODO: Revise the way to fusion suggestion results.
     override fun getSuggestionResults(
         composedData: ComposedData, ngramContext: NgramContext, keyboard: Keyboard,

app/src/main/java/helium314/keyboard/latin/Suggest.kt

@@ -17,6 +17,7 @@ import helium314.keyboard.latin.define.DebugFlags
 import helium314.keyboard.latin.define.DecoderSpecificConstants.SHOULD_AUTO_CORRECT_USING_NON_WHITE_LISTED_SUGGESTION
 import helium314.keyboard.latin.define.DecoderSpecificConstants.SHOULD_REMOVE_PREVIOUSLY_REJECTED_SUGGESTION
 import helium314.keyboard.latin.dictionary.Dictionary
+import helium314.keyboard.latin.gesture.SwipeGestureEngine
 import helium314.keyboard.latin.settings.Settings
 import helium314.keyboard.latin.settings.SettingsValuesForSuggestion
 import helium314.keyboard.latin.suggestions.SuggestionStripView
@@ -35,8 +36,14 @@ class Suggest(private val mDictionaryFacilitator: DictionaryFacilitator) {
     private val mPlausibilityThreshold = 0f
     private val nextWordSuggestionsCache = HashMap<NgramContext, SuggestionResults>()
 
+    // Precomputed gesture word index. Rebuilt lazily; cleared on dictionary/layout change.
+    @Volatile private var gestureIndex: SwipeGestureEngine.GestureIndex? = null
+
     // cache cleared whenever LatinIME.loadSettings is called, notably on changing layout and switching input fields
-    fun clearNextWordSuggestionsCache() = nextWordSuggestionsCache.clear()
+    fun clearNextWordSuggestionsCache() {
+        nextWordSuggestionsCache.clear()
+        gestureIndex = null
+    }
 
     /**
      * Set the normalized-score threshold for a suggestion to be considered strong enough that we
@@ -265,10 +272,17 @@ class Suggest(private val mDictionaryFacilitator: DictionaryFacilitator) {
         settingsValuesForSuggestion: SettingsValuesForSuggestion,
         inputStyle: Int, sequenceNumber: Int
     ): SuggestedWords {
-        val suggestionResults = mDictionaryFacilitator.getSuggestionResults(
-            wordComposer.composedDataSnapshot, ngramContext, keyboard,
-            settingsValuesForSuggestion, SESSION_ID_GESTURE, inputStyle
-        )
+        val pointers = wordComposer.composedDataSnapshot.mInputPointers
+        // Build the precomputed gesture index lazily (once per dictionary/layout).
+        // getAllMainDictionaryWordsWithFrequency() iterates the binary dict via JNI — slow on
+        // first call, instant thereafter. Runs on InputLogicHandler's background thread.
+        var index = gestureIndex
+        if (index == null || index.byFirst.isEmpty()) {
+            val words = mDictionaryFacilitator.getAllMainDictionaryWordsWithFrequency()
+            index = SwipeGestureEngine.buildIndex(words, keyboard)
+            if (index.byFirst.isNotEmpty()) gestureIndex = index
+        }
+        val suggestionResults = SwipeGestureEngine.rankByIndex(index, pointers, keyboard, SuggestedWords.MAX_SUGGESTIONS)
         replaceSingleLetterFirstSuggestion(suggestionResults)
 
         // For transforming words that don't come from a dictionary, because it's our best bet

app/src/main/java/helium314/keyboard/latin/dictionary/Dictionary.java

@@ -7,7 +7,9 @@
 package helium314.keyboard.latin.dictionary;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Locale;
+import java.util.Map;
 
 import helium314.keyboard.latin.NgramContext;
 import helium314.keyboard.latin.SuggestedWords.SuggestedWordInfo;
@@ -98,6 +100,16 @@ public boolean isValidWord(final String word) {
      */
     abstract public boolean isInDictionary(final String word);
 
+    /**
+     * Returns all words stored in this dictionary.
+     * The default implementation returns an empty list; override in concrete dictionaries
+     * that support full enumeration (e.g. ReadOnlyBinaryDictionary).
+     */
+    @androidx.annotation.NonNull
+    public Map<String, Integer> getAllWordsWithFrequency() {
+        return Collections.emptyMap();
+    }
+
     /**
      * Get the frequency of the word.
      * @param word the word to get the frequency of.

app/src/main/java/helium314/keyboard/latin/dictionary/DictionaryCollection.java

@@ -16,7 +16,9 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Locale;
+import java.util.Map;
 
 /**
  * Class for a collection of dictionaries that behave like one dictionary.
@@ -89,6 +91,14 @@ public int getMaxFrequencyOfExactMatches(final String word) {
         return maxFreq;
     }
 
+    @Override
+    @androidx.annotation.NonNull
+    public Map<String, Integer> getAllWordsWithFrequency() {
+        Map<String, Integer> result = new HashMap<>();
+        for (Dictionary dict : mDictionaries) result.putAll(dict.getAllWordsWithFrequency());
+        return result;
+    }
+
     @Override
     public boolean isInitialized() {
         return !mDictionaries.isEmpty();

app/src/main/java/helium314/keyboard/latin/dictionary/ReadOnlyBinaryDictionary.java

@@ -15,7 +15,9 @@
 import helium314.keyboard.latin.settings.SettingsValuesForSuggestion;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Locale;
+import java.util.Map;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
@@ -109,6 +111,30 @@ public int getMaxFrequencyOfExactMatches(final String word) {
         return NOT_A_PROBABILITY;
     }
 
+    @Override
+    @androidx.annotation.NonNull
+    public Map<String, Integer> getAllWordsWithFrequency() {
+        Map<String, Integer> words = new HashMap<>();
+        if (!mLock.readLock().tryLock()) return words;
+        try {
+            int token = 0;
+            do {
+                BinaryDictionary.GetNextWordPropertyResult result =
+                        mBinaryDictionary.getNextWordProperty(token);
+                if (result.mWordProperty == null) break;
+                if (!result.mWordProperty.mIsNotAWord && !result.mWordProperty.mIsPossiblyOffensive) {
+                    String word = result.mWordProperty.mWord;
+                    if (word != null && !word.isEmpty())
+                        words.put(word, result.mWordProperty.mProbabilityInfo.mProbability);
+                }
+                token = result.mNextToken;
+            } while (token != 0);
+        } finally {
+            mLock.readLock().unlock();
+        }
+        return words;
+    }
+
     @Override
     public WordProperty getWordProperty(String word, boolean isBeginningOfSentence) {
         if (mLock.readLock().tryLock()) {