@padosoft/react-native-ecr17 0.0.0

package/cpp/tests/test_session.cpp

@@ -0,0 +1,262 @@
+// Orchestration tests for Ecr17Session driven by the in-memory FakeTransport:
+// ACK/NAK handshake, retransmission, timeouts, LRC-failure NAK, and progress /
+// receipt forwarding. Timeouts are tiny so the suite stays fast.
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "PacketCodec/PacketCodec.hpp"
+#include "Session/Ecr17Session.hpp"
+#include "Transport/FakeTransport.hpp"
+
+using namespace margelo::nitro::ecr17;
+
+namespace {
+
+SessionConfig fastConfig() {
+    SessionConfig c;
+    c.lrcMode = LrcMode::STD;
+    c.ackTimeoutMs = 40;
+    c.responseTimeoutMs = 40;
+    c.retryCount = 2;
+    c.retryDelayMs = 1;
+    return c;
+}
+
+void append(std::vector<uint8_t>& a, const std::vector<uint8_t>& b) {
+    a.insert(a.end(), b.begin(), b.end());
+}
+
+std::vector<uint8_t> progressFrame(const std::string& msg20) {
+    std::vector<uint8_t> f{0x01};  // SOH
+    f.insert(f.end(), msg20.begin(), msg20.end());
+    f.push_back(0x04);  // EOT
+    return f;
+}
+
+const std::string kResultPayload = "123456780E0000DATA";   // code 'E' at pos 10 -> result
+const std::string kReceiptPayload = "123456780SLINE 1";    // code 'S' at pos 10 -> receipt
+
+}  // namespace
+
+TEST(Session, HappyPathReturnsResultAndAcks) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> response = codec.encodeControl(PacketCodec::ACK);
+    append(response, codec.encodeApplication(kResultPayload));
+    t.enqueueResponse(response);
+
+    Ecr17Session session(t, fastConfig());
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.type, PacketType::APPLICATION);
+    EXPECT_TRUE(result.validLrc);
+    EXPECT_EQ(result.payload, kResultPayload);
+    EXPECT_EQ(t.applicationRequestCount(), 1u);
+
+    // The session must have ACKed the received result frame.
+    bool sentAck = false;
+    for (const auto& f : t.sentFrames()) {
+        if (!f.empty() && f.front() == PacketCodec::ACK) sentAck = true;
+    }
+    EXPECT_TRUE(sentAck);
+}
+
+TEST(Session, NakTriggersRetransmitThenSucceeds) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    t.enqueueResponse(codec.encodeControl(PacketCodec::NAK));  // reply to attempt 1
+    std::vector<uint8_t> ok = codec.encodeControl(PacketCodec::ACK);
+    append(ok, codec.encodeApplication(kResultPayload));
+    t.enqueueResponse(ok);  // reply to retransmit
+
+    Ecr17Session session(t, fastConfig());
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.payload, kResultPayload);
+    EXPECT_EQ(t.applicationRequestCount(), 2u);  // initial + 1 retransmit
+}
+
+TEST(Session, AckTimeoutExhaustsRetriesThenThrows) {
+    FakeTransport t;  // no responses queued
+    Ecr17Session session(t, fastConfig());
+    EXPECT_THROW(session.exchange("123456780P..."), std::runtime_error);
+    // initial + retryCount retransmissions
+    EXPECT_EQ(t.applicationRequestCount(), 3u);
+}
+
+TEST(Session, BadLrcResponseSendsNak) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> response = codec.encodeControl(PacketCodec::ACK);
+    auto bad = codec.encodeApplication(kResultPayload);
+    bad.back() ^= 0xFF;  // corrupt LRC
+    append(response, bad);
+    t.enqueueResponse(response);
+
+    Ecr17Session session(t, fastConfig());
+    EXPECT_THROW(session.exchange("123456780P..."), std::runtime_error);  // no valid result
+
+    bool sentNak = false;
+    for (const auto& f : t.sentFrames()) {
+        if (!f.empty() && f.front() == PacketCodec::NAK) sentNak = true;
+    }
+    EXPECT_TRUE(sentNak);
+}
+
+TEST(Session, ProgressMessagesForwarded) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> response = codec.encodeControl(PacketCodec::ACK);
+    append(response, progressFrame("ATTENDERE PREGO     "));
+    append(response, codec.encodeApplication(kResultPayload));
+    t.enqueueResponse(response);
+
+    std::vector<std::string> progress;
+    Ecr17Session session(t, fastConfig());
+    session.setOnProgress([&](const std::string& m) { progress.push_back(m); });
+
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.payload, kResultPayload);
+    ASSERT_EQ(progress.size(), 1u);
+    EXPECT_EQ(progress[0], "ATTENDERE PREGO     ");
+}
+
+TEST(Session, ReceiptLinesForwardedBeforeResult) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> response = codec.encodeControl(PacketCodec::ACK);
+    append(response, codec.encodeApplication(kReceiptPayload));
+    append(response, codec.encodeApplication(kResultPayload));
+    t.enqueueResponse(response);
+
+    std::vector<std::string> receipts;
+    Ecr17Session session(t, fastConfig());
+    session.setOnReceiptLine([&](const std::string& l) { receipts.push_back(l); });
+
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.payload, kResultPayload);
+    ASSERT_EQ(receipts.size(), 1u);
+    EXPECT_EQ(receipts[0], kReceiptPayload);
+}
+
+// Regression: some terminals send the application RESULT before (or instead of)
+// the physical ACK. The handshake must not discard that frame — losing the
+// result of a completed financial transaction is the worst failure mode.
+TEST(Session, ResultBeforeAckIsNotLost) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    t.enqueueResponse(codec.encodeApplication(kResultPayload));  // result, no leading ACK
+
+    Ecr17Session session(t, fastConfig());
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.type, PacketType::APPLICATION);
+    EXPECT_EQ(result.payload, kResultPayload);
+    EXPECT_EQ(t.applicationRequestCount(), 1u);  // no spurious retransmit
+
+    // The accepted result must still be ACKed back to the terminal.
+    bool sentAck = false;
+    for (const auto& f : t.sentFrames()) {
+        if (!f.empty() && f.front() == PacketCodec::ACK) sentAck = true;
+    }
+    EXPECT_TRUE(sentAck);
+}
+
+TEST(Session, ResponseTimeoutAfterAckThrows) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    t.enqueueResponse(codec.encodeControl(PacketCodec::ACK));  // ACK only, no result
+
+    Ecr17Session session(t, fastConfig());
+    EXPECT_THROW(session.exchange("123456780P..."), std::runtime_error);
+}
+
+TEST(Session, DisconnectDuringExchangeThrows) {
+    FakeTransport t;
+    t.disconnectOnNextRequest();
+    Ecr17Session session(t, fastConfig());
+    EXPECT_THROW(session.exchange("123456780P..."), std::runtime_error);
+}
+
+// Scenario: the connection drops mid-exchange, then the client reconnects and
+// retries (the auto-reconnect path for safe commands). The session must recover
+// — it must NOT stay stuck in the disconnected state after a drop.
+TEST(Session, RecoversAndSucceedsAfterReconnect) {
+    FakeTransport t;
+    t.disconnectOnNextRequest();
+    Ecr17Session session(t, fastConfig());
+
+    // First attempt drops.
+    EXPECT_THROW(session.exchange("123456780P..."), std::runtime_error);
+
+    // Client reconnects the transport and the next transaction must work.
+    t.rearm();
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> ok = codec.encodeControl(PacketCodec::ACK);
+    append(ok, codec.encodeApplication(kResultPayload));
+    t.enqueueResponse(ok);
+
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.type, PacketType::APPLICATION);
+    EXPECT_EQ(result.payload, kResultPayload);
+}
+
+TEST(Session, SendAckOnlyReturnsOnAck) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    t.enqueueResponse(codec.encodeControl(PacketCodec::ACK));  // ACK, no app result
+    Ecr17Session session(t, fastConfig());
+    EXPECT_NO_THROW(session.sendAckOnly("123456780E1"));
+    EXPECT_EQ(t.applicationRequestCount(), 1u);
+}
+
+TEST(Session, SendAckOnlyRetransmitsOnNak) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    t.enqueueResponse(codec.encodeControl(PacketCodec::NAK));
+    t.enqueueResponse(codec.encodeControl(PacketCodec::ACK));
+    Ecr17Session session(t, fastConfig());
+    EXPECT_NO_THROW(session.sendAckOnly("123456780E0"));
+    EXPECT_EQ(t.applicationRequestCount(), 2u);
+}
+
+TEST(Session, SendAckOnlyTimesOut) {
+    FakeTransport t;  // no ACK
+    Ecr17Session session(t, fastConfig());
+    EXPECT_THROW(session.sendAckOnly("123456780E1"), std::runtime_error);
+}
+
+TEST(Session, ExchangeWithAdditionalDataSendsTwoRequests) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    t.enqueueResponse(codec.encodeControl(PacketCodec::ACK));  // ACK for the main 'P'
+    std::vector<uint8_t> ok = codec.encodeControl(PacketCodec::ACK);
+    append(ok, codec.encodeApplication(kResultPayload));
+    t.enqueueResponse(ok);  // ACK for 'U' + the result
+
+    Ecr17Session session(t, fastConfig());
+    DecodedPacket result = session.exchangeWithAdditionalData("123456780P...", "123456780U...");
+    EXPECT_EQ(result.payload, kResultPayload);
+    EXPECT_EQ(t.applicationRequestCount(), 2u);  // P + U
+}
+
+TEST(Session, ReceiptDrainForwardsReceiptsAfterResult) {
+    FakeTransport t;
+    PacketCodec codec(LrcMode::STD);
+    std::vector<uint8_t> response = codec.encodeControl(PacketCodec::ACK);
+    append(response, codec.encodeApplication(kResultPayload));   // result first
+    append(response, codec.encodeApplication(kReceiptPayload));  // then a receipt line
+    t.enqueueResponse(response);
+
+    SessionConfig cfg = fastConfig();
+    cfg.receiptDrainMs = 30;  // drain receipts that follow the result
+    std::vector<std::string> receipts;
+    Ecr17Session session(t, cfg);
+    session.setOnReceiptLine([&](const std::string& l) { receipts.push_back(l); });
+
+    DecodedPacket result = session.exchange("123456780P...");
+    EXPECT_EQ(result.payload, kResultPayload);
+    ASSERT_EQ(receipts.size(), 1u);
+    EXPECT_EQ(receipts[0], kReceiptPayload);
+}

