/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbServers module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbsplashgenerator_p.h"

#include "hbsplashdirs_p.h"

#include "hbsplashdefs_p.h"

#include "hbmainwindow.h"

#include "hbmainwindow_p.h"

#include "hbinstance.h"

#include "hbtheme.h"

#include "hbeffectinternal_p.h"

#include "hbview.h"

#include "hbdocumentloader.h"

#include "hbicon.h"

#include "hbaction.h"

#include "hbcolorscheme.h"

#include "hbstatusbar_p.h"

#include "hbstyle.h"

#include "hbbackgrounditem_p.h"

#include "hbframeitem.h"

#include <QCoreApplication>

#include <QPainter>

#include <QDir>

#include <QFile>

#include <QFileInfo>

#include <QSet>

#include <QSettings>

#include <QTranslator>

#include <QLocale>

#include <QTimer>

#if defined(Q_OS_SYMBIAN)

#include <f32file.h>

#include <coemain.h>

#endif

const char *last_theme_key = "lasttheme";

const char *last_lang_key = "lastlang";

const char *last_file_count_key = "lastfilecount";

const char *last_output_dir_key = "lastoutdir";

HbSplashGenerator::HbSplashGenerator()

    : mMainWindowLocked(false),

      mProcessQueuePending(false),

      mForceRegen(false),

      mMainWindow(0),

{

#if defined(Q_OS_SYMBIAN)

    CCoeEnv::Static()->FsSession().CreatePrivatePath(EDriveC);

    QString iniFileName = QString("c:/private/%1/hbsplashgen.ini")

                          .arg(QString::number(hbsplash_server_uid3.iUid, 16));

    mSettings = new QSettings(iniFileName, QSettings::IniFormat, this);

#else

    mSettings = new QSettings("Nokia", "Hb", this);

    mSettings->beginGroup("Splash");

#endif

    // Effects on decorators (started when they are shown) would ruin

    // the screenshot. So disable everything (except the orientation

    // switch effect which is needed for a proper rotated image).

    HbEffectInternal::setEffectsEnabled(false);

}

HbSplashGenerator::~HbSplashGenerator()

{

    delete mMainWindow;

    clearTranslators();

}

static QString orientationName(Qt::Orientation orientation)

{

    switch (orientation) {

    case Qt::Horizontal:

        return QLatin1String("lsc");

    case Qt::Vertical:

        return QLatin1String("prt");

    default:

        return QString();

    }

}

#define PRE "[hbsplashgenerator]"

static void log(const QString &msg, const QString &theme = QString(), int orientation = -1)

{

    const char *fmt = PRE " %s ('%s' '%s')";

    QString oriName = orientationName(static_cast<Qt::Orientation>(orientation));

    qDebug(fmt, qPrintable(msg), qPrintable(theme), qPrintable(oriName));

}

// To be called on startup and after each fully completed regeneration.

// Returns the number of files in the output directory.

int HbSplashGenerator::updateOutputDirContents(const QString &outDir)

{

    QDir dir(outDir);

    QStringList entries = dir.entryList(QDir::Files);

    emit outputDirContentsUpdated(outDir, entries);

    return entries.count();

}

void HbSplashGenerator::start(bool forceRegen)

{

    mForceRegen = forceRegen;

    QTimer::singleShot(5000, this, SLOT(doStart()));

}

void HbSplashGenerator::doStart()

