Merge upstream LeanType v3.9.1

app/src/main/assets/layouts/editing/editing.json

@@ -0,0 +1,30 @@
+[
+  [
+    { "code": -131, "label": "Undo", "type": "function", "width": 0.2 },
+    { "code": -132, "label": "Redo", "type": "function", "width": 0.2 },
+    { "code": -35, "label": "All", "type": "function", "width": 0.2 },
+    { "code": -34, "label": "Word", "type": "function", "width": 0.2 },
+    { "code": -201, "label": "✕", "type": "function", "width": 0.2 }
+  ],
+  [
+    { "code": -32, "label": "Cut", "type": "function", "width": 0.2 },
+    { "code": -25, "label": "⤒", "width": 0.2 },
+    { "code": -23, "label": "↑", "width": 0.2 },
+    { "code": -26, "label": "⤓", "width": 0.2 },
+    { "code": -7, "label": "delete", "type": "function", "width": 0.2 }
+  ],
+  [
+    { "code": -31, "label": "Copy", "type": "function", "width": 0.2 },
+    { "code": -21, "label": "←", "width": 0.2 },
+    { "code": -306, "label": "Select", "type": "function", "width": 0.2 },
+    { "code": -22, "label": "→", "width": 0.2 },
+    { "code": -10015, "label": "«", "width": 0.2 }
+  ],
+  [
+    { "code": -33, "label": "Paste", "type": "function", "width": 0.2 },
+    { "code": -27, "label": "⇱", "width": 0.2 },
+    { "code": -24, "label": "↓", "width": 0.2 },
+    { "code": -28, "label": "⇲", "width": 0.2 },
+    { "code": -10016, "label": "»", "width": 0.2 }
+  ]
+]

app/src/main/java/com/android/inputmethod/latin/BinaryDictionary.java

@@ -429,6 +429,37 @@ public GetNextWordPropertyResult getNextWordProperty(final int token) {
                 getWordProperty(word, isBeginningOfSentence[0]), nextToken);
     }
 
