react-native-reanimated 3.0.2 → 3.1.0

package/android/src/main/cpp/NativeProxy.h

@@ -166,8 +166,8 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
   jni::global_ref<NativeProxy::javaobject> javaPart_;
   jsi::Runtime *runtime_;
   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
-  std::shared_ptr<NativeReanimatedModule> _nativeReanimatedModule;
-  jni::global_ref<LayoutAnimations::javaobject> layoutAnimations;
+  std::shared_ptr<NativeReanimatedModule> nativeReanimatedModule_;
+  jni::global_ref<LayoutAnimations::javaobject> layoutAnimations_;
   std::shared_ptr<Scheduler> scheduler_;
 #ifdef RCT_NEW_ARCH_ENABLED
   std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
@@ -188,22 +188,25 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
   void installJSIBindings(
       jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread);
 #endif
+  PlatformDepMethodsHolder getPlatformDependentMethods();
+  void setGlobalProperties(
+      jsi::Runtime &jsRuntime,
+      const std::shared_ptr<jsi::Runtime> &reanimatedRuntime);
+  void setupLayoutAnimations();
+
+  double getCurrentTime();
   bool isAnyHandlerWaitingForEvent(std::string);
   void performOperations();
-  void requestRender(std::function<void(double)> onRender);
-  void registerEventHandler(std::function<void(
-                                jni::alias_ref<JString>,
-                                jni::alias_ref<react::WritableMap>)> handler);
+  void requestRender(std::function<void(double)> onRender, jsi::Runtime &rt);
+  void registerEventHandler();
+  void maybeFlushUIUpdatesQueue();
   void setGestureState(int handlerTag, int newState);
   int registerSensor(
       int sensorType,
       int interval,
+      int iosReferenceFrame,
       std::function<void(double[], int)> setter);
   void unregisterSensor(int sensorId);
-  void configureProps(
-      jsi::Runtime &rt,
-      const jsi::Value &uiProps,
-      const jsi::Value &nativeProps);
   int subscribeForKeyboardEvents(
       std::function<void(int, int)> keyboardEventDataUpdater,
       bool isStatusBarTranslucent);
@@ -211,10 +214,49 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
 #ifdef RCT_NEW_ARCH_ENABLED
   // nothing
 #else
-  void updateProps(jsi::Runtime &rt, int viewTag, const jsi::Object &props);
+  jsi::Value
+  obtainProp(jsi::Runtime &rt, const int viewTag, const jsi::String &propName);
+  void configureProps(
+      jsi::Runtime &rt,
+      const jsi::Value &uiProps,
+      const jsi::Value &nativeProps);
+  void updateProps(
+      jsi::Runtime &rt,
+      int viewTag,
+      const jsi::Value &viewName,
+      const jsi::Object &props);
   void scrollTo(int viewTag, double x, double y, bool animated);
   std::vector<std::pair<std::string, double>> measure(int viewTag);
 #endif
