@padosoft/react-native-ecr17 0.0.0 → 2.0.1

package/cpp/Session/Ecr17Session.hpp

@@ -1,97 +1,97 @@
-#pragma once
-
-#include <condition_variable>
-#include <cstdint>
-#include <functional>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "Lcr/Lcr.hpp"  // brings LrcMode
-#include "PacketCodec/PacketCodec.hpp"
-#include "Transport/Transport.hpp"
-
-namespace margelo::nitro::ecr17 {
-
-struct SessionConfig {
-    LrcMode lrcMode = LrcMode::STD;
-    int ackTimeoutMs = 2000;       // wait for the physical ACK/NAK
-    int responseTimeoutMs = 60000; // wait for the application response
-    int retryCount = 3;            // retransmissions on NAK/timeout (spec: up to 3)
-    int retryDelayMs = 200;        // delay between retransmissions
-    int receiptDrainMs = 0;        // after the result, keep forwarding 'S' receipt
-                                   // lines until this many ms of silence (0 = off)
-};
-
-// Drives one ECR17 request/response exchange over a Transport: frames the
-// request, handles the physical ACK/NAK handshake with retransmission, waits for
-// the application response while forwarding progress (SOH) and receipt ('S')
-// messages, and ACK/NAKs incoming frames per their LRC validity.
-//
-// Pure C++ and transport-agnostic: unit-tested against FakeTransport. A single
-// exchange runs at a time (the protocol is one transaction per terminal).
-class Ecr17Session {
-   public:
-    Ecr17Session(Transport& transport, const SessionConfig& config);
-
-    void setOnProgress(std::function<void(const std::string&)> cb) { onProgress_ = std::move(cb); }
-    void setOnReceiptLine(std::function<void(const std::string&)> cb) {
-        onReceiptLine_ = std::move(cb);
-    }
-
-    // Sends `requestPayload` (the application message, without STX/ETX) and
-    // returns the decoded application result. Throws std::runtime_error on
-    // retransmission exhaustion, ACK/response timeout, or transport disconnect.
-    DecodedPacket exchange(const std::string& requestPayload);
-
-    // Like exchange(), but sends an extra additional-data message (command 'U',
-    // tokenization) after the main request is ACKed, before the result: the
-    // documented flow is request(flag=1) -> ACK -> 'U' -> ACK -> result.
-    DecodedPacket exchangeWithAdditionalData(const std::string& requestPayload,
-                                             const std::string& additionalPayload);
-
-    // For commands whose only reply is the physical ACK (e.g. enable/disable ECR
-    // printing 'E'). Performs the ACK handshake with retransmission and returns
-    // once ACK is received; does NOT wait for an application response. Throws on
-    // retransmission exhaustion / timeout / disconnect.
-    void sendAckOnly(const std::string& requestPayload);
-
-   private:
-    void onData(const std::vector<uint8_t>& data);
-    void onDisconnect();
-    // Clears stale RX bytes and the disconnected flag so the session is reusable
-    // across reconnects (a new transaction starts from a clean state).
-    void resetForNewTransaction();
-    // Sends a request and completes the physical ACK handshake (with
-    // retransmission). Does NOT reset state — callers reset once per transaction.
-    void ackHandshake(const std::string& requestPayload);
-    // Waits for the application result after the ACK handshake, forwarding
-    // progress (SOH) and receipt ('S') frames, NAKing invalid-LRC frames.
-    DecodedPacket waitForResult();
-    void drainReceipts();
-    std::optional<std::vector<uint8_t>> extractFrameLocked();
-    std::optional<DecodedPacket> waitForFrame(int timeoutMs);
-    void sendControl(uint8_t control);
-    static bool isReceipt(const std::string& payload);
-
-    Transport& transport_;
-    SessionConfig config_;
-    PacketCodec codec_;
-
-    std::mutex mutex_;
-    std::condition_variable cv_;
-    std::vector<uint8_t> rxBuffer_;
-    bool disconnected_ = false;
-
-    // Holds an application response that arrived during the ACK handshake (some
-    // terminals send the result before/without a physical ACK). Consumed by
-    // waitForResult() so the completed transaction's result is never dropped.
-    // Touched only by the worker thread, never the data-callback thread.
-    std::optional<DecodedPacket> pendingResult_{};
-
-    std::function<void(const std::string&)> onProgress_{};
-    std::function<void(const std::string&)> onReceiptLine_{};
-};
-
-}  // namespace margelo::nitro::ecr17
+#pragma once
+
+#include <condition_variable>
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "Lcr/Lcr.hpp"  // brings LrcMode
+#include "PacketCodec/PacketCodec.hpp"
+#include "Transport/Transport.hpp"
+
+namespace margelo::nitro::ecr17 {
+
+struct SessionConfig {
+    LrcMode lrcMode = LrcMode::STD;
+    int ackTimeoutMs = 2000;       // wait for the physical ACK/NAK
+    int responseTimeoutMs = 60000; // wait for the application response
+    int retryCount = 3;            // retransmissions on NAK/timeout (spec: up to 3)
+    int retryDelayMs = 200;        // delay between retransmissions
+    int receiptDrainMs = 0;        // after the result, keep forwarding 'S' receipt
+                                   // lines until this many ms of silence (0 = off)
+};
+
+// Drives one ECR17 request/response exchange over a Transport: frames the
+// request, handles the physical ACK/NAK handshake with retransmission, waits for
+// the application response while forwarding progress (SOH) and receipt ('S')
+// messages, and ACK/NAKs incoming frames per their LRC validity.
+//
+// Pure C++ and transport-agnostic: unit-tested against FakeTransport. A single
+// exchange runs at a time (the protocol is one transaction per terminal).
+class Ecr17Session {
+   public:
+    Ecr17Session(Transport& transport, const SessionConfig& config);
+
+    void setOnProgress(std::function<void(const std::string&)> cb) { onProgress_ = std::move(cb); }
+    void setOnReceiptLine(std::function<void(const std::string&)> cb) {
+        onReceiptLine_ = std::move(cb);
+    }
+
+    // Sends `requestPayload` (the application message, without STX/ETX) and
+    // returns the decoded application result. Throws std::runtime_error on
+    // retransmission exhaustion, ACK/response timeout, or transport disconnect.
+    DecodedPacket exchange(const std::string& requestPayload);
+
+    // Like exchange(), but sends an extra additional-data message (command 'U',
+    // tokenization) after the main request is ACKed, before the result: the
+    // documented flow is request(flag=1) -> ACK -> 'U' -> ACK -> result.
+    DecodedPacket exchangeWithAdditionalData(const std::string& requestPayload,
+                                             const std::string& additionalPayload);
+
+    // For commands whose only reply is the physical ACK (e.g. enable/disable ECR
+    // printing 'E'). Performs the ACK handshake with retransmission and returns
+    // once ACK is received; does NOT wait for an application response. Throws on
+    // retransmission exhaustion / timeout / disconnect.
+    void sendAckOnly(const std::string& requestPayload);
+
+   private:
+    void onData(const std::vector<uint8_t>& data);
+    void onDisconnect();
+    // Clears stale RX bytes and the disconnected flag so the session is reusable
+    // across reconnects (a new transaction starts from a clean state).
+    void resetForNewTransaction();
+    // Sends a request and completes the physical ACK handshake (with
+    // retransmission). Does NOT reset state — callers reset once per transaction.
+    void ackHandshake(const std::string& requestPayload);
+    // Waits for the application result after the ACK handshake, forwarding
+    // progress (SOH) and receipt ('S') frames, NAKing invalid-LRC frames.
+    DecodedPacket waitForResult();
+    void drainReceipts();
+    std::optional<std::vector<uint8_t>> extractFrameLocked();
+    std::optional<DecodedPacket> waitForFrame(int timeoutMs);
+    void sendControl(uint8_t control);
+    static bool isReceipt(const std::string& payload);
+
+    Transport& transport_;
+    SessionConfig config_;
+    PacketCodec codec_;
+
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    std::vector<uint8_t> rxBuffer_;
+    bool disconnected_ = false;
+
+    // Holds an application response that arrived during the ACK handshake (some
+    // terminals send the result before/without a physical ACK). Consumed by
+    // waitForResult() so the completed transaction's result is never dropped.
+    // Touched only by the worker thread, never the data-callback thread.
+    std::optional<DecodedPacket> pendingResult_{};
+
+    std::function<void(const std::string&)> onProgress_{};
+    std::function<void(const std::string&)> onReceiptLine_{};
+};
+
+}  // namespace margelo::nitro::ecr17

