react-native-reanimated 2.9.1 → 2.10.0

package/ios/keyboardObserver/REAKeyboardEventObserver.m

@@ -0,0 +1,198 @@
+#import "REAKeyboardEventObserver.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import <React/RCTUIManager.h>
+
+typedef NS_ENUM(NSUInteger, KeyboardState) {
+  UNKNOWN = 0,
+  OPENING = 1,
+  OPEN = 2,
+  CLOSING = 3,
+  CLOSED = 4,
+};
+
+@implementation REAKeyboardEventObserver {
+  NSNumber *_nextListenerId;
+  NSMutableDictionary *_listeners;
+  CADisplayLink *displayLink;
+  int _windowsCount;
+  UIView *_keyboardView;
+  KeyboardState _state;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  _listeners = [[NSMutableDictionary alloc] init];
+  _nextListenerId = @0;
+  _state = UNKNOWN;
+  return self;
+}
+
+// copied from
+// https://github.com/tonlabs/UIKit/blob/bd5651e4723d547bde0cb86ca1c27813cedab4a9/casts/keyboard/ios/UIKitKeyboardIosFrameListener.m
+- (UIView *)findKeyboardView
+{
+  for (UIWindow *window in [UIApplication.sharedApplication.windows objectEnumerator]) {
+    if ([window isKindOfClass:NSClassFromString(@"UITextEffectsWindow")]) {
+      for (UIView *containerView in window.subviews) {
+        if ([containerView isKindOfClass:NSClassFromString(@"UIInputSetContainerView")]) {
+          for (UIView *hostView in containerView.subviews) {
+            if ([hostView isKindOfClass:NSClassFromString(@"UIInputSetHostView")]) {
+              return hostView;
+            }
+          }
+        }
+      }
+    }
+  }
+  return nil;
+}
+
+- (UIView *)getKeyboardView
+{
+  /**
+   * If the count of windows has changed it means there might be a new UITextEffectsWindow,
+   * thus we have to obtain a new `keyboardView`
+   */
+  int windowsCount = [UIApplication.sharedApplication.windows count];
+
+  if (_keyboardView == nil || windowsCount != _windowsCount) {
+    _keyboardView = [self findKeyboardView];
+    _windowsCount = windowsCount;
+  }
+  return _keyboardView;
+}
+
+#if TARGET_OS_TV
+- (int)subscribeForKeyboardEvents:(KeyboardEventListenerBlock)listener
+{
+  NSLog(@"Keyboard handling is not supported on tvOS");
+  return 0;
+}
+
+- (void)unsubscribeFromKeyboardEvents:(int)listenerId
+{
+  NSLog(@"Keyboard handling is not supported on tvOS");
+}
+#else
+
+- (void)runAnimation
+{
+  displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(updateKeyboardFrame)];
+  [displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+- (void)stopAnimation
+{
+  [displayLink invalidate];
+  displayLink = nil;
+  [self updateKeyboardFrame];
+}
+
+- (void)updateKeyboardFrame
+{
+  UIView *keyboardView = [self getKeyboardView];
+  if (keyboardView == nil) {
+    return;
+  }
+
+  CGFloat keyboardHeight = [self computeKeyboardHeight:keyboardView];
+  for (NSString *key in _listeners.allKeys) {
+    ((KeyboardEventListenerBlock)_listeners[key])(_state, keyboardHeight);
+  }
+}
+
+- (CGFloat)computeKeyboardHeight:(UIView *)keyboardView
+{
+  CGFloat keyboardFrameY = [keyboardView.layer presentationLayer].frame.origin.y;
+  CGFloat keyboardWindowH = keyboardView.window.bounds.size.height;
+  CGFloat keyboardHeight = keyboardWindowH - keyboardFrameY;
+  return keyboardHeight;
+}
+
+- (void)keyboardWillShow:(NSNotification *)notification
+{
+  _state = OPENING;
+  [self runAnimation];
+}
+
+- (void)keyboardDidShow:(NSNotification *)notification
+{
+  _state = OPEN;
+  [self stopAnimation];
+}
+
+- (void)keyboardWillHide:(NSNotification *)notification
+{
+  _state = CLOSING;
+  [self runAnimation];
+}
+
+- (void)keyboardDidHide:(NSNotification *)notification
+{
+  _state = CLOSED;
+  [self stopAnimation];
+}
+
+- (int)subscribeForKeyboardEvents:(KeyboardEventListenerBlock)listener
+{
+  NSNumber *listenerId = [_nextListenerId copy];
+  _nextListenerId = [NSNumber numberWithInt:[_nextListenerId intValue] + 1];
+  if ([_listeners count] == 0) {
+    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
+
+    [notificationCenter addObserver:self
+                           selector:@selector(keyboardWillHide:)
+                               name:UIKeyboardWillHideNotification
+                             object:nil];
+
+    [notificationCenter addObserver:self
+                           selector:@selector(keyboardWillShow:)
+                               name:UIKeyboardWillShowNotification
+                             object:nil];
+
+    [notificationCenter addObserver:self
+                           selector:@selector(keyboardDidHide:)
+                               name:UIKeyboardDidHideNotification
+                             object:nil];
+
+    [notificationCenter addObserver:self
+                           selector:@selector(keyboardDidShow:)
+                               name:UIKeyboardDidShowNotification
+                             object:nil];
+  }
+
+  [_listeners setObject:listener forKey:listenerId];
+  if (_state == UNKNOWN) {
+    [self recognizeInitialKeyboardState];
+  }
+  return [listenerId intValue];
+}
+
+- (void)unsubscribeFromKeyboardEvents:(int)listenerId
+{
+  NSNumber *_listenerId = [NSNumber numberWithInt:listenerId];
+  [_listeners removeObjectForKey:_listenerId];
+  if ([_listeners count] == 0) {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+  }
+}
+
+- (void)recognizeInitialKeyboardState
+{
+  RCTExecuteOnMainQueue(^() {
+    UIView *keyboardView = [self getKeyboardView];
+    if (keyboardView == nil) {
+      self->_state = CLOSED;
+    } else {
+      CGFloat keyboardHeight = [self computeKeyboardHeight:keyboardView];
+      self->_state = keyboardHeight == 0 ? CLOSED : OPEN;
+    }
+    [self updateKeyboardFrame];
+  });
+}
+
+#endif
+
+@end

package/ios/native/NativeProxy.mm

@@ -4,6 +4,7 @@
 #import <RNReanimated/REAAnimationsManager.h>
 #import <RNReanimated/REAIOSErrorHandler.h>
 #import <RNReanimated/REAIOSScheduler.h>
+#import <RNReanimated/REAKeyboardEventObserver.h>
 #import <RNReanimated/REAModule.h>
 #import <RNReanimated/REANodesManager.h>
 #import <RNReanimated/REAUIManager.h>
@@ -297,6 +298,21 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
   auto unregisterSensorFunction = [=](int sensorId) { [reanimatedSensorContainer unregisterSensor:sensorId]; };
   // end sensors
 
+  // keyboard events
+
+  static REAKeyboardEventObserver *keyboardObserver = [[REAKeyboardEventObserver alloc] init];
+  auto subscribeForKeyboardEventsFunction =
+      [](std::function<void(int keyboardState, int height)> keyboardEventDataUpdater) {
+        return [keyboardObserver subscribeForKeyboardEvents:^(int keyboardState, int height) {
+          keyboardEventDataUpdater(keyboardState, height);
+        }];
+      };
+
+  auto unsubscribeFromKeyboardEventsFunction = [](int listenerId) {
+    [keyboardObserver unsubscribeFromKeyboardEvents:listenerId];
+  };
+  // end keyboard events
+
   PlatformDepMethodsHolder platformDepMethodsHolder = {
       requestRender,
       propUpdater,
@@ -306,7 +322,10 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
       registerSensorFunction,
       unregisterSensorFunction,
       setGestureStateFunction,
-      configurePropsFunction};
+      configurePropsFunction,
+      subscribeForKeyboardEventsFunction,
+      unsubscribeFromKeyboardEventsFunction,
+  };
 
   module = std::make_shared<NativeReanimatedModule>(
       jsInvoker,

package/ios/native/REAInitializer.mm

@@ -45,20 +45,16 @@ JSIExecutor::RuntimeInstaller REAJSIExecutorRuntimeInstaller(
     auto callInvoker = std::make_shared<react::BridgeJSCallInvoker>(bridge.reactInstance);
     auto reanimatedModule = reanimated::createReanimatedModule(bridge, callInvoker);
 #endif
-    auto workletRuntimeValue = runtime
-        .global()
-        .getProperty(runtime, "ArrayBuffer")
-        .asObject(runtime)
-        .asFunction(runtime)
-        .callAsConstructor(runtime, {static_cast<double>(sizeof(void*))});
-    uintptr_t* workletRuntimeData = reinterpret_cast<uintptr_t*>(
-        workletRuntimeValue.getObject(runtime).getArrayBuffer(runtime).data(runtime));
+    auto workletRuntimeValue = runtime.global()
+                                   .getProperty(runtime, "ArrayBuffer")
+                                   .asObject(runtime)
+                                   .asFunction(runtime)
+                                   .callAsConstructor(runtime, {static_cast<double>(sizeof(void *))});
+    uintptr_t *workletRuntimeData =
+        reinterpret_cast<uintptr_t *>(workletRuntimeValue.getObject(runtime).getArrayBuffer(runtime).data(runtime));
     workletRuntimeData[0] = reinterpret_cast<uintptr_t>(reanimatedModule->runtime.get());
 
-    runtime.global().setProperty(
-        runtime,
-        "_WORKLET_RUNTIME",
-        workletRuntimeValue);
+    runtime.global().setProperty(runtime, "_WORKLET_RUNTIME", workletRuntimeValue);
 
     runtime.global().setProperty(
         runtime,

package/ios/sensor/ReanimatedSensor.m

@@ -7,7 +7,11 @@
 {
   self = [super init];
   _sensorType = sensorType;
-  _interval = interval / 1000; // in seconds
+  if (interval == -1) {
+    _interval = 1.0 / UIScreen.mainScreen.maximumFramesPerSecond;
+  } else {
+    _interval = interval / 1000.0; // in seconds
+  }
   _setter = setter;
   _motionManager = [[CMMotionManager alloc] init];
   return self;
@@ -59,18 +63,21 @@
   }
   [_motionManager setAccelerometerUpdateInterval:_interval];
   [_motionManager startAccelerometerUpdates];
-  [_motionManager
-      startAccelerometerUpdatesToQueue:[NSOperationQueue mainQueue]
-                           withHandler:^(CMAccelerometerData *sensorData, NSError *error) {
-                             double currentTime = [[NSProcessInfo processInfo] systemUptime];
-                             if (currentTime - self->_lastTimestamp < self->_interval) {
-                               return;
-                             }
-                             double data[] = {
-                                 sensorData.acceleration.x, sensorData.acceleration.y, sensorData.acceleration.z};
-                             self->_setter(data);
-                             self->_lastTimestamp = currentTime;
-                           }];
+  [_motionManager startAccelerometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                                       withHandler:^(CMAccelerometerData *sensorData, NSError *error) {
+                                         double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                                         if (currentTime - self->_lastTimestamp < self->_interval) {
+                                           return;
+                                         }
+                                         double G = 9.81;
+                                         // convert G to m/s^2
+                                         double data[] = {
+                                             sensorData.acceleration.x * G,
+                                             sensorData.acceleration.y * G,
+                                             sensorData.acceleration.z * G};
+                                         self->_setter(data);
+                                         self->_lastTimestamp = currentTime;
+                                       }];
 
   return true;
 }
@@ -89,7 +96,10 @@
                             if (currentTime - self->_lastTimestamp < self->_interval) {
                               return;
                             }
-                            double data[] = {sensorData.gravity.x, sensorData.gravity.y, sensorData.gravity.z};
+                            double G = 9.81;
+                            // convert G to m/s^2
+                            double data[] = {
+                                sensorData.gravity.x * G, sensorData.gravity.y * G, sensorData.gravity.z * G};
                             self->_setter(data);
                             self->_lastTimestamp = currentTime;
                           }];
