react-native-reanimated 2.3.0-alpha.1 → 2.3.0-beta.2

package/Common/cpp/Tools/JSIStoreValueUser.cpp

@@ -1,43 +1,55 @@
 #include "JSIStoreValueUser.h"
+#include "RuntimeManager.h"
+#ifdef ONANDROID
+#include <AndroidScheduler.h>
+#endif
 
 namespace reanimated {
 
-std::atomic<int> StoreUser::ctr;
-std::recursive_mutex StoreUser::storeMutex;
-std::unordered_map<int, std::vector<std::shared_ptr<jsi::Value>>> StoreUser::store;
-
 std::weak_ptr<jsi::Value> StoreUser::getWeakRef(jsi::Runtime &rt) {
-  const std::lock_guard<std::recursive_mutex> lock(storeMutex);
-  if (StoreUser::store.count(identifier) == 0) {
-    StoreUser::store[identifier] = std::vector<std::shared_ptr<jsi::Value>>();
+  const std::lock_guard<std::recursive_mutex> lock(storeUserData->storeMutex);
+  if (storeUserData->store.count(identifier) == 0) {
+    storeUserData->store[identifier] =
+        std::vector<std::shared_ptr<jsi::Value>>();
   }
-  std::shared_ptr<jsi::Value> sv = std::make_shared<jsi::Value>(rt, jsi::Value::undefined());
-  StoreUser::store[identifier].push_back(sv);
-  
+  std::shared_ptr<jsi::Value> sv =
+      std::make_shared<jsi::Value>(rt, jsi::Value::undefined());
+  storeUserData->store[identifier].push_back(sv);
+
   return sv;
 }
 
-StoreUser::StoreUser(std::shared_ptr<Scheduler> s): scheduler(s) {
-  identifier = StoreUser::ctr++;
+StoreUser::StoreUser(
+    std::shared_ptr<Scheduler> s,
+    RuntimeManager &runtimeManager)
+    : scheduler(s) {
+  storeUserData = runtimeManager.storeUserData;
+  identifier = storeUserData->ctr++;
 }
 
 StoreUser::~StoreUser() {
   int id = identifier;
   std::shared_ptr<Scheduler> strongScheduler = scheduler.lock();
   if (strongScheduler != nullptr) {
-    strongScheduler->scheduleOnUI([id]() {
-      const std::lock_guard<std::recursive_mutex> lock(storeMutex);
-      if (StoreUser::store.count(id) > 0) {
-        StoreUser::store.erase(id);
-      }
+    std::shared_ptr<StaticStoreUser> sud = storeUserData;
+    #ifdef ONANDROID
+    jni::ThreadScope::WithClassLoader([&] {
+      strongScheduler->scheduleOnUI([id, sud]() {
+        const std::lock_guard<std::recursive_mutex> lock(sud->storeMutex);
+        if (sud->store.count(id) > 0) {
+          sud->store.erase(id);
+        }
+      });
     });
+    #else 
+    strongScheduler->scheduleOnUI([id, sud]() {
+        const std::lock_guard<std::recursive_mutex> lock(sud->storeMutex);
+        if (sud->store.count(id) > 0) {
+          sud->store.erase(id);
+        }
+    });
+    #endif
   }
 }
 
-
-void StoreUser::clearStore() {
-  const std::lock_guard<std::recursive_mutex> lock(storeMutex);
-  StoreUser::store.clear();
-}
-
-}
+} // namespace reanimated

package/Common/cpp/Tools/Mapper.cpp

@@ -1,32 +1,16 @@
 #include "Mapper.h"
-#include "SharedParent.h"
 #include "MutableValue.h"
+#include "SharedParent.h"
 
 namespace reanimated {
 
-Mapper::Mapper(NativeReanimatedModule *module,
-               unsigned long id,
-               std::shared_ptr<jsi::Function> mapper,
-               std::vector<std::shared_ptr<MutableValue>> inputs,
-               std::vector<std::shared_ptr<MutableValue>> outputs,
-               std::shared_ptr<ShareableValue> updater,
-               const int viewTag,
-               const std::string& viewName,
-               const int optimalizationLvl):
-id(id),
-module(module),
-mapper(mapper),
-inputs(inputs),
-outputs(outputs),
-viewTag(viewTag),
-optimalizationLvl(optimalizationLvl)
-{
-  jsi::Runtime* rt = module->runtime.get();
-  this->viewName = jsi::Value(*rt, jsi::String::createFromUtf8(*rt, viewName));
-  updateProps = &module->updaterFunction;
-  userUpdater = std::make_shared<jsi::Function>(updater->getValue(*rt).asObject(*rt).asFunction(*rt));
-  
-  
+Mapper::Mapper(
+    NativeReanimatedModule *module,
+    unsigned long id,
+    std::shared_ptr<jsi::Function> mapper,
+    std::vector<std::shared_ptr<MutableValue>> inputs,
+    std::vector<std::shared_ptr<MutableValue>> outputs)
+    : id(id), module(module), mapper(mapper), inputs(inputs), outputs(outputs) {
   auto markDirty = [this, module]() {
     this->dirty = true;
     module->maybeRequestRender();
@@ -38,12 +22,40 @@ optimalizationLvl(optimalizationLvl)
 
 void Mapper::execute(jsi::Runtime &rt) {
   dirty = false;
-  if(optimalizationLvl == 0) {
-    mapper->callWithThis(rt, *mapper);// call styleUpdater
+  if (optimalizationLvl == 0) {
+    mapper->callWithThis(rt, *mapper); // call styleUpdater
+  } else {
+    jsi::Object newStyle = userUpdater->call(rt).asObject(rt);
+    auto jsViewDescriptorArray = viewDescriptors->getValue(rt)
+                                     .getObject(rt)
+                                     .getProperty(rt, "value")
+                                     .asObject(rt)
+                                     .getArray(rt);
+    for (int i = 0; i < jsViewDescriptorArray.length(rt); ++i) {
+      auto jsViewDescriptor =
+          jsViewDescriptorArray.getValueAtIndex(rt, i).getObject(rt);
+      (*updateProps)(
+          rt,
+          (int)jsViewDescriptor.getProperty(rt, "tag").asNumber(),
+          jsViewDescriptor.getProperty(rt, "name"),
+          newStyle);
+    }
   }
-  else {
-    (*updateProps)(rt, viewTag, viewName, userUpdater->call(rt).asObject(rt));
+}
+
+void Mapper::enableFastMode(
+    const int optimalizationLvl,
+    const std::shared_ptr<ShareableValue> &updater,
+    const std::shared_ptr<ShareableValue> &jsViewDescriptors) {
+  if (optimalizationLvl == 0) {
+    return;
   }
+  viewDescriptors = jsViewDescriptors;
+  this->optimalizationLvl = optimalizationLvl;
+  updateProps = &module->updaterFunction;
+  jsi::Runtime *rt = module->runtime.get();
+  userUpdater = std::make_shared<jsi::Function>(
+      updater->getValue(*rt).asObject(*rt).asFunction(*rt));
 }
 
 Mapper::~Mapper() {
@@ -52,4 +64,4 @@ Mapper::~Mapper() {
   }
 }
 
-}
+} // namespace reanimated

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -1,45 +1,53 @@
 #include "RuntimeDecorator.h"
-#include "ReanimatedHiddenHeaders.h"
-#include <unordered_map>
 #include <memory>
-#include "MutableValue.h"
+#include <unordered_map>
 #include "LayoutAnimationsProxy.h"
+#include "MutableValue.h"
+#include "ReanimatedHiddenHeaders.h"
 
 namespace reanimated {
 
-std::unordered_map<RuntimePointer, RuntimeType> RuntimeDecorator::runtimeRegistry;
-void RuntimeDecorator::registerRuntime(jsi::Runtime *runtime, RuntimeType runtimeType) {
-  runtimeRegistry.insert({ runtime, runtimeType });
+std::unordered_map<RuntimePointer, RuntimeType>
+    RuntimeDecorator::runtimeRegistry;
+void RuntimeDecorator::registerRuntime(
+    jsi::Runtime *runtime,
+    RuntimeType runtimeType) {
+  runtimeRegistry.insert({runtime, runtimeType});
 }
 
-void RuntimeDecorator::decorateRuntime(jsi::Runtime &rt, const std::string &label) {
-  // This property will be used to find out if a runtime is a custom worklet runtime (e.g. UI, VisionCamera frame processor, ...)
+void RuntimeDecorator::decorateRuntime(
+    jsi::Runtime &rt,
+    const std::string &label) {
+  // This property will be used to find out if a runtime is a custom worklet
+  // runtime (e.g. UI, VisionCamera frame processor, ...)
   rt.global().setProperty(rt, "_WORKLET", jsi::Value(true));
   // This property will be used for debugging
-  rt.global().setProperty(rt, "_LABEL", jsi::String::createFromAscii(rt, label));
+  rt.global().setProperty(
+      rt, "_LABEL", jsi::String::createFromAscii(rt, label));
 
   jsi::Object dummyGlobal(rt);
-  auto dummyFunction = [](
-                          jsi::Runtime &rt,
+  auto dummyFunction = [](jsi::Runtime &rt,
                           const jsi::Value &thisValue,
                           const jsi::Value *args,
-                          size_t count
-                          ) -> jsi::Value {
+                          size_t count) -> jsi::Value {
     return jsi::Value::undefined();
   };
-  jsi::Function __reanimatedWorkletInit = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "__reanimatedWorkletInit"), 1, dummyFunction);
-
-  dummyGlobal.setProperty(rt, "__reanimatedWorkletInit", __reanimatedWorkletInit);
+  jsi::Function __reanimatedWorkletInit = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "__reanimatedWorkletInit"),
+      1,
+      dummyFunction);
+
+  dummyGlobal.setProperty(
+      rt, "__reanimatedWorkletInit", __reanimatedWorkletInit);
   rt.global().setProperty(rt, "global", dummyGlobal);
 
   rt.global().setProperty(rt, "jsThis", jsi::Value::undefined());
 
-  auto callback = [](
-                     jsi::Runtime &rt,
+  auto callback = [](jsi::Runtime &rt,
                      const jsi::Value &thisValue,
                      const jsi::Value *args,
-                     size_t count
-                     ) -> jsi::Value {
+                     size_t count) -> jsi::Value {
     const jsi::Value *value = &args[0];
     if (value->isString()) {
       Logger::log(value->getString(rt).utf8(rt).c_str());
@@ -52,68 +60,74 @@ void RuntimeDecorator::decorateRuntime(jsi::Runtime &rt, const std::string &labe
     }
     return jsi::Value::undefined();
   };
-  jsi::Value log = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_log"), 1, callback);
+  jsi::Value log = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_log"), 1, callback);
   rt.global().setProperty(rt, "_log", log);
 
-  auto setGlobalConsole = [](
-                             jsi::Runtime &rt,
+  auto setGlobalConsole = [](jsi::Runtime &rt,
                              const jsi::Value &thisValue,
                              const jsi::Value *args,
-                             size_t count
-                             ) -> jsi::Value {
+                             size_t count) -> jsi::Value {
     rt.global().setProperty(rt, "console", args[0]);
     return jsi::Value::undefined();
   };
-  rt.global().setProperty(rt, "_setGlobalConsole", jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_setGlobalConsole"), 1, setGlobalConsole));
+  rt.global().setProperty(
+      rt,
+      "_setGlobalConsole",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "_setGlobalConsole"),
+          1,
+          setGlobalConsole));
 }
 
-void RuntimeDecorator::decorateUIRuntime(jsi::Runtime &rt,
-                                         const UpdaterFunction updater,
-                                         const RequestFrameFunction requestFrame,
-                                         const ScrollToFunction scrollTo,
-                                         const MeasuringFunction measure,
-                                         const TimeProviderFunction getCurrentTime,
-                                         std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy) {
+void RuntimeDecorator::decorateUIRuntime(
+    jsi::Runtime &rt,
+    const UpdaterFunction updater,
+    const RequestFrameFunction requestFrame,
+    const ScrollToFunction scrollTo,
+    const MeasuringFunction measure,
+    const TimeProviderFunction getCurrentTime,
+    std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy) {
   RuntimeDecorator::decorateRuntime(rt, "UI");
   rt.global().setProperty(rt, "_UI", jsi::Value(true));
 
   auto clb = [updater](
-                       jsi::Runtime &rt,
-                       const jsi::Value &thisValue,
-                       const jsi::Value *args,
-                       const size_t count
-                       ) -> jsi::Value {
+                 jsi::Runtime &rt,
+                 const jsi::Value &thisValue,
+                 const jsi::Value *args,
+                 const size_t count) -> jsi::Value {
     const auto viewTag = args[0].asNumber();
-    const jsi::Value* viewName = &args[1];
+    const jsi::Value *viewName = &args[1];
     const auto params = args[2].asObject(rt);
     updater(rt, viewTag, *viewName, params);
     return jsi::Value::undefined();
   };
-  jsi::Value updateProps = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_updateProps"), 2, clb);
+  jsi::Value updateProps = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_updateProps"), 2, clb);
   rt.global().setProperty(rt, "_updateProps", updateProps);
 
-
   auto clb2 = [requestFrame](
-                             jsi::Runtime &rt,
-                             const jsi::Value &thisValue,
-                             const jsi::Value *args,
-                             const size_t count
-                             ) -> jsi::Value {
-    auto fun = std::make_shared<jsi::Function>(args[0].asObject(rt).asFunction(rt));
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
+    auto fun =
+        std::make_shared<jsi::Function>(args[0].asObject(rt).asFunction(rt));
     requestFrame([&rt, fun](double timestampMs) {
       fun->call(rt, jsi::Value(timestampMs));
     });
     return jsi::Value::undefined();
   };
-  jsi::Value requestAnimationFrame = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "requestAnimationFrame"), 1, clb2);
+  jsi::Value requestAnimationFrame = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "requestAnimationFrame"), 1, clb2);
   rt.global().setProperty(rt, "requestAnimationFrame", requestAnimationFrame);
 
   auto clb3 = [scrollTo](
-                         jsi::Runtime &rt,
-                         const jsi::Value &thisValue,
-                         const jsi::Value *args,
-                         const size_t count
-                         ) -> jsi::Value {
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
     int viewTag = (int)args[0].asNumber();
     double x = args[1].asNumber();
     double y = args[2].asNumber();
@@ -121,64 +135,68 @@ void RuntimeDecorator::decorateUIRuntime(jsi::Runtime &rt,
     scrollTo(viewTag, x, y, animated);
     return jsi::Value::undefined();
   };
-  jsi::Value scrollToFunction = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_scrollTo"), 4, clb3);
+  jsi::Value scrollToFunction = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_scrollTo"), 4, clb3);
   rt.global().setProperty(rt, "_scrollTo", scrollToFunction);
 
   auto clb4 = [measure](
-                        jsi::Runtime &rt,
-                        const jsi::Value &thisValue,
-                        const jsi::Value *args,
-                        const size_t count
-                        ) -> jsi::Value {
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
     int viewTag = (int)args[0].asNumber();
     auto result = measure(viewTag);
     jsi::Object resultObject(rt);
-    for (auto &i:result) {
+    for (auto &i : result) {
       resultObject.setProperty(rt, i.first.c_str(), i.second);
     }
     return resultObject;
   };
-  jsi::Value measureFunction = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_measure"), 1, clb4);
+  jsi::Value measureFunction = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_measure"), 1, clb4);
   rt.global().setProperty(rt, "_measure", measureFunction);
 
   auto clb6 = [getCurrentTime](
-                               jsi::Runtime &rt,
-                               const jsi::Value &thisValue,
-                               const jsi::Value *args,
-                               const size_t count
-                               ) -> jsi::Value {
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
     return getCurrentTime();
   };
-  jsi::Value timeFun = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_getCurrentTime"), 0, clb6);
+  jsi::Value timeFun = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_getCurrentTime"), 0, clb6);
   rt.global().setProperty(rt, "_getCurrentTime", timeFun);
 
   rt.global().setProperty(rt, "_frameTimestamp", jsi::Value::undefined());
   rt.global().setProperty(rt, "_eventTimestamp", jsi::Value::undefined());
-    
+
   // layout animation
   std::weak_ptr<LayoutAnimationsProxy> layoutProxy = layoutAnimationsProxy;
   auto clb7 = [layoutProxy](
-                               jsi::Runtime &rt,
-                               const jsi::Value &thisValue,
-                               const jsi::Value *args,
-                               size_t count
-                               ) -> jsi::Value {
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  size_t count) -> jsi::Value {
     std::shared_ptr<LayoutAnimationsProxy> proxy = layoutProxy.lock();
     if (layoutProxy.expired()) {
       return jsi::Value::undefined();
     }
-    proxy->startObserving(args[0].asNumber(), args[1].asObject(rt).getHostObject<MutableValue>(rt), rt);
+    proxy->startObserving(
+        args[0].asNumber(),
+        args[1].asObject(rt).getHostObject<MutableValue>(rt),
+        rt);
     return jsi::Value::undefined();
   };
-  jsi::Value _startObservingProgress = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_startObservingProgress"), 0, clb7);
-  rt.global().setProperty(rt, "_startObservingProgress", _startObservingProgress);
-  
+  jsi::Value _startObservingProgress = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_startObservingProgress"), 0, clb7);
+  rt.global().setProperty(
+      rt, "_startObservingProgress", _startObservingProgress);
+
   auto clb8 = [layoutProxy](
-                               jsi::Runtime &rt,
-                               const jsi::Value &thisValue,
-                               const jsi::Value *args,
-                               size_t count
-                               ) -> jsi::Value {
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  size_t count) -> jsi::Value {
     std::shared_ptr<LayoutAnimationsProxy> proxy = layoutProxy.lock();
     if (layoutProxy.expired()) {
       return jsi::Value::undefined();
@@ -186,8 +204,9 @@ void RuntimeDecorator::decorateUIRuntime(jsi::Runtime &rt,
     proxy->stopObserving(args[0].asNumber(), args[1].getBool());
     return jsi::Value::undefined();
   };
-  jsi::Value _stopObservingProgress = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "_stopObservingProgress"), 0, clb8);
+  jsi::Value _stopObservingProgress = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_stopObservingProgress"), 0, clb8);
   rt.global().setProperty(rt, "_stopObservingProgress", _stopObservingProgress);
 }
 
-}
+} // namespace reanimated

package/Common/cpp/Tools/Scheduler.cpp

@@ -1,7 +1,6 @@
 #include "Scheduler.h"
 
-namespace reanimated
-{
+namespace reanimated {
 
 void Scheduler::scheduleOnUI(std::function<void()> job) {
   uiJobs.push(std::move(job));
@@ -12,18 +11,27 @@ void Scheduler::scheduleOnJS(std::function<void()> job) {
 }
 
 void Scheduler::triggerUI() {
-  auto job = uiJobs.pop();
-  job();
+  scheduledOnUI = false;
+  while (uiJobs.getSize()) {
+    auto job = uiJobs.pop();
+    job();
+  }
 }
 
-void Scheduler::setJSCallInvoker(std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker) {
+void Scheduler::setJSCallInvoker(
+    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker) {
   jsCallInvoker_ = jsCallInvoker;
 }
 
-void Scheduler::setRuntimeManager(std::shared_ptr<RuntimeManager> runtimeManager) {
+void Scheduler::setRuntimeManager(
+    std::shared_ptr<RuntimeManager> runtimeManager) {
   this->runtimeManager = runtimeManager;
 }
 
 Scheduler::~Scheduler() {}
 
+Scheduler::Scheduler() {
+  this->scheduledOnUI = false;
 }
+
+} // namespace reanimated

package/Common/cpp/Tools/WorkletEventHandler.cpp

@@ -6,4 +6,4 @@ void WorkletEventHandler::process(jsi::Runtime &rt, jsi::Value &eventValue) {
   handler.callWithThis(rt, handler, eventValue);
 }
 
-}
+} // namespace reanimated

package/Common/cpp/headers/LayoutAnimations/LayoutAnimationsProxy.h

@@ -1,10 +1,10 @@
 #pragma once
 
+#include <jsi/jsi.h>
 #include <stdio.h>
-#include <memory>
 #include <functional>
 #include <map>
-#include <jsi/jsi.h>
+#include <memory>
 
 namespace reanimated {
 
@@ -13,19 +13,20 @@ using namespace facebook;
 class MutableValue;
 
 class LayoutAnimationsProxy {
-  
-public:
-  LayoutAnimationsProxy(std::function<void(int, jsi::Object newProps)> _notifyAboutProgress, std::function<void(int, bool)> _notifyAboutEnd);
-  
-  void startObserving(int tag, std::shared_ptr<MutableValue> sv, jsi::Runtime &rt);
+ public:
+  LayoutAnimationsProxy(
+      std::function<void(int, jsi::Object newProps)> _notifyAboutProgress,
+      std::function<void(int, bool)> _notifyAboutEnd);
+
+  void
+  startObserving(int tag, std::shared_ptr<MutableValue> sv, jsi::Runtime &rt);
   void stopObserving(int tag, bool finished);
   void notifyAboutCancellation(int tag);
-  
-private:
+
+ private:
   std::function<void(int, jsi::Object newProps)> notifyAboutProgress;
   std::function<void(int, bool)> notifyAboutEnd;
   std::map<int, std::shared_ptr<MutableValue>> observedValues;
 };
 
-}
-
+} // namespace reanimated