ZblApp.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZblApp.cpp
 *
 *  Created on: Feb 3, 2013
 *      Author: Bob Dinitto   bob@ninzo.com
 *
 * 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 "ZblApp.h"
#include "ZblException.h"
#include "ZApplication.h"
#include "ZblThreadErr.h"
#include "ZScriptThread.h"
#include "zglobal.h"
#include "ZDir.h"
#include "ZFile.h"
#include "ZByteArray.h"
#include "ZTextStream.h"
#include "ZDataStream.h"
#include "ZSchemaValidator.h"
#include "ZTableModel.h"
#include "ZblCog.h"
#include "ZblFactory.h"
#include "ZblLogManager.h"
#include "ZSettings.h"
#include "ZFileSystemWatcher.h"
#include "ZMessageQueue.h"
#include "ZMailslot.h"
#include "ZMailbox.h"
#include "ZMap.h"
#include "ZScopedMap.h"
#include "ZLogReader.h"
#include "ZxQuery.h"
#include "ZProcess.h"
#include <QtQml>
#include <QVariant>

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZblApp)

QVariant ZblApp::m_tags;
QReadWriteLock ZblApp::m_lock(QReadWriteLock::Recursive); // TBD: need this?

QThreadStorage<ZblApp::AppPtr*> ZblApp::m_zApp;

ZblApp::ZblApp(QJSEngine* scriptEngine,
               ZScriptThread *container,
               QObject* parent)
    : QObject(parent), m_engine(scriptEngine), m_container(container)
{

    //ZBL_REGISTER_LOGGED_OBJECT
    zDebug() << "ZblApp::ZblApp";

    m_zApp.setLocalData(new AppPtr(this));

    createTags();

    connect( &zApp.zStatus(), SIGNAL(dataReady(const QString&)),
             SIGNAL(statusAvailable(QString)));

    connect( this, SIGNAL(destroyed(QObject*)),
            SLOT(onDestroyed(QObject*)));

    connect( this, SIGNAL(exit(int)),
            this, SLOT(exitApp(int)), Qt::QueuedConnection);

}

ZblApp::~ZblApp()
{
    zDebug() << "ZblApp::~ZblApp";

    stopAllTimers();
}

ZblApp& ZblApp::zInstance()
{
    if(!m_zApp.hasLocalData())
        throw ZblException("ZblApp::zInstance - a ZblApp object hasn't been "
                           "constructed for the current thread.");

    return *m_zApp.localData()->m_app;
}

void ZblApp::createTags()
{
    if(!m_tags.isNull())
        return;

    QVariantMap map;

    map.insert("appDirPath", ZApplication::appDirPath);
    map.insert("appFilePath",  ZApplication::appFilePath);
    map.insert("appName",  ZApplication::appName);
    map.insert("appPid",  ZApplication::appPid);
    map.insert("appVersion",  ZApplication::appVersion);
    map.insert("appArguments",  ZApplication::appArguments);
    map.insert("appLibraryPath",  ZApplication::appLibraryPath);

    map.insert("LogFieldRecordNum",  ZblLogManager::LogFieldRecordNum);
    map.insert("LogFieldCategory",  ZblLogManager::LogFieldCategory);
    map.insert("LogFieldSource",  ZblLogManager::LogFieldSource);
    map.insert("LogFieldMessage",  ZblLogManager::LogFieldMessage);
    map.insert("LogFieldFunction",  ZblLogManager::LogFieldFunction);
    map.insert("LogFieldLine",  ZblLogManager::LogFieldLine);
    map.insert("LogFieldFile",  ZblLogManager::LogFieldFile);

    map.insert("LogFieldSeekIndex",  ZblLogManager::LogFieldFile);
    map.insert("LogFieldByteCount",  ZblLogManager::LogFieldFile);
    map.insert("LogFieldBookmarks",  ZblLogManager::LogFieldFile);

    map.insert("LogRuleCategory",  ZblLogManager::RuleCategory);
    map.insert("LogRuleRegistered",  ZblLogManager::RuleRegistered);
    map.insert("LogRuleSaved",  ZblLogManager::RuleSaved);
    map.insert("LogRuleEnabled",  ZblLogManager::RuleEnabled);
    map.insert("LogRuleWarning",  ZblLogManager::RuleWarning);
    map.insert("LogRuleCritical",  ZblLogManager::RuleCritical);
    map.insert("LogRuleDebug",  ZblLogManager::RuleDebug);

    map.insert("SettingsUserScope", QSettings::UserScope);
    map.insert("SettingsSystemScope", QSettings::SystemScope);


    QVariantMap testMap;

    testMap.insert("VALUE_ONE", 1);
    testMap.insert("VALUE_TWO", 2);


    map.insert("Test", QVariant::fromValue(testMap));


    m_tags = QVariant::fromValue(map);
}

