react-native-external-keyboard 0.5.6 → 0.6.1-rc

package/android/src/main/java/com/externalkeyboard/helper/Linking/LinkingQueue.java

@@ -0,0 +1,94 @@
+package com.externalkeyboard.helper.Linking;
+
+import android.view.View;
+
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class LinkingQueue {
+  public NavigableSet<Integer> positions = new TreeSet<>();
+  public NavigableMap<Integer, View> viewMap = new TreeMap<>();
+
+
+  private void linkPosition(View prev, View next) {
+    if (prev != null && next != null) {
+      prev.setNextFocusForwardId(next.getId());
+    }
+  }
+
+  private void addWithLinking(int position, View currentView) {
+    viewMap.put(position, currentView);
+    Map.Entry<Integer, View> nextView = viewMap.higherEntry(position);
+    Map.Entry<Integer, View> prevView = viewMap.lowerEntry(position);
+
+    if (prevView != null) {
+      this.linkPosition(prevView.getValue(), currentView);
+    }
+
+    if (nextView != null) {
+      this.linkPosition(currentView, nextView.getValue());
+    }
+  }
+
+  private void unlinkLast() {
+    Map.Entry<Integer, View> lastView = viewMap.lastEntry();
+    if (lastView != null) {
+      lastView.getValue().setNextFocusForwardId(View.NO_ID);
+    }
+  }
+
+
+  private void reLinkWithRemove(int position) {
+    Map.Entry<Integer, View> nextView = viewMap.higherEntry(position);
+    Map.Entry<Integer, View> prevView = viewMap.lowerEntry(position);
+
+    if (prevView != null && nextView != null) {
+      this.linkPosition(prevView.getValue(), nextView.getValue());
+    }
+
+    boolean shouldUnlinkLast = nextView == null;
+    this.viewMap.remove(position);
+
+    if (shouldUnlinkLast) {
+      this.unlinkLast();
+    }
+  }
+
+  public void addPosition(View view, int position) {
+    if (this.viewMap.get(position) == view) {
+      return;
+    }
+
+    this.addWithLinking(position, view);
+  }
+
+  public void removeFromOrder(int position) {
+    if (!this.viewMap.containsKey(position)) return;
+    this.reLinkWithRemove(position);
+  }
+
+  public void refreshIndexes(View view, int position) {
+    this.viewMap.put(position, view);
+
+    for (Map.Entry<Integer, View> positionEntry : this.viewMap.entrySet()) {
+      if (positionEntry != null) {
+        View currentView = positionEntry.getValue();
+        Map.Entry<Integer, View> nextEntry = this.viewMap.higherEntry(positionEntry.getKey());
+
+        if (nextEntry != null) {
+          linkPosition(currentView, nextEntry.getValue());
+        }
+      }
+    }
+
+    unlinkLast();
+  }
+
+  public boolean isEmpty() {
+    return positions.isEmpty() && viewMap.isEmpty();
+  }
+
+}

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

@@ -0,0 +1,24 @@
+package com.externalkeyboard.helper;
+
+import com.facebook.react.views.textinput.ReactEditText;
+
+import java.lang.reflect.Field;
+
+public class ReactNativeVersionChecker {
+  private static Boolean is80OrLaterVersion = null;
+
+  public static boolean isReactNative80OrLater() {
+    if (is80OrLaterVersion != null) {
+      return is80OrLaterVersion;
+    }
+
+    try {
+      Field field = ReactEditText.class.getDeclaredField("dragAndDropFilter");
+      is80OrLaterVersion = true;
+    } catch (NoSuchFieldException e) {
+      is80OrLaterVersion = false;
+    }
+
+    return is80OrLaterVersion;
+  }
+}

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

