fix: Ref-count batch operations

+ don's close the secure channel preemptively

Author: alexjba

include/keycard-qt/communication_manager.h

@@ -102,29 +102,22 @@ class CommunicationManager : public ICommunicationManager {
     void stop();
 
     /**
-     * @brief Start batch operations mode
-     * 
+     * @brief Start batch operations mode (ref-counted)
+     *
      * Prevents the communication manager from automatically stopping card detection
      * when the command queue becomes empty. Useful for performing multiple sequential
      * operations without channel stop/start cycles.
-     * 
-     * Call endBatchOperations() when done to allow automatic detection management.
-     * 
-     * Example:
-     * @code
-     * m_commMgr->startBatchOperations();
-     * // Perform multiple executeCommandSync() calls
-     * // Channel stays open between commands
-     * m_commMgr->endBatchOperations();
-     * @endcode
+     *
+     * Calls are ref-counted: every startBatchOperations() must be matched with a
+     * corresponding endBatchOperations() call.
      */
     void startBatchOperations() override;
 
     /**
-     * @brief End batch operations mode
-     * 
-     * Re-enables automatic card detection management. If the queue is empty,
-     * detection will be stopped.
+     * @brief End batch operations mode (ref-counted)
+     *
+     * Decrements the active batch reference count. Automatic detection management
+     * is re-enabled only when the count reaches zero.
      */
     void endBatchOperations() override;
 
@@ -311,8 +304,8 @@ private slots:
     // Running flag
     bool m_running;
 
-    // Batch operations flag - when true, don't stop detection on empty queue
-    bool m_batchOperations;
+    // Batch operations ref-count - > 0 means don't stop detection on empty queue
+    int m_batchOperationDepth;
     QMutex m_batchMutex;
 };
 

src/command_set.cpp

@@ -1431,10 +1431,6 @@ void CommandSet::stopDetection() {
         return;
     }
 
-    // Reset secure channel when stopping detection
-    // This ensures that when detection restarts, the secure channel will be properly re-established
-    resetSecureChannel();
-    
     // This runs on main thread, so it's safe to call directly
     m_channel->setState(ChannelState::Idle);
     emit channelStateChanged(ChannelState::Idle);

src/communication_manager.cpp

@@ -35,7 +35,7 @@ CommunicationManager::CommunicationManager(QObject* parent)
     , m_commThread(nullptr)
     , m_state(State::Idle)
     , m_running(false)
-    , m_batchOperations(false)
+    , m_batchOperationDepth(0)
 {
     qDebug() << "CommunicationManager: Created";
 }
@@ -133,7 +133,7 @@ void CommunicationManager::stop() {
     // Step 2: Clear batch mode
     {
         QMutexLocker locker(&m_batchMutex);
-        m_batchOperations = false;
+        m_batchOperationDepth = 0;
     }
 
     // Step 3: Stop card detection
@@ -216,26 +216,46 @@ void CommunicationManager::stop() {
 }
 
 void CommunicationManager::startBatchOperations() {
-    QMutexLocker locker(&m_batchMutex);
-    if (!m_batchOperations) {
-        m_batchOperations = true;
+    int depth = 0;
+    bool becameActive = false;
+    {
+        QMutexLocker locker(&m_batchMutex);
+        if (m_batchOperationDepth == 0) {
+            becameActive = true;
+        }
+        ++m_batchOperationDepth;
+        depth = m_batchOperationDepth;
+    }
+
+    if (becameActive) {
         qDebug() << "CommunicationManager: Batch operations mode ENABLED - channel will stay open";
+    } else {
+        qDebug() << "CommunicationManager: Batch operations depth increased to" << depth;
     }
 }
 
 void CommunicationManager::endBatchOperations() {
-    bool wasBatch = false;
+    int depth = 0;
+    bool becameInactive = false;
     {
         QMutexLocker locker(&m_batchMutex);
-        wasBatch = m_batchOperations;
-        m_batchOperations = false;
+        if (m_batchOperationDepth <= 0) {
+            qWarning() << "CommunicationManager: endBatchOperations() called with depth" << m_batchOperationDepth;
+            return;
+        }
+
+        --m_batchOperationDepth;
+        depth = m_batchOperationDepth;
+        becameInactive = (m_batchOperationDepth == 0);
     }
-    
-    if (wasBatch) {
+
+    if (becameInactive) {
         qDebug() << "CommunicationManager: Batch operations mode DISABLED";
-        
+
         // Check if queue is empty and stop detection if needed
         QMetaObject::invokeMethod(this, &CommunicationManager::processQueue, Qt::QueuedConnection);
+    } else {
+        qDebug() << "CommunicationManager: Batch operations depth decreased to" << depth;
     }
 }
 
@@ -600,7 +620,7 @@ void CommunicationManager::processQueue() {
         bool inBatchMode = false;
         {
             QMutexLocker batchLocker(&m_batchMutex);
-            inBatchMode = m_batchOperations;
+            inBatchMode = (m_batchOperationDepth > 0);
         }
 
         if (inBatchMode) {

tests/test_communication_manager.cpp

@@ -255,12 +255,23 @@ private slots:
 
     void testNestedBatchOperations() {
         m_commMgr->init(m_cmdSet);
-        
+
         m_commMgr->startBatchOperations();
-        m_commMgr->startBatchOperations();  // Second call should be idempotent
-        
+        m_commMgr->startBatchOperations();  // Second call should increase depth
+
         m_commMgr->endBatchOperations();
-        
+        m_commMgr->endBatchOperations();  // Fully exit batch mode
+
+        QVERIFY(true);
+    }
+
+    void testEndBatchOperationsWithoutStart() {
+        m_commMgr->init(m_cmdSet);
+
+        // Extra end calls should be safe and never underflow.
+        m_commMgr->endBatchOperations();
+        m_commMgr->endBatchOperations();
+
         QVERIFY(true);
     }