QVariant ZblApp::getAppTags()
{
    return m_tags;
}

QObject* ZblApp::getSingletonType(
        QQmlEngine *engine, QJSEngine *scriptEngine)
{
     Q_UNUSED(engine)

     zDebug() << "ZblApp::getSingletonType";

     ZblApp* newApp = new ZblApp(scriptEngine);

     return  newApp;

}

int ZblApp::registerSingletonType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    zDebug() << "ZblApp::registerSingletonType";


    //m_log().setEnabled(QtDebugMsg, true);
    //m_log().setEnabled(QtWarningMsg, true);
    //m_log().setEnabled(QtCriticalMsg, true);


    return qmlRegisterSingletonType<ZblApp>(
                "org.zuble.qml",
                1,
                0,
                "Zbl",
                getSingletonType);

}

QObject* ZblApp::getLogBuffer()
{
    return ZblLogManager::zInstance().getLogBuffer();
}

QObject* ZblApp::getLogRules()
{
    return ZblLogManager::zInstance().getLogRules();
}

QString ZblApp::errorMessage()
{
    return zThreadErr.getErrorMessage();
}

void ZblApp::throwAnException()
{
    throw Zbl::ZblException("top level exception");
}

void ZblApp::throwDeeperException()
{
   ZBL_SLOT_BEGIN_TRY

        throwException();

   ZBL_SLOT_END_VOID(myfacility,mycode,exception in throwDeeperException)
}

void ZblApp::catchDeeperException()
{
    try
    {
        throwException();
    }
    catch(Zbl::ZblException zblEx)
    {
        zDebug() << "ZblException exception caught: " << zblEx.what();
     }
    catch(...)
    {
        zDebug() << "unknown exception caught";
    }
}


void ZblApp::throwException()
{
    throw Zbl::ZblException("second level exception");
}

#if 0
QJSValue ZblApp::returnAnException()
{
    //QString name("message");
    //m_errorObject.setProperty(name, QJSValue("returning error message ok"));

    setError(QJSValue("returnExceptionError"));

    return m_errorObject;
}
#else

QVariant ZblApp::returnAnException()
{
    //QString name("message");
    //m_errorObject.setProperty(name, QJSValue("returning error message ok"));

    setError(QJSValue("returnExceptionError"));

    return error().toVariant();
}
#endif

void ZblApp::setError(QJSValue errValue)
{
    QWriteLocker lock(&m_lock);

    if(errValue.isError())
    {
        zThreadErr.raiseError(
                    errValue.property(QStringLiteral("name")).toString(),
                    QStringLiteral(""),
                    errValue.property(QStringLiteral("message")).toString());
    }
    else
    {
        zThreadErr.raiseError(
                    QStringLiteral("Error"),
                    QStringLiteral(""),
                    errValue.toString());
    }


}

bool ZblApp::isError()
{
    QReadLocker lock(&m_lock);

    return zThreadErr.error().isError();
}

void ZblApp::clearError()
{
    QWriteLocker lock(&m_lock);
    //qDebug("ZblApp::clearError");

    zThreadErr.clearError();
}

QJSValue ZblApp::error()
{
    QJSValue err(m_engine->evaluate("new Error();"));
    err.setProperty(QStringLiteral("facility"), QJSValue(zThreadErr.error().facility()));
    err.setProperty(QStringLiteral("code"), QJSValue(zThreadErr.error().code()));
    err.setProperty(QStringLiteral("message"), QJSValue(zThreadErr.error().message()));
    err.setProperty(QStringLiteral("description"), QJSValue(zThreadErr.error().description()));
    err.setProperty(QStringLiteral("isError"), QJSValue(zThreadErr.error().isError()));
    return err;
}

