main.cpp

Go to the documentation of this file.

/*
* Zuble - A run-time system for QML/Javascript applications
* Copyright (C) 2013, 2014  Bob Dinitto
*
* Filename:   main.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 <QtWidgets/QApplication>
#include <QQmlEngine>
#include <QQmlContext>
#include <QDir>
#include <QXmlSchema>
#include "qtquick2applicationviewer.h"

#include <QDebug>
#include <QPluginLoader>
#include <QQmlExtensionPlugin>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonArray>
#include <QJsonDocument>
#include <QObject>
#include <QProcessEnvironment>
//#include "Zblcore.h"
#include "ZResourceEdifyIF.h"

void showAppStructureMessage(const char* appName);
bool validateXMLDoc(const QString& schemaUrl, const QString& docUrl);
void dumpPathList(const QStringList& list);
void dumpResourceSpace(QString path);

bool loadZubleConfiguration(const QString& configFilePath);

void dumpJsonObject(QJsonObject jsonObject);
void dumpJsonValue(const QString& key, QJsonValue& jsonValue);
void dumpJsonArray(QJsonArray jsonArray);
void dumpEnv(const char* name);
QString getEnv(const char* name);
void addPath(const QString& prefix, const QString& path, QStringList& pathList);
void addImportPath(const QString& prefix, const QString& path, QQmlEngine* engine);

static int versionMajor = 0;
static int versionMinor = 1;
static int versionPatch = 0;
static QString versionBuild = "prototype-91";


int main(int argc, char *argv[])
{
    qDebug("starting...");

    dumpResourceSpace(":/");

    dumpEnv("HOME");
    dumpEnv("LD_LIBRARY_PATH");
    dumpEnv("SNAP");
    dumpEnv("SNAP_ARCH");
    dumpEnv("SNAP_DATA");
    dumpEnv("SNAP_LIBRARY_PATH");
    dumpEnv("SNAP_NAME");
    dumpEnv("SNAP_REVISION");
    dumpEnv("SNAP_USER_DATA");
    dumpEnv("SNAP_VERSION");
    dumpEnv("TMPDIR");

    QApplication* app = new QApplication(argc, argv);

    qDebug("library paths: ");

    dumpPathList(QCoreApplication::libraryPaths());

    //qDebug("Added library path: %s", pluginPath.toUtf8().constData());


     QtQuick2ApplicationViewer viewer;

    //QObject::connect(&libraryviewer, SIGNAL(statusChanged(QQuickView::Status)),
    //                 app, SLOT(onViewStatusChanged(QQuickView::Status)));


    QQmlEngine* engine = viewer.engine();

    bool snapApp = true;

    QString zAppDirPath ;

    QString installPrefix(getEnv("SNAP"));
    if(installPrefix.isEmpty())
    {
        installPrefix = QCoreApplication::applicationDirPath();
        installPrefix += "/../";
        installPrefix = QDir::cleanPath(installPrefix);
        zAppDirPath = installPrefix + "/apps";

        snapApp = false;
    }
    else
    {
        installPrefix += "/opt/zbl";
        zAppDirPath = installPrefix + "/apps";
    }
    qDebug("Install prefix: %s", installPrefix.toUtf8().constData());
    qDebug("Zuble app directory: %s", zAppDirPath.toUtf8().constData());

    QStringList libPaths;

    if(snapApp)
        libPaths = QCoreApplication::libraryPaths();


    addPath(installPrefix, "/lib", libPaths);
    addPath("",".", libPaths);

    QCoreApplication::setLibraryPaths(libPaths);
    engine->setPluginPathList(libPaths);

    engine->addImportPath("qrc:/"); // exposes /org/zuble/qml/qmldir to QML

    addImportPath(installPrefix, "/lib", engine); // exposes Zuble plugins to QML

    qDebug("Dumping library paths...");
    libPaths = QCoreApplication::libraryPaths();
    dumpPathList(libPaths);

    qDebug("Dumping plugin paths...");
    libPaths = engine->pluginPathList();
    dumpPathList(libPaths);
   int retvalue = -1;

    try
    {
        QUrl sourceUrl; // ultimate location of main.qml file
        QString zblmainPath("qrc:/org/zuble/qml/frames/zblmain.qml"); // zbl hosted main qml file
        QString title("I Am Zuble");
        bool zblHostedApp = true;

        QString zAppName;

        // get the specific directory for this application

        QString zAppMainQmlFilePath;

        if(argc < 2 )
        {
            // no args so run stand-alone zbl app

            sourceUrl.setUrl(zblmainPath);
            zAppDirPath += "/zbl/";
            zAppName = "zbl";
        }
        else
        {
            const char* arg1 = argv[1];

            if(arg1[0] == '-')
            {
                // first arg is option flag so run stand-alone zbl app

                sourceUrl.setUrl(zblmainPath);
                zAppDirPath += "/zbl/";
                zAppName = "zbl";
            }
            else
            {
                // first arg is zuble app name so run named app

                zAppDirPath += "/";
                zAppDirPath += arg1;
                zAppName = arg1;

                QFileInfo appDirInfo(zAppDirPath);

                if(!appDirInfo.exists())
                {
                    // app directory is missing!

                    qCritical("ERROR: Zuble application directory doesn't exist: %s",
                          zAppDirPath.toUtf8().constData());

                    showAppStructureMessage(arg1);

                    qFatal("Zuble aborting...!");

                }
                else if(!appDirInfo.isDir())
                {
                    // specified app should be a subdirectory of zuble apps directory!

                    qCritical("ERROR: Specified Zuble application is not a directory type file: %s",
                          zAppDirPath.toUtf8().constData());

                    showAppStructureMessage(arg1);

                   qFatal("Zuble aborting...!");
                }

                zAppDirPath += "/";

                zAppMainQmlFilePath = zAppDirPath;
                zAppMainQmlFilePath += "main.qml";

                if(QFile::exists(zAppMainQmlFilePath))
                {
                    // main.qml file exists so run named app stand-alone

                    sourceUrl.setUrl(zAppMainQmlFilePath);
                    zblHostedApp = false;
                }
                else
                {
                    // no main.qml file so run named app in zbl

                    sourceUrl.setUrl(zblmainPath);
                    title = "Zuble: ";
                    title += zAppName;
                }
            }
        }

        engine->addImportPath(zAppDirPath);

#if 0
        //TBD: XML validation too slow for normal program startup,
        // use MD5 checksum stored in application settings to determine
        // when this should be performed.
        if(zblHostedApp)
        {
            QString zAppConfigFilePath(zAppDirPath);
            zAppConfigFilePath += "zblconfig.xml";

            bool bValidConfig = validateXMLDoc(
                        "qrc:///schema/zblconfig.xsd",
                        zAppConfigFilePath);

            if(!bValidConfig)
                qDebug("Invalid zblconfig.xml file!");
        }
#endif

        // initialize the application settings

        QCoreApplication::setOrganizationName("zuble");    // org name
        QCoreApplication::setOrganizationDomain("zuble.org");  // org domain
        QCoreApplication::setApplicationName(zAppName);      // app name

        // exposes application directory to QML

        qApp->setProperty("org_zuble_appName",
                          QVariant(zAppName));

        qApp->setProperty("org_zuble_appRootPath",
                          QVariant(zAppDirPath));

        if(zAppMainQmlFilePath.isEmpty())
            qApp->setProperty("org_zuble_appMainQmlPath",
                              QVariant(zblmainPath));
        else
            qApp->setProperty("org_zuble_appMainQmlPath",
                              QVariant(zAppMainQmlFilePath));

        // set Zuble identity properties


        qApp->setProperty("org_zuble_host_name",
                          QVariant("zbl"));

        qApp->setProperty("org_zuble_host_versionMajor",
                          QVariant(versionMajor));

        qApp->setProperty("org_zuble_host_versionMinor",
                          QVariant(versionMinor));

        qApp->setProperty("org_zuble_host_versionPatch",
                          QVariant(versionPatch));

        qApp->setProperty("org_zuble_host_versionBuild",
                          QVariant(versionBuild));

        QVariant appRootPath(qApp->property("org_zuble_appRootPath"));

        qDebug("Root path property on QApplication = %s",
               appRootPath.toString().toUtf8().constData());

        qDebug("Dumping import paths...");

        QStringList importPathList = engine->importPathList();

        dumpPathList(importPathList);

        if(zblHostedApp)
        {
            QString zAppConfigFilePath(zAppDirPath);
            zAppConfigFilePath += "zblconfig.xml";

            loadZubleConfiguration(zAppConfigFilePath);

            // debug

            qDebug("Dumping resource space...");

            dumpResourceSpace(":/org/zuble/qml");

            qDebug("End dumping resource space...");
        }

        viewer.setTitle(title);
        viewer.setSource(sourceUrl);
        viewer.showExpanded();

        retvalue = qApp->exec();

        //delete qApp;
    }
    catch(...)
    {
        qDebug("Zuble QML exception caught...!");

        retvalue = -1;

    }
    qDebug("ending...");

    return retvalue;
}



bool loadZubleConfiguration(const QString& configFilePath)
{

    // if(hasArg("-zl"))
    //   logging = "on";
    //
    // registerConfigSettingsBundles
    // if(logprofile)
    //   use it;
    // else
    //   use default log profile;

    qDebug("Loading Zuble core plugin resources...");

    bool status = false;

    static const QString corePluginName = "libzblcore";

    QPluginLoader loader;

    loader.setFileName(corePluginName);

    if(!loader.load())
    {
        qWarning() << "Zuble failed to load core plugin: " << loader.errorString();
        return status;
    }

    Zbl::ZResourceEdifyIF* plugin =
            qobject_cast<Zbl::ZResourceEdifyIF*>(loader.instance());


    if(!plugin)
    {
        qWarning() << "Zuble core ERROR, core plugin doesn't implement ZResourceEdifyIF";

        return status;
    }

    status = plugin->mapPluginResources(corePluginName.toUtf8(), true);

    if(!status)
    {
        qWarning() << "Zuble FAILED to locate and register core binary "
                      "resource files.";

        return status;
    }

    qDebug("Loading application resources...");


    status = plugin->mapConfigResources(configFilePath.toUtf8());

    if(!status)
    {
        qWarning() << "Zuble FAILED to locate and register application's "
                      "binary resource files.";

        return status;
    }

    qDebug("Done loading application resources.");

    qDebug("Mapping application settings bundles.");

    status = plugin->mapConfigSettings(configFilePath.toUtf8());

    if(!status)
    {
        qWarning() << "Zuble FAILED to map applicaiton settings bundles.";
    }

    qDebug("Done mapping application settings bundles.");


    return status;

}

void dumpJsonObject(QJsonObject jsonObject)
{
    QJsonDocument doc(jsonObject);

    QByteArray ba = doc.toJson();

    qDebug("%s", ba.constData());

    return;

}

void dumpJsonValue(const QString& key, QJsonValue& jsonValue)
{
    QString stringValue;
    QJsonArray emptyArray;

    switch(jsonValue.type())
    {

    case QJsonValue::Null:
        stringValue = "null";
        break;
    case QJsonValue::Bool:
        if(jsonValue.toBool())
            stringValue = "true";
        else
            stringValue = "false";
        break;
    case QJsonValue::Double:
        stringValue = QString::number(jsonValue.toDouble());
        break;
    case QJsonValue::String:
        stringValue = jsonValue.toString();
        break;
    case QJsonValue::Array:
        dumpJsonArray(jsonValue.toArray(emptyArray));
        return;
    case QJsonValue::Object:
        dumpJsonObject(jsonValue.toObject());
        return;
    case QJsonValue::Undefined:
        stringValue = "undefined";
        break;
    };

    qDebug("METADATA %s=%s",
           key.toUtf8().constData(),
           stringValue.toUtf8().constData());

}

void dumpJsonArray(QJsonArray jsonArray)
{
    qDebug("[");

    QString emptyKey;

    QJsonArray::const_iterator it(jsonArray.constBegin());

    while(it != jsonArray.constEnd())
    {
        QJsonValue jVal = *it;
        dumpJsonValue(emptyKey, jVal);
        it++;
    }
    qDebug("]");

}



void showAppStructureMessage(const char* appName)
{
    qCritical("ERROR: Zuble application should be a subdirectory named \"%s\" "
              "within the zuble apps directory, containing "
           "either a main.qml or zblconfig.xml file.", appName);
}

bool validateXMLDoc(const QString& schemaUrl, const QString& docUrl)
{
    QUrl schemaURL(schemaUrl);
    QXmlSchema schema;
    QUrl docURL(docUrl);

    bool status = schema.load(schemaURL);

    return status;

}

void dumpPathList(const QStringList& list)
{
    const int len = list.length();

    for(int i=0; i < len; i++)
    {
        qDebug("path: %s", list.at(i).toUtf8().constData() );
    }

}

void dumpResourceSpace(QString path)
{
    QDir dir(path);

    QStringList list = dir.entryList(QStringList());

    int count = list.count();

    for(int i=0; i<count; i++)
    {
        qDebug("resource: %s", list.at(i).toUtf8().data());
    }
}

void dumpEnv(const char* name)
{
    char* value;

    value = getenv(name);

    if(value)
        qDebug("env %s=%s", name, value);
    else
        qDebug("env %s=", name);

}

QString getEnv(const char* name)
{
    char* value;

    value = getenv(name);

    if(value)
        return QString(value);
    else
        return QString();
}

void addPath(const QString& prefix, const QString& path, QStringList& pathList)
{
    QString tempPath("%1%2");
    tempPath = tempPath.arg(prefix).arg(path);

    qDebug("Adding path: %s", tempPath.toUtf8().constData());

    pathList.append(tempPath);
}

void addImportPath(const QString& prefix, const QString& path, QQmlEngine* engine)
{
    QString tempPath("%1%2");
    tempPath = tempPath.arg(prefix).arg(path);

    qDebug("Adding import path: %s", tempPath.toUtf8().constData());

    engine->addImportPath(tempPath);
}