Shareable value rewrite

Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -1,19 +1,17 @@
 #include "AnimatedSensorModule.h"
-#include "MutableValue.h"
-#include "ValueWrapper.h"
 
 #include <memory>
 #include <utility>
 
+#include "Shareables.h"
+
 namespace reanimated {
 
 AnimatedSensorModule::AnimatedSensorModule(
-    const PlatformDepMethodsHolder &platformDepMethodsHolder,
-    RuntimeManager *runtimeManager)
+    const PlatformDepMethodsHolder &platformDepMethodsHolder)
     : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
       platformUnregisterSensorFunction_(
-          platformDepMethodsHolder.unregisterSensor),
-      runtimeManager_(runtimeManager) {}
+          platformDepMethodsHolder.unregisterSensor) {}
 
 AnimatedSensorModule::~AnimatedSensorModule() {
   // It is called during app reload because app reload doesn't call hooks
@@ -25,41 +23,38 @@ AnimatedSensorModule::~AnimatedSensorModule() {
 
 jsi::Value AnimatedSensorModule::registerSensor(
     jsi::Runtime &rt,
-    const jsi::Value &sensorType,
+    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+    const jsi::Value &sensorTypeValue,
     const jsi::Value &interval,
-    const jsi::Value &sensorDataContainer) {
-  std::shared_ptr<ShareableValue> sensorsData = ShareableValue::adapt(
-      rt, sensorDataContainer.getObject(rt), runtimeManager_);
-  auto &mutableObject =
-      ValueWrapper::asMutableValue(sensorsData->valueContainer);
+    const jsi::Value &sensorDataHandler) {
+  SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
 
-  std::function<void(double[])> setter;
-  if (sensorType.asNumber() == SensorType::ROTATION_VECTOR) {
-    setter = [&, mutableObject](double newValues[]) {
-      jsi::Runtime &runtime = *runtimeManager_->runtime.get();
-      jsi::Object value(runtime);
-      value.setProperty(runtime, "qx", newValues[0]);
-      value.setProperty(runtime, "qy", newValues[1]);
-      value.setProperty(runtime, "qz", newValues[2]);
-      value.setProperty(runtime, "qw", newValues[3]);
-      value.setProperty(runtime, "yaw", newValues[4]);
-      value.setProperty(runtime, "pitch", newValues[5]);
-      value.setProperty(runtime, "roll", newValues[6]);
-      mutableObject->setValue(runtime, std::move(value));
-    };
-  } else {
-    setter = [&, mutableObject](double newValues[]) {
-      jsi::Runtime &runtime = *runtimeManager_->runtime.get();
-      jsi::Object value(runtime);
-      value.setProperty(runtime, "x", newValues[0]);
-      value.setProperty(runtime, "y", newValues[1]);
-      value.setProperty(runtime, "z", newValues[2]);
-      mutableObject->setValue(runtime, std::move(value));
-    };
-  }
+  auto shareableHandler = extractShareableOrThrow(rt, sensorDataHandler);
+  auto uiRuntime = runtimeHelper->uiRuntime();
 
   int sensorId = platformRegisterSensorFunction_(
-      sensorType.asNumber(), interval.asNumber(), setter);
+      sensorType, interval.asNumber(), [=](double newValues[]) {
+        jsi::Runtime &rt = *uiRuntime;
+        auto handler =
+            shareableHandler->getJSValue(rt).asObject(rt).asFunction(rt);
+        if (sensorType == SensorType::ROTATION_VECTOR) {
+          jsi::Object value(rt);
+          value.setProperty(rt, "qx", newValues[0]);
+          value.setProperty(rt, "qy", newValues[1]);
+          value.setProperty(rt, "qz", newValues[2]);
+          value.setProperty(rt, "qw", newValues[3]);
+          value.setProperty(rt, "yaw", newValues[4]);
+          value.setProperty(rt, "pitch", newValues[5]);
+          value.setProperty(rt, "roll", newValues[6]);
+          handler.call(rt, value);
+        } else {
+          jsi::Object value(rt);
+          value.setProperty(rt, "x", newValues[0]);
+          value.setProperty(rt, "y", newValues[1]);
+          value.setProperty(rt, "z", newValues[2]);
+          handler.call(rt, value);
+        }
+      });
   if (sensorId != -1) {
     sensorsIds_.insert(sensorId);
   }

Common/cpp/AnimatedSensor/AnimatedSensorModule.h

@@ -5,6 +5,7 @@
 
 #include "PlatformDepMethodsHolder.h"
 #include "RuntimeManager.h"
+#include "Shareables.h"
 
 namespace reanimated {
 
@@ -22,16 +23,15 @@ class AnimatedSensorModule {
   std::unordered_set<int> sensorsIds_;
   RegisterSensorFunction platformRegisterSensorFunction_;
   UnregisterSensorFunction platformUnregisterSensorFunction_;
-  RuntimeManager *runtimeManager_;
 
  public:
   AnimatedSensorModule(
-      const PlatformDepMethodsHolder &platformDepMethodsHolder,
-      RuntimeManager *runtimeManager);
+      const PlatformDepMethodsHolder &platformDepMethodsHolder);
   ~AnimatedSensorModule();
 
   jsi::Value registerSensor(
       jsi::Runtime &rt,
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       const jsi::Value &sensorType,
       const jsi::Value &interval,
       const jsi::Value &sensorDataContainer);

Common/cpp/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -0,0 +1,76 @@
+#include "LayoutAnimationsManager.h"
+#include "Shareables.h"
+
+#include <utility>
+
+namespace reanimated {
+
+void LayoutAnimationsManager::configureAnimation(
+    int tag,
+    const std::string &type,
+    std::shared_ptr<Shareable> config) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  if (type == "entering") {
+    enteringAnimations_[tag] = config;
+  } else if (type == "exiting") {
+    exitingAnimations_[tag] = config;
+  } else if (type == "layout") {
+    layoutAnimations_[tag] = config;
+  }
+}
+
+bool LayoutAnimationsManager::hasLayoutAnimation(
+    int tag,
+    const std::string &type) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  if (type == "entering") {
+    return enteringAnimations_.find(tag) != enteringAnimations_.end();
+  } else if (type == "exiting") {
+    return exitingAnimations_.find(tag) != exitingAnimations_.end();
+  } else if (type == "layout") {
+    return layoutAnimations_.find(tag) != layoutAnimations_.end();
+  }
+  return false;
+}
+
+void LayoutAnimationsManager::clearLayoutAnimationConfig(int tag) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  enteringAnimations_.erase(tag);
+  exitingAnimations_.erase(tag);
+  layoutAnimations_.erase(tag);
+}
+
+void LayoutAnimationsManager::startLayoutAnimation(
+    jsi::Runtime &rt,
+    int tag,
+    const std::string &type,
+    const jsi::Object &values) {
+  std::shared_ptr<Shareable> config, viewShareable;
+  {
+    auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+    if (type == "entering") {
+      config = enteringAnimations_[tag];
+    } else if (type == "exiting") {
+      config = exitingAnimations_[tag];
+    } else if (type == "layout") {
+      config = layoutAnimations_[tag];
+    }
+  }
+
+  // TODO: cache the following!!
+  jsi::Value layoutAnimationRepositoryAsValue =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getProperty(rt, "LayoutAnimationsManager");
+  jsi::Function startAnimationForTag =
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
+          rt, "start");
+  startAnimationForTag.call(
+      rt,
+      jsi::Value(tag),
+      jsi::String::createFromAscii(rt, type),
+      values,
+      config->getJSValue(rt));
+}
+
+} // namespace reanimated

Common/cpp/LayoutAnimations/LayoutAnimationsManager.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "ErrorHandler.h"
+#include "Shareables.h"
+
+#include <jsi/jsi.h>
+#include <stdio.h>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated {
+
+using namespace facebook;
+
+class LayoutAnimationsManager {
+ public:
+  void configureAnimation(
+      int tag,
+      const std::string &type,
+      std::shared_ptr<Shareable> config);
+  bool hasLayoutAnimation(int tag, const std::string &type);
+  void startLayoutAnimation(
+      jsi::Runtime &rt,
+      int tag,
+      const std::string &type,
+      const jsi::Object &values);
+  void clearLayoutAnimationConfig(int tag);
+
+ private:
+  std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>> exitingAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>> layoutAnimations_;
+  mutable std::mutex
+      animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
+                        // `layoutAnimations_` and `viewSharedValues_`.
+};
+
+} // namespace reanimated