QJSValue ZblApp::convertEvaluateError(const QJSValue& evaluateError)
{
    QString msg(evaluateError.toString());
    QString desc("ZBL:0:%1");

    QJSValue err(m_engine->evaluate("new Error();"));
    err.setProperty(QStringLiteral("facility"), QJSValue("ZBL"));
    err.setProperty(QStringLiteral("code"), QJSValue(0));
    err.setProperty(QStringLiteral("message"), QJSValue(msg));
    err.setProperty(QStringLiteral("description"), QJSValue(desc.arg(msg)));
    err.setProperty(QStringLiteral("isError"), true);
    return err;
}

QVariant ZblApp::include(const QString& fileUrl)
{
    QString filePath = resolveAppPath(fileUrl,false);
    QString script;
    QJSValue result;
    ZBL_SLOT_BEGIN_TRY

        QFile file(filePath);

        status(QString("zInclude: %1").arg(filePath));

        if(!file.exists())
        {
            QString msg("zInclude -- Non-existent file: %1");
            throw ZblException(msg.arg(filePath));
        }
        else if(!file.open(QIODevice::ReadOnly))
        {
            QString msg("zInclude -- Can't open file for reading: %1");
            throw ZblException(msg.arg(filePath));
        }

        QTextStream stream(&file);

        script = stream.readAll();

        if(!script.isEmpty())
            result = m_engine->evaluate(script, fileUrl, 1);

        if(result.isError())
        {
            // evaluation error
             result = convertEvaluateError(result);
        }

        if(isError())
        {
            // Zuble custom QObject exception error
            result = error();
        }

    }
    catch(ZblException ex)
    {
        // normal exception error

        result = error();
    }

    return result.toVariant();
}



void ZblApp::status(const QString& text)
{
    qDebug() << "z@ " << text;

    ZTextFeed& feed(zApp.zStatus());

    feed.send(text);

    feed.flush();
}




QVariant ZblApp::getAppData(int dataKey)
{
    //qDebug() << "ZblApp::getAppData in some thread";

    if(isInMainThread())
    {
        //qDebug() << "ZblApp::getAppData in main thread ";

        return zApp.getAppData(dataKey);
    }
    else
    {
        //qDebug() << "ZblApp::getAppData in background thread";

        //ZApplication::appDataKey key(static_cast<ZApplication::appDataKey>(dataKey));

        QVariant retValue;

        QMetaObject::invokeMethod(&zApp,"getAppData",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG( QVariant, retValue),
                                  Q_ARG(int, dataKey));

        //qDebug() << "ZblApp::getAppData: " << retValue;

        return retValue;
    }
}

QVariant ZblApp::getAppName()
{
    if(isInMainThread())
    {
        return zApp.getAppName();
    }
    else
    {
        //qDebug() << "ZblApp::getAppData in background thread";

        //ZApplication::appDataKey key(static_cast<ZApplication::appDataKey>(dataKey));

        QVariant retValue;

        QMetaObject::invokeMethod(&zApp,"getAppName",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QVariant, retValue));
        return retValue;
    }
}


bool ZblApp::isInMainThread()
{
    return QThread::currentThread() == qApp->thread();
}

QObject* ZblApp::newDir()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZDir(),  NULL,
    Z_FAC_JS, ZblApp::newDir, newDir failed)
}

QObject* ZblApp::newFile()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZFile(),  NULL,
    Z_FAC_JS, ZblApp::newFile, newFile failed)
}

QObject* ZblApp::newByteArray()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZByteArray(),  NULL,
    Z_FAC_JS, ZblApp::newByteArray, newByteArray failed)
}

QObject* ZblApp::newTextStream(const QString& text)
{
    ZqStringPtr stringPtr = ZqStringPtr::create();
    ZBL_SLOT_BEGIN_TRY
    *stringPtr = text;
    ZBL_SLOT_END_RETURN(new ZTextStream(stringPtr),  NULL,
    Z_FAC_JS, ZblApp::newTextStream, newTextStream failed)
}

QString ZblApp::readLine()
{
    ZBL_SLOT_BEGIN_TRY
    QTextStream instream(stdin);
    QString text = instream.readLine(0);
    ZBL_SLOT_END_RETURN(text,  QString(),
    Z_FAC_JS, ZblApp::readLine, readLine failed)
}

void ZblApp::print(const QString& text, bool newLine)
{
    ZBL_SLOT_BEGIN_TRY
    QTextStream outstream(stdout, QIODevice::WriteOnly | QIODevice::Text);
    outstream << text;
    if(newLine)
        outstream << endl;
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::print, print failed)
}

