main.cpp

Go to the documentation of this file.

/*
* Zuble - A run-time system for QML/Javascript applications
* Copyright (C) 2019  Bob Dinitto
*
* Filename:   main.cpp
* Created on: 20-Aug-2019
* 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 <QCoreApplication>
#include <QQmlApplicationEngine>
#include <QPluginLoader>
#include <QDir>
#include <QtDebug>
#include "ZblApp.h"
#include "ZResourceEdifyIF.h"
#include <iostream>

using namespace Zbl;
using namespace std;

bool loadPlugin();
void printUsage();
void addImportPath(const QString& prefix, const QString& path, QQmlEngine* engine);
void addPath(const QString& prefix, const QString& path, QStringList& pathList);
void dumpPathList(const QStringList& list);
QString findScriptPath(const QString& name);
QStringList getPathList();
void listScripts();
QString getScriptPath();
void printScriptPath();

static QString extension("qml");
static QString envPathName("ZUB_PATH");
static QChar pathSeparator(':');
static QString zubName;

int main(int argc, char *argv[])
{
    zubName = argv[0];

    zubName = zubName.right(zubName.length() - zubName.lastIndexOf('/')-1);

    if(argc < 2 || !strcmp(argv[1], "-h"))
    {
        printUsage();
        return -1;
    }
    else if(!strcmp(argv[1], "-l"))
    {
        listScripts();
        return 0;
    }
    else if(!strcmp(argv[1], "-p"))
    {
        printScriptPath();
        return 0;
    }

    QString scriptName(argv[1]);

    QString filePath = findScriptPath(scriptName);

    QCoreApplication a(argc, argv);

    QQmlApplicationEngine* engine = new QQmlApplicationEngine(&a);

    engine->installExtensions(QJSEngine::AllExtensions);

    QString installPrefix;

    installPrefix = QCoreApplication::applicationDirPath();
    installPrefix += "/../";
    installPrefix = QDir::cleanPath(installPrefix);
    QString zAppDirPath = installPrefix + "/apps";

    qWarning("Install prefix: %s", installPrefix.toUtf8().constData());
    qWarning("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);

    loadPlugin();

    engine->load(filePath);

    qDebug() << "Returned from engine->load()";

    int status = a.exec();

    qDebug("Returned from exec() with value: %d", status);

    return status;
}

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);
}

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 dumpPathList(const QStringList& list)
{
    const int len = list.length();

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

}




bool loadPlugin()
{

    // 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() << "zub 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;
    }

    return status;

}

// walks the ZUB_PATH looking for a script file named <name>.qml

QString findScriptPath(const QString& scriptName)
{
    QString path(getenv(envPathName.toUtf8().constData()));

    if(path.isEmpty())
    {
        qWarning() << "ERROR: No ZUB_PATH environment variable specified. "
                   "This should contain a list of directories for "
                << zubName << " to search for QML files.";

        exit(-1);

    }
    QString fullName(scriptName);

    if(fullName.lastIndexOf(extension) != fullName.size() - 4)
    {
        fullName += ".";
        fullName += extension;
    }

    QStringList folders = getPathList();

    qDebug() << "resolveProgramName, name: " << fullName;
    qDebug() << "resolveProgramName, path: " << path;

    QDir dir;
    QString fullPath;

    for(int i=0; i<folders.size(); i++)
    {
        qDebug() << "folder: " << folders.at(i) << endl;

        dir.setPath(folders.at(i));

        if(!dir.exists())
            continue;

        if(dir.exists(fullName))
        {
            QFileInfo info = QFileInfo(dir, fullName);
            fullPath = info.absoluteFilePath();
            if(!info.isExecutable())
            {
                qWarning() << zubName << ": ERROR - File is not executable: "
                        << fullPath;
                qWarning() << zubName << ": You must set file permissions to \"executable\" for file: "
                        << fullPath;
                exit(-1);
            }
            return fullPath;
        }
    }

    qWarning() << zubName << ": ERROR - Script file not found: "
            << fullName;

    exit(-1);

}

void listScripts()
{
    cout << zubName.toUtf8().constData()
         << ": Listing Zuble scripts..." << endl;

    cout << envPathName.toUtf8().constData() << "="
         << getScriptPath().toUtf8().constData() << endl << endl;

    QStringList folders = getPathList();

    QDir dir;
    QStringList filters;
    filters << "*.qml";
    dir.setNameFilters(filters);
    dir.setFilter(QDir::Executable | QDir::Files);
    QString fullPath;
    QString ext(".%1");
    ext = ext.arg(extension);

    for(int i=0; i<folders.size(); i++)
    {
        cout << folders.at(i).toUtf8().constData() << ":" << endl;

        dir.setPath(folders.at(i));

        if(!dir.exists())
            continue;


        QStringList files = dir.entryList();

        for(int i=0; i<files.count(); i++)
        {
            QString name = files.at(i);

            int extIndex = name.lastIndexOf(ext);

            name = name.left(extIndex);

            cout << name.toUtf8().constData() << endl;
        }
    }
}

QStringList getPathList()
{
    QStringList folders = getScriptPath().split(pathSeparator);

    if(folders.isEmpty())
    {
        qWarning() << zubName << "WARNING: ZUB_PATH environment variable contains no directories"
                " to search for QML files";

        exit(-1);
    }

    return folders;
}

QString getScriptPath()
{
    QString path(getenv(envPathName.toUtf8().constData()));

    if(path.isEmpty())
    {
        qWarning() << "ERROR: No ZUB_PATH environment variable specified. "
                   "This should contain a list of directories for "
                << zubName << " to search for QML files.";

        exit(-1);

    }

    return path;
}

void printScriptPath()
{
    cout << zubName.toUtf8().constData() << " script path: "
         << getScriptPath().toUtf8().constData() << endl;
}


void printUsage()
{
    cout << zubName.toUtf8().constData() << " usage: " << endl;
    cout << "   " << zubName.toUtf8().constData() << " <script-file>" << endl;
    cout << "      Loads and runs the non-gui QML script named <script-file>.qml" << endl;
    cout << "      on the path defined by environment variable ZUB_PATH." << endl;
    cout << "   " << zubName.toUtf8().constData() << " -l" << endl;
    cout << "      Lists QML scripts found on paths defined by ZUB_PATH environment variable." << endl;
    cout << "      Script files must have \".qml\" extension and executable permission." << endl;
    cout << "   " << zubName.toUtf8().constData() << " -h" << endl;
    cout << "      Prints this help message." << endl << endl;
}