@@ -0,0 +1,131 @@
+package com.externalkeyboard.services.FocusLinkObserver;
+
+import android.view.View;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FocusLinkObserver {
+  private final Map<String, View> links;
+  private final Map<String, List<Subscriber>> subscribers;
+
+  public FocusLinkObserver() {
+    links = new HashMap<>();
+    subscribers = new HashMap<>();
+  }
+
+  public void emit(String id, View link) {
+    if (id == null || link == null) {
+      throw new IllegalArgumentException("Both id and link are required");
+    }
+
+    links.put(id, link);
+    emitLinkUpdated(id, link);
+  }
+
+
+  public void emitRemove(String id) {
+    if (links.containsKey(id)) {
+      links.remove(id);  // Remove the link
+      emitLinkRemoved(id);  // Notify subscribers
+      subscribers.remove(id);  // Clean up subscribers for the ID
+    }
+  }
+
+  public void subscribe(String id, LinkUpdatedCallback onLinkUpdated, LinkRemovedCallback onLinkRemoved) {
+    if (id == null || (onLinkUpdated == null && onLinkRemoved == null)) {
+      return;
+    }
+
+    subscribers.putIfAbsent(id, new ArrayList<>());
+    subscribers.get(id).add(new Subscriber(onLinkUpdated, onLinkRemoved));
+
+    if (onLinkUpdated != null && links.containsKey(id)) {
+      onLinkUpdated.onLinkUpdated(links.get(id));
+    }
+  }
+
+  public void unsubscribe(String id, LinkUpdatedCallback onLinkUpdated, LinkRemovedCallback onLinkRemoved) {
+    if (id == null || (onLinkUpdated == null && onLinkRemoved == null)) {
+      return;
+    }
+
+    List<Subscriber> subscriberList = subscribers.get(id);
+    if (subscriberList != null) {
+      subscriberList.removeIf(subscriber -> {
+        LinkUpdatedCallback updatedCallback = subscriber.onLinkUpdated.get();
+        LinkRemovedCallback removedCallback = subscriber.onLinkRemoved.get();
+        return updatedCallback == onLinkUpdated && removedCallback == onLinkRemoved;
+      });
+
+      if (subscriberList.isEmpty()) {
+        subscribers.remove(id);
+      }
+    }
+  }
+
+  private void emitLinkUpdated(String id, View link) {
+    List<Subscriber> subscriberList = subscribers.get(id);
+    if (subscriberList != null) {
+      subscriberList.removeIf(Subscriber::isEmpty);
+
+      for (Subscriber subscriber : subscriberList) {
+        subscriber.notifyLinkUpdated(link);
+      }
+    }
+  }
+
+  private void emitLinkRemoved(String id) {
+    List<Subscriber> subscriberList = subscribers.get(id);
+    if (subscriberList != null) {
+      // Remove stale subscribers (whose weak references were garbage-collected)
+      subscriberList.removeIf(Subscriber::isEmpty);
+
+      // Notify all valid subscribers
+      for (Subscriber subscriber : subscriberList) {
+        subscriber.notifyLinkRemoved();
+      }
+    }
+  }
+
+  @FunctionalInterface
+  public interface LinkUpdatedCallback {
+    void onLinkUpdated(View link);
+  }
+
+  @FunctionalInterface
+  public interface LinkRemovedCallback {
+    void onLinkRemoved();
+  }
+
+  private static class Subscriber {
+    private final WeakReference<LinkUpdatedCallback> onLinkUpdated;
+    private final WeakReference<LinkRemovedCallback> onLinkRemoved;
+
+    public Subscriber(LinkUpdatedCallback onLinkUpdated, LinkRemovedCallback onLinkRemoved) {
+      this.onLinkUpdated = new WeakReference<>(onLinkUpdated);
+      this.onLinkRemoved = new WeakReference<>(onLinkRemoved);
+    }
+
+    public void notifyLinkUpdated(View link) {
+      LinkUpdatedCallback callback = onLinkUpdated.get();
+      if (callback != null) {
+        callback.onLinkUpdated(link);
+      }
+    }
+
+    public void notifyLinkRemoved() {
+      LinkRemovedCallback callback = onLinkRemoved.get();
+      if (callback != null) {
+        callback.onLinkRemoved();
+      }
+    }
+
+    public boolean isEmpty() {
+      return onLinkUpdated.get() == null && onLinkRemoved.get() == null;
+    }
+  }
+}

package/android/src/main/java/com/externalkeyboard/services/FocusLinkObserver/FocusLinkObserverSingleton.java

@@ -0,0 +1,20 @@
+package com.externalkeyboard.services.FocusLinkObserver;
+
+public final class FocusLinkObserverSingleton {
+
+  private static volatile FocusLinkObserver instance;
+
+  private FocusLinkObserverSingleton() {
+  }
+
+  public static FocusLinkObserver getInstance() {
+    if (instance == null) {
+      synchronized (FocusLinkObserverSingleton.class) {
+        if (instance == null) {
+          instance = new FocusLinkObserver();
+        }
+      }
+    }
+    return instance;
+  }
+}

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

@@ -1,15 +1,18 @@
 package com.externalkeyboard.views.ExternalKeyboardView;
 
 import android.content.Context;
+import android.view.FocusFinder;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.view.accessibility.AccessibilityEvent;
 
+import com.externalkeyboard.delegates.FocusOrderDelegate;
 import com.externalkeyboard.events.EventHelper;
 
 import com.externalkeyboard.helper.FocusHelper;
+import com.externalkeyboard.helper.ReactNativeVersionChecker;
 import com.externalkeyboard.services.KeyboardKeyPressHandler;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