void ZblApp::printErr(const QString& text, bool newLine)
{
    ZBL_SLOT_BEGIN_TRY
    QTextStream errstream(stderr, QIODevice::WriteOnly | QIODevice::Text);
    errstream << text;
    if(newLine)
        errstream << endl;
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::printErr, printErr failed)
}


QObject* ZblApp::newDataStream(QObject* byteArray)
{
    ZBL_SLOT_BEGIN_TRY
    ZByteArray* pByteArray = qobject_cast<ZByteArray*>(byteArray);
    if(!pByteArray)
    throw ZblException(
    "Programming error - object passed is not a Zbl::ZByteArray");
    ZBL_SLOT_END_RETURN(new ZDataStream(pByteArray->qByteArray()),  NULL,
    Z_FAC_JS, ZblApp::newDataStream, newDataStream failed)
}

QObject* ZblApp::newFileSystemWatcher()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZFileSystemWatcher(),  NULL,
    Z_FAC_JS, ZblApp::newFileSystemWatcher, newFileSystemWatcher failed)
}


QObject* ZblApp::newTableModel()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZTableModel(),  NULL,
    Z_FAC_JS, ZblApp::newTableModel, newTableModel failed)
}

QObject* ZblApp::newMessageQueue()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZMessageQueue(),  NULL,
    Z_FAC_JS, ZblApp::newMessageQueue, newMessageQueue failed)
}

QObject* ZblApp::newMailslot()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZMailslot(),  NULL,
    Z_FAC_JS, ZblApp::newMailslot, newMailslot failed)
}

QObject* ZblApp::newProcess()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZProcess(),  NULL,
    Z_FAC_JS, ZblApp::newProcess, newProcess failed)
}

QObject* ZblApp::newMailbox()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZMailbox(),  NULL,
    Z_FAC_JS, ZblApp::newMailbox, newMailbox failed)
}

QObject* ZblApp::newMap()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZMap(),  NULL,
    Z_FAC_JS, ZblApp::newMap, newMap failed)
}

QObject* ZblApp::newScopedMap()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZScopedMap(),  NULL,
    Z_FAC_JS, ZblApp::newScopedMap, newScopedMap failed)
}

QObject* ZblApp::newLogReader()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZLogReader(),  NULL,
    Z_FAC_JS, ZblApp::newLogReader, newLogReader failed)
}


QObject* ZblApp::newSchemaValidator()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZSchemaValidator(),  NULL,
    Z_FAC_JS, ZblApp::newSchemaValidator, newSchemaValidator failed)
}

QObject* ZblApp::newAppSettings(int scope,
                                    const QString& application,
                                    const QString& organization)
{
    ZSettings* settings = NULL;

    ZBL_SLOT_BEGIN_TRY
    settings = new ZSettings();

    bool ok = settings->open(scope, application, organization);
    if(!ok)
    {
        delete settings;
        throw ZblException(QString("ZblApp::newAppSettings - can't open app settings "
                           "for scope: %1, application: %2, organization: %3")
                           .arg(scope).arg(application, organization));
    }
    ZBL_SLOT_END_RETURN(settings,  NULL,
    Z_FAC_JS, ZblApp::newAppSettings, newAppSettings failed)
}

QObject* ZblApp::newSettingsFile(const QString& filePath)
{
    ZSettings* settings = nullptr;

    ZBL_SLOT_BEGIN_TRY
    settings = new ZSettings();

    bool ok = settings->open(filePath);
    if(!ok)
    {
        delete settings;
        throw ZblException(QString("ZblApp::newSettingsFile - can't open settings "
                           "file: %1").arg(filePath));
    }
    ZBL_SLOT_END_RETURN(settings,  NULL,
    Z_FAC_JS, ZblApp::newSettingsFile, newSettingsFile failed)
}

QObject* ZblApp::newXmlQuery()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZxQuery(),  NULL,
    Z_FAC_JS, ZblApp::newXmlQuery, newXmlQuery failed)
}

QObject* ZblApp::newThread()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(new ZScriptThread(),  NULL,
    Z_FAC_JS, ZblApp::newThread, newThread failed)
}

QObject* ZblApp::bundleSettings(const QString& bundleID)
{
    QObject* settings = nullptr;
    ZBL_SLOT_BEGIN_TRY
    settings = ZSettings::getBundleSettings(bundleID);
    ZBL_SLOT_END_RETURN(settings,  NULL,
    Z_FAC_JS, ZblApp::bundleSettings, bundleSettings failed)
}

