react-native-external-keyboard 0.8.5 → 0.9.1

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

@@ -0,0 +1,190 @@
+package com.externalkeyboard.views.base;
+
+import android.content.Context;
+import android.view.FocusFinder;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.externalkeyboard.delegates.FocusOrderDelegate;
+import com.externalkeyboard.delegates.FocusOrderDelegateHost;
+import com.externalkeyboard.helper.FocusHelper;
+import com.externalkeyboard.helper.ReactNativeVersionChecker;
+
+public class ViewOrderGroupBase extends ViewGroupBase implements FocusOrderDelegateHost {
+  public int lockFocus = 0;
+
+  private View firstChild;
+
+  private Integer orderIndex;
+  private String orderGroup;
+
+  public String orderId;
+  private String orderUp;
+  private String orderDown;
+  private String orderLeft;
+  private String orderRight;
+  public String orderForward;
+  public String orderBackward;
+
+  protected FocusOrderDelegate focusOrderDelegate;
+
+
+  public String getOrderRight() {
+    return orderRight;
+  }
+
+  public void setOrderRight(String orderRight) {
+    focusOrderDelegate.refreshRight(this.orderRight, orderRight);
+    this.orderRight = orderRight;
+  }
+
+  public String getOrderLeft() {
+    return orderLeft;
+  }
+
+  public void setOrderLeft(String orderLeft) {
+    focusOrderDelegate.refreshLeft(this.orderLeft, orderLeft);
+    this.orderLeft = orderLeft;
+  }
+
+  public String getOrderDown() {
+    return orderDown;
+  }
+
+  public void setOrderDown(String orderDown) {
+    focusOrderDelegate.refreshDown(this.orderDown, orderDown);
+    this.orderDown = orderDown;
+  }
+
+  public String getOrderUp() {
+    return orderUp;
+  }
+
+  public void setOrderUp(String orderUp) {
+    focusOrderDelegate.refreshUp(this.orderUp, orderUp);
+    this.orderUp = orderUp;
+  }
+
+  public String getOrderGroup() {
+    return this.orderGroup;
+  }
+
+  public String getOrderId() {
+    return this.orderId;
+  }
+
+  public void setOrderGroup(String orderGroup) {
+    focusOrderDelegate.updateOrderGroup(this.orderGroup, orderGroup);
+    this.orderGroup = orderGroup;
+  }
+
+  public Integer getOrderIndex() {
+    return this.orderIndex;
+  }
+
+
+  public void setOrderIndex(int orderIndex) {
+    if(orderIndex == -1) {
+      this.orderIndex = null;
+      return;
+    }
+    boolean wasSet = this.orderIndex != null;
+    this.orderIndex = orderIndex;
+    if (wasSet) {
+      focusOrderDelegate.refreshOrder();
+    }
+  }
+
+  public View getFirstChild() {
+    return this.firstChild;
+  }
+
+  public ViewOrderGroupBase(Context context) {
+    super(context);
+    this.focusOrderDelegate = new FocusOrderDelegate(this);
+  }
+
+  @Override
+  public void onViewAdded(View child) {
+    super.onViewAdded(child);
+    linkAddView(child);
+  }
+
+  @Override
+  public void onViewRemoved(View child) {
+    super.onViewRemoved(child);
+    linkRemoveView(child);
+  }
+
+  public void linkAddView(View child) {
+    if (firstChild == null) {
+      firstChild = child;
+      focusOrderDelegate.link();
+    }
+  }
+
+  public void linkRemoveView(View view) {
+    if (view == firstChild) {
+      focusOrderDelegate.unlink();
+      firstChild = null;
+    }
+  }
+
+
+  @Override
+  public View focusSearch(View focused, int direction) {
+    if (lockFocus == 0 && orderGroup == null && orderIndex == null && 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;
+      }
+    }
+
+    if (ReactNativeVersionChecker.isReactNative80OrLater()) {
+      if (orderGroup != null && orderIndex != null && (direction == FOCUS_FORWARD || direction == FOCUS_BACKWARD)) {
+        return FocusFinder.getInstance().findNextFocus((ViewGroup) this.getParent(), focused, direction);
+      }
+    }
+
+    return super.focusSearch(focused, direction);
+  }
+
+  protected boolean isFocusLocked(KeyEvent keyEvent) {
+    if (lockFocus != 0) {
+      int keyCode = keyEvent.getKeyCode();
+      return FocusHelper.isKeyLocked(keyCode, lockFocus);
+    }
+
+    return false;
+  }
+
+
+  private boolean isValidLinkedFocusTarget(View target) {
+    if (target == null || !target.isAttachedToWindow() || !this.isAttachedToWindow()) {
+      return false;
+    }
+
+    return target.getWindowToken() == this.getWindowToken();
+  }
+
+  public void onDropViewInstance() {
+    focusOrderDelegate.cleanByOrderId(orderId);
+  }
+}