package/cpp/Session/RetryPolicy.hpp

@@ -1,23 +1,23 @@
-#pragma once
-
-namespace margelo::nitro::ecr17 {
-
-// Decides whether a command may be safely RE-SENT after an auto-reconnect.
-//
-// ⚠️ MONEY-CRITICAL INVARIANT: a financial command (safeToRetry == false) must
-// NEVER be retried. If the connection drops after the terminal has processed the
-// payment but before the response arrives, a blind re-send would charge the
-// cardholder twice. Such cases are recovered by querying the terminal's last
-// result (command 'G' / sendLastResult), NOT by retransmitting the request.
-//
-// Only read-only / idempotent commands (status, totals, sendLastResult,
-// enable-printing) pass safeToRetry == true.
-//
-// Reconnecting the socket is a separate, always-safe action; this function only
-// governs whether the *request* is replayed.
-inline bool shouldRetryAfterReconnect(bool autoReconnect, bool transportDropped,
-                                      bool safeToRetry) {
-    return autoReconnect && transportDropped && safeToRetry;
-}
-
-}  // namespace margelo::nitro::ecr17
+#pragma once
+
+namespace margelo::nitro::ecr17 {
+
+// Decides whether a command may be safely RE-SENT after an auto-reconnect.
+//
+// ⚠️ MONEY-CRITICAL INVARIANT: a financial command (safeToRetry == false) must
+// NEVER be retried. If the connection drops after the terminal has processed the
+// payment but before the response arrives, a blind re-send would charge the
+// cardholder twice. Such cases are recovered by querying the terminal's last
+// result (command 'G' / sendLastResult), NOT by retransmitting the request.
+//
+// Only read-only / idempotent commands (status, totals, sendLastResult,
+// enable-printing) pass safeToRetry == true.
+//
+// Reconnecting the socket is a separate, always-safe action; this function only
+// governs whether the *request* is replayed.
+inline bool shouldRetryAfterReconnect(bool autoReconnect, bool transportDropped,
+                                      bool safeToRetry) {
+    return autoReconnect && transportDropped && safeToRetry;
+}
+
+}  // namespace margelo::nitro::ecr17

