ZApplication.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZApplication.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 <QDebug>
#include <QSettings>
#include <QMetaProperty>
#include <QApplication>
#include <QXmlQuery>
#include <QXmlResultItems>
#include "ZApplication.h"
#include "ZblException.h"
#include "ZblThreadErr.h"
#include "ZblLogManager.h"
#include "ZSettings.h"
#include "ZblApp.h"

//#include "ZFile.h"
#include <QDir>

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZApplication)

ZTextFeed ZApplication::m_status;

QList<ZblApp*> ZApplication::m_zappObjects;

const QString ZApplication::m_defaultOrganization = "zubleapp";

const QString ZApplication::m_defaultApplication = ZApplication::getAppName();

//const QString ZApplication::m_queryProlog =
//"declare namespace zset = \"http://zuble.org/schema/zuble/settings\"; ";

const QString ZApplication::m_appPathPrefix = "zbl://";

const QString ZApplication::m_homePathPrefix = "home://";

const QString ZApplication::m_dataPathPrefix = "data://";

const QString ZApplication::m_fileUrlPrefix = "file://";

const QString ZApplication::m_resourcePathPrefix = "qrc://";

const QString ZApplication::m_settingMetadataFileName = "zblsettings.xml";

const QString ZApplication::m_settingMetadataInitName = "zblinitset.xml";

const QString ZApplication::m_defaultSettingsID = "default";

const QString ZApplication::m_defaultZubleAppSettings =

"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
"<appsettings\n"
"xmlns=\"http://zuble.org/schema/zuble/settings\"\n"
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
"xsi:schemaLocation=\"http://zuble.org/schema/zuble/settings zublesettings01.xsd\">\n"
"<organization>zuble.org</organization>\n"
"<name>Zuble</name>\n"
"<setgroups>\n"
"    <setgroup xml:id=\"zuble\">\n"
"    <name>Zuble Settings</name>\n"
"    </setgroup>\n"
"</setgroups>\n"
"<settings>\n"
"    <setting xml:id=\"enable-zuble-logging\" group=\"zuble\">\n"
"        <name>Enable Zuble Logging</name> "
"        <type>bool</type>\n"
"        <default>true</default>\n"
"        <status>\n"
"        <state value=\"false\">Disabled</state>\n"
"        <state value=\"true\">Enabled</state>\n"
"        </status>\n"
"        <desc>Redirects Qt log messages to Zuble's log manager.</desc>\n"
"    </setting>\n"
"    <setting xml:id=\"log-profile-path\" group=\"zuble\">\n"
"        <name>Log Profile</name>\n"
"        <type>string</type>\n"
"        <default>data://log-profiles/default-log-profile.json</default>\n"
"        <desc>The log profile controls the Zuble application's current logging behavior.</desc>\n"
"    </setting>\n"
"    <setting xml:id=\"sync-log-profile\" group=\"zuble\">\n"
"        <name>Sync Log Profile To Settings</name> "
"        <type>bool</type>\n"
"        <default>true</default>\n"
"        <status>\n"
"        <state value=\"false\">Disabled</state>\n"
"        <state value=\"true\">Enabled</state>\n"
"        </status>\n"
"        <desc>Current log settings will be synchronized with the log profile.</desc>\n"
"    </setting>\n"
"    <setting xml:id=\"log-output-dir\" group=\"zuble\">\n"
"        <name>Log Output Directory</name>\n"
"        <type>string</type>\n"
"        <default>data://log</default>\n"
"        <desc>Directory where log files will be saved.</desc>\n"
"    </setting>\n"
"</settings>\n"
"</appsettings>\n";

ZApplication::ZApplication(QObject * parent)
    : QObject(parent)

{
    ZBL_REGISTER_LOGGED_OBJECT

    zDebug() << "ZApplication::ZApplication";

}

bool ZApplication::zInit()
{

    zDebug() << "ZApplication::zInit";


    //QString dataPath(resolvePath(m_dataPathPrefix));

    //QDir dataDir(QDir::home());

    return initDefaultApplicationSettings();

}

