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

**

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

#include "hbthemeserverutils_p.h"

#include "hbmemorymanager_p.h"

#include "hbiconsource_p.h"

#include "hbthemeindex_p.h"

#include "hbthemeutils_p.h"

#include "hbsharedmemorymanager_p.h"

#include "hbtypefaceinfodatabase_p.h"

#include <QHash>

#include <QImage>

#include <QSharedMemory>

#include <QDebug>

#include <QProcess>

#include <QFile>

#include <QFileInfo>

#include <QPainter>

#include <QSettings>

#include <QSizeF>

#include <e32property.h>

#include <e32base.h>

#include <e32svr.h>

#include <centralrepository.h>

#include "hbpixmapiconprocessor_p.h"

#include "hbpixmapiconimpl_p.h"

#include "hblayeredstyleloader_p.h"

#include "hbmemoryutils_p.h"

#include "hbdeviceprofiledatabase_p.h"

#include "hbthemesystemeffect_p.h"

#ifdef HB_SGIMAGE_ICON

#include "hbsgimagerenderer_p.h"

#endif

// 5 MB GPU cache size

#define GPU_CACHE_SIZE 0x500000

// 5 MB  CPU cache size

#define CPU_CACHE_SIZE 0x500000

static const TInt KThemeName = 0;

const QString KOperatorCPath = "C:/resource/hb/prioritytheme/icons/";

const QString KOperatorZPath = "Z:/resource/hb/prioritytheme/icons/";

bool HbThemeServerPrivate::gpuGoodMemoryState = true;

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

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

//HbThemeServerPrivate

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

/**

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

 */

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