+    // ponytail: allocation-free container for fast dict iteration
+    public static class WordAndFrequency {
+        public final String mWord;
+        public final int mFrequency;
+        public WordAndFrequency(String word, int frequency) {
+            mWord = word;
+            mFrequency = frequency;
+        }
+    }
+
+    // ponytail: allocation-free result container for fast dict iteration
+    public static class GetNextWordAndFrequencyResult {
+        public final WordAndFrequency mWordAndFrequency;
+        public final int mNextToken;
+        public GetNextWordAndFrequencyResult(WordAndFrequency wordAndFrequency, int nextToken) {
+            mWordAndFrequency = wordAndFrequency;
+            mNextToken = nextToken;
+        }
+    }
+
+    // ponytail: fast word iteration that avoids fetching heavy shortcut/ngram metadata
+    public GetNextWordAndFrequencyResult getNextWordAndFrequency(final int token) {
+        final int[] codePoints = new int[DICTIONARY_MAX_WORD_LENGTH];
+        final boolean[] isBeginningOfSentence = new boolean[1];
+        final int nextToken = getNextWordNative(mNativeDict, token, codePoints,
+                isBeginningOfSentence);
+        final String word = StringUtils.getStringFromNullTerminatedCodePointArray(codePoints);
+        final int probability = getFrequency(word);
+        return new GetNextWordAndFrequencyResult(new WordAndFrequency(word, probability), nextToken);
+    }
+
     // Add a unigram entry to binary dictionary with unigram attributes in native code.
     public boolean addUnigramEntry(final String word, final int probability,
             final String shortcutTarget, final int shortcutProbability,

app/src/main/java/helium314/keyboard/keyboard/Key.java

@@ -1308,6 +1308,7 @@ public KeyParams(
             // action flags don't need to be specified, they can be deduced from the key
             if (mCode == Constants.CODE_SPACE
                     || mCode == KeyCode.LANGUAGE_SWITCH
+                    || mCode == KeyCode.CLEAR_HANDWRITING
                     || (mCode == KeyCode.SYMBOL_ALPHA && !params.mId.isAlphabetKeyboard()))
                 actionFlags |= ACTION_FLAGS_ENABLE_LONG_PRESS;
             if (mCode <= Constants.CODE_SPACE && mCode != KeyCode.MULTIPLE_CODE_POINTS && mIconName == null)

app/src/main/java/helium314/keyboard/keyboard/KeyboardActionListenerImpl.kt

@@ -102,7 +102,39 @@ class KeyboardActionListenerImpl(private val latinIME: LatinIME, private val inp
     }
 
     override fun onCodeInput(primaryCode: Int, x: Int, y: Int, isKeyRepeat: Boolean) {
+        val isArrow = primaryCode == KeyCode.ARROW_LEFT || primaryCode == KeyCode.ARROW_RIGHT || primaryCode == KeyCode.ARROW_UP || primaryCode == KeyCode.ARROW_DOWN
+        if (isArrow) {
+            val isSelecting = keyboardSwitcher.keyboard?.mId?.isAlphabetShifted == true || sPersistentSelectionModeActive
+            if (isSelecting) {
+                val androidKeyCode = when (primaryCode) {
+                    KeyCode.ARROW_LEFT -> KeyEvent.KEYCODE_DPAD_LEFT
+                    KeyCode.ARROW_RIGHT -> KeyEvent.KEYCODE_DPAD_RIGHT
+                    KeyCode.ARROW_UP -> KeyEvent.KEYCODE_DPAD_UP
+                    KeyCode.ARROW_DOWN -> KeyEvent.KEYCODE_DPAD_DOWN
+                    else -> 0
+                }
+                if (androidKeyCode != 0) {
+                    val eventTime = android.os.SystemClock.uptimeMillis()
+                    connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SHIFT_LEFT, 0, 0))
+                    connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, androidKeyCode, 0, KeyEvent.META_SHIFT_ON))
+                    connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP, androidKeyCode, 0, KeyEvent.META_SHIFT_ON))
+                    connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_SHIFT_LEFT, 0, 0))
+                }
+                return
+            }
+        }
         when (primaryCode) {
+            KeyCode.TOGGLE_SELECTION_MODE -> {
+                sPersistentSelectionModeActive = !sPersistentSelectionModeActive
+                keyboardSwitcher.mainKeyboardView?.invalidateAllKeys()
+                keyboardSwitcher.suggestionStripView?.refreshToolbarButtonsActivation()
+                return
+            }
+            KeyCode.ALPHA -> {
+                sPersistentTextEditModeActive = false
+                sPersistentSelectionModeActive = false
+                keyboardSwitcher.hideTextEditView()
+            }
             KeyCode.HANDWRITING -> {
                 if (keyboardSwitcher.isHandwritingShowing) {
                     keyboardSwitcher.setAlphabetKeyboard()
@@ -167,12 +199,7 @@ class KeyboardActionListenerImpl(private val latinIME: LatinIME, private val inp
                 if (sPersistentTextEditModeActive) {
                     PointerTracker.sPersistentTouchpadModeActive = false
                     keyboardSwitcher.hideTouchpadView()
-
-                    val textEditView = keyboardSwitcher.textEditView
-                    if (textEditView != null) {
-                        setupTextEditListener(textEditView)
-                        keyboardSwitcher.showTextEditView()
-                    }
+                    keyboardSwitcher.showTextEditView()
                 } else {
                     keyboardSwitcher.hideTextEditView()
                 }
@@ -188,17 +215,21 @@ class KeyboardActionListenerImpl(private val latinIME: LatinIME, private val inp
         }
         val mkv = keyboardSwitcher.mainKeyboardView
 
+        val isEditingNav = primaryCode == KeyCode.WORD_LEFT || primaryCode == KeyCode.WORD_RIGHT
+                || primaryCode == KeyCode.MOVE_START_OF_PAGE || primaryCode == KeyCode.MOVE_END_OF_PAGE
+                || primaryCode == KeyCode.MOVE_START_OF_LINE || primaryCode == KeyCode.MOVE_END_OF_LINE
+                || primaryCode == KeyCode.PAGE_UP || primaryCode == KeyCode.PAGE_DOWN
+        val eventMetaState = if (isEditingNav && (keyboardSwitcher.keyboard?.mId?.isAlphabetShifted == true || sPersistentSelectionModeActive)) {
+            metaState or KeyEvent.META_SHIFT_ON
+        } else {
+            metaState
+        }
+
         // checking if the character is a combining accent
         val event = if (primaryCode in combiningRange) { // todo: should this be done later, maybe in inputLogic?
-            Event.createSoftwareDeadEvent(primaryCode, 0, metaState, mkv.getKeyX(x), mkv.getKeyY(y), null)
+            Event.createSoftwareDeadEvent(primaryCode, 0, eventMetaState, mkv.getKeyX(x), mkv.getKeyY(y), null)
         } else {
-            // todo:
-            //  setting meta shift should only be done for arrow and similar cursor movement keys
-            //  should only be enabled once it works more reliably (currently depends on app for some reason)
-//            if (mkv.keyboard?.mId?.isAlphabetShiftedManually == true)
-//                Event.createSoftwareKeypressEvent(primaryCode, metaState or KeyEvent.META_SHIFT_ON, mkv.getKeyX(x), mkv.getKeyY(y), isKeyRepeat)
-//            else Event.createSoftwareKeypressEvent(primaryCode, metaState, mkv.getKeyX(x), mkv.getKeyY(y), isKeyRepeat)
-            Event.createSoftwareKeypressEvent(primaryCode, metaState, mkv.getKeyX(x), mkv.getKeyY(y), isKeyRepeat)
+            Event.createSoftwareKeypressEvent(primaryCode, eventMetaState, mkv.getKeyX(x), mkv.getKeyY(y), isKeyRepeat)
         }
         latinIME.onEvent(event)
         metaAfterCodeInput(primaryCode)
@@ -360,6 +391,21 @@ class KeyboardActionListenerImpl(private val latinIME: LatinIME, private val inp
         val rtl = RichInputMethodManager.getInstance().currentSubtype.isRtlSubtype
         val steps = if (rtl) -rawSteps else rawSteps
 
+        val isSelecting = keyboardSwitcher.keyboard?.mId?.isAlphabetShifted == true || sPersistentSelectionModeActive
+        if (isSelecting) {
+            val code = if (steps < 0) {
+                gestureMoveBackHaptics()
+                if (rtl) KeyCode.ARROW_RIGHT else KeyCode.ARROW_LEFT
+            } else {
+                gestureMoveForwardHaptics(true)
+                if (rtl) KeyCode.ARROW_LEFT else KeyCode.ARROW_RIGHT
+            }
+            repeat(abs(steps)) {
+                onCodeInput(code, Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE, false)
+            }
+            return true
+        }
+
         // Web editors (Chromium, Firefox, etc.) handle direct setSelection badly during fast swipes,
         // often resulting in focus loss, caret hiding, or composition desynchronization.
         // Fall back to sending simulated arrow keys, which is fast, asynchronous, and robust.
@@ -670,43 +716,13 @@ class KeyboardActionListenerImpl(private val latinIME: LatinIME, private val inp
         })
     }
 
-    fun setupTextEditListener(textEditView: TextEditView) {
-        textEditView.setTextEditListener(object : TextEditView.TextEditListener {
-            override fun onCursorMove(keyCode: Int, isSelecting: Boolean) {
-                if (isSelecting) {
-                    val androidKeyCode = when (keyCode) {
-                        KeyCode.ARROW_UP -> KeyEvent.KEYCODE_DPAD_UP
-                        KeyCode.ARROW_DOWN -> KeyEvent.KEYCODE_DPAD_DOWN
-                        KeyCode.ARROW_LEFT -> KeyEvent.KEYCODE_DPAD_LEFT
-                        KeyCode.ARROW_RIGHT -> KeyEvent.KEYCODE_DPAD_RIGHT
-                        else -> 0
-                    }
-                    if (androidKeyCode != 0) {
-                        val eventTime = android.os.SystemClock.uptimeMillis()
-                        connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SHIFT_LEFT, 0, 0))
-                        connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, androidKeyCode, 0, KeyEvent.META_SHIFT_ON))
-                        connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP, androidKeyCode, 0, KeyEvent.META_SHIFT_ON))
-                        connection.sendKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_SHIFT_LEFT, 0, 0))
-                    }
-                } else {
-                    onCodeInput(keyCode, Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE, false)
-                }
-            }
-
-            override fun onCodeInput(keyCode: Int) {
-                onCodeInput(keyCode, Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE, false)
-            }
 