package/android/src/main/java/com/externalkeyboard/views/base/keyboard/ViewFocusChangeBase.java

@@ -0,0 +1,39 @@
+package com.externalkeyboard.views.base.keyboard;
+
+import android.content.Context;
+import android.view.View;
+
+import com.externalkeyboard.events.EventHelper;
+import com.externalkeyboard.views.base.FocusHighlightBase;
+import com.facebook.react.bridge.ReactContext;
+
+public class ViewFocusChangeBase extends FocusHighlightBase {
+  private View listeningView;
+  private final Context context;
+
+  public ViewFocusChangeBase(Context context) {
+    super(context);
+    this.context = context;
+  }
+
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+
+    this.listeningView = getFocusingView();
+    setFocusable(this.listeningView == this);
+
+    this.listeningView.setOnFocusChangeListener((focusedView, hasFocus) -> {
+      EventHelper.focusChanged((ReactContext) context, this.getId(), hasFocus);
+    });
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    if (this.listeningView != null) {
+      this.listeningView.setOnFocusChangeListener(null);
+    }
+  }
+}

package/android/src/main/java/com/externalkeyboard/views/base/keyboard/ViewFocusRequestBase.java

@@ -0,0 +1,125 @@
+package com.externalkeyboard.views.base.keyboard;
+
+import android.content.Context;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.accessibility.AccessibilityEvent;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.common.ViewUtil;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.uimanager.events.EventDispatcherListener;
+
+
+public class ViewFocusRequestBase extends ViewFocusChangeBase {
+  public boolean autoFocus = false;
+  public boolean enableA11yFocus = false;
+  public boolean hasBeenFocused = false;
+  public boolean hasBeenA11yFocused = false;
+
+  public boolean screenAutoA11yFocus = false;
+
+  public int screenAutoA11yFocusDelay = 500;
+
+  private EventDispatcher a11yViewAppearDispatcher = null;
+  private EventDispatcherListener eventA11yViewAppearListener = null;
+  private final Context context;
+
+  public ViewFocusRequestBase(Context context) {
+    super(context);
+    this.context = context;
+  }
+
+  private void onRnScreenViewAppear() {
+    boolean a11yAutoFocus = autoFocus && enableA11yFocus && !hasBeenA11yFocused && screenAutoA11yFocus;
+    if (!a11yAutoFocus) return;
+
+    try {
+      int reactTag = this.getId();
+      int uiManagerType = ViewUtil.getUIManagerType(reactTag);
+      a11yViewAppearDispatcher = UIManagerHelper.getEventDispatcher((ReactContext) context, uiManagerType);
+      if (a11yViewAppearDispatcher == null) return;
+      View focusingView = this.getFocusingView();
+
+
+      eventA11yViewAppearListener = new EventDispatcherListener() {
+        @Override
+        public void onEventDispatch(Event event) {
+          if ("topClick".equals(event.getEventName())) {
+            a11yViewAppearDispatcher.removeListener(this);
+            eventA11yViewAppearListener = null;
+            hasBeenA11yFocused = true;
+          }
+          if ("topFinishTransitioning".equals(event.getEventName()) || "topShow".equals(event.getEventName())) {
+            if (hasBeenA11yFocused) return;
+            hasBeenA11yFocused = true;
+
+            focusingView.postDelayed(() -> {
+              focus(false, true);
+              a11yViewAppearDispatcher.removeListener(this);
+              eventA11yViewAppearListener = null;
+            }, screenAutoA11yFocusDelay);
+          }
+        }
+      };
+      a11yViewAppearDispatcher.addListener(eventA11yViewAppearListener);
+    } catch (Exception ignored) {
+    }
+  }
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+
+    if (autoFocus && !hasBeenFocused) {
+      this.autoFocusOnDraw();
+      hasBeenFocused = true;
+    }
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    if (this.a11yViewAppearDispatcher != null && this.eventA11yViewAppearListener != null) {
+      this.a11yViewAppearDispatcher.removeListener(this.eventA11yViewAppearListener);
+      a11yViewAppearDispatcher = null;
+      eventA11yViewAppearListener = null;
+    }
+  }
+
+  private void autoFocusOnDraw() {
+    getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+      @Override
+      public boolean onPreDraw() {
+        onRnScreenViewAppear();
+        getViewTreeObserver().removeOnPreDrawListener(this);
+        focus();
+
+        return true;
+      }
+    });
+  }
+
+  private void a11yFocus(View view) {
+    if (!enableA11yFocus) return;
+    view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
+  }
+
+  public void focus(boolean keyboard, boolean a11y) {
+    View focusingView = this.getFocusingView();
+    if (keyboard) {
+      focusingView.requestFocus();
+    }
+    if (a11y) {
+      a11yFocus(focusingView);
+    }
+  }
+
+
+  public void focus() {
+    this.focus(true, true);
+  }
+
+}

