/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qeventdispatcher_symbian_p.h"

#include <private/qthread_p.h>

#include <qcoreapplication.h>

#include <private/qcoreapplication_p.h>

#include <unistd.h>

#include <errno.h>

QT_BEGIN_NAMESPACE

#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS

// when the system UI is Qt based, priority drop is not needed as CPU starved processes will not be killed.

#undef QT_SYMBIAN_PRIORITY_DROP

#else

#define QT_SYMBIAN_PRIORITY_DROP

#endif

#define WAKE_UP_PRIORITY CActive::EPriorityStandard

#define TIMER_PRIORITY CActive::EPriorityHigh

#define NULLTIMER_PRIORITY CActive::EPriorityLow

#define COMPLETE_DEFERRED_ACTIVE_OBJECTS_PRIORITY CActive::EPriorityIdle

static inline int qt_pipe_write(int socket, const char *data, qint64 len)

{

	return ::write(socket, data, len);

}

#if defined(write)

# undef write

#endif

static inline int qt_pipe_close(int socket)

{

	return ::close(socket);

}

#if defined(close)

# undef close

#endif

static inline int qt_pipe_fcntl(int socket, int command)

{

	return ::fcntl(socket, command);

}

static inline int qt_pipe2_fcntl(int socket, int command, int option)

{

	return ::fcntl(socket, command, option);

}

#if defined(fcntl)

# undef fcntl

#endif

static inline int qt_socket_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)

{

	return ::select(nfds, readfds, writefds, exceptfds, timeout);

}

// This simply interrupts the select and locks the mutex until destroyed.

class QSelectMutexGrabber

{

public:

    QSelectMutexGrabber(int fd, QMutex *mutex)

        : m_mutex(mutex)

    {

        if (m_mutex->tryLock())

            return;

        char dummy = 0;

        qt_pipe_write(fd, &dummy, 1);

        m_mutex->lock();

    }

    ~QSelectMutexGrabber()

    {

        m_mutex->unlock();

    }

private:

    QMutex *m_mutex;

};

/*

 * This class is designed to aid in implementing event handling in a more round robin fashion. We

 * cannot change active objects that we do not own, but the active objects that Qt owns will use

 * this as a base class with convenience functions.

 *

 * Here is how it works: On every RunL, the deriving class should call okToRun(). This will allow

 * exactly one run of the active object, and mark it as such. If it is called again, it will return

 * false, and add the object to a queue so it can be run later.

 *

 * The QCompleteDeferredAOs class is a special object that runs after all others, which will

 * reactivate the objects that were previously not run.

 */

inline QActiveObject::QActiveObject(TInt priority, QEventDispatcherSymbian *dispatcher)

    : CActive(priority),

      m_dispatcher(dispatcher),

      m_hasAlreadyRun(false),

      m_hasRunAgain(false),

      m_iterationCount(1)

{

}

QActiveObject::~QActiveObject()

{

    if (m_hasRunAgain)

        m_dispatcher->removeDeferredActiveObject(this);

}

bool QActiveObject::okToRun()

{

    Q_ASSERT(!m_hasRunAgain);

    if (!m_hasAlreadyRun || m_dispatcher->iterationCount() != m_iterationCount) {

        // First occurrence of this event in this iteration.

        m_hasAlreadyRun = true;

        m_iterationCount = m_dispatcher->iterationCount();

        return true;

    } else {

        // The event has already occurred.

        m_dispatcher->addDeferredActiveObject(this);

        m_hasRunAgain = true;

        return false;

    }

}

void QActiveObject::reactivateAndComplete()

{

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus *status = &iStatus;

    QEventDispatcherSymbian::RequestComplete(status, KErrNone);

    m_hasRunAgain = false;

    m_hasAlreadyRun = false;

}

QWakeUpActiveObject::QWakeUpActiveObject(QEventDispatcherSymbian *dispatcher)

    : CActive(WAKE_UP_PRIORITY),

      m_dispatcher(dispatcher)

{

    CActiveScheduler::Add(this);

    iStatus = KRequestPending;

    SetActive();

}

QWakeUpActiveObject::~QWakeUpActiveObject()

{

    Cancel();

}

void QWakeUpActiveObject::DoCancel()

{

    if (iStatus.Int() == KRequestPending) {

        TRequestStatus *status = &iStatus;

        QEventDispatcherSymbian::RequestComplete(status, KErrNone);

    }

}

void QWakeUpActiveObject::RunL()

{

    iStatus = KRequestPending;

    SetActive();

    QT_TRYCATCH_LEAVING(m_dispatcher->wakeUpWasCalled());

}

QTimerActiveObject::QTimerActiveObject(QEventDispatcherSymbian *dispatcher, SymbianTimerInfo *timerInfo)

    : QActiveObject((timerInfo->interval) ? TIMER_PRIORITY : NULLTIMER_PRIORITY , dispatcher),

      m_timerInfo(timerInfo)