package/cpp/Transport/FakeTransport.hpp

@@ -1,95 +1,95 @@
-#pragma once
-
-#include <cstdint>
-#include <functional>
-#include <vector>
-
-#include "Transport/Transport.hpp"
-
-namespace margelo::nitro::ecr17 {
-
-// In-memory Transport for unit tests. Deterministic and synchronous:
-//
-//  - `enqueueResponse(bytes)` queues a scripted terminal reply.
-//  - Every time the session sends an APPLICATION request (a frame starting with
-//    STX, i.e. an initial send or a retransmit) the next queued response is
-//    delivered synchronously via the data callback. Control sends (ACK/NAK,
-//    which start with 0x06/0x15) are just recorded and never trigger a reply.
-//
-// This lets a test script "ACK + result", "NAK then (on retransmit) ACK+result",
-// progress/receipt streams, or no reply at all (to exercise timeouts), without
-// any real sockets or threads.
-class FakeTransport : public Transport {
-   public:
-    static constexpr uint8_t STX = 0x02;
-
-    void connect() override { connected_ = true; }
-    void disconnect() override { connected_ = false; }
-    bool isConnected() const override { return connected_; }
-
-    void send(const std::vector<uint8_t>& bytes) override {
-        sent_.push_back(bytes);
-        const bool isApplicationRequest = !bytes.empty() && bytes.front() == STX;
-        if (isApplicationRequest && disconnectOnRequest_) {
-            triggerDisconnect();
-            return;
-        }
-        if (isApplicationRequest && !responses_.empty()) {
-            std::vector<uint8_t> next = std::move(responses_.front());
-            responses_.erase(responses_.begin());
-            if (dataCallback_) {
-                dataCallback_(next);
-            }
-        }
-    }
-
-    void setDataCallback(DataCallback cb) override { dataCallback_ = std::move(cb); }
-    void setDisconnectCallback(DisconnectCallback cb) override { disconnectCallback_ = std::move(cb); }
-
-    // --- Test helpers ---
-    void enqueueResponse(std::vector<uint8_t> bytes) { responses_.push_back(std::move(bytes)); }
-
-    // Make the next application-request send drop the connection instead of replying.
-    void disconnectOnNextRequest() { disconnectOnRequest_ = true; }
-
-    // Simulate a successful reconnect: clear the drop flag and mark connected.
-    void rearm() {
-        disconnectOnRequest_ = false;
-        connected_ = true;
-    }
-
-    // Deliver bytes immediately as if received from the terminal.
-    void pushIncoming(const std::vector<uint8_t>& bytes) {
-        if (dataCallback_) {
-            dataCallback_(bytes);
-        }
-    }
-
-    void triggerDisconnect() {
-        connected_ = false;
-        if (disconnectCallback_) {
-            disconnectCallback_();
-        }
-    }
-
-    const std::vector<std::vector<uint8_t>>& sentFrames() const { return sent_; }
-    size_t applicationRequestCount() const {
-        size_t count = 0;
-        for (const auto& f : sent_) {
-            if (!f.empty() && f.front() == STX) {
-                ++count;
-            }
-        }
-        return count;
-    }
-
-   private:
-    bool connected_ = false;
-    DataCallback dataCallback_{};
-    DisconnectCallback disconnectCallback_{};
-    std::vector<std::vector<uint8_t>> sent_{};
-    std::vector<std::vector<uint8_t>> responses_{};
-    bool disconnectOnRequest_ = false;
-};
-
-}  // namespace margelo::nitro::ecr17
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <vector>
+
+#include "Transport/Transport.hpp"
+
+namespace margelo::nitro::ecr17 {
+
+// In-memory Transport for unit tests. Deterministic and synchronous:
+//
+//  - `enqueueResponse(bytes)` queues a scripted terminal reply.
+//  - Every time the session sends an APPLICATION request (a frame starting with
+//    STX, i.e. an initial send or a retransmit) the next queued response is
+//    delivered synchronously via the data callback. Control sends (ACK/NAK,
+//    which start with 0x06/0x15) are just recorded and never trigger a reply.
+//
+// This lets a test script "ACK + result", "NAK then (on retransmit) ACK+result",
+// progress/receipt streams, or no reply at all (to exercise timeouts), without
+// any real sockets or threads.
+class FakeTransport : public Transport {
+   public:
+    static constexpr uint8_t STX = 0x02;
+
+    void connect() override { connected_ = true; }
+    void disconnect() override { connected_ = false; }
+    bool isConnected() const override { return connected_; }
+
+    void send(const std::vector<uint8_t>& bytes) override {
+        sent_.push_back(bytes);
+        const bool isApplicationRequest = !bytes.empty() && bytes.front() == STX;
+        if (isApplicationRequest && disconnectOnRequest_) {
+            triggerDisconnect();
+            return;
+        }
+        if (isApplicationRequest && !responses_.empty()) {
+            std::vector<uint8_t> next = std::move(responses_.front());
+            responses_.erase(responses_.begin());
+            if (dataCallback_) {
+                dataCallback_(next);
+            }
+        }
+    }
+
+    void setDataCallback(DataCallback cb) override { dataCallback_ = std::move(cb); }
+    void setDisconnectCallback(DisconnectCallback cb) override { disconnectCallback_ = std::move(cb); }
+
+    // --- Test helpers ---
+    void enqueueResponse(std::vector<uint8_t> bytes) { responses_.push_back(std::move(bytes)); }
+
+    // Make the next application-request send drop the connection instead of replying.
+    void disconnectOnNextRequest() { disconnectOnRequest_ = true; }
+
+    // Simulate a successful reconnect: clear the drop flag and mark connected.
+    void rearm() {
+        disconnectOnRequest_ = false;
+        connected_ = true;
+    }
+
+    // Deliver bytes immediately as if received from the terminal.
+    void pushIncoming(const std::vector<uint8_t>& bytes) {
+        if (dataCallback_) {
+            dataCallback_(bytes);
+        }
+    }
+
+    void triggerDisconnect() {
+        connected_ = false;
+        if (disconnectCallback_) {
+            disconnectCallback_();
+        }
+    }
+
+    const std::vector<std::vector<uint8_t>>& sentFrames() const { return sent_; }
+    size_t applicationRequestCount() const {
+        size_t count = 0;
+        for (const auto& f : sent_) {
+            if (!f.empty() && f.front() == STX) {
+                ++count;
+            }
+        }
+        return count;
+    }
+
+   private:
+    bool connected_ = false;
+    DataCallback dataCallback_{};
+    DisconnectCallback disconnectCallback_{};
+    std::vector<std::vector<uint8_t>> sent_{};
+    std::vector<std::vector<uint8_t>> responses_{};
+    bool disconnectOnRequest_ = false;
+};
+
+}  // namespace margelo::nitro::ecr17