{

    qDebug() << PRE << "accessing theme";

    // Start listening to the theme-change-finished signal.

    HbTheme *theme = hbInstance->theme();

    connect(theme, SIGNAL(changeFinished()), SLOT(regenerate()));

    // Watch also the directories containing splashml files. Files may

    // be added/updated at any time.

    connect(&mFsWatcher, SIGNAL(directoryChanged(QString)), SLOT(onDirectoryChanged(QString)));

    foreach(const QString & dir, hbsplash_splashml_dirs()) {

        // Check for directory existence before calling addPath() to

        // avoid printing warnings.

        if (QDir(dir).exists()) {

            mFsWatcher.addPath(dir);

        }

    }

    // Regenerate screens on startup only when the theme, the language, the

    // number of files in the splash screen directory, or the splash screen

    // directory path is different than the recorded values. (or when

    // regeneration is forced via command line arg)

    QString lastTheme = mSettings->value(QLatin1String(last_theme_key)).toString();

    QString lastLang = mSettings->value(QLatin1String(last_lang_key)).toString();

    int lastFileCount = mSettings->value(QLatin1String(last_file_count_key)).toInt();

    QString lastOutputDir = mSettings->value(QLatin1String(last_output_dir_key)).toString();

    QString currentTheme = theme->name();

    QString currentLang = QLocale::system().name();

    QString currentOutputDir = hbsplash_output_dir();

    int currentFileCount = updateOutputDirContents(currentOutputDir);

    qDebug() << PRE << "last regen:" << lastTheme << lastLang << lastFileCount << lastOutputDir

             << "current:" << currentTheme << currentLang << currentFileCount << currentOutputDir;

    if (mForceRegen

            || currentFileCount == 0 // not having any files is wrong for sure

            || currentTheme != lastTheme

            || currentLang != lastLang

            || currentFileCount != lastFileCount

            || currentOutputDir != lastOutputDir) {

        QMetaObject::invokeMethod(this, "regenerate", Qt::QueuedConnection);

    }

}

void HbSplashGenerator::uncachedRegenerate()

{

    // Same as regenerate() but no caching is used so every file is

    // parsed again.

    mParsedSplashmls.clear();

    regenerate();

}

void HbSplashGenerator::regenerate()

{

    QString themeName = hbInstance->theme()->name();

    qDebug() << PRE << "regenerate() theme:" << themeName;

    if (!themeName.isEmpty()) {

        try {

            emit regenerateStarted();

            QTime queuePrepTime;

            queuePrepTime.start();

            // Delete existing splash screens. This is important because apps

            // should never pick up a screen with the previous theme or

            // language. If the generation of the new screens (at least the

            // empty view) has not finished when a new app is started then it is

            // better to show no splash screen at all.

            QDir outDir(hbsplash_output_dir());

            if (outDir.exists()) {

                QStringList names = outDir.entryList(QStringList() << "*", QDir::Files);

                foreach(const QString & name, names) {

                    outDir.remove(name);

                }

            }

            // Clear the queue, generating screens with a non-current theme is

            // not possible anyway.

            mQueue.clear();

            // If this is the first invocation then put some requests for

            // screens we won't use. On certain platforms the very first

            // rendering (with a newly created mainwindow) may lead to

            // mysteriously scaled down output.

            if (mFirstRegenerate) {

                mFirstRegenerate = false;

                mQueue.enqueue(QueueItem(themeName, Qt::Vertical));

                mQueue.enqueue(QueueItem(themeName, Qt::Horizontal));

            }

            // Queue the screenshot request for both orientations.

            mQueue.enqueue(QueueItem(themeName, Qt::Vertical));

            mQueue.enqueue(QueueItem(themeName, Qt::Horizontal));

            queueAppSpecificItems(themeName, Qt::Vertical);

            queueAppSpecificItems(themeName, Qt::Horizontal);

            qDebug() << PRE << "queue preparation time (ms):" << queuePrepTime.elapsed();

            QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);

        } catch (const std::bad_alloc &) {

            cleanup();

        }

    }

}

void HbSplashGenerator::regenerateOne(const QString &splashmlFileName, const QString &customTrDir)

{

    mQueue.clear();

    QueueItem item(hbInstance->theme()->name(), Qt::Vertical);

    QString path = QFileInfo(splashmlFileName).path();

    item.mCustomTrDirs.append(path);

    if (!customTrDir.isEmpty()) {

        item.mCustomTrDirs.append(customTrDir);

    }

    parseSplashml(splashmlFileName, item);

    item.mDocmlFileName = QDir(path).filePath(item.mDocmlFileName);

    mQueue.enqueue(item); // generate it regardless of the fixed orientation setting

    item.mOrientation = Qt::Horizontal;

    mQueue.enqueue(item);

    QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);

}

QImage HbSplashGenerator::renderView()

