react-native-external-keyboard 0.8.4-rc2 → 0.8.5-rc

package/android/src/main/java/com/externalkeyboard/delegates/FocusOrderDelegate.java

@@ -5,10 +5,8 @@ import android.view.View;
 import com.externalkeyboard.helper.Linking.A11yOrderLinking;
 import com.externalkeyboard.services.FocusLinkObserver.FocusLinkObserver;
 import com.externalkeyboard.services.FocusLinkObserver.FocusLinkObserverSingleton;
-import com.externalkeyboard.views.ExternalKeyboardView.ExternalKeyboardView;
-
 public class FocusOrderDelegate {
-  private final ExternalKeyboardView delegate;
+  private final FocusOrderDelegateHost delegate;
 
   FocusLinkObserver.LinkUpdatedCallback leftUpdated = null;
   FocusLinkObserver.LinkRemovedCallback leftRemoved = null;
@@ -20,7 +18,7 @@ public class FocusOrderDelegate {
   FocusLinkObserver.LinkRemovedCallback downRemoved = null;
 
 
-  public FocusOrderDelegate(ExternalKeyboardView delegate) {
+  public FocusOrderDelegate(FocusOrderDelegateHost delegate) {
     super();
     this.delegate = delegate;
   }

package/android/src/main/java/com/externalkeyboard/delegates/FocusOrderDelegateHost.java

@@ -0,0 +1,14 @@
+package com.externalkeyboard.delegates;
+
+import android.view.View;
+
+public interface FocusOrderDelegateHost {
+  View getFirstChild();
+  String getOrderGroup();
+  Integer getOrderIndex();
+  String getOrderId();
+  String getOrderLeft();
+  String getOrderRight();
+  String getOrderUp();
+  String getOrderDown();
+}

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

@@ -9,6 +9,7 @@ import android.view.ViewTreeObserver;
 import android.view.accessibility.AccessibilityEvent;
 
 import com.externalkeyboard.delegates.FocusOrderDelegate;
+import com.externalkeyboard.delegates.FocusOrderDelegateHost;
 import com.externalkeyboard.events.EventHelper;
 
 import com.externalkeyboard.helper.FocusHelper;
@@ -22,7 +23,7 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import com.facebook.react.views.view.ReactViewGroup;
 
-public class ExternalKeyboardView extends ReactViewGroup {
+public class ExternalKeyboardView extends ReactViewGroup implements FocusOrderDelegateHost {
   public boolean hasKeyDownListener = false;
   public boolean hasKeyUpListener = false;
   public boolean autoFocus = false;

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

@@ -10,16 +10,18 @@ import android.widget.EditText;
 
 import androidx.annotation.NonNull;
 
+import com.externalkeyboard.delegates.FocusOrderDelegate;
+import com.externalkeyboard.delegates.FocusOrderDelegateHost;
 import com.externalkeyboard.events.EventHelper;
+import com.externalkeyboard.helper.FocusHelper;
 import com.externalkeyboard.helper.ReactNativeVersionChecker;
 import com.externalkeyboard.modules.ExternalKeyboardModule;
 import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.systeminfo.ReactNativeVersion;
 import com.facebook.react.views.textinput.ReactEditText;
 
 import java.lang.reflect.Field;
 
-public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChangeListener {
+public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChangeListener, FocusOrderDelegateHost {
   private final Context context;
   public static final byte FOCUS_BY_PRESS = 1;
   private ReactEditText reactEditText = null;
@@ -30,12 +32,104 @@ public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChan
   private boolean multiline = false;
   private boolean keyboardFocusable = true;
   private static View focusedView = null;
+
+  public int lockFocus = 0;
+  public String orderForward;
+  public String orderBackward;
+  public String orderId;
+
+  private Integer orderIndex;
+  private String orderGroup;
+  private String orderUp;
+  private String orderDown;
+  private String orderLeft;
+  private String orderRight;
+
+  private FocusOrderDelegate focusOrderDelegate;
+  private boolean isLinked = false;
+
   public boolean getIsFocusByPress() {
     return focusType == FOCUS_BY_PRESS;
   }
+
+  // FocusOrderDelegateHost implementation
+  @Override
+  public View getFirstChild() {
+    return this.reactEditText;
+  }
+
+  @Override
+  public String getOrderGroup() {
+    return orderGroup;
+  }
+
+  @Override
+  public Integer getOrderIndex() {
+    return orderIndex;
+  }
+
+  @Override
+  public String getOrderId() {
+    return orderId;
+  }
+
+  @Override
+  public String getOrderLeft() {
+    return orderLeft;
+  }
+
+  @Override
+  public String getOrderRight() {
+    return orderRight;
+  }
+
+  @Override
+  public String getOrderUp() {
+    return orderUp;
+  }
+
+  @Override
+  public String getOrderDown() {
+    return orderDown;
+  }
+
+  public void setOrderGroup(String orderGroup) {
+    focusOrderDelegate.updateOrderGroup(this.orderGroup, orderGroup);
+    this.orderGroup = orderGroup;
+  }
+
+  public void setOrderIndex(int orderIndex) {
+    if (this.orderIndex == null) {
+      this.orderIndex = orderIndex;
+    } else {
+      this.orderIndex = orderIndex;
+      focusOrderDelegate.refreshOrder();
+    }
+  }
+
+  public void setOrderLeft(String orderLeft) {
+    focusOrderDelegate.refreshLeft(this.orderLeft, orderLeft);
+    this.orderLeft = orderLeft;
+  }
+
+  public void setOrderRight(String orderRight) {
+    focusOrderDelegate.refreshRight(this.orderRight, orderRight);
+    this.orderRight = orderRight;
+  }
+
+  public void setOrderUp(String orderUp) {
+    focusOrderDelegate.refreshUp(this.orderUp, orderUp);
+    this.orderUp = orderUp;
+  }
+
+  public void setOrderDown(String orderDown) {
+    focusOrderDelegate.refreshDown(this.orderDown, orderDown);
+    this.orderDown = orderDown;
+  }
+
   private boolean getIsNativelyFixedVersion () {
     try {
-      Object minorValue = ReactNativeVersion.VERSION.getOrDefault("minor", 0);
+      Object minorValue = com.facebook.react.modules.systeminfo.ReactNativeVersion.VERSION.getOrDefault("minor", 0);
       int minor = (minorValue instanceof Integer) ? (int) minorValue : 0;
       return minor >= 79;
     } catch (Exception e) {
@@ -62,12 +156,14 @@ public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChan
       onAttachListener = new View.OnAttachStateChangeListener() {
         @Override
         public void onViewAttachedToWindow(@NonNull View view) {
+          focusOrderDelegate.link();
           boolean isAlreadyFixed = getIsNativelyFixedVersion();
           view.setFocusable(isAlreadyFixed);
         }
 
         @Override
         public void onViewDetachedFromWindow(@NonNull View view) {
+          focusOrderDelegate.unlink(view);
         }
       };
     }
@@ -143,6 +239,7 @@ public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChan
   public TextInputFocusWrapper(Context context) {
     super(context);
     this.context = context;
+    this.focusOrderDelegate = new FocusOrderDelegate(this);
 
     if (keyboardFocusable) {
       boolean isAlreadyFixed = getIsNativelyFixedVersion();
@@ -159,8 +256,42 @@ public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChan
     onMultiplyBlurSubmitHandle();
   }
 
+  @Override
+  public View focusSearch(View focused, int direction) {
+    if (lockFocus == 0 && orderForward == null && orderBackward == null) {
+      return super.focusSearch(focused, direction);
+    }
+
+    boolean isLocked = FocusHelper.isLocked(direction, lockFocus);
+    if (isLocked) {
+      return this;
+    }
+
+    if (direction == FOCUS_FORWARD && orderForward != null) {
+      View nextView = this.focusOrderDelegate.getLink(orderForward);
+      if (isValidLinkedFocusTarget(nextView)) {
+        return nextView;
+      }
+    }
+
+    if (direction == FOCUS_BACKWARD && orderBackward != null) {
+      View prevView = this.focusOrderDelegate.getLink(orderBackward);
+      if (isValidLinkedFocusTarget(prevView)) {
+        return prevView;
+      }
+    }
+
+    return super.focusSearch(focused, direction);
+  }
+
   @Override
   public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (lockFocus != 0) {
+      boolean isLocked = FocusHelper.isKeyLocked(keyCode, lockFocus);
+      if (isLocked) {
+        return true;
+      }
+    }
     if (focusType == FOCUS_BY_PRESS) {
       this.reactEditText.setFocusable(false);
     }
@@ -217,6 +348,22 @@ public class TextInputFocusWrapper extends ViewGroup implements View.OnFocusChan
     }
   }
 
+  private boolean isValidLinkedFocusTarget(View target) {
+    if (target == null || !target.isAttachedToWindow() || !this.isAttachedToWindow()) {
+      return false;
+    }
+
+    if (target.getWindowToken() == null || this.getWindowToken() == null) {
+      return false;
+    }
+
+    if (target.getWindowToken() != this.getWindowToken()) {
+      return false;
+    }
+
+    return target.getRootView() == this.getRootView();
+  }
+
   @Override
   protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
     // No-op since UIManagerModule handles actually laying out children.

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

@@ -6,6 +6,8 @@ import android.view.ViewGroup;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
+import java.util.Objects;
+
 import com.externalkeyboard.events.FocusChangeEvent;
 import com.externalkeyboard.events.MultiplyTextSubmit;
 import com.externalkeyboard.views.ExternalKeyboardView.ExternalKeyboardView;
@@ -89,6 +91,96 @@ public class TextInputFocusWrapperManager extends com.externalkeyboard.TextInput
     //stub
   }
 
+  @Override
+  @ReactProp(name = "orderGroup")
+  public void setOrderGroup(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.getOrderGroup(), value)) {
+      view.setOrderGroup(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderIndex")
+  public void setOrderIndex(TextInputFocusWrapper view, int value) {
+    if (!Objects.equals(view.getOrderIndex(), value)) {
+      view.setOrderIndex(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderId")
+  public void setOrderId(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.orderId, value)) {
+      view.orderId = value;
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderLeft")
+  public void setOrderLeft(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.getOrderLeft(), value)) {
+      view.setOrderLeft(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderRight")
+  public void setOrderRight(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.getOrderRight(), value)) {
+      view.setOrderRight(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderUp")
+  public void setOrderUp(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.getOrderUp(), value)) {
+      view.setOrderUp(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderDown")
+  public void setOrderDown(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.getOrderDown(), value)) {
+      view.setOrderDown(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderForward")
+  public void setOrderForward(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.orderForward, value)) {
+      view.orderForward = value;
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderBackward")
+  public void setOrderBackward(TextInputFocusWrapper view, @Nullable String value) {
+    if (!Objects.equals(view.orderBackward, value)) {
+      view.orderBackward = value;
+    }
+  }
+
+  @Override
+  @ReactProp(name = "lockFocus")
+  public void setLockFocus(TextInputFocusWrapper view, int value) {
+    if (view.lockFocus != value) {
+      view.lockFocus = value;
+    }
+  }
+
+  @Override
+  public void setOrderFirst(TextInputFocusWrapper view, @Nullable String value) {
+    //stub
+  }
+
+  @Override
+  public void setOrderLast(TextInputFocusWrapper view, @Nullable String value) {
+    //stub
+  }
+
 
   @Override
   @ReactProp(name = "canBeFocused", defaultBoolean = true)

package/android/src/oldarch/TextInputFocusWrapperManagerSpec.java

@@ -23,4 +23,28 @@ public abstract class TextInputFocusWrapperManagerSpec<T extends ViewGroup> exte
   public abstract void setMultiline(TextInputFocusWrapper view, boolean value);
 
   public abstract void setGroupIdentifier(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderGroup(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderIndex(TextInputFocusWrapper view, int value);
+
+  public abstract void setOrderId(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderLeft(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderRight(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderUp(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderDown(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderForward(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderBackward(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setLockFocus(TextInputFocusWrapper view, int value);
+
+  public abstract void setOrderFirst(TextInputFocusWrapper view, @Nullable String value);
+
+  public abstract void setOrderLast(TextInputFocusWrapper view, @Nullable String value);
 }

package/ios/Delegates/RNCEKVFocusOrderDelegate/RNCEKVFocusOrderDelegate.mm

@@ -92,8 +92,8 @@ static NSNumber *const FOCUS_UPDATE = @1;
 }
 
 - (void)keyboardedViewFocus:(UIView *)view {
-  if ([view isKindOfClass:[RNCEKVExternalKeyboardView class]]) {
-    [(RNCEKVExternalKeyboardView*)view focus];
+  if ([view respondsToSelector:@selector(focus)]) {
+    [(id)view focus];
   }
 }
 

package/ios/Views/RNCEKVExternalKeyboardView/RNCEKVExternalKeyboardView.mm

@@ -265,12 +265,6 @@ using namespace facebook::react;
     [self setHasOnFocusChanged:newViewProps.hasOnFocusChanged];
   }
 
-  BOOL isLockChanged = [RNCEKVPropHelper isPropChanged:_lockFocus intValue: newViewProps.lockFocus];
-  if(isLockChanged) {
-    NSNumber* lockValue = [RNCEKVPropHelper unwrapIntValue: newViewProps.lockFocus];
-    [self setLockFocus: lockValue];
-  }
-
   if (oldViewProps.canBeFocused != newViewProps.canBeFocused) {
     [self setCanBeFocused:newViewProps.canBeFocused];
   }
@@ -288,6 +282,11 @@ using namespace facebook::react;
     [self setAutoFocus:hasAutoFocus];
   }
 
+  BOOL isLockChanged = [RNCEKVPropHelper isPropChanged:_lockFocus intValue: newViewProps.lockFocus];
+  if(isLockChanged) {
+    NSNumber* lockValue = [RNCEKVPropHelper unwrapIntValue: newViewProps.lockFocus];
+    [self setLockFocus: lockValue];
+  }
 
   BOOL isIndexChanged = [RNCEKVPropHelper isPropChanged:_orderPosition intValue: newViewProps.orderIndex];
   if(isIndexChanged) {

package/ios/Views/RNCEKVTextInputFocusWrapper/RNCEKVTextInputFocusWrapper.h

@@ -3,6 +3,7 @@
 #import <UIKit/UIKit.h>
 #import <React/RCTUITextField.h>
 #import "RNCEKVGroupIdentifierProtocol.h"
+#import "RNCEKVFocusOrderProtocol.h"
 #import <React/RCTUITextView.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -11,7 +12,12 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface RNCEKVTextInputFocusWrapper : RCTViewComponentView <RNCEKVGroupIdentifierProtocol>{
+#define RKNA_PROP_UPDATE(prop, setter, newProps) \
+if ([RNCEKVPropHelper isPropChanged: _##prop stringValue: newProps.prop]) { \
+[self setter: [RNCEKVPropHelper unwrapStringValue: newProps.prop]]; \
+}
+
+@interface RNCEKVTextInputFocusWrapper : RCTViewComponentView <RNCEKVGroupIdentifierProtocol, RNCEKVFocusOrderProtocol>{
     RCTUITextField* _textField;
     RCTUITextView* _textView;
 }
@@ -23,6 +29,21 @@ NS_ASSUME_NONNULL_BEGIN
 @property int blurType;
 @property BOOL multiline;
 @property (nonatomic, strong, nullable) NSString *customGroupId;
+
+// RNCEKVFocusOrderProtocol
+@property (nonatomic, strong) NSString* orderGroup;
+@property NSNumber* lockFocus;
+@property NSNumber* orderPosition;
+@property (nonatomic, strong) NSString* orderLeft;
+@property (nonatomic, strong) NSString* orderRight;
+@property (nonatomic, strong) NSString* orderUp;
+@property (nonatomic, strong) NSString* orderDown;
+@property NSString* orderForward;
+@property NSString* orderBackward;
+@property NSString* orderLast;
+@property NSString* orderFirst;
+@property (nonatomic, strong) NSString* orderId;
+
 - (UIView*)getFocusTargetView;
 
 - (void)onFocusChange:(BOOL)isFocused;
@@ -37,7 +58,7 @@ NS_ASSUME_NONNULL_END
 
 
 #import <React/RCTView.h>
-@interface RNCEKVTextInputFocusWrapper : RCTView <RNCEKVGroupIdentifierProtocol>{
+@interface RNCEKVTextInputFocusWrapper : RCTView <RNCEKVGroupIdentifierProtocol, RNCEKVFocusOrderProtocol>{
     RCTUITextField* _textField;
     RCTUITextView* _textView;
 }
@@ -51,6 +72,21 @@ NS_ASSUME_NONNULL_END
 @property (nonatomic, copy) RCTDirectEventBlock onFocusChange;
 @property (nonatomic, copy) RCTDirectEventBlock onMultiplyTextSubmit;
 @property NSString* customGroupId;
+
+// RNCEKVFocusOrderProtocol
+@property (nonatomic, strong) NSString* orderGroup;
+@property NSNumber* lockFocus;
+@property NSNumber* orderPosition;
+@property (nonatomic, strong) NSString* orderLeft;
+@property (nonatomic, strong) NSString* orderRight;
+@property (nonatomic, strong) NSString* orderUp;
+@property (nonatomic, strong) NSString* orderDown;
+@property NSString* orderForward;
+@property NSString* orderBackward;
+@property NSString* orderLast;
+@property NSString* orderFirst;
+@property (nonatomic, strong) NSString* orderId;
+
 - (UIView*)getFocusTargetView;
 
 - (void)onFocusChange:(BOOL)isFocused;