package/cpp/Transport/NativeTransportAdapter.cpp

@@ -1,42 +1,42 @@
-#include "Transport/NativeTransportAdapter.hpp"
-
-#include <NitroModules/ArrayBuffer.hpp>
-
-#include <utility>
-
-namespace margelo::nitro::ecr17 {
-
-NativeTransportAdapter::NativeTransportAdapter(std::shared_ptr<HybridEcr17TransportSpec> transport)
-    : transport_(std::move(transport)) {}
-
-void NativeTransportAdapter::connect() {
-    // Connection is initiated by HybridEcr17Client via the spec's async connect();
-    // nothing to do here.
-}
-
-void NativeTransportAdapter::disconnect() { transport_->disconnect(); }
-
-bool NativeTransportAdapter::isConnected() const { return transport_->isConnected(); }
-
-void NativeTransportAdapter::send(const std::vector<uint8_t>& bytes) {
-    transport_->send(ArrayBuffer::copy(bytes));
-}
-
-void NativeTransportAdapter::setDataCallback(DataCallback cb) {
-    transport_->setOnData([cb = std::move(cb)](const std::shared_ptr<ArrayBuffer>& buffer) {
-        if (!cb || buffer == nullptr) {
-            return;
-        }
-        const uint8_t* data = buffer->data();
-        if (data == nullptr) {
-            return;
-        }
-        cb(std::vector<uint8_t>(data, data + buffer->size()));
-    });
-}
-
-void NativeTransportAdapter::setDisconnectCallback(DisconnectCallback cb) {
-    transport_->setOnDisconnect(std::move(cb));
-}
-
-}  // namespace margelo::nitro::ecr17
+#include "Transport/NativeTransportAdapter.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+#include <utility>
+
+namespace margelo::nitro::ecr17 {
+
+NativeTransportAdapter::NativeTransportAdapter(std::shared_ptr<HybridEcr17TransportSpec> transport)
+    : transport_(std::move(transport)) {}
+
+void NativeTransportAdapter::connect() {
+    // Connection is initiated by HybridEcr17Client via the spec's async connect();
+    // nothing to do here.
+}
+
+void NativeTransportAdapter::disconnect() { transport_->disconnect(); }
+
+bool NativeTransportAdapter::isConnected() const { return transport_->isConnected(); }
+
+void NativeTransportAdapter::send(const std::vector<uint8_t>& bytes) {
+    transport_->send(ArrayBuffer::copy(bytes));
+}
+
+void NativeTransportAdapter::setDataCallback(DataCallback cb) {
+    transport_->setOnData([cb = std::move(cb)](const std::shared_ptr<ArrayBuffer>& buffer) {
+        if (!cb || buffer == nullptr) {
+            return;
+        }
+        const uint8_t* data = buffer->data();
+        if (data == nullptr) {
+            return;
+        }
+        cb(std::vector<uint8_t>(data, data + buffer->size()));
+    });
+}
+
+void NativeTransportAdapter::setDisconnectCallback(DisconnectCallback cb) {
+    transport_->setOnDisconnect(std::move(cb));
+}
+
+}  // namespace margelo::nitro::ecr17

