fix: Remove timeouts

REmoving the command timeouts and adding support for cancel action.
On IOS the cancel is drived by the OS and the entry point is in the channel
On Android the cancel is app driven

Author: alexjba

docs/API.md

@@ -175,14 +175,13 @@ connect(commManager.get(), &CommunicationManager::commandCompleted,
 
 ```cpp
 // Execute command synchronously (blocks until complete)
-CommandResult executeCommandSync(std::unique_ptr<CardCommand> cmd, 
-                                  int timeoutMs = -1);
+CommandResult executeCommandSync(std::unique_ptr<CardCommand> cmd);
 ```
 
 **Example:**
 ```cpp
 auto cmd = std::make_unique<VerifyPINCommand>("123456");
-CommandResult result = commManager->executeCommandSync(std::move(cmd), 5000);
+CommandResult result = commManager->executeCommandSync(std::move(cmd));
 
 if (result.success) {
     qDebug() << "PIN verified!";
@@ -637,10 +636,7 @@ QByteArray getData(uint8_t type);
 QByteArray identify(const QByteArray& challenge = QByteArray());
 
 // Wait for card presence
-bool waitForCard(int timeoutMs = -1);
-
-// Set default wait timeout
-void setDefaultWaitTimeout(int timeoutMs);
+bool waitForCard();
 
 // Get last error message
 QString lastError() const;
@@ -1324,15 +1320,15 @@ commManager->startDetection();
 ```cpp
 // Verify PIN (blocks until complete, but thread-safe!)
 auto verifyCmd = std::make_unique<VerifyPINCommand>("123456");
-CommandResult result = commManager->executeCommandSync(std::move(verifyCmd), 5000);
+CommandResult result = commManager->executeCommandSync(std::move(verifyCmd));
 
 if (result.success) {
     qDebug() << "PIN verified!";
 
     // Sign a transaction
     QByteArray hash = /* 32-byte hash */;
     auto signCmd = std::make_unique<SignCommand>(hash, "m/44'/60'/0'/0/0");
-    CommandResult signResult = commManager->executeCommandSync(std::move(signCmd), 30000);
+    CommandResult signResult = commManager->executeCommandSync(std::move(signCmd));
 
     if (signResult.success) {
         QByteArray signature = signResult.data.toMap()["signature"].toByteArray();
@@ -1398,7 +1394,7 @@ connect(commManager.get(), &CommunicationManager::cardInitialized,
     if (!result.appInfo.initialized) {
         // Initialize new card
         auto initCmd = std::make_unique<InitCommand>("123456", "123456789012", "KeycardDefaultPairing");
-        CommandResult initResult = commManager->executeCommandSync(std::move(initCmd), 60000);
+        CommandResult initResult = commManager->executeCommandSync(std::move(initCmd));
         
         if (!initResult.success) {
             qWarning() << "Init failed:" << initResult.error;
@@ -1681,14 +1677,8 @@ constexpr uint8_t P1StoreDataCash = 0x02;    // Cash data
    }
    ```
 
-2. **Handle platform-specific timeouts:**
-   ```cpp
-   #ifdef Q_OS_IOS
-       cmdSet->setDefaultWaitTimeout(30000);  // 30s for iOS
-   #else
-       cmdSet->setDefaultWaitTimeout(60000);  // 60s for desktop
-   #endif
-   ```
+2. **Use event-driven card waiting:**
+   `waitForCard()` now waits for channel events (detect/error/detection-stopped) instead of a timeout.
 
 ---
 

examples/README.md

@@ -136,7 +136,7 @@ QUuid token = commMgr->enqueueCommand(std::move(cmd));
 
 // Sync API (for worker threads)
 auto cmd = std::make_unique<SelectCommand>();
-CommandResult result = commMgr->executeCommandSync(std::move(cmd), 5000);
+CommandResult result = commMgr->executeCommandSync(std::move(cmd));
 ```
 
 ### Dependency Injection

include/keycard-qt/backends/keycard_channel_backend.h

@@ -105,6 +105,12 @@ class KeycardChannelBackend : public QObject
      */
     virtual void stopDetection() = 0;
 
+    /**
+     * @brief Check if detection is active
+     * @return true if detection is active, false otherwise
+     */
+    virtual bool isDetectionActive() const = 0;
+
     /**
      * @brief Disconnect from the currently connected card/tag
      */
@@ -194,6 +200,14 @@ class KeycardChannelBackend : public QObject
      */
     void cardRemoved();
 
+    /**
+     * @brief Emitted when the backend stops target detection
+     *
+     * Used by event-driven waiters that should unblock when detection ends.
+     * @param forced true if detection was forcefully stopped by the user or application
+     */
+    void targetDetectionStopped(bool forced);
+
     /**
      * @brief Emitted when an error occurs
      * @param message Error description

include/keycard-qt/backends/keycard_channel_pcsc.h

@@ -42,6 +42,7 @@ class KeycardChannelPcsc : public KeycardChannelBackend
     // KeycardChannelBackend interface
     void startDetection() override;
     void stopDetection() override;
+    bool isDetectionActive() const override { return m_stopDetection.loadAcquire() == 0; }
     void disconnect() override;
     bool isConnected() const override;
     QByteArray transmit(const QByteArray& apdu) override;

include/keycard-qt/backends/keycard_channel_unified_qt_nfc.h

@@ -28,6 +28,7 @@ class KeycardChannelUnifiedQtNfc : public KeycardChannelBackend
     // KeycardChannelBackend interface
     void startDetection() override;
     void stopDetection() override;
+    bool isDetectionActive() const override { return m_detectionActive; }
     void disconnect() override;
     bool isConnected() const override;
     QByteArray transmit(const QByteArray& apdu) override;

include/keycard-qt/card_command.h

@@ -10,24 +10,35 @@ namespace Keycard {
 // Forward declarations
 class CommandSet;
 
+enum class CommandResultType {
+    Success,
+    Error,
+    Timeout,
+    Cancelled,
+    InvalidState,
+    InvalidCommand,
+    InvalidParameter
+};
+
 /**
  * @brief Result of a card command execution
  */
 struct CommandResult {
     bool success;
     QVariant data;
     QString error;
+    CommandResultType reason;
 
-    CommandResult() : success(false) {}
-    CommandResult(bool s, const QVariant& d = QVariant(), const QString& e = QString())
-        : success(s), data(d), error(e) {}
+    CommandResult() : success(false), reason(CommandResultType::InvalidState) {}
+    CommandResult(bool s, const QVariant& d = QVariant(), const QString& e = QString(), CommandResultType t = CommandResultType::Success)
+        : success(s), data(d), error(e), reason(t) {}
 
     static CommandResult fromSuccess(const QVariant& data = QVariant()) {
-        return CommandResult(true, data);
+        return CommandResult(true, data, QString(), CommandResultType::Success);
     }
 
-    static CommandResult fromError(const QString& error) {
-        return CommandResult(false, QVariant(), error);
+    static CommandResult fromError(const QString& error, CommandResultType type = CommandResultType::Error) {
+        return CommandResult(false, QVariant(), error, type);
     }
 };
 

include/keycard-qt/command_set.h

@@ -319,17 +319,9 @@ class CommandSet : public QObject {
     /**
      * @brief Wait for card to be present
      * Checks if card is connected, enables card detection if needed, and waits for card
-     * @param timeoutMs Timeout in milliseconds (default: uses defaultWaitTimeout)
-     * @return true if card detected, false on timeout or error
+     * @return true if card detected, false on error or when detection stops
      */
-    bool waitForCard(int timeoutMs = -1);
-    
-    /**
-     * @brief Set default timeout for waitForCard operations
-     * @param timeoutMs Timeout in milliseconds (default: 60000)
-     * Useful for tests to use shorter timeouts
-     */
-    void setDefaultWaitTimeout(int timeoutMs);
+    bool waitForCard();
 
     /**
      * @brief Ensure pairing is available for current card
@@ -400,6 +392,12 @@ class CommandSet : public QObject {
      *       CommunicationManager should use this instead of accessing channel directly.
      */
     void stopDetection();
+
+    /**
+     * @brief Check if detection is active
+     * @return true if detection is active, false otherwise
+     */
+    bool isDetectionActive() const { return m_channel && m_channel->isDetectionActive(); }
 
     /**
      * @brief Get current card UID
@@ -496,10 +494,9 @@ private slots:
 
     /**
      * @brief Internal implementation of waitForCard (must be called from correct thread)
-     * @param timeoutMs Timeout in milliseconds
-     * @return true if card detected, false on timeout
+     * @return true if card detected, false on error or when detection stops
      */
-    bool waitForCardInternal(int timeoutMs);
+    bool waitForCardInternal();
 
     /**
      * @brief Clean up state after factory reset
@@ -543,8 +540,6 @@ private slots:
     QString m_cachedPIN;              // Cached PIN for auto-reauth after NFC session loss
     bool m_needsSecureChannelReestablishment = false;  // Flag: secure channel must be re-opened before next command
 
-    // Default timeout for waitForCard operations (can be configured for tests)
-    int m_defaultWaitTimeout = 60000;  // 60 seconds default
 
     std::atomic_bool m_cardReady = false;
 };

include/keycard-qt/communication_manager.h

@@ -92,6 +92,15 @@ class CommunicationManager : public ICommunicationManager {
      * Call startDetection() to resume monitoring.
      */
     void stopDetection() override;
+
+    /**
+     * @brief Cancel all pending operations with the given reason
+     * @param reason Error message for cancelled operations (default: "User cancelled NFC")
+     *
+     * Wakes sync waiters, flushes the queue with error results, and stops detection.
+     * Keeps the manager thread alive. Thread-safe: marshals to manager thread if needed.
+     */
+    void cancelPendingOperations(const QString& reason = "User cancelled NFC") override;
 
     /**
      * @brief Stop the communication manager completely
@@ -137,16 +146,15 @@ class CommunicationManager : public ICommunicationManager {
     /**
      * @brief Execute command synchronously (blocking)
      * @param cmd Command to execute
-     * @param timeoutMs Timeout in milliseconds
      * @return CommandResult with success/failure and data
      * 
      * This is a convenience wrapper around enqueueCommand() that blocks
-     * until the command completes or times out.
+     * until the command completes or the manager is stopped.
      * 
      * IMPORTANT: Do NOT call this from the communication thread or main thread
      * if the main thread needs to process events. Use from worker threads only.
      */
-    CommandResult executeCommandSync(std::unique_ptr<CardCommand> cmd, int timeoutMs = -1) override;
+    CommandResult executeCommandSync(std::unique_ptr<CardCommand> cmd) override;
 
     /**
      * @brief Get current state
@@ -221,6 +229,15 @@ private slots:
      * Allows tracking of channel state for operational state emission.
      */
     void onChannelStateChanged(ChannelState state);
+
+    /**
+     * @brief Handle target detection stopped from channel (user cancelled NFC)
+     *
+     * Emitted when the NFC backend stops detection (e.g., user closed drawer).
+     * Triggers unified cancel cleanup.
+     * @param forced true if detection was forcefully stopped by the user or application
+     */
+    void onTargetDetectionStopped(bool forced);
 
     /**
      * @brief Process next command in queue
@@ -267,6 +284,14 @@ private slots:
      * @brief Set state and emit signal
      */
     void setState(State newState);
+
+    /**
+     * @brief Internal cancel: wake sync waiters, flush queue, stop detection
+     * @param reason Error message for cancelled operations
+     *
+     * Keeps manager thread alive. Used by cancelPendingOperations() and stop().
+     */
+    void cancelPendingOperationsInternal(const QString& reason);
 
     // Thread and queue management
     CommunicationThread* m_commThread;

include/keycard-qt/i_communication_manager.h

@@ -57,9 +57,10 @@ class ICommunicationManager : public QObject {
     // Detection management
     virtual bool startDetection() = 0;
     virtual void stopDetection() = 0;
+    virtual void cancelPendingOperations(const QString& reason) = 0;
 
     // Command execution
-    virtual CommandResult executeCommandSync(std::unique_ptr<CardCommand> cmd, int timeoutMs = -1) = 0;
+    virtual CommandResult executeCommandSync(std::unique_ptr<CardCommand> cmd) = 0;
 
     // Card information
     virtual ApplicationInfo applicationInfo() const = 0;
@@ -87,6 +88,12 @@ class ICommunicationManager : public QObject {
      * @brief Emitted when state changes (optional - for diagnostics)
      */
     void stateChanged(int newState);
+
+    /**
+     * @brief Emitted when an operation is cancelled
+     * @param reason Reason for cancellation
+     */
+    void operationCancelled(const QString& reason);
 };
 
 } // namespace Keycard

include/keycard-qt/keycard_channel.h

@@ -91,7 +91,14 @@ class KeycardChannel : public QObject, public IChannel {
      * an already connected card.
      */
     void stopDetection();
-    
+
+
+    /**
+     * @brief Check if detection is active
+     * @return true if detection is active, false otherwise
+     */
+    bool isDetectionActive() const;
+
     /**
      * @brief Force immediate re-scan for cards
      * 
@@ -189,6 +196,12 @@ class KeycardChannel : public QObject, public IChannel {
      * After this signal, transmit() will fail until a new card is detected.
      */
     void targetLost();
+
+    /**
+     * @brief Emitted when target detection is stopped by backend/platform
+     * @param forced true if detection was forcefully stopped by the user or application
+     */
+    void targetDetectionStopped(bool forced);
 
     /**
      * @brief Emitted when an error occurs