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

**

** 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"

/*!

  @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()

{

    bool success = false;

    if (!server->listen(THEME_SERVER_NAME)) {

        qWarning("Unable to start the server: %s.", server->errorString().toLatin1().data());

#if defined(Q_OS_LINUX) || defined(Q_OS_MAC)

        if (server->serverError() == QAbstractSocket::AddressInUseError) {

            qDebug() << "Trying to delete temporary file hbthemeserver";

            QFile::remove("/tmp/hbthemeserver");

            success = start();

        }

#endif

        return success;

    }

#ifdef QT_DEBUG

    statusLabel.setText("Theme Server Started");

    setCentralWidget(&statusLabel);

#endif

    connect(server, SIGNAL(newConnection()), this, SLOT(newClientConnected()));

    success = true;

    return success;

}

/*!

  \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)

{

    return(iconCache->getCacheItem(key, false));

}

/*!

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

    QString prevTheme = settings.value("currenttheme").toString();

    if (prevTheme == newTheme) {

        // Theme did not change, return.

        return;

    }

    QString cleanThemeName = newTheme.trimmed();

    settings.setValue("currenttheme", cleanThemeName);

    settings.sync();

    HbThemeServerRequest requestType;

    requestType = EThemeSelection;

    QByteArray block;

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

    out << (int)requestType;

    out << cleanThemeName;

    writeToClients(block);

}

/*!

  \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;

        }

    }

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

}

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

}

int HbThemeServerPrivate::cacheMissCount()

{

    return iconCache->cacheMissCount();

}

int HbThemeServerPrivate::serverHeapSize()

{

    return 0;

}

void HbThemeServerPrivate::cleanVectorLRUList()

{

    iconCache->cleanVectorLRUList();

}

void HbThemeServerPrivate::cleanRasterLRUList()

{

    iconCache->cleanRasterLRUList();

}

int HbThemeServerPrivate::rasterLruCount()

{

    return iconCache->rasterLruCount();

}

int HbThemeServerPrivate::vectorLruCount()

{

    return iconCache->vectorLruCount();

}

#endif

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

//HbThemeServerSession - implementations

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

/*!

  @hbserver

  \class HbThemeServerSession

  \brief HbThemeServerSession implements the sessions associated with the server.

  The Theme server maintains a list of sessions, each session corresponding to a client.

  Each session in turn is responsible for keeping track of client specific resources.

  In case of Icon caching, a session maintains a list of Icon keys.

  A  key is added to the list only if the corresponding cache item has been successfully inserted into cache

  or if a previously cached icon is requested and successfully found in the cache.

  In case of client crash or graceful exit of client, the server goes through its list of sessions,

  finds the session corresponding to the client, removes the session from its session list and deletes the session.

  In the session destructor, the session specific resources are cleaned up.

  In case of icon caching, the list of icon keys is traversed and a remove operation is performed on the cache

  items corresponding to these keys. On removal, the items reference count is decremented and in case the

  reference count becomes 0, the cache item instance gets added to the back of the LRU list.

*/

/*!

  \fn HbThemeServerSession::HbThemeServerSession()

  Constructor

  \a aClientConnection indicates the local socket that is contained within this session

  \a aServer denotes the handle to the theme server

*/

HbThemeServerSession::HbThemeServerSession(QLocalSocket *aClientConnection, HbThemeServerPrivate *aServer)

{

    iServer = aServer;

    iClientConnection = aClientConnection;

    sessionIconData.clear();

    sessionCssData.clear();

    connect(iClientConnection, SIGNAL(readyRead()), this, SLOT(readDataFromClient()));

    connect(iClientConnection, SIGNAL(disconnected()), iClientConnection, SLOT(deleteLater()));

}

/*!

  \fn HbThemeServerSession::~HbThemeServerSession()

  Destructor

*/

HbThemeServerSession::~HbThemeServerSession()

{

    //Remove icon related-session-specific data

    QList<HbIconKey>::const_iterator itEnd(sessionIconData.constEnd());

    for (QList<HbIconKey>::const_iterator iter = sessionIconData.constBegin();

            iter != itEnd;

            ++iter) {

        iServer->removeIconCacheItem(*iter);

    }

    //Remove css related-session-specific data

    QList<QString>::const_iterator iterEnd(sessionCssData.constEnd());

    for (QList<QString>::const_iterator iter = sessionCssData.constBegin();

            iter != iterEnd;

            ++iter) {

        iServer->removeCssCacheItem(*iter);

    }

    sessionIconData.clear();

    sessionCssData.clear();

}

/*!

  \fn HbThemeServerSession::clientConnection()

  Returns a handle to the local socket contained by the session

*/

QLocalSocket * HbThemeServerSession::clientConnection()

{

    return iClientConnection;

}

/*!

  \fn HbThemeServerSession::readDataFromClient()

  Slot that is reponsible for reading data from the client

  Is responsible for performing operations such as creating cache items and storing into cache

  and writing back data to the client

*/

void HbThemeServerSession::readDataFromClient()

{

#ifdef THEME_SERVER_TRACES

    qDebug() << Q_FUNC_INFO;

#endif

    HbSharedIconInfo data;

    data.type = INVALID_FORMAT;

    HbThemeServerRequest requestType;

    QByteArray inputByteArray = ((QLocalSocket *)sender())->readAll();

    if (inputByteArray.size() > 0) {

        QDataStream inputDataStream(inputByteArray);

        int clue;

        inputDataStream >> clue;

        requestType = (HbThemeServerRequest)clue;

#ifdef THEME_SERVER_TRACES

        qDebug() << Q_FUNC_INFO << "recognizer: " << requestType;

#endif

//Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

        QByteArray outputByteArray;

        QDataStream outputDataStream(&outputByteArray, QIODevice::WriteOnly);

        outputDataStream << (int)requestType;

#endif

        switch (requestType) {

        case EStyleSheetLookup: {

            QString fileName;

            int priority;

            HbLayeredStyleLoader::LayerPriority layerdPriority;

            inputDataStream >> fileName;

            inputDataStream >> priority;

            layerdPriority = (HbLayeredStyleLoader::LayerPriority) priority;

            QByteArray output = handleStyleSheetLookup((int) requestType, fileName, layerdPriority);

            ((QLocalSocket *)sender())->write(output);

            break;

        }

        case EWidgetMLLookup: {

            QString filename;

            QString section;

            QString layout;