QObject* ZblApp::newObject(
        const QString& sprocketUri, const QString& objectName)
{
    QObject* ob = nullptr;

    ZBL_SLOT_BEGIN_TRY

    ZblFactory* factory = m_factories.value(sprocketUri, nullptr);

    if(!factory)
        throw ZblException(QString(
    "No Sprocket plugin has been imported for uri: %1").arg(sprocketUri));

    // new Sprocket object will automatically receive Javascript ownership

    ob = factory->createObject(cStr(objectName));

    ZBL_SLOT_END_RETURN(ob,  NULL,
    Z_FAC_JS, ZblApp::newObject, newObject failed)
}


bool ZblApp::import(
        const QString& sprocketUri, int versionMajor, int versionMinor)
{
    ZBL_SLOT_BEGIN_TRY

    if(m_factories.contains(sprocketUri))
        throw ZblException(QString(
        "Sprocket already imported: %1").arg(sprocketUri));

    ZblFactory* factory = zCog.createFactory(cStr(sprocketUri), versionMajor, versionMinor);

    if(!factory)
        throw ZblException(QString(
        "Can't import Sprocket: %1").arg(sprocketUri));

    factory->setParent(this);

    m_factories.insert(sprocketUri, factory);

    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZblApp::import, import failed)

}

bool ZblApp::mapResource(
        const QString& uri,
        int versionMajor,
        int versionMinor,
        const QString& fileName)
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(
    zCog.mapResource(uri.toUtf8(),
    versionMajor, versionMinor, fileName.toUtf8()),
    false, Z_FAC_JS, ZblApp::mapResource, mapResource failed)
}

bool ZblApp::registerResource(
        const QString& uri, int versionMajor, int versionMinor)
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(
    zCog.registerResource(uri.toUtf8(), versionMajor, versionMinor),
    false, Z_FAC_JS, ZblApp::registerResource, registerResource failed)
}


bool ZblApp::mapPluginResources(const QString& fileName, bool qmlregister)
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(
        zCog.mapPluginResources(fileName.toUtf8(), qmlregister),
    false, Z_FAC_JS, ZblApp::mapPluginResources, mapPluginResources failed)
}


QStringList ZblApp::getApplicationArguments()
{
    ZBL_SLOT_BEGIN_TRY
            ZBL_SLOT_END_RETURN(QCoreApplication::arguments(),  QStringList(),
    Z_FAC_JS, ZblApp::getApplicationArguments, getApplicationArguments failed)
}

QStringList ZblApp::getSystemEnvironment()
{
    ZBL_SLOT_BEGIN_TRY
            ZBL_SLOT_END_RETURN(
                QProcessEnvironment::systemEnvironment().toStringList(),
                QStringList(),
    Z_FAC_JS, ZblApp::getApplicationArguments, getApplicationArguments failed)
}

bool ZblApp::isInterruptRequested()
{
    QThread* thread = QThread::currentThread();

    if(thread == qApp->thread())
        return false;
    else
        return thread->isInterruptionRequested();
}


QString ZblApp::getCurrentThreadAddress()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(ZApplication::getCurrentThreadAddress(),
    QString("<Thread ID Error>"),
    Z_FAC_JS, ZblApp::getCurrentThreadAddress, getCurrentThreadAddress failed)
}


QString ZblApp::getObjectThreadAddress(QObject* object)
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(ZApplication::getObjectThreadAddress(object),
    QString("<Thread ID Error>"),
    Z_FAC_JS, ZblApp::getObjectThreadAddress, getObjectThreadAddress failed)
}

void ZblApp::addLibraryPath(const QString& path)
{
    if(!isInMainThread())
   {
#if 0
        //TBD: THIS CAN'T WORK! no addLibraryPath method in ZApplication

       QMetaObject::invokeMethod(&zApp,"addLibraryPath",
                                 Qt::BlockingQueuedConnection,
                                 Q_ARG(const QString&, path));
#else

    zWarning() << "Zuble programming ERROR: addLibaryPath not supported for background threads.";

#endif
   }
   else
   {
      qApp->addLibraryPath(path);
  }
}


QString ZblApp::resolveAppPath(const QString& path, bool includeUrlScheme)
{
    return ZApplication::resolvePath(ZApplication::m_appPathPrefix,
    ZApplication::getRootPath(), path, includeUrlScheme);
}

