qtimer.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtimer.h"
#include "qtimer_p.h"
 
#include "qabstracteventdispatcher.h"
#include "qcoreapplication.h"
#include "qcoreapplication_p.h"
#include "qdeadlinetimer.h"
#include "qmetaobject_p.h"
#include "qobject_p.h"
#include "qproperty_p.h"
#include "qthread.h"
 
QT_BEGIN_NAMESPACE
 
QTimer::QTimer(QObject *parent)
    : QObject(*new QTimerPrivate, parent)
{
}
 
 
QTimer::~QTimer()
{
    if (d_func()->id != QTimerPrivate::INV_TIMER) // stop running timer
        stop();
}
 
 
bool QTimer::isActive() const
{
    return d_func()->isActiveData.value();
}
 
QBindable<bool> QTimer::bindableActive()
{
    return QBindable<bool>(&d_func()->isActiveData);
}
 
int QTimer::timerId() const
{
    return d_func()->id;
}
 
 
void QTimer::start()
{
    Q_D(QTimer);
    if (d->id != QTimerPrivate::INV_TIMER) // stop running timer
        stop();
    d->id = QObject::startTimer(std::chrono::milliseconds{d->inter}, d->type);
    d->isActiveData.notify();
}
 
void QTimer::start(int msec)
{
    Q_D(QTimer);
    const bool intervalChanged = msec != d->inter;
    d->inter.setValue(msec);
    start();
    if (intervalChanged)
        d->inter.notify();
}
 
 
 
void QTimer::stop()
{
    Q_D(QTimer);
    if (d->id != QTimerPrivate::INV_TIMER) {
        QObject::killTimer(d->id);
        d->id = QTimerPrivate::INV_TIMER;
        d->isActiveData.notify();
    }
}
 
 
void QTimer::timerEvent(QTimerEvent *e)
{
    Q_D(QTimer);
    if (e->timerId() == d->id) {
        if (d->single)
            stop();
        emit timeout(QPrivateSignal());
    }
}
 
class QSingleShotTimer : public QObject
{
    Q_OBJECT
    int timerId = -1;
public:
    ~QSingleShotTimer();
    QSingleShotTimer(int msec, Qt::TimerType timerType, const QObject *r, const char * m);
    QSingleShotTimer(int msec, Qt::TimerType timerType, const QObject *r, QtPrivate::QSlotObjectBase *slotObj);
 
    void startTimerForReceiver(int msec, Qt::TimerType timerType, const QObject *receiver);
 
Q_SIGNALS:
    void timeout();
protected:
    void timerEvent(QTimerEvent *) override;
};
 
QSingleShotTimer::QSingleShotTimer(int msec, Qt::TimerType timerType, const QObject *r, const char *member)
    : QObject(QAbstractEventDispatcher::instance())
{
    connect(this, SIGNAL(timeout()), r, member);
 
    startTimerForReceiver(msec, timerType, r);
}
 
QSingleShotTimer::QSingleShotTimer(int msec, Qt::TimerType timerType, const QObject *r, QtPrivate::QSlotObjectBase *slotObj)
    : QObject(QAbstractEventDispatcher::instance())
{
    int signal_index = QMetaObjectPrivate::signalOffset(&staticMetaObject);
    Q_ASSERT(QMetaObjectPrivate::signal(&staticMetaObject, signal_index).name() == "timeout");
    QObjectPrivate::connectImpl(this, signal_index, r ? r : this, nullptr, slotObj,
                                Qt::AutoConnection, nullptr, &staticMetaObject);
 
    startTimerForReceiver(msec, timerType, r);
}
 
QSingleShotTimer::~QSingleShotTimer()
{
    if (timerId > 0)
        killTimer(timerId);
}
 
/*
    Move the timer, and the dispatching and handling of the timer event, into
    the same thread as where it will be handled, so that it fires reliably even
    if the thread that set up the timer is busy.
*/
void QSingleShotTimer::startTimerForReceiver(int msec, Qt::TimerType timerType, const QObject *receiver)
{
    if (receiver && receiver->thread() != thread()) {
        // Avoid leaking the QSingleShotTimer instance in case the application exits before the timer fires
        connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, this, &QObject::deleteLater);
        setParent(nullptr);
        moveToThread(receiver->thread());
 
        QDeadlineTimer deadline(std::chrono::milliseconds{msec}, timerType);
        QMetaObject::invokeMethod(this, [this, deadline, timerType]{
            if (deadline.hasExpired())
                emit timeout();
            else
                timerId = startTimer(std::chrono::milliseconds{deadline.remainingTime()}, timerType);
        }, Qt::QueuedConnection);
    } else {
        timerId = startTimer(std::chrono::milliseconds{msec}, timerType);
    }
}
 
 
void QSingleShotTimer::timerEvent(QTimerEvent *)
{
    // need to kill the timer _before_ we emit timeout() in case the
    // slot connected to timeout calls processEvents()
    if (timerId > 0)
        killTimer(timerId);
    timerId = -1;
 
    emit timeout();
 
    // we would like to use delete later here, but it feels like a
    // waste to post a new event to handle this event, so we just unset the flag
    // and explicitly delete...
    qDeleteInEventHandler(this);
}
 
