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

package/README.md

@@ -5,17 +5,139 @@ React Native library for enhanced external keyboard support.
 - ⚡️ The New Architecture is supported
 - ⚡️ Bridgeless
 
+> [!NOTE]
+> React Native `0.80.0` includes a fix for `TextInput` focus on Android.
+> `TextInput`: Can now focus TextInput with keyboard ([e00028f6bb](https://github.com/facebook/react-native/commit/e00028f6bb6c19de861f9a25f377295755f3671b) by [@joevilches](https://github.com/joevilches))
+>
+> This means that there is no need to use the workaround with `KeyboardExtendedInput`, and it is recommended to use the default `TextInput` instead. Additionally, because of changes in `TextInput`, `focusType="press"` for `KeyboardExtendedInput`  no longer works on Android.
+
+
+## New Release: Focus Lock and Focus Order
+Improved keyboard focus control with features like focus order, ordered links, and focus lock.
+
+|Android| iOS|
+|-|-|
+| <image alt="Android Focus Order Example" src="https://github.com/user-attachments/assets/8bae353e-cf4b-41f7-8796-fd1cceae5df5" height="400" />|  <image alt="iOS Focus Order Example" src="https://github.com/user-attachments/assets/51850cc6-9573-4ccb-b69c-14deefbb4b65" height="400"/> |
+
+<details>
+  <summary>More Information</summary>
+  
+Advanced focus order functionality for Android and iOS, plus focus lock!
+
+It can be really challenging to manage focus in React Native, but fortunately, there are tools available to simplify the process. 
+
+## Link Focus Order
+
+`Linking` components could be the most logical way to define focus order. By using properties such as `orderId` and `orderBackward`, `orderForward`, `orderLeft`, `orderRight`, `orderUp`, and `orderDown`, you can customize the focus order according to your needs.
+
+```tsx
+<View>
+  <Pressable
+    onPress={onPress}
+    orderId="0_0"
+    orderForward="0_2"
+  >
+    <Text>1</Text>
+  </Pressable>
+  <Pressable
+    onPress={onPress}
+    orderId="0_2"
+    orderBackward="0_1"
+  >
+    <Text>3</Text>
+  </Pressable>
+  <Pressable
+    onPress={onPress}
+    orderId="0_1"
+    orderForward="0_2"
+    orderBackward="0_0"
+  >
+    <Text>2</Text>
+  </Pressable>
+</View>
+```
+
+You can find more examples here: [Focus Link Order](https://github.com/ArturKalach/react-native-external-keyboard/blob/release/0.6.0-rc/example/src/components/FocusOrderExample/FocusLinkOrder.tsx), [DPad Order](https://github.com/ArturKalach/react-native-external-keyboard/blob/release/0.6.0-rc/example/src/components/FocusOrderExample/FocusDPadOrder.tsx)
+
+| Props | Description | Type |
+| :-- | :-- | :-- |
+| orderId? | A unique ID used for link target identification. | `string` |
+| orderBackward? | ID of the target for backward navigation with "Tab + Shift". | `string` |
+| orderForward? | ID of the target for forward navigation with "Tab". | `string` |
+| orderLeft? | ID of the target for navigation to the left. | `string` |
+| orderRight? | ID of the target for navigation to the right. | `string` |
+| orderUp? | ID of the target for navigation upward. | `string` |
+| orderDown? | ID of the target for navigation downward. | `string` |
+
+## Indexes Focus Order
+
+Linking is one of the best ways to set up focus order. However, there may be cases where you need to define the order of multiple elements, such as groups. As an alternative solution, you can use Indexes.
+
+```tsx
+<KeyboardOrderFocusGroup>
+  <View>
+    <Pressable
+      onPress={onPress}
+      orderIndex={0}
+    >
+      <Text>First</Text>
+    </Pressable>
+    <Pressable
+      onPress={onPress}
+      orderIndex={2}
+    >
+      <Text>Third</Text>
+    </Pressable>
+    <Pressable
+      onPress={onPress}
+      orderIndex={1}
+    >
+      <Text>Second</Text>
+    </Pressable>
+  </View>
+</KeyboardOrderFocusGroup>
+```
+Indexing requres `orderGroup` param for proper order set,  you can use `KeyboardOrderFocusGroup` or provide `orderGroup` to the component.
+
+```tsx
+ <Pressable
+      orderGroup="main"
+      onPress={onPress}
+      orderIndex={2}
+    >
+      <Text>Back</Text>
+  </Pressable>
+```
+
+| Props | Description | Type |
+| :-- | :-- | :-- |
+| orderGroup? | The name of the group containing ordered elements. | `string` |
+| orderIndex? | The order index of the element within the group. | `number` |
+
+
+You can find more examples here: [Focus Order via indexes](https://github.com/ArturKalach/react-native-external-keyboard/blob/release/0.6.0-rc/example/src/components/FocusOrderExample/FocusOrder.tsx)
+
+## Focus Lock
+
+Finally, you can lock focus to specific directions. 
+
+```tsx
+ <Pressable
+  lockFocus={['down', 'right']}
+>
+  <Text>Lock Example</Text>
+</Pressable>
+```
 
-## Breaking Changes !!!
-> The Keyboard Module (`A11yModule`, `KeyboardExtendedModule`) has been removed. This API was deprecated and did not work properly with the new architecture. You can refer to the migration guide to update it.
 
+| Props | Description | Type |
+| :-- | :-- | :-- |
+| lockFocus? | An array of directions to lock focus. | Array of 'left' | 'right' | 'up' | 'down' | 'forward' | 'backward' | 'first' | 'last' |
+
+> [!NOTE]  
+> `first` and `last` are specific to `iOS`. When focus is blocked for `forward` and `backward` on iOS, it checks for the `last` and `first` elements to focus.
+</details>
 
-## New Release Features
-- Added `Keyboard.dismiss` functionality for Android.
-- Introduced an iOS-specific component: `KeyboardFocusGroup`, a component for managing the `tintColor`, `focusGroupIdentifier`, and group focus.
-- Enhanced `KeyboardExtendedBaseView` with `haloCornerRadius`, `haloExpandX`, and `haloExpandY` properties for customizing the appearance of the `Halo Effect`.
-- Enhanced `KeyboardExtendedBaseView` with `onBubbledContextMenuPress`, key press functionality has been also enhanced. Key presses can be listened to for a group of components, screens, or pages.
-- Added the `ignoreGroupFocusHint` prop to `KeyboardExtendedBaseView` to support key press listening without focusing the container.
 
 iOS | Android
 -- | --
@@ -27,6 +149,7 @@ iOS | Android
 - Key press event handling.
 - Focus management for `TextInput` and `Pressable` components.
 - Customization of the `Halo Effect` and `tintColor` for iOS.
+- Keyboard focus order.
 
 ## Installation
 
@@ -102,6 +225,14 @@ enableA11yFocus?: | Can be used to move the screen reader focus within the keybo
 screenAutoA11yFocus?: | Enables screen reader auto-focus functionality. | `boolean \| undefined`
 `screenAutoA11yFocusDelay?:`   | **Android only:** Delay for screen reader autofocus. On Android, focus can only be applied after the component has rendered, which may take 300–500 milliseconds. | `number \| undefined`, default: 300
 `exposeMethods?:` | List of exposed view methods  | `string[] \| undefined`, by default the following methods are exposed: `'blur', 'measure', 'measureInWindow', 'measureLayout', and 'setNativeProps'`.
+orderId? | A unique ID used for link target identification. | `string`
+orderBackward? | ID of the target for backward navigation with "Tab + Shift". | `string`
+orderForward? | ID of the target for forward navigation with "Tab". | `string`
+orderLeft? | ID of the target for navigation to the left. | `string`
+orderRight? | ID of the target for navigation to the right. | `string`
+orderUp? | ID of the target for navigation upward. | `string`
+orderDown? | ID of the target for navigation downward. | `string`
+lockFocus? | An array of directions to lock focus. | Array of 'left' \| 'right' \| 'up' \| 'down' \| 'forward' \| 'backward' \| 'first' \| 'last'
 ...rest | Remaining component props  | `Type of Component`
 
 
@@ -153,6 +284,14 @@ enableA11yFocus?: | Can be used to move the screen reader focus within the keybo
 screenAutoA11yFocus?: | Enables screen reader auto-focus functionality. | `boolean \| undefined`
 `screenAutoA11yFocusDelay?:`   | **Android only:** Delay for screen reader autofocus. On Android, focus can only be applied after the component has rendered, which may take 300–500 milliseconds. | `number \| undefined`, default: 300
 `exposeMethods?:` | List of exposed view methods  | `string[] \| undefined`, by default the following methods are exposed: `'blur', 'measure', 'measureInWindow', 'measureLayout', and 'setNativeProps'`.
+orderId? | A unique ID used for link target identification. | `string`
+orderBackward? | ID of the target for backward navigation with "Tab + Shift". | `string`
+orderForward? | ID of the target for forward navigation with "Tab". | `string`
+orderLeft? | ID of the target for navigation to the left. | `string`
+orderRight? | ID of the target for navigation to the right. | `string`
+orderUp? | ID of the target for navigation upward. | `string`
+orderDown? | ID of the target for navigation downward. | `string`
+lockFocus? | An array of directions to lock focus. | Array of 'left' \| 'right' \| 'up' \| 'down' \| 'forward' \| 'backward' \| 'first' \| 'last'
 ...rest | Remaining View props  | `View`
 
 
@@ -219,6 +358,14 @@ haloEffect | Enables halo effect on focus (iOS only) | `boolean \| undefined`
 autoFocus | Indicates if the component should automatically gain focus | `boolean \| undefined`
 tintColor | Color used for tinting the component | `string`
 ref->focus | Command to programmatically focus the component | () => void;
+orderId? | A unique ID used for link target identification. | `string`
+orderBackward? | ID of the target for backward navigation with "Tab + Shift". | `string`
+orderForward? | ID of the target for forward navigation with "Tab". | `string`
+orderLeft? | ID of the target for navigation to the left. | `string`
+orderRight? | ID of the target for navigation to the right. | `string`
+orderUp? | ID of the target for navigation upward. | `string`
+orderDown? | ID of the target for navigation downward. | `string`
+lockFocus? | An array of directions to lock focus. | Array of 'left' \| 'right' \| 'up' \| 'down' \| 'forward' \| 'backward' \| 'first' \| 'last'
 ...rest | Remaining View props | `View`
 
 ### KeyboardFocusGroup
@@ -273,6 +420,120 @@ import { Keyboard } from 'react-native-external-keyboard';
 
 This is needed for hiding the soft keyboard using a hardware keyboard. Additionally, the soft keyboard can be hidden from the settings or by pressing `Alt + K`.
 
+## Focus order features
+
+## Link Focus Order
+
+`Linking` components could be the most logical way to define focus order. By using properties such as `orderId` and `orderBackward`, `orderForward`, `orderLeft`, `orderRight`, `orderUp`, and `orderDown`, you can customize the focus order according to your needs.
+
+```tsx
+<View>
+  <Pressable
+    onPress={onPress}
+    orderId="0_0"
+    orderForward="0_2"
+  >
+    <Text>1</Text>
+  </Pressable>
+  <Pressable
+    onPress={onPress}
+    orderId="0_2"
+    orderBackward="0_1"
+  >
+    <Text>3</Text>
+  </Pressable>
+  <Pressable
+    onPress={onPress}
+    orderId="0_1"
+    orderForward="0_2"
+    orderBackward="0_0"
+  >
+    <Text>2</Text>
+  </Pressable>
+</View>
+```
+
+You can find more examples here: [Focus Link Order](https://github.com/ArturKalach/react-native-external-keyboard/blob/release/0.6.0-rc/example/src/components/FocusOrderExample/FocusLinkOrder.tsx), [DPad Order](https://github.com/ArturKalach/react-native-external-keyboard/blob/release/0.6.0-rc/example/src/components/FocusOrderExample/FocusDPadOrder.tsx)
+
+| Props | Description | Type |
+| :-- | :-- | :-- |
+| orderId? | A unique ID used for link target identification. | `string` |
+| orderBackward? | ID of the target for backward navigation with "Tab + Shift". | `string` |
+| orderForward? | ID of the target for forward navigation with "Tab". | `string` |
+| orderLeft? | ID of the target for navigation to the left. | `string` |
+| orderRight? | ID of the target for navigation to the right. | `string` |
+| orderUp? | ID of the target for navigation upward. | `string` |
+| orderDown? | ID of the target for navigation downward. | `string` |
+
+## Indexes Focus Order
+
+Linking is one of the best ways to set up focus order. However, there may be cases where you need to define the order of multiple elements, such as groups. As an alternative solution, you can use Indexes.
+
+```tsx
+<KeyboardOrderFocusGroup>
+  <View>
+    <Pressable
+      onPress={onPress}
+      orderIndex={0}
+    >
+      <Text>First</Text>
+    </Pressable>
+    <Pressable
+      onPress={onPress}
+      orderIndex={2}
+    >
+      <Text>Third</Text>
+    </Pressable>
+    <Pressable
+      onPress={onPress}
+      orderIndex={1}
+    >
+      <Text>Second</Text>
+    </Pressable>
+  </View>
+</KeyboardOrderFocusGroup>
+```
+Indexing requres `orderGroup` param for proper order set,  you can use `KeyboardOrderFocusGroup` or provide `orderGroup` to the component.
+
+```tsx
+ <Pressable
+      orderGroup="main"
+      onPress={onPress}
+      orderIndex={2}
+    >
+      <Text>Back</Text>
+  </Pressable>
+```
+
+| Props | Description | Type |
+| :-- | :-- | :-- |
+| orderGroup? | The name of the group containing ordered elements. | `string` |
+| orderIndex? | The order index of the element within the group. | `number` |
+
+
+You can find more examples here: [Focus Order via indexes](https://github.com/ArturKalach/react-native-external-keyboard/blob/release/0.6.0-rc/example/src/components/FocusOrderExample/FocusOrder.tsx)
+
+## Focus Lock
+
+Finally, you can lock focus to specific directions. 
+
+```tsx
+ <Pressable
+  lockFocus={['down', 'right']}
+>
+  <Text>Lock Example</Text>
+</Pressable>
+```
+
+
+| Props | Description | Type |
+| :-- | :-- | :-- |
+| lockFocus? | An array of directions to lock focus. | Array of 'left' \| 'right' \| 'up' \| 'down' \| 'forward' \| 'backward' \| 'first' \| 'last' |
+
+> [!NOTE]  
+> `first` and `last` are specific to `iOS`. When focus is blocked for `forward` and `backward` on iOS, it checks for the `last` and `first` elements to focus.
+
+
 # Migration 0.3.x to 0.4.0
 
 ## Module (A11yModule, KeyboardExtendedModule)
@@ -356,12 +617,14 @@ export type OnKeyPress = NativeSyntheticEvent<{
 ```
 
 ## Roadmap
-- Update `onPress` and `onLongPress` for `withKeyboardFocus`
-- Add functionality to control keyboard focus order.
-- Verify and update `focusable` and `disabled` states for iOS and Android.
-- Update `Readme.md`.
-- Create the documentation.
-- Perfomance optimization
+- [ ] Refactor and Performance optimization
+- [ ] Update `focusGroupIdentifier` and implement `KeyboardNavigationCluster` functionality
+- [ ] Update `onPress` and `onLongPress` for `withKeyboardFocus`
+- [x] Add functionality to control keyboard focus order.
+- [ ] Verify and update `focusable` and `disabled` states for iOS and Android.
+- [ ] Update `Readme.md`.
+- [ ] Create the documentation.
+
 
 ## Contributing
 Any type of contribution is highly appreciated. Feel free to create PRs, raise issues, or share ideas.

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

@@ -0,0 +1,213 @@
+package com.externalkeyboard.delegates;
+
+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;
+
+  FocusLinkObserver.LinkUpdatedCallback leftUpdated = null;
+  FocusLinkObserver.LinkRemovedCallback leftRemoved = null;
+  FocusLinkObserver.LinkUpdatedCallback rightUpdated = null;
+  FocusLinkObserver.LinkRemovedCallback rightRemoved = null;
+  FocusLinkObserver.LinkUpdatedCallback upUpdated = null;
+  FocusLinkObserver.LinkRemovedCallback upRemoved = null;
+  FocusLinkObserver.LinkUpdatedCallback downUpdated = null;
+  FocusLinkObserver.LinkRemovedCallback downRemoved = null;
+
+
+  public FocusOrderDelegate(ExternalKeyboardView delegate) {
+    super();
+    this.delegate = delegate;
+  }
+
+  public void link() {
+    View child = delegate.getFirstChild();
+    String orderGroup = delegate.getOrderGroup();
+    Integer orderIndex = delegate.getOrderIndex();
+    String orderId = delegate.getOrderId();
+
+    if (child != null && orderGroup != null && orderIndex != null) {
+      A11yOrderLinking.getInstance().addViewRelationship(child, orderGroup, orderIndex);
+    }
+
+    FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+    if (orderId != null && child != null) {
+      observer.emit(orderId, child);
+      A11yOrderLinking.getInstance().addOrderLink(child, orderId);
+    }
+
+    if (delegate.getOrderLeft() != null && child != null) {
+      leftUpdated = link -> child.setNextFocusLeftId(link.getId());
+      leftRemoved = () -> child.setNextFocusLeftId(View.NO_ID);
+      observer.subscribe(delegate.getOrderLeft(), leftUpdated, leftRemoved);
+    }
+
+    if (delegate.getOrderRight() != null && child != null) {
+      rightUpdated = link -> child.setNextFocusRightId(link.getId());
+      rightRemoved = () -> child.setNextFocusRightId(View.NO_ID);
+      observer.subscribe(delegate.getOrderRight(), rightUpdated, rightRemoved);
+    }
+
+    if (delegate.getOrderUp() != null && child != null) {
+      upUpdated = link -> child.setNextFocusUpId(link.getId());
+      upRemoved = () -> child.setNextFocusUpId(View.NO_ID);
+      observer.subscribe(delegate.getOrderUp(), upUpdated, upRemoved);
+    }
+
+    if (delegate.getOrderDown() != null && child != null) {
+      downUpdated = link -> child.setNextFocusDownId(link.getId());
+      downRemoved = () -> child.setNextFocusDownId(View.NO_ID);
+      observer.subscribe(delegate.getOrderDown(), downUpdated, downRemoved);
+    }
+  }
+
+  public void refreshOrder() {
+    View child = delegate.getFirstChild();
+    String orderGroup = delegate.getOrderGroup();
+    Integer orderIndex = delegate.getOrderIndex();
+
+    if (child != null && orderGroup != null) {
+      A11yOrderLinking.getInstance().refreshIndexes(child, orderGroup, orderIndex);
+    }
+  }
+
+  public void refreshLeft(String prev, String next) {
+    FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+    if (prev != null && leftUpdated != null && leftRemoved != null) {
+      observer.unsubscribe(prev, leftUpdated, leftRemoved);
+      View child = delegate.getFirstChild();
+      if(child != null) {
+        child.setNextFocusLeftId(View.NO_ID);
+      }
+    }
+
+    View child = delegate.getFirstChild();
+    if (next != null && child != null) {
+      leftUpdated = link -> child.setNextFocusLeftId(link.getId());
+      leftRemoved = () -> child.setNextFocusLeftId(View.NO_ID);
+      observer.subscribe(next, leftUpdated, leftRemoved);
+    }
+  }
+
+  public void refreshRight(String prev, String next) {
+    FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+    if (rightUpdated != null && rightRemoved != null) {
+      observer.unsubscribe(prev, rightUpdated, rightRemoved);
+      View child = delegate.getFirstChild();
+      if(child != null) {
+        child.setNextFocusRightId(View.NO_ID);
+      }
+    }
+
+    View child = delegate.getFirstChild();
+    if (next != null && child != null) {
+      rightUpdated = link -> child.setNextFocusRightId(link.getId());
+      rightRemoved = () -> child.setNextFocusRightId(View.NO_ID);
+      observer.subscribe(next, rightUpdated, rightRemoved);
+    }
+  }
+
+  public void refreshUp(String prev, String next) {
+    FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+    if (prev != null && upUpdated != null && upRemoved != null) {
+      observer.unsubscribe(prev, upUpdated, upRemoved);
+
+      View child = delegate.getFirstChild();
+      if(child != null) {
+        child.setNextFocusUpId(View.NO_ID);
+      }
+    }
+
+    View child = delegate.getFirstChild();
+    if (next != null && child != null) {
+      upUpdated = link -> child.setNextFocusUpId(link.getId());
+      upRemoved = () -> child.setNextFocusUpId(View.NO_ID);
+      observer.subscribe(next, upUpdated, upRemoved);
+    }
+  }
+
+  public void updateOrderGroup(String prev, String next) {
+    View child = delegate.getFirstChild();
+    Integer position = delegate.getOrderIndex();
+
+    if (child != null && position != null) {
+      A11yOrderLinking.getInstance().updateGroup(prev, next, position, child);
+    }
+  }
+
+  public void refreshDown(String prev, String next) {
+    FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+    if (prev != null && downUpdated != null && downRemoved != null) {
+      observer.unsubscribe(prev, downUpdated, downRemoved);
+
+      View child = delegate.getFirstChild();
+      if(child != null) {
+        child.setNextFocusDownId(View.NO_ID);
+      }
+    }
+
+    View child = delegate.getFirstChild();
+    if (next != null && child != null) {
+      downUpdated = link -> child.setNextFocusDownId(link.getId());
+      downRemoved = () -> child.setNextFocusDownId(View.NO_ID);
+      observer.subscribe(next, downUpdated, downRemoved);
+    }
+  }
+
+
+  public void unlink(View unlinkView) {
+    String orderGroup = delegate.getOrderGroup();
+    Integer orderIndex = delegate.getOrderIndex();
+    String orderId = delegate.getOrderId();
+
+    if (orderGroup != null && orderIndex != null) {
+      A11yOrderLinking.getInstance().removeRelationship(orderGroup, orderIndex);
+    }
+
+    if (orderId != null) {
+      FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+      View storedView = A11yOrderLinking.getInstance().getOrderLink(orderId);
+      if(storedView == unlinkView) {
+        observer.emitRemove(orderId);
+        A11yOrderLinking.getInstance().removeOrderLink(orderId);
+      }
+    }
+
+
+    if (delegate.getOrderLeft() != null) {
+      FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+      observer.unsubscribe(delegate.getOrderLeft(), leftUpdated, leftRemoved);
+    }
+
+    if (delegate.getOrderRight() != null) {
+      FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+      observer.unsubscribe(delegate.getOrderRight(), rightUpdated, rightRemoved);
+    }
+
+    if (delegate.getOrderUp() != null) {
+      FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+      observer.unsubscribe(delegate.getOrderUp(), upUpdated, upRemoved);
+    }
+
+    if (delegate.getOrderDown() != null) {
+      FocusLinkObserver observer = FocusLinkObserverSingleton.getInstance();
+      observer.unsubscribe(delegate.getOrderDown(), downUpdated, downRemoved);
+    }
+  }
+
+  public View getLink(String linkId) {
+    return A11yOrderLinking.getInstance().getOrderLink(linkId);
+  }
+
+  public void clear(View view) {
+    if(view != null) {
+      unlink(view);
+    }
+  }
+
+}

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

@@ -1,9 +1,53 @@
 package com.externalkeyboard.helper;
 
+import android.view.KeyEvent;
 import android.view.View;
 import android.view.ViewGroup;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class FocusHelper {
+  private static final int MASK_FOCUS_UP = 0b1;
+  private static final int MASK_FOCUS_DOWN = 0b10;
+  private static final int MASK_FOCUS_LEFT = 0b100;
+  private static final int MASK_FOCUS_RIGHT = 0b1000;
+  private static final int MASK_FOCUS_FORWARD = 0b10000;
+  private static final int MASK_FOCUS_BACKWARD = 0b100000;
+
+  private static final Map<Integer, Integer> DIRECTION_MASK_MAP = new HashMap<>();
+  private static final Map<Integer, Integer> DIRECTION_KEY_MASK_MAP = new HashMap<>();
+
+  static {
+    DIRECTION_MASK_MAP.put(View.FOCUS_UP, MASK_FOCUS_UP);
+    DIRECTION_MASK_MAP.put(View.FOCUS_DOWN, MASK_FOCUS_DOWN);
+    DIRECTION_MASK_MAP.put(View.FOCUS_LEFT, MASK_FOCUS_LEFT);
+    DIRECTION_MASK_MAP.put(View.FOCUS_RIGHT, MASK_FOCUS_RIGHT);
+    DIRECTION_MASK_MAP.put(View.FOCUS_FORWARD, MASK_FOCUS_FORWARD);
+    DIRECTION_MASK_MAP.put(View.FOCUS_BACKWARD, MASK_FOCUS_BACKWARD);
+
+    DIRECTION_KEY_MASK_MAP.put(KeyEvent.KEYCODE_DPAD_LEFT, MASK_FOCUS_LEFT);
+    DIRECTION_KEY_MASK_MAP.put(KeyEvent.KEYCODE_DPAD_RIGHT, MASK_FOCUS_RIGHT);
+    DIRECTION_KEY_MASK_MAP.put(KeyEvent.KEYCODE_DPAD_UP, MASK_FOCUS_UP);
+    DIRECTION_KEY_MASK_MAP.put(KeyEvent.KEYCODE_DPAD_DOWN, MASK_FOCUS_DOWN);
+  }
+
+  public static boolean isLocked(int direction, int lockFocus) {
+    Integer mask = DIRECTION_MASK_MAP.get(direction);
+    if (mask != null) {
+      return (lockFocus & mask) != 0;
+    }
+    return false;
+  }
+
+  public static boolean isKeyLocked(int direction, int lockFocus) {
+    Integer mask = DIRECTION_KEY_MASK_MAP.get(direction);
+    if (mask != null) {
+      return (lockFocus & mask) != 0;
+    }
+    return false;
+  }
+
   public static View getFocusableView(ViewGroup viewGroup) {
     if (viewGroup.getChildCount() > 0) {
       View subView = viewGroup.getChildAt(0);

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

@@ -0,0 +1,81 @@
+package com.externalkeyboard.helper.Linking;
+
+import android.view.View;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+public class A11yOrderLinking {
+
+  private static A11yOrderLinking instance;
+  private final Map<String, LinkingQueue> relationships;
+  private final Map<String, View> weakMap;
+
+  private A11yOrderLinking() {
+    relationships = new HashMap<>();
+    weakMap = new WeakHashMap<>();
+  }
+
+  public static synchronized A11yOrderLinking getInstance() {
+    if (instance == null) {
+      instance = new A11yOrderLinking();
+    }
+    return instance;
+  }
+
+  public void addOrderLink(View view, String key) {
+    this.weakMap.put(key, view);
+  }
+
+  public void removeOrderLink(String key) {
+    this.weakMap.remove(key);
+  }
+
+  public View getOrderLink(String key) {
+    return this.weakMap.get(key);
+  }
+
+  public void refreshIndexes(View view, String key, int position) {
+    LinkingQueue queue = relationships.get(key);
+    if (queue != null) {
+      queue.refreshIndexes(view, position);
+    }
+  }
+
+  public void addViewRelationship(View view, String key, int position) {
+    LinkingQueue queue = relationships.get(key);
+    if (queue == null) {
+      queue = new LinkingQueue();
+      relationships.put(key, queue);
+    }
+
+    queue.addPosition(view, position);
+  }
+
+
+  public void removeRelationship(String key, int index) {
+    LinkingQueue queue = relationships.get(key);
+    if (queue == null) return;
+
+    queue.removeFromOrder(index);
+  }
+
+  public void updateGroup(String prev, String next, Integer position, View child) {
+    if (prev != null && prev.equals(next)) return;
+    if (prev != null) {
+      LinkingQueue queue = relationships.get(prev);
+      if (queue != null) {
+        queue.removeFromOrder(position);
+
+        if (queue.isEmpty()) {
+          relationships.remove(prev);
+        }
+      }
+    }
+
+    if (next != null && position != null && child != null) {
+      this.addViewRelationship(child, next, position);
+    }
+  }
+}