bool ZApplication::initDefaultApplicationSettings()
{
    //static const QString settingMetadataFileName = "zblsettings.xml";

    // locate XML settings metadata - look in Zuble application dir,
    // or else use default settings.

    QString settingSrcPath = getRootPath();
    settingSrcPath += m_settingMetadataFileName;

    //bool queryOK = false;
    bool usingDefault = false;

    if(!QFile::exists(settingSrcPath))
    {
        zDebug() << "Can't find app settings metadata file: " << settingSrcPath;

        usingDefault = true;

        QString initSettingsMetaPath(m_dataPathPrefix + m_settingMetadataInitName);
        initSettingsMetaPath = resolvePath(initSettingsMetaPath, false);

        QFile initMetafile(initSettingsMetaPath);

        if(!initMetafile.exists())
        {
            zDebug() << "Creating default app settings metadata file...";

            const QString dataPath(getDataPath());

            QDir dataDir(dataPath);

            if(!dataDir.exists())
            {
                zDebug() << "Creating Zuble data directory: " << dataDir.path();

                if(!dataDir.mkpath(dataPath))
                {
                    zCritical() << "Can't create Zuble data directory";

                    zCritical() << "ABORTING settings initialization!";

                    return false;
                }
            }

            bool fileOK = initMetafile.open(QIODevice::WriteOnly);

            if(!fileOK)
            {
                zDebug() << "Can't initialize settings metafile: "
                         << initSettingsMetaPath
                         << " error message = "
                         << initMetafile.errorString();

                zCritical() << "ABORTING settings initialization!";

                return false;
            }
            else
            {
                qint64 bytesWritten =
                        initMetafile.write(m_defaultZubleAppSettings.toUtf8());

                if(bytesWritten == -1)
                {
                    zDebug() << "Can't initialize settings metafile: "
                             << initSettingsMetaPath
                             << " error message = "
                             << initMetafile.errorString();

                    zCritical() << "ABORTING settings initialization!";

                    return false;

                }

                initMetafile.close();
             }
        }

        zDebug() << "Using default settings metafile: "
                 << initSettingsMetaPath;

        settingSrcPath = initSettingsMetaPath;
    }
    else
    {
        zDebug() << "Using application settings metafile: " << settingSrcPath;
    }


    return ZSettings::insertBundle(m_defaultSettingsID, settingSrcPath);

}

ZTextFeed& ZApplication::zStatus()
{
    return m_status;
}


QString ZApplication::resolvePath(
        const QString& prefix,
        const QString& root,
        const QString& path,
        bool includeUrlScheme)
{
    if(path.length() < prefix.length())
    {
        return path;
    }
    else if(path.startsWith(prefix))
    {
        if(includeUrlScheme)
        {
            if(hasPathScheme(root))
                return root + path.mid(prefix.length());
            else
                return m_fileUrlPrefix + root + path.mid(prefix.length());
        }
        else
        {
            return root + path.mid(prefix.length());
        }
    }
    else
    {
        return path;
    }
}

QString ZApplication::resolvePath( const QString& path,
        bool includeUrlScheme)
{
    QString ret = path;

    if(ret.length() < 4)
        return ret;

    if(!hasPathScheme(path) && includeUrlScheme)
    {
        ret = m_fileUrlPrefix + path;
    }
    else if(path.startsWith(m_appPathPrefix))
    {
        ret = resolvePath(m_appPathPrefix,
                    getRootPath(),
                    path,
                    includeUrlScheme);
    }
    else if(path.startsWith(m_homePathPrefix))
    {
        QString homePath(QDir::homePath() + "/");

        ret = resolvePath(m_homePathPrefix,
                    homePath,
                    path,
                    includeUrlScheme);
    }
    else if(path.startsWith(m_dataPathPrefix))
    {
        ret = resolvePath(m_dataPathPrefix,
                    getDataPath(),
                    path,
                    includeUrlScheme);
    }
    else if(path.startsWith(m_resourcePathPrefix))
    {
        ret = resolvePath(m_resourcePathPrefix,
                    ":",
                    path,
                    false);
    }


    return ret;
}

QString ZApplication::getPathScheme(const QString& path)
{
    QString ret;

    const int ixC = path.indexOf(':');

    if(ixC == -1)
        return ret;

    const int ixS = path.indexOf('/');

    if(ixS != ixC+1)
        return ret;

    ret = path.left(ixS+1);

    return ret;
}

QString ZApplication::removePathScheme(const QString& path)
{
    QString ret;

    const int ixC = path.indexOf(':');

    if(ixC == -1)
        return ret;

    const int ixS = path.indexOf('/');

    if(ixS != ixC+1)
        return ret;

    const int pathSize = path.length() - ixS - 1;

    if(pathSize > 0)
        ret = path.right(pathSize);

    return ret;
}

bool ZApplication::hasPathScheme(const QString& path)
{
    const int ixC = path.indexOf(':');

    if(ixC == -1)
        return false;

    const int ixS = path.indexOf('/');

    if(ixS != ixC+1)
        return false;

    return true;
}


QString ZApplication::getDataPath()
{
#if 0
    QString orgName = QCoreApplication::organizationName();

    if(orgName.isEmpty())
    {
        return QDir::homePath() + "/."
                + m_defaultOrganization + "/"
                + getAppName() + "/";

    }
    else
    {
        return QDir::homePath() + "/."
                + orgName + "/"
                + getAppName() + "/";
    }
#endif
    return QDir::homePath() + "/."
            + getOrganization() + "/"
            + getAppName() + "/";

}