{

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

/**

ConstructL

 */

void HbThemeServerPrivate::ConstructL()

{

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

    if ( err != KErrAlreadyExists ) {

        User::LeaveIfError( err );

    }

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

    User::LeaveIfError(error);

    QString currentTheme = HbThemeUtils::getThemeSetting(HbThemeUtils::CurrentThemeSetting);

    // Store the active theme name in a member string

    // and resolve the path of the current theme

    QDir path(currentTheme);

    iCurrentThemeName = path.dirName();

    iCurrentThemePath = path.absolutePath();

    cache = 0;

    cssCache = 0;

    QT_TRY {

        //Create the Icon cache

        cache = new HbIconDataCache();

        //Create the CSS cache

        cssCache = new HbCache();

    } QT_CATCH(const std::bad_alloc &badalloc) {

        delete cache;

        delete cssCache;

        qt_symbian_exception2LeaveL(badalloc);

    }

    setMaxGpuCacheSize(GPU_CACHE_SIZE);

    setMaxCpuCacheSize(CPU_CACHE_SIZE);

#if defined(HB_SGIMAGE_ICON) || defined(HB_NVG_CS_ICON)

    renderMode = EHWRendering;

#else

    renderMode = ESWRendering;

#endif

    // Load theme indexes

    UpdateThemeIndexes();

    // Start the splash screen generator app.

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

}

void HbThemeServerPrivate::UpdateThemeIndexes(bool updateBase)

{

    // Start watching the current theme.index for uninstallation

    if (!openCurrentIndexFile()) {

        // theme doesn't exist activate default theme

        QString defaultTheme = HbThemeUtils::getThemeSetting(HbThemeUtils::DefaultThemeSetting);

        QDir path(defaultTheme);

        iCurrentThemeName = path.dirName();

        iCurrentThemePath = path.absolutePath();

    }

    if (updateBase) {

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

        HbThemeServerUtils::createThemeIndex(HbThemeUtils::getThemeSetting(HbThemeUtils::BaseThemeSetting), BaseTheme);

    }

    // Process operator theme indexes

    QString operatorName = HbThemeUtils::getThemeSetting(HbThemeUtils::OperatorNameSetting);

    if (!operatorName.isEmpty()) {

        QString operatorPath;

        operatorPath.append(KOperatorCPath);

        operatorPath.append(operatorName);

        HbThemeServerUtils::createThemeIndex(operatorPath, OperatorC);

        if (updateBase) {

            // Process operator Drive Z theme index

            QString operatorROMPath;

            operatorROMPath.append(KOperatorZPath);

            operatorROMPath.append(operatorName);

            HbThemeServerUtils::createThemeIndex(operatorROMPath, OperatorROM);

        }

    }

    // Process current theme index

    HbThemeServerUtils::createThemeIndex(iCurrentThemePath, ActiveTheme);

    // Register theme system effects

    // TODO: fix parameter

    HbThemeSystemEffect::handleThemeChange(iCurrentThemeName);

    // Set the current theme also in the cenrep key that is used to notify clients.

    HbThemeUtils::setThemeSetting(HbThemeUtils::CurrentThemeSetting, iCurrentThemePath);

}

/**

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.

*/

HbThemeServerPrivate::HbThemeServerPrivate(CActive::TPriority aActiveObjectPriority)

    : CServer2( aActiveObjectPriority ), iWatcher(0)

{

    // Set up the listener to listen for Publish events

    TRAPD(err, iListener = CHbThemeChangeNotificationListener::NewL(*this));

    if (err) {

        qWarning( "HbThemeServerPrivate::HbThemeServerPrivate: CHbThemeChangeNotificationListener::NewL failed = %d", err );

    } else {

        TRAPD(err, iListener->startListeningL());

        if (err) {

             qWarning( "HbThemeServerPrivate::HbThemeServerPrivate: iListener->startListening failed = %d", err );

         }

    }    

}

/**

Destructor

 */

HbThemeServerPrivate::~HbThemeServerPrivate()

{

    delete cache;

    delete cssCache;

    cache = 0;      // so that HbThemeServerSession::~HbThemeServerSession can avoid using these pointers;

    cssCache = 0;   // it may be called inside HbThemeServerPrivate::~HbThemeServerPrivate

    TInt err = RProperty::Delete(KServerUid3, KNewThemeForThemeChanger);

    if(err != KErrNotFound) {

        User::LeaveIfError(err);

    }

    // Delete the listener for Publish/Subscribe

    delete iListener;

    // Delete file watcher

    if (iWatcher) {

        delete iWatcher;

    }

}

/*

 * Returns FALSE if file doesn't exist, TRUE otherwise

 */

bool HbThemeServerPrivate::openCurrentIndexFile()

{

    if (!iCurrentThemePath.isEmpty() && iCurrentThemePath[0] != 'z' && 

        iCurrentThemePath[0] != 'Z' && iCurrentThemePath[0] != ':') {

        QString indexFileName;

        indexFileName.append(iCurrentThemePath);

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

        QFile currentIndexfile(indexFileName);

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

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

            return false;

        } else {

            currentIndexfile.close();

            if (!iWatcher) {

                // Set up the file watcher for active theme changes

                TRAP_IGNORE(iWatcher = CHbThemeWatcher::NewL(*this));

            }

            // Start watching in case of mmc ejection

            if (iWatcher) {

                iWatcher->startWatchingL(indexFileName);

            }

        }

    }

    return true;

}

/**

Handles theme selection

*/

void HbThemeServerPrivate::HandleThemeSelection( const QString& themeName)

{

    QDir path(themeName.trimmed());

    iCurrentThemeName = path.dirName();

    iCurrentThemePath = path.absolutePath();

    #ifdef THEME_INDEX_TRACES

    qDebug() << "ThemeIndex: theme change request, new theme =" << themeName.toUtf8();

    #endif

    // Clear cached icons and session data

    clearIconCache();

    iSessionIter.SetToFirst();

    while(iSessionIter) {

        HbThemeServerSession &session = reinterpret_cast<HbThemeServerSession &>(*iSessionIter);

        session.ClearSessionData();

        iSessionIter++;

    }

    // Update current theme index

    UpdateThemeIndexes(false);

}

/**

Creates a new session with the server.

*/

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

{

#ifdef THEME_SERVER_TRACES

    qDebug() << "HbThemeServerPrivate::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) HbThemeServerSession(const_cast<HbThemeServerPrivate*>(this));

}

/**

A utility function to panic the server.

*/

void HbThemeServerPrivate::PanicServer(TPixmapServPanic aPanic)

{

    _LIT(KTxtServerPanic, "Pixmap server panic");

    User::Panic(KTxtServerPanic, aPanic);

}

/**

 * HbThemeServerPrivate::insertIconCacheItem

 *

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

 */

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

{

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

}

/**

 * HbThemeServerPrivate::insertCssCacheItem

 *

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

 */

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

{

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

}

/**

 * HbThemeServerPrivate::iconCacheItem

 *

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

 */

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