package/cpp/Transport/NativeTransportAdapter.hpp

@@ -1,32 +1,32 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "HybridEcr17TransportSpec.hpp"  // generated Nitro spec (Swift/Kotlin impl)
-#include "Transport/Transport.hpp"
-
-namespace margelo::nitro::ecr17 {
-
-// Adapts the native Nitro transport (Ecr17Transport HybridObject, implemented in
-// Swift/Kotlin) to the C++ Transport interface used by Ecr17Session. Converts
-// between std::vector<uint8_t> and Nitro's ArrayBuffer. Connection lifecycle is
-// driven by HybridEcr17Client directly via the spec (async Promise); the session
-// only uses send + the data/disconnect callbacks.
-class NativeTransportAdapter : public Transport {
-   public:
-    explicit NativeTransportAdapter(std::shared_ptr<HybridEcr17TransportSpec> transport);
-
-    void connect() override;      // no-op: client drives connect() via the spec (async)
-    void disconnect() override;
-    bool isConnected() const override;
-    void send(const std::vector<uint8_t>& bytes) override;
-    void setDataCallback(DataCallback cb) override;
-    void setDisconnectCallback(DisconnectCallback cb) override;
-
-   private:
-    std::shared_ptr<HybridEcr17TransportSpec> transport_;
-};
-
-}  // namespace margelo::nitro::ecr17
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "HybridEcr17TransportSpec.hpp"  // generated Nitro spec (Swift/Kotlin impl)
+#include "Transport/Transport.hpp"
+
+namespace margelo::nitro::ecr17 {
+
+// Adapts the native Nitro transport (Ecr17Transport HybridObject, implemented in
+// Swift/Kotlin) to the C++ Transport interface used by Ecr17Session. Converts
+// between std::vector<uint8_t> and Nitro's ArrayBuffer. Connection lifecycle is
+// driven by HybridEcr17Client directly via the spec (async Promise); the session
+// only uses send + the data/disconnect callbacks.
+class NativeTransportAdapter : public Transport {
+   public:
+    explicit NativeTransportAdapter(std::shared_ptr<HybridEcr17TransportSpec> transport);
+
+    void connect() override;      // no-op: client drives connect() via the spec (async)
+    void disconnect() override;
+    bool isConnected() const override;
+    void send(const std::vector<uint8_t>& bytes) override;
+    void setDataCallback(DataCallback cb) override;
+    void setDisconnectCallback(DisconnectCallback cb) override;
+
+   private:
+    std::shared_ptr<HybridEcr17TransportSpec> transport_;
+};
+
+}  // namespace margelo::nitro::ecr17