QString ZblApp::resolveHomePath(const QString& path, bool includeUrlScheme)
{
    QString homePath(QDir::homePath() + "/");
    return ZApplication::resolvePath(ZApplication::m_homePathPrefix,
    homePath, path, includeUrlScheme);
}

QString ZblApp::resolvePath(const QString& path, bool includeUrlScheme)
{
    return ZApplication::resolvePath( path, includeUrlScheme);
}

QString ZblApp::getRootPath()
{
    return ZApplication::getRootPath();
}

QString ZblApp::getMainQmlPath()
{
    return ZApplication::getMainQmlPath();
}

bool ZblApp::isResourcePath(const QString& path)
{
    QString scheme = ZApplication::getPathScheme(path);

    if(scheme == "qrc:/" || scheme == ":/")
        return true;

    return false;
}

QString ZblApp::bundleMetapath(const QString& bundleID)
{
    ZBL_SLOT_BEGIN_TRY

    ZBL_SLOT_END_RETURN(ZSettings::getBundleMetapath(bundleID),  QString(),
    Z_FAC_JS, ZblApp::bundleMetapath, bundleMetapath failed)
}

QString ZblApp::bundleMetadata(const QString& bundleID)
{
    ZBL_SLOT_BEGIN_TRY

    ZBL_SLOT_END_RETURN(ZSettings::getBundleMetadata(bundleID),  QString(),
    Z_FAC_JS, ZblApp::bundleMetadata, bundleMetadata failed)
}


int ZblApp::startTimerInterval(
        QJSValue timerFunction,
        QJSValue timerArgument,
        int milliseconds)
{
    int timerID = 0;

    ZBL_SLOT_BEGIN_TRY

    timerID = startTimer(milliseconds);

    if(timerID == 0)
        throw ZblException("QObject::startTimer failed");

    if(m_scriptTimers.contains(timerID))
        zWarning() << "ZblApp::startTimerInterval - warning: script timer ID reused";

    m_scriptTimers.insert(
                timerID,TimerMethodCall(timerFunction, timerArgument));

    ZBL_SLOT_END_RETURN(timerID,  timerID,
    Z_FAC_JS, ZblApp::startTimerInterval, startTimerInterval failed)

    //return 0;

}

void ZblApp::stopTimerInterval(int timerID)
{
    ZBL_SLOT_BEGIN_TRY
    if(timerID == 0)
        return;
    killTimer(timerID);
    m_scriptTimers.remove(timerID);
    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZblApp::stopTimerInterval, stopTimerInterval failed)
}

void ZblApp::timerEvent(QTimerEvent * event)
{
    ZBL_SLOT_BEGIN_TRY
    const int timerID = event->timerId();

    //qDebug("ZblApp::timerEvent -- %u", timerID);

    if(m_scriptTimers.contains(timerID))
    {
        TimerMethodCall call(m_scriptTimers.value(timerID));
        QJSValueList timerArgs;
        timerArgs.append(call.timerArg);
        call.timerFunc.callWithInstance(m_engine->globalObject(),timerArgs);
    }
    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZblApp::timerEvent, timerEvent failed)

}

void ZblApp::stopAllTimers()
{
    ZBL_SLOT_BEGIN_TRY

    if(!m_scriptTimers.isEmpty())
    {
        timerKeys timers(m_scriptTimers.keys());

        timerKeys::iterator it(timers.begin());

        while(it != timers.end())
            killTimer(*it++);

        m_scriptTimers.clear();
    }

    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZblApp::stopAllTimers, stopAllTimers failed)

}

void ZblApp::sleep(unsigned long milliseconds)
{
    ZBL_SLOT_BEGIN_TRY

    QThread::msleep(milliseconds);

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::sleep, sleep failed)
}

void ZblApp::sleepEvents(unsigned long milliseconds)
{
    ZBL_SLOT_BEGIN_TRY

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


    if(count < 1)
        count = 1;

    zDebug() << "Waiting: " << count << " * " << waitTime << " milliseconds.";

    for(unsigned long i=0; i < count; i++)
    {
        QThread::msleep(waitTime);

        d->processEvents(QEventLoop::AllEvents);

        //QCoreApplication::processEvents(QEventLoop::AllEvents);
        collectGarbage(); // TBD: need this?

    }
    zDebug() << "Done Waiting: " << count << " * " << waitTime << " milliseconds.";


    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::sleepEvents, sleepEvents failed)
}