void QTimer::singleShotImpl(int msec, Qt::TimerType timerType,
                            const QObject *receiver,
                            QtPrivate::QSlotObjectBase *slotObj)
{
    if (msec == 0) {
        bool deleteReceiver = false;
        // Optimize: set a receiver context when none is given, such that we can use
        // QMetaObject::invokeMethod which is more efficient than going through a timer.
        // We need a QObject living in the current thread. But the QThread itself lives
        // in a different thread - with the exception of the main QThread which lives in
        // itself. And QThread::currentThread() is among the few QObjects we know that will
        // most certainly be there. Note that one can actually call singleShot before the
        // QApplication is created!
        if (!receiver && QThread::currentThread() == QCoreApplicationPrivate::mainThread()) {
            // reuse main thread as context object
            receiver = QThread::currentThread();
        } else if (!receiver) {
            // Create a receiver context object on-demand. According to the benchmarks,
            // this is still more efficient than going through a timer.
            receiver = new QObject;
            deleteReceiver = true;
        }
 
        QMetaObject::invokeMethodImpl(const_cast<QObject *>(receiver), slotObj,
                                      Qt::QueuedConnection, nullptr);
 
        if (deleteReceiver)
            const_cast<QObject *>(receiver)->deleteLater();
        return;
    }
 
    new QSingleShotTimer(msec, timerType, receiver, slotObj);
}
 
void QTimer::singleShot(int msec, const QObject *receiver, const char *member)
{
    // coarse timers are worst in their first firing
    // so we prefer a high precision timer for something that happens only once
    // unless the timeout is too big, in which case we go for coarse anyway
    singleShot(msec, msec >= 2000 ? Qt::CoarseTimer : Qt::PreciseTimer, receiver, member);
}
 
void QTimer::singleShot(int msec, Qt::TimerType timerType, const QObject *receiver, const char *member)
{
    if (Q_UNLIKELY(msec < 0)) {
        qWarning("QTimer::singleShot: Timers cannot have negative timeouts");
        return;
    }
    if (receiver && member) {
        if (msec == 0) {
            // special code shortpath for 0-timers
            const char* bracketPosition = strchr(member, '(');
            if (!bracketPosition || !(member[0] >= '0' && member[0] <= '2')) {
                qWarning("QTimer::singleShot: Invalid slot specification");
                return;
            }
            QByteArray methodName(member+1, bracketPosition - 1 - member); // extract method name
            QMetaObject::invokeMethod(const_cast<QObject *>(receiver), methodName.constData(), Qt::QueuedConnection);
            return;
        }
        (void) new QSingleShotTimer(msec, timerType, receiver, member);
    }
}
 
void QTimer::setSingleShot(bool singleShot)
{
    d_func()->single = singleShot;
}
 
bool QTimer::isSingleShot() const
{
    return d_func()->single;
}
 
QBindable<bool> QTimer::bindableSingleShot()
{
    return QBindable<bool>(&d_func()->single);
}
 
void QTimer::setInterval(int msec)
{
    Q_D(QTimer);
    const bool intervalChanged = msec != d->inter;
    d->inter.setValue(msec);
    if (d->id != QTimerPrivate::INV_TIMER) { // create new timer
        QObject::killTimer(d->id);                        // restart timer
        d->id = QObject::startTimer(std::chrono::milliseconds{msec}, d->type);
        // No need to call markDirty() for d->isActiveData here,
        // as timer state actually does not change
    }
    if (intervalChanged)
        d->inter.notify();
}
 
int QTimer::interval() const
{
    return d_func()->inter;
}
 
QBindable<int> QTimer::bindableInterval()
{
    return QBindable<int>(&d_func()->inter);
}
 
int QTimer::remainingTime() const
{
    Q_D(const QTimer);
    if (d->id != QTimerPrivate::INV_TIMER) {
        return QAbstractEventDispatcher::instance()->remainingTime(d->id);
    }
 
    return -1;
}
 
void QTimer::setTimerType(Qt::TimerType atype)
{
    d_func()->type = atype;
}
 
Qt::TimerType QTimer::timerType() const
{
    return d_func()->type;
}
 
QBindable<Qt::TimerType> QTimer::bindableTimerType()
{
    return QBindable<Qt::TimerType>(&d_func()->type);
}
 
QT_END_NAMESPACE
 
#include "qtimer.moc"
#include "moc_qtimer.cpp"