react-native 0.0.0-16bb2ae4f → 0.0.0-18697adec

package/ReactCommon/logger/react_native_log.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "react_native_log.h"
+#include <glog/logging.h>
+
+static reactnativelogfunctype _reactnativelogfunc = NULL;
+
+void set_react_native_logfunc(reactnativelogfunctype newlogfunc) {
+  _reactnativelogfunc = newlogfunc;
+}
+void react_native_log_info(const char *message) {
+  _react_native_log(ReactNativeLogLevelInfo, message);
+}
+void react_native_log_warn(const char *message) {
+  _react_native_log(ReactNativeLogLevelWarning, message);
+}
+void react_native_log_error(const char *message) {
+  _react_native_log(ReactNativeLogLevelError, message);
+}
+void react_native_log_fatal(const char *message) {
+  _react_native_log(ReactNativeLogLevelFatal, message);
+}
+
+void _react_native_log(ReactNativeLogLevel level, const char *message) {
+  if (_reactnativelogfunc == NULL) {
+    _react_native_log_default(level, message);
+  } else {
+    _reactnativelogfunc(level, message);
+  }
+}
+
+void _react_native_log_default(ReactNativeLogLevel level, const char *message) {
+  switch (level) {
+    case ReactNativeLogLevelInfo:
+      LOG(INFO) << message;
+      break;
+    case ReactNativeLogLevelWarning:
+      LOG(WARNING) << message;
+      break;
+    case ReactNativeLogLevelError:
+      LOG(ERROR) << message;
+      break;
+    case ReactNativeLogLevelFatal:
+      LOG(FATAL) << message;
+      break;
+  }
+}

package/ReactCommon/logger/react_native_log.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+enum ReactNativeLogLevel {
+  ReactNativeLogLevelInfo = 1,
+  ReactNativeLogLevelWarning = 2,
+  ReactNativeLogLevelError = 3,
+  ReactNativeLogLevelFatal = 4
+};
+
+typedef void (*reactnativelogfunctype)(ReactNativeLogLevel, const char *);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+void set_react_native_logfunc(reactnativelogfunctype newlogfunc);
+
+void react_native_log_info(const char *text);
+void react_native_log_warn(const char *text);
+void react_native_log_error(const char *text);
+void react_native_log_fatal(const char *text);
+
+void _react_native_log(ReactNativeLogLevel level, const char *text);
+void _react_native_log_default(ReactNativeLogLevel level, const char *text);
+#ifdef __cplusplus
+}
+#endif // __cpusplus

package/ReactCommon/react/nativemodule/core/Android.mk

@@ -15,9 +15,9 @@ LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/ReactCommon/*.cpp) $(wildcard $(LOCA
 
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH) $(LOCAL_PATH)/platform/android/
 
-LOCAL_SHARED_LIBRARIES := libfbjni libfolly_json libreactnativejni libreact_debug
+LOCAL_SHARED_LIBRARIES := libfbjni libfolly_json libreactnativejni libreact_debug libjsi
 
-LOCAL_STATIC_LIBRARIES := libjsi libreactperflogger
+LOCAL_STATIC_LIBRARIES :=  libreactperflogger
 
 LOCAL_CFLAGS := \
   -DLOG_TAG=\"ReactNative\"

package/ReactCommon/react/nativemodule/core/ReactCommon/LongLivedObject.cpp

@@ -43,6 +43,7 @@ void LongLivedObjectCollection::clear() const {
 
 // LongLivedObject
 LongLivedObject::LongLivedObject() {}
+LongLivedObject::~LongLivedObject() {}
 
 void LongLivedObject::allowRelease() {
   LongLivedObjectCollection::get().remove(this);

package/ReactCommon/react/nativemodule/core/ReactCommon/LongLivedObject.h

@@ -26,10 +26,11 @@ namespace react {
  */
 class LongLivedObject {
  public:
-  void allowRelease();
+  virtual void allowRelease();
 
  protected:
   LongLivedObject();
+  virtual ~LongLivedObject();
 };
 
 /**
@@ -39,6 +40,7 @@ class LongLivedObjectCollection {
  public:
   static LongLivedObjectCollection &get();
 
+  LongLivedObjectCollection();
   LongLivedObjectCollection(LongLivedObjectCollection const &) = delete;
   void operator=(LongLivedObjectCollection const &) = delete;
 
@@ -47,7 +49,6 @@ class LongLivedObjectCollection {
   void clear() const;
 
  private:
-  LongLivedObjectCollection();
   mutable std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
   mutable std::mutex collectionMutex_;
 };

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.cpp

@@ -21,9 +21,19 @@ namespace react {
 /**
  * Public API to install the TurboModule system.
  */
