react-native-universal-keyboard-aware-scrollview 1.0.0

package/ios/Podfile.properties.json

@@ -0,0 +1,5 @@
+{
+  "expo.jsEngine": "hermes",
+  "EX_DEV_CLIENT_NETWORK_INSPECTOR": "true",
+  "newArchEnabled": "true"
+}

package/ios/UniversalKeyboard.h

@@ -0,0 +1,24 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+/**
+ * UniversalKeyboard - Native iOS module for detecting keyboard height changes.
+ *
+ * This module provides reliable keyboard detection that works in:
+ * - Normal React Native screens
+ * - React Native Modal components
+ * - BottomSheet components
+ * - Any overlay/presentation scenarios
+ *
+ * It uses UIKeyboardWillChangeFrameNotification which is the most reliable
+ * notification for keyboard changes on iOS, providing accurate frame
+ * information including during interactive dismissals and keyboard size
+ * changes.
+ */
+@interface UniversalKeyboard : RCTEventEmitter <RCTBridgeModule>
+
+@property(nonatomic, assign) BOOL hasListeners;
+@property(nonatomic, assign) CGFloat lastKeyboardHeight;
+@property(nonatomic, assign) BOOL isKeyboardVisible;
+
+@end

package/ios/UniversalKeyboard.m

@@ -0,0 +1,413 @@
+#import "UniversalKeyboard.h"
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <UIKit/UIKit.h>
+
+@implementation UniversalKeyboard
+
+RCT_EXPORT_MODULE();
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _hasListeners = NO;
+    _lastKeyboardHeight = 0;
+    _isKeyboardVisible = NO;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self removeKeyboardObservers];
+}
+
+#pragma mark - RCTEventEmitter
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[
+    @"keyboardDidShow", @"keyboardDidHide", @"keyboardHeightChanged",
+    @"keyboardWillShow", @"keyboardWillHide"
+  ];
+}
+
+- (void)startObserving {
+  _hasListeners = YES;
+}
+
+- (void)stopObserving {
+  _hasListeners = NO;
+}
+
+#pragma mark - Public Methods
+
+/**
+ * Start listening for keyboard events.
+ * This method MUST be called from JS before keyboard events will be emitted.
+ */
+RCT_EXPORT_METHOD(startListening : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @try {
+      [self setupKeyboardObservers];
+      resolve(@YES);
+    } @catch (NSException *exception) {
+      reject(
+          @"ERROR",
+          [NSString stringWithFormat:@"Failed to start keyboard listener: %@",
+                                     exception.reason],
+          nil);
+    }
+  });
+}
+
+/**
+ * Stop listening for keyboard events.
+ * Call this when the component unmounts to prevent issues.
+ */
+RCT_EXPORT_METHOD(stopListening : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @try {
+      [self removeKeyboardObservers];
+      resolve(@YES);
+    } @catch (NSException *exception) {
+      reject(@"ERROR",
+             [NSString stringWithFormat:@"Failed to stop keyboard listener: %@",
+                                        exception.reason],
+             nil);
+    }
+  });
+}
+
+/**
+ * Get the current keyboard height.
+ */
+RCT_EXPORT_METHOD(getKeyboardHeight : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  resolve(@(self.lastKeyboardHeight));
+}
+
+/**
+ * Check if the keyboard is currently visible.
+ */
+RCT_EXPORT_METHOD(isKeyboardVisible : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  resolve(@(self.isKeyboardVisible));
+}
+
+/**
+ * Force dismiss the keyboard.
+ */
+RCT_EXPORT_METHOD(dismissKeyboard : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @try {
+      UIWindow *window = [self getKeyWindow];
+      if (window) {
+        [window endEditing:YES];
+      }
+      resolve(@YES);
+    } @catch (NSException *exception) {
+      reject(@"ERROR",
+             [NSString stringWithFormat:@"Failed to dismiss keyboard: %@",
+                                        exception.reason],
+             nil);
+    }
+  });
+}
+
+#pragma mark - Keyboard Observers
+
+/**
+ * Sets up observers for keyboard notifications.
+ * Uses multiple notifications for comprehensive keyboard tracking.
+ */
+- (void)setupKeyboardObservers {
+  // Remove existing observers first
+  [self removeKeyboardObservers];
+
+  NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+
+  // Main notification - provides frame information for all keyboard changes
+  [center addObserver:self
+             selector:@selector(keyboardWillChangeFrame:)
+                 name:UIKeyboardWillChangeFrameNotification
+               object:nil];
+
+  // Additional notifications for will show/hide
+  [center addObserver:self
+             selector:@selector(keyboardWillShow:)
+                 name:UIKeyboardWillShowNotification
+               object:nil];
+
+  [center addObserver:self
+             selector:@selector(keyboardWillHide:)
+                 name:UIKeyboardWillHideNotification
+               object:nil];
+
+  // Did show/hide for confirmation
+  [center addObserver:self
+             selector:@selector(keyboardDidShow:)
+                 name:UIKeyboardDidShowNotification
+               object:nil];
+
+  [center addObserver:self
+             selector:@selector(keyboardDidHide:)
+                 name:UIKeyboardDidHideNotification
+               object:nil];
+}
+
+/**
+ * Removes all keyboard observers to prevent memory leaks.
+ */
+- (void)removeKeyboardObservers {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+#pragma mark - Keyboard Notification Handlers
+
+/**
+ * Handler for UIKeyboardWillChangeFrameNotification.
+ * This is the most reliable notification for keyboard frame changes.
+ */
+- (void)keyboardWillChangeFrame:(NSNotification *)notification {
+  if (!self.hasListeners)
+    return;
+
+  NSDictionary *userInfo = notification.userInfo;
+  if (!userInfo)
+    return;
+
+  CGRect beginFrame = [userInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
+  CGRect endFrame = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+  NSTimeInterval duration =
+      [userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+  UIViewAnimationCurve curve =
+      [userInfo[UIKeyboardAnimationCurveUserInfoKey] integerValue];
+
+  // Calculate keyboard height
+  CGFloat keyboardHeight = [self calculateKeyboardHeightFromFrame:endFrame];
+
+  // Emit height change event
+  if (keyboardHeight != self.lastKeyboardHeight) {
+    self.lastKeyboardHeight = keyboardHeight;
+
+    [self sendEventWithName:@"keyboardHeightChanged"
+                       body:[self createEventDataWithHeight:keyboardHeight
+                                                   duration:duration
+                                                      curve:curve
+                                                 beginFrame:beginFrame
+                                                   endFrame:endFrame]];
+  }
+}
+
+/**
+ * Handler for UIKeyboardWillShowNotification.
+ */
+- (void)keyboardWillShow:(NSNotification *)notification {
+  if (!self.hasListeners)
+    return;
+
+  NSDictionary *userInfo = notification.userInfo;
+  CGRect endFrame = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+  NSTimeInterval duration =
+      [userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+  UIViewAnimationCurve curve =
+      [userInfo[UIKeyboardAnimationCurveUserInfoKey] integerValue];
+
+  CGFloat keyboardHeight = [self calculateKeyboardHeightFromFrame:endFrame];
+
+  [self sendEventWithName:@"keyboardWillShow"
+                     body:[self createEventDataWithHeight:keyboardHeight
+                                                 duration:duration
+                                                    curve:curve
+                                               beginFrame:CGRectZero
+                                                 endFrame:endFrame]];
+}
+
+/**
+ * Handler for UIKeyboardWillHideNotification.
+ */
+- (void)keyboardWillHide:(NSNotification *)notification {
+  if (!self.hasListeners)
+    return;
+
+  NSDictionary *userInfo = notification.userInfo;
+  NSTimeInterval duration =
+      [userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+  UIViewAnimationCurve curve =
+      [userInfo[UIKeyboardAnimationCurveUserInfoKey] integerValue];
+
+  [self sendEventWithName:@"keyboardWillHide"
+                     body:[self createEventDataWithHeight:0
+                                                 duration:duration
+                                                    curve:curve
+                                               beginFrame:CGRectZero
+                                                 endFrame:CGRectZero]];
+}
+
+/**
+ * Handler for UIKeyboardDidShowNotification.
+ */
+- (void)keyboardDidShow:(NSNotification *)notification {
+  if (!self.hasListeners)
+    return;
+
+  self.isKeyboardVisible = YES;
+
+  NSDictionary *userInfo = notification.userInfo;
+  CGRect endFrame = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+  CGFloat keyboardHeight = [self calculateKeyboardHeightFromFrame:endFrame];
+
+  self.lastKeyboardHeight = keyboardHeight;
+
+  [self sendEventWithName:@"keyboardDidShow"
+                     body:[self createEventDataWithHeight:keyboardHeight
+                                                 duration:0
+                                                    curve:0
+                                               beginFrame:CGRectZero
+                                                 endFrame:endFrame]];
+}
+
+/**
+ * Handler for UIKeyboardDidHideNotification.
+ */
+- (void)keyboardDidHide:(NSNotification *)notification {
+  if (!self.hasListeners)
+    return;
+
+  self.isKeyboardVisible = NO;
+  self.lastKeyboardHeight = 0;
+
+  [self sendEventWithName:@"keyboardDidHide"
+                     body:[self createEventDataWithHeight:0
+                                                 duration:0
+                                                    curve:0
+                                               beginFrame:CGRectZero
+                                                 endFrame:CGRectZero]];
+}
+
+#pragma mark - Helper Methods
+
+/**
+ * Calculates the keyboard height from keyboard frame.
+ * Accounts for safe area on notch devices.
+ */
+- (CGFloat)calculateKeyboardHeightFromFrame:(CGRect)frame {
+  CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height;
+
+  // If the keyboard frame extends beyond the screen, it's hidden
+  if (frame.origin.y >= screenHeight) {
+    return 0;
+  }
+
+  // Calculate keyboard height
+  CGFloat keyboardHeight = screenHeight - frame.origin.y;
+
+  // For modals and presented view controllers, we need to check
+  // if the keyboard is actually visible
+  if (keyboardHeight <= 0) {
+    return 0;
+  }
+
+  return keyboardHeight;
+}
+
+/**
+ * Gets the safe area bottom inset for proper keyboard height calculation.
+ */
+- (CGFloat)getSafeAreaBottomInset {
+  UIWindow *window = [self getKeyWindow];
+  if (@available(iOS 11.0, *)) {
+    if (window) {
+      return window.safeAreaInsets.bottom;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Gets the key window (works on iOS 13+ and earlier).
+ */
+- (UIWindow *)getKeyWindow {
+  if (@available(iOS 13.0, *)) {
+    for (UIWindowScene *scene in [UIApplication sharedApplication]
+             .connectedScenes) {
+      if (scene.activationState == UISceneActivationStateForegroundActive) {
+        for (UIWindow *window in scene.windows) {
+          if (window.isKeyWindow) {
+            return window;
+          }
+        }
+      }
+    }
+  }
+
+  // Fallback for iOS < 13
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  return [UIApplication sharedApplication].keyWindow;
+#pragma clang diagnostic pop
+}
+
+/**
+ * Creates the event data dictionary for keyboard events.
+ */
+- (NSDictionary *)createEventDataWithHeight:(CGFloat)height
+                                   duration:(NSTimeInterval)duration
+                                      curve:(UIViewAnimationCurve)curve
+                                 beginFrame:(CGRect)beginFrame
+                                   endFrame:(CGRect)endFrame {
+  CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height;
+  CGFloat screenWidth = [UIScreen mainScreen].bounds.size.width;
+  CGFloat safeAreaBottom = [self getSafeAreaBottomInset];
+
+  return @{
+    @"height" : @(height),
+    @"isVisible" : @(height > 0),
+    @"duration" : @(duration * 1000), // Convert to milliseconds
+    @"easing" : [self easingFromCurve:curve],
+    @"screenHeight" : @(screenHeight),
+    @"screenWidth" : @(screenWidth),
+    @"safeAreaBottom" : @(safeAreaBottom),
+    @"endCoordinates" : @{
+      @"screenX" : @(endFrame.origin.x),
+      @"screenY" : @(endFrame.origin.y),
+      @"width" : @(endFrame.size.width),
+      @"height" : @(endFrame.size.height)
+    },
+    @"startCoordinates" : @{
+      @"screenX" : @(beginFrame.origin.x),
+      @"screenY" : @(beginFrame.origin.y),
+      @"width" : @(beginFrame.size.width),
+      @"height" : @(beginFrame.size.height)
+    },
+    @"timestamp" : @([[NSDate date] timeIntervalSince1970] * 1000)
+  };
+}
+
+/**
+ * Converts UIViewAnimationCurve to a string identifier.
+ */
+- (NSString *)easingFromCurve:(UIViewAnimationCurve)curve {
+  switch (curve) {
+  case UIViewAnimationCurveEaseIn:
+    return @"easeIn";
+  case UIViewAnimationCurveEaseOut:
+    return @"easeOut";
+  case UIViewAnimationCurveEaseInOut:
+    return @"easeInOut";
+  case UIViewAnimationCurveLinear:
+    return @"linear";
+  default:
+    return @"keyboard"; // iOS keyboard uses a custom curve (7)
+  }
+}
+
+@end

package/ios/reactnativeuniversalkeyboardawarescrollview/AppDelegate.swift

@@ -0,0 +1,70 @@
+import Expo
+import React
+import ReactAppDependencyProvider
+
+@UIApplicationMain
+public class AppDelegate: ExpoAppDelegate {
+  var window: UIWindow?
+
+  var reactNativeDelegate: ExpoReactNativeFactoryDelegate?
+  var reactNativeFactory: RCTReactNativeFactory?
+
+  public override func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
+  ) -> Bool {
+    let delegate = ReactNativeDelegate()
+    let factory = ExpoReactNativeFactory(delegate: delegate)
+    delegate.dependencyProvider = RCTAppDependencyProvider()
+
+    reactNativeDelegate = delegate
+    reactNativeFactory = factory
+    bindReactNativeFactory(factory)
+
+#if os(iOS) || os(tvOS)
+    window = UIWindow(frame: UIScreen.main.bounds)
+    factory.startReactNative(
+      withModuleName: "main",
+      in: window,
+      launchOptions: launchOptions)
+#endif
+
+    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
+  }
+
+  // Linking API
+  public override func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+  ) -> Bool {
+    return super.application(app, open: url, options: options) || RCTLinkingManager.application(app, open: url, options: options)
+  }
+
+  // Universal Links
+  public override func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    let result = RCTLinkingManager.application(application, continue: userActivity, restorationHandler: restorationHandler)
+    return super.application(application, continue: userActivity, restorationHandler: restorationHandler) || result
+  }
+}
+
+class ReactNativeDelegate: ExpoReactNativeFactoryDelegate {
+  // Extension point for config-plugins
+
+  override func sourceURL(for bridge: RCTBridge) -> URL? {
+    // needed to return the correct URL for expo-dev-client.
+    bridge.bundleURL ?? bundleURL()
+  }
+
+  override func bundleURL() -> URL? {
+#if DEBUG
+    return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry")
+#else
+    return Bundle.main.url(forResource: "main", withExtension: "jsbundle")
+#endif
+  }
+}

package/ios/reactnativeuniversalkeyboardawarescrollview/Images.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,14 @@
+{
+  "images": [
+    {
+      "filename": "App-Icon-1024x1024@1x.png",
+      "idiom": "universal",
+      "platform": "ios",
+      "size": "1024x1024"
+    }
+  ],
+  "info": {
+    "version": 1,
+    "author": "expo"
+  }
+}

package/ios/reactnativeuniversalkeyboardawarescrollview/Images.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "expo"
+  }
+}

package/ios/reactnativeuniversalkeyboardawarescrollview/Images.xcassets/SplashScreenBackground.colorset/Contents.json

@@ -0,0 +1,20 @@
+{
+  "colors": [
+    {
+      "color": {
+        "components": {
+          "alpha": "1.000",
+          "blue": "1.00000000000000",
+          "green": "1.00000000000000",
+          "red": "1.00000000000000"
+        },
+        "color-space": "srgb"
+      },
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "version": 1,
+    "author": "expo"
+  }
+}

package/ios/reactnativeuniversalkeyboardawarescrollview/Images.xcassets/SplashScreenLegacy.imageset/Contents.json

@@ -0,0 +1,23 @@
+{
+  "images": [
+    {
+      "idiom": "universal",
+      "filename": "image.png",
+      "scale": "1x"
+    },
+    {
+      "idiom": "universal",
+      "filename": "image@2x.png",
+      "scale": "2x"
+    },
+    {
+      "idiom": "universal",
+      "filename": "image@3x.png",
+      "scale": "3x"
+    }
+  ],
+  "info": {
+    "version": 1,
+    "author": "expo"
+  }
+}

package/ios/reactnativeuniversalkeyboardawarescrollview/Info.plist

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>CADisableMinimumFrameDurationOnPhone</key>
+    <true/>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleDisplayName</key>
+    <string>react-native-universal-keyboard-aware-scrollview</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0.0</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundleURLTypes</key>
+    <array>
+      <dict>
+        <key>CFBundleURLSchemes</key>
+        <array>
+          <string>com.anonymous.reactnativeuniversalkeyboardawarescrollview</string>
+        </array>
+      </dict>
+    </array>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>12.0</string>
+    <key>LSRequiresIPhoneOS</key>
+    <true/>
+    <key>NSAppTransportSecurity</key>
+    <dict>
+      <key>NSAllowsArbitraryLoads</key>
+      <false/>
+      <key>NSAllowsLocalNetworking</key>
+      <true/>
+    </dict>
+    <key>RCTNewArchEnabled</key>
+    <true/>
+    <key>UILaunchStoryboardName</key>
+    <string>SplashScreen</string>
+    <key>UIRequiredDeviceCapabilities</key>
+    <array>
+      <string>arm64</string>
+    </array>
+    <key>UIRequiresFullScreen</key>
+    <false/>
+    <key>UIStatusBarStyle</key>
+    <string>UIStatusBarStyleDefault</string>
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+      <string>UIInterfaceOrientationPortrait</string>
+      <string>UIInterfaceOrientationPortraitUpsideDown</string>
+    </array>
+    <key>UISupportedInterfaceOrientations~ipad</key>
+    <array>
+      <string>UIInterfaceOrientationPortrait</string>
+      <string>UIInterfaceOrientationPortraitUpsideDown</string>
+      <string>UIInterfaceOrientationLandscapeLeft</string>
+      <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+    <key>UIUserInterfaceStyle</key>
+    <string>Light</string>
+    <key>UIViewControllerBasedStatusBarAppearance</key>
+    <false/>
+  </dict>
+</plist>