react-native 0.69.1 → 0.70.0-rc.0

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

@@ -22,45 +22,18 @@ namespace react {
  * Public API to install the TurboModule system.
  */
 
-TurboModuleBinding::TurboModuleBinding(
-    const TurboModuleProviderFunctionType &&moduleProvider)
-    : moduleProvider_(std::move(moduleProvider)),
-      longLivedObjectCollection_(nullptr),
-      disableGlobalLongLivedObjectCollection_(false) {}
-
 TurboModuleBinding::TurboModuleBinding(
     const TurboModuleProviderFunctionType &&moduleProvider,
+    TurboModuleBindingMode bindingMode,
     std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection)
     : moduleProvider_(std::move(moduleProvider)),
-      longLivedObjectCollection_(longLivedObjectCollection),
-      disableGlobalLongLivedObjectCollection_(true) {}
-
-void TurboModuleBinding::install(
-    jsi::Runtime &runtime,
-    const TurboModuleProviderFunctionType &&moduleProvider) {
-  runtime.global().setProperty(
-      runtime,
-      "__turboModuleProxy",
-      jsi::Function::createFromHostFunction(
-          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,
-              const jsi::Value &thisVal,
-              const jsi::Value *args,
-              size_t count) {
-            return binding->jsProxy(rt, thisVal, args, count);
-          }));
-}
+      longLivedObjectCollection_(std::move(longLivedObjectCollection)),
+      bindingMode_(bindingMode) {}
 
 void TurboModuleBinding::install(
     jsi::Runtime &runtime,
     const TurboModuleProviderFunctionType &&moduleProvider,
+    TurboModuleBindingMode bindingMode,
     std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection) {
   runtime.global().setProperty(
       runtime,
@@ -69,42 +42,27 @@ void TurboModuleBinding::install(
           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)](
+          [binding = TurboModuleBinding(
+               std::move(moduleProvider),
+               bindingMode,
+               std::move(longLivedObjectCollection))](
               jsi::Runtime &rt,
               const jsi::Value &thisVal,
               const jsi::Value *args,
-              size_t count) {
-            return binding->jsProxy(rt, thisVal, args, count);
+              size_t count) mutable {
+            return binding.getModule(rt, thisVal, args, count);
           }));
 }
 
 TurboModuleBinding::~TurboModuleBinding() {
-  if (longLivedObjectCollection_ != nullptr) {
+  if (longLivedObjectCollection_) {
     longLivedObjectCollection_->clear();
-    return;
-  }
-
-  if (disableGlobalLongLivedObjectCollection_) {
-    return;
-  }
-
-  LongLivedObjectCollection::get().clear();
-}
-
-std::shared_ptr<TurboModule> TurboModuleBinding::getModule(
-    const std::string &name) {
-  std::shared_ptr<TurboModule> module = nullptr;
-  {
-    SystraceSection s("TurboModuleBinding::getModule", "module", name);
-    module = moduleProvider_(name);
+  } else {
+    LongLivedObjectCollection::get().clear();
   }
-  return module;
 }
 
-jsi::Value TurboModuleBinding::jsProxy(
+jsi::Value TurboModuleBinding::getModule(
     jsi::Runtime &runtime,
     const jsi::Value &thisVal,
     const jsi::Value *args,
@@ -114,14 +72,41 @@ jsi::Value TurboModuleBinding::jsProxy(
         "__turboModuleProxy must be called with at least 1 argument");
   }
   std::string moduleName = args[0].getString(runtime).utf8(runtime);
-  jsi::Value nullSchema = jsi::Value::undefined();
 
-  std::shared_ptr<TurboModule> module = getModule(moduleName);
-  if (module == nullptr) {
+  std::shared_ptr<TurboModule> module;
+  {
+    SystraceSection s(
+        "TurboModuleBinding::moduleProvider", "module", moduleName);
+    module = moduleProvider_(moduleName);
+  }
+  if (module) {
+    // Default behaviour
+    if (bindingMode_ == TurboModuleBindingMode::HostObject) {
+      return jsi::Object::createFromHostObject(runtime, std::move(module));
+    }
+
+    auto &jsRepresentation = module->jsRepresentation_;
+    if (!jsRepresentation) {
+      jsRepresentation = std::make_unique<jsi::Object>(runtime);
+      if (bindingMode_ == TurboModuleBindingMode::Prototype) {
+        // Option 1: create plain object, with it's prototype mapped back to the
+        // hostobject. Any properties accessed are stored on the plain object
+        auto hostObject =
+            jsi::Object::createFromHostObject(runtime, std::move(module));
+        jsRepresentation->setProperty(
+            runtime, "__proto__", std::move(hostObject));
+      } else {
+        // Option 2: eagerly install all hostfunctions at this point, avoids
+        // prototype
+        for (auto &propName : module->getPropertyNames(runtime)) {
+          module->get(runtime, propName);
+        }
+      }
+    }
+    return jsi::Value(runtime, *jsRepresentation);
+  } else {
     return jsi::Value::null();
   }
-
-  return jsi::Object::createFromHostObject(runtime, std::move(module));
 }
 
 } // namespace react

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

@@ -18,6 +18,12 @@ namespace react {
 
 class JSCallInvoker;
 
+enum class TurboModuleBindingMode : uint8_t {
+  HostObject = 0,
+  Prototype = 1,
+  Eager = 2,
+};
+
 /**
  * Represents the JavaScript binding for the TurboModule system.
  */
@@ -27,31 +33,24 @@ class TurboModuleBinding {
    * Installs TurboModuleBinding into JavaScript runtime.
    * Thread synchronization must be enforced externally.
    */
-  static void install(
-      jsi::Runtime &runtime,
-      const TurboModuleProviderFunctionType &&moduleProvider);
   static void install(
       jsi::Runtime &runtime,
       const TurboModuleProviderFunctionType &&moduleProvider,
+      TurboModuleBindingMode bindingMode,
       std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
 
-  TurboModuleBinding(const TurboModuleProviderFunctionType &&moduleProvider);
+ private:
   TurboModuleBinding(
       const TurboModuleProviderFunctionType &&moduleProvider,
+      TurboModuleBindingMode bindingMode,
       std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
   virtual ~TurboModuleBinding();
 
-  /**
-   * Get an TurboModule instance for the given module name.
-   */
-  std::shared_ptr<TurboModule> getModule(const std::string &name);
-
- private:
   /**
    * A lookup function exposed to JS to get an instance of a TurboModule
    * for the given name.
    */
-  jsi::Value jsProxy(
+  jsi::Value getModule(
       jsi::Runtime &runtime,
       const jsi::Value &thisVal,
       const jsi::Value *args,
@@ -59,7 +58,7 @@ class TurboModuleBinding {
 
   TurboModuleProviderFunctionType moduleProvider_;
   std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
-  bool disableGlobalLongLivedObjectCollection_;
+  TurboModuleBindingMode bindingMode_;
 };
 
 } // namespace react

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);