feat: add reader availability handling making a distinction between card and reader removal

Problem was that both "card removed from reader" and "reader unplugged" produced the same cardLost signal
and SessionManager couldn't distinguish between them.

Proper connection to `readerAvailabilityChanged` to make a clear distinction between card
and reader removal, 2 different signals are sent to client in this case `waiting-for-reader` and `waiting-for-card`.

Now in case of removing reader:
- KeycardChannelBackend -> readerAvailabilityChanged(false) -> KeycardChannel -> SessionManager::onReaderAvailabilityChanged -> state is WaitingForReader
- CommandSet -> cardLost -> CommunicationManager -> SessionManager::onCardRemoved -> (no signal, cause already WaitingForReader)

In case of removing card, but reader is connected:
- CommandSet -> cardLost -> CommunicationManager -> SessionManager::onCardRemoved -> state is WaitingForCard

Author: saledjenic

src/session/session_composite_operations.cpp

@@ -37,7 +37,8 @@ SessionManager::LoginKeys SessionManager::login(const QString& keyUid, const QSt
     // Step 2: Wait for card to be ready (event-driven, no polling)
     {
         QMutexLocker locker(&m_cardReadyMutex);
-        while (m_state == SessionState::WaitingForCard && !m_compositeMethodCallCancelled) {
+        while ((m_state == SessionState::WaitingForCard || m_state == SessionState::WaitingForReader)
+               && !m_compositeMethodCallCancelled) {
             m_cardReadyCondition.wait(&m_cardReadyMutex);
         }
     }
@@ -107,7 +108,8 @@ SessionManager::RecoverKeys SessionManager::recover(const QString& pin, const QS
     // Step 2: Wait for card to be ready (event-driven, no polling)
     {
         QMutexLocker locker(&m_cardReadyMutex);
-        while (m_state == SessionState::WaitingForCard && !m_compositeMethodCallCancelled) {
+        while ((m_state == SessionState::WaitingForCard || m_state == SessionState::WaitingForReader)
+               && !m_compositeMethodCallCancelled) {
             m_cardReadyCondition.wait(&m_cardReadyMutex);
         }
     }
@@ -173,7 +175,8 @@ SessionManager::ExtendedPublicKey SessionManager::exportExtendedPublicKey(const
 
     {
         QMutexLocker locker(&m_cardReadyMutex);
-        while (m_state == SessionState::WaitingForCard && !m_compositeMethodCallCancelled) {
+        while ((m_state == SessionState::WaitingForCard || m_state == SessionState::WaitingForReader)
+               && !m_compositeMethodCallCancelled) {
             m_cardReadyCondition.wait(&m_cardReadyMutex);
         }
     }
@@ -238,7 +241,8 @@ SessionManager::ExportPublicKeyResult SessionManager::exportPublicKey(const QStr
 
     {
         QMutexLocker locker(&m_cardReadyMutex);
-        while (m_state == SessionState::WaitingForCard && !m_compositeMethodCallCancelled) {
+        while ((m_state == SessionState::WaitingForCard || m_state == SessionState::WaitingForReader)
+               && !m_compositeMethodCallCancelled) {
             m_cardReadyCondition.wait(&m_cardReadyMutex);
         }
     }

src/session/session_manager.cpp

@@ -100,14 +100,32 @@ bool SessionManager::start(bool logEnabled, const QString& logFilePath)
             this, [this]() { setState(SessionState::Cancelled); },
             Qt::AutoConnection);
 
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+    if (auto cmdSet = m_commMgr->commandSet()) {
+        if (auto ch = cmdSet->channel()) {
+            connect(ch.get(), &Keycard::KeycardChannel::readerAvailabilityChanged,
+                    this, &SessionManager::onReaderAvailabilityChanged,
+                    Qt::AutoConnection);
+        }
+    }
+#endif
+
+    // Mark as started before startDetection(), because detection may emit
+    // readerAvailabilityChanged synchronously and the slot needs m_started == true.
+    m_started = true;
+
     // Start card detection (CommunicationManager should already be init'd by caller)
     if (!m_commMgr->startDetection()) {
         qWarning() << "SessionManager: Failed to start card detection";
+        m_started = false;
         return false;
     }
 
-    setState(SessionState::WaitingForCard);
-    m_started = true;
+    // Only set WaitingForCard if a reader-availability signal hasn't already
+    // moved us to a more specific state (e.g. WaitingForReader).
+    if (m_state == SessionState::UnknownReaderState) {
+        setState(SessionState::WaitingForCard);
+    }
 
     qDebug() << "StatusKeycardQt::SessionManager: Started successfully, monitoring for cards";
     return true;
@@ -132,6 +150,14 @@ void SessionManager::stop()
     if (m_commMgr) {
         // Disconnect from CommunicationManager signals so SessionManager doesn't react to card events anymore
         QObject::disconnect(m_commMgr.get(), nullptr, this, nullptr);
+
+        // Also disconnect from the channel's readerAvailabilityChanged signal
+        if (auto cmdSet = m_commMgr->commandSet()) {
+            if (auto ch = cmdSet->channel()) {
+                QObject::disconnect(ch.get(), nullptr, this, nullptr);
+            }
+        }
+
         m_commMgr->stopDetection();
     }
 
@@ -210,11 +236,36 @@ void SessionManager::onCardRemoved()
     m_currentCardUID.clear();
 
     if (m_started) {
-        setState(SessionState::WaitingForCard);
+        // If the reader was already marked as unavailable, the reader itself was removed
+        // (onReaderAvailabilityChanged already set the appropriate state).
+        // Only transition to WaitingForCard if the reader is still present.
+        if (m_state != SessionState::WaitingForReader) {
+            setState(SessionState::WaitingForCard);
+        }
     }
 #endif
 }
 
+void SessionManager::onReaderAvailabilityChanged(bool available)
+{
+    qDebug() << "StatusKeycardQt::========================================";
+    qDebug() << "StatusKeycardQt::SessionManager: READER AVAILABILITY CHANGED -" << (available ? "available" : "removed");
+    qDebug() << "StatusKeycardQt::========================================";
+
+    if (!m_started) {
+        return;
+    }
+
+    if (!available) {
+        m_currentCardUID.clear();
+        setState(SessionState::WaitingForReader);
+    } else {
+        if (m_state == SessionState::WaitingForReader) {
+            setState(SessionState::WaitingForCard);
+        }
+    }
+}
+
 void SessionManager::setError(const QString& error)
 {
     qDebug() << "StatusKeycardQt::SessionManager::setError() - Error:" << error;

src/session/session_manager.h

@@ -172,6 +172,7 @@ class SessionManager : public QObject {
 public slots:
     void onCardInitialized(const Keycard::CardInitializationResult& result);
     void onCardRemoved();
+    void onReaderAvailabilityChanged(bool available);
 
 private:
     void setState(SessionState newState);

tests/mocks/mock_communication_manager.cpp

@@ -66,6 +66,14 @@ void MockCommunicationManager::simulateCardRemoved()
     emit cardLost();
 }
 
+void MockCommunicationManager::simulateReaderAvailabilityChanged(bool available)
+{
+    qDebug() << "StatusKeycardQt::[MockCommunicationManager] Simulating reader availability changed:" << available;
+    // In the real stack, this signal comes from KeycardChannel.
+    // For mock testing, call SessionManager::onReaderAvailabilityChanged directly.
+    Q_UNUSED(available);
+}
+
 void MockCommunicationManager::setMockApplicationInfo(const Keycard::ApplicationInfo& info)
 {
     m_mockAppInfo = info;

tests/mocks/mock_communication_manager.h

@@ -44,10 +44,20 @@ class MockCommunicationManager : public Keycard::ICommunicationManager {
 
     /**
      * @brief Simulate card removal
-     * 
+     *
      * This will emit cardLost signal asynchronously.
      */
     void simulateCardRemoved();
+
+    /**
+     * @brief Simulate reader availability change (PC/SC reader plugged/unplugged)
+     * @param available true if reader is present, false if removed
+     *
+     * Note: In the real implementation, readerAvailabilityChanged comes from the
+     * KeycardChannel, not ICommunicationManager. The mock exposes this for convenience;
+     * tests connect SessionManager::onReaderAvailabilityChanged directly.
+     */
+    void simulateReaderAvailabilityChanged(bool available);
 
     /**
      * @brief Set mock application info to be returned