@@ -28,20 +31,159 @@ public class ExternalKeyboardView extends ReactViewGroup {
   public boolean enableA11yFocus = false;
   public boolean screenAutoA11yFocus = false;
   public int screenAutoA11yFocusDelay = 500;
+  public int lockFocus = 0;
+  public String orderForward;
+  public String orderBackward;
+  public String orderId;
+
+
+  private FocusOrderDelegate focusOrderDelegate = null;
   private EventDispatcher a11yViewAppearDispatcher = null;
   private EventDispatcherListener eventA11yViewAppearListener = null;
   private final KeyboardKeyPressHandler keyboardKeyPressHandler;
   private final Context context;
   private View listeningView;
 
+  private Integer orderIndex;
+  private String orderGroup;
+  private View firstChild;
+
+  private String orderUp;
+  private String orderDown;
+  private String orderLeft;
+
+  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;
+  }
+
+  private String orderRight;
+
   public ExternalKeyboardView(Context context) {
     super(context);
     this.context = context;
+    this.focusOrderDelegate = new FocusOrderDelegate(this);
     this.keyboardKeyPressHandler = new KeyboardKeyPressHandler();
   }
 
+  public View getFirstChild() {
+    return this.firstChild;
+  }
+
+  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 (this.orderIndex == null) {
+      this.orderIndex = orderIndex;
+    } else {
+      this.orderIndex = orderIndex;
+      focusOrderDelegate.refreshOrder();
+    }
+  }
+
+  public void linkAddView(View child) {
+    if (firstChild == null) {
+      firstChild = child;
+      focusOrderDelegate.link();
+    }
+  }
+
+  public void linkRemoveView(View view) {
+    if (view == firstChild) {
+      firstChild = null;
+      focusOrderDelegate.unlink(view);
+    }
+  }
+
+  @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 (nextView != null) {
+        return nextView;
+      }
+    }
+
+    if (direction == FOCUS_BACKWARD && orderBackward != null) {
+      View prevView = this.focusOrderDelegate.getLink(orderBackward);
+      if (prevView != null) {
+        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);
+  }
+
   @Override
   public boolean dispatchKeyEvent(KeyEvent keyEvent) {
+    if(lockFocus != 0) {
+      int keyCode = keyEvent.getKeyCode();
+      boolean isLocked = FocusHelper.isKeyLocked(keyCode, lockFocus);
+      if(isLocked) {
+        return true;
+      }
+    }
     if (!this.hasKeyUpListener && !this.hasKeyDownListener) {
       return super.dispatchKeyEvent(keyEvent);
     }
@@ -141,6 +283,8 @@ public class ExternalKeyboardView extends ReactViewGroup {
     if (this.listeningView != null) {
       this.listeningView.setOnFocusChangeListener(null);
     }
+
+//    this.focusOrderDelegate.clear(firstChild); // ToDO check how to clean
   }
 
   private View getFocusingView() {

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

@@ -1,5 +1,8 @@
 package com.externalkeyboard.views.ExternalKeyboardView;
 
+import android.view.View;
+
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import com.externalkeyboard.events.FocusChangeEvent;
@@ -13,6 +16,7 @@ import com.facebook.react.views.view.ReactViewGroup;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 
 @ReactModule(name = ExternalKeyboardViewManager.NAME)
@@ -25,9 +29,23 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
     return NAME;
   }
 
+  @NonNull
   @Override
-  public ExternalKeyboardView createViewInstance(ThemedReactContext context) {
-    return new ExternalKeyboardView(context);
+  public ExternalKeyboardView createViewInstance(@NonNull ThemedReactContext context) {
+    ExternalKeyboardView viewGroup = new ExternalKeyboardView(context);
+
+    viewGroup.setOnHierarchyChangeListener(new ExternalKeyboardView.OnHierarchyChangeListener() {
+      @Override
+      public void onChildViewAdded(View parent, View child) {
+        viewGroup.linkAddView(child);
+      }
+
+      @Override
+      public void onChildViewRemoved(View parent, View child) {
+        viewGroup.linkRemoveView(child);
+      }
+    });
+    return viewGroup;
   }
 
   public static Map<String, Object> buildDirectEventMap(String registrationName) {
@@ -69,31 +87,41 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
   @Override
   @ReactProp(name = "enableA11yFocus", defaultBoolean = false)
   public void setEnableA11yFocus(ExternalKeyboardView wrapper, boolean enableA11yFocus) {
-    wrapper.enableA11yFocus = enableA11yFocus;
+    if(wrapper.enableA11yFocus != enableA11yFocus) {
+      wrapper.enableA11yFocus = enableA11yFocus;
+    }
   }
 
   @Override
   @ReactProp(name = "screenAutoA11yFocus", defaultBoolean = false)
   public void setScreenAutoA11yFocus(ExternalKeyboardView wrapper, boolean enableA11yFocus) {
-    wrapper.screenAutoA11yFocus = enableA11yFocus;
+    if(wrapper.screenAutoA11yFocus != enableA11yFocus) {
+      wrapper.screenAutoA11yFocus = enableA11yFocus;
+    }
   }
 
   @Override
   @ReactProp(name = "screenAutoA11yFocusDelay", defaultInt = 500)
   public void setScreenAutoA11yFocusDelay(ExternalKeyboardView wrapper, int value) {
-    wrapper.screenAutoA11yFocusDelay = value;
+    if(wrapper.screenAutoA11yFocusDelay != value) {
+      wrapper.screenAutoA11yFocusDelay = value;
+    }
   }
 
   @Override
   @ReactProp(name = "hasKeyDownPress")
   public void setHasKeyDownPress(ExternalKeyboardView view, boolean value) {
-    view.hasKeyDownListener = value;
+    if(view.hasKeyDownListener != value) {
+      view.hasKeyDownListener = value;
+    }
   }
 
   @Override
   @ReactProp(name = "hasKeyUpPress")
   public void setHasKeyUpPress(ExternalKeyboardView view, boolean value) {
-    view.hasKeyUpListener = value;
+    if(view.hasKeyUpListener != value) {
+      view.hasKeyUpListener = value;
+    }
   }
 
   @Override
@@ -104,7 +132,9 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
   @Override
   @ReactProp(name = "autoFocus")
   public void setAutoFocus(ExternalKeyboardView view, @Nullable boolean value) {
-    view.autoFocus = value;
+    if(view.autoFocus != value) {
+      view.autoFocus = value;
+    }
   }
 
   @Override
@@ -134,7 +164,97 @@ public class ExternalKeyboardViewManager extends com.externalkeyboard.ExternalKe
   @Override
   @ReactProp(name = "tintColor")
   public void setTintColor(ExternalKeyboardView view, @Nullable Integer value) {
+    //stub
+  }
+
+  @Override
+  @ReactProp(name = "orderGroup")
+  public void setOrderGroup(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.getOrderGroup(), value)) {
+      view.setOrderGroup(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderIndex")
+  public void setOrderIndex(ExternalKeyboardView view, int value) {
+    if(!Objects.equals(view.getOrderIndex(), value)) {
+      view.setOrderIndex(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "lockFocus")
+  public void setLockFocus(ExternalKeyboardView view, int value) {
+    if(view.lockFocus != value) {
+      view.lockFocus = value;
+    }
+  }
 
+  @Override
+  @ReactProp(name = "orderId")
+  public void setOrderId(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.orderId, value)) {
+      view.orderId = value;
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderLeft")
+  public void setOrderLeft(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.getOrderLeft(), value)) {
+      view.setOrderLeft(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderRight")
+  public void setOrderRight(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.getOrderRight(), value)) {
+      view.setOrderRight(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderUp")
+  public void setOrderUp(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.getOrderUp(), value)) {
+      view.setOrderUp(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderDown")
+  public void setOrderDown(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.getOrderDown(), value)) {
+      view.setOrderDown(value);
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderForward")
+  public void setOrderForward(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.orderForward, value)) {
+      view.orderForward = value;
+    }
+  }
+
+  @Override
+  @ReactProp(name = "orderBackward")
+  public void setOrderBackward(ExternalKeyboardView view, @Nullable String value) {
+    if(!Objects.equals(view.orderBackward, value)) {
+      view.orderBackward = value;
+    }
+  }
+
+  @Override
+  public void setOrderFirst(ExternalKeyboardView view, @Nullable String value) {
+    //stub
+  }
+
+  @Override
+  public void setOrderLast(ExternalKeyboardView view, @Nullable String value) {
+    //stub
   }
 
   @Override

package/android/src/main/java/com/externalkeyboard/views/KeyboardFocusGroup/KeyboardFocusGroupManager.java

@@ -20,10 +20,8 @@ public class KeyboardFocusGroupManager extends com.externalkeyboard.KeyboardFocu
     return new KeyboardFocusGroup(context);
   }
 
-
   @Override
-  @ReactProp(name = "tintColor")
-  public void setTintColor(KeyboardFocusGroup view, @Nullable Integer value) {
+  public void setTintColor(KeyboardFocusGroup view, Integer value) {
     //stub
   }
 
@@ -32,4 +30,10 @@ public class KeyboardFocusGroupManager extends com.externalkeyboard.KeyboardFocu
   public void setGroupIdentifier(KeyboardFocusGroup wrapper, String groupIdentifier) {
     //stub
   }
+
+  @Override
+  @ReactProp(name = "orderGroup")
+  public void setOrderGroup(KeyboardFocusGroup view, @Nullable String value) {
+    //stub
+  }
 }