{

    log("renderView()", mItem.mThemeName, mItem.mOrientation);

    // Note: Do not use QPixmap::grabWidget() because our widget has never been

    // shown (it is not visible). QGraphicsView::render() seems to work better

    // in this respect. Also, let's use QImage because the stuff is going to a

    // file and is never drawn anywhere. This makes using graphics system

    // dependent things (e.g. some special filter effects) impossible but using

    // those for a splash screen would not be the best idea anyway.

    QTime t;

    t.start();

    // The image format must be the one that fits the OpenVG paint engine best.

    // (in order to avoid unnecessary conversions later when apps load and show

    // these images)

    QImage image(mMainWindow->size(), QImage::Format_ARGB32_Premultiplied);

    image.fill(QColor(Qt::transparent).rgba());

    QPainter painter(&image);

    mMainWindow->render(&painter);

    qDebug() << PRE << "rendering time (ms):" << t.elapsed();

    return image;

}

void HbSplashGenerator::processQueue()

{

    qDebug() << PRE << "processQueue()";

    // If the queue is empty then the splash regeneraton is complete so store

    // the current theme and language names as the last fully processed ones in

    // the settings and stop.

    if (mQueue.isEmpty()) {

        qDebug() << PRE << "queue is empty  regen finished";

        mSettings->setValue(last_theme_key, hbInstance->theme()->name());

        mSettings->setValue(last_lang_key, QLocale::system().name());

        QString outDir = hbsplash_output_dir();

        mSettings->setValue(last_output_dir_key, outDir);

        emit finished();

        qDebug() << PRE << "processQueue() over";

        return;

    }

    // If a previous splash generation is still in progress or a compositor is

    // working then do nothing.

    if (!lockMainWindow()) {

        mProcessQueuePending = true;

        qDebug() << PRE << "still busy  processQueue() over";

        return;

    }

    try {

        mProcessQueuePending = false;

        mItem = mQueue.dequeue();

        mItemTime.start();

        log("generating splash screen", mItem.mThemeName, mItem.mOrientation);

        ensureMainWindow();

        mMainWindow->setOrientation(mItem.mOrientation, false);

        qDebug() << PRE << "mainwindow init time (ms):" << mItemTime.elapsed();

        QTime setupTime;

        setupTime.start();

        setupAppSpecificWindow();

    } catch (const std::bad_alloc &) {

        cleanup();

    }

    qDebug() << PRE << "processQueue() over";

}

HbMainWindow *HbSplashGenerator::ensureMainWindow()

{

    if (!mMainWindow) {

        // The FixedVertical flag is used just to disable the sensor-based

        // orientation switching.

        mMainWindow = new HbMainWindow(0, Hb::WindowFlagFixedVertical);

        // Make sure that at least the 1st phase of the delayed

        // construction is done right now.

        HbMainWindowPrivate::d_ptr(mMainWindow)->_q_delayedConstruction();

    }

    return mMainWindow;

}

void HbSplashGenerator::processWindow()

{

    // Take the screenshot, remove content, and move on to the next request in the queue.

    log("processWindow()  rendering splash screen", mItem.mThemeName, mItem.mOrientation);

    takeScreenshot();

    qDebug() << PRE << "total time for screen (ms):" << mItemTime.elapsed();

    QList<HbView *> views = mMainWindow->views();

    foreach(HbView * view, views) {

        mMainWindow->removeView(view);

        delete view;

    }

    clearTranslators();

    unlockMainWindowInternal();

    QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);

    log("processWindow() over", mItem.mThemeName, mItem.mOrientation);

}

void HbSplashGenerator::takeScreenshot()

{

    log("takeScreenshot()", mItem.mThemeName, mItem.mOrientation);

    try {

        // Render the content. Note that this may use the wrong theme

        // graphics if there are quick theme changes on-going. We only

        // guarantee that there will always be a correct splash screen for

        // the currently set theme, and that can be fulfilled because even

        // though the screenshot we make here may be wrong in such a case

        // there will already be a new request queued due to the theme

        // change.

        QImage image = renderView();

        QTime t;

        t.start();

        QString splashFile = splashFileName();

        qDebug() << PRE << "saving to" << splashFile;

        if (saveSpl(splashFile, image, mItem.mFlagsToStore)) {

#if !defined(Q_OS_SYMBIAN) && defined(QT_DEBUG)

            image.save(splashFile + QLatin1String(".png"));

#endif

        } else {

            qWarning() << PRE << "file write failed for" << splashFile;

        }

        qDebug() << PRE << "save time (ms):" << t.elapsed();

        log("takeScreenshot() over", mItem.mThemeName, mItem.mOrientation);

    } catch (const std::bad_alloc &) {

        cleanup();

    }

}

