react-native-external-keyboard 0.8.5 → 0.9.1

package/ios/Delegates/RNCEKVFocusLinkDelegate/RNCEKVFocusLinkDelegate.mm

@@ -0,0 +1,195 @@
+//
+//  RNCEKVFocusLinkDelegate.mm
+//  react-native-external-keyboard
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVFocusLinkDelegate.h"
+#import "RNCEKVFocusGuideHelper.h"
+#import "RNCEKVFocusLinkObserver.h"
+#import "RNCEKVOrderSubscriber.h"
+#import "RNCEKVOrderLinking.h"
+#import "RNCEKVKeyboardFocusableProtocol.h"
+
+static NSNumber *const FOCUS_DEFAULT = nil;
+static NSNumber *const FOCUS_LOCK = @0;
+static NSNumber *const FOCUS_HANDLED = @0;
+
+@implementation RNCEKVFocusLinkDelegate {
+  BOOL _isFocused;
+  UIView<RNCEKVFocusOrderProtocol> *_delegate;
+  NSMutableDictionary<NSNumber *, UIFocusGuide *> *_sides;
+  NSMutableDictionary<NSNumber *, RNCEKVOrderSubscriber *> *_subscribers;
+}
+
+- (instancetype)initWithView:(UIView<RNCEKVFocusOrderProtocol> *)delegate {
+  self = [super init];
+  if (self) {
+    _delegate = delegate;
+    _isFocused = NO;
+    _sides = [NSMutableDictionary dictionary];
+    _subscribers = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (void)link {
+  if (_delegate.orderId != nil) {
+    [[RNCEKVOrderLinking sharedInstance] storeOrderId:_delegate.orderId withView:_delegate];
+    [self linkId];
+  }
+}
+
+- (void)unlink {
+  if (_delegate.orderId != nil) {
+    [[RNCEKVOrderLinking sharedInstance] cleanOrderId:_delegate.orderId];
+    [self clear];
+  }
+}
+
+#pragma mark - Focus helpers
+
+- (void)keyboardedViewFocus:(UIView *)view {
+  if ([view conformsToProtocol:@protocol(RNCEKVKeyboardFocusableProtocol)]) {
+    [(UIView<RNCEKVKeyboardFocusableProtocol> *)view focus];
+  }
+}
+
+#pragma mark - Guide management
+
+- (void)setGuideFor:(RNCEKVFocusGuideDirection)direction withView:(UIView *)view {
+  if (!view) return;
+  [self removeGuideFor:direction];
+  _sides[@(direction)] = [RNCEKVFocusGuideHelper setGuideForDirection:direction
+                                                               inView:_delegate
+                                                           focusView:view
+                                                             enabled:_isFocused];
+}
+
+- (void)removeGuideFor:(RNCEKVFocusGuideDirection)direction {
+  if (_sides[@(direction)]) {
+    [_delegate removeLayoutGuide:_sides[@(direction)]];
+    _sides[@(direction)] = nil;
+  }
+}
+
+- (void)setIsFocused:(BOOL)value {
+  _isFocused = value;
+  for (NSNumber *key in _sides) {
+    _sides[key].enabled = value;
+  }
+}
+
+#pragma mark - Subscriptions
+
+- (void)subscribeToDirection:(RNCEKVFocusGuideDirection)direction linkId:(NSString *)linkId {
+  if (!linkId) return;
+
+  if (_subscribers[@(direction)]) {
+    [self clearDirection:direction];
+  }
+
+  RNCEKVFocusGuideDirection capturedDirection = direction;
+
+  LinkUpdatedCallback onLinkUpdated = ^(UIView *link) {
+    [self setGuideFor:capturedDirection withView:link];
+  };
+
+  LinkRemovedCallback onLinkRemoved = ^{
+    [self removeGuideFor:capturedDirection];
+  };
+
+  RNCEKVOrderSubscriber *subscriber = [[RNCEKVFocusLinkObserver sharedManager] subscribe:linkId
+                                                                           onLinkUpdated:onLinkUpdated
+                                                                           onLinkRemoved:onLinkRemoved];
+  _subscribers[@(direction)] = subscriber;
+}
+
+- (void)clearDirection:(RNCEKVFocusGuideDirection)direction {
+  if (!_subscribers[@(direction)]) return;
+  [[RNCEKVFocusLinkObserver sharedManager] unsubscribe:_subscribers[@(direction)]];
+  _subscribers[@(direction)] = nil;
+  [self removeGuideFor:direction];
+}
+
+- (void)refreshDirection:(RNCEKVFocusGuideDirection)direction nextId:(NSString *)nextId {
+  [self clearDirection:direction];
+  [self subscribeToDirection:direction linkId:nextId];
+}
+
+#pragma mark - Public API
+
+- (void)linkId {
+  RNCEKVFocusLinkObserver *focusLinkObserver = [RNCEKVFocusLinkObserver sharedManager];
+  NSString *orderId = _delegate.orderId;
+  UIView *view = [_delegate getFocusTargetView];
+
+  if (orderId != nil) {
+    [focusLinkObserver emitWithId:orderId link:view];
+  }
+
+  [self subscribeToDirection:RNCEKVFocusGuideDirectionLeft  linkId:_delegate.orderLeft];
+  [self subscribeToDirection:RNCEKVFocusGuideDirectionRight linkId:_delegate.orderRight];
+  [self subscribeToDirection:RNCEKVFocusGuideDirectionUp    linkId:_delegate.orderUp];
+  [self subscribeToDirection:RNCEKVFocusGuideDirectionDown  linkId:_delegate.orderDown];
+}
+
+- (void)refreshId:(NSString *)prev next:(NSString *)next {
+  RNCEKVFocusLinkObserver *focusLinkObserver = [RNCEKVFocusLinkObserver sharedManager];
+  UIView *view = [_delegate getFocusTargetView];
+
+  if (prev != nil) {
+    [focusLinkObserver emitRemoveWithId:prev];
+    [[RNCEKVOrderLinking sharedInstance] cleanOrderId:prev];
+  }
+
+  if (next != nil && view != nil) {
+    [[RNCEKVOrderLinking sharedInstance] storeOrderId:next withView:_delegate];
+    [focusLinkObserver emitWithId:next link:view];
+  }
+}
+
+- (void)refreshLeft:(NSString *)next  { [self refreshDirection:RNCEKVFocusGuideDirectionLeft  nextId:next]; }
+- (void)refreshRight:(NSString *)next { [self refreshDirection:RNCEKVFocusGuideDirectionRight nextId:next]; }
+- (void)refreshUp:(NSString *)next    { [self refreshDirection:RNCEKVFocusGuideDirectionUp    nextId:next]; }
+- (void)refreshDown:(NSString *)next  { [self refreshDirection:RNCEKVFocusGuideDirectionDown  nextId:next]; }
+
+- (void)clear {
+  [self clearDirection:RNCEKVFocusGuideDirectionLeft];
+  [self clearDirection:RNCEKVFocusGuideDirectionRight];
+  [self clearDirection:RNCEKVFocusGuideDirectionUp];
+  [self clearDirection:RNCEKVFocusGuideDirectionDown];
+  [self refreshId:_delegate.orderId next:nil];
+}
+
+- (NSNumber *)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context {
+  UIFocusHeading movementHint = context.focusHeading;
+  UIView *current = (UIView *)context.previouslyFocusedItem;
+  UIView *targetView = [_delegate getFocusTargetView];
+
+  BOOL isCurrentDelegate = current != nil
+    && [current isKindOfClass:[UIView class]]
+    && (current == targetView || [current isDescendantOfView:_delegate]);
+  if (isCurrentDelegate) {
+    NSUInteger rawFocusLockValue = [_delegate.lockFocus unsignedIntegerValue];
+    if ((rawFocusLockValue & movementHint) != 0) {
+      return FOCUS_LOCK;
+    }
+
+    NSString *orderId = nil;
+    if (movementHint == UIFocusHeadingLast)          orderId = _delegate.orderLast;
+    else if (movementHint == UIFocusHeadingFirst)    orderId = _delegate.orderFirst;
+    else if (movementHint == UIFocusHeadingNext)     orderId = _delegate.orderForward;
+    else if (movementHint == UIFocusHeadingPrevious) orderId = _delegate.orderBackward;
+
+    if (orderId) {
+      UIView *nextView = [[RNCEKVOrderLinking sharedInstance] getOrderView:orderId];
+      [self keyboardedViewFocus:nextView];
+      return FOCUS_HANDLED;
+    }
+  }
+
+  return FOCUS_DEFAULT;
+}
+
+@end

package/ios/Delegates/RNCEKVFocusOrderDelegate/RNCEKVFocusOrderProtocol.h

@@ -13,20 +13,18 @@
 @protocol RNCEKVFocusOrderProtocol <NSObject>
 
 @property (nonatomic, strong) NSString* orderGroup;
-@property NSNumber* lockFocus;
-@property NSNumber* orderPosition;
+@property (nonatomic, strong) NSNumber* lockFocus;
+@property (nonatomic, strong) 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* orderForward;
+@property (nonatomic, strong) NSString* orderBackward;
+@property (nonatomic, strong) NSString* orderLast;
+@property (nonatomic, strong) NSString* orderFirst;
 @property (nonatomic, strong) NSString* orderId;
 
-- (UIViewController *)reactViewController;
 - (UIView *)getFocusTargetView;
 
 @end

package/ios/Delegates/RNCEKVFocusSequenceDelegate/RNCEKVFocusSequenceDelegate.h

@@ -0,0 +1,25 @@
+//
+//  RNCEKVFocusSequenceDelegate.h
+//  react-native-external-keyboard
+//
+
+#ifndef RNCEKVFocusSequenceDelegate_h
+#define RNCEKVFocusSequenceDelegate_h
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVFocusOrderProtocol.h"
+
+@interface RNCEKVFocusSequenceDelegate : NSObject
+
+- (instancetype _Nonnull)initWithView:(UIView<RNCEKVFocusOrderProtocol> *_Nonnull)view;
+
+- (NSNumber *_Nullable)shouldUpdateFocusInContext:(UIFocusUpdateContext *_Nonnull)context;
+
+- (void)link;
+- (void)unlink;
+- (void)updatePosition:(NSNumber *_Nullable)position;
+- (void)updateOrderGroup:(NSString *_Nullable)orderGroup;
+
+@end
+
+#endif /* RNCEKVFocusSequenceDelegate_h */

package/ios/Delegates/RNCEKVFocusSequenceDelegate/RNCEKVFocusSequenceDelegate.mm

@@ -0,0 +1,163 @@
+//
+//  RNCEKVFocusSequenceDelegate.mm
+//  react-native-external-keyboard
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVFocusSequenceDelegate.h"
+#import "RNCEKVOrderLinking.h"
+#import "RNCEKVOrderRelationship.h"
+#import "RNCEKVKeyboardFocusableProtocol.h"
+#import "UIViewController+RNCEKVExternalKeyboard.h"
+#import "UIView+React.h"
+
+static NSNumber *const FOCUS_DEFAULT = nil;
+static NSNumber *const FOCUS_HANDLED = @0;
+
+@implementation RNCEKVFocusSequenceDelegate {
+  BOOL _isLinked;
+  UIView<RNCEKVFocusOrderProtocol> *_delegate;
+}
+
+- (instancetype)initWithView:(UIView<RNCEKVFocusOrderProtocol> *)delegate {
+  self = [super init];
+  if (self) {
+    _delegate = delegate;
+  }
+  return self;
+}
+
+- (void)link {
+  if (_delegate.orderPosition != nil && _delegate.orderGroup != nil && !_isLinked) {
+    [[RNCEKVOrderLinking sharedInstance] add:_delegate.orderPosition withOrderKey:_delegate.orderGroup withObject:_delegate];
+    _isLinked = YES;
+  }
+}
+
+- (void)unlink {
+  if (_delegate.orderPosition != nil && _delegate.orderGroup != nil && _isLinked) {
+    [[RNCEKVOrderLinking sharedInstance] remove:_delegate.orderPosition withOrderKey:_delegate.orderGroup];
+  }
+  _isLinked = NO;
+}
+
+- (void)updatePosition:(NSNumber *)position {
+  if (position == nil || _delegate.orderPosition == position || (_delegate.orderPosition != nil && [_delegate.orderPosition isEqualToNumber:position])) {
+    return;
+  }
+  if (_delegate.orderGroup != nil && _delegate.superview != nil && _isLinked) {
+    [[RNCEKVOrderLinking sharedInstance] update:position lastPosition:_delegate.orderPosition withOrderKey:_delegate.orderGroup withView:_delegate];
+  }
+}
+
+- (void)updateOrderGroup:(NSString *)orderGroup {
+  if (_delegate.orderPosition != nil && _delegate.superview != nil) {
+    [[RNCEKVOrderLinking sharedInstance] updateOrderKey:_delegate.orderGroup next:orderGroup position:_delegate.orderPosition withView:_delegate];
+  }
+}
+
+#pragma mark - Focus helpers
+
+- (void)keyboardedViewFocus:(UIView *)view {
+  if ([view conformsToProtocol:@protocol(RNCEKVKeyboardFocusableProtocol)]) {
+    [(UIView<RNCEKVKeyboardFocusableProtocol> *)view focus];
+  }
+}
+
+- (void)defaultViewFocus:(UIView *)view {
+  UIViewController *controller = _delegate.reactViewController;
+  if (controller != nil) {
+    [controller rncekvFocusView:view];
+  }
+}
+
+#pragma mark - Sequential navigation
+
+- (BOOL)handleNextFocus:(UIView *)current
+           currentIndex:(NSInteger)currentIndex
+      orderRelationship:(RNCEKVOrderRelationship *)orderRelationship {
+  UIView *entry = orderRelationship.entry;
+  UIView *exit = orderRelationship.exit;
+
+  if (entry == current) {
+    [self keyboardedViewFocus:[orderRelationship getItem:0]];
+    return NO;
+  }
+
+  if (currentIndex == orderRelationship.count - 1 && exit) {
+    [self defaultViewFocus:exit];
+    return YES;
+  }
+
+  if (currentIndex >= 0 && currentIndex < orderRelationship.count - 1) {
+    [self keyboardedViewFocus:[orderRelationship getItem:currentIndex + 1]];
+    return YES;
+  }
+
+  return NO;
+}
+
+- (BOOL)handlePrevFocus:(UIView *)current
+           currentIndex:(NSInteger)currentIndex
+      orderRelationship:(RNCEKVOrderRelationship *)orderRelationship {
+  UIView *exit = orderRelationship.exit;
+  UIView *entry = orderRelationship.entry;
+  int orderCount = [orderRelationship count];
+
+  if (exit == current) {
+    [self keyboardedViewFocus:[orderRelationship getItem:orderCount - 1]];
+    return YES;
+  }
+
+  if (currentIndex == 0 && entry) {
+    [self defaultViewFocus:entry];
+    return YES;
+  }
+
+  if (currentIndex > 0 && currentIndex <= orderCount - 1) {
+    [self keyboardedViewFocus:[orderRelationship getItem:currentIndex - 1]];
+    return YES;
+  }
+
+  return NO;
+}
+
+#pragma mark - shouldUpdateFocusInContext
+
+- (NSNumber *)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context {
+  UIFocusHeading movementHint = context.focusHeading;
+  UIView *next = (UIView *)context.nextFocusedItem;
+  UIView *current = (UIView *)context.previouslyFocusedItem;
+
+  if (_delegate.orderGroup && _delegate.orderPosition != nil) {
+    RNCEKVOrderRelationship *orderRelationship = [[RNCEKVOrderLinking sharedInstance] getInfo:_delegate.orderGroup];
+    if ([orderRelationship getArray].count == 0) {
+      return FOCUS_DEFAULT;
+    }
+
+    int currentIndex = [orderRelationship getItemIndex:current];
+    int nextIndex = [orderRelationship getItemIndex:next];
+
+    if (orderRelationship.entry == nil && currentIndex == -1 && movementHint == UIFocusHeadingNext) {
+      orderRelationship.entry = current;
+    }
+
+    if (orderRelationship.exit == nil && nextIndex == -1 && movementHint == UIFocusHeadingNext) {
+      orderRelationship.exit = next;
+    }
+
+    if (movementHint == UIFocusHeadingNext) {
+      BOOL handled = [self handleNextFocus:current currentIndex:currentIndex orderRelationship:orderRelationship];
+      return handled ? FOCUS_HANDLED : FOCUS_DEFAULT;
+    }
+
+    if (movementHint == UIFocusHeadingPrevious) {
+      BOOL handled = [self handlePrevFocus:current currentIndex:currentIndex orderRelationship:orderRelationship];
+      return handled ? FOCUS_HANDLED : FOCUS_DEFAULT;
+    }
+  }
+
+  return FOCUS_DEFAULT;
+}
+
+@end

package/ios/Delegates/RNCEKVGroupIdentifierDelegate/RNCEKVGroupIdentifierDelegate.h

@@ -13,13 +13,9 @@
 
 @interface RNCEKVGroupIdentifierDelegate : NSObject
 
-- (instancetype _Nonnull )initWithView:(UIView<RNCEKVGroupIdentifierProtocol> *_Nonnull)view;
+- (instancetype _Nonnull)initWithView:(UIView<RNCEKVGroupIdentifierProtocol> *_Nonnull)view;
 
-- (NSString*_Nonnull) getFocusGroupIdentifier;
-- (void)updateGroupIdentifier;
-- (void)clear;
-- (void)clearSubview:(UIView*_Nullable)subview;
-- (void)syncCustomGroupId;
+@property (nonatomic, readonly, nonnull) NSString *focusGroupIdentifier;
 
 @end
 

package/ios/Delegates/RNCEKVGroupIdentifierDelegate/RNCEKVGroupIdentifierDelegate.mm

@@ -8,7 +8,6 @@
 #import <Foundation/Foundation.h>
 
 #import "RNCEKVGroupIdentifierDelegate.h"
-#import "RNCEKVFocusEffectUtility.h"
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import "RCTViewComponentView+RNCEKVExternalKeyboard.h"
@@ -29,89 +28,18 @@
 }
 
 
--  (NSString*) getTagId {
-  if(_tagId) {
-    return _tagId;
+- (NSString *)tagId {
+  if (!_tagId) {
+    _tagId = [NSString stringWithFormat:@"app.group.%@", [NSUUID UUID].UUIDString];
   }
-
-  NSUUID *uuid = [NSUUID UUID];
-  NSString *uniqueID = [uuid UUIDString];
-  _tagId = [NSString stringWithFormat:@"app.group.%@", uniqueID];
-
   return _tagId;
 }
 
-
-- (NSString*) getFocusGroupIdentifier {
-  if (@available(iOS 14.0, *)) {
-    if(_delegate.customGroupId) {
-      return _delegate.customGroupId;
-    }
-
-    return [self getTagId];
-  } else {
-    return nil;
-  }
-}
-
-
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void) updateGroupIdentifier {
-  if (@available(iOS 14.0, *)) {
-    UIView* focus = [_delegate getFocusTargetView];
-
-    NSString* identifier = [self getFocusGroupIdentifier];
-    if([focus isKindOfClass:[RCTViewComponentView class]]) {
-      ((RCTViewComponentView*)focus).rncekvCustomGroup = identifier;
-    } else {
-      focus.focusGroupIdentifier = identifier;
-    }
-  }
-}
-
-#else
-
-- (void) updateGroupIdentifier {
-  if (@available(iOS 14.0, *)) {
-    UIView* focus = [_delegate getFocusTargetView];
-    focus.focusGroupIdentifier = [self getFocusGroupIdentifier];
-  }
-}
-
-#endif
-
-- (void) clear {
-  if (@available(iOS 14.0, *)) {
-    UIView* focus = [_delegate getFocusTargetView];
-    [self clearSubview: focus];
-  }
-}
-
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)clearSubview: (UIView*_Nullable)subview {
-  if(!subview) return;
-
-  if (@available(iOS 14.0, *)) {
-
-    if(subview) {
-      if([subview isKindOfClass:[RCTViewComponentView class]]) {
-        ((RCTViewComponentView*)subview).rncekvCustomGroup = nil;
-      } else {
-        subview.focusGroupIdentifier = nil;
-      }
-    }
-  }
-}
-#else
-
-- (void)clearSubview: (UIView*_Nullable)subview {
-  if(!subview) return;
-
+- (NSString *)focusGroupIdentifier {
   if (@available(iOS 14.0, *)) {
-    subview.focusGroupIdentifier = nil;
+    return _delegate.customGroupId ?: self.tagId;
   }
+  return self.tagId;
 }
 
-#endif
-
 @end

package/ios/Delegates/RNCEKVHaloDelegate/RNCEKVHaloDelegate.h

@@ -13,11 +13,10 @@
 
 @interface RNCEKVHaloDelegate : NSObject
 
-- (instancetype _Nonnull )initWithView:(UIView<RNCEKVHaloProtocol> *_Nonnull)view;
+- (instancetype _Nonnull)initWithView:(UIView<RNCEKVHaloProtocol> *_Nonnull)view;
 
-- (void)displayHalo:(BOOL)force;
-- (void)displayHalo;
-- (void)updateHalo;
+@property (nonatomic, readonly, nullable) UIFocusEffect *focusEffect;
+- (void)invalidate;
 - (void)clear;
 
 @end