+
 TurboModuleBinding::TurboModuleBinding(
     const TurboModuleProviderFunctionType &&moduleProvider)
-    : moduleProvider_(std::move(moduleProvider)) {}
+    : moduleProvider_(std::move(moduleProvider)),
+      longLivedObjectCollection_(nullptr),
+      disableGlobalLongLivedObjectCollection_(false) {}
+
+TurboModuleBinding::TurboModuleBinding(
+    const TurboModuleProviderFunctionType &&moduleProvider,
+    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection)
+    : moduleProvider_(std::move(moduleProvider)),
+      longLivedObjectCollection_(longLivedObjectCollection),
+      disableGlobalLongLivedObjectCollection_(true) {}
 
 void TurboModuleBinding::install(
     jsi::Runtime &runtime,
@@ -35,6 +45,9 @@ void TurboModuleBinding::install(
           runtime,
           jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
           1,
+
+          // Create a TurboModuleBinding that uses the global
+          // LongLivedObjectCollection
           [binding =
                std::make_shared<TurboModuleBinding>(std::move(moduleProvider))](
               jsi::Runtime &rt,
@@ -45,7 +58,39 @@ void TurboModuleBinding::install(
           }));
 }
 
+void TurboModuleBinding::install(
+    jsi::Runtime &runtime,
+    const TurboModuleProviderFunctionType &&moduleProvider,
+    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection) {
+  runtime.global().setProperty(
+      runtime,
+      "__turboModuleProxy",
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
+          1,
+          // Create a TurboModuleBinding that doesn't use the global
+          // LongLivedObjectCollection
+          [binding = std::make_shared<TurboModuleBinding>(
+               std::move(moduleProvider), longLivedObjectCollection)](
+              jsi::Runtime &rt,
+              const jsi::Value &thisVal,
+              const jsi::Value *args,
+              size_t count) {
+            return binding->jsProxy(rt, thisVal, args, count);
+          }));
+}
+
 TurboModuleBinding::~TurboModuleBinding() {
+  if (longLivedObjectCollection_ != nullptr) {
+    longLivedObjectCollection_->clear();
+    return;
+  }
+
+  if (disableGlobalLongLivedObjectCollection_) {
+    return;
+  }
+
   LongLivedObjectCollection::get().clear();
 }
 

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.h

@@ -9,6 +9,7 @@
 
 #include <string>
 
+#include <ReactCommon/LongLivedObject.h>
 #include <ReactCommon/TurboModule.h>
 #include <jsi/jsi.h>
 