{

}

QTimerActiveObject::~QTimerActiveObject()

{

    Cancel();

}

void QTimerActiveObject::DoCancel()

{

    if (m_timerInfo->interval > 0) {

        m_rTimer.Cancel();

        m_rTimer.Close();

    } else {

        if (iStatus.Int() == KRequestPending) {

            TRequestStatus *status = &iStatus;

            QEventDispatcherSymbian::RequestComplete(status, KErrNone);

        }

    }

}

void QTimerActiveObject::RunL()

{

    int error;

    QT_TRYCATCH_ERROR(error, Run());

    // All Symbian error codes are negative.

    if (error < 0) {

        CActiveScheduler::Current()->Error(error);  // stop and report here, as this timer will be deleted on scope exit

    }

}

#define MAX_SYMBIAN_TIMEOUT_MS 2000000

void QTimerActiveObject::StartTimer()

{

    if (m_timerInfo->msLeft > MAX_SYMBIAN_TIMEOUT_MS) {

        //There is loss of accuracy anyway due to needing to restart the timer every 33 minutes,

        //so the 1/64s res of After() is acceptable for these very long timers.

        m_rTimer.After(iStatus, MAX_SYMBIAN_TIMEOUT_MS * 1000);

        m_timerInfo->msLeft -= MAX_SYMBIAN_TIMEOUT_MS;

    } else {

        //HighRes gives the 1ms accuracy expected by Qt, the +1 is to ensure that

        //"Timers will never time out earlier than the specified timeout value"

        //condition is always met.

        m_rTimer.HighRes(iStatus, (m_timerInfo->msLeft + 1) * 1000);

        m_timerInfo->msLeft = 0;

    }

    SetActive();

}

void QTimerActiveObject::Run()

{

    //restart timer immediately, if the timeout has been split because it overflows max for platform.

    if (m_timerInfo->msLeft > 0) {

        StartTimer();

        return;

    }

    if (!okToRun())

        return;

    if (m_timerInfo->interval > 0) {

        // Start a new timer immediately so that we don't lose time.

        m_timerInfo->msLeft = m_timerInfo->interval;

        StartTimer();

        m_timerInfo->dispatcher->timerFired(m_timerInfo->timerId);

    } else {

        // However, we only complete zero timers after the event has finished,

        // in order to prevent busy looping when doing nested loops.

        // Keep the refpointer around in order to avoid deletion until the end of this function.

        SymbianTimerInfoPtr timerInfoPtr(m_timerInfo);

        m_timerInfo->dispatcher->timerFired(m_timerInfo->timerId);

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus *status = &iStatus;

        QEventDispatcherSymbian::RequestComplete(status, KErrNone);

    }

}

void QTimerActiveObject::Start()

{

    CActiveScheduler::Add(this);

    m_timerInfo->msLeft = m_timerInfo->interval;

    if (m_timerInfo->interval > 0) {

        m_rTimer.CreateLocal();

        StartTimer();

    } else {

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus *status = &iStatus;

        QEventDispatcherSymbian::RequestComplete(status, KErrNone);

    }

}

SymbianTimerInfo::SymbianTimerInfo()

    : timerAO(0)

{

}

SymbianTimerInfo::~SymbianTimerInfo()

{

    delete timerAO;

}

QCompleteDeferredAOs::QCompleteDeferredAOs(QEventDispatcherSymbian *dispatcher)

    : CActive(COMPLETE_DEFERRED_ACTIVE_OBJECTS_PRIORITY),

      m_dispatcher(dispatcher)

{

    CActiveScheduler::Add(this);

    iStatus = KRequestPending;

    SetActive();

}

QCompleteDeferredAOs::~QCompleteDeferredAOs()

{

    Cancel();

}

void QCompleteDeferredAOs::complete()

{

    if (iStatus.Int() == KRequestPending) {

        TRequestStatus *status = &iStatus;

        QEventDispatcherSymbian::RequestComplete(status, KErrNone);

    }

}

void QCompleteDeferredAOs::DoCancel()

{

    if (iStatus.Int() == KRequestPending) {

        TRequestStatus *status = &iStatus;

        QEventDispatcherSymbian::RequestComplete(status, KErrNone);

    }

}

void QCompleteDeferredAOs::RunL()

{

    iStatus = KRequestPending;

    SetActive();

    QT_TRYCATCH_LEAVING(m_dispatcher->reactivateDeferredActiveObjects());

}

QSelectThread::QSelectThread()

    : m_quit(false)

{

    if (::pipe(m_pipeEnds) != 0) {

        qWarning("Select thread was unable to open a pipe, errno: %i", errno);

    } else {

        int flags0 = qt_pipe_fcntl(m_pipeEnds[0], F_GETFL);

        int flags1 = qt_pipe_fcntl(m_pipeEnds[1], F_GETFL);

        // We should check the error code here, but Open C has a bug that returns

        // failure even though the operation was successful.

        qt_pipe2_fcntl(m_pipeEnds[0], F_SETFL, flags0 | O_NONBLOCK);

        qt_pipe2_fcntl(m_pipeEnds[1], F_SETFL, flags1 | O_NONBLOCK);

    }

}

