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

**

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

#include "hbthemeserverutils_p.h"

#include "hbmemorymanager_p.h"

#include "hbiconsource_p.h"

#include "hbthemeindex_p.h"

#include "hbthemeutils_p.h"

#include <QHash>

#include <QImage>

#include <QSettings>

#include <QSharedMemory>

#include <QDebug>

#include <QProcess>

#include <QFile>

#include <QPainter>

#include <QSizeF>

#include <e32property.h>

#include <e32base.h>

#include <e32svr.h>

#include "hbpixmapiconprocessor_p.h"

#include "hbpixmapiconimpl_p.h"

#include "hblayeredstyleloader_p.h"

#include "hbmemoryutils_p.h"

#include "hbdeviceprofiledatabase_p.h"

// 5 MB GPU cache size

#define GPU_CACHE_SIZE 0x500000

// 5 MB  CPU cache size

#define CPU_CACHE_SIZE 0x500000

const TInt KThemeName = 0;

static HbThemeServerSymbian *TheServer = 0;

// This is used as parent theme always regardless of the active theme

static const char *baseThemeName = "hbdefault";

const int themeIndexFailed = -2; // error code to indicate failure in processing theme index

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

//HbThemeServerSymbian

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

/**

Our server class - an active object - and therefore derived ultimately from CActive.

It accepts requests from client threads and forwards

them to the client session to be dealt with. It also handles the creation

of the server-side client session.

*/

/**

NewL

 */

HbThemeServerSymbian * HbThemeServerSymbian::NewL(CActive::TPriority aActiveObjectPriority)

{

    HbThemeServerSymbian* self = new(ELeave) HbThemeServerSymbian(aActiveObjectPriority);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

}

/**

ConstructL

 */

void HbThemeServerSymbian::ConstructL()

{

    TInt err = RProperty::Define(KServerUid3, KThemeName, RProperty::ELargeText);

    if ( err != KErrAlreadyExists ) {

        User::LeaveIfError( err );

    }

    TInt error = iThemeProperty.Attach(KServerUid3, KThemeName );

    User::LeaveIfError(error);

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

    // Store the active theme name in a member string

    iCurrentThemeName = settings.value("currenttheme").toString();

    // HACK

    if (iCurrentThemeName.isEmpty()) {

        iCurrentThemeName = "sfblacktheme";

    }

    // TODO: Get default theme name if current theme setting does not return theme name

/*

    if (iCurrentThemeName.isEmpty()) {

        iCurrentThemeName = HbThemeUtils::defaultTheme();

        settings.setValue("currenttheme", iCurrentThemeName); 

        settings.sync();

        TPtrC name(reinterpret_cast<const TUint16 *>(iCurrentThemeName.constData()));

        iThemeProperty.Set(name);

    }

*/

    // Resolve the drive letter of the current theme

    resolveCurrentThemeDrive();

    // Open index file to prevent uninstallation of the active theme

    openCurrentIndexFile();

    //Create the Icon cache

    cache = new HbIconDataCache();

    setMaxGpuCacheSize(GPU_CACHE_SIZE);

    setMaxCpuCacheSize(CPU_CACHE_SIZE);

    //Create the CSS cache

    cssCache = new HbCache();

    // Temporary hack for pre-loading app. background graphics in server startup to give more realistic

    // results in performance tests. (Normally these graphics get loaded anyway when the first hb app is started.)

#ifndef HB_NVG_CS_ICON

    QProcess::startDetached("hbiconpreloader.exe");

#endif

    // Process base theme index, it is used as parent index also when the current theme is something else

    processThemeIndex(baseThemeName, QChar('Z'));

    baseThemeIndexKey = themeIndexKey(baseThemeName, QChar('Z'));

}

/**

Constructor takes the server priority value. 

The server is an active object, and the priority value is the priority

of this active object.

It passes the priority value to the base class in the Ctor list.

By default, the session is not sharable, which is what we want here

so no second parameter is passed to the CServer2 constructor.

*/

HbThemeServerSymbian::HbThemeServerSymbian( CActive::TPriority aActiveObjectPriority )

    : CServer2( aActiveObjectPriority ),

      currentThemeDrive('Z') // Assume default theme is in ROM

{

    // Set server pointer in static variable

    TheServer = this;

}

/**

Destructor

 */

HbThemeServerSymbian::~HbThemeServerSymbian()

{

    delete cache;

    delete cssCache;

    cache = NULL;      // so that HbSymbianThemeServSession::~HbSymbianThemeServSession can avoid using these pointers;

	cssCache = NULL;   // it may be called inside HbThemeServerSymbian::~HbThemeServerSymbian

}

HbThemeServerSymbian *HbThemeServerSymbian::Instance()

{

    return TheServer;

}

void HbThemeServerSymbian::openCurrentIndexFile()

