noo/client/platforms/hidtracker.cpp

#include "hidtracker.h"
#include "hidtrackerimpl.h"
#include <QTimer>

#ifdef TARGET_OSX
# include "platforms/osx/hidtrackerimpl_osx.h"
#endif

HIDActivityTracker::HIDActivityTracker()
    :mInterval(600), mTrackerActive(false), mState(None), mImpl(nullptr)
{
#ifdef TARGET_OSX
    mImpl = new HIDTrackerImplOSX();
    mImpl->setInterval(mInterval);
#endif

    // Check timer belongs to this object
    mCheckTimer = new QTimer(this);
    mCheckTimer->setSingleShot(false);
    connect(mCheckTimer, SIGNAL(timeout()), this, SLOT(checkState()));
}

HIDActivityTracker::~HIDActivityTracker()
{
}

bool HIDActivityTracker::isPossible()
{
    if (!mImpl)
        return false;
    return mImpl->isPossible();
}

void HIDActivityTracker::setInterval(int seconds)
{
    if (mImpl)
        mImpl->setInterval(seconds);

    mInterval = seconds;
}

int HIDActivityTracker::interval() const
{
    return mInterval;
}

bool HIDActivityTracker::isTrackerActive()
{
    return mTrackerActive;
}

bool HIDActivityTracker::start()
{
    if (mTrackerActive)
        return true;

    if (mImpl)
        mTrackerActive = mImpl->start();

    mState = None;
    mIdleSignalSent = false;
    mActivitySignalSent = false;
    if (mTrackerActive)
        mCheckTimer->start(1000);

    return mTrackerActive;
}

void HIDActivityTracker::stop()
{
    if (!mTrackerActive)
        return;

    if (mImpl)
        mImpl->stop();

    mState = None;
    mCheckTimer->stop();
    mTrackerActive = false;
}

bool HIDActivityTracker::isUserActive()
{
    if (!mImpl)
        return true;

    return mImpl->isUserActive();
}

void HIDActivityTracker::resetUserActive()
{
    if (!mImpl)
        return;
    mState = None;
    mImpl->resetUserActive();
}

void HIDActivityTracker::acceptIdleState()
{
    mState = Idle;
}

void HIDActivityTracker::acceptUserActiveState()
{
    mState = UserActive;
}

void HIDActivityTracker::checkState()
{
    if (!mTrackerActive)
        return;

    // Now activity tracker is started, check if there was user activity during interval
    if (!mImpl->isUserActive())
    {
        switch (mState)
        {
        case None:
            mState = Idle;
            break;

        case Idle:
            break;

        case UserActive:
            if (!mIdleSignalSent)
            {
                mIdleSignalSent = true;
                mActivitySignalSent = false;
                emit idleDetected();
            }
            break;
        }
    }
    else
    {
        switch (mState)
        {
        case None:
            mState = UserActive;
            break;

        case UserActive:
            break;

        case Idle:
            if (!mActivitySignalSent)
            {
                mActivitySignalSent = true;
                mIdleSignalSent = false;
                emit activityDetected();
            }
            break;
        }
    }
}