react-native-reanimated 2.8.0 → 2.10.0

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

@@ -7,8 +7,10 @@
 #include <memory>
 #include <string>
 
-#if FOR_HERMES
+#if JS_RUNTIME_HERMES
 #include <hermes/hermes.h>
+#elif JS_RUNTIME_V8
+#include <v8runtime/V8RuntimeFactory.h>
 #else
 #include <jsi/JSCRuntime.h>
 #endif
@@ -38,10 +40,8 @@ NativeProxy::NativeProxy(
       layoutAnimations(std::move(_layoutAnimations)) {}
 
 NativeProxy::~NativeProxy() {
-  runtime_->global().setProperty(
-      *runtime_,
-      jsi::PropNameID::forAscii(*runtime_, "__reanimatedModuleProxy"),
-      jsi::Value::undefined());
+  // removed temporary, new event listener mechanism need fix on the RN side
+  // reactScheduler_->removeEventListener(eventListener_);
 }
 
 jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
@@ -136,20 +136,44 @@ void NativeProxy::installJSIBindings() {
   auto setGestureStateFunction = [this](int handlerTag, int newState) -> void {
     setGestureState(handlerTag, newState);
   };
-#if FOR_HERMES
+
+  auto subscribeForKeyboardEventsFunction =
+      [this](std::function<void(int, int)> keyboardEventDataUpdater) -> int {
+    return subscribeForKeyboardEvents(std::move(keyboardEventDataUpdater));
+  };
+
+  auto unsubscribeFromKeyboardEventsFunction = [this](int listenerId) -> void {
+    unsubscribeFromKeyboardEvents(listenerId);
+  };
+
+#if JS_RUNTIME_HERMES
   auto config =
       ::hermes::vm::RuntimeConfig::Builder().withEnableSampleProfiling(false);
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::hermes::makeHermesRuntime(config.build());
+#elif JS_RUNTIME_V8
+  auto config = std::make_unique<rnv8::V8RuntimeConfig>();
+  config->enableInspector = false;
+  config->appName = "reanimated";
+  std::shared_ptr<jsi::Runtime> animatedRuntime =
+      rnv8::createSharedV8Runtime(runtime_, std::move(config));
 #else
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::jsc::makeJSCRuntime();
 #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_));
+  workletRuntimeData[0] = reinterpret_cast<uintptr_t>(animatedRuntime.get());
+
   runtime_->global().setProperty(
-      *runtime_,
-      "_WORKLET_RUNTIME",
-      static_cast<double>(
-          reinterpret_cast<std::uintptr_t>(animatedRuntime.get())));
+      *runtime_, "_WORKLET_RUNTIME", workletRuntimeValue);
 
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
@@ -187,7 +211,10 @@ void NativeProxy::installJSIBindings() {
       registerSensorFunction,
       unregisterSensorFunction,
       setGestureStateFunction,
-      configurePropsFunction};
+      configurePropsFunction,
+      subscribeForKeyboardEventsFunction,
+      unsubscribeFromKeyboardEventsFunction,
+  };
 
   auto module = std::make_shared<NativeReanimatedModule>(
       jsCallInvoker_,
@@ -334,4 +361,22 @@ void NativeProxy::configureProps(
           .get());
 }
 
+int NativeProxy::subscribeForKeyboardEvents(
+    std::function<void(int, int)> keyboardEventDataUpdater) {
+  auto method = javaPart_->getClass()
+                    ->getMethod<int(KeyboardEventDataUpdater::javaobject)>(
+                        "subscribeForKeyboardEvents");
+  return method(
+      javaPart_.get(),
+      KeyboardEventDataUpdater::newObjectCxxArgs(
+          std::move(keyboardEventDataUpdater))
+          .get());
+}
+
+void NativeProxy::unsubscribeFromKeyboardEvents(int listenerId) {
+  auto method = javaPart_->getClass()->getMethod<void(int)>(
+      "unsubscribeFromKeyboardEvents");
+  method(javaPart_.get(), listenerId);
+}
+
 } // namespace reanimated

package/android/src/main/cpp/OnLoad.cpp

@@ -13,5 +13,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
     reanimated::AndroidScheduler::registerNatives();
     reanimated::LayoutAnimations::registerNatives();
     reanimated::SensorSetter::registerNatives();
+    reanimated::KeyboardEventDataUpdater::registerNatives();
   });
 }

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