{

    // Open index file to prevent uninstallation of the active theme

    if (!iCurrentThemeName.isEmpty() && currentThemeDrive != 'Z') {

        QString indexFileName;

        indexFileName.append(currentThemeDrive);

        indexFileName.append("\\resource\\hb\\themes\\icons\\");

        indexFileName.append(iCurrentThemeName);

        indexFileName.append("\\index.theme");

        currentIndexfile.setFileName(indexFileName);

        if(!currentIndexfile.open(QIODevice::ReadOnly)) {

            qWarning()<< "HbSymbianThemeServer: No Index file found in the new theme, How did this happen ??";

        }

    }

}

void HbThemeServerSymbian::resolveCurrentThemeDrive()

{

    if (!iCurrentThemeName.isEmpty()) {

        // Check for the theme's icon directory in different drives.

        // ROM is checked first and then phone memory and memory card drives.

        QString filename = "Z:\\resource\\hb\\themes\\icons\\";

        filename.append(iCurrentThemeName);

        if (QFile::exists(filename)) {

            currentThemeDrive = 'Z';

            return;

        }

        filename[0] = 'C';

        if (QFile::exists(filename)) {

            currentThemeDrive = 'C';

            return;

        }

        filename[0] = 'E';

        if (QFile::exists(filename)) {

            currentThemeDrive = 'E';

            return;

        }

        // Default to 'Z' if not found in any drive

        currentThemeDrive = 'Z';

    }

}

/**

Creates a new session with the server.

*/

CSession2* HbThemeServerSymbian::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

{

#ifdef THEME_SERVER_TRACES 

    qDebug() << "HbThemeServerSymbian::NewSessionL: entered";

#endif    

    // Check that the version is OK

    TVersion v( KThemeServerMajorVersionNumber, KThemeServerMinorVersionNumber, KThemeServerBuildVersionNumber );

    if (!User::QueryVersionSupported( v, aVersion ))

        User::Leave( KErrNotSupported );  

    // Create the session.

    return new (ELeave) HbSymbianThemeServSession( const_cast<HbThemeServerSymbian*>(this) );

}

/**

A utility function to panic the server.

*/

void HbThemeServerSymbian::PanicServer(TPixmapServPanic aPanic)

{

    _LIT(KTxtServerPanic, "Pixmap server panic");

    User::Panic(KTxtServerPanic, aPanic);

}

/**

 * HbThemeServerSymbian::insertIconCacheItem

 * 

 * Inserts an icon-cache item along with its key into the icon-cache.

 */

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

{

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

}

/**

 * HbThemeServerSymbian::insertCssCacheItem

 * 

 * Inserts a css-cache item along with its key into the css-cache.

 */

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

{

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

}

/**

 * HbThemeServerSymbian::iconCacheItem

 * 

 * Retrieves a icon cache-item from the icon cache based on it's key.

 */

HbIconCacheItem * HbThemeServerSymbian::iconCacheItem ( const HbIconKey &key , bool isMultiIconPiece )

{

    return(cache->getCacheItem(key, isMultiIconPiece));

}

/**

 * HbThemeServerSymbian::cssCacheItem

 * 

 * Retrieves a css-cache item from the css cache based on it's key.

 */

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

{

    return(cssCache->cacheItem(key));

}

void HbThemeServerSymbian::insertIconDefaultSizeCacheItem(const QString &key, const QSizeF &item)

{

    iconDefaultSizes.insert(key, item);

}

QSizeF HbThemeServerSymbian::iconDefaultSizeCacheItem(const QString &key)

{

    return iconDefaultSizes.value(key);

}

/**

 * HbThemeServerSymbian::clearIconCache

 * 

 * Clears icon cache.

 */

void HbThemeServerSymbian::clearIconCache()

{

    cache->clear();

}

/**

 * HbThemeServerSymbian::clearCssCache

 * 

 * Clears css cache.

 */

void HbThemeServerSymbian::clearCssCache()

{

    cssCache->clear();

}

/**

 * HbThemeServerSymbian::CleanupSessionIconItem

 * 

 * Removes an icon cache-item from icon-cache based on it's key.

 */

void HbThemeServerSymbian::CleanupSessionIconItem(HbIconKey key)

{

    /*

	    Don't call any HbIconDataCache functions if HbThemeServerSymbian has already deleted it,

	     which happens when ThemeServer is closed before the client(s).

	*/

    if(cache)

        cache->remove(key); 

}

/**

 * HbThemeServerSymbian::CleanupSessionCssItem

 * 

 * Removes a css cache-item from css-cache based on it's key.

 */

void HbThemeServerSymbian::CleanupSessionCssItem(QString key)

{

    /*

	    Don't call any HbCache ( CssCache )  functions if HbThemeServerSymbian has already deleted it,

	     which happens when ThemeServer is closed before the client(s).

	*/

    if(cssCache)

        cssCache->remove(key); 

}

/**

HbThemeServerSymbian::setMaxGpuCacheSize

 */

void HbThemeServerSymbian::setMaxGpuCacheSize(int size)

{

    cache->setMaxGpuCacheSize(size);

}