package/ios/Bridge.h

@@ -0,0 +1 @@
+#pragma once

package/ios/HybridEcr17Transport.swift

@@ -0,0 +1,103 @@
+import Foundation
+import Network
+import NitroModules
+
+/// iOS (Swift) implementation of the ECR17 LAN transport, using Network.framework.
+///
+/// NOTE: there is no iOS CI runner in this project yet, so this file is
+/// best-effort and must be verified by an actual iOS build (the ArrayBuffer <->
+/// Data bridging in particular). The Android (Kotlin) transport is the
+/// CI-verified reference implementation; this mirrors its behaviour.
+final class HybridEcr17Transport: HybridEcr17TransportSpec {
+    private var connection: NWConnection?
+    private let queue = DispatchQueue(label: "com.ecr17.transport")
+    private var onData: ((ArrayBuffer) -> Void)?
+    private var onDisconnect: (() -> Void)?
+
+    func connect(host: String, port: Double, timeoutMs: Double) throws -> Promise<Void> {
+        let promise = Promise<Void>()
+        let endpointPort =
+            NWEndpoint.Port(rawValue: UInt16(port)) ?? NWEndpoint.Port(integerLiteral: 10000)
+        let conn = NWConnection(host: NWEndpoint.Host(host), port: endpointPort, using: .tcp)
+        connection = conn
+
+        var settled = false
+        conn.stateUpdateHandler = { [weak self] state in
+            switch state {
+            case .ready:
+                if !settled {
+                    settled = true
+                    promise.resolve(withResult: ())
+                }
+                self?.receiveLoop(conn)
+            case .failed(let error):
+                if !settled {
+                    settled = true
+                    promise.reject(withError: error)
+                }
+                self?.onDisconnect?()
+            case .cancelled:
+                self?.onDisconnect?()
+            default:
+                break
+            }
+        }
+        conn.start(queue: queue)
+        return promise
+    }
+
+    private func receiveLoop(_ conn: NWConnection) {
+        conn.receive(minimumIncompleteLength: 1, maximumLength: 4096) {
+            [weak self] data, _, isComplete, error in
+            guard let self = self else { return }
+            if let data = data, !data.isEmpty {
+                self.onData?(HybridEcr17Transport.toArrayBuffer(data))
+            }
+            if error == nil && !isComplete {
+                self.receiveLoop(conn)
+            } else {
+                self.onDisconnect?()
+            }
+        }
+    }
+
+    func disconnect() throws {
+        connection?.cancel()
+        connection = nil
+    }
+
+    func isConnected() throws -> Bool {
+        // Used by the C++ client as a PRE-SEND liveness check so a command starts on
+        // a verified-live socket (the Android transport probes the socket here). With
+        // Network.framework the connection transitions to .failed/.cancelled when the
+        // peer closes, so `.ready` is the closest equivalent. NOTE: state updates are
+        // delivered asynchronously on `queue`, so a peer close observed between
+        // transactions may take a moment to flip the state — a small residual race
+        // not present on Android. Best-effort (no iOS CI); verify on a real build.
+        return connection?.state == .ready
+    }
+
+    func send(bytes: ArrayBuffer) throws {
+        let data = HybridEcr17Transport.toData(bytes)
+        connection?.send(content: data, completion: .contentProcessed { _ in })
+    }
+
+    func setOnData(callback: @escaping (_ bytes: ArrayBuffer) -> Void) throws {
+        onData = callback
+    }
+
+    func setOnDisconnect(callback: @escaping () -> Void) throws {
+        onDisconnect = callback
+    }
+
+    // MARK: - ArrayBuffer <-> Data (verify on a real iOS build)
+    private static func toData(_ buffer: ArrayBuffer) -> Data {
+        return Data(bytes: buffer.data, count: buffer.size)
+    }
+
+    private static func toArrayBuffer(_ data: Data) -> ArrayBuffer {
+        let buffer = ArrayBuffer.allocate(size: data.count)
+        data.copyBytes(to: buffer.data, count: data.count)
+        return buffer
+    }
+}

