qnearfieldmanager_pcsc.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qnearfieldmanager_pcsc_p.h"
#include "qnearfieldtarget_pcsc_p.h"
#include "pcsc/qpcscmanager_p.h"
#include "pcsc/qpcsccard_p.h"
#include <QtCore/QLoggingCategory>
#include <QtCore/QThread>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_DECLARE_LOGGING_CATEGORY(QT_NFC_PCSC)
 
/*
    Constructs a new near field manager private implementation.
 
    This object creates a worker thread with an instance of QPcscManager in
    it. All the communication with QPcscManager is done using signal-slot
    mechanism.
*/
QNearFieldManagerPrivateImpl::QNearFieldManagerPrivateImpl()
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
 
    m_worker = new QPcscManager;
    m_workerThread = new QThread(this);
    m_workerThread->setObjectName(u"QtNfcThread"_s);
    m_worker->moveToThread(m_workerThread);
 
    connect(m_worker, &QPcscManager::cardInserted, this,
            &QNearFieldManagerPrivateImpl::onCardInserted);
    connect(this, &QNearFieldManagerPrivateImpl::startTargetDetectionRequest, m_worker,
            &QPcscManager::onStartTargetDetectionRequest);
    connect(this, &QNearFieldManagerPrivateImpl::stopTargetDetectionRequest, m_worker,
            &QPcscManager::onStopTargetDetectionRequest);
 
    m_workerThread->start();
}
 
/*
    Destroys the near field manager private implementation.
*/
QNearFieldManagerPrivateImpl::~QNearFieldManagerPrivateImpl()
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
 
    // Destroy the worker. It calls QThread::quit() on the working thread in
    // its destructor.
    QMetaObject::invokeMethod(m_worker, &QObject::deleteLater, Qt::QueuedConnection);
    m_workerThread->wait();
}
 
bool QNearFieldManagerPrivateImpl::isEnabled() const
{
    return true;
}
 
bool QNearFieldManagerPrivateImpl::isSupported(QNearFieldTarget::AccessMethod accessMethod) const
{
    switch (accessMethod) {
    case QNearFieldTarget::TagTypeSpecificAccess:
    case QNearFieldTarget::NdefAccess:
        return true;
    default:
        return false;
    }
}
 
bool QNearFieldManagerPrivateImpl::startTargetDetection(QNearFieldTarget::AccessMethod accessMethod)
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
 
    Q_EMIT startTargetDetectionRequest(accessMethod);
 
    return true;
}
 
void QNearFieldManagerPrivateImpl::stopTargetDetection(const QString &errorMessage)
{
    Q_UNUSED(errorMessage);
 
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
 
    Q_EMIT stopTargetDetectionRequest();
}
 
/*
    Invoked when the worker has detected a new card.
 
    The worker will ensure that the card object remains valid until the manager
    emits targetCreatedForCard() signal.
*/
void QNearFieldManagerPrivateImpl::onCardInserted(QPcscCard *card, const QByteArray &uid,
                                                  QNearFieldTarget::AccessMethods accessMethods,
                                                  int maxInputLength)
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
 
    auto priv = new QNearFieldTargetPrivateImpl(uid, accessMethods, maxInputLength, this);
 
    connect(priv, &QNearFieldTargetPrivateImpl::disconnectRequest, card,
            &QPcscCard::onDisconnectRequest);
    connect(priv, &QNearFieldTargetPrivateImpl::destroyed, card, &QPcscCard::onTargetDestroyed);
    connect(priv, &QNearFieldTargetPrivateImpl::sendCommandRequest, card,
            &QPcscCard::onSendCommandRequest);
    connect(priv, &QNearFieldTargetPrivateImpl::readNdefMessagesRequest, card,
            &QPcscCard::onReadNdefMessagesRequest);
    connect(priv, &QNearFieldTargetPrivateImpl::writeNdefMessagesRequest, card,
            &QPcscCard::onWriteNdefMessagesRequest);
 
    connect(priv, &QNearFieldTargetPrivateImpl::targetLost, this,
            &QNearFieldManagerPrivateImpl::onTargetLost);
 
    connect(card, &QPcscCard::disconnected, priv, &QNearFieldTargetPrivateImpl::onDisconnected);
    connect(card, &QPcscCard::invalidated, priv, &QNearFieldTargetPrivateImpl::onInvalidated);
    connect(card, &QPcscCard::requestCompleted, priv,
            &QNearFieldTargetPrivateImpl::onRequestCompleted);
    connect(card, &QPcscCard::ndefMessageRead, priv,
            &QNearFieldTargetPrivateImpl::onNdefMessageRead);
 
    auto target = new QNearFieldTarget(priv, this);
 
    Q_EMIT targetDetected(target);
 
    // Let the worker know that the card object can be deleted if it is no
    // longer needed.
    QMetaObject::invokeMethod(card, &QPcscCard::enableAutodelete, Qt::QueuedConnection);
}
 
void QNearFieldManagerPrivateImpl::onTargetLost(QNearFieldTargetPrivate *target)
{
    Q_EMIT targetLost(target->q_ptr);
}
 
Q_LOGGING_CATEGORY(QT_NFC_PCSC, "qt.nfc.pcsc")
 
QT_END_NAMESPACE