qsocketnotifier.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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
 
#define BUILDING_QSOCKETNOTIFIER
#include "qsocketnotifier.h"
#undef BUILDING_QSOCKETNOTIFIER
 
#include "qplatformdefs.h"
 
#include "qabstracteventdispatcher.h"
#include "qcoreapplication.h"
 
#include "qmetatype.h"
 
#include "qobject_p.h"
#include <private/qthread_p.h>
 
#include <QtCore/QLoggingCategory>
#include <QtCore/qpointer.h>
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(lcSocketNotifierDeprecation)
Q_LOGGING_CATEGORY(lcSocketNotifierDeprecation, "qt.core.socketnotifier_deprecation");
 
QT_IMPL_METATYPE_EXTERN_TAGGED(QSocketNotifier::Type, QSocketNotifier_Type)
QT_IMPL_METATYPE_EXTERN(QSocketDescriptor)
 
class QSocketNotifierPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QSocketNotifier)
public:
    QSocketDescriptor sockfd;
    QSocketNotifier::Type sntype;
    bool snenabled = false;
};
 
QSocketNotifier::QSocketNotifier(Type type, QObject *parent)
    : QObject(*new QSocketNotifierPrivate, parent)
{
    Q_D(QSocketNotifier);
 
    qRegisterMetaType<QSocketDescriptor>();
    qRegisterMetaType<QSocketNotifier::Type>();
 
    d->sntype = type;
}
 
QSocketNotifier::QSocketNotifier(qintptr socket, Type type, QObject *parent)
    : QSocketNotifier(type, parent)
{
    Q_D(QSocketNotifier);
 
    d->sockfd = socket;
    d->snenabled = true;
 
    auto thisThreadData = d->threadData.loadRelaxed();
 
    if (!d->sockfd.isValid())
        qWarning("QSocketNotifier: Invalid socket specified");
    else if (!thisThreadData->hasEventDispatcher())
        qWarning("QSocketNotifier: Can only be used with threads started with QThread");
    else
        thisThreadData->eventDispatcher.loadRelaxed()->registerSocketNotifier(this);
}
 
QSocketNotifier::~QSocketNotifier()
{
    setEnabled(false);
}
 
 
void QSocketNotifier::setSocket(qintptr socket)
{
    Q_D(QSocketNotifier);
 
    setEnabled(false);
    d->sockfd = socket;
}
 
qintptr QSocketNotifier::socket() const
{
    Q_D(const QSocketNotifier);
    return qintptr(d->sockfd);
}
 
QSocketNotifier::Type QSocketNotifier::type() const
{
    Q_D(const QSocketNotifier);
    return d->sntype;
}
 
bool QSocketNotifier::isValid() const
{
    Q_D(const QSocketNotifier);
    return d->sockfd.isValid();
}
 
bool QSocketNotifier::isEnabled() const
{
    Q_D(const QSocketNotifier);
    return d->snenabled;
}
 
void QSocketNotifier::setEnabled(bool enable)
{
    Q_D(QSocketNotifier);
    if (!d->sockfd.isValid())
        return;
    if (d->snenabled == enable)                        // no change
        return;
    d->snenabled = enable;
 
 
    auto thisThreadData = d->threadData.loadRelaxed();
 
    if (!thisThreadData->hasEventDispatcher()) // perhaps application/thread is shutting down
        return;
    if (Q_UNLIKELY(thread() != QThread::currentThread())) {
        qWarning("QSocketNotifier: Socket notifiers cannot be enabled or disabled from another thread");
        return;
    }
    if (d->snenabled)
        thisThreadData->eventDispatcher.loadRelaxed()->registerSocketNotifier(this);
    else
        thisThreadData->eventDispatcher.loadRelaxed()->unregisterSocketNotifier(this);
}
 
 
bool QSocketNotifier::event(QEvent *e)
{
    Q_D(QSocketNotifier);
    // Emits the activated() signal when a QEvent::SockAct or QEvent::SockClose is
    // received.
    switch (e->type()) {
    case QEvent::ThreadChange:
        if (d->snenabled) {
            QMetaObject::invokeMethod(this, "setEnabled", Qt::QueuedConnection,
                                      Q_ARG(bool, d->snenabled));
            setEnabled(false);
        }
        break;
    case QEvent::SockAct:
    case QEvent::SockClose:
        {
            QPointer<QSocketNotifier> alive(this);
            emit activated(d->sockfd, d->sntype, QPrivateSignal());
            // ### Qt7: Remove emission if the activated(int) signal is removed
            if (alive)
                emit activated(int(qintptr(d->sockfd)), QPrivateSignal());
        }
        return true;
    default:
        break;
    }
    return QObject::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qsocketnotifier.cpp"