react-native-external-keyboard 0.9.1 → 0.11.1

package/ios/Helpers/RNCEKVNativeProps/RNCEKVNativeProps.h

@@ -45,6 +45,7 @@ struct HaloProps {
   double haloExpendY{0};
   double haloCornerRadius{0};
   facebook::react::SharedColor tintColor{};
+  bool roundedHaloFix{false};
 
   template <typename T>
   static HaloProps from(const T &props) {
@@ -54,6 +55,7 @@ struct HaloProps {
       props.haloExpendY,
       props.haloCornerRadius,
       props.tintColor,
+      props.roundedHaloFix,
     };
   }
 };
@@ -96,13 +98,11 @@ struct ContextMenuProps {
 
 struct AutoFocusProps {
   bool autoFocus{false};
-  bool enableA11yFocus{false};
-  
+
   template <typename T>
   static AutoFocusProps from(const T &props) {
     return AutoFocusProps{
       props.autoFocus,
-      props.enableA11yFocus,
     };
   }
 };
@@ -110,7 +110,7 @@ struct AutoFocusProps {
 struct KeyPressProps {
   bool hasKeyDownPress{false};
   bool hasKeyUpPress{false};
-  
+
   template <typename T>
   static KeyPressProps from(const T &props) {
     return KeyPressProps{

package/ios/Helpers/RNCEKVSwizzleInstanceMethod/RNCEKVSwizzleInstanceMethod.h

@@ -13,4 +13,23 @@
 
 void RNCEKVSwizzleInstanceMethod(Class swizzleClass, SEL originalSelector, SEL swizzledSelector);
 
+#define RNCEKV_CONCAT_INNER(a, b) a##b
+#define RNCEKV_CONCAT(a, b) RNCEKV_CONCAT_INNER(a, b)
+
+#ifdef RCT_DYNAMIC_FRAMEWORKS
+
+#define RNCEKV_INSTALL_SWIZZLES(registerFn)                                    \
+  __attribute__((constructor))                                                 \
+  static void RNCEKV_CONCAT(RNCEKVInstall_, registerFn)(void) { registerFn(); }
+
+#else
+
+#define RNCEKV_INSTALL_SWIZZLES(registerFn)                                    \
+  + (void)load {                                                               \
+    static dispatch_once_t RNCEKV_CONCAT(once_, registerFn);                   \
+    dispatch_once(&RNCEKV_CONCAT(once_, registerFn), ^{ registerFn(); });      \
+  }
+
+#endif
+
 #endif /* RNCEKVSwizzleInstanceMethod_h */

package/ios/Protocols/RNCEKVCustomFocusEffectProtocol.h

@@ -9,7 +9,7 @@
 #define RNCEKVCustomFocusEffectProtocol_h
 
 @protocol RNCEKVCustomFocusEffectProtocol <NSObject>
-- (UIFocusEffect*)customFocusEffect;
+- (UIFocusEffect*)customFocusEffect API_AVAILABLE(ios(15.0));
 @end
 
 #endif /* RNCEKVCustomFocusEffectProtocol_h */

package/ios/Services/RNCEKVFocusMemoryService.h

@@ -0,0 +1,39 @@
+//
+//  RNCEKVFocusMemoryService.h
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 05/06/2026.
+//
+
+#ifndef RNCEKVFocusMemoryService_h
+#define RNCEKVFocusMemoryService_h
+
+#import <UIKit/UIKit.h>
+
+/// Remembers the focused view inside a focus environment and restores it later.
+///
+/// Reusable for any "leave then come back" flow — modal presentation, screen
+/// navigation, etc. The owner decides *when* to call store / restore; the only
+/// difference between flows is the ordering of those two calls:
+///
+///   Modal:      store on present, restore on dismiss.
+///   Navigation: store on disappear, restore on appear.
+///
+/// The stored view is held weakly, so it never keeps a detached view alive.
+@interface RNCEKVFocusMemoryService : NSObject
+
+/// Captures the currently focused view in the environment and marks it preferred.
+- (void)store:(id<UIFocusEnvironment>)environment;
+
+/// Restores focus to the stored view (if any) and clears the stored reference.
+- (void)restore;
+
+/// Returns the currently stored view without consuming it, or nil.
+- (UIView *)get;
+
+/// Drops the stored reference without restoring focus.
+- (void)clean;
+
+@end
+
+#endif /* RNCEKVFocusMemoryService_h */

package/ios/Services/RNCEKVFocusMemoryService.mm

@@ -0,0 +1,42 @@
+//
+//  RNCEKVFocusMemoryService.mm
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 05/06/2026.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVFocusMemoryService.h"
+#import "RNCEKVKeyboardFocusService.h"
+
+@implementation RNCEKVFocusMemoryService {
+  __weak UIView *_storedView;
+}
+
+- (void)store:(id<UIFocusEnvironment>)environment {
+  if (!environment) {
+    return;
+  }
+
+  _storedView = [RNCEKVKeyboardFocusService getFocusedItem:environment];
+  [RNCEKVKeyboardFocusService updatePreferredFocusEnvironment:_storedView];
+}
+
+- (void)restore {
+  if (!_storedView) {
+    return;
+  }
+
+  [RNCEKVKeyboardFocusService focus:_storedView];
+  _storedView = nil;
+}
+
+- (UIView *)get {
+  return _storedView;
+}
+
+- (void)clean {
+  _storedView = nil;
+}
+
+@end

package/ios/Services/RNCEKVKeyboardFocusService.h

@@ -0,0 +1,28 @@
+//
+//  RNCEKVKeyboardFocusService.h
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 05/06/2026.
+//
+
+#ifndef RNCEKVKeyboardFocusService_h
+#define RNCEKVKeyboardFocusService_h
+
+#import <UIKit/UIKit.h>
+
+/// Public entry point for driving the UIKit focus engine from custom native code.
+/// All methods are static — this service holds no state.
+@interface RNCEKVKeyboardFocusService : NSObject
+
+/// Returns the view currently focused inside the given focus environment, or nil.
++ (UIView *)getFocusedItem:(id<UIFocusEnvironment>)environment;
+
+/// Marks a view as the preferred focus environment without forcing a focus update.
++ (void)updatePreferredFocusEnvironment:(UIView *)view;
+
+/// Moves keyboard focus to the given view on the next focus update.
++ (void)focus:(UIView *)view;
+
+@end
+
+#endif /* RNCEKVKeyboardFocusService_h */

package/ios/Services/RNCEKVKeyboardFocusService.mm

@@ -0,0 +1,54 @@
+//
+//  RNCEKVKeyboardFocusService.mm
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 05/06/2026.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVKeyboardFocusService.h"
+#import "UIViewController+RNCEKVExternalKeyboard.h"
+#import <React/RCTUtils.h>
+
+@implementation RNCEKVKeyboardFocusService
+
++ (UIView *)getFocusedItem:(id<UIFocusEnvironment>)environment {
+  if (!environment) {
+    return nil;
+  }
+
+  @try {
+    UIFocusSystem *focusSystem = [UIFocusSystem focusSystemForEnvironment:environment];
+    if (![focusSystem.focusedItem isKindOfClass:[UIView class]]) {
+      return nil;
+    }
+
+    return (UIView *)focusSystem.focusedItem;
+  } @catch (NSException *exception) {
+    return nil;
+  }
+}
+
++ (void)updatePreferredFocusEnvironment:(UIView *)view {
+  if (!view) {
+    return;
+  }
+
+  UIWindow *window = RCTKeyWindow();
+  if (window && window.rootViewController) {
+    window.rootViewController.rncekvCustomFocusView = view;
+  }
+}
+
++ (void)focus:(UIView *)view {
+  if (!view) {
+    return;
+  }
+
+  UIWindow *window = RCTKeyWindow();
+  if (window && window.rootViewController) {
+    [window.rootViewController rncekvFocusView:view];
+  }
+}
+
+@end

package/ios/Views/Base/FocusChange/RNCEKVViewFocusChangeBase.h

@@ -31,6 +31,8 @@ newProps:(const RNCEKV::FocusProps &)newProps;
 
 - (void)onFocusChangeHandler:(BOOL)isFocused;
 
+- (NSNumber *)resolveFocusChange:(UIFocusUpdateContext *)context;
+
 @end
 
 

package/ios/Views/Base/FocusChange/RNCEKVViewFocusChangeBase.mm

@@ -20,10 +20,6 @@
   NSNumber* _isFocused;
 }
 
-- (BOOL)isGroup {
-  return false;
-}
-
 - (BOOL)isKeyboardFocused {
   return [_isFocused isEqual:@YES];
 }
@@ -33,7 +29,7 @@
     _focusDelegate = [[RNCEKVFocusDelegate alloc] initWithView:self];
     _isFocused = nil;
   }
-  
+
   return self;
 }
 
@@ -50,15 +46,21 @@
 
 
 - (BOOL)canBecomeFocused {
-  if (!_canBeFocused)
-    NO;
-  return [_focusDelegate canBecomeFocused];
+  if (!self.focusableWrapper) {
+    return _canBeFocused;
+  }
+
+  return [super canBecomeFocused];
 }
 
 
+- (NSNumber *)resolveFocusChange:(UIFocusUpdateContext *)context {
+  return [_focusDelegate isFocusChanged:context];
+}
+
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
        withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator {
-  _isFocused = [_focusDelegate isFocusChanged:context];
+  _isFocused = [self resolveFocusChange:context];
 
   if ([self hasOnFocusChanged]) {
     if (_isFocused != nil) {
@@ -76,7 +78,7 @@
   if (_canBeFocused != newProps.canBeFocused) {
     [self setCanBeFocused:newProps.canBeFocused];
   }
-  
+
   if (_hasOnFocusChanged != newProps.hasOnFocusChanged) {
     [self setHasOnFocusChanged:newProps.hasOnFocusChanged];
   }

package/ios/Views/Base/FocusRequest/RNCEKVViewFocusRequestBase.h

@@ -18,7 +18,6 @@
 @interface RNCEKVViewFocusRequestBase : RNCEKVViewContextMenuBase
 
 @property BOOL autoFocus;
-@property BOOL enableA11yFocus;
 
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -28,6 +27,7 @@ newProps:(const RNCEKV::AutoFocusProps &)newProps;
 #endif
 
 - (void)focus;
+- (void)screenReaderFocus;
 
 @end
 

package/ios/Views/Base/FocusRequest/RNCEKVViewFocusRequestBase.mm

@@ -19,13 +19,11 @@
 @implementation RNCEKVViewFocusRequestBase {
   BOOL _isAttachedToWindow;
   BOOL _autoFocusRequested;
-  BOOL _enableA11yFocus;
 }
 
 - (void)cleanReferences {
   [super cleanReferences];
   _isAttachedToWindow = NO;
-  _enableA11yFocus = NO;
   _autoFocusRequested = NO;
 }
 
@@ -39,14 +37,17 @@
 }
 
 - (void)focus {
-  
   UIViewController *controller = self.reactViewController;
   if (controller != nil) {
     [controller rncekvFocusView: self];
   }
-  
+}
+
+- (void)screenReaderFocus {
   dispatch_async(dispatch_get_main_queue(), ^{
-    [self a11yFocus];
+    UIView *focusView = [self getFocusTargetView];
+    UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification,
+                                    focusView);
   });
 }
 
@@ -56,10 +57,6 @@ newProps:(const RNCEKV::AutoFocusProps &)newProps {
     if (oldProps.autoFocus != newProps.autoFocus) {
       [self setAutoFocus: newProps.autoFocus];
     }
-  
-  if (_enableA11yFocus != newProps.enableA11yFocus) {
-    [self setEnableA11yFocus: newProps.enableA11yFocus];
-  }
 }
 
 
@@ -71,14 +68,6 @@ newProps:(const RNCEKV::AutoFocusProps &)newProps {
   [self focusOnMount];
 }
 
-- (void)a11yFocus {
-  if (!_enableA11yFocus)
-    return;
-  UIView *focusView = [self getFocusTargetView];
-  UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification,
-                                  focusView);
-}
-
 - (void)focusOnMount {
   if (self.autoFocus) {
     if(!_autoFocusRequested) {

package/ios/Views/Base/KeyboardHallo/RNCEKVExternalKeyboardHalloBase.h

@@ -22,6 +22,7 @@
 @property (nonatomic, assign) CGFloat haloExpendX;
 @property (nonatomic, assign) CGFloat haloExpendY;
 @property (nonatomic, assign) BOOL isHaloHidden;
+@property (nonatomic, assign) BOOL roundedHaloFix;
 
 #ifdef RCT_NEW_ARCH_ENABLED
 - (void)updateHaloProps:(const RNCEKV::HaloProps &)oldProps

package/ios/Views/Base/KeyboardHallo/RNCEKVExternalKeyboardHalloBase.mm

@@ -10,12 +10,31 @@
 #import "RNCEKVHaloDelegate.h"
 #import "RNCEKVExternalKeyboardHalloBase.h"
 
+// See CLAUDE.md in this directory for the full rationale (RN's cornerRadius
+// toggle, the pinned custom halo, the delayed re-arm and loop guard).
+
 #ifdef RCT_NEW_ARCH_ENABLED
   #import <React/RCTConversions.h>
+
+// invalidateLayer is private to RCTViewComponentView; forward-declare so the
+// override and its [super] call compile cleanly.
+@interface RNCEKVBaseViewClass (RNCEKVInvalidateLayer)
+- (void)invalidateLayer;
+@end
 #endif
 
+// Delay before re-arming, to win UIKit's same-pass default halo (see CLAUDE.md).
+static const NSTimeInterval RNCEKVHaloRearmDelay = 0.02;
+
 @implementation RNCEKVExternalKeyboardHalloBase {
   RNCEKVHaloDelegate *_haloDelegate;
+  BOOL _rearmScheduled;       // a flush is already pending
+  // Dedup signature — re-arm only when one of these changed (breaks the loop).
+  CGRect _lastArmedBounds;
+  CGFloat _lastArmedRadius;
+  BOOL _lastArmedFocused;
+  CGFloat _stableLayerRadius; // last non-zero cornerRadius (RN toggles it to 0)
+  BOOL _forceRearm;           // a halo prop changed — re-arm even if geometry didn't
 }
 
 - (instancetype)initWithFrame:(CGRect)frame
@@ -23,7 +42,7 @@
   if (self = [super initWithFrame:frame]) {
     _haloDelegate = [[RNCEKVHaloDelegate alloc] initWithView:self];
   }
-  
+
   return self;
 }
 
@@ -31,37 +50,154 @@
   return _haloDelegate.focusEffect;
 }
 
+- (UIFocusEffect*)focusEffect API_AVAILABLE(ios(15.0)) {
+  // Hidden views must return our empty effect even when wrapper, or the system
+  // default ring leaks through (see CLAUDE.md).
+  if (!self.focusableWrapper || self.isHaloHidden) {
+    UIFocusEffect* effect = [self customFocusEffect];
+    if(effect != nil) {
+      return effect;
+    }
+  }
+
+  return [super focusEffect];
+}
+
+
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+
+  if(!self.isHaloHidden && !self.roundedHaloFix) return;
+
+  [self observeStableRadius];
+  [self setNeedsHaloRearm];
+}
+
+- (UIView *)rearmTarget {
+  return (self.focusableWrapper && self.subviews.count > 0)
+    ? self.subviews.firstObject
+    : self;
+}
+
+// Cache the last non-zero corner radius so the delegate pins the halo to it,
+// not to the transient 0 RN sets mid-pass (see CLAUDE.md).
+- (void)observeStableRadius {
+  CGFloat radius = [self getFocusTargetView].layer.cornerRadius;
+  if (radius > 0) {
+    _stableLayerRadius = radius;
+    [_haloDelegate observeCornerRadius:radius];
+  }
+}
+
+// Coalesce a burst of passes into one delayed re-arm (see CLAUDE.md).
+- (void)setNeedsHaloRearm {
+  if (_rearmScheduled) return;
+  _rearmScheduled = YES;
+
+  __weak __typeof(self) weakSelf = self;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(RNCEKVHaloRearmDelay * NSEC_PER_SEC)),
+                 dispatch_get_main_queue(), ^{
+    [weakSelf flushHaloRearm];
+  });
+}
+
+- (void)flushHaloRearm {
+  _rearmScheduled = NO;
+
+  UIView *target = [self rearmTarget];
+  BOOL focused = target.isFocused;
+
+  // The halo only renders on the focused view; skip the rest otherwise.
+  if (!focused) {
+    _lastArmedFocused = NO;
+    return;
+  }
+
+  // Skip when the signature is unchanged — this is what stops the re-arm from
+  // feeding itself (see CLAUDE.md). Key on the stable radius, never the live one.
+  CGRect bounds = target.bounds;
+  CGFloat radius = _stableLayerRadius;
+  if (!_forceRearm &&
+      _lastArmedFocused &&
+      CGRectEqualToRect(bounds, _lastArmedBounds) &&
+      radius == _lastArmedRadius) {
+    return;
+  }
+
+  _forceRearm = NO;
+  _lastArmedBounds = bounds;
+  _lastArmedRadius = radius;
+  _lastArmedFocused = YES;
+
+  // Re-arm: read focusEffect and write it back to force UIKit to repaint.
+  if (@available(iOS 15.0, *)) {
+    target.focusEffect = target.focusEffect;
+  }
+}
+
 - (void)cleanReferences {
   [super cleanReferences];
   [_haloDelegate clear];
+  _rearmScheduled = NO;
+  _lastArmedBounds = CGRectZero;
+  _lastArmedRadius = 0;
+  _lastArmedFocused = NO;
+  _stableLayerRadius = 0;
+  _forceRearm = NO;
   _isHaloHidden = false;
   _haloExpendX = 0;
   _haloExpendY = 0;
   _haloCornerRadius = 0;
+  _roundedHaloFix = false;
 }
 
 