package/nitro.json

@@ -0,0 +1,30 @@
+{
+	"$schema": "https://nitro.margelo.com/nitro.schema.json",
+	"cxxNamespace": ["ecr17"],
+	"ios": {
+		"iosModuleName": "Ecr17"
+	},
+	"android": {
+		"androidNamespace": ["ecr17"],
+		"androidCxxLibName": "Ecr17"
+	},
+	"autolinking": {
+		"Ecr17Client": {
+			"all": {
+				"language": "c++",
+				"implementationClassName": "HybridEcr17Client"
+			}
+		},
+		"Ecr17Transport": {
+			"ios": {
+				"language": "swift",
+				"implementationClassName": "HybridEcr17Transport"
+			},
+			"android": {
+				"language": "kotlin",
+				"implementationClassName": "HybridEcr17Transport"
+			}
+		}
+	},
+	"ignorePaths": ["**/node_modules"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/Ecr17+autolinking.cmake

@@ -0,0 +1,82 @@
+#
+# Ecr17+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/Ecr17+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_ECR17_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  Ecr17 PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/Ecr17OnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridEcr17ClientSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridEcr17TransportSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridEcr17TransportSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  Ecr17 PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        Ecr17
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        Ecr17
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        Ecr17
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/Ecr17+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// Ecr17+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/Ecr17+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 Ecr17 is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/Ecr17OnLoad.cpp

@@ -0,0 +1,68 @@
+///
+/// Ecr17OnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_ECR17_WITH_GENERATED_CMAKE_PROJECT
+#error Ecr17OnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "Ecr17OnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridEcr17TransportSpec.hpp"
+#include "JFunc_void_std__shared_ptr_ArrayBuffer_.hpp"
+#include "JFunc_void.hpp"
+#include "HybridEcr17Client.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::ecr17 {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::ecr17::registerAllNatives();
+  });
+}
+
+struct JHybridEcr17TransportSpecImpl: public jni::JavaClass<JHybridEcr17TransportSpecImpl, JHybridEcr17TransportSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/ecr17/HybridEcr17Transport;";
+  static std::shared_ptr<JHybridEcr17TransportSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridEcr17TransportSpecImpl::javaobject()>();
+    jni::local_ref<JHybridEcr17TransportSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridEcr17TransportSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::ecr17;
+
+  // Register native JNI methods
+  margelo::nitro::ecr17::JHybridEcr17TransportSpec::CxxPart::registerNatives();
+  margelo::nitro::ecr17::JFunc_void_std__shared_ptr_ArrayBuffer__cxx::registerNatives();
+  margelo::nitro::ecr17::JFunc_void_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ecr17Client",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEcr17Client>,
+                    "The HybridObject \"HybridEcr17Client\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEcr17Client>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ecr17Transport",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridEcr17TransportSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::ecr17

package/nitrogen/generated/android/Ecr17OnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// Ecr17OnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::ecr17 {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of Ecr17, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all Ecr17 HybridObjects
+   *     margelo::nitro::ecr17::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::ecr17

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::ecr17 {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/ecr17/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/ecr17/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::ecr17