RuntimeDecorator: Correctly set global

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -61,37 +61,25 @@ NativeReanimatedModule::NativeReanimatedModule(std::shared_ptr<CallInvoker> jsIn
                                                std::unique_ptr<jsi::Runtime> rt,
                                                std::shared_ptr<ErrorHandler> errorHandler,
                                                std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)> propObtainer,
-                                               PlatformDepMethodsHolder platformDepMethodsHolder) : NativeReanimatedModuleSpec(jsInvoker),
-                                                  runtime(std::move(rt)),
+                                               PlatformDepMethodsHolder platformDepMethodsHolder) :
+                                                  NativeReanimatedModuleSpec(jsInvoker),
+                                                  RuntimeManager(std::move(rt), errorHandler, scheduler),
                                                   mapperRegistry(new MapperRegistry()),
                                                   eventHandlerRegistry(new EventHandlerRegistry()),
                                                   requestRender(platformDepMethodsHolder.requestRender),
-                                                  propObtainer(propObtainer),
-                                                  errorHandler(errorHandler),
-                                                  workletsCache(new WorkletsCache()),
-                                                  scheduler(scheduler)
+                                                  propObtainer(propObtainer)
 {
   auto requestAnimationFrame = [=](FrameCallback callback) {
     frameCallbacks.push_back(callback);
     maybeRequestRender();
   };
 
-  RuntimeDecorator::addNativeObjects(*runtime,
-                                     platformDepMethodsHolder.updaterFunction,
-                                     requestAnimationFrame,
-                                     platformDepMethodsHolder.scrollToFunction,
-                                     platformDepMethodsHolder.measuringFunction,
-                                     platformDepMethodsHolder.getCurrentTime);
-}
-
-bool NativeReanimatedModule::isUIRuntime(jsi::Runtime &rt)
-{
-  return runtime.get() == &rt;
-}
-
-bool NativeReanimatedModule::isHostRuntime(jsi::Runtime &rt)
-{
-  return !isUIRuntime(rt);
+  RuntimeDecorator::decorateUIRuntime(*runtime,
+                                      platformDepMethodsHolder.updaterFunction,
+                                      requestAnimationFrame,
+                                      platformDepMethodsHolder.scrollToFunction,
+                                      platformDepMethodsHolder.measuringFunction,
+                                      platformDepMethodsHolder.getCurrentTime);
 }
 
 void NativeReanimatedModule::installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter)

Common/cpp/SharedItems/FrozenObject.cpp

@@ -1,15 +1,16 @@
 #include "FrozenObject.h"
 #include "SharedParent.h"
 #include "ShareableValue.h"