{

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

}

/**

 * HbThemeServerPrivate::cssCacheItem

 *

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

 */

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

{

    return(cssCache->cacheItem(key));

}

/**

 * HbThemeServerPrivate::clearIconCache

 *

 * Clears icon cache.

 */

void HbThemeServerPrivate::clearIconCache()

{

    cache->clear();

}

/**

 * HbThemeServerPrivate::clearCssCache

 *

 * Clears css cache.

 */

void HbThemeServerPrivate::clearCssCache()

{

    cssCache->clear();

}

/**

 * HbThemeServerPrivate::CleanupSessionIconItem

 *

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

 */

void HbThemeServerPrivate::CleanupSessionIconItem(HbIconKey key)

{

    /*

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

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

    */

    if (cache) {

        cache->remove(key);

    }

}

/**

 * HbThemeServerPrivate::IconTypeInCache

 *

 * Returns the Icon Format Type i.e SGIMAGE,NVG,SVG etc...if it is present in cache

 * else returns INVALID_FORMAT

 */

 HbIconFormatType HbThemeServerPrivate::IconTypeInCache( const HbIconKey &key ) const

{

    if ( key.filename.isEmpty() || !cache->contains(key) ) {

         return INVALID_FORMAT;

    }

    HbIconCacheItem* item = cache->value(key);

    if ( item->rasterIconData.type != INVALID_FORMAT ) {

        return item->rasterIconData.type;

    } else {

        return item->vectorIconData.type;

    }

}

/**

 * HbThemeServerPrivate::CleanupSessionCssItem

 *

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

 */

void HbThemeServerPrivate::CleanupSessionCssItem(QString key)

{

    /*

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

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

    */

    if (cssCache) {

        cssCache->remove(key);

    }

}

/**

HbThemeServerPrivate::setMaxGpuCacheSize

 */

void HbThemeServerPrivate::setMaxGpuCacheSize(int size)

{

    cache->setMaxGpuCacheSize(size);

}

/**

HbThemeServerPrivate::setMaxGpuCacheSize

 */

void HbThemeServerPrivate::setMaxCpuCacheSize(int size)

{

    cache->setMaxCpuCacheSize(size);

}

void HbThemeServerPrivate::MemoryGood()

{

    gpuGoodMemoryState = true;

    cache->memoryGood();

}

void HbThemeServerPrivate::FreeGpuRam(int bytes, bool useSwRendering )

{

    gpuGoodMemoryState = false;

    cache->freeGpuRam(bytes, useSwRendering);

#ifdef HB_SGIMAGE_ICON

    if (useSwRendering) {

    HbSgImageRenderer::global()->terminate();

    }    	

#endif

}

/**

 *  HbThemeServerPrivate::freeUnusedGpuResources

 *  This function frees all unused SgImage icons

 *

 */

void HbThemeServerPrivate::freeUnusedGpuResources()

{

#if defined(HB_SGIMAGE_ICON) || defined(HB_NVG_CS_ICON)

#ifdef HB_ICON_CACHE_DEBUG

        HbSgImageRenderer *sgImg = HbSgImageRenderer::global();

        qDebug() << "Free GPU Memory Before clearing GPU LRU list  = " << sgImg->freeGPUMemory();

#endif    

    cache->freeUnusedGpuResources();

#ifdef HB_ICON_CACHE_DEBUG

        qDebug() << "Free GPU Memory After clearing GPU LRU list  = " << sgImg->freeGPUMemory();

#endif        

#endif

}

bool HbThemeServerPrivate::gpuMemoryState()

{

    return gpuGoodMemoryState;

}

int HbThemeServerPrivate::freeSharedMemory()

{

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    return static_cast<HbSharedMemoryManager *>(manager)->freeSharedMemory();

}

int HbThemeServerPrivate::allocatedSharedMemory()

{

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory);

    return static_cast<HbSharedMemoryManager *>(manager)->allocatedSharedMemory();

}

int HbThemeServerPrivate::allocatedHeapMemory()

{

    TInt heapSize = 0;

    User::AllocSize(heapSize);

    return heapSize;

}

/**

 *  HbThemeServerPrivate::currentRenderingMode

 *  This function returns ThemeServer's current rendering mode

 *

 */

HbRenderingMode HbThemeServerPrivate::currentRenderingMode() const

{

    return renderMode;

}