/**

HbThemeServerSymbian::setMaxGpuCacheSize

 */

void HbThemeServerSymbian::setMaxCpuCacheSize(int size)

{

    cache->setMaxCpuCacheSize(size);

}

//Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

int HbThemeServerSymbian ::cacheIconCount() const

{

    return cache->count();

}

int HbThemeServerSymbian::freeVectorMemory()

{

    return cache->freeVectorMemory();

}

int HbThemeServerSymbian::freeRasterMemory()

{

    return cache->freeRasterMemory();

}

int HbThemeServerSymbian::lastAddedRefCount()

{

    return cache->lastAddedRefCount();

}

int HbThemeServerSymbian::lastAddedItemMem()

{

    return cache->lastAddedItemMem();

}

int HbThemeServerSymbian::lastRemovedItemMem()

{

    return cache->lastRemovedItemMem();

}

int HbThemeServerSymbian::lastRemovedItemRfCount()

{

    return cache->lastRemovedItemRfCount();

}

bool HbThemeServerSymbian::enableCache(bool cacheIt)

{

    return cache->enableCache(cacheIt);

}

int HbThemeServerSymbian::cacheHitCount()

{

    return cache->cacheHitCount();

}

int HbThemeServerSymbian::cacheMissCount()

{

    return cache->cacheMissCount();

}

int HbThemeServerSymbian::serverHeapSize()

{

    TInt heapSize = 0; 

    User::AllocSize(heapSize);

    return heapSize;

}

void HbThemeServerSymbian::cleanVectorLRUList()

{

    cache->cleanVectorLRUList();

}

void HbThemeServerSymbian::cleanRasterLRUList()

{

    cache->cleanRasterLRUList();

}

int HbThemeServerSymbian::rasterLruCount()

{

    return cache->rasterLruCount();

}

int HbThemeServerSymbian::vectorLruCount()

{

    return cache->vectorLruCount();

}

#endif

/**

 * HbThemeServerSymbian::doCleanup()

 * 

 * This function releases shared memory occupied by css-resources whose reference count is zero,

 * so that subsequent css-requests could be fulfilled by the server. Those css-files whose reference

 * count are zero, are already appended to the LRU list maintained by the css-cache. Since these resources

 * are not being referred to by any application, they can be removed from the cache and corresponding

 * shared memory can be freed up.

 */

void HbThemeServerSymbian::doCleanup() 

{

    HbThemeServerUtils::cleanupUnusedCss(cssCache);

}

QString HbThemeServerSymbian::themeIndexKey(const QString &theme, const QChar drive)

{

    QString key(drive);

    key.append(':');

    key.append(theme);

    return key;

}

void HbThemeServerSymbian::processThemeIndex(const QString &theme, const QChar drive)

{

    QString filename(drive);

    filename.append(":\\resource\\hb\\themes\\");

    filename.append(theme);

    filename.append(".themeindex");

    QFile indexFile(filename);

    bool indexOK = false;

    if (indexFile.open(QIODevice::ReadOnly)) {

        indexOK = true;

        GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

        qint64 byteSize = indexFile.size();

        int offset = manager->alloc(byteSize);

        if (offset >= 0) {        

            // Read the theme index in the shared chunk

            char *address = HbMemoryUtils::getAddress<char>(HbMemoryManager::SharedMemory, offset);

            #ifdef THEME_INDEX_TRACES

            qDebug() <<  "ThemeIndex: Reading themeindex for theme" << theme.toUtf8();

            #endif

            indexFile.read(address, byteSize);

            indexFile.close();

            #ifdef THEME_INDEX_TRACES

            qDebug() <<  "ThemeIndex: Reading themeindex for theme" << theme.toUtf8() << "... Done!";

            #endif

            // Verify theme index contents if it is not located in ROM,

            // so that it does not have over-indexing offsets which might

            // crash all the clients trying to read from it.

            if (drive != 'Z') {

                #ifdef THEME_INDEX_TRACES

                qDebug() <<  "ThemeIndex: Validating themeindex for theme" << theme.toUtf8();

                #endif

                HbThemeIndex index(address);

                int count = index.itemCount();

                if (count * sizeof(HbThemeIndexItem) >= byteSize) {

                    indexOK = false;

                } else {

                    const HbThemeIndexItem *itemArray = index.itemArray();

                    int stringAreaStart = reinterpret_cast<int>(index.stringAreaStart()) - reinterpret_cast<int>(address);

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

                        const HbThemeIndexItem *item = itemArray++;

                        if (item->iconnameOffset < stringAreaStart || item->iconnameOffset >= byteSize ||

                            item->folderOffset < stringAreaStart || item->folderOffset >= byteSize ||

                            item->extOffset < stringAreaStart || item->extOffset >= byteSize ||

                            item->mirroredExtOffset != -1 &&

                            (item->mirroredExtOffset < stringAreaStart || item->mirroredExtOffset >= byteSize)) {