package/cpp/Transport/Transport.hpp

@@ -1,31 +1,31 @@
-#pragma once
-
-#include <cstdint>
-#include <functional>
-#include <string>
-#include <vector>
-
-namespace margelo::nitro::ecr17 {
-
-using DataCallback = std::function<void(const std::vector<uint8_t>&)>;
-
-using DisconnectCallback = std::function<void()>;
-
-class Transport {
-   public:
-    virtual ~Transport() = default;
-
-    virtual void connect() = 0;
-
-    virtual void disconnect() = 0;
-
-    virtual bool isConnected() const = 0;
-
-    virtual void send(const std::vector<uint8_t>& bytes) = 0;
-
-    virtual void setDataCallback(DataCallback cb) = 0;
-
-    virtual void setDisconnectCallback(DisconnectCallback cb) = 0;
-};
-
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::ecr17 {
+
+using DataCallback = std::function<void(const std::vector<uint8_t>&)>;
+
+using DisconnectCallback = std::function<void()>;
+
+class Transport {
+   public:
+    virtual ~Transport() = default;
+
+    virtual void connect() = 0;
+
+    virtual void disconnect() = 0;
+
+    virtual bool isConnected() const = 0;
+
+    virtual void send(const std::vector<uint8_t>& bytes) = 0;
+
+    virtual void setDataCallback(DataCallback cb) = 0;
+
+    virtual void setDisconnectCallback(DisconnectCallback cb) = 0;
+};
+
 }  // namespace margelo::nitro::ecr17