@@ -29,8 +30,15 @@ class TurboModuleBinding {
   static void install(
       jsi::Runtime &runtime,
       const TurboModuleProviderFunctionType &&moduleProvider);
+  static void install(
+      jsi::Runtime &runtime,
+      const TurboModuleProviderFunctionType &&moduleProvider,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
 
   TurboModuleBinding(const TurboModuleProviderFunctionType &&moduleProvider);
+  TurboModuleBinding(
+      const TurboModuleProviderFunctionType &&moduleProvider,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
   virtual ~TurboModuleBinding();
 
   /**
@@ -50,6 +58,8 @@ class TurboModuleBinding {
       size_t count);
 
   TurboModuleProviderFunctionType moduleProvider_;
+  std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
+  bool disableGlobalLongLivedObjectCollection_;
 };
 
 } // namespace react

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleUtils.h

@@ -47,10 +47,25 @@ class CallbackWrapper : public LongLivedObject {
       jsi::Function &&callback,
       jsi::Runtime &runtime,
       std::shared_ptr<CallInvoker> jsInvoker)
-      : callback_(std::move(callback)),
+      : longLivedObjectCollection_(),
+        callback_(std::move(callback)),
         runtime_(runtime),
         jsInvoker_(std::move(jsInvoker)) {}
 
+  CallbackWrapper(
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : longLivedObjectCollection_(longLivedObjectCollection),
+        callback_(std::move(callback)),
+        runtime_(runtime),
+        jsInvoker_(std::move(jsInvoker)) {}
+
+  // Use a weak_ptr to avoid a retain cycle: LongLivedObjectCollection owns all
+  // CallbackWrappers. So, CallbackWrapper cannot own its
+  // LongLivedObjectCollection.
+  std::weak_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
   jsi::Function callback_;
   jsi::Runtime &runtime_;
   std::shared_ptr<CallInvoker> jsInvoker_;
@@ -66,6 +81,17 @@ class CallbackWrapper : public LongLivedObject {
     return wrapper;
   }
 
+  static std::weak_ptr<CallbackWrapper> createWeak(
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker) {
+    auto wrapper = std::shared_ptr<CallbackWrapper>(new CallbackWrapper(
+        longLivedObjectCollection, std::move(callback), runtime, jsInvoker));
+    longLivedObjectCollection->add(wrapper);
+    return wrapper;
+  }
+
   // Delete the enclosed jsi::Function
   void destroy() {
     allowRelease();
@@ -82,6 +108,16 @@ class CallbackWrapper : public LongLivedObject {
   CallInvoker &jsInvoker() {
     return *(jsInvoker_);
   }
+
+  void allowRelease() override {
+    if (auto longLivedObjectCollection = longLivedObjectCollection_.lock()) {
+      if (longLivedObjectCollection != nullptr) {
+        longLivedObjectCollection->remove(this);
+        return;
+      }
+    }
+    LongLivedObject::allowRelease();
+  }
 };
 
 class RAIICallbackWrapperDestroyer {

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -30,7 +30,8 @@ namespace react {
 JavaTurboModule::JavaTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(jni::make_global(params.instance)),
-      nativeInvoker_(params.nativeInvoker) {}
+      nativeInvoker_(params.nativeInvoker),
+      retainJSCallback_(params.retainJSCallback) {}
 
 JavaTurboModule::~JavaTurboModule() {
   /**
@@ -52,18 +53,15 @@ JavaTurboModule::~JavaTurboModule() {
   });
 }
 
-bool JavaTurboModule::useTurboModulesRAIICallbackManager_ = false;
-void JavaTurboModule::enableUseTurboModulesRAIICallbackManager(bool enable) {
-  JavaTurboModule::useTurboModulesRAIICallbackManager_ = enable;
-}
-
 namespace {
 jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
+    JSCallbackRetainer retainJSCallback,
     jsi::Function &&function,
     jsi::Runtime &rt,
     std::shared_ptr<CallInvoker> jsInvoker) {
-  auto weakWrapper =
-      react::CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
+  auto weakWrapper = retainJSCallback != nullptr
+      ? retainJSCallback(std::move(function), rt, jsInvoker)
+      : react::CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
 
   // This needs to be a shared_ptr because:
   // 1. It cannot be unique_ptr. std::function is copyable but unique_ptr is
@@ -72,9 +70,7 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
   // 3. It cannot be a value, because that would be deleted as soon as this
   // function returns.
   auto callbackWrapperOwner =
-      (JavaTurboModule::useTurboModulesRAIICallbackManager_
-           ? std::make_shared<RAIICallbackWrapperDestroyer>(weakWrapper)
-           : nullptr);
+      std::make_shared<RAIICallbackWrapperDestroyer>(weakWrapper);
 
   std::function<void(folly::dynamic)> fn =
       [weakWrapper, callbackWrapperOwner, wrapperWasCalled = false](
@@ -114,11 +110,7 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
                   (const jsi::Value *)result.data(),
                   result.size());
 
-              if (JavaTurboModule::useTurboModulesRAIICallbackManager_) {
-                callbackWrapperOwner.reset();
-              } else {
-                strongWrapper2->destroy();
-              }
+              callbackWrapperOwner.reset();
             });
 
         wrapperWasCalled = true;
@@ -262,7 +254,8 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
     const jsi::Value *args,
     size_t count,
     std::shared_ptr<CallInvoker> jsInvoker,
-    TurboModuleMethodValueKind valueKind) {
+    TurboModuleMethodValueKind valueKind,
+    JSCallbackRetainer retainJSCallback) {
   unsigned int expectedArgumentCount = valueKind == PromiseKind
       ? methodArgTypes.size() - 1
       : methodArgTypes.size();
@@ -397,7 +390,8 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
 
       jsi::Function fn = arg->getObject(rt).getFunction(rt);
       jarg->l = makeGlobalIfNecessary(
-          createJavaCallbackFromJSIFunction(std::move(fn), rt, jsInvoker)
+          createJavaCallbackFromJSIFunction(
+              retainJSCallback, std::move(fn), rt, jsInvoker)
               .release());
       continue;
     }
@@ -544,7 +538,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
       args,
       argCount,
       jsInvoker_,
-      valueKind);
+      valueKind,
+      retainJSCallback_);
 
   if (isMethodSync && valueKind != PromiseKind) {
     TMPL::syncMethodCallArgConversionEnd(moduleName, methodName);
@@ -755,7 +750,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
            methodID,
            moduleNameStr = name_,
            methodNameStr,
-           env](
+           env,
+           retainJSCallback = retainJSCallback_](
               jsi::Runtime &runtime,
               const jsi::Value &thisVal,
               const jsi::Value *promiseConstructorArgs,
@@ -772,10 +768,16 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                     runtime);
 
             auto resolve = createJavaCallbackFromJSIFunction(
-                               std::move(resolveJSIFn), runtime, jsInvoker_)
+                               retainJSCallback,
+                               std::move(resolveJSIFn),
+                               runtime,
+                               jsInvoker_)
                                .release();
             auto reject = createJavaCallbackFromJSIFunction(
-                              std::move(rejectJSIFn), runtime, jsInvoker_)
+                              retainJSCallback,
+                              std::move(rejectJSIFn),
+                              runtime,
+                              jsInvoker_)
                               .release();
 
             jclass jPromiseImpl =

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h

@@ -7,9 +7,11 @@
 
 #pragma once
 
+#include <functional>
 #include <string>
 #include <unordered_set>
 
+#include <ReactCommon/LongLivedObject.h>
 #include <ReactCommon/TurboModule.h>
 #include <ReactCommon/TurboModuleUtils.h>
 #include <fbjni/fbjni.h>
@@ -30,6 +32,11 @@ struct JTurboModule : jni::JavaClass<JTurboModule> {
       "Lcom/facebook/react/turbomodule/core/interfaces/TurboModule;";
 };
 
+using JSCallbackRetainer = std::function<std::weak_ptr<CallbackWrapper>(
+    jsi::Function &&callback,
+    jsi::Runtime &runtime,
+    std::shared_ptr<CallInvoker> jsInvoker)>;
+
 class JSI_EXPORT JavaTurboModule : public TurboModule {
  public:
   // TODO(T65603471): Should we unify this with a Fabric abstraction?
@@ -38,6 +45,7 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
     jni::alias_ref<JTurboModule> instance;
     std::shared_ptr<CallInvoker> jsInvoker;
     std::shared_ptr<CallInvoker> nativeInvoker;
+    JSCallbackRetainer retainJSCallback;
   };
 
   JavaTurboModule(const InitParams &params);
@@ -51,16 +59,10 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
       const jsi::Value *args,
       size_t argCount);
 
-  static void enableUseTurboModulesRAIICallbackManager(bool enable);
-
-  /**
-   * Experiments
-   */
-  static bool useTurboModulesRAIICallbackManager_;
-
  private:
   jni::global_ref<JTurboModule> instance_;
   std::shared_ptr<CallInvoker> nativeInvoker_;
+  JSCallbackRetainer retainJSCallback_;
 
   JNIArgs convertJSIArgsToJNIArgs(
       JNIEnv *env,
@@ -70,7 +72,8 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
       const jsi::Value *args,
       size_t count,
       std::shared_ptr<CallInvoker> jsInvoker,
-      TurboModuleMethodValueKind valueKind);
+      TurboModuleMethodValueKind valueKind,
+      JSCallbackRetainer retainJSCallbacks);
 };
 
 } // namespace react

