From 30bff4000c9c76d86d292df122e6fc0bb015c84d Mon Sep 17 00:00:00 2001 From: Bao Nguyen Date: Sat, 5 Sep 2026 15:05:57 +0700 Subject: [PATCH] fix(nitrogen): look up Kotlin callbacks with a boxed return type A generated `fun interface Func_X: (..) -> R` overrides `FunctionN.invoke`, whose return type is a generic, so kotlinc keeps the boxed type in the JVM signature. Parameters are specialized to primitives, return types are not. The generated JNI lookup used the primitive signature (`()D` for `() => number`), which does not exist on the class, so the first C++ call into a Kotlin-implemented callback that returns a value throws NoSuchMethodError. --- apps/example/src/getTests.ts | 8 ++++++ .../src/syntax/kotlin/KotlinFunction.ts | 26 +++++++++++++++++-- .../nitro/test/HybridTestObjectKotlin.kt | 4 +++ .../cpp/HybridTestObjectCpp.cpp | 4 +++ .../cpp/HybridTestObjectCpp.hpp | 1 + .../ios/HybridTestObjectSwift.swift | 4 +++ .../generated/android/NitroTestOnLoad.cpp | 4 +-- .../generated/android/c++/JFunc_double.hpp | 4 +-- .../c++/JHybridTestObjectSwiftKotlinSpec.cpp | 15 ++++++++++- .../c++/JHybridTestObjectSwiftKotlinSpec.hpp | 1 + .../test/HybridTestObjectSwiftKotlinSpec.kt | 9 +++++++ .../ios/NitroTest-Swift-Cxx-Bridge.hpp | 9 +++++++ .../HybridTestObjectSwiftKotlinSpecSwift.hpp | 8 ++++++ .../HybridTestObjectSwiftKotlinSpec.swift | 1 + .../HybridTestObjectSwiftKotlinSpec_cxx.swift | 15 +++++++++++ .../shared/c++/HybridTestObjectCppSpec.cpp | 1 + .../shared/c++/HybridTestObjectCppSpec.hpp | 1 + .../c++/HybridTestObjectSwiftKotlinSpec.cpp | 1 + .../c++/HybridTestObjectSwiftKotlinSpec.hpp | 1 + .../src/specs/TestObject.nitro.ts | 1 + 20 files changed, 111 insertions(+), 7 deletions(-) diff --git a/apps/example/src/getTests.ts b/apps/example/src/getTests.ts index 0c698e436..c60bedb34 100644 --- a/apps/example/src/getTests.ts +++ b/apps/example/src/getTests.ts @@ -2366,6 +2366,14 @@ export function getTests( .didNotThrow() .equals(55) ), + createTest('getSyncNumberCallback()() returns a number', () => + it(() => { + const callback = testObject.getSyncNumberCallback() + return callback() + }) + .didNotThrow() + .equals(55) + ), createTest('bounceExternalHybrid(...) works', () => it(() => { return testObject.bounceExternalHybrid(HybridSomeExternalObject) diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts b/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts index 352c5488c..515a8ee9f 100644 --- a/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts +++ b/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts @@ -4,9 +4,25 @@ import { includeHeader } from '../c++/includeNitroHeader.js' import { createFileMetadataString, isNotDuplicate } from '../helpers.js' import type { SourceFile } from '../SourceFile.js' import type { FunctionType } from '../types/FunctionType.js' +import type { Type } from '../types/Type.js' import { addJNINativeRegistration } from './JNINativeRegistrations.js' import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js' +/** + * Whether the JVM signature of the generated `fun interface`'s `invoke` boxes the + * given return type. `Unit` maps to `void`, every other primitive is boxed. + */ +function hasBoxedJvmReturnType(returnType: Type): boolean { + switch (returnType.kind) { + case 'number': + case 'boolean': + case 'int64': + return true + default: + return false + } +} + export function createKotlinFunction(functionType: FunctionType): SourceFile[] { const name = functionType.specializationName const packageName = NitroConfig.current.getAndroidPackage('java/kotlin') @@ -110,6 +126,9 @@ class ${name}_java(private val function: ${lambdaSignature}): ${name} { `${name}_cxx` ) const bridgedReturn = new KotlinCxxBridgedType(functionType.returnType) + // `invoke` overrides `FunctionN.invoke`, whose return type is a generic - so Kotlin + // boxes it. Parameters are unaffected, they are specialized to primitives. + const isReturnBoxed = hasBoxedJvmReturnType(functionType.returnType) const cxxNamespace = NitroConfig.current.getCxxNamespace('c++') const typename = functionType.getCode('c++') @@ -139,7 +158,10 @@ class ${name}_java(private val function: ${lambdaSignature}): ${name} { return bridge.parseFromCppToKotlin(p.escapedName, 'c++', false) }), ] - const jniSignature = `${bridgedReturn.asJniReferenceType('local')}(${functionType.parameters + const jniReturnType = isReturnBoxed + ? `jni::local_ref<${bridgedReturn.getTypeCode('c++', true)}>` + : bridgedReturn.asJniReferenceType('local') + const jniSignature = `${jniReturnType}(${functionType.parameters .map((p) => { const bridge = new KotlinCxxBridgedType(p) return `${bridge.asJniReferenceType('alias')} /* ${p.escapedName} */` @@ -164,7 +186,7 @@ return ${bridgedReturn.parseFromCppToKotlin('__result', 'c++')}; jniCallBody = ` static const auto method = javaClassStatic()->getMethod<${jniSignature}>("invoke"); auto __result = method(${jniParamsForward.join(', ')}); -return ${bridgedReturn.parseFromKotlinToCpp('__result', 'c++', false)}; +return ${bridgedReturn.parseFromKotlinToCpp('__result', 'c++', isReturnBoxed)}; `.trim() } diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt index 506f8a187..dcdc80f62 100644 --- a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt +++ b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt @@ -677,6 +677,10 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() { return value } + override fun getSyncNumberCallback(): () -> Double { + return { 55.0 } + } + override fun bounceExternalHybrid(externalObject: HybridSomeExternalObjectSpec): HybridSomeExternalObjectSpec { return externalObject } diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp index f15402b0d..f326fab3e 100644 --- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp +++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp @@ -829,6 +829,10 @@ double HybridTestObjectCpp::callbackSync(const std::function& callback return value; } +std::function HybridTestObjectCpp::getSyncNumberCallback() { + return []() -> double { return 55; }; +} + std::shared_ptr HybridTestObjectCpp::bounceExternalHybrid( const std::shared_ptr& externalObject) { return externalObject; diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp index b0eee53a6..8f06da931 100644 --- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp +++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp @@ -239,6 +239,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec { bool getIsViewBlue(const std::shared_ptr& view) override; double callbackSync(const std::function& callback) override; + std::function getSyncNumberCallback() override; std::shared_ptr bounceExternalHybrid(const std::shared_ptr& externalObject) override; diff --git a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift index 1c9b6fdd9..c6cd27970 100644 --- a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift +++ b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift @@ -645,6 +645,10 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec { return value } + func getSyncNumberCallback() throws -> () -> Double { + return { 55 } + } + func bounceExternalHybrid(externalObject: (any HybridSomeExternalObjectSpec)) throws -> ( any HybridSomeExternalObjectSpec ) { diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp index f539a0043..b79637bde 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTestOnLoad.cpp @@ -23,6 +23,7 @@ #include "JHybridTestObjectSwiftKotlinSpec.hpp" #include "JFunc_void_double.hpp" #include "JFunc_void.hpp" +#include "JFunc_double.hpp" #include "JFunc_void_std__vector_Powertrain_.hpp" #include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_void____.hpp" #include "JFunc_void_std__optional_double_.hpp" @@ -32,7 +33,6 @@ #include "JFunc_void_std__string.hpp" #include "JFunc_void_std__exception_ptr.hpp" #include "JFunc_std__shared_ptr_Promise_std__string__.hpp" -#include "JFunc_double.hpp" #include "JFunc_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec_.hpp" #include "JHybridTestViewSpec.hpp" #include "views/JHybridTestViewStateUpdater.hpp" @@ -109,6 +109,7 @@ void registerAllNatives() { margelo::nitro::test::JHybridTestObjectSwiftKotlinSpec::CxxPart::registerNatives(); margelo::nitro::test::JFunc_void_double_cxx::registerNatives(); margelo::nitro::test::JFunc_void_cxx::registerNatives(); + margelo::nitro::test::JFunc_double_cxx::registerNatives(); margelo::nitro::test::JFunc_void_std__vector_Powertrain__cxx::registerNatives(); margelo::nitro::test::JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____cxx::registerNatives(); margelo::nitro::test::JFunc_void_std__optional_double__cxx::registerNatives(); @@ -118,7 +119,6 @@ void registerAllNatives() { margelo::nitro::test::JFunc_void_std__string_cxx::registerNatives(); margelo::nitro::test::JFunc_void_std__exception_ptr_cxx::registerNatives(); margelo::nitro::test::JFunc_std__shared_ptr_Promise_std__string___cxx::registerNatives(); - margelo::nitro::test::JFunc_double_cxx::registerNatives(); margelo::nitro::test::JFunc_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec__cxx::registerNatives(); margelo::nitro::test::JHybridTestViewSpec::CxxPart::registerNatives(); margelo::nitro::test::views::JHybridTestViewStateUpdater::registerNatives(); diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JFunc_double.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JFunc_double.hpp index cb676366f..895cda07d 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JFunc_double.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JFunc_double.hpp @@ -30,9 +30,9 @@ namespace margelo::nitro::test { * Invokes the function this `JFunc_double` instance holds through JNI. */ double invoke() const { - static const auto method = javaClassStatic()->getMethod("invoke"); + static const auto method = javaClassStatic()->getMethod()>("invoke"); auto __result = method(self()); - return __result; + return __result->value(); } }; diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp index dd0e8131b..48089ffa2 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp @@ -113,6 +113,7 @@ namespace margelo::nitro::test { class HybridTestViewSpec; } #include "JVariant_HybridBaseSpec_OptionalWrapper.hpp" #include "JHybridBaseSpec.hpp" #include "JCoreTypesVariant.hpp" +#include "JFunc_double.hpp" #include #include #include "ExternalObjectStruct.hpp" @@ -135,7 +136,6 @@ namespace margelo::nitro::test { class HybridTestViewSpec; } #include "HardwareBufferFormat.hpp" #include "JHardwareBufferFormat.hpp" #include "JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp" -#include "JFunc_double.hpp" #include "HybridTestViewSpec.hpp" #include "JHybridTestViewSpec.hpp" #include "JFunc_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec_.hpp" @@ -1523,6 +1523,19 @@ namespace margelo::nitro::test { auto __result = method(_javaPart, JFunc_double_cxx::fromCpp(callback)); return __result; } + std::function JHybridTestObjectSwiftKotlinSpec::getSyncNumberCallback() { + static const auto method = _javaPart->javaClassStatic()->getMethod()>("getSyncNumberCallback_cxx"); + auto __result = method(_javaPart); + return [&]() -> std::function { + if (__result->isInstanceOf(JFunc_double_cxx::javaClassStatic())) [[likely]] { + auto downcast = jni::static_ref_cast(__result); + return downcast->cthis()->getFunction(); + } else { + auto __resultRef = jni::make_global(__result); + return JNICallable(std::move(__resultRef)); + } + }(); + } bool JHybridTestObjectSwiftKotlinSpec::getIsViewBlue(const std::shared_ptr& view) { static const auto method = _javaPart->javaClassStatic()->getMethod /* view */)>("getIsViewBlue"); auto __result = method(_javaPart, std::dynamic_pointer_cast(view)->getJavaPart()); diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp index db313a652..93eecf242 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp @@ -195,6 +195,7 @@ namespace margelo::nitro::test { std::shared_ptr bounceChildBase(const std::shared_ptr& child) override; std::shared_ptr castBase(const std::shared_ptr& base) override; double callbackSync(const std::function& callback) override; + std::function getSyncNumberCallback() override; bool getIsViewBlue(const std::shared_ptr& view) override; std::shared_ptr bounceExternalHybrid(const std::shared_ptr& externalObject) override; std::shared_ptr createInternalObject() override; diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt index 20fa4c213..5bbc5df74 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt +++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt @@ -660,6 +660,15 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() { return __result } + abstract fun getSyncNumberCallback(): () -> Double + + @DoNotStrip + @Keep + private fun getSyncNumberCallback_cxx(): Func_double { + val __result = getSyncNumberCallback() + return Func_double_java(__result) + } + @DoNotStrip @Keep abstract fun getIsViewBlue(view: HybridTestViewSpec): Boolean diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp index b53b23518..bfbc51372 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp @@ -2304,6 +2304,15 @@ namespace margelo::nitro::test::bridge::swift { return Result>::withError(error); } + // pragma MARK: Result> + using Result_std__function_double____ = Result>; + inline Result_std__function_double____ create_Result_std__function_double____(const std::function& value) noexcept { + return Result>::withValue(value); + } + inline Result_std__function_double____ create_Result_std__function_double____(const std::exception_ptr& error) noexcept { + return Result>::withError(error); + } + // pragma MARK: Result> using Result_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec__ = Result>; inline Result_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec__ create_Result_std__shared_ptr_margelo__nitro__test__external__HybridSomeExternalObjectSpec__(const std::shared_ptr& value) noexcept { diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp index 28cc1fb17..d7630388e 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp @@ -1074,6 +1074,14 @@ namespace margelo::nitro::test { auto __value = std::move(__result.value()); return __value; } + inline std::function getSyncNumberCallback() override { + auto __result = _swiftPart.getSyncNumberCallback(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } inline bool getIsViewBlue(const std::shared_ptr& view) override { auto __result = _swiftPart.getIsViewBlue(view); if (__result.hasError()) [[unlikely]] { diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift index 47d8a8d5e..531ca7561 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift @@ -137,6 +137,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject { func bounceChildBase(child: (any HybridChildSpec)) throws -> (any HybridBaseSpec) func castBase(base: (any HybridBaseSpec)) throws -> (any HybridChildSpec) func callbackSync(callback: @escaping () -> Double) throws -> Double + func getSyncNumberCallback() throws -> () -> Double func getIsViewBlue(view: (any HybridTestViewSpec)) throws -> Bool func bounceExternalHybrid(externalObject: (any HybridSomeExternalObjectSpec)) throws -> (any HybridSomeExternalObjectSpec) func createInternalObject() throws -> (any HybridSomeExternalObjectSpec) diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift index 3ccaecd96..cf84ec2ff 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift @@ -2871,6 +2871,21 @@ open class HybridTestObjectSwiftKotlinSpec_cxx { } } + @inline(__always) + public final func getSyncNumberCallback() -> bridge.Result_std__function_double____ { + do { + let __result = try self.__implementation.getSyncNumberCallback() + let __resultCpp = { () -> bridge.Func_double in + let __closureWrapper = Func_double(__result) + return bridge.create_Func_double(__closureWrapper.toUnsafe()) + }() + return bridge.create_Result_std__function_double____(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__function_double____(__exceptionPtr) + } + } + @inline(__always) public final func getIsViewBlue(view: bridge.std__shared_ptr_HybridTestViewSpec_) -> bridge.Result_bool_ { do { diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp index 8f5a54e2f..f0725eb39 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp @@ -164,6 +164,7 @@ namespace margelo::nitro::test { prototype.registerHybridMethod("bounceChildBase", &HybridTestObjectCppSpec::bounceChildBase); prototype.registerHybridMethod("castBase", &HybridTestObjectCppSpec::castBase); prototype.registerHybridMethod("callbackSync", &HybridTestObjectCppSpec::callbackSync); + prototype.registerHybridMethod("getSyncNumberCallback", &HybridTestObjectCppSpec::getSyncNumberCallback); prototype.registerHybridMethod("getIsViewBlue", &HybridTestObjectCppSpec::getIsViewBlue); prototype.registerHybridMethod("bounceExternalHybrid", &HybridTestObjectCppSpec::bounceExternalHybrid); prototype.registerHybridMethod("createInternalObject", &HybridTestObjectCppSpec::createInternalObject); diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp index e36bc5cdd..57f7c841e 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp @@ -273,6 +273,7 @@ namespace margelo::nitro::test { virtual std::shared_ptr bounceChildBase(const std::shared_ptr& child) = 0; virtual std::shared_ptr castBase(const std::shared_ptr& base) = 0; virtual double callbackSync(const std::function& callback) = 0; + virtual std::function getSyncNumberCallback() = 0; virtual bool getIsViewBlue(const std::shared_ptr& view) = 0; virtual std::shared_ptr bounceExternalHybrid(const std::shared_ptr& externalObject) = 0; virtual std::shared_ptr createInternalObject() = 0; diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp index 1d831d075..a683a85d4 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp @@ -156,6 +156,7 @@ namespace margelo::nitro::test { prototype.registerHybridMethod("bounceChildBase", &HybridTestObjectSwiftKotlinSpec::bounceChildBase); prototype.registerHybridMethod("castBase", &HybridTestObjectSwiftKotlinSpec::castBase); prototype.registerHybridMethod("callbackSync", &HybridTestObjectSwiftKotlinSpec::callbackSync); + prototype.registerHybridMethod("getSyncNumberCallback", &HybridTestObjectSwiftKotlinSpec::getSyncNumberCallback); prototype.registerHybridMethod("getIsViewBlue", &HybridTestObjectSwiftKotlinSpec::getIsViewBlue); prototype.registerHybridMethod("bounceExternalHybrid", &HybridTestObjectSwiftKotlinSpec::bounceExternalHybrid); prototype.registerHybridMethod("createInternalObject", &HybridTestObjectSwiftKotlinSpec::createInternalObject); diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp index 7f42afa41..5756c6f92 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp @@ -260,6 +260,7 @@ namespace margelo::nitro::test { virtual std::shared_ptr bounceChildBase(const std::shared_ptr& child) = 0; virtual std::shared_ptr castBase(const std::shared_ptr& base) = 0; virtual double callbackSync(const std::function& callback) = 0; + virtual std::function getSyncNumberCallback() = 0; virtual bool getIsViewBlue(const std::shared_ptr& view) = 0; virtual std::shared_ptr bounceExternalHybrid(const std::shared_ptr& externalObject) = 0; virtual std::shared_ptr createInternalObject() = 0; diff --git a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts index 0edc62156..100860123 100644 --- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts +++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts @@ -346,6 +346,7 @@ interface SharedTestObjectProps { // Sync funcs callbackSync(callback: Sync<() => number>): number + getSyncNumberCallback(): Sync<() => number> // Views getIsViewBlue(view: TestView): boolean