+// A halo prop changed: force a re-arm even if geometry didn't move (see CLAUDE.md).
+- (void)haloAppearanceChanged {
+  [_haloDelegate invalidate];
+  _forceRearm = YES;
+  [self setNeedsHaloRearm];
+}
+
 - (void)setIsHaloHidden:(BOOL)isHaloHidden {
   _isHaloHidden = isHaloHidden;
-  [_haloDelegate invalidate];
+  [self haloAppearanceChanged];
 }
 
 - (void)setHaloCornerRadius:(CGFloat)haloCornerRadius {
   _haloCornerRadius = haloCornerRadius;
-  [_haloDelegate invalidate];
+  [self haloAppearanceChanged];
 }
 
 - (void)setHaloExpendX:(CGFloat)haloExpendX {
   _haloExpendX = haloExpendX;
-  [_haloDelegate invalidate];
+  [self haloAppearanceChanged];
 }
 
 - (void)setHaloExpendY:(CGFloat)haloExpendY {
   _haloExpendY = haloExpendY;
-  [_haloDelegate invalidate];
+  [self haloAppearanceChanged];
+}
+
+- (void)setRoundedHaloFix:(BOOL)roundedHaloFix {
+  _roundedHaloFix = roundedHaloFix;
+  [self haloAppearanceChanged];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
+
+
+- (void)invalidateLayer {
+  [super invalidateLayer]; // must run first — RN sets the layer here
+
+  if (!self.isHaloHidden && !self.roundedHaloFix) return;
+
+  // Catches the cornerRadius/style repaints layoutSubviews doesn't (see CLAUDE.md).
+  [self observeStableRadius];
+  [self setNeedsHaloRearm];
+}
+
 - (void)updateHaloProps:(const RNCEKV::HaloProps &)oldProps
                newProps:(const RNCEKV::HaloProps &)newProps {
   if (_isHaloHidden == newProps.haloEffect) {
@@ -79,7 +215,11 @@
   if (oldProps.haloCornerRadius != newProps.haloCornerRadius) {
     [self setHaloCornerRadius:newProps.haloCornerRadius];
   }
-  
+
+  if (self.roundedHaloFix != newProps.roundedHaloFix) {
+    [self setRoundedHaloFix:newProps.roundedHaloFix];
+  }
+
   UIColor *newColor = RCTUIColorFromSharedColor(newProps.tintColor);
   BOOL renewColor = newColor != nil && self.tintColor == nil;
   BOOL isColorChanged = oldProps.tintColor != newProps.tintColor;

package/ios/Views/Base/ViewGroup/RNCEKVViewGroupBase.h

@@ -27,6 +27,8 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)onSubviewRemoved:(UIView *)subview;
 - (void)onSubviewsLayoutUpdated;
 
+- (BOOL)focusableWrapper;
+
 - (void)cleanReferences;
 
 @end

package/ios/Views/Base/ViewGroup/RNCEKVViewGroupBase.mm

@@ -60,4 +60,8 @@
 
 - (void)onSubviewsLayoutUpdated {}
 
+- (BOOL)focusableWrapper {
+  return NO;
+}
+
 @end

package/ios/Views/RNCEKVExternalKeyboardView/RNCEKVExternalKeyboardView.h

@@ -12,7 +12,7 @@
 
 @interface RNCEKVExternalKeyboardView : RNCEKVViewKeyPress <RNCEKVKeyboardFocusableProtocol>
 
-@property BOOL isGroup;
+@property BOOL focusableWrapper;
 
 #ifndef RCT_NEW_ARCH_ENABLED
 @property (nonatomic, copy) RCTDirectEventBlock onFocusChange;

package/ios/Views/RNCEKVExternalKeyboardView/RNCEKVExternalKeyboardView.mm

@@ -58,10 +58,14 @@ using namespace facebook::react;
 
 
 - (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
-  NSString *FOCUS = @"focus";
-  if ([commandName isEqual:FOCUS]) {
+  NSString *KEYBOARD_FOCUS = @"rnekKeyboardFocus";
+  NSString *SCREEN_READER_FOCUS = @"rnekScreenReaderFocus";
+  if ([commandName isEqual:KEYBOARD_FOCUS]) {
     [self focus];
   }
+  if ([commandName isEqual:SCREEN_READER_FOCUS]) {
+    [self screenReaderFocus];
+  }
 }
 
 - (void)updateProps:(Props::Shared const &)props
@@ -91,8 +95,8 @@ using namespace facebook::react;
   [self updateFocusRequestProps:RNCEKV::AutoFocusProps::from(oldViewProps)
                      newProps:RNCEKV::AutoFocusProps::from(newViewProps)];
 
-  if (oldViewProps.group != newViewProps.group) {
-    [self setIsGroup:newViewProps.group];
+  if (oldViewProps.focusableWrapper != newViewProps.focusableWrapper) {
+    [self setFocusableWrapper:newViewProps.focusableWrapper];
   }
 }