react-native-reanimated 3.0.0-rc.9 → 3.0.0

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

@@ -11,24 +11,19 @@
 
 #include "AndroidErrorHandler.h"
 #include "AndroidScheduler.h"
+#include "JsiUtils.h"
 #include "LayoutAnimationsManager.h"
 #include "NativeProxy.h"
 #include "PlatformDepMethodsHolder.h"
 #include "ReanimatedRuntime.h"
+#include "ReanimatedVersion.h"
 
 #ifdef RCT_NEW_ARCH_ENABLED
-#include <JFabricUIManager.h>
 #include "FabricUtils.h"
 #include "NewestShadowNodesRegistry.h"
 #include "ReanimatedUIManagerBinding.h"
 #endif
 
-#ifdef REANIMATED_VERSION
-#define STRINGIZE(x) #x
-#define STRINGIZE2(x) STRINGIZE(x)
-#define REANIMATED_VERSION_STRING STRINGIZE2(REANIMATED_VERSION)
-#endif // REANIMATED_VERSION
-
 namespace reanimated {
 
 using namespace facebook;
@@ -69,6 +64,11 @@ NativeProxy::NativeProxy(
 NativeProxy::~NativeProxy() {
   // removed temporary, new event listener mechanism need fix on the RN side
   // reactScheduler_->removeEventListener(eventListener_);
+
+  // cleanup all animated sensors here, since NativeProxy
+  // has already been destroyed when AnimatedSensorModule's
+  // destructor is ran
+  _nativeReanimatedModule->cleanupSensors();
 }
 
 jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
@@ -138,24 +138,9 @@ void NativeProxy::installJSIBindings(
     return static_cast<double>(output);
   };
 
-  auto requestRender = [this, getCurrentTime](
+  auto requestRender = [this](
                            std::function<void(double)> onRender,
-                           jsi::Runtime &rt) {
-    // doNoUse -> NodesManager passes here a timestamp from choreographer which
-    // is useless for us as we use diffrent timer to better handle events. The
-    // lambda is translated to NodeManager.OnAnimationFrame and treated just
-    // like reanimated 1 frame callbacks which make use of the timestamp.
-    auto wrappedOnRender = [getCurrentTime, &rt, onRender](double doNotUse) {
-      jsi::Object global = rt.global();
-      jsi::String frameTimestampName =
-          jsi::String::createFromAscii(rt, "_frameTimestamp");
-      double frameTimestamp = getCurrentTime();
-      global.setProperty(rt, frameTimestampName, frameTimestamp);
-      onRender(frameTimestamp);
-      global.setProperty(rt, frameTimestampName, jsi::Value::undefined());
-    };
-    this->requestRender(std::move(wrappedOnRender));
-  };
+                           jsi::Runtime &rt) { this->requestRender(onRender); };
 
 #ifdef RCT_NEW_ARCH_ENABLED
   auto synchronouslyUpdateUIPropsFunction =
@@ -186,8 +171,11 @@ void NativeProxy::installJSIBindings(
 #endif
 
   auto registerSensorFunction =
-      [this](int sensorType, int interval, std::function<void(double[])> setter)
-      -> int {
+      [this](
+          int sensorType,
+          int interval,
+          int iosReferenceFrame,
+          std::function<void(double[], int)> setter) -> int {
     return this->registerSensor(sensorType, interval, std::move(setter));
   };
   auto unregisterSensorFunction = [this](int sensorId) {
@@ -199,8 +187,11 @@ void NativeProxy::installJSIBindings(
   };
 
   auto subscribeForKeyboardEventsFunction =
-      [this](std::function<void(int, int)> keyboardEventDataUpdater) -> int {
-    return subscribeForKeyboardEvents(std::move(keyboardEventDataUpdater));
+      [this](
+          std::function<void(int, int)> keyboardEventDataUpdater,
+          bool isStatusBarTranslucent) -> int {
+    return subscribeForKeyboardEvents(
+        std::move(keyboardEventDataUpdater), isStatusBarTranslucent);
   };
 
   auto unsubscribeFromKeyboardEventsFunction = [this](int listenerId) -> void {
@@ -211,39 +202,39 @@ void NativeProxy::installJSIBindings(
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       ReanimatedRuntime::make(runtime_, jsQueue);
 
+  auto &rt = *runtime_;
+
   auto workletRuntimeValue =
-      runtime_->global()
-          .getProperty(*runtime_, "ArrayBuffer")
-          .asObject(*runtime_)
-          .asFunction(*runtime_)
-          .callAsConstructor(*runtime_, {static_cast<double>(sizeof(void *))});
+      rt.global()
+          .getPropertyAsObject(rt, "ArrayBuffer")
+          .asFunction(rt)
+          .callAsConstructor(rt, {static_cast<double>(sizeof(void *))});
   uintptr_t *workletRuntimeData = reinterpret_cast<uintptr_t *>(
-      workletRuntimeValue.getObject(*runtime_).getArrayBuffer(*runtime_).data(
-          *runtime_));
+      workletRuntimeValue.getObject(rt).getArrayBuffer(rt).data(rt));
   workletRuntimeData[0] = reinterpret_cast<uintptr_t>(animatedRuntime.get());
 
-  runtime_->global().setProperty(
-      *runtime_, "_WORKLET_RUNTIME", workletRuntimeValue);
+  rt.global().setProperty(rt, "_WORKLET_RUNTIME", workletRuntimeValue);
 
 #ifdef RCT_NEW_ARCH_ENABLED
-  runtime_->global().setProperty(*runtime_, "_IS_FABRIC", true);
+  rt.global().setProperty(rt, "_IS_FABRIC", true);
 #else
-  runtime_->global().setProperty(*runtime_, "_IS_FABRIC", false);
+  rt.global().setProperty(rt, "_IS_FABRIC", false);
 #endif
 
-  auto version =
-      jsi::String::createFromUtf8(*runtime_, REANIMATED_VERSION_STRING);
-  runtime_->global().setProperty(*runtime_, "_REANIMATED_VERSION_CPP", version);
+  auto version = getReanimatedVersionString(rt);
+  rt.global().setProperty(rt, "_REANIMATED_VERSION_CPP", version);
 
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
   std::weak_ptr<jsi::Runtime> wrt = animatedRuntime;
 
-  auto progressLayoutAnimation = [this, wrt](
-                                     int tag, const jsi::Object &newProps) {
-    auto newPropsJNI = JNIHelper::ConvertToPropsMap(*wrt.lock(), newProps);
-    this->layoutAnimations->cthis()->progressLayoutAnimation(tag, newPropsJNI);
-  };
+  auto progressLayoutAnimation =
+      [this, wrt](
+          int tag, const jsi::Object &newProps, bool isSharedTransition) {
+        auto newPropsJNI = JNIHelper::ConvertToPropsMap(*wrt.lock(), newProps);
+        this->layoutAnimations->cthis()->progressLayoutAnimation(
+            tag, newPropsJNI, isSharedTransition);
+      };
 
   auto endLayoutAnimation = [this](int tag, bool isCancelled, bool removeView) {
     this->layoutAnimations->cthis()->endLayoutAnimation(
@@ -287,40 +278,43 @@ void NativeProxy::installJSIBindings(
   _nativeReanimatedModule = module;
   std::weak_ptr<NativeReanimatedModule> weakModule = module;
 
-#ifdef RCT_NEW_ARCH_ENABLED
   this->registerEventHandler([weakModule, getCurrentTime](
-                                 std::string eventName,
-                                 std::string eventAsString) {
+                                 jni::alias_ref<JString> eventKey,
+                                 jni::alias_ref<react::WritableMap> event) {
+    // handles RCTEvents from RNGestureHandler
     if (auto module = weakModule.lock()) {
-      // handles RCTEvents from RNGestureHandler
+      auto eventName = eventKey->toString();
 
+      // TODO: convert event directly to jsi::Value without JSON serialization
+      std::string eventAsString;
+      try {
+        eventAsString = event->toString();
+      } catch (std::exception &) {
+        // Events from other libraries may contain NaN or INF values which
+        // cannot be represented in JSON. See
+        // https://github.com/software-mansion/react-native-reanimated/issues/1776
+        // for details.
+        return;
+      }
       std::string eventJSON = eventAsString.substr(
           13, eventAsString.length() - 15); // removes "{ NativeMap: " and " }"
-      jsi::Runtime &rt = *module->runtime;
-      jsi::Value payload =
-          jsi::valueFromDynamic(rt, folly::parseJson(eventJSON));
-      // TODO: support NaN and INF values
-      // TODO: convert event directly to jsi::Value without JSON serialization
+      if (eventJSON == "null") {
+        return;
+      }
 
-      module->handleEvent(eventName, std::move(payload), getCurrentTime());
+      jsi::Runtime &rt = *module->runtime;
+      jsi::Value payload;
+      try {
+        payload = jsi::Value::createFromJsonUtf8(
+            rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
+      } catch (std::exception &) {
+        // Ignore events with malformed JSON payload.
+        return;
+      }
+
+      module->handleEvent(eventName, payload, getCurrentTime());
     }
   });
-#else
-  this->registerEventHandler(
-      [weakModule, getCurrentTime](
-          std::string eventName, std::string eventAsString) {
-        if (auto module = weakModule.lock()) {
-          jsi::Object global = module->runtime->global();
-          jsi::String eventTimestampName =
-              jsi::String::createFromAscii(*module->runtime, "_eventTimestamp");
-          global.setProperty(
-              *module->runtime, eventTimestampName, getCurrentTime());
-          module->onEvent(eventName, eventAsString);
-          global.setProperty(
-              *module->runtime, eventTimestampName, jsi::Value::undefined());
-        }
-      });
-#endif
 
 #ifdef RCT_NEW_ARCH_ENABLED
   Binding *binding = fabricUIManager->getBinding();
@@ -342,17 +336,23 @@ void NativeProxy::installJSIBindings(
 
   layoutAnimations->cthis()->setAnimationStartingBlock(
       [wrt, weakModule, weakErrorHandler](
-          int tag,
-          alias_ref<JString> type,
-          alias_ref<JMap<jstring, jstring>> values) {
+          int tag, int type, alias_ref<JMap<jstring, jstring>> values) {
         auto &rt = *wrt.lock();
         jsi::Object yogaValues(rt);
         for (const auto &entry : *values) {
           try {
-            auto key =
-                jsi::String::createFromAscii(rt, entry.first->toStdString());
-            auto value = stod(entry.second->toStdString());
-            yogaValues.setProperty(rt, key, value);
+            std::string keyString = entry.first->toStdString();
+            std::string valueString = entry.second->toStdString();
+            auto key = jsi::String::createFromAscii(rt, keyString);
+            if (keyString == "currentTransformMatrix" ||
+                keyString == "targetTransformMatrix") {
+              jsi::Array matrix =
+                  jsi_utils::convertStringToArray(rt, valueString, 9);
+              yogaValues.setProperty(rt, key, matrix);
+            } else {
+              auto value = stod(valueString);
+              yogaValues.setProperty(rt, key, value);
+            }
           } catch (std::invalid_argument e) {
             if (auto errorHandler = weakErrorHandler.lock()) {
               errorHandler->setError("Failed to convert value to number");
@@ -361,26 +361,66 @@ void NativeProxy::installJSIBindings(
           }
         }
 
-        weakModule.lock()->layoutAnimationsManager().startLayoutAnimation(
-            rt, tag, type->toStdString(), yogaValues);
+        auto reaModule = weakModule.lock();
+        if (reaModule == nullptr) {
+          return;
+        }
+
+        reaModule->layoutAnimationsManager().startLayoutAnimation(
+            rt, tag, static_cast<LayoutAnimationType>(type), yogaValues);
       });
 
   layoutAnimations->cthis()->setHasAnimationBlock(
-      [weakModule](int tag, const std::string &type) {
-        return weakModule.lock()->layoutAnimationsManager().hasLayoutAnimation(
-            tag, type);
+      [weakModule](int tag, int type) {
+        auto reaModule = weakModule.lock();
+        if (reaModule == nullptr) {
+          return false;
+        }
+
+        return reaModule->layoutAnimationsManager().hasLayoutAnimation(
+            tag, static_cast<LayoutAnimationType>(type));
       });
 
   layoutAnimations->cthis()->setClearAnimationConfigBlock(
       [weakModule](int tag) {
-        weakModule.lock()->layoutAnimationsManager().clearLayoutAnimationConfig(
-            tag);
+        auto reaModule = weakModule.lock();
+        if (reaModule == nullptr) {
+          return;
+        }
+
+        reaModule->layoutAnimationsManager().clearLayoutAnimationConfig(tag);
+      });
+
+  layoutAnimations->cthis()->setCancelAnimationForTag(
+      [wrt, weakModule](
+          int tag, int type, jboolean cancelled, jboolean removeView) {
+        if (auto reaModule = weakModule.lock()) {
+          if (auto runtime = wrt.lock()) {
+            jsi::Runtime &rt = *runtime;
+            reaModule->layoutAnimationsManager().cancelLayoutAnimation(
+                rt,
+                tag,
+                static_cast<LayoutAnimationType>(type),
+                cancelled,
+                removeView);
+          }
+        }
+      });
+
+  layoutAnimations->cthis()->setFindPrecedingViewTagForTransition(
+      [weakModule](int tag) {
+        if (auto module = weakModule.lock()) {
+          return module->layoutAnimationsManager()
+              .findPrecedingViewTagForTransition(tag);
+        } else {
+          return -1;
+        }
       });
 
-  runtime_->global().setProperty(
-      *runtime_,
-      jsi::PropNameID::forAscii(*runtime_, "__reanimatedModuleProxy"),
-      jsi::Object::createFromHostObject(*runtime_, module));
+  rt.global().setProperty(
+      rt,
+      jsi::PropNameID::forAscii(rt, "__reanimatedModuleProxy"),
+      jsi::Object::createFromHostObject(rt, module));
 }
 
 bool NativeProxy::isAnyHandlerWaitingForEvent(std::string s) {
@@ -414,7 +454,9 @@ void NativeProxy::requestRender(std::function<void(double)> onRender) {
 }
 
 void NativeProxy::registerEventHandler(
-    std::function<void(std::string, std::string)> handler) {
+    std::function<
+        void(jni::alias_ref<JString>, jni::alias_ref<react::WritableMap>)>
+        handler) {
   static auto method =
       javaPart_->getClass()->getMethod<void(EventHandler::javaobject)>(
           "registerEventHandler");
@@ -488,7 +530,7 @@ void NativeProxy::synchronouslyUpdateUIProps(
 int NativeProxy::registerSensor(
     int sensorType,
     int interval,
-    std::function<void(double[])> setter) {
+    std::function<void(double[], int)> setter) {
   static auto method =
       javaPart_->getClass()->getMethod<int(int, int, SensorSetter::javaobject)>(
           "registerSensor");
@@ -527,15 +569,18 @@ void NativeProxy::configureProps(
 }
 
 int NativeProxy::subscribeForKeyboardEvents(
-    std::function<void(int, int)> keyboardEventDataUpdater) {
-  auto method = javaPart_->getClass()
-                    ->getMethod<int(KeyboardEventDataUpdater::javaobject)>(
-                        "subscribeForKeyboardEvents");
+    std::function<void(int, int)> keyboardEventDataUpdater,
+    bool isStatusBarTranslucent) {
+  auto method =
+      javaPart_->getClass()
+          ->getMethod<int(KeyboardEventDataUpdater::javaobject, bool)>(
+              "subscribeForKeyboardEvents");
   return method(
       javaPart_.get(),
       KeyboardEventDataUpdater::newObjectCxxArgs(
           std::move(keyboardEventDataUpdater))
-          .get());
+          .get(),
+      isStatusBarTranslucent);
 }
 
 void NativeProxy::unsubscribeFromKeyboardEvents(int listenerId) {

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #ifdef RCT_NEW_ARCH_ENABLED
-#include <JFabricUIManager.h>
+#include <react/fabric/JFabricUIManager.h>
 #endif
 
 #include <ReactCommon/CallInvokerHolder.h>
@@ -32,7 +32,7 @@ using namespace facebook::jni;
 class AnimationFrameCallback : public HybridClass<AnimationFrameCallback> {
  public:
   static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/reanimated/NativeProxy$AnimationFrameCallback;";
+      "Lcom/swmansion/reanimated/nativeProxy/AnimationFrameCallback;";
 
   void onAnimationFrame(double timestampMs) {
     callback_(timestampMs);
@@ -57,24 +57,12 @@ class AnimationFrameCallback : public HybridClass<AnimationFrameCallback> {
 class EventHandler : public HybridClass<EventHandler> {
  public:
   static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/reanimated/NativeProxy$EventHandler;";
+      "Lcom/swmansion/reanimated/nativeProxy/EventHandler;";
 
   void receiveEvent(
       jni::alias_ref<JString> eventKey,
       jni::alias_ref<react::WritableMap> event) {
-    std::string eventAsString = "{NativeMap:null}";
-    if (event != nullptr) {
-      try {
-        eventAsString = event->toString();
-      } catch (std::exception &) {
-        // Events from other libraries may contain NaN or INF values which
-        // cannot be represented in JSON. See
-        // https://github.com/software-mansion/react-native-reanimated/issues/1776
-        // for details.
-        return;
-      }
-    }
-    handler_(eventKey->toString(), eventAsString);
+    handler_(eventKey, event);
   }
 
   static void registerNatives() {
@@ -86,25 +74,29 @@ class EventHandler : public HybridClass<EventHandler> {
  private:
   friend HybridBase;
 
-  explicit EventHandler(std::function<void(std::string, std::string)> handler)
+  explicit EventHandler(std::function<void(
+                            jni::alias_ref<JString>,
+                            jni::alias_ref<react::WritableMap>)> handler)
       : handler_(std::move(handler)) {}
 
-  std::function<void(std::string, std::string)> handler_;
+  std::function<
+      void(jni::alias_ref<JString>, jni::alias_ref<react::WritableMap>)>
+      handler_;
 };
 
 class SensorSetter : public HybridClass<SensorSetter> {
  public:
   static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/reanimated/NativeProxy$SensorSetter;";
+      "Lcom/swmansion/reanimated/nativeProxy/SensorSetter;";
 
-  void sensorSetter(jni::alias_ref<JArrayFloat> value) {
+  void sensorSetter(jni::alias_ref<JArrayFloat> value, int orientationDegrees) {
     size_t size = value->size();
     auto elements = value->getRegion(0, size);
     double array[7];
     for (int i = 0; i < size; i++) {
       array[i] = elements[i];
     }
-    callback_(array);
+    callback_(array, orientationDegrees);
   }
 
   static void registerNatives() {
@@ -116,16 +108,16 @@ class SensorSetter : public HybridClass<SensorSetter> {
  private:
   friend HybridBase;
 
-  explicit SensorSetter(std::function<void(double[])> callback)
+  explicit SensorSetter(std::function<void(double[], int)> callback)
       : callback_(std::move(callback)) {}
 
-  std::function<void(double[])> callback_;
+  std::function<void(double[], int)> callback_;
 };
 
 class KeyboardEventDataUpdater : public HybridClass<KeyboardEventDataUpdater> {
  public:
   static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/reanimated/NativeProxy$KeyboardEventDataUpdater;";
+      "Lcom/swmansion/reanimated/nativeProxy/KeyboardEventDataUpdater;";
 
   void keyboardEventDataUpdater(int keyboardState, int height) {
     callback_(keyboardState, height);
@@ -199,20 +191,22 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
   bool isAnyHandlerWaitingForEvent(std::string);
   void performOperations();
   void requestRender(std::function<void(double)> onRender);
-  void registerEventHandler(
-      std::function<void(std::string, std::string)> handler);
+  void registerEventHandler(std::function<void(
+                                jni::alias_ref<JString>,
+                                jni::alias_ref<react::WritableMap>)> handler);
   void setGestureState(int handlerTag, int newState);
   int registerSensor(
       int sensorType,
       int interval,
-      std::function<void(double[])> setter);
+      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);
+      std::function<void(int, int)> keyboardEventDataUpdater,
+      bool isStatusBarTranslucent);
   void unsubscribeFromKeyboardEvents(int listenerId);
 #ifdef RCT_NEW_ARCH_ENABLED
   // nothing

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

@@ -16,8 +16,10 @@ import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import com.facebook.react.uimanager.ReanimatedUIManager;
 import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
 import com.facebook.systrace.Systrace;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class ReanimatedPackage extends TurboReactPackage implements ReactPackage {
@@ -68,12 +70,11 @@ public class ReanimatedPackage extends TurboReactPackage implements ReactPackage
     ReactMarker.logMarker(CREATE_UI_MANAGER_MODULE_START);
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "createUIManagerModule");
     final ReactInstanceManager reactInstanceManager = getReactInstanceManager(reactContext);
+    List<ViewManager> viewManagers = reactInstanceManager.getOrCreateViewManagers(reactContext);
     int minTimeLeftInFrameForNonBatchedOperationMs = -1;
     try {
-      return new ReanimatedUIManager(
-          reactContext,
-          reactInstanceManager.getOrCreateViewManagers(reactContext),
-          minTimeLeftInFrameForNonBatchedOperationMs);
+      return ReanimatedUIManagerFactory.create(
+          reactContext, viewManagers, minTimeLeftInFrameForNonBatchedOperationMs);
     } finally {
       Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
       ReactMarker.logMarker(CREATE_UI_MANAGER_MODULE_END);

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

@@ -8,7 +8,7 @@ import java.util.Map;
 
 public class Utils {
 
-  protected static boolean isChromeDebugger = false;
+  public static boolean isChromeDebugger = false;
 
   public static Map<String, Integer> processMapping(ReadableMap style) {
     ReadableMapKeySetIterator iter = style.keySetIterator();
@@ -29,4 +29,10 @@ public class Utils {
     }
     return res;
   }
+
+  public static String simplifyStringNumbersList(String list) {
+    // transforms string: '[1, 2, 3]' -> '1 2 3'
+    // to make usage of std::istringstream in C++ easier
+    return list.replace(",", "").replace("[", "").replace("]", "");
+  }
 }

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

@@ -12,7 +12,7 @@ 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 com.swmansion.reanimated.nativeProxy.KeyboardEventDataUpdater;
 import java.lang.ref.WeakReference;
 import java.util.HashMap;
 import java.util.List;
@@ -40,6 +40,7 @@ public class ReanimatedKeyboardEventListener {
   private int nextListenerId = 0;
   private KeyboardState state;
   private final HashMap<Integer, KeyboardEventDataUpdater> listeners = new HashMap<>();
+  private boolean isStatusBarTranslucent = false;
 
   public ReanimatedKeyboardEventListener(WeakReference<ReactApplicationContext> reactContext) {
     this.reactContext = reactContext;
@@ -68,7 +69,11 @@ public class ReanimatedKeyboardEventListener {
           FrameLayout.LayoutParams params =
               new FrameLayout.LayoutParams(
                   FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
-          params.setMargins(0, paddingTop, 0, paddingBottom);
+          if (isStatusBarTranslucent) {
+            params.setMargins(0, 0, 0, 0);
+          } else {
+            params.setMargins(0, paddingTop, 0, paddingBottom);
+          }
           content.setLayoutParams(params);
           return insets;
         });
@@ -127,9 +132,11 @@ public class ReanimatedKeyboardEventListener {
     ViewCompat.setWindowInsetsAnimationCallback(rootView, new WindowInsetsCallback());
   }
 
-  public int subscribeForKeyboardEvents(KeyboardEventDataUpdater updater) {
+  public int subscribeForKeyboardEvents(
+      KeyboardEventDataUpdater updater, boolean isStatusBarTranslucent) {
     int listenerId = nextListenerId++;
     if (listeners.isEmpty()) {
+      this.isStatusBarTranslucent = isStatusBarTranslucent;
       setUpCallbacks();
     }
     listeners.put(listenerId, updater);