fix: Fix passing function inside object on Android (toCpp()) (#453)

* chore: Add test for JS-style object as params * Image specs * Impl * fix: Use `cthis()` for function conversions * fix: Use `getFunction()`
mrousavy · Dec 30, 2024 · 57336f4 · 57336f4
1 parent 3a6d46d
commit 57336f4
Show file tree

Hide file tree

Showing 35 changed files with 450 additions and 7 deletions.
diff --git a/example/src/getTests.ts b/example/src/getTests.ts
@@ -1002,6 +1002,21 @@ export function getTests(
         .didNotThrow()
         .equals({ age: 24, name: 'marc' })
     ),
+    createTest('jsStyleObjectAsParameters()', async () =>
+      (
+        await it(() =>
+          timeoutedPromise<number>((complete) => {
+            testObject.jsStyleObjectAsParameters({
+              value: 55,
+              onChanged: (num) => complete(num),
+            })
+          })
+        )
+      )
+        .didNotThrow()
+        .didReturn('number')
+        .equals(55)
+    ),
 
     // Hybrid Object Tests
     createTest('get self', () =>

diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinCxxBridgedType.ts b/packages/nitrogen/src/syntax/kotlin/KotlinCxxBridgedType.ts
@@ -620,8 +620,7 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             return parameterName
         }
       case 'struct':
-      case 'enum':
-      case 'function': {
+      case 'enum': {
         switch (language) {
           case 'c++':
             return `${parameterName}->toCpp()`
@@ -662,6 +661,14 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             return parameterName
         }
       }
+      case 'function': {
+        switch (language) {
+          case 'c++':
+            return `${parameterName}->cthis()->getFunction()`
+          default:
+            return parameterName
+        }
+      }
       case 'array-buffer': {
         switch (language) {
           case 'c++':

diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts b/packages/nitrogen/src/syntax/kotlin/KotlinFunction.ts
@@ -121,6 +121,11 @@ namespace ${cxxNamespace} {
       ${indent(callBody, '      ')}
     }
 
+  public:
+    inline const ${typename}& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
     static void registerNatives() {

diff --git a/...ative-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt b/...ative-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
@@ -230,6 +230,10 @@ class HybridTestObjectKotlin: HybridTestObjectSwiftKotlinSpec() {
         return car.driver
     }
 
+    override fun jsStyleObjectAsParameters(params: JsStyleStruct): Unit {
+        params.onChanged(params.value)
+    }
+
     override fun createArrayBuffer(): ArrayBuffer {
         return ArrayBuffer.allocate(1024 * 1024 * 10) // 10 MB
     }

diff --git a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp
@@ -380,6 +380,10 @@ std::optional<Person> HybridTestObjectCpp::getDriver(const Car& car) {
   }
 }
 
+void HybridTestObjectCpp::jsStyleObjectAsParameters(const JsStyleStruct& params) {
+  params.onChanged(params.value);
+}
+
 std::shared_ptr<ArrayBuffer> HybridTestObjectCpp::createArrayBuffer() {
   size_t size = 1024 * 1024 * 10; // 10MB
   uint8_t* buffer = new uint8_t[size];

diff --git a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp
@@ -127,6 +127,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   Car getCar() override;
   bool isCarElectric(const Car& car) override;
   std::optional<Person> getDriver(const Car& car) override;
+  void jsStyleObjectAsParameters(const JsStyleStruct& params) override;
   std::shared_ptr<ArrayBuffer> createArrayBuffer() override;
   double getBufferLastItem(const std::shared_ptr<ArrayBuffer>& buffer) override;
   void setAllValuesTo(const std::shared_ptr<ArrayBuffer>& buffer, double value) override;

diff --git a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
@@ -249,6 +249,10 @@ class HybridTestObjectSwift : HybridTestObjectSwiftKotlinSpec {
     return car.driver
   }
 
+  func jsStyleObjectAsParameters(params: JsStyleStruct) throws -> Void {
+    params.onChanged(params.value)
+  }
+
   func createArrayBuffer() throws -> ArrayBufferHolder {
     return .allocate(size: 1024 * 1024 * 10) // 10 MB
   }

diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/NitroImageOnLoad.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/NitroImageOnLoad.cpp
@@ -22,6 +22,7 @@
 #include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_double____.hpp"
 #include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer_____.hpp"
 #include "JFunc_std__shared_ptr_Promise_std__string__.hpp"
+#include "JFunc_void_double.hpp"
 #include "JHybridBaseSpec.hpp"
 #include "JHybridChildSpec.hpp"
 #include <NitroModules/JNISharedPtr.hpp>
@@ -53,6 +54,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::image::JFunc_std__shared_ptr_Promise_double__::registerNatives();
     margelo::nitro::image::JFunc_std__shared_ptr_Promise_std__string__::registerNatives();
     margelo::nitro::image::JFunc_void_std__string::registerNatives();
+    margelo::nitro::image::JFunc_void_double::registerNatives();
     margelo::nitro::image::JHybridBaseSpec::registerNatives();
     margelo::nitro::image::JHybridChildSpec::registerNatives();
 

diff --git a/...ive-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_double__.hpp b/...ive-nitro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_double__.hpp
@@ -45,6 +45,11 @@ namespace margelo::nitro::image {
       }();
     }
 
+  public:
+    inline const std::function<std::shared_ptr<Promise<double>>()>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_std__shared_ptr_Promise_double__;";
     static void registerNatives() {

diff --git a/...enerated/android/c++/JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_double____.hpp b/...enerated/android/c++/JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_double____.hpp
@@ -56,6 +56,11 @@ namespace margelo::nitro::image {
       }();
     }
 
+  public:
+    inline const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<double>>>>()>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_double____;";
     static void registerNatives() {

diff --git a/...Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer_____.hpp b/...Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer_____.hpp
@@ -59,6 +59,11 @@ namespace margelo::nitro::image {
       }();
     }
 
+  public:
+    inline const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>>()>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer_____;";
     static void registerNatives() {

diff --git a/...itro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__string__.hpp b/...itro-image/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__string__.hpp
@@ -46,6 +46,11 @@ namespace margelo::nitro::image {
       }();
     }
 
+  public:
+    inline const std::function<std::shared_ptr<Promise<std::string>>()>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_std__shared_ptr_Promise_std__string__;";
     static void registerNatives() {

diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void.hpp
@@ -31,6 +31,11 @@ namespace margelo::nitro::image {
       _func();
     }
 
+  public:
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_void;";
     static void registerNatives() {

diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_double.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_double.hpp
@@ -0,0 +1,53 @@
+///
+/// JFunc_void_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+
+namespace margelo::nitro::image {
+
+  using namespace facebook;
+
+  /**
+   * C++ representation of the callback Func_void_double.
+   * This is a Kotlin `(num: Double) -> Unit`, backed by a `std::function<...>`.
+   */
+  struct JFunc_void_double final: public jni::HybridClass<JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* num */)>& func) {
+      return JFunc_void_double::newObjectCxxArgs(func);
+    }
+
+  public:
+    void call(double num) {
+      _func(num);
+    }
+
+  public:
+    inline const std::function<void(double /* num */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_void_double;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("call", JFunc_void_double::call)});
+    }
+
+  private:
+    explicit JFunc_void_double(const std::function<void(double /* num */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* num */)> _func;
+  };
+
+} // namespace margelo::nitro::image
diff --git a/...ct-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__optional_double_.hpp b/...ct-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__optional_double_.hpp
@@ -32,6 +32,11 @@ namespace margelo::nitro::image {
       _func(maybe != nullptr ? std::make_optional(maybe->value()) : std::nullopt);
     }
 
+  public:
+    inline const std::function<void(std::optional<double> /* maybe */)>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_void_std__optional_double_;";
     static void registerNatives() {

diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__string.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__string.hpp
@@ -32,6 +32,11 @@ namespace margelo::nitro::image {
       _func(valueFromJs->toStdString());
     }
 
+  public:
+    inline const std::function<void(const std::string& /* valueFromJs */)>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_void_std__string;";
     static void registerNatives() {

diff --git a/...-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__vector_Powertrain_.hpp b/...-native-nitro-image/nitrogen/generated/android/c++/JFunc_void_std__vector_Powertrain_.hpp
@@ -43,6 +43,11 @@ namespace margelo::nitro::image {
             }());
     }
 
+  public:
+    inline const std::function<void(const std::vector<Powertrain>& /* array */)>& getFunction() const {
+      return _func;
+    }
+
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/Func_void_std__vector_Powertrain_;";
     static void registerNatives() {

diff --git a/...ct-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/...ct-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
@@ -25,6 +25,8 @@ namespace NitroModules { class ArrayBuffer; }
 namespace margelo::nitro::image { class HybridChildSpec; }
 // Forward declaration of `HybridBaseSpec` to properly resolve imports.
 namespace margelo::nitro::image { class HybridBaseSpec; }
+// Forward declaration of `JsStyleStruct` to properly resolve imports.
+namespace margelo::nitro::image { struct JsStyleStruct; }
 
 #include <memory>
 #include "HybridTestObjectSwiftKotlinSpec.hpp"
@@ -64,6 +66,9 @@ namespace margelo::nitro::image { class HybridBaseSpec; }
 #include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer_____.hpp"
 #include "JFunc_std__shared_ptr_Promise_std__string__.hpp"
 #include "JFunc_void_std__string.hpp"
+#include "JsStyleStruct.hpp"
+#include "JJsStyleStruct.hpp"
+#include "JFunc_void_double.hpp"
 
 namespace margelo::nitro::image {
 
@@ -617,6 +622,10 @@ namespace margelo::nitro::image {
     auto __result = method(_javaPart, JCar::fromCpp(car));
     return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
   }
+  void JHybridTestObjectSwiftKotlinSpec::jsStyleObjectAsParameters(const JsStyleStruct& params) {
+    static const auto method = _javaPart->getClass()->getMethod<void(jni::alias_ref<JJsStyleStruct> /* params */)>("jsStyleObjectAsParameters");
+    method(_javaPart, JJsStyleStruct::fromCpp(params));
+  }
   std::shared_ptr<ArrayBuffer> JHybridTestObjectSwiftKotlinSpec::createArrayBuffer() {
     static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JArrayBuffer::javaobject>()>("createArrayBuffer");
     auto __result = method(_javaPart);

diff --git a/...ct-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/...ct-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
@@ -111,6 +111,7 @@ namespace margelo::nitro::image {
     Car getCar() override;
     bool isCarElectric(const Car& car) override;
     std::optional<Person> getDriver(const Car& car) override;
+    void jsStyleObjectAsParameters(const JsStyleStruct& params) override;
     std::shared_ptr<ArrayBuffer> createArrayBuffer() override;
     double getBufferLastItem(const std::shared_ptr<ArrayBuffer>& buffer) override;
     void setAllValuesTo(const std::shared_ptr<ArrayBuffer>& buffer, double value) override;

diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JJsStyleStruct.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JJsStyleStruct.hpp
@@ -0,0 +1,57 @@
+///
+/// JJsStyleStruct.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "JsStyleStruct.hpp"
+
+#include "JFunc_void_double.hpp"
+#include <functional>
+
+namespace margelo::nitro::image {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "JsStyleStruct" and the the Kotlin data class "JsStyleStruct".
+   */
+  struct JJsStyleStruct final: public jni::JavaClass<JJsStyleStruct> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/JsStyleStruct;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct JsStyleStruct by copying all values to C++.
+     */
+    [[maybe_unused]]
+    JsStyleStruct toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldValue = clazz->getField<double>("value");
+      double value = this->getFieldValue(fieldValue);
+      static const auto fieldOnChanged = clazz->getField<JFunc_void_double::javaobject>("onChanged");
+      jni::local_ref<JFunc_void_double::javaobject> onChanged = this->getFieldValue(fieldOnChanged);
+      return JsStyleStruct(
+        value,
+        onChanged->cthis()->getFunction()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JJsStyleStruct::javaobject> fromCpp(const JsStyleStruct& value) {
+      return newInstance(
+        value.value,
+        JFunc_void_double::fromCpp(value.onChanged)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::image