+#include "RuntimeManager.h"
 
 namespace reanimated {
 
-FrozenObject::FrozenObject(jsi::Runtime &rt, const jsi::Object &object, NativeReanimatedModule *module) {
+FrozenObject::FrozenObject(jsi::Runtime &rt, const jsi::Object &object, RuntimeManager *runtimeManager) {
   auto propertyNames = object.getPropertyNames(rt);
   for (size_t i = 0, count = propertyNames.size(rt); i < count; i++) {
     auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt);
     std::string nameStr = propertyName.utf8(rt);
-    map[nameStr] = ShareableValue::adapt(rt, object.getProperty(rt, propertyName), module);
+    map[nameStr] = ShareableValue::adapt(rt, object.getProperty(rt, propertyName), runtimeManager);
     this->containsHostFunction |= map[nameStr]->containsHostFunction;
   }
 }

Common/cpp/SharedItems/MutableValue.cpp

@@ -1,28 +1,29 @@
 #include "MutableValue.h"
 #include "SharedParent.h"
 #include "ShareableValue.h"
-#include "NativeReanimatedModule.h"
+#include "RuntimeManager.h"
+#include "RuntimeDecorator.h"
 
 namespace reanimated {
 
 void MutableValue::setValue(jsi::Runtime &rt, const jsi::Value &newValue) {
   std::lock_guard<std::mutex> lock(readWriteMutex);
-  value = ShareableValue::adapt(rt, newValue, module);
-  
+  value = ShareableValue::adapt(rt, newValue, runtimeManager);
+
   std::shared_ptr<MutableValue> thiz = shared_from_this();
   auto notifyListeners = [thiz] () {
     for (auto listener : thiz->listeners) {
       listener.second();
     }
   };
-  
-  if (module->isUIRuntime(rt)) {
+
+  if (RuntimeDecorator::isWorkletRuntime(rt)) {
     notifyListeners();
   } else {
-    module->scheduler->scheduleOnUI([notifyListeners] {
+    runtimeManager->scheduler->scheduleOnUI([notifyListeners] {
       notifyListeners();
     });
-  } 
+  }
 }
 
 jsi::Value MutableValue::getValue(jsi::Runtime &rt) {
@@ -33,14 +34,14 @@ jsi::Value MutableValue::getValue(jsi::Runtime &rt) {
 void MutableValue::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &newValue) {
   auto propName = name.utf8(rt);
 
-  if (module->isHostRuntime(rt)) {
+  if (RuntimeDecorator::isReactRuntime(rt)) {
     if (propName == "value") {
-      auto shareable = ShareableValue::adapt(rt, newValue, module);
-      module->scheduler->scheduleOnUI([this, shareable] {
-        jsi::Runtime &rt = *this->module->runtime.get();
+      auto shareable = ShareableValue::adapt(rt, newValue, runtimeManager);
+      runtimeManager->scheduler->scheduleOnUI([this, shareable] {
+        jsi::Runtime &rt = *this->runtimeManager->runtime.get();
         auto setterProxy = jsi::Object::createFromHostObject(rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
         jsi::Value newValue = shareable->getValue(rt);
-        module->valueSetter->getValue(rt)
+        runtimeManager->valueSetter->getValue(rt)
           .asObject(rt)
           .asFunction(rt)
           .callWithThis(rt, setterProxy, newValue);
@@ -52,7 +53,7 @@ void MutableValue::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi:
   // UI thread
   if (propName == "value") {
     auto setterProxy = jsi::Object::createFromHostObject(rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
-    module->valueSetter->getValue(rt)
+    runtimeManager->valueSetter->getValue(rt)
       .asObject(rt)
       .asFunction(rt)
       .callWithThis(rt, setterProxy, newValue);
@@ -72,7 +73,7 @@ jsi::Value MutableValue::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
     return getValue(rt);
   }
 
-  if (module->isUIRuntime(rt)) {
+  if (RuntimeDecorator::isWorkletRuntime(rt)) {
     // _value and _animation should be accessed from UI only
     if (propName == "_value") {
       return getValue(rt);
@@ -94,8 +95,8 @@ std::vector<jsi::PropNameID> MutableValue::getPropertyNames(jsi::Runtime &rt) {
   return result;
 }
 
-MutableValue::MutableValue(jsi::Runtime &rt, const jsi::Value &initial, NativeReanimatedModule *module, std::shared_ptr<Scheduler> s):
-StoreUser(s), module(module), value(ShareableValue::adapt(rt, initial, module)) {
+MutableValue::MutableValue(jsi::Runtime &rt, const jsi::Value &initial, RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s):
+StoreUser(s), runtimeManager(runtimeManager), value(ShareableValue::adapt(rt, initial, runtimeManager)) {
 }
 
 unsigned long int MutableValue::addListener(unsigned long id, std::function<void ()> listener) {

Common/cpp/SharedItems/RemoteObject.cpp

@@ -1,6 +1,6 @@
 #include "RemoteObject.h"
 #include "SharedParent.h"
-#include "NativeReanimatedModule.h"
+#include "RuntimeDecorator.h"
 #include <jsi/jsi.h>
 
 using namespace facebook;
@@ -16,14 +16,14 @@ void RemoteObject::maybeInitializeOnUIRuntime(jsi::Runtime &rt) {
 }
 
 jsi::Value RemoteObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
-  if (module->isUIRuntime(rt)) {
+  if (RuntimeDecorator::isWorkletRuntime(rt)) {
     return backing.lock()->getObject(rt).getProperty(rt, name);
   }
   return jsi::Value::undefined();
 }
 
 void RemoteObject::set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value) {
-  if (module->isUIRuntime(rt)) {
+  if (RuntimeDecorator::isWorkletRuntime(rt)) {
     backing.lock()->getObject(rt).setProperty(rt, name, value);
   }
   // TODO: we should throw if trying to update remote from host runtime