package/android/src/main/java/com/externalkeyboard/views/base/keyboard/ViewKeyHandlerBase.java

@@ -0,0 +1,40 @@
+package com.externalkeyboard.views.base.keyboard;
+
+import android.content.Context;
+import android.view.KeyEvent;
+
+import com.externalkeyboard.events.EventHelper;
+import com.externalkeyboard.services.KeyboardKeyPressHandler;
+import com.facebook.react.bridge.ReactContext;
+
+public class ViewKeyHandlerBase extends ViewFocusRequestBase {
+  public boolean hasKeyDownListener = false;
+  public boolean hasKeyUpListener = false;
+  private final Context context;
+
+  private final KeyboardKeyPressHandler keyboardKeyPressHandler;
+
+  public ViewKeyHandlerBase(Context context) {
+    super(context);
+    this.context = context;
+
+    this.keyboardKeyPressHandler = new KeyboardKeyPressHandler();
+  }
+
+  protected boolean hasKeyListener() {
+    return this.hasKeyUpListener || this.hasKeyDownListener;
+  }
+
+  protected void handleKeyPress(KeyEvent keyEvent) {
+    int keyCode = keyEvent.getKeyCode();
+    KeyboardKeyPressHandler.PressInfo pressInfo = keyboardKeyPressHandler.getEventsFromKeyPress(keyCode, keyEvent);
+
+    if (pressInfo.firePressDownEvent && this.hasKeyDownListener) {
+      EventHelper.pressDown((ReactContext) context, this.getId(), keyCode, keyEvent);
+    }
+
+    if (pressInfo.firePressUpEvent && this.hasKeyUpListener) {
+      EventHelper.pressUp((ReactContext) context, this.getId(), keyCode, keyEvent, pressInfo.isLongPress);
+    }
+  }
+}

package/android/src/newarch/TextInputFocusWrapperManagerSpec.java

@@ -4,21 +4,15 @@ import android.view.ViewGroup;
 
 import androidx.annotation.Nullable;
 