QSelectThread::~QSelectThread()

{

    qt_pipe_close(m_pipeEnds[1]);

    qt_pipe_close(m_pipeEnds[0]);

}

void QSelectThread::run()

{

    Q_D(QThread);

    m_mutex.lock();

    while (!m_quit) {

        fd_set readfds;

        fd_set writefds;

        fd_set exceptionfds;

        FD_ZERO(&readfds);

        FD_ZERO(&writefds);

        FD_ZERO(&exceptionfds);

        int maxfd = 0;

        maxfd = qMax(maxfd, updateSocketSet(QSocketNotifier::Read, &readfds));

        maxfd = qMax(maxfd, updateSocketSet(QSocketNotifier::Write, &writefds));

        maxfd = qMax(maxfd, updateSocketSet(QSocketNotifier::Exception, &exceptionfds));

        maxfd = qMax(maxfd, m_pipeEnds[0]);

        maxfd++;

        FD_SET(m_pipeEnds[0], &readfds);

        int ret;

        int savedSelectErrno;

        ret = qt_socket_select(maxfd, &readfds, &writefds, &exceptionfds, 0);

        savedSelectErrno = errno;

        char buffer;

        while (::read(m_pipeEnds[0], &buffer, 1) > 0) {}

        if(ret == 0) {

         // do nothing

        } else if (ret < 0) {

            switch (savedSelectErrno) {

            case EBADF:

            case EINVAL:

            case ENOMEM:

            case EFAULT:

                qWarning("::select() returned an error: %i", savedSelectErrno);

                break;

            case ECONNREFUSED:

            case EPIPE:

                qWarning("::select() returned an error: %i (go through sockets)", savedSelectErrno);

                // prepare to go through all sockets

                // mark in fd sets both:

                //     good ones

                //     ones that return -1 in select

                // after loop update notifiers for all of them

                // as we dont have "exception" notifier type

                // we should force monitoring fd_set of this

                // type as well

                // clean @ start

                FD_ZERO(&readfds);

                FD_ZERO(&writefds);

                FD_ZERO(&exceptionfds);

                for (QHash<QSocketNotifier *, TRequestStatus *>::const_iterator i = m_AOStatuses.begin();

                        i != m_AOStatuses.end(); ++i) {

                    fd_set onefds;

                    FD_ZERO(&onefds);

                    FD_SET(i.key()->socket(), &onefds);

                    fd_set excfds;

                    FD_ZERO(&excfds);

                    FD_SET(i.key()->socket(), &excfds);

                    maxfd = i.key()->socket() + 1;

                    struct timeval timeout;

                    timeout.tv_sec = 0;

                    timeout.tv_usec = 0;

                    ret = 0;

                    if(i.key()->type() == QSocketNotifier::Read) {

                        ret = ::select(maxfd, &onefds, 0, &excfds, &timeout);

                        if(ret != 0) FD_SET(i.key()->socket(), &readfds);

                    } else if(i.key()->type() == QSocketNotifier::Write) {

                        ret = ::select(maxfd, 0, &onefds, &excfds, &timeout);

                        if(ret != 0) FD_SET(i.key()->socket(), &writefds);

                    }

                } // end for

                // traversed all, so update

                updateActivatedNotifiers(QSocketNotifier::Read, &readfds);

                updateActivatedNotifiers(QSocketNotifier::Write, &writefds);

                updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);

                break;

            case EINTR: // Should never occur on Symbian, but this is future proof!

            default:

                qWarning("::select() returned an unknown error: %i", savedSelectErrno);

                break;

            }

        } else {

            updateActivatedNotifiers(QSocketNotifier::Read, &readfds);

            updateActivatedNotifiers(QSocketNotifier::Write, &writefds);

            updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);

        }

        m_waitCond.wait(&m_mutex);

    }

    m_mutex.unlock();

}

void QSelectThread::requestSocketEvents ( QSocketNotifier *notifier, TRequestStatus *status )

{

    Q_D(QThread);

    if (!isRunning()) {

        start();

    }

    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex);

    Q_ASSERT(!m_AOStatuses.contains(notifier));

    m_AOStatuses.insert(notifier, status);

    m_waitCond.wakeAll();

}

void QSelectThread::cancelSocketEvents ( QSocketNotifier *notifier )

{

    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex);

    m_AOStatuses.remove(notifier);

    m_waitCond.wakeAll();

}

void QSelectThread::restart()

{

    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex);

    m_waitCond.wakeAll();

}

int QSelectThread::updateSocketSet(QSocketNotifier::Type type, fd_set *fds)

{

    int maxfd = 0;

    if(m_AOStatuses.isEmpty()) {

        /*