@@ -118,6 +118,32 @@ class SensorSetter : public HybridClass<SensorSetter> {
   std::function<void(double[])> callback_;
 };
 
+class KeyboardEventDataUpdater : public HybridClass<KeyboardEventDataUpdater> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy$KeyboardEventDataUpdater;";
+
+  void keyboardEventDataUpdater(int keyboardState, int height) {
+    callback_(keyboardState, height);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod(
+            "keyboardEventDataUpdater",
+            KeyboardEventDataUpdater::keyboardEventDataUpdater),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit KeyboardEventDataUpdater(std::function<void(int, int)> callback)
+      : callback_(std::move(callback)) {}
+
+  std::function<void(int, int)> callback_;
+};
+
 class NativeProxy : public jni::HybridClass<NativeProxy> {
  public:
   static auto constexpr kJavaDescriptor =
@@ -160,6 +186,9 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps);
+  int subscribeForKeyboardEvents(
+      std::function<void(int, int)> keyboardEventDataUpdater);
+  void unsubscribeFromKeyboardEvents(int listenerId);
 
   explicit NativeProxy(
       jni::alias_ref<NativeProxy::jhybridobject> jThis,

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

@@ -16,6 +16,7 @@ import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.swmansion.common.GestureHandlerStateManager;
+import com.swmansion.reanimated.keyboardObserver.ReanimatedKeyboardEventListener;
 import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
 import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
 import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
@@ -87,6 +88,18 @@ public class NativeProxy {
     public native void sensorSetter(float[] value);
   }
 
+  @DoNotStrip
+  public static class KeyboardEventDataUpdater {
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private KeyboardEventDataUpdater(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    public native void keyboardEventDataUpdater(int keyboardState, int height);
+  }
+
   @DoNotStrip
   @SuppressWarnings("unused")
   private final HybridData mHybridData;
@@ -96,6 +109,7 @@ public class NativeProxy {
   private Scheduler mScheduler = null;
   private ReanimatedSensorContainer reanimatedSensorContainer;
   private final GestureHandlerStateManager gestureHandlerStateManager;
+  private ReanimatedKeyboardEventListener reanimatedKeyboardEventListener;
   private Long firstUptime = SystemClock.uptimeMillis();
   private boolean slowAnimationsEnabled = false;
 
@@ -110,6 +124,7 @@ public class NativeProxy {
     mContext = new WeakReference<>(context);
     prepare(LayoutAnimations);
     reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
+    reanimatedKeyboardEventListener = new ReanimatedKeyboardEventListener(mContext);
     addDevMenuOption();
 
     GestureHandlerStateManager tempHandlerStateManager;
@@ -237,6 +252,16 @@ public class NativeProxy {
     reanimatedSensorContainer.unregisterSensor(sensorId);
   }
 
+  @DoNotStrip
+  private int subscribeForKeyboardEvents(KeyboardEventDataUpdater keyboardEventDataUpdater) {
+    return reanimatedKeyboardEventListener.subscribeForKeyboardEvents(keyboardEventDataUpdater);
+  }
+
+  @DoNotStrip
+  private void unsubscribeFromKeyboardEvents(int listenerId) {
+    reanimatedKeyboardEventListener.unsubscribeFromKeyboardEvents(listenerId);
+  }
+
   public void onCatalystInstanceDestroy() {
     mScheduler.deactivate();
     mHybridData.resetNative();

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

@@ -1,5 +1,7 @@
 package com.swmansion.reanimated;
 
+import static java.lang.Float.NaN;
+
 import android.util.SparseArray;
 import android.view.View;
 import com.facebook.react.bridge.Arguments;
@@ -83,7 +85,7 @@ public class NodesManager implements EventDispatcherListener {
       view = mUIManager.resolveView(viewTag);
     } catch (IllegalViewOperationException e) {
       e.printStackTrace();
-      return (new float[] {});
+      return (new float[] {NaN, NaN, NaN, NaN, NaN, NaN});
     }
     return NativeMethodsHelper.measure(view);
   }

package/android/src/main/java/com/swmansion/reanimated/keyboardObserver/ReanimatedKeyboardEventListener.java

@@ -0,0 +1,165 @@
+package com.swmansion.reanimated.keyboardObserver;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.widget.FrameLayout;
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.PixelUtil;
+import com.swmansion.reanimated.BuildConfig;
+import com.swmansion.reanimated.NativeProxy.KeyboardEventDataUpdater;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.List;
+
+public class ReanimatedKeyboardEventListener {
+  enum KeyboardState {
+    UNKNOWN(0),
+    OPENING(1),
+    OPEN(2),
+    CLOSING(3),
+    CLOSED(4);
+
+    private final int value;
+
+    KeyboardState(int value) {
+      this.value = value;
+    }
+
+    public int asInt() {
+      return value;
+    }
+  }
+
+  private final WeakReference<ReactApplicationContext> reactContext;
+  private int nextListenerId = 0;
+  private KeyboardState state;
+  private final HashMap<Integer, KeyboardEventDataUpdater> listeners = new HashMap<>();
+
+  public ReanimatedKeyboardEventListener(WeakReference<ReactApplicationContext> reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  private View getRootView() {
+    return reactContext.get().getCurrentActivity().getWindow().getDecorView();
+  }
+
+  private void setupWindowInsets() {
+    View rootView = getRootView();
+    WindowCompat.setDecorFitsSystemWindows(
+        reactContext.get().getCurrentActivity().getWindow(), false);
+    ViewCompat.setOnApplyWindowInsetsListener(
+        rootView,
+        (v, insets) -> {
+          int paddingBottom = 0;
+          if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED && BuildConfig.REACT_NATIVE_VERSION < 70) {
+            paddingBottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom;
+          }
+          int paddingTop = insets.getInsets(WindowInsetsCompat.Type.systemBars()).top;
+          View content =
+              rootView.getRootView().findViewById(com.swmansion.reanimated.R.id.action_bar_root);
+
+          FrameLayout.LayoutParams params =
+              new FrameLayout.LayoutParams(
+                  FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
+          params.setMargins(0, paddingTop, 0, paddingBottom);
+          content.setLayoutParams(params);
+          return insets;
+        });
+  }
+
+  private void updateKeyboard(int keyboardHeight) {
+    for (KeyboardEventDataUpdater listener : listeners.values()) {
+      listener.keyboardEventDataUpdater(state.asInt(), keyboardHeight);
+    }
+  }
+
+  private class WindowInsetsCallback extends WindowInsetsAnimationCompat.Callback {
+    private int keyboardHeight = 0;
+
+    public WindowInsetsCallback() {
+      super(WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE);
+    }
+
+    @NonNull
+    @Override
+    public WindowInsetsAnimationCompat.BoundsCompat onStart(
+        @NonNull WindowInsetsAnimationCompat animation,
+        @NonNull WindowInsetsAnimationCompat.BoundsCompat bounds) {
+      state = keyboardHeight == 0 ? KeyboardState.OPENING : KeyboardState.CLOSING;
+      updateKeyboard(keyboardHeight);
+      return super.onStart(animation, bounds);
+    }
+
+    @NonNull
+    @Override
+    public WindowInsetsCompat onProgress(
+        @NonNull WindowInsetsCompat insets,
+        @NonNull List<WindowInsetsAnimationCompat> runningAnimations) {
+
+      keyboardHeight =
+          (int)
+              PixelUtil.toDIPFromPixel(
+                  Math.max(
+                      0,
+                      insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+                          - insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom));
+      updateKeyboard(keyboardHeight);
+      return insets;
+    }
+
+    @Override
+    public void onEnd(@NonNull WindowInsetsAnimationCompat animation) {
+      state = keyboardHeight == 0 ? KeyboardState.CLOSED : KeyboardState.OPEN;
+      updateKeyboard(keyboardHeight);
+    }
+  }
+
+  private void setUpCallbacks() {
+    View rootView = getRootView();
+    new Handler(Looper.getMainLooper()).post(this::setupWindowInsets);
+    ViewCompat.setWindowInsetsAnimationCallback(rootView, new WindowInsetsCallback());
+  }
+
+  public int subscribeForKeyboardEvents(KeyboardEventDataUpdater updater) {
+    int listenerId = nextListenerId++;
+    if (listeners.isEmpty()) {
+      setUpCallbacks();
+    }
+    listeners.put(listenerId, updater);
+    return listenerId;
+  }
+
+  private void bringBackWindowInsets() {
+    WindowCompat.setDecorFitsSystemWindows(
+        reactContext.get().getCurrentActivity().getWindow(), true);
+    ViewCompat.setOnApplyWindowInsetsListener(getRootView(), null);
+    ViewCompat.setWindowInsetsAnimationCallback(getRootView(), null);
+    View content =
+        getRootView().getRootView().findViewById(com.swmansion.reanimated.R.id.action_bar_root);
+
+    FrameLayout.LayoutParams params =
+        new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
+    params.setMargins(0, 0, 0, 0);
+    content.setLayoutParams(params);
+  }
+
+  private void removeCallbacks() {
+    View rootView = getRootView();
+    new Handler(Looper.getMainLooper()).post(this::bringBackWindowInsets);
+    ViewCompat.setWindowInsetsAnimationCallback(rootView, null);
+  }
+
+  public void unsubscribeFromKeyboardEvents(int listenerId) {
+    listeners.remove(listenerId);
+    if (listeners.isEmpty()) {
+      removeCallbacks();
+    }
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/AnimationsManager.java

@@ -229,24 +229,27 @@ public class AnimationsManager implements ViewHierarchyObserver {
   }
 
   private void removeLeftovers() {
-    HashSet<Integer> roots = new HashSet<>();
-    // go through ready to remove from bottom to top
-    for (int tag : mToRemove) {
-      View view = mViewForTag.get(tag);
-      if (view == null) {
-        try {
-          view = mUIManager.resolveView(tag);
-          mViewForTag.put(tag, view);
-        } catch (IllegalViewOperationException ignored) {
-          continue;
+    //mToRemove may be null if onCatalystInstanceDestroy was called first
+    if(mToRemove != null){
+      HashSet<Integer> roots = new HashSet<>();
+      // go through ready to remove from bottom to top
+      for (int tag : mToRemove) {
+        View view = mViewForTag.get(tag);
+        if (view == null) {
+          try {
+            view = mUIManager.resolveView(tag);
+            mViewForTag.put(tag, view);
+          } catch (IllegalViewOperationException ignored) {
+            continue;
+          }
         }
+        findRoot(view, roots);
       }
-      findRoot(view, roots);
-    }
-    for (int tag : roots) {
-      View view = mViewForTag.get(tag);
-      if (view != null) {
-        dfs(view, view, mToRemove);
+      for (int tag : roots) {
+        View view = mViewForTag.get(tag);
+        if (view != null) {
+          dfs(view, view, mToRemove);
+        }
       }
     }
   }

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.java

@@ -23,7 +23,11 @@ public class ReanimatedSensor {
     sensorManager =
         (SensorManager) reactContext.get().getSystemService(reactContext.get().SENSOR_SERVICE);
     this.sensorType = sensorType;
-    this.interval = interval;
+    if (interval == -1) {
+      this.interval = SensorManager.SENSOR_DELAY_UI;
+    } else {
+      this.interval = interval;
+    }
   }
 
   boolean initialize() {

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorListener.java

@@ -3,6 +3,7 @@ package com.swmansion.reanimated.sensor;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
 import com.swmansion.reanimated.NativeProxy;
 
 public class ReanimatedSensorListener implements SensorEventListener {
@@ -11,6 +12,10 @@ public class ReanimatedSensorListener implements SensorEventListener {
   private double lastRead = (double) System.currentTimeMillis();
   private final double interval;
 
+  private float[] rotation = new float[9];
+  private float[] orientation = new float[3];
+  private float[] quaternion = new float[4];
+
   ReanimatedSensorListener(NativeProxy.SensorSetter setter, double interval) {
     this.setter = setter;
     this.interval = interval;
@@ -22,8 +27,26 @@ public class ReanimatedSensorListener implements SensorEventListener {
     if (current - lastRead < interval) {
       return;
     }
+    int sensorType = event.sensor.getType();
     lastRead = current;
-    setter.sensorSetter(event.values);
+    if (sensorType == Sensor.TYPE_ROTATION_VECTOR) {
+      SensorManager.getQuaternionFromVector(quaternion, event.values);
+      SensorManager.getRotationMatrixFromVector(rotation, event.values);
+      SensorManager.getOrientation(rotation, orientation);
+      float[] data =
+          new float[] {
+            quaternion[1], // qx
+            quaternion[2], // qy
+            quaternion[3], // qz
+            quaternion[0], // qw
+            orientation[0], // yaw
+            orientation[1], // pitch
+            orientation[2] // roll
+          };
+      setter.sensorSetter(data);
+    } else {
+      setter.sensorSetter(event.values);
+    }
   }
 
   @Override

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorType.java

@@ -1,11 +1,13 @@
 package com.swmansion.reanimated.sensor;
 
+import android.hardware.Sensor;
+
 public enum ReanimatedSensorType {
-  ACCELEROMETER(1),
-  GYROSCOPE(2),
-  GRAVITY(3),
-  MAGNETIC_FIELD(4),
-  ROTATION_VECTOR(5);
+  ACCELEROMETER(Sensor.TYPE_LINEAR_ACCELERATION),
+  GYROSCOPE(Sensor.TYPE_GYROSCOPE),
+  GRAVITY(Sensor.TYPE_GRAVITY),
+  MAGNETIC_FIELD(Sensor.TYPE_MAGNETIC_FIELD),
+  ROTATION_VECTOR(Sensor.TYPE_ROTATION_VECTOR);
 
   private final int type;
 

package/ios/REANodesManager.m

@@ -509,9 +509,9 @@
   _nativeProps = nativePropsSet;
 }
 
-- (BOOL)isNotNativeViewFullyMounted:(NSNumber *)viewTag
+- (BOOL)isNativeViewMounted:(NSNumber *)viewTag
 {
-  return _viewRegistry[viewTag].superview == nil;
+  return _viewRegistry[viewTag].superview != nil;
 }
 
 - (void)setValueForNodeID:(nonnull NSNumber *)nodeID value:(nonnull NSNumber *)newValue
@@ -529,7 +529,17 @@
            withName:(nonnull NSString *)viewName
 {
   ComponentUpdate *lastSnapshot = _componentUpdateBuffer[viewTag];
-  if ([self isNotNativeViewFullyMounted:viewTag] || lastSnapshot != nil) {
+  BOOL isNativeViewMounted = [self isNativeViewMounted:viewTag];
+
+  if (lastSnapshot != nil) {
+    NSMutableDictionary *lastProps = lastSnapshot.props;
+    for (NSString *key in props) {
+      [lastProps setValue:props[key] forKey:key];
+    }
+  }
+
+  // If the component isn't mounted, we will bail early with a scheduled update
+  if (!isNativeViewMounted) {
     if (lastSnapshot == nil) {
       ComponentUpdate *propsSnapshot = [ComponentUpdate new];
       propsSnapshot.props = [props mutableCopy];
@@ -537,15 +547,28 @@
       propsSnapshot.viewName = viewName;
       _componentUpdateBuffer[viewTag] = propsSnapshot;
       atomic_store(&_shouldFlushUpdateBuffer, true);
-    } else {
-      NSMutableDictionary *lastProps = lastSnapshot.props;
-      for (NSString *key in props) {
-        [lastProps setValue:props[key] forKey:key];
-      }
     }
+
     return;
   }
 
+  // The component may have been mounted with a pending snapshot (due to a race condition),
+  // so we should attempt run the update. Otherwise, the next call to -maybeFlushUpdateBuffer
+  // will only arrive when a new component is mounted (which might be never!)
+  //
+  // If there are 0 remaining items in the buffer, we can skip the run in -maybeFlushUpdateBuffer.
+  if (lastSnapshot != nil && isNativeViewMounted) {
+    props = lastSnapshot.props;
+    viewTag = lastSnapshot.viewTag;
+    viewName = lastSnapshot.viewName;
+
+    [_componentUpdateBuffer removeObjectForKey:viewTag];
+
+    if (_componentUpdateBuffer.count == 0) {
+      atomic_store(&_shouldFlushUpdateBuffer, false);
+    }
+  }
+
   // TODO: refactor PropsNode to also use this function
   NSMutableDictionary *uiProps = [NSMutableDictionary new];
   NSMutableDictionary *nativeProps = [NSMutableDictionary new];

package/ios/keyboardObserver/REAKeyboardEventObserver.h

@@ -0,0 +1,17 @@
+#ifndef REAKeyboardEventManager_h
+#define REAKeyboardEventManager_h
+
+#import <RNReanimated/REAEventDispatcher.h>
+#import <React/RCTEventDispatcher.h>
+
+typedef void (^KeyboardEventListenerBlock)(int keyboardState, int height);
+
+@interface REAKeyboardEventObserver : NSObject
+
+- (instancetype)init;
+- (int)subscribeForKeyboardEvents:(KeyboardEventListenerBlock)listener;
+- (void)unsubscribeFromKeyboardEvents:(int)listenerId;
+
+@end
+
+#endif /* REAKeyboardEventManager_h */