ZScriptThread.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * Filename:   ZScriptThread.cpp
 * Created on: 11/9/2014
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZScriptThread.h"
#include "ZScriptWorker.h"
#include "ZblApp.h"
#include "ZblJsonHelper.h"

#include <QtQml>
#include <QVariant>


namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZScriptThread)

ZScriptThread::ZScriptThread(QObject *parent) :
    QObject(parent), m_initReady(false), m_threadCompleted(false)
{
    zDebug() << "ZScriptThread::ZScriptThread";

    m_thread = new QThread(this);

    m_worker = new ZScriptWorker(this);

    m_worker->moveToThread(m_thread);

    connect(m_worker, &ZScriptWorker::execComplete, this,
            &ZScriptThread::onWorkerExecComplete, Qt::QueuedConnection);

    connect(m_thread, &QThread::started, m_worker,
            &ZScriptWorker::onStarted, Qt::QueuedConnection);

    connect(m_thread, &QThread::started, this,
            &ZScriptThread::onStarted, Qt::BlockingQueuedConnection);

    connect(m_thread, &QThread::finished, this,
            &ZScriptThread::onFinished, Qt::BlockingQueuedConnection);

}

ZScriptThread::~ZScriptThread()
{
    qDebug("ZScriptThread::~ZScriptThread");

    destroyThread();
}

void ZScriptThread::destroyThread()
{
    qDebug("ZScriptThread::destroyThread");

    if(!m_thread)
        return;

    if(m_initReady)
    {
        m_initReady = false;

        emit readyChanged();
    }

    if(m_thread->isRunning())
    {
        m_thread->quit();

        waitThreadComplete();
    }

    delete m_worker;

     m_worker = nullptr;

     delete m_thread;

    m_thread = nullptr;
}

QString ZScriptThread::getInitScript()
{
    return m_initScript;
}

void ZScriptThread::setInitScript(const QString& script)
{
    if(m_initReady)
        zWarning() << "WARNING - programming error: initScript "
        "can't be set after initizlization";
    else
        m_initScript = script;
}

QVariant ZScriptThread::getInitError()
{
    return m_initError;
}

bool ZScriptThread::getReady()
{
    return  m_initReady;
}

bool ZScriptThread::getCompleted()
{
    return  m_threadCompleted;
}

void ZScriptThread::start()
{
    if(!m_thread)
    {
        zWarning() << "Programming error; Thread already destroyed.";
        return;
    }

    if(!m_initReady && !m_initScript.isEmpty())
    {
        // We must check m_initReady BEFORE calling QThread::start
        // since QThread::starting signal could set it before executing
        // the following code, at least in theory

        zDebug() << "Starting thread: " << ptrToString(m_thread);
        m_thread->start();

        static int snipLength = 150;
        QString snipText = m_initScript.left(snipLength);
        if(m_initScript.size() > 150)
            snipText += "...";
        zDebug() << "Loading init script: " << snipText;
        execScript(static_cast<qulonglong>(-1), m_initScript);
    }
    else
    {
        zDebug() << "Starting thread: " << ptrToString(m_thread);
        m_thread->start();

        zDebug() << "No init script";
    }
}

void ZScriptThread::quit()
{
    if(m_thread)
    {
        m_thread->quit();

        //zDebug() << "Quit! running = " << m_thread->isRunning();
    }
}

void ZScriptThread::execScript(qulonglong requestID, const QString& script, QVariantMap userData)
{
    zDebug() << "execScript ID=" << requestID << ", script = " << script.left(150) << ", userData = " << userData;

    if(!m_thread)
    {
        zWarning() << "Programming error: Thread already destroyed.";
        return;
    }

    QVariant data(userData);
    QString jsonUserData = variantToJson(data);

    QMetaObject::invokeMethod(m_worker,"execScript",
                              Qt::QueuedConnection,
                              Q_ARG(qulonglong, requestID),
                              Q_ARG(const QString&, script),
                              Q_ARG(QString, jsonUserData)
                              );
}

void ZScriptThread::onWorkerExecComplete(qulonglong requestID, QString result, QString userData)
{
    QVariant varResult = jsonToVariant(result);
    QVariant varUserData = jsonToVariant(userData);

    if(requestID == static_cast<qulonglong>(-1) && !m_initReady && !m_initScript.isEmpty())
    {
        m_initError = varResult;

        m_initReady = true;

        emit readyChanged();

        emit initComplete(varResult);
    }
    else
    {
        emit execComplete(requestID, varResult, varUserData);
    }
}

void ZScriptThread::onThreadAlert(QString signalID,
                               QString payload,
                               int conversion)
{
    zDebug() << "ZScriptThread ALERT id=" << signalID << ", payload=" << payload;

   QVariant var;

    switch(conversion)
    {
    case INTEGER:

        var = QVariant(payload.toInt());

    break;

    case DOUBLE:

        var = QVariant(payload.toDouble());

    break;

    case STRING:

        var = QVariant(payload);

    break;

    case JSON:

        var = jsonToVariant(payload);

    break;

    case UNDEFINED:

    zWarning() << "ZScriptThread::onThreadAlert received UNDEFINED conversion value: " << conversion;

    return;

    default:

        zWarning() << "ZScriptThread::onThreadAlert received unrecognized conversion value: " << conversion;

    return;

    }

    emit alert(signalID, var);
}

void ZScriptThread::onStarted()
{
    zDebug() << "QThread STARTED: " << ptrToString(m_thread);

    if(m_initScript.isEmpty())
    {
        emit initComplete(QVariant());

        m_initReady = true;

        zDebug() << "ZScriptThread::readyChanged";

        emit readyChanged();
    }
}


void ZScriptThread::onFinished()
{
    zDebug() << "QThread FINISHED: " << ptrToString(m_thread);

    if(m_initReady)
    {
        m_initReady = false;

        emit readyChanged();
    }

    m_threadCompleted = true;

    emit completeChanged();

    emit finished();
}



bool ZScriptThread::isInterrupted() const
{
    if(!m_thread)
        return true;
    else
        return m_thread->isInterruptionRequested();
}

void ZScriptThread::sendInterruptRequest()
{
    m_thread->requestInterruption();
}

bool ZScriptThread::waitThreadComplete(unsigned long time)
{

    // We keep our message pump running in case the thread we're waiting on is
    // communicating with objects in our thread, to prevent deadlock.

    bool status = false;

    unsigned long waitTime = 25;
    unsigned long count = time > waitTime ? time / waitTime : 1;
    QAbstractEventDispatcher* d = QThread::currentThread()->eventDispatcher();

    for(unsigned long i=0; i < count; i++)
    {
        if(m_thread->wait(waitTime))
        {
            status = true;
            break;
        }

        d->processEvents(QEventLoop::AllEvents);
    }

    if(!status)
        zWarning() << "THREAD WAIT TIMED OUT";

    return status;
}

void ZScriptThread::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterType<ZScriptThread>("org.zuble.qml", 1, 0, "ZScriptThread");
}

QString ZScriptThread::variantToJson(QVariant& var)
{
    QJsonDocument doc = QJsonDocument::fromVariant(var);
    QByteArray jsonText = doc.toJson(QJsonDocument::Compact);
    return QString(jsonText);
}

QVariant ZScriptThread::jsonToVariant(const QString& json)
{
    QVariant retVal;

    if(!json.isEmpty())
    {
        QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8().constData());
        retVal = doc.toVariant();
    }

    return retVal;
}


} // Zbl