-            override fun onClose() {
-                sPersistentTextEditModeActive = false
-                keyboardSwitcher.hideTextEditView()
-            }
-        })
-    }
 
     companion object {
         @JvmField
         var sPersistentTextEditModeActive = false
+        @JvmField
+        var sPersistentSelectionModeActive = false
         private enum class MetaPressState {
             UNSET, // default state, not active
             SET, // enabled without onPressKey (e.g. in popup)

app/src/main/java/helium314/keyboard/keyboard/KeyboardId.java

@@ -68,6 +68,7 @@ public final class KeyboardId {
     public static final int ELEMENT_EMOJI_BOTTOM_ROW = 29;
     public static final int ELEMENT_CLIPBOARD_BOTTOM_ROW = 30;
     public static final int ELEMENT_HANDWRITING_BOTTOM_ROW = 31;
+    public static final int ELEMENT_TEXT_EDIT = 32;
 
     public final RichInputMethodSubtype mSubtype;
     public final int mWidth;
@@ -294,6 +295,7 @@ public static String elementIdToName(final int elementId) {
             case ELEMENT_EMOJI_BOTTOM_ROW -> "emojiBottomRow";
             case ELEMENT_CLIPBOARD_BOTTOM_ROW -> "clipboardBottomRow";
             case ELEMENT_HANDWRITING_BOTTOM_ROW -> "handwritingBottomRow";
+            case ELEMENT_TEXT_EDIT -> "editing";
             default -> null;
         };
     }