@@ -128,7 +138,7 @@
   [_motionManager setDeviceMotionUpdateInterval:_interval];
 
   [_motionManager setShowsDeviceMovementDisplay:YES];
-  [_motionManager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXTrueNorthZVertical
+  [_motionManager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXArbitraryZVertical
                                                       toQueue:[NSOperationQueue mainQueue]
                                                   withHandler:^(CMDeviceMotion *sensorData, NSError *error) {
                                                     double currentTime = [[NSProcessInfo processInfo] systemUptime];
@@ -143,8 +153,7 @@
                                                         attitude.quaternion.w,
                                                         attitude.yaw,
                                                         attitude.pitch,
-                                                        attitude.roll
-                                                    };
+                                                        attitude.roll};
                                                     self->_setter(data);
                                                     self->_lastTimestamp = currentTime;
                                                   }];

package/lib/index.js

@@ -1,6 +1,14 @@
-// tree-shaken side effects
-import './reanimated2/js-reanimated/global';
+import * as Animated from './Animated';
+import webGlobalIsInitialized from './reanimated2/js-reanimated/global';
+if (!webGlobalIsInitialized) {
+    /*
+      `webGlobalIsInitialized` should always be `true`,
+      but we need to use `webGlobalIsInitialized` somewhere to ensure function execution,
+      in another way, the bundler can remove unused variables.
+    */
+    console.error('[Reanimated] Unable to initialize global objects for web.');
+}
 // @ts-ignore backward compatibility with treeshaking
 export * from './reanimated1';
 export * from './reanimated2';