QString HbSplashGenerator::splashFileName()

{

    QString outDirName = hbsplash_output_dir();

    QDir dir(outDirName);

    if (!dir.exists()) {

        }

    }

    // "splash_<orientation>_<appid>_<screenid>"

    QString splashFile = dir.filePath("splash_");

    splashFile.append(orientationName(mItem.mOrientation));

    if (!mItem.mAppId.isEmpty()) {

        splashFile.append('_');

        splashFile.append(mItem.mAppId);

        if (!mItem.mScreenId.isEmpty()) {

            splashFile.append('_');

            splashFile.append(mItem.mScreenId);

        }

    }

    return splashFile;

}

bool HbSplashGenerator::saveSpl(const QString &nameWithoutExt, const QImage &image, quint32 extra)

{

    QString fn(nameWithoutExt);

    fn.append(".spl");

    QFile f(fn);

    if (f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {

        quint32 w = (quint32) image.width();

        quint32 h = (quint32) image.height();

        quint32 bpl = (quint32) image.bytesPerLine();

        qint32 fmt = (qint32) image.format();

        f.write((char *) &w, sizeof(quint32));

        f.write((char *) &h, sizeof(quint32));

        f.write((char *) &bpl, sizeof(quint32));

        f.write((char *) &fmt, sizeof(qint32));

        f.write((char *) &extra, sizeof(quint32));

        f.close();

    }

    return false;

}

void HbSplashGenerator::cleanup()

{

    mQueue.clear();

    delete mMainWindow;

    mMainWindow = 0;

    clearTranslators();

    unlockMainWindowInternal();

    mProcessQueuePending = false;

}

QDebug operator<<(QDebug dbg, const HbSplashGenerator::QueueItem &item)

{

    dbg << "["

        << item.mDocmlFileName

        << item.mAppId

        << item.mScreenId

        << item.mDocmlWidgetName

        << item.mThemeName

        << orientationName(item.mOrientation)

        << item.mTsAppName

        << "]";

    return dbg;

}

HbSplashGenerator::QueueItem::QueueItem()

    : mOrientation(Qt::Vertical),

      mHideBackground(false),

      mFlagsToStore(0)

{

}

HbSplashGenerator::QueueItem::QueueItem(const QString &themeName, Qt::Orientation orientation)

    : mThemeName(themeName),

      mOrientation(orientation),

      mHideBackground(false),

      mFlagsToStore(0)

{

}

void HbSplashGenerator::addSplashmlItemToQueue(const QueueItem &item)

{

    bool fixedPortrait = item.mFixedOrientation == QLatin1String("portrait");

    bool fixedLandscape = item.mFixedOrientation == QLatin1String("landscape");

    if (fixedPortrait && item.mOrientation != Qt::Vertical) {

        return;

    }

    if (fixedLandscape && item.mOrientation != Qt::Horizontal) {

        return;

    }

    mQueue.enqueue(item);

}

void HbSplashGenerator::queueAppSpecificItems(const QString &themeName, Qt::Orientation orientation)

{

    QSet<QString> processedFileNames;

    QStringList dirNames(hbsplash_splashml_dirs());

    foreach(const QString & dirName, dirNames) {

        QDir dir(dirName);

        if (!dir.exists()) {

            continue;

        }

        QStringList entries = dir.entryList(QStringList() << "*.splashml", QDir::Files);

        foreach(const QString & entry, entries) {

            // Skip if a file with the same name has already been processed from

            // a different location.

            if (processedFileNames.contains(entry)) {

                qDebug() << PRE << "skipping splashml (already found at other location)" << dir.filePath(entry);

                continue;

            }

            processedFileNames.insert(entry);

            QString fullName = dir.filePath(entry);

            qDebug() << PRE << "parsing splashml" << fullName;

            if (mParsedSplashmls.contains(fullName)) {

                QueueItem item(mParsedSplashmls.value(fullName));

                item.mThemeName = themeName;