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

**

** 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 "hbthemeserver_generic_p_p.h"

#include <QLabel>

#include <QLocalServer>

#include <QLocalSocket>

#include <QSharedMemory>

#include <QSettings>

#include <QDebug>

#include <QList>

#include <QIcon>

#include <QFile>

#include <QCoreApplication>

#include <QPainter>

#include <QStringList>

#include <QPixmap>

#include <hbinstance.h>

#include "hbthemecommon_p.h"

#include "hbmemoryutils_p.h"

#include "hbthemeserverutils_p.h"

#include "hbiconcacheitemcreator_p.h"

#include "hbiconloader_p.h"

#include "hbcache_p.h"

#include "hbdeviceprofiledatabase_p.h"

#include "hbpixmapiconimpl_p.h"

#include "hbpixmapiconprocessor_p.h"

#include "hblayeredstyleloader_p.h"

#include "hbthemesystemeffect_p.h"

#include "hbsharedmemorymanager_p.h"

/*!

  @hbserver

  \class HbThemeServerPrivate

  \brief HbThemeServerPrivate implements the theme server

*/

#ifdef THEME_SERVER_TRACES

extern QLabel *testLabel;

#endif

// 5 MB GPU & CPU cache size

#define GPU_CACHE_SIZE 0x500000

#define CPU_CACHE_SIZE 0x500000

/*!

  \fn HbThemeServerPrivate::HbThemeServerPrivate()

  Constructor

  \a parent

*/

#ifdef QT_DEBUG

HbThemeServerPrivate::HbThemeServerPrivate(QWidget *parent): QMainWindow(parent), server(new QLocalServer(this))

#else

HbThemeServerPrivate::HbThemeServerPrivate(): server(new QLocalServer(this))

#endif

{

    iThemeSelectionClient = 0;

    sessionList.clear();

#ifdef QT_DEBUG

    setWindowTitle("Theme Server");

#endif

    // Using QScopedPointer so that it deallocates memory

    // when std::badalloc exception occurs.

    QScopedPointer <HbIconDataCache> tempIconCache(new HbIconDataCache());

    QScopedPointer <HbCache> tempCssCache(new HbCache());

    iconCache = tempIconCache.take();

    cssCache = tempCssCache.take();

    setMaxGpuCacheSize(GPU_CACHE_SIZE);

    setMaxCpuCacheSize(CPU_CACHE_SIZE);

}

/*!

  \fn HbThemeServerPrivate::~HbThemeServerPrivate()

  Destructor

*/

HbThemeServerPrivate::~HbThemeServerPrivate()

{

    server->close();

    delete server; // Order of Deletion needs to be maintain ,as the QLocalServer should delete first before deleting Server data so All sessions will be cleanup first.

    delete iconCache;

    delete cssCache;

}

/*!

  \fn HbThemeServerPrivate::start()

  start the themeserver

*/

bool HbThemeServerPrivate::start()

{

#endif

    }

#ifdef QT_DEBUG

#endif

}

/*!

  \fn HbThemeServerPrivate::insertIconCacheItem()

  Insert item into the icon cache

  \a key denotes the unique identifier for the cache item that is to be inserted into the cache.

  \a item denotes the cache item that is to be inserted

*/

bool HbThemeServerPrivate::insertIconCacheItem(const HbIconKey &key,  HbIconCacheItem *item)

{

    return (iconCache->insert(key, item));

}

/*!

  \fn HbThemeServerPrivate::insertCssCacheItem()

  Insert item into the css cache

  \a key denotes the unique identifier for the cache item that is to be inserted into the cache.

  \a item denotes the cache item that is to be inserted

*/

bool HbThemeServerPrivate::insertCssCacheItem(const QString &key,  HbCacheItem *item)

{

    return (cssCache->insert(key, item));

}

/*!

  \fn HbThemeServerPrivate::iconCacheItem()

  Find an item in the icon cache

  \a key denotes the unique identifier for the cache item that is to be found in the cache.

*/

HbIconCacheItem *HbThemeServerPrivate::iconCacheItem(const HbIconKey &key)

{

}