-export * as default from './Animated';
+export default Animated;

package/lib/index.web.js

@@ -0,0 +1,4 @@
+// tree-shaken side effects
+import './reanimated2/js-reanimated/global';
+export * from './reanimated2';
+export * as default from './Animated'; // If this line fails, you probably forgot some installation steps. Check out the installation guide here: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation/ 1) Make sure reanimated's babel plugin is installed in your babel.config.js (you should have 'react-native-reanimated/plugin' listed there - also see the above link for details) 2) Make sure you reset build cache after updating the config, run: yarn start --reset-cache

package/lib/reanimated2/Colors.js

@@ -9,7 +9,7 @@
 import { Platform } from 'react-native';
 import { makeRemote, makeShareable, isConfigured } from './core';
 // var INTEGER = '[-+]?\\d+';
-const NUMBER = '[-+]?\\d*\\.?\\d+';
+const NUMBER = '[-+]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)';
 const PERCENTAGE = NUMBER + '%';
 function call(...args) {
     'worklet';

package/lib/reanimated2/NativeMethods.js

@@ -22,6 +22,9 @@ export function measure(animatedRef) {
     if (result.x === -1234567) {
         throw new Error(`The view with tag ${viewTag} could not be measured`);
     }
+    if (isNaN(result.x)) {
+        console.warn('Trying to measure a component which gets view-flattened on Android. To disable view-flattening, set `collapsable={false}` on this component.');
+    }
     return result;
 }
 export function scrollTo(animatedRef, x, y, animated) {

package/lib/reanimated2/NativeReanimated/NativeReanimated.js

@@ -47,4 +47,10 @@ export class NativeReanimated {
     configureProps(uiProps, nativeProps) {
         this.InnerNativeModule.configureProps(uiProps, nativeProps);
     }
+    subscribeForKeyboardEvents(keyboardEventData) {
+        return this.InnerNativeModule.subscribeForKeyboardEvents(keyboardEventData);
+    }
+    unsubscribeFromKeyboardEvents(listenerId) {
+        this.InnerNativeModule.unsubscribeFromKeyboardEvents(listenerId);
+    }
 }

package/lib/reanimated2/animation/util.js

@@ -47,7 +47,10 @@ function decorateAnimation(animation) {
         animation.startValue = strippedValue;
         animation.toValue = strippedToValue;
         if (previousAnimation && previousAnimation !== animation) {
-            previousAnimation.current = previousAnimation.strippedCurrent;
+            const { prefix: paPrefix, suffix: paSuffix, strippedValue: paStrippedValue, } = recognizePrefixSuffix(previousAnimation.current);
+            previousAnimation.current = paStrippedValue;
+            previousAnimation.__prefix = paPrefix;
+            previousAnimation.__suffix = paSuffix;
         }
         baseOnStart(animation, strippedValue, timestamp, previousAnimation);
         animation.current =

package/lib/reanimated2/commonTypes.js

@@ -1 +1,8 @@
-export {};
+export var KeyboardState;
+(function (KeyboardState) {
+    KeyboardState[KeyboardState["UNKNOWN"] = 0] = "UNKNOWN";
+    KeyboardState[KeyboardState["OPENING"] = 1] = "OPENING";
+    KeyboardState[KeyboardState["OPEN"] = 2] = "OPEN";
+    KeyboardState[KeyboardState["CLOSING"] = 3] = "CLOSING";
+    KeyboardState[KeyboardState["CLOSED"] = 4] = "CLOSED";
+})(KeyboardState || (KeyboardState = {}));

package/lib/reanimated2/component/FlatList.js

@@ -9,7 +9,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import React from 'react';
+import React, { forwardRef } from 'react';
 import { FlatList } from 'react-native';
 import ReanimatedView from './View';
 import createAnimatedComponent from '../../createAnimatedComponent';
@@ -22,9 +22,9 @@ const createCellRenderer = (itemLayoutAnimation) => {
     };
     return cellRenderer;
 };
-const ReanimatedFlatlist = (_a) => {
-    var { itemLayoutAnimation } = _a, restProps = __rest(_a, ["itemLayoutAnimation"]);
+const ReanimatedFlatlist = forwardRef((props, ref) => {
+    const { itemLayoutAnimation } = props, restProps = __rest(props, ["itemLayoutAnimation"]);
     const cellRenderer = React.useMemo(() => createCellRenderer(itemLayoutAnimation), []);
-    return (<AnimatedFlatList {...restProps} CellRendererComponent={cellRenderer}/>);
-};
+    return (<AnimatedFlatList ref={ref} {...restProps} CellRendererComponent={cellRenderer}/>);
+});
 export default ReanimatedFlatlist;

package/lib/reanimated2/core.js

@@ -11,10 +11,13 @@ if (global._setGlobalConsole === undefined) {
 const testWorklet = () => {
     'worklet';
 };
+const throwUninitializedReanimatedException = () => {
+    throw new Error("Failed to initialize react-native-reanimated library, make sure you followed installation steps here: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation/ \n1) Make sure reanimated's babel plugin is installed in your babel.config.js (you should have 'react-native-reanimated/plugin' listed there - also see the above link for details) \n2) Make sure you reset build cache after updating the config, run: yarn start --reset-cache");
+};
 export const checkPluginState = (throwError = true) => {
     if (!testWorklet.__workletHash && !shouldBeUseWeb()) {
         if (throwError) {
-            throw new Error("Reanimated 2 failed to create a worklet, maybe you forgot to add Reanimated's babel plugin?");
+            throwUninitializedReanimatedException();
         }
         return false;
     }
@@ -24,9 +27,7 @@ export const isConfigured = (throwError = false) => {
     return checkPluginState(throwError);
 };
 export const isConfiguredCheck = () => {
-    if (!isConfigured(true)) {
-        throw new Error('If you want to use Reanimated 2 then go through our installation steps https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation');
-    }
+    checkPluginState(true);
 };
 function pushFrame(frame) {
     NativeReanimatedModule.pushFrame(frame);

package/lib/reanimated2/frameCallback/FrameCallbackRegistryJS.js

@@ -0,0 +1,32 @@
+import { runOnUI } from '../core';
+import { prepareUIRegistry } from './FrameCallbackRegistryUI';
+export default class FrameCallbackRegistryJS {
+    constructor() {
+        this.nextCallbackId = 0;
+        prepareUIRegistry();
+    }
+    registerFrameCallback(callback) {
+        if (!callback) {
+            return -1;
+        }
+        const callbackId = this.nextCallbackId;
+        this.nextCallbackId++;
+        runOnUI(() => {
+            'worklet';
+            global._frameCallbackRegistry.registerFrameCallback(callback, callbackId);
+        })();
+        return callbackId;
+    }
+    unregisterFrameCallback(frameCallbackId) {
+        runOnUI(() => {
+            'worklet';
+            global._frameCallbackRegistry.unregisterFrameCallback(frameCallbackId);
+        })();
+    }
+    manageStateFrameCallback(frameCallbackId, state) {
+        runOnUI(() => {
+            'worklet';
+            global._frameCallbackRegistry.manageStateFrameCallback(frameCallbackId, state);
+        })();
+    }
+}

package/lib/reanimated2/frameCallback/FrameCallbackRegistryUI.js

@@ -0,0 +1,47 @@
+import { runOnUI } from '../core';
+export const prepareUIRegistry = runOnUI(() => {
+    'worklet';
+    const frameCallbackRegistry = {
+        frameCallbackRegistry: new Map(),
+        frameCallbackActive: new Set(),
+        isFrameCallbackRunning: false,
+        runCallbacks() {
+            const loop = () => {
+                this.frameCallbackActive.forEach((key) => {
+                    const callback = this.frameCallbackRegistry.get(key);
+                    callback();
+                });
+                if (this.frameCallbackActive.size > 0) {
+                    requestAnimationFrame(loop);
+                }
+                else {
+                    this.isFrameCallbackRunning = false;
+                }
+            };
+            if (!this.isFrameCallbackRunning) {
+                requestAnimationFrame(loop);
+                this.isFrameCallbackRunning = true;
+            }
+        },
+        registerFrameCallback(callback, callbackId) {
+            this.frameCallbackRegistry.set(callbackId, callback);
+        },
+        unregisterFrameCallback(frameCallbackId) {
+            this.manageStateFrameCallback(frameCallbackId, false);
+            this.frameCallbackRegistry.delete(frameCallbackId);
+        },
+        manageStateFrameCallback(frameCallbackId, state) {
+            if (frameCallbackId === -1) {
+                return;
+            }
+            if (state) {
+                this.frameCallbackActive.add(frameCallbackId);
+                this.runCallbacks();
+            }
+            else {
+                this.frameCallbackActive.delete(frameCallbackId);
+            }
+        },
+    };
+    global._frameCallbackRegistry = frameCallbackRegistry;
+});

package/lib/reanimated2/globals.d.ts

@@ -1,5 +1,6 @@
 import { AnimatedStyle, StyleProps } from './commonTypes';
 import { ReanimatedConsole } from './core';
+import FrameCallbackRegistryUI from './frameCallback/FrameCallbackRegistryUI';
 import { MeasuredDimensions } from './NativeMethods';
 import { NativeReanimated } from './NativeReanimated/NativeReanimated';
 declare global {
@@ -30,6 +31,7 @@ declare global {
   const ReanimatedDataMock: {
     now: () => number;
   };
+  const _frameCallbackRegistry: FrameCallbackRegistryUI;
   namespace NodeJS {
     interface Global {
       _setGlobalConsole: (console?: ReanimatedConsole) => void;
@@ -55,6 +57,7 @@ declare global {
       ReanimatedDataMock: {
         now: () => number;
       };
+      _frameCallbackRegistry: FrameCallbackRegistryUI;
     }
   }
 }

package/lib/reanimated2/hook/index.js

@@ -7,3 +7,5 @@ export { useAnimatedRef } from './useAnimatedRef';
 export { useAnimatedScrollHandler, } from './useAnimatedScrollHandler';
 export { useDerivedValue } from './useDerivedValue';
 export { useAnimatedSensor, SensorType } from './useAnimatedSensor';
+export { useFrameCallback } from './useFrameCallback';
+export { useAnimatedKeyboard } from './useAnimatedKeyboard';

package/lib/reanimated2/hook/useAnimatedKeyboard.js

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from 'react';
+import NativeReanimated from '../NativeReanimated';
+import { makeMutable } from '../core';
+import { KeyboardState } from '../commonTypes';
+export function useAnimatedKeyboard() {
+    const ref = useRef(null);
+    const listenerId = useRef(-1);
+    const isSubscribed = useRef(false);
+    if (ref.current === null) {
+        const keyboardEventData = {
+            state: makeMutable(KeyboardState.UNKNOWN),
+            height: makeMutable(0),
+        };
+        listenerId.current =
+            NativeReanimated.subscribeForKeyboardEvents(keyboardEventData);
+        ref.current = keyboardEventData;
+        isSubscribed.current = true;
+    }
+    useEffect(() => {
+        if (isSubscribed.current === false && ref.current !== null) {
+            // subscribe again after Fast Refresh
+            listenerId.current = NativeReanimated.subscribeForKeyboardEvents(ref.current);
+            isSubscribed.current = true;
+        }
+        return () => {
+            NativeReanimated.unsubscribeFromKeyboardEvents(listenerId.current);
+            isSubscribed.current = false;
+        };
+    }, []);
+    return ref.current;
+}

package/lib/reanimated2/hook/useAnimatedSensor.js

@@ -21,7 +21,7 @@ export function useAnimatedSensor(sensorType, userConfig) {
         },
     });
     if (ref.current.sensor === null) {
-        ref.current.config = Object.assign({ interval: 10 }, userConfig);
+        ref.current.config = Object.assign({ interval: 'auto' }, userConfig);
         let sensorData;
         if (sensorType === SensorType.ROTATION) {
             sensorData = {
@@ -44,8 +44,8 @@ export function useAnimatedSensor(sensorType, userConfig) {
         ref.current.sensor = makeMutable(sensorData);
     }
     useEffect(() => {
-        ref.current.config = Object.assign({ interval: 10 }, userConfig);
-        const id = NativeReanimated.registerSensor(sensorType, ref.current.config.interval, ref.current.sensor);
+        ref.current.config = Object.assign({ interval: 'auto' }, userConfig);
+        const id = NativeReanimated.registerSensor(sensorType, ref.current.config.interval === 'auto' ? -1 : ref.current.config.interval, ref.current.sensor);
         if (id !== -1) {
             // if sensor is available
             ref.current.unregister = () => NativeReanimated.unregisterSensor(id);

package/lib/reanimated2/hook/useFrameCallback.js

@@ -0,0 +1,23 @@
+import { useEffect, useRef } from 'react';
+import FrameCallbackRegistryJS from '../frameCallback/FrameCallbackRegistryJS';
+const frameCallbackRegistry = new FrameCallbackRegistryJS();
+export function useFrameCallback(callback, autostart = true) {
+    const ref = useRef({
+        setActive: (isActive) => {
+            frameCallbackRegistry.manageStateFrameCallback(ref.current.callbackId, isActive);
+            ref.current.isActive = isActive;
+        },
+        isActive: autostart,
+        callbackId: -1,
+    });
+    useEffect(() => {
+        ref.current.callbackId =
+            frameCallbackRegistry.registerFrameCallback(callback);
+        ref.current.setActive(ref.current.isActive);
+        return () => {
+            frameCallbackRegistry.unregisterFrameCallback(ref.current.callbackId);
+            ref.current.callbackId = -1;
+        };
+    }, [callback, autostart]);
+    return ref.current;
+}