+  void handleEvent(
+      jni::alias_ref<JString> eventKey,
+      jni::alias_ref<react::WritableMap> event);
+
+  void progressLayoutAnimation(
+      int tag,
+      const jsi::Object &newProps,
+      bool isSharedTransition);
+
+  /***
+   * Wraps a method of `NativeProxy` in a function object capturing `this`
+   * @tparam TReturn return type of passed method
+   * @tparam TParams paramater types of passed method
+   * @param methodPtr pointer to method to be wrapped
+   * @return a function object with the same signature as the method, calling
+   * that method on `this`
+   */
+  template <class TReturn, class... TParams>
+  std::function<TReturn(TParams...)> bindThis(
+      TReturn (NativeProxy::*methodPtr)(TParams...)) {
+    return [this, methodPtr](TParams &&...args) {
+      return (this->*methodPtr)(std::forward<TParams>(args)...);
+    };
+  }
+
+  template <class Signature>
+  JMethod<Signature> getJniMethod(std::string const &methodName) {
+    return javaPart_->getClass()->getMethod<Signature>(methodName.c_str());
+  }
 
   explicit NativeProxy(
       jni::alias_ref<NativeProxy::jhybridobject> jThis,

package/android/src/main/java/com/swmansion/reanimated/NativeMethodsHelper.java

@@ -39,11 +39,9 @@ public class NativeMethodsHelper {
   public static void scrollTo(View view, double argX, double argY, boolean animated) {
     int x = Math.round(PixelUtil.toPixelFromDIP(argX));
     int y = Math.round(PixelUtil.toPixelFromDIP(argY));
-    boolean horizontal = false;
+    boolean isHorizontal = view instanceof ReactHorizontalScrollView;
 
-    if (view instanceof ReactHorizontalScrollView) {
-      horizontal = true;
-    } else {
+    if (!isHorizontal) {
       if (view instanceof ReactSwipeRefreshLayout) {
         view = findScrollView((ReactSwipeRefreshLayout) view);
       }
@@ -56,17 +54,14 @@ public class NativeMethodsHelper {
     }
 
     if (animated) {
-      if (horizontal) {
-        ((ReactHorizontalScrollView) view).smoothScrollTo((int) x, (int) y);
+      final View finalView = view;
+      if (isHorizontal) {
+        view.post(() -> ((ReactHorizontalScrollView) finalView).smoothScrollTo(x, y));
       } else {
-        ((ReactScrollView) view).smoothScrollTo((int) x, (int) y);
+        view.post(() -> ((ReactScrollView) finalView).smoothScrollTo(x, y));
       }
     } else {
-      if (horizontal) {
-        ((ReactHorizontalScrollView) view).scrollTo((int) x, (int) y);
-      } else {
-        ((ReactScrollView) view).scrollTo((int) x, (int) y);
-      }
+      view.scrollTo(x, y);
     }
   }
 

package/android/src/main/java/com/swmansion/reanimated/NodesManager.java

@@ -36,6 +36,7 @@ import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import javax.annotation.Nullable;
 
@@ -163,6 +164,10 @@ public class NodesManager implements EventDispatcherListener {
     }
   }
 
+  public boolean isAnimationRunning() {
+    return mCallbackPosted.get();
+  }
+
   public void onHostResume() {
     if (mCallbackPosted.getAndSet(false)) {
       startUpdatingOnAnimationFrame();
@@ -183,7 +188,7 @@ public class NodesManager implements EventDispatcherListener {
     }
   }
 
-  private void performOperations() {
+  public void performOperations() {
     if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
       mNativeProxy.performOperations();
     } else if (!mOperationsInBatch.isEmpty()) {
@@ -218,13 +223,11 @@ public class NodesManager implements EventDispatcherListener {
             }
           });
       if (trySynchronously) {
-        while (true) {
-          try {
-            semaphore.acquire();
-            break;
-          } catch (InterruptedException e) {
-            // noop
-          }
+        try {
+          semaphore.tryAcquire(16, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+          // if the thread is interruped we just continue and let the layout update happen
+          // asynchronously
         }
       }
     }

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/NativeProxyCommon.java

@@ -88,39 +88,39 @@ public abstract class NativeProxyCommon {
   }
 
   @DoNotStrip
-  private void requestRender(AnimationFrameCallback callback) {
+  public void requestRender(AnimationFrameCallback callback) {
     mNodesManager.postOnAnimation(callback);
   }
 
   @DoNotStrip
-  private void updateProps(int viewTag, Map<String, Object> props) {
+  public void updateProps(int viewTag, Map<String, Object> props) {
     mNodesManager.updateProps(viewTag, props);
   }
 
   @DoNotStrip
-  private void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+  public void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
     mNodesManager.synchronouslyUpdateUIProps(viewTag, uiProps);
   }
 
   @DoNotStrip
-  private String obtainProp(int viewTag, String propName) {
+  public String obtainProp(int viewTag, String propName) {
     return mNodesManager.obtainProp(viewTag, propName);
   }
 
   @DoNotStrip
-  private void scrollTo(int viewTag, double x, double y, boolean animated) {
+  public void scrollTo(int viewTag, double x, double y, boolean animated) {
     mNodesManager.scrollTo(viewTag, x, y, animated);
   }
 
   @DoNotStrip
-  private void setGestureState(int handlerTag, int newState) {
+  public void setGestureState(int handlerTag, int newState) {
     if (gestureHandlerStateManager != null) {
       gestureHandlerStateManager.setGestureHandlerState(handlerTag, newState);
     }
   }
 
   @DoNotStrip
-  private long getCurrentTime() {
+  public long getCurrentTime() {
     if (slowAnimationsEnabled) {
       final long ANIMATIONS_DRAG_FACTOR = 10;
       return this.firstUptime
@@ -131,12 +131,12 @@ public abstract class NativeProxyCommon {
   }
 
   @DoNotStrip
-  private float[] measure(int viewTag) {
+  public float[] measure(int viewTag) {
     return mNodesManager.measure(viewTag);
   }
 
   @DoNotStrip
-  private void configureProps(ReadableNativeArray uiProps, ReadableNativeArray nativeProps) {
+  public void configureProps(ReadableNativeArray uiProps, ReadableNativeArray nativeProps) {
     Set<String> uiPropsSet = convertProps(uiProps);
     Set<String> nativePropsSet = convertProps(nativeProps);
     mNodesManager.configureProps(uiPropsSet, nativePropsSet);
@@ -152,31 +152,31 @@ public abstract class NativeProxyCommon {
   }
 
   @DoNotStrip
-  private void registerEventHandler(EventHandler handler) {
+  public void registerEventHandler(EventHandler handler) {
     handler.mCustomEventNamesResolver = mNodesManager.getEventNameResolver();
     mNodesManager.registerEventHandler(handler);
   }
 
   @DoNotStrip
-  private int registerSensor(int sensorType, int interval, SensorSetter setter) {
+  public int registerSensor(int sensorType, int interval, SensorSetter setter) {
     return reanimatedSensorContainer.registerSensor(
         ReanimatedSensorType.getInstanceById(sensorType), interval, setter);
   }
 
   @DoNotStrip
-  private void unregisterSensor(int sensorId) {
+  public void unregisterSensor(int sensorId) {
     reanimatedSensorContainer.unregisterSensor(sensorId);
   }
 
   @DoNotStrip
-  private int subscribeForKeyboardEvents(
+  public int subscribeForKeyboardEvents(
       KeyboardEventDataUpdater keyboardEventDataUpdater, boolean isStatusBarTranslucent) {
     return reanimatedKeyboardEventListener.subscribeForKeyboardEvents(
         keyboardEventDataUpdater, isStatusBarTranslucent);
   }
 
   @DoNotStrip
-  private void unsubscribeFromKeyboardEvents(int listenerId) {
+  public void unsubscribeFromKeyboardEvents(int listenerId) {
     reanimatedKeyboardEventListener.unsubscribeFromKeyboardEvents(listenerId);
   }
 
@@ -203,4 +203,11 @@ public abstract class NativeProxyCommon {
 
     animationsManager.setNativeMethods(NativeProxy.createNativeMethodsHolder(layoutAnimations));
   }
+
+  @DoNotStrip
+  void maybeFlushUIUpdatesQueue() {
+    if (!mNodesManager.isAnimationRunning()) {
+      mNodesManager.performOperations();
+    }
+  }
 }

package/android/src/paper/java/com/swmansion/reanimated/NativeProxy.java

@@ -2,14 +2,11 @@ package com.swmansion.reanimated;
 
 import static com.swmansion.reanimated.Utils.simplifyStringNumbersList;
 
-import android.util.Log;
-
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
-import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
 import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
 import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
 import com.swmansion.reanimated.nativeProxy.NativeProxyCommon;

package/ios/Fabric/REAInitializerRCTFabricSurface.mm

@@ -66,6 +66,7 @@
 {
   // This method should never be called.
   react_native_assert(false);
+  return nullptr;
 }
 
 @end

package/ios/REANodesManager.h

@@ -55,5 +55,6 @@ typedef void (^REAPerformOperations)();
                        trySynchronously:(BOOL)trySync;
 - (NSString *)obtainProp:(nonnull NSNumber *)viewTag propName:(nonnull NSString *)propName;
 #endif
+- (void)maybeFlushUIUpdatesQueue;
 
 @end

package/ios/REANodesManager.mm

@@ -96,6 +96,8 @@ using namespace facebook::react;
   BOOL _tryRunBatchUpdatesSynchronously;
   REAEventHandler _eventHandler;
   volatile void (^_mounting)(void);
+  NSObject *_syncLayoutUpdatesWaitLock;
+  volatile BOOL _syncLayoutUpdatesWaitTimedOut;
   NSMutableDictionary<NSNumber *, ComponentUpdate *> *_componentUpdateBuffer;
   NSMutableDictionary<NSNumber *, UIView *> *_viewRegistry;
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -123,6 +125,7 @@ using namespace facebook::react;
     _operationsInBatch = [NSMutableDictionary new];
     _componentUpdateBuffer = [NSMutableDictionary new];
     _viewRegistry = [_uiManager valueForKey:@"_viewRegistry"];
+    _syncLayoutUpdatesWaitLock = [NSObject new];
   }
 
   _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(onAnimationFrame:)];
@@ -241,8 +244,14 @@ using namespace facebook::react;
 - (BOOL)uiManager:(RCTUIManager *)manager performMountingWithBlock:(RCTUIManagerMountingBlock)block
 {
   RCTAssert(_mounting == nil, @"Mouting block is expected to not be set");
-  _mounting = block;
-  return YES;
+  @synchronized(_syncLayoutUpdatesWaitLock) {
+    if (_syncLayoutUpdatesWaitTimedOut) {
+      return NO;
+    } else {
+      _mounting = block;
+      return YES;
+    }
+  }
 }
 
 - (void)performOperations
@@ -260,6 +269,7 @@ using namespace facebook::react;
 
     __weak __typeof__(self) weakSelf = self;
     dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    _syncLayoutUpdatesWaitTimedOut = NO;
     RCTExecuteOnUIManagerQueue(^{
       __typeof__(self) strongSelf = weakSelf;
       if (strongSelf == nil) {
@@ -276,7 +286,7 @@ using namespace facebook::react;
       }
 
       if (canUpdateSynchronously) {
-        [strongSelf.uiManager runSyncUIUpdatesWithObserver:self];
+        [strongSelf.uiManager runSyncUIUpdatesWithObserver:strongSelf];
         dispatch_semaphore_signal(semaphore);
       }
       // In case canUpdateSynchronously=true we still have to send uiManagerWillPerformMounting event
@@ -284,7 +294,16 @@ using namespace facebook::react;
       [strongSelf.uiManager setNeedsLayout];
     });
     if (trySynchronously) {
-      dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+      // The 16ms timeout here aims to match the frame duration. It may make sense to read that parameter
+      // from CADisplayLink but it is easier to hardcode it for the time being.
+      // The reason why we use frame duration here is that if takes longer than one frame to complete layout tasks
+      // there is no point of synchronizing layout with the UI interaction as we get that one frame delay anyways.
+      long result = dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 16 * NSEC_PER_MSEC));
+      if (result != 0) {
+        @synchronized(_syncLayoutUpdatesWaitLock) {
+          _syncLayoutUpdatesWaitTimedOut = YES;
+        }
+      }
     }
 
     if (_mounting) {
@@ -494,4 +513,11 @@ using namespace facebook::react;
 
 #endif // RCT_NEW_ARCH_ENABLED
 
+- (void)maybeFlushUIUpdatesQueue
+{
+  if ([_displayLink isPaused]) {
+    [self performOperations];
+  }
+}
+
 @end

package/ios/keyboardObserver/REAKeyboardEventObserver.m

@@ -12,13 +12,11 @@ typedef NS_ENUM(NSUInteger, KeyboardState) {
 };
 
 @implementation REAKeyboardEventObserver {
+  UIView *_measuringView;
   NSNumber *_nextListenerId;
   NSMutableDictionary *_listeners;
-  CADisplayLink *displayLink;
-  int _windowsCount;
-  UIView *_keyboardView;
+  CADisplayLink *_displayLink;
   KeyboardState _state;
-  bool _shouldInvalidateDisplayLink;
 }
 
 - (instancetype)init
@@ -27,52 +25,16 @@ typedef NS_ENUM(NSUInteger, KeyboardState) {
   _listeners = [[NSMutableDictionary alloc] init];
   _nextListenerId = @0;
   _state = UNKNOWN;
-  _shouldInvalidateDisplayLink = false;
 
   NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
 
   [notificationCenter addObserver:self
-                         selector:@selector(clearListeners)
+                         selector:@selector(cleanupListeners)
                              name:RCTBridgeDidInvalidateModulesNotification
                            object:nil];
   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
 {
@@ -86,72 +48,61 @@ typedef NS_ENUM(NSUInteger, KeyboardState) {
 }
 #else
 
-- (void)runAnimation
+- (void)runUpdater
 {
-  if (!displayLink) {
-    displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(updateKeyboardFrame)];
-    [displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+  if (!_displayLink) {
+    _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(updateKeyboardFrame)];
+    _displayLink.preferredFramesPerSecond = 120; // will fallback to 60 fps for devices without Pro Motion display
+    [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
   }
-}
-
-- (void)stopAnimation
-{
+  _displayLink.paused = NO;
   [self updateKeyboardFrame];
-  // there might be a case that keyboard will change height in the next frame
-  // (for example changing keyboard language so that suggestions appear)
-  // so we invalidate display link after we handle that in the next frame
-  _shouldInvalidateDisplayLink = true;
 }
 
 - (void)updateKeyboardFrame
 {
-  UIView *keyboardView = [self getKeyboardView];
-  if (keyboardView == nil) {
-    return;
+  BOOL isAnimatingKeyboardChange = _measuringView.layer.presentationLayer.animationKeys.count != 0;
+  CGRect measuringFrame =
+      isAnimatingKeyboardChange ? _measuringView.layer.presentationLayer.frame : _measuringView.frame;
+  CGFloat keyboardHeight = measuringFrame.size.height;
+
+  if (!isAnimatingKeyboardChange) {
+    // measuring view is no longer running an animation, we should settle in OPEN/CLOSE state
+    if (_state == OPENING || _state == CLOSING) {
+      _state = _state == OPENING ? OPEN : CLOSED;
+    }
+    // stop display link updates if no animation is running
+    _displayLink.paused = YES;
   }
 
-  CGFloat keyboardHeight = [self computeKeyboardHeight:keyboardView];
   for (NSString *key in _listeners.allKeys) {
     ((KeyboardEventListenerBlock)_listeners[key])(_state, keyboardHeight);
   }
-
-  if (_shouldInvalidateDisplayLink) {
-    _shouldInvalidateDisplayLink = false;
-    [displayLink invalidate];
-    displayLink = nil;
-  }
 }
 
-- (CGFloat)computeKeyboardHeight:(UIView *)keyboardView
+- (void)keyboardWillChangeFrame:(NSNotification *)notification
 {
-  CGFloat keyboardFrameY = [keyboardView.layer presentationLayer].frame.origin.y;
-  CGFloat keyboardWindowH = keyboardView.window.bounds.size.height;
-  CGFloat keyboardHeight = keyboardWindowH - keyboardFrameY;
-  return keyboardHeight;
-}
+  NSDictionary *userInfo = [notification userInfo];
+  CGRect beginFrame = [[userInfo objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue];
+  CGRect endFrame = [[userInfo objectForKey:UIKeyboardFrameEndUserInfoKey] CGRectValue];
+  NSTimeInterval animationDuration = [[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+  CGSize windowSize = [[[UIApplication sharedApplication] delegate] window].frame.size;
 
-- (void)keyboardWillShow:(NSNotification *)notification
-{
-  _state = OPENING;
-  [self runAnimation];
-}
-
-- (void)keyboardDidShow:(NSNotification *)notification
-{
-  _state = OPEN;
-  [self stopAnimation];
-}
+  CGFloat beginHeight = windowSize.height - beginFrame.origin.y;
+  CGFloat endHeight = windowSize.height - endFrame.origin.y;
 
-- (void)keyboardWillHide:(NSNotification *)notification
-{
-  _state = CLOSING;
-  [self runAnimation];
-}
+  if (endHeight > 0 && _state != OPEN) {
+    _state = OPENING;
+  } else if (endHeight == 0 && _state != CLOSED) {
+    _state = CLOSING;
+  }
 
-- (void)keyboardDidHide:(NSNotification *)notification
-{
-  _state = CLOSED;
-  [self stopAnimation];
+  _measuringView.frame = CGRectMake(0, -1, 0, beginHeight);
+  [UIView animateWithDuration:animationDuration
+                   animations:^{
+                     self->_measuringView.frame = CGRectMake(0, -1, 0, endHeight);
+                   }];
+  [self runUpdater];
 }
 
 - (int)subscribeForKeyboardEvents:(KeyboardEventListenerBlock)listener
@@ -159,34 +110,21 @@ typedef NS_ENUM(NSUInteger, KeyboardState) {
   NSNumber *listenerId = [_nextListenerId copy];
   _nextListenerId = [NSNumber numberWithInt:[_nextListenerId intValue] + 1];
   RCTExecuteOnMainQueue(^() {
+    if (!self->_measuringView) {
+      self->_measuringView = [[UIView alloc] initWithFrame:CGRectMake(0, -1, 0, 0)];
+      UIWindow *keyWindow = [[[UIApplication sharedApplication] delegate] window];
+      [keyWindow addSubview:self->_measuringView];
+    }
     if ([self->_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
+                             selector:@selector(keyboardWillChangeFrame:)
+                                 name:UIKeyboardWillChangeFrameNotification
                                object:nil];
     }
 
     [self->_listeners setObject:listener forKey:listenerId];
-    if (self->_state == UNKNOWN) {
-      [self recognizeInitialKeyboardState];
-    }
   });
   return [listenerId intValue];
 }
@@ -197,34 +135,17 @@ typedef NS_ENUM(NSUInteger, KeyboardState) {
     NSNumber *_listenerId = [NSNumber numberWithInt:listenerId];
     [self->_listeners removeObjectForKey:_listenerId];
     if ([self->_listeners count] == 0) {
-      [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillHideNotification object:nil];
-      [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillShowNotification object:nil];
-      [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardDidHideNotification object:nil];
-      [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardDidShowNotification object:nil];
-    }
-  });
-}
-
-- (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;
+      [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillChangeFrameNotification object:nil];
     }
-    [self updateKeyboardFrame];
   });
 }
 
-- (void)clearListeners
+- (void)cleanupListeners
 {
   RCTUnsafeExecuteOnMainQueueSync(^() {
     [self->_listeners removeAllObjects];
-    [self->displayLink invalidate];
-    self->displayLink = nil;
+    [self->_displayLink invalidate];
+    self->_displayLink = nil;
     [[NSNotificationCenter defaultCenter] removeObserver:self];
   });
 }

package/ios/native/NativeMethods.mm

@@ -51,4 +51,4 @@ void setGestureState(id<RNGestureHandlerStateManager> gestureHandlerStateManager
   }
 }
 
-}
+} // namespace reanimated