react-native-external-keyboard 0.9.1 → 1.0.0

package/android/build.gradle

@@ -1,19 +1,3 @@
-buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["ExternalKeyboard_kotlinVersion"]
-
-  repositories {
-    google()
-    mavenCentral()
-  }
-
-  dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
-    // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-  }
-}
-
 def reactNativeArchitectures() {
   def value = rootProject.getProperties().get("reactNativeArchitectures")
   return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
@@ -24,8 +8,6 @@ def isNewArchitectureEnabled() {
 }
 
 apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
-
 
 def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
 

package/android/src/main/java/com/externalkeyboard/ExternalKeyboardViewPackage.java

@@ -6,19 +6,19 @@ import com.externalkeyboard.views.ExternalKeyboardLockView.ExternalKeyboardLockV
 import com.externalkeyboard.views.ExternalKeyboardView.ExternalKeyboardViewManager;
 import com.externalkeyboard.views.KeyboardFocusGroup.KeyboardFocusGroupManager;
 import com.externalkeyboard.views.TextInputFocusWrapper.TextInputFocusWrapperManager;
-import com.facebook.react.TurboReactPackage;
+import com.facebook.react.BaseReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.module.model.ReactModuleInfo;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.uimanager.ViewManager;
 
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.HashMap;
 import java.util.Map;
 
-public class ExternalKeyboardViewPackage extends TurboReactPackage {
+public class ExternalKeyboardViewPackage extends BaseReactPackage {
   @Override
   public NativeModule getModule(String name, ReactApplicationContext reactContext) {
     if (name.equals(ExternalKeyboardModule.NAME)) {
@@ -30,29 +30,31 @@ public class ExternalKeyboardViewPackage extends TurboReactPackage {
 
   @Override
   public ReactModuleInfoProvider getReactModuleInfoProvider() {
-    return () -> {
-      Map<String, ReactModuleInfo> map = new HashMap<>();
-      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
-      map.put(ExternalKeyboardModule.NAME, new ReactModuleInfo(ExternalKeyboardModule.NAME, // name
-        ExternalKeyboardModule.NAME, // className
-        false,                           // canOverrideExistingModule
-        false,                           // needsEagerInit
-        true,                            // hasConstants
-        false,                           // isCxxModule
-        isTurboModule                    // isTurboModule
-      ));
-      return map;
+    return new ReactModuleInfoProvider() {
+      @Override
+      public Map<String, ReactModuleInfo> getReactModuleInfos() {
+        Map<String, ReactModuleInfo> map = new HashMap<>();
+
+        map.put(ExternalKeyboardModule.NAME, new ReactModuleInfo(
+          ExternalKeyboardModule.NAME, // name
+          ExternalKeyboardModule.NAME, // className
+          false,                   // canOverrideExistingModule
+          false,                   // needsEagerInit
+          false,                   // isCxxModule
+          BuildConfig.IS_NEW_ARCHITECTURE_ENABLED // isTurboModule
+        ));
+        return map;
+      }
     };
   }
 
   @Override
   public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-    List<ViewManager> viewManagers = new ArrayList<>();
-    viewManagers.add(new ExternalKeyboardViewManager());
-    viewManagers.add(new TextInputFocusWrapperManager());
-    viewManagers.add(new KeyboardFocusGroupManager());
-    viewManagers.add(new ExternalKeyboardLockViewManager());
-
-    return viewManagers;
+    return Arrays.asList(
+      new ExternalKeyboardViewManager(),
+      new TextInputFocusWrapperManager(),
+      new KeyboardFocusGroupManager(),
+      new ExternalKeyboardLockViewManager()
+    );
   }
 }

package/android/src/main/java/com/externalkeyboard/events/EventHelper.java

@@ -2,42 +2,39 @@ package com.externalkeyboard.events;
 
 import android.view.KeyEvent;
 
+import com.externalkeyboard.helper.ReactNativeEventDispatcher;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcher;
 
 public class EventHelper {
   public static void focusChanged(ReactContext context, int id, boolean hasFocus) {
     int surfaceId = UIManagerHelper.getSurfaceId(context);
     FocusChangeEvent event = new FocusChangeEvent(surfaceId, id, hasFocus);
-    EventDispatcher eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, id);
-    if (eventDispatcher != null) {
-      eventDispatcher.dispatchEvent(event);
-    }
+    dispatch(context, id, event);
   }
 
   public static void pressDown(ReactContext context, int id, int keyCode, KeyEvent keyEvent) {
     int surfaceId = UIManagerHelper.getSurfaceId(context);
     KeyPressDownEvent keyPressDownEvent = new KeyPressDownEvent(surfaceId, id, keyCode, keyEvent);
-    EventDispatcher eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, id);
-    if (eventDispatcher != null) {
-      eventDispatcher.dispatchEvent(keyPressDownEvent);
-    }
+    dispatch(context, id, keyPressDownEvent);
   }
 
   public static void pressUp(ReactContext context, int id, int keyCode, KeyEvent keyEvent, boolean isLongPress) {
     int surfaceId = UIManagerHelper.getSurfaceId(context);
     KeyPressUpEvent keyPressUpEvent = new KeyPressUpEvent(surfaceId, id, keyCode, keyEvent, isLongPress);
-    EventDispatcher eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, id);
-    if (eventDispatcher != null) {
-      eventDispatcher.dispatchEvent(keyPressUpEvent);
-    }
+    dispatch(context, id, keyPressUpEvent);
   }
 
   public static void multiplyTextSubmit(ReactContext context, int id, String text) {
     int surfaceId = UIManagerHelper.getSurfaceId(context);
     MultiplyTextSubmit event = new MultiplyTextSubmit(surfaceId, id, text);
-    EventDispatcher eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, id);
+    dispatch(context, id, event);
+  }
+
+  private static void dispatch(ReactContext context, int id, Event<?> event) {
+    EventDispatcher eventDispatcher = ReactNativeEventDispatcher.getEventDispatcher(context, id);
     if (eventDispatcher != null) {
       eventDispatcher.dispatchEvent(event);
     }

package/android/src/main/java/com/externalkeyboard/helper/FocusHelper.java

@@ -8,7 +8,6 @@ import java.util.HashMap;
 import java.util.Map;
 
 import androidx.annotation.Nullable;
-import androidx.core.view.ViewCompat;
 
 public class FocusHelper {
   private static final int MASK_FOCUS_UP = 0b1;
@@ -64,7 +63,7 @@ public class FocusHelper {
     return null;
   }
   public static boolean isAccessible(@Nullable View view) {
-    return view != null && ViewCompat.isImportantForAccessibility(view);
+    return view != null && view.isImportantForAccessibility();
   }
 
   public static View findFirstAccessible(@Nullable ViewGroup viewGroup, boolean ignoreRoot) {

package/android/src/main/java/com/externalkeyboard/services/FocusMemoryService.java

@@ -0,0 +1,64 @@
+package com.externalkeyboard.services;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Remembers the focused view inside an environment and restores it later.
+ *
+ * Reusable for any "leave then come back" flow — modal presentation, screen
+ * navigation, etc. The owner decides <em>when</em> to call store / restore; the
+ * only difference between flows is the ordering of those two calls:
+ *
+ * <pre>
+ *   Modal:      store on present, restore on dismiss.
+ *   Navigation: store on disappear, restore on appear.
+ * </pre>
+ *
+ * The stored view is held weakly, so it never keeps a detached view alive.
+ */
+public class FocusMemoryService {
+  private WeakReference<View> storedView = new WeakReference<>(null);
+
+  /**
+   * Captures the currently focused view in the environment's window.
+   */
+  public void store(@Nullable View environment) {
+    if (environment == null) {
+      return;
+    }
+
+    storedView = new WeakReference<>(KeyboardFocusService.getFocusedItem(environment));
+  }
+
+  /**
+   * Restores focus to the stored view (if any) and clears the stored reference.
+   */
+  public void restore() {
+    View view = storedView.get();
+    if (view == null) {
+      return;
+    }
+
+    KeyboardFocusService.focus(view);
+    storedView.clear();
+  }
+
+  /**
+   * Returns the currently stored view without consuming it, or null.
+   */
+  @Nullable
+  public View get() {
+    return storedView.get();
+  }
+
+  /**
+   * Drops the stored reference without restoring focus.
+   */
+  public void clean() {
+    storedView.clear();
+  }
+}

package/android/src/main/java/com/externalkeyboard/services/KeyboardFocusService.java

@@ -0,0 +1,41 @@
+package com.externalkeyboard.services;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Public entry point for driving the Android focus engine from custom native code.
+ * All methods are static — this service holds no state.
+ */
+public class KeyboardFocusService {
+
+  private KeyboardFocusService() {
+  }
+
+  /**
+   * Returns the view currently focused within the given environment's window, or null.
+   */
+  @Nullable
+  public static View getFocusedItem(@Nullable View environment) {
+    if (environment == null) {
+      return null;
+    }
+
+    View root = environment.getRootView();
+    return root != null ? root.findFocus() : environment.findFocus();
+  }
+
+  /**
+   * Requests focus on the given view on the main thread.
+   */
+  public static void focus(@Nullable final View view) {
+    if (view == null) {
+      return;
+    }
+
+    new Handler(Looper.getMainLooper()).post(view::requestFocus);
+  }
+}

package/android/src/main/java/com/externalkeyboard/services/KeyboardService.java

@@ -1,8 +1,6 @@
 package com.externalkeyboard.services;
 
 
-import static com.facebook.react.uimanager.common.UIManagerType.FABRIC;
-
 import android.app.Activity;
 import android.util.Log;
 import android.view.View;
@@ -11,8 +9,6 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.UIManagerHelper;
-import com.facebook.react.uimanager.UIManagerModule;
-import com.facebook.react.uimanager.common.ViewUtil;
 
 public class KeyboardService {
   private final ReactApplicationContext context;
@@ -30,17 +26,12 @@ public class KeyboardService {
 
     activity.runOnUiThread(() -> {
       try {
-        int uiManagerType = ViewUtil.getUIManagerType(tag);
-        if (uiManagerType == FABRIC) {
-          UIManager fabricUIManager = UIManagerHelper.getUIManager(context, uiManagerType);
-          if (fabricUIManager != null) {
-            View view = fabricUIManager.resolveView(tag);
+        UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(context, tag);
+        if (uiManager != null) {
+          View view = uiManager.resolveView(tag);
+          if (view != null) {
             view.requestFocus();
           }
-        } else {
-          UIManager uiManager = context.getNativeModule(UIManagerModule.class);
-          View view = uiManager.resolveView(tag);
-          view.requestFocus();
         }
       } catch (IllegalViewOperationException error) {
         Log.e("KEYBOARD_FOCUS_ERROR", error.getMessage());

package/android/src/main/java/com/externalkeyboard/views/ExternalKeyboardView/ExternalKeyboardView.java

@@ -2,7 +2,6 @@ package com.externalkeyboard.views.ExternalKeyboardView;
 
 import android.content.Context;
 import android.view.KeyEvent;
-import android.view.ViewGroup;
 
 import com.externalkeyboard.views.base.keyboard.ViewKeyHandlerBase;
 
@@ -14,6 +13,8 @@ public class ExternalKeyboardView extends ViewKeyHandlerBase {
 
   @Override
   public boolean dispatchKeyEvent(KeyEvent keyEvent) {
+    this.handleKeyPress(keyEvent);
+
     if (this.isFocusLocked(keyEvent)) {
       return true;
     }
@@ -25,13 +26,6 @@ public class ExternalKeyboardView extends ViewKeyHandlerBase {
       return super.dispatchKeyEvent(keyEvent);
     }
 
-    this.handleKeyPress(keyEvent);
-
     return super.dispatchKeyEvent(keyEvent);
   }
-
-  public void setCanBeFocused(boolean canBeFocused) {
-    int descendantFocusability = canBeFocused ? ViewGroup.FOCUS_BEFORE_DESCENDANTS : ViewGroup.FOCUS_BLOCK_DESCENDANTS;
-    this.setDescendantFocusability(descendantFocusability);
-  }
 }

package/android/src/main/java/com/externalkeyboard/views/ExternalKeyboardView/ExternalKeyboardViewManager.java

@@ -69,14 +69,6 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
     wrapper.setCanBeFocused(canBeFocused);
   }
 
-  @Override
-  @ReactProp(name = "enableA11yFocus", defaultBoolean = false)
-  public void setEnableA11yFocus(ExternalKeyboardView wrapper, boolean enableA11yFocus) {
-    if(wrapper.enableA11yFocus != enableA11yFocus) {
-      wrapper.enableA11yFocus = enableA11yFocus;
-    }
-  }
-
   @Override
   @ReactProp(name = "screenAutoA11yFocus", defaultBoolean = false)
   public void setScreenAutoA11yFocus(ExternalKeyboardView wrapper, boolean enableA11yFocus) {
@@ -146,6 +138,12 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
     //stub
   }
 
+  @Override
+  @ReactProp(name = "roundedHaloFix")
+  public void setRoundedHaloFix(ExternalKeyboardView view, boolean value) {
+    //stub
+  }
+
   @Override
   @ReactProp(name = "tintColor")
   public void setTintColor(ExternalKeyboardView view, @Nullable Integer value) {
@@ -248,8 +246,9 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
   }
 
   @Override
-  public void setGroup(ExternalKeyboardView view, boolean value) {
-    //stub
+  @ReactProp(name = "focusableWrapper", defaultBoolean = false)
+  public void setFocusableWrapper(ExternalKeyboardView view, boolean value) {
+    view.setFocusableWrapper(value);
   }
 
   @Override
@@ -258,14 +257,22 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
   }
 
   @Override
-  public void focus(ExternalKeyboardView view) {
+  public void rnekKeyboardFocus(ExternalKeyboardView view) {
     view.focus();
   }
 
+  @Override
+  public void rnekScreenReaderFocus(ExternalKeyboardView view) {
+    view.a11yFocus();
+  }
+
+
   @Override
   public void receiveCommand(ReactViewGroup root, String commandId, @Nullable ReadableArray args) {
-    if (commandId.equals("focus")) {
-      this.focus((ExternalKeyboardView) root);
+    if (commandId.equals("rnekKeyboardFocus")) {
+      this.rnekKeyboardFocus((ExternalKeyboardView) root);
+    } else if (commandId.equals("rnekScreenReaderFocus")) {
+      this.rnekScreenReaderFocus((ExternalKeyboardView) root);
     } else {
       super.receiveCommand(root, commandId, args);
     }

package/android/src/main/java/com/externalkeyboard/views/TextInputFocusWrapper/TextInputFocusWrapper.java

@@ -7,6 +7,7 @@ import android.text.Editable;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
+import android.view.inputmethod.InputMethodManager;
 import android.widget.EditText;
 
 import androidx.annotation.NonNull;
@@ -32,6 +33,13 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
   private boolean blurOnSubmit = true;
   private boolean multiline = false;
   private boolean keyboardFocusable = true;
+  // FOCUS_BY_PRESS only: set while a directional focus search (Tab/Shift+Tab/arrows)
+  // is moving focus out of the EditText, so the blur handler knows not to pull
+  // focus back to the wrapper. Cleared right after on the message queue.
+  private boolean navigatingAway = false;
+  // FOCUS_BY_PRESS only: set when Enter enters edit mode, so the EditText key listener
+  // swallows the single paired Enter key-up that would otherwise hide the IME hint.
+  private boolean consumeActivationEnterUp = false;
 
   private static boolean resolveIsNativelyFixedVersion() {
     try {
@@ -62,7 +70,16 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
   private void updateFocusability() {
     this.setFocusable(shouldWrapperBeFocusable());
     if (this.reactEditText != null) {
-      this.reactEditText.setFocusable(shouldEditTextBeFocusable());
+      boolean editTextFocusable = shouldEditTextBeFocusable();
+      this.reactEditText.setFocusable(editTextFocusable);
+      if (focusType == FOCUS_BY_PRESS) {
+        // RN creates every ReactEditText with focusableInTouchMode=true, so in touch
+        // mode the EditText stays a focus candidate even with focusable=false. During
+        // navigation focus would land on the field (flashing the soft keyboard) before
+        // resolving to the wrapper. Clear it so focus goes straight to the wrapper;
+        // handleTextInputFocus restores it when the user enters edit mode.
+        this.reactEditText.setFocusableInTouchMode(editTextFocusable);
+      }
     }
   }
 
@@ -135,9 +152,10 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
       focusabilityListener = new View.OnAttachStateChangeListener() {
         @Override
         public void onViewAttachedToWindow(@NonNull View view) {
-          // Re-apply focusability after React Native attaches the view; the
-          // framework may reset it during the layout/commit phase.
-          view.setFocusable(shouldEditTextBeFocusable());
+          // Re-apply focusability (both focusable and focusableInTouchMode) after
+          // React Native attaches the view; the framework may reset them during the
+          // layout/commit phase.
+          updateFocusability();
         }
         @Override
         public void onViewDetachedFromWindow(@NonNull View view) {}
@@ -172,7 +190,14 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
       if (!hasTextEditFocus) {
         updateFocusability();
         if (focusType == FOCUS_BY_PRESS) {
-          post(() -> TextInputFocusWrapper.this.requestFocus());
+          // Tab/Shift+Tab/arrows blur the EditText as part of moving focus to
+          // another view — leave it there. Otherwise edit mode was exited in
+          // place (Enter/submit, keyboard dismissed), and clearFocus() would let
+          // the framework default focus to the first view on screen, so pull
+          // focus back to the wrapper to stay on this control in its idle state.
+          if (!navigatingAway) {
+            post(() -> TextInputFocusWrapper.this.requestFocus());
+          }
         }
       }
     });
@@ -241,13 +266,29 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
     if (focusType == FOCUS_BY_PRESS && this.reactEditText != null) {
       this.reactEditText.setFocusable(false);
     }
-    if (keyCode == KeyEvent.KEYCODE_SPACE || keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_ENTER) {
+    // Only activate from the wrapper's idle state (wrapper itself focused). While the
+    // EditText is editing it — not the wrapper — holds focus, so an Enter that bubbles
+    // up here must fall through to submit/blur instead of re-entering edit mode.
+    if (isActivationKey(keyCode) && this.isFocused()) {
+      if (keyCode == KeyEvent.KEYCODE_ENTER) {
+        // Focus is about to move to the EditText; the paired Enter key-up will land on
+        // it and ReactEditText.onKeyUp(Enter) would hide the soft-input hint we just
+        // raised (a visible blink). Mark it so the EditText key listener swallows that
+        // one key-up.
+        consumeActivationEnterUp = true;
+      }
       this.handleTextInputFocus();
       return true;
     }
     return super.onKeyDown(keyCode, event);
   }
 
+  private boolean isActivationKey(int keyCode) {
+    return keyCode == KeyEvent.KEYCODE_SPACE
+        || keyCode == KeyEvent.KEYCODE_DPAD_CENTER
+        || keyCode == KeyEvent.KEYCODE_ENTER;
+  }
+
   // --- Touch handling ---
 
   @Override
@@ -281,6 +322,27 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
     return super.focusSearch(direction);
   }
 
+  @Override
+  public View focusSearch(View focused, int direction) {
+    // Called when a descendant (the EditText, in edit mode) drives a directional
+    // focus search. Flag it so the blur handler lets focus move to the next view
+    // instead of pulling it back to the wrapper. Cleared on the next loop tick so
+    // a search that finds no target (no blur fired) doesn't strand the flag.
+    View next = super.focusSearch(focused, direction);
+    if (focusType == FOCUS_BY_PRESS) {
+      navigatingAway = true;
+      post(() -> navigatingAway = false);
+      // Dismiss the IME up front (only when there's actually somewhere to go) so it
+      // hides together with the focus move instead of flashing after the blur. The
+      // destination is an idle wrapper, not an edit field, and Android won't auto-
+      // hide the keyboard when focus leaves an EditText for a plain focusable View.
+      if (next != null && next != focused && this.reactEditText != null) {
+        hideSoftKeyboard(this.reactEditText);
+      }
+    }
+    return next;
+  }
+
   @Override
   public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
     if (focusType != FOCUS_BY_PRESS) {
@@ -299,21 +361,36 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
 
   private void onMultiplyBlurSubmitHandle() {
     if (this.reactEditText == null) return;
-    if (this.multiline) {
-      this.reactEditText.setOnKeyListener((v, keyCode, event) -> {
-        if (event.getAction() == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_ENTER && !event.isShiftPressed()) {
-          Editable editableText = reactEditText.getText();
-          String text = editableText == null ? "" : String.valueOf(editableText);
-          EventHelper.multiplyTextSubmit((ReactContext) context, getId(), text);
-          if (blurOnSubmit && v instanceof EditText) {
-            v.clearFocus();
-            return true;
-          }
+    this.reactEditText.setOnKeyListener((v, keyCode, event) -> {
+      // Swallow the single Enter key-up that immediately follows entering edit mode,
+      // so ReactEditText.onKeyUp doesn't hide the freshly raised soft-input hint.
+      // Runs before the EditText's own onKeyUp, so returning true suppresses the hide.
+      if (consumeActivationEnterUp && event.getAction() == KeyEvent.ACTION_UP
+          && keyCode == KeyEvent.KEYCODE_ENTER) {
+        consumeActivationEnterUp = false;
+        return true;
+      }
+      if (this.multiline && event.getAction() == KeyEvent.ACTION_DOWN
+          && keyCode == KeyEvent.KEYCODE_ENTER && !event.isShiftPressed()) {
+        Editable editableText = reactEditText.getText();
+        String text = editableText == null ? "" : String.valueOf(editableText);
+        EventHelper.multiplyTextSubmit((ReactContext) context, getId(), text);
+        if (blurOnSubmit && v instanceof EditText) {
+          v.clearFocus();
+          return true;
         }
-        return false;
-      });
-    } else {
-      this.reactEditText.setOnKeyListener(null);
+      }
+      return false;
+    });
+  }
+
+  private void hideSoftKeyboard(View view) {
+    try {
+      InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+      if (imm != null) {
+        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
+      }
+    } catch (Exception ignored) {
     }
   }
 
@@ -322,7 +399,8 @@ public class TextInputFocusWrapper extends FocusHighlightBase implements View.On
     this.setFocusable(false);
     this.reactEditText.setFocusable(true);
     // focusableInTouchMode is required for requestFocus() to succeed when the device
-    // is in touch mode (canTakeFocus() returns false without it).
+    // is in touch mode (canTakeFocus() returns false without it), and re-arms the
+    // EditText as a focus target after updateFocusability cleared it for navigation.
     this.reactEditText.setFocusableInTouchMode(true);
     if (!this.reactEditText.hasFocus()) {
       this.reactEditText.requestFocusFromJS();

package/android/src/main/java/com/externalkeyboard/views/TextInputFocusWrapper/TextInputFocusWrapperManager.java

@@ -163,6 +163,11 @@ public class TextInputFocusWrapperManager extends com.externalkeyboard.TextInput
     view.setKeyboardFocusable(value);
   }
 
+  @Override
+  public void setHasOnFocusChanged(TextInputFocusWrapper view, boolean value) {
+    //stub - Android attaches focus listeners unconditionally
+  }
+
   @Override
   @ReactProp(name = "haloEffect", defaultBoolean = true)
   public void setHaloEffect(TextInputFocusWrapper view, boolean value) {
@@ -218,4 +223,10 @@ public class TextInputFocusWrapperManager extends com.externalkeyboard.TextInput
   public void setHaloCornerRadius(TextInputFocusWrapper view, float value) {
 
   }
+
+  @Override
+  @ReactProp(name = "roundedHaloFix")
+  public void setRoundedHaloFix(TextInputFocusWrapper view, boolean value) {
+
+  }
 }

package/android/src/main/java/com/externalkeyboard/views/base/FocusHighlightBase.java

@@ -6,21 +6,27 @@ import android.view.View;
 
 public class FocusHighlightBase extends ViewOrderGroupBase {
   protected boolean focusHighlight = true;
+  protected boolean focusableWrapper = true;
 
   public void setFocusHighlight (boolean defaultFocusHighlightEnabled) {
     focusHighlight = defaultFocusHighlightEnabled;
     syncFocusHighlight();
   }
 
-  protected View getFocusHighlightView () {
-    return this.getFirstChild();
+  public void setFocusableWrapper (boolean isFocusableWrapper) {
+    focusableWrapper = isFocusableWrapper;
+    syncFocusHighlight();
+  }
+
+  protected View getFocusTargetView () {
+    return focusableWrapper ? this.getFirstChild() : this;
   }
 
   protected void syncFocusHighlight () {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      View child = this.getFocusHighlightView();
-      if(child != null) {
-        child.setDefaultFocusHighlightEnabled(focusHighlight);
+      View view = getFocusTargetView();
+      if(view != null) {
+        view.setDefaultFocusHighlightEnabled(focusHighlight);
       }
     }
   }