/*!

  \fn HbThemeServerPrivate::cssCacheItem()

  Find an item in the css cache

  \a key denotes the unique identifier for the cache item that is to be found in the cache.

*/

HbCacheItem *HbThemeServerPrivate::cssCacheItem(const QString &key)

{

    return(cssCache->cacheItem(key));

}

/*!

  \fn HbThemeServerPrivate::setMaxGpuCacheSize()

  Provides a mechanism for setting the Gpu cache limit

  \a size denotes the cache limit in bytes e.g. size = 0x500000

*/

void HbThemeServerPrivate::setMaxGpuCacheSize(int size)

{

    iconCache->setMaxGpuCacheSize(size);

}

/*!

  \fn HbThemeServerPrivate::setMaxCpuCacheSize()

  Provides a mechanism for setting the Cpu cache limit

  \a size denotes the cache limit in bytes e.g. size = 0x500000

*/

void HbThemeServerPrivate::setMaxCpuCacheSize(int size)

{

    iconCache->setMaxCpuCacheSize(size);

}

/*!

  \fn HbThemeServerPrivate::removeIconCacheItem()

  Remove an item from iconcache corresponding to key.

  \a key denotes the unique identifier for the cache item that is to be removed from the cache.

*/

void HbThemeServerPrivate::removeIconCacheItem(const HbIconKey &key)

{

    iconCache->remove(key);

}

/*!

  \fn HbThemeServerPrivate::removeCssCacheItem()

  Remove item from css cache corresponding to key.

  \a key denotes the unique identifier for the cache item that is to be removed from the cache.

*/

void HbThemeServerPrivate::removeCssCacheItem(const QString &key)

{

    cssCache->remove(key);

}

/*!

  \fn HbThemeServerPrivate::clearIconCache()

  Clears the icon cache

*/

void HbThemeServerPrivate::clearIconCache()

{

    iconCache->clear();

}

/*!

  \fn HbThemeServerPrivate::clearCssCache()

  Clears the css cache

*/

void HbThemeServerPrivate::clearCssCache()

{

    cssCache->clear();

}

/*!

  data.type = INVALID_FORMAT;

  \fn HbThemeServerPrivate::handleThemeSelection()

  Handle change of theme

  \a newTheme

*/

void HbThemeServerPrivate::handleThemeSelection(const QString &newTheme)

{

#ifdef THEME_SERVER_TRACES

    qDebug() << Q_FUNC_INFO << "  theme=" << newTheme;

#endif

    // Modify the QSettings to store the applied theme

    QSettings settings(QLatin1String(ORGANIZATION), QLatin1String(THEME_COMPONENT));

    // Clear cached icons and session data

    clearIconCache();

    HbThemeServerSession *session;

    foreach(session, sessionList) {

        session->clearSessionIconData();

    }

    QString cleanThemeName = newTheme.trimmed();

    settings.remove("currenttheme"); //temporary

    settings.setValue(CURRENT_THEME_KEY, cleanThemeName);

    settings.sync();

    // Register new system effects

    HbThemeSystemEffect::handleThemeChange(cleanThemeName);

    HbThemeServerRequest requestType;

    requestType = EThemeSelection;

    QByteArray block;

    QDataStream out(&block, QIODevice::WriteOnly);

    out << (int)requestType;

    out << cleanThemeName;

    writeToClients(block);

}

void HbThemeServerPrivate::handleContentUpdate(const QStringList &fileNames)

