react-native 0.69.3 → 0.70.0-rc.2

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

@@ -14,6 +14,7 @@
 
 #include <ReactCommon/TurboModule.h>
 #include <ReactCommon/TurboModulePerfLogger.h>
+#include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/JSIDynamic.h>
 #include <react/debug/react_native_assert.h>
 #include <react/jni/NativeMap.h>
@@ -22,11 +23,11 @@
 
 #include "JavaTurboModule.h"
 
-namespace TMPL = facebook::react::TurboModulePerfLogger;
-
 namespace facebook {
 namespace react {
 
+namespace TMPL = TurboModulePerfLogger;
+
 JavaTurboModule::JavaTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(jni::make_global(params.instance)),
@@ -54,11 +55,18 @@ JavaTurboModule::~JavaTurboModule() {
 }
 
 namespace {
+
+struct JNIArgs {
+  JNIArgs(size_t count) : args_(count) {}
+  std::vector<jvalue> args_;
+  std::vector<jobject> globalRefs_;
+};
+
 jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
-    JSCallbackRetainer retainJSCallback,
+    const JSCallbackRetainer &retainJSCallback,
     jsi::Function &&function,
     jsi::Runtime &rt,
-    std::shared_ptr<CallInvoker> jsInvoker) {
+    const std::shared_ptr<CallInvoker> &jsInvoker) {
   auto weakWrapper = retainJSCallback != nullptr
       ? retainJSCallback(std::move(function), rt, jsInvoker)
       : react::CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
@@ -119,13 +127,6 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
   return JCxxCallbackImpl::newObjectCxxArgs(fn);
 }
 
-template <typename T>
-std::string to_string(T v) {
-  std::ostringstream stream;
-  stream << v;
-  return stream.str();
-}
-
 // This is used for generating short exception strings.
 std::string stringifyJSIValue(const jsi::Value &v, jsi::Runtime *rt = nullptr) {
   if (v.isUndefined()) {
@@ -141,7 +142,7 @@ std::string stringifyJSIValue(const jsi::Value &v, jsi::Runtime *rt = nullptr) {
   }
 
   if (v.isNumber()) {
-    return "a number (" + to_string(v.getNumber()) + ")";
+    return "a number (" + std::to_string(v.getNumber()) + ")";
   }
 
   if (v.isString()) {
@@ -162,7 +163,7 @@ class JavaTurboModuleArgumentConversionException : public std::runtime_error {
       const jsi::Value *arg,
       jsi::Runtime *rt)
       : std::runtime_error(
-            "Expected argument " + to_string(index) + " of method \"" +
+            "Expected argument " + std::to_string(index) + " of method \"" +
             methodName + "\" to be a " + expectedType + ", but got " +
             stringifyJSIValue(*arg, rt)) {}
 };
@@ -175,7 +176,7 @@ class JavaTurboModuleInvalidArgumentTypeException : public std::runtime_error {
       const std::string &methodName)
       : std::runtime_error(
             "Called method \"" + methodName + "\" with unsupported type " +
-            actualType + " at argument " + to_string(argIndex)) {}
+            actualType + " at argument " + std::to_string(argIndex)) {}
 };
 
 class JavaTurboModuleInvalidArgumentCountException : public std::runtime_error {
@@ -186,9 +187,9 @@ class JavaTurboModuleInvalidArgumentCountException : public std::runtime_error {
       int expectedArgCount)
       : std::runtime_error(
             "TurboModule method \"" + methodName + "\" called with " +
-            to_string(actualArgCount) +
+            std::to_string(actualArgCount) +
             " arguments (expected argument count: " +
-            to_string(expectedArgCount) + ").") {}
+            std::to_string(expectedArgCount) + ").") {}
 };
 
 /**
@@ -240,22 +241,20 @@ int32_t getUniqueId() {
   return counter++;
 }
 
-} // namespace
-
-// fnjni already does this conversion, but since we are using plain JNI, this
+// fbjni already does this conversion, but since we are using plain JNI, this
 // needs to be done again
 // TODO (axe) Reuse existing implementation as needed - the exist in
 // MethodInvoker.cpp
-JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
+JNIArgs convertJSIArgsToJNIArgs(
     JNIEnv *env,
     jsi::Runtime &rt,
-    std::string methodName,
-    std::vector<std::string> methodArgTypes,
+    const std::string &methodName,
+    const std::vector<std::string> &methodArgTypes,
     const jsi::Value *args,
     size_t count,
-    std::shared_ptr<CallInvoker> jsInvoker,
+    const std::shared_ptr<CallInvoker> &jsInvoker,
     TurboModuleMethodValueKind valueKind,
-    JSCallbackRetainer retainJSCallback) {
+    const JSCallbackRetainer &retainJSCallback) {
   unsigned int expectedArgumentCount = valueKind == PromiseKind
       ? methodArgTypes.size() - 1
       : methodArgTypes.size();
@@ -281,11 +280,8 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
     return obj;
   };
 
-  jclass booleanClass = nullptr;
-  jclass doubleClass = nullptr;
-
   for (unsigned int argIndex = 0; argIndex < count; argIndex += 1) {
-    std::string type = methodArgTypes.at(argIndex);
+    const std::string &type = methodArgTypes.at(argIndex);
 
     const jsi::Value *arg = &args[argIndex];
     jvalue *jarg = &jargs[argIndex];
@@ -295,7 +291,6 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
         throw JavaTurboModuleArgumentConversionException(
             "number", argIndex, methodName, arg, &rt);
       }
-
       jarg->d = arg->getNumber();
       continue;
     }
@@ -305,108 +300,64 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
         throw JavaTurboModuleArgumentConversionException(
             "boolean", argIndex, methodName, arg, &rt);
       }
-
       jarg->z = (jboolean)arg->getBool();
       continue;
     }
 
-    if (!(type == "Ljava/lang/Double;" || type == "Ljava/lang/Boolean;" ||
-          type == "Ljava/lang/String;" ||
-          type == "Lcom/facebook/react/bridge/ReadableArray;" ||
-          type == "Lcom/facebook/react/bridge/Callback;" ||
-          type == "Lcom/facebook/react/bridge/ReadableMap;")) {
-      throw JavaTurboModuleInvalidArgumentTypeException(
-          type, argIndex, methodName);
-    }
-
     if (arg->isNull() || arg->isUndefined()) {
       jarg->l = nullptr;
-      continue;
-    }
-
-    if (type == "Ljava/lang/Double;") {
+    } else if (type == "Ljava/lang/Double;") {
       if (!arg->isNumber()) {
         throw JavaTurboModuleArgumentConversionException(
             "number", argIndex, methodName, arg, &rt);
       }
-
-      if (doubleClass == nullptr) {
-        doubleClass = env->FindClass("java/lang/Double");
-      }
-
-      jmethodID doubleConstructor =
-          env->GetMethodID(doubleClass, "<init>", "(D)V");
       jarg->l = makeGlobalIfNecessary(
-          env->NewObject(doubleClass, doubleConstructor, arg->getNumber()));
-      continue;
-    }
-
-    if (type == "Ljava/lang/Boolean;") {
+          jni::JDouble::valueOf(arg->getNumber()).release());
+    } else if (type == "Ljava/lang/Boolean;") {
       if (!arg->isBool()) {
         throw JavaTurboModuleArgumentConversionException(
             "boolean", argIndex, methodName, arg, &rt);
       }
-
-      if (booleanClass == nullptr) {
-        booleanClass = env->FindClass("java/lang/Boolean");
-      }
-
-      jmethodID booleanConstructor =
-          env->GetMethodID(booleanClass, "<init>", "(Z)V");
       jarg->l = makeGlobalIfNecessary(
-          env->NewObject(booleanClass, booleanConstructor, arg->getBool()));
-      continue;
-    }
-
-    if (type == "Ljava/lang/String;") {
+          jni::JBoolean::valueOf(arg->getBool()).release());
+    } else if (type == "Ljava/lang/String;") {
       if (!arg->isString()) {
         throw JavaTurboModuleArgumentConversionException(
             "string", argIndex, methodName, arg, &rt);
       }
-
       jarg->l = makeGlobalIfNecessary(
           env->NewStringUTF(arg->getString(rt).utf8(rt).c_str()));
-      continue;
-    }
-
-    if (type == "Lcom/facebook/react/bridge/ReadableArray;") {
-      if (!(arg->isObject() && arg->getObject(rt).isArray(rt))) {
-        throw JavaTurboModuleArgumentConversionException(
-            "Array", argIndex, methodName, arg, &rt);
-      }
-
-      auto dynamicFromValue = jsi::dynamicFromValue(rt, *arg);
-      auto jParams =
-          ReadableNativeArray::newObjectCxxArgs(std::move(dynamicFromValue));
-      jarg->l = makeGlobalIfNecessary(jParams.release());
-      continue;
-    }
-
-    if (type == "Lcom/facebook/react/bridge/Callback;") {
+    } else if (type == "Lcom/facebook/react/bridge/Callback;") {
       if (!(arg->isObject() && arg->getObject(rt).isFunction(rt))) {
         throw JavaTurboModuleArgumentConversionException(
             "Function", argIndex, methodName, arg, &rt);
       }
-
       jsi::Function fn = arg->getObject(rt).getFunction(rt);
       jarg->l = makeGlobalIfNecessary(
           createJavaCallbackFromJSIFunction(
               retainJSCallback, std::move(fn), rt, jsInvoker)
               .release());
-      continue;
-    }
-
-    if (type == "Lcom/facebook/react/bridge/ReadableMap;") {
+    } else if (type == "Lcom/facebook/react/bridge/ReadableArray;") {
+      if (!(arg->isObject() && arg->getObject(rt).isArray(rt))) {
+        throw JavaTurboModuleArgumentConversionException(
+            "Array", argIndex, methodName, arg, &rt);
+      }
+      auto dynamicFromValue = jsi::dynamicFromValue(rt, *arg);
+      auto jParams =
+          ReadableNativeArray::newObjectCxxArgs(std::move(dynamicFromValue));
+      jarg->l = makeGlobalIfNecessary(jParams.release());
+    } else if (type == "Lcom/facebook/react/bridge/ReadableMap;") {
       if (!(arg->isObject())) {
         throw JavaTurboModuleArgumentConversionException(
             "Object", argIndex, methodName, arg, &rt);
       }
-
       auto dynamicFromValue = jsi::dynamicFromValue(rt, *arg);
       auto jParams =
           ReadableNativeMap::createWithContents(std::move(dynamicFromValue));
       jarg->l = makeGlobalIfNecessary(jParams.release());
-      continue;
+    } else {
+      throw JavaTurboModuleInvalidArgumentTypeException(
+          type, argIndex, methodName);
     }
   }
 
@@ -430,13 +381,16 @@ jsi::Value convertFromJMapToValue(JNIEnv *env, jsi::Runtime &rt, jobject arg) {
   return jsi::valueFromDynamic(rt, result->cthis()->consume());
 }
 
+} // namespace
+
 jsi::Value JavaTurboModule::invokeJavaMethod(
     jsi::Runtime &runtime,
     TurboModuleMethodValueKind valueKind,
     const std::string &methodNameStr,
     const std::string &methodSignature,
     const jsi::Value *args,
-    size_t argCount) {
+    size_t argCount,
+    jmethodID &methodID) {
   const char *methodName = methodNameStr.c_str();
   const char *moduleName = name_.c_str();
 
@@ -485,12 +439,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
    */
   jni::JniLocalScope scope(env, estimatedLocalRefCount);
 
-  jclass cls = env->GetObjectClass(instance);
-  jmethodID methodID =
-      env->GetMethodID(cls, methodName, methodSignature.c_str());
-
-  auto checkJNIErrorForMethodCall =
-      [methodName, moduleName, isMethodSync]() -> void {
+  auto checkJNIErrorForMethodCall = [&]() -> void {
     try {
       FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
     } catch (...) {
@@ -503,9 +452,14 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
     }
   };
 
-  // If the method signature doesn't match, show a redbox here instead of
-  // crashing later.
-  checkJNIErrorForMethodCall();
+  if (!methodID) {
+    jclass cls = env->GetObjectClass(instance);
+    methodID = env->GetMethodID(cls, methodName, methodSignature.c_str());
+
+    // If the method signature doesn't match, show a redbox here instead of
+    // crashing later.
+    checkJNIErrorForMethodCall();
+  }
 
   // TODO(T43933641): Refactor to remove this special-casing
   if (methodNameStr == "getConstants") {
@@ -555,81 +509,73 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
           methodSignature.substr(methodSignature.find_last_of(')') + 1);
       if (returnType == "Ljava/lang/Boolean;") {
         auto returnObject =
-            (jobject)env->CallObjectMethodA(instance, methodID, jargs.data());
+            env->CallObjectMethodA(instance, methodID, jargs.data());
         checkJNIErrorForMethodCall();
 
         TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
         TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
 
-        jsi::Value returnValue = jsi::Value::null();
-        if (returnObject != nullptr) {
-          jclass booleanClass = env->FindClass("java/lang/Boolean");
-          jmethodID booleanValueMethod =
-              env->GetMethodID(booleanClass, "booleanValue", "()Z");
-          bool returnBoolean =
-              (bool)env->CallBooleanMethod(returnObject, booleanValueMethod);
-          checkJNIErrorForMethodCall();
-          returnValue = jsi::Value(returnBoolean);
+        auto returnValue = jsi::Value::null();
+        if (returnObject) {
+          auto booleanObj = jni::adopt_local(
+              static_cast<jni::JBoolean::javaobject>(returnObject));
+          returnValue = jsi::Value(static_cast<bool>(booleanObj->value()));
         }
 
         TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
         TMPL::syncMethodCallEnd(moduleName, methodName);
         return returnValue;
-      }
-
-      bool returnBoolean =
-          (bool)env->CallBooleanMethodA(instance, methodID, jargs.data());
-      checkJNIErrorForMethodCall();
+      } else {
+        bool returnBoolean =
+            (bool)env->CallBooleanMethodA(instance, methodID, jargs.data());
+        checkJNIErrorForMethodCall();
 
-      TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
-      TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
+        TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
+        TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
 
-      jsi::Value returnValue = jsi::Value(returnBoolean);
+        jsi::Value returnValue = jsi::Value(returnBoolean);
 
-      TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
-      TMPL::syncMethodCallEnd(moduleName, methodName);
+        TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
+        TMPL::syncMethodCallEnd(moduleName, methodName);
 
-      return returnValue;
+        return returnValue;
+      }
     }
     case NumberKind: {
       std::string returnType =
           methodSignature.substr(methodSignature.find_last_of(')') + 1);
       if (returnType == "Ljava/lang/Double;") {
         auto returnObject =
-            (jobject)env->CallObjectMethodA(instance, methodID, jargs.data());
+            env->CallObjectMethodA(instance, methodID, jargs.data());
         checkJNIErrorForMethodCall();
 
         TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
         TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
 
-        jsi::Value returnValue = jsi::Value::null();
-        if (returnObject != nullptr) {
-          jclass doubleClass = env->FindClass("java/lang/Double");
-          jmethodID doubleValueMethod =
-              env->GetMethodID(doubleClass, "doubleValue", "()D");
-          double returnDouble =
-              (double)env->CallDoubleMethod(returnObject, doubleValueMethod);
-          checkJNIErrorForMethodCall();
-          returnValue = jsi::Value(returnDouble);
+        auto returnValue = jsi::Value::null();
+        if (returnObject) {
+          auto doubleObj = jni::adopt_local(
+              static_cast<jni::JDouble::javaobject>(returnObject));
+          returnValue = jsi::Value(doubleObj->value());
         }
 
         TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
         TMPL::syncMethodCallEnd(moduleName, methodName);
         return returnValue;
-      }
-
-      double returnDouble =
-          (double)env->CallDoubleMethodA(instance, methodID, jargs.data());
-      checkJNIErrorForMethodCall();
+      } else {
+        double returnDouble =
+            (double)env->CallDoubleMethodA(instance, methodID, jargs.data());
+        checkJNIErrorForMethodCall();
 
-      TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
-      TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
+        TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
+        TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
 
-      jsi::Value returnValue = jsi::Value(returnDouble);
+        jsi::Value returnValue = jsi::Value(returnDouble);
 
-      TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
-      TMPL::syncMethodCallEnd(moduleName, methodName);
-      return returnValue;
+        TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
+        TMPL::syncMethodCallEnd(moduleName, methodName);
+        return returnValue;
+      }
     }
     case StringKind: {
       auto returnString =
@@ -654,7 +600,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
     }
     case ObjectKind: {
       auto returnObject =
-          (jobject)env->CallObjectMethodA(instance, methodID, jargs.data());
+          env->CallObjectMethodA(instance, methodID, jargs.data());
       checkJNIErrorForMethodCall();
 
       TMPL::syncMethodCallExecutionEnd(moduleName, methodName);

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

@@ -11,22 +11,15 @@
 #include <string>
 #include <unordered_set>
 
-#include <ReactCommon/LongLivedObject.h>
+#include <ReactCommon/CallInvoker.h>
 #include <ReactCommon/TurboModule.h>
-#include <ReactCommon/TurboModuleUtils.h>
-#include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
+#include <react/bridging/CallbackWrapper.h>
 #include <react/jni/JCallback.h>
 
 namespace facebook {
 namespace react {
 
-struct JNIArgs {
-  JNIArgs(size_t count) : args_(count) {}
-  std::vector<jvalue> args_;
-  std::vector<jobject> globalRefs_;
-};
-
 struct JTurboModule : jni::JavaClass<JTurboModule> {
   static auto constexpr kJavaDescriptor =
       "Lcom/facebook/react/turbomodule/core/interfaces/TurboModule;";
@@ -35,7 +28,7 @@ struct JTurboModule : jni::JavaClass<JTurboModule> {
 using JSCallbackRetainer = std::function<std::weak_ptr<CallbackWrapper>(
     jsi::Function &&callback,
     jsi::Runtime &runtime,
-    std::shared_ptr<CallInvoker> jsInvoker)>;
+    const std::shared_ptr<CallInvoker> &jsInvoker)>;
 
 class JSI_EXPORT JavaTurboModule : public TurboModule {
  public:
@@ -57,23 +50,13 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
       const std::string &methodName,
       const std::string &methodSignature,
       const jsi::Value *args,
-      size_t argCount);
+      size_t argCount,
+      jmethodID &cachedMethodID);
 
  private:
   jni::global_ref<JTurboModule> instance_;
   std::shared_ptr<CallInvoker> nativeInvoker_;
   JSCallbackRetainer retainJSCallback_;
-
-  JNIArgs convertJSIArgsToJNIArgs(
-      JNIEnv *env,
-      jsi::Runtime &rt,
-      std::string methodName,
-      std::vector<std::string> methodArgTypes,
-      const jsi::Value *args,
-      size_t count,
-      std::shared_ptr<CallInvoker> jsInvoker,
-      TurboModuleMethodValueKind valueKind,
-      JSCallbackRetainer retainJSCallbacks);
 };
 
 } // namespace react

package/ReactCommon/react/nativemodule/core/platform/ios/RCTTurboModuleManager.mm

@@ -777,12 +777,14 @@ static Class getFallbackClassFromName(const char *name)
   if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScope ||
       RCTGetTurboModuleCleanupMode() == kRCTGlobalScopeUsingRetainJSCallback) {
     runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider)](jsi::Runtime &runtime) {
-      react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider));
+      react::TurboModuleBinding::install(
+          runtime, std::move(turboModuleProvider), TurboModuleBindingMode::HostObject, nullptr);
     });
   } else if (RCTGetTurboModuleCleanupMode() == kRCTTurboModuleManagerScope) {
     runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider),
                      longLivedObjectCollection = _longLivedObjectCollection](jsi::Runtime &runtime) {
-      react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider), longLivedObjectCollection);
+      react::TurboModuleBinding::install(
+          runtime, std::move(turboModuleProvider), TurboModuleBindingMode::HostObject, longLivedObjectCollection);
     });
   }
 }

package/ReactCommon/react/nativemodule/samples/BUCK

@@ -81,6 +81,7 @@ rn_android_library(
     name = "impl",
     srcs = glob(["platform/android/*.java"]),
     autoglob = False,
+    language = "JAVA",
     required_for_source_only_abi = True,
     visibility = [
         "PUBLIC",

package/ReactCommon/react/nativemodule/samples/platform/android/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(-fexceptions -frtti -std=c++17 -Wall -DLOG_TAG=\"ReactNative\")
+
+file(GLOB sampleturbomodule_SRC CONFIGURE_DEPENDS ReactCommon/*.cpp)
+add_library(sampleturbomodule STATIC ${sampleturbomodule_SRC})
+
+target_include_directories(sampleturbomodule PUBLIC .)
+
+target_link_libraries(sampleturbomodule
+        fbjni
+        jsi
+        react_nativemodule_core)