void ZblApp::collectGarbage()
{
    ZBL_SLOT_BEGIN_TRY
        m_engine->collectGarbage();
    ZBL_SLOT_END_VOID(
    Z_FAC_JS, ZblApp::collectGarbage, collectGarbage failed)
}

void ZblApp::alert(const QString signalID, QVariant payload, bool wait)
{
    ZBL_SLOT_BEGIN_TRY

            if(isInMainThread())
                return;
   // pass int as int
   // pass string as string with JSONflag = false
   // pass QJSValues as JSON strings with JSONflag = true


    if(!m_container)
    {
        zWarning() << "ZblApp::alert - Programming error! Background ZblApp "
                      "expects it's container to be a ZScriptThread object.";

        return;
    }

    zDebug() << "SENDING ALERT id=" << signalID << ", wait = " << wait << ", payload=" << payload;

    //QVariant vPayload(payload);

    QString strPayload;
    ZScriptThread::AlertConversion conversion = ZScriptThread::UNDEFINED;
    QJsonDocument doc;

    int metatype = int(payload.type());

    zDebug() << "metatype = " << metatype;

    switch(metatype)
    {

    case QMetaType::Int:

        zDebug() << "QMetaType = Int";

       strPayload = payload.toString();
       conversion = ZScriptThread::INTEGER;

       break;

    case QMetaType::Double:

        zDebug() << "QMetaType = Double";

       strPayload = payload.toString();
       conversion = ZScriptThread::DOUBLE;

       break;

    case QMetaType::QString:

        zDebug() << "QMetaType = QString";

       strPayload = payload.toString();
       conversion = ZScriptThread::STRING;

       break;

     case QMetaType::User:

        zDebug() << "QMetaType = User";

        static const int qjstype = QVariant::fromValue(QJSValue()).userType();

        if(payload.userType() == qjstype)
        {
            zDebug() << "QMetaType = QJSValue";

            QVariant var = payload.value<QJSValue>().toVariant();

            strPayload = ZScriptThread::variantToJson(var);
            conversion = ZScriptThread::JSON;

            zDebug() << "Stringified payload=" << strPayload;
        }
        else
        {
            QString msg("ZblApp::alert received unrecognized QVariant type: %1");
            throw ZblException(msg.arg(metatype));
        }
        break;

    default:

        QString msg("ZblApp::alert received unrecognized QVariant type: %1");
        msg = msg.arg(metatype);

        zWarning() << msg;

        throw ZblException(msg);
    }


    Qt::ConnectionType connection = wait ? Qt::BlockingQueuedConnection
                                         : Qt::QueuedConnection;

    QMetaObject::invokeMethod(m_container,"onThreadAlert",
                              connection,
                              Q_ARG(QString, signalID),
                              Q_ARG(QString, strPayload),
                              Q_ARG(int, static_cast<int>(conversion)));

    zDebug() << "SENT ALERT id=" << signalID << ", payload=" << payload;

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::alert, alert failed)
}

void ZblApp::quit()
{
    ZBL_SLOT_BEGIN_TRY

    if(isInMainThread())
    {
        zDebug() << "ZblApp calling QCoreApplication::quit()...";

        QMetaObject::invokeMethod(m_engine,"quit",
                                  Qt::QueuedConnection);

        m_engine->deleteLater();

        return;
    }

    if(!m_container)
    {
        zWarning() << "ZblApp::quit - Programming error! Background ZblApp "
                      "expects it's container to be a ZScriptThread object.";

        return;
    }

    zDebug() << "ZblApp quitting thread: " << getCurrentThreadAddress();

    QMetaObject::invokeMethod(m_container,"quit",
                              Qt::QueuedConnection);

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::quit, quit failed)
}


void ZblApp::exitApp(int returnCode)
{
    ZBL_SLOT_BEGIN_TRY

   if(isInMainThread())
    {
        zDebug() << "ZblApp calling QCoreApplication::exit()...";

        m_engine->deleteLater();

        QCoreApplication::exit(returnCode);
    }
    else
    {
        zWarning() << "ZblApp::exit - Programming ERROR: exit() method must be called from main thread.";
    }

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZblApp::exitApp, exitApp failed)
}


void ZblApp::onDestroyed(QObject* obj)
{
    zDebug() << "ZblApp::onDestroyed";
}

} // Zbl