package/ReactCommon/react/nativemodule/core/platform/ios/RCTTurboModule.h

@@ -29,6 +29,9 @@ namespace react {
 
 class Instance;
 
+typedef std::weak_ptr<CallbackWrapper> (
+    ^RCTRetainJSCallback)(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker);
+
 /**
  * ObjC++ specific TurboModule base class.
  */
@@ -41,6 +44,7 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
     std::shared_ptr<CallInvoker> jsInvoker;
     std::shared_ptr<CallInvoker> nativeInvoker;
     bool isSyncModule;
+    RCTRetainJSCallback retainJSCallback;
   };
 
   ObjCTurboModule(const InitParams &params);
@@ -63,6 +67,8 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
   // Does the NativeModule dispatch async methods to the JS thread?
   const bool isSyncModule_;
 
+  RCTRetainJSCallback retainJSCallback_;
+
   /**
    * TODO(ramanpreet):
    * Investigate an optimization that'll let us get rid of this NSMutableDictionary.
@@ -90,11 +96,7 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
       NSMutableArray *retainedObjectsForInvocation);
 
   using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
-  jsi::Value createPromise(
-      jsi::Runtime &runtime,
-      std::shared_ptr<react::CallInvoker> jsInvoker,
-      std::string methodName,
-      PromiseInvocationBlock invoke);
+  jsi::Value createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke);
 };
 
 } // namespace react