QString ZApplication::getRootPath()
{
    QVariant path(qApp->property("org_zuble_appRootPath"));

    if(path.isValid())
        return path.toString();
    else
        return QString("%1/").arg(QCoreApplication::applicationDirPath());
}

QString ZApplication::getMainQmlPath()
{
    QVariant path(qApp->property("org_zuble_appMainQmlPath"));

    if(path.isValid())
        return path.toString();
    else
        return QString("%1/%2").arg(getRootPath()).arg("main.qml");
}


QString ZApplication::getAppName()
{
    QVariant name(qApp->property("org_zuble_appName"));

    if(name.isValid())
        return name.toString();
    else
        return QString(qApp->applicationName());
}

QString ZApplication::getOrganization()
{
    QString orgName = QCoreApplication::organizationName();

    if(!orgName.isEmpty())
        return orgName;
    else
        return m_defaultOrganization;
}

QVariant ZApplication::getAppData(int tag)
{
    QVariant retValue;

    switch(tag)
    {
    case appDirPath:
        retValue = QCoreApplication::applicationDirPath();
        break;
    case appFilePath:
        retValue = QCoreApplication::applicationFilePath();
            break;
    case appName:
        retValue = QCoreApplication::applicationName();
            break;
    case appPid:
        retValue = QCoreApplication::applicationPid();
            break;
    case appVersion:
        retValue = QCoreApplication::applicationVersion();
            break;
    case appArguments:
        retValue = QCoreApplication::arguments();
            break;
    case appLibraryPath:
        retValue = QCoreApplication::libraryPaths();
            break;

    default:

        zThreadErr.raiseError("ZApplication::getAppData - invalid data key: " + tag);
    }

    return retValue;

}

QString ZApplication::getObjectThreadAddress(QObject* object)
{
    char threadID[50];
    ZBL_SLOT_BEGIN_TRY
    if(!object)
    {
        sprintf(threadID, "<null object>");
    }
    else
    {
        QThread* pThread = object->thread();
        sprintf(threadID, "%p", pThread);
    }
    ZBL_SLOT_END_RETURN(QString(threadID),  QString("<Thread ID Error>"),
    Z_FAC_JS, ZApplication::getObjectThreadAddress, getObjectThreadAddress failed)
}

QString ZApplication::getCurrentThreadAddress()
{
    char threadID[50];
    ZBL_SLOT_BEGIN_TRY
    QThread* pThread = QThread::currentThread();
    sprintf(threadID, "%p", pThread);
    ZBL_SLOT_END_RETURN(QString(threadID),  QString("<Thread ID Error>"),
    Z_FAC_JS, ZApplication::getObjectThreadAddress, getObjectThreadAddress failed)
}

void ZApplication::debugObjectThreadAddress(const char* label, QObject* obj)
{
    qDebug() << label << " OBJECT THREAD: " << getObjectThreadAddress(obj);
}

void ZApplication::debugCurrentThreadAddress(const char* label)
{
    qDebug()  << label << " CURRENT THREAD: "  << getCurrentThreadAddress();
}

void ZApplication::debugGuiThreadAddress(const char* label)
{
    qDebug() << label << " GUI THREAD: "  << getObjectThreadAddress(qApp);
}

void ZApplication::debugCompareThreadAddress(const char* label, QObject* obj)
{
    debugCurrentThreadAddress(label);

    debugObjectThreadAddress(label, obj);

    debugGuiThreadAddress(label);
}

void ZApplication::addThreadApp(ZblApp* appObject)
{
    if(inObjectThread(this))
    {
        if(!m_zappObjects.contains(appObject))
        {
            m_zappObjects.append(appObject);

            //connect(this, &ZApplication::settingsBundleAvailable,
            //        appObject, &ZblApp::settingsBundleAvailable);
        }

    }
    else
    {
        QMetaObject::invokeMethod(this,"addThreadApp",
                                  Qt::QueuedConnection,
                                  Q_ARG(ZblApp*, appObject));
    }

}

void ZApplication::removeThreadApp(ZblApp* appObject)
{
    if(inObjectThread(this))
    {
        int ix = m_zappObjects.indexOf(appObject);

        if(ix != -1)
        {
            //disconnect(this, &ZApplication::settingsBundleAvailable,
            //        appObject, &ZblApp::settingsBundleAvailable);

            m_zappObjects.removeAt(ix);
        }

    }
    else
    {
        QMetaObject::invokeMethod(this,"removeThreadApp",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(ZblApp*, appObject));
    }

}


} // Zbl