{

    // If list is empty clear all themed content

    if (!fileNames.count()) {

        // Clear icons

        HbThemeServerSession *session;

        foreach(session, sessionList) {

            session->clearSessionIconData();

        }

        iconCache->clear();

        // Clear effects

        HbThemeServerUtils::clearSharedEffects();

        // Clear stylesheets

        QHash<QString, HbCacheItem*>::const_iterator itEnd(themePriorityItems.constEnd());

        for (QHash<QString, HbCacheItem*>::const_iterator iter = themePriorityItems.constBegin();

                iter != itEnd;

                ++iter) {

            cssCache->cacheHandle().remove(iter.key());

            HbThemeServerSession *session;

            foreach(session, sessionList) {

                session->removeSessionCssItem(iter.key());

            }

        }

        themePriorityItems.clear();

        return;

    }

    // Else delete only specified files

    for (int i=0; i<fileNames.count();i++) {

        QString filename = fileNames.at(i);

        // Stylesheet

        if (themePriorityItems.contains(filename)) {

            cssCache->cacheHandle().remove(filename);

            themePriorityItems.remove(filename);

            HbThemeServerSession *session;

            foreach(session, sessionList) {

                session->removeSessionCssItem(filename);

            }

            break;

        }

        // Effect

        if (HbThemeServerUtils::removeSharedEffect(filename)) {

            break;

        }

        // Icon

        QVector<const HbIconKey *> keys = iconCache->getKeys(filename);

        for (int j = 0; j<keys.count();j++) {

            HbThemeServerSession *session;

            foreach(session, sessionList) {

                session->removeSessionIconItem(*keys.at(j));

            }

            iconCache->remove(*keys.at(j),false);

        }

    }

}

/*!

  \fn HbThemeServerPrivate::writeToClients()

  Write to all clients

  \a block

*/

void HbThemeServerPrivate::writeToClients(QByteArray &block)

{

    HbThemeServerSession *session;

#ifdef THEME_SERVER_TRACES

    qDebug() << Q_FUNC_INFO << "socketlist count: " << sessionList.count();

#endif

    foreach(session, sessionList) {

        QLocalSocket * curSocket = session->clientConnection();

        if (iThemeSelectionClient != curSocket) {

            curSocket->write(block);

        }

    }

}

/*!

  \fn HbThemeServerPrivate::setThemeSelectionClient()

  Set the theme selection client

  \a socket

*/

void HbThemeServerPrivate::setThemeSelectionClient(QLocalSocket *socket)

{

    iThemeSelectionClient = socket;

}

/*!

  \fn HbThemeServerPrivate::newClientConnected()

  Creates a new session with the server.

*/

void HbThemeServerPrivate::newClientConnected()

{

    QLocalSocket * newClient = server->nextPendingConnection();

    if (newClient) {

        HbThemeServerSession * newSession =

            new HbThemeServerSession(newClient, this);

        // Store list of client connected to server

        sessionList.append(newSession);

#ifdef THEME_SERVER_TRACES

        qDebug() << "Total No of Connection after addition = " << sessionList.count();

#endif

        connect(newClient, SIGNAL(disconnected()), this, SLOT(removeFromList()));

    }

}

/*!

  \fn HbThemeServerPrivate::removeFromList()

  Remove a session from list

*/

void HbThemeServerPrivate::removeFromList()

{

    QList<HbThemeServerSession*>::const_iterator itEnd(sessionList.constEnd());

    for (QList<HbThemeServerSession*>::const_iterator iter = sessionList.constBegin();

            iter != itEnd;

            ++iter) {

        if ((*iter)->clientConnection() == (QLocalSocket *)sender()) {

            sessionList.removeOne((*iter));

            delete(*iter);

            break;

        }

    }

}

//Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

int HbThemeServerPrivate ::cacheIconCount() const

{

    return iconCache->count();

}

int HbThemeServerPrivate::freeVectorMemory()

{

    return iconCache->freeVectorMemory();

}

int HbThemeServerPrivate::freeRasterMemory()

{

    return iconCache->freeRasterMemory();

}

int HbThemeServerPrivate::lastAddedRefCount()

{

    return iconCache->lastAddedRefCount();

}

int HbThemeServerPrivate::lastAddedItemMem()

{

    return iconCache->lastAddedItemMem();

}

int HbThemeServerPrivate::lastRemovedItemMem()

{

    return iconCache->lastRemovedItemMem();

}

int HbThemeServerPrivate::lastRemovedItemRfCount()

{

    return iconCache->lastRemovedItemRfCount();

}

bool HbThemeServerPrivate::enableCache(bool cacheIt)

{

    return iconCache->enableCache(cacheIt);

}

int HbThemeServerPrivate::cacheHitCount()

{

    return iconCache->cacheHitCount();

}