-import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.views.view.ReactViewManager;
 import com.facebook.react.uimanager.ViewManagerDelegate;
 import com.facebook.react.viewmanagers.TextInputFocusWrapperManagerDelegate;
 import com.facebook.react.viewmanagers.TextInputFocusWrapperManagerInterface;
 
-public abstract class TextInputFocusWrapperManagerSpec<T extends ViewGroup> extends ViewGroupManager<T> implements TextInputFocusWrapperManagerInterface<T> {
+public abstract class TextInputFocusWrapperManagerSpec<T extends ViewGroup> extends ReactViewManager implements TextInputFocusWrapperManagerInterface<T> {
   private final ViewManagerDelegate<T> mDelegate;
 
   public TextInputFocusWrapperManagerSpec() {
     mDelegate = new TextInputFocusWrapperManagerDelegate(this);
   }
-
-  @Nullable
-  @Override
-  protected ViewManagerDelegate<T> getDelegate() {
-    return mDelegate;
-  }
 }

package/android/src/oldarch/ExternalKeyboardLockViewManagerSpec.java

@@ -8,5 +8,6 @@ import com.facebook.react.views.view.ReactViewManager;
 public abstract class ExternalKeyboardLockViewManagerSpec<T extends ExternalKeyboardLockView> extends ReactViewManager {
   public abstract void setComponentType(T view, int value);
   public abstract void setLockDisabled(T view, boolean value);
+  public abstract void setForceLock(T view, boolean value);
 }
 

package/android/src/oldarch/TextInputFocusWrapperManagerSpec.java

@@ -5,9 +5,9 @@ import android.view.ViewGroup;
 import androidx.annotation.Nullable;
 
 import com.externalkeyboard.views.TextInputFocusWrapper.TextInputFocusWrapper;
-import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.views.view.ReactViewManager;
 
-public abstract class TextInputFocusWrapperManagerSpec<T extends ViewGroup> extends ViewGroupManager<T> {
+public abstract class TextInputFocusWrapperManagerSpec<T extends ViewGroup> extends ReactViewManager {
   public abstract void setCanBeFocused(T wrapper, boolean canBeFocused);
 
   public abstract void setFocusType(T wrapper, int focusType);
@@ -23,4 +23,34 @@ 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);
+
+  public abstract void setHaloExpendY(TextInputFocusWrapper view, float value);
+
+  public abstract void setHaloExpendX(TextInputFocusWrapper view, float value);
+
+  public abstract void setHaloCornerRadius(TextInputFocusWrapper view, float value);
 }

package/ios/Delegates/RNCEKVFocusLinkDelegate/RNCEKVFocusLinkDelegate.h

@@ -0,0 +1,35 @@
+//
+//  RNCEKVFocusLinkDelegate.h
+//  react-native-external-keyboard
+//
+
+#ifndef RNCEKVFocusLinkDelegate_h
+#define RNCEKVFocusLinkDelegate_h
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVFocusOrderProtocol.h"
+#import "RNCEKVFocusGuideHelper.h"
+
+@interface RNCEKVFocusLinkDelegate : NSObject
+
+- (instancetype _Nonnull)initWithView:(UIView<RNCEKVFocusOrderProtocol> *_Nonnull)view;
+
+- (NSNumber *_Nullable)shouldUpdateFocusInContext:(UIFocusUpdateContext *_Nonnull)context;
+
+- (void)link;
+- (void)unlink;
+
+- (void)linkId;
+- (void)refreshId:(NSString *_Nullable)prev next:(NSString *_Nullable)next;
+- (void)setIsFocused:(BOOL)value;
+
+- (void)refreshLeft:(NSString *_Nullable)next;
+- (void)refreshRight:(NSString *_Nullable)next;
+- (void)refreshUp:(NSString *_Nullable)next;
+- (void)refreshDown:(NSString *_Nullable)next;
+
+- (void)clear;
+
+@end
+
+#endif /* RNCEKVFocusLinkDelegate_h */