/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of class CAknIconSrv.

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <e32property.h>

#include <fbs.h>

#include <gdi.h>

#include <bitdev.h>

#include <mifconvdefs.h>

#ifdef PRECACHELOG

#include <flogger.h>

#endif

#include "AknIconSrv.h"

#include "AknIconSrvScheduler.h"

#include "AknIconSrvSession.h"

#include "AknIconSrvDef.h"

#include "AknIconSrvIconItem.h"

#include "AknIconFormatHandler.h"

#include "AknIconFormatHandlerFactory.h"

#include "AknIconLoader.h"

#include "AknIconSrvCache.h"

#include "AknIconSrvPanic.h"

#include "AknIconUtils.h"

#include "AknIconDataPreserver.h"

#include "AknIconDataItem.h"

#include "AknIconSrvUtils.h"

#include "AknIconFileNameCache.h"

#include "akniconconfig.h"

#include "AknIconTraces.h"

#include "AknBitmap.h"

#include <centralrepository.h>

#include <UikonInternalPSKeys.h>    // KUikLayoutState

#include <AvkonInternalCRKeys.h>    // KAknQwertyInputModeActive

#include <avkondomainpskeys.h>      // KAknPowerMenuStatus

#include <bitdev.h>

#include "SvgtRasterizerKeyDefs.hrh"

// CONSTANTS

const TUid KZiUdbProterty = {0x101F8614};

const TInt KZiUdbPropertyKey = 1;

const TUid KT9UdbProterty = {0x101F8615};

const TInt KT9UdbPropertyKey = 1;

const TInt KIconItemArrayGranularity = 4;

// Value -1 is used to indicate 'automatic' layout ID detection.        

const TInt KAvkonAutomaticLayoutDetectionValue = -1;

_LIT( KAvkonIconFileName, "z:\\resource\\apps\\avkon2.mif" );

_LIT( KAknIconServerStartupSemaphore, "AknIconSem" );

// ================= MEMBER FUNCTIONS =======================

CAknIconServer::CAknIconServer()

    : CServer2( CActive::EPriorityStandard ),

    iIconItems( KIconItemArrayGranularity )

    {

    }

// Create and start a new server.

CAknIconServer* CAknIconServer::NewL()

    {

    CAknIconServer* server = new( ELeave ) CAknIconServer;

    CleanupStack::PushL( server );

    server->ConstructL();

    CleanupStack::Pop();

    return server;

    }

void CAknIconServer::ConstructL()

    {    

    User::LeaveIfError( iFsSession.Connect() );

    User::LeaveIfError( RFbsSession::Connect() );

    User::LeaveIfError( Start( KAknIconSrvName ) );

    iFileNameCache = CAknIconFileNameCache::NewL();

    iIconDataPreserver = CAknIconDataPreserver::NewL( *this );

    _LIT_SECURITY_POLICY_PASS(KPassReadPolicy);

    _LIT_SECURITY_POLICY_PASS(KPassWritePolicy);

    _LIT_SECURITY_POLICY_C1(KWriteDDPolicy, ECapabilityWriteDeviceData);

    _LIT_SECURITY_POLICY_C1(KWriteTUPolicy, ECapabilityTrustedUI);

    TInt err1  = RProperty::Define(KCRUidAvkon,       KAknQwertyInputModeActive, RProperty::EInt, KPassReadPolicy, KWriteDDPolicy);

    TInt err2  = RProperty::Define(KPSUidUikon,       KUikLayoutState,           RProperty::EInt, KPassReadPolicy, KWriteDDPolicy);

    TInt err3  = RProperty::Define(KPSUidUikon,       KUikOOMWatchdogStatus,     RProperty::EInt, KPassReadPolicy, KPassWritePolicy);

    TInt err4  = RProperty::Define(KPSUidUikon,       KUikVideoCallTopApp,       RProperty::EInt, KPassReadPolicy, KWriteDDPolicy);

    TInt err5  = RProperty::Define(KPSUidUikon,       KUikFFSFreeLevel,          RProperty::EInt, KPassReadPolicy, KWriteTUPolicy);

    TInt err6  = RProperty::Define(KPSUidUikon,       KUikMmcFFSFreeLevel,       RProperty::EInt, KPassReadPolicy, KWriteTUPolicy);

    TInt err7  = RProperty::Define(KPSUidUikon,       KUikGlobalNotesAllowed,    RProperty::EInt, KPassReadPolicy, KWriteDDPolicy);

    TInt err8  = RProperty::Define(KZiUdbProterty,    KZiUdbPropertyKey,         RProperty::EInt, KPassReadPolicy, KPassWritePolicy);

    TInt err9  = RProperty::Define(KT9UdbProterty,    KT9UdbPropertyKey,         RProperty::EInt, KPassReadPolicy, KPassWritePolicy);

    TInt err10 = RProperty::Define(KPSUidAvkonDomain, KAknPowerMenuStatus,       RProperty::EInt, KPassReadPolicy, KWriteDDPolicy);

    TInt err11 = RProperty::Define(KPSUidAvkonDomain, KAknEndKeyEvent,           RProperty::EInt, KPassReadPolicy, KWriteDDPolicy);         

    TInt err12 = RProperty::Define(KSvgtPropertyCategory, ESvgtPropertyBool,     RProperty::EInt);         

    RProperty::Set( KSvgtPropertyCategory, ESvgtPropertyBool, ETrue );

#ifdef _DEBUG

    RDebug::Print(_L("xxxx KAknQwertyInputModeActive err=%d"), err1);

    RDebug::Print(_L("xxxx KUikLayoutState           err=%d"), err2);

    RDebug::Print(_L("xxxx KUikOOMWatchdogStatus     err=%d"), err3);

    RDebug::Print(_L("xxxx KUikVideoCallTopApp       err=%d"), err4);

    RDebug::Print(_L("xxxx KUikFFSFreeLevel          err=%d"), err5);

    RDebug::Print(_L("xxxx KUikMmcFFSFreeLevel       err=%d"), err6);

    RDebug::Print(_L("xxxx KUikGlobalNotesAllowed    err=%d"), err7);

    RDebug::Print(_L("xxxx KZiUdbProterty            err=%d"), err8);

    RDebug::Print(_L("xxxx KT9UdbProterty            err=%d"), err9);

    RDebug::Print(_L("xxxx KAknPowerMenuStatus       err=%d"), err10);

    RDebug::Print(_L("xxxx KAknEndKeyEvent           err=%d"), err11);

    RDebug::Print(_L("xxxx ESvgtPropertyBool         err=%d"), err12);

#endif

    CRepository* repository = NULL;

    TRAPD(ret, repository = CRepository::NewL(KCRUidAvkon));

    if (ret == KErrNone)

        {

        // Reset value of KAknLayoutId on the boot.

        // Return value ignored.

        ret = repository->Set(KAknLayoutId, KAvkonAutomaticLayoutDetectionValue); 

        }

    delete repository;

    repository = NULL;     

#ifdef _NGATESTING

    do {

    iConfigIconType = -1;

    TRAPD(leaveError, LoadConfigurationL(iFsSession));

		if(leaveError!=KErrNone)

		{

			#ifdef _DEBUG

		RDebug::Print(_L("xxxx LoadConfigurationL err=%d"), leaveError);

		#endif

		}

    } while (0);

#endif

    iThreadLaunchStatus = KRequestPending;

    // This launches SVG precache thread, if required.

    iCache = CAknIconSrvCache::NewL( *this );

    User::WaitForRequest( iThreadLaunchStatus );

    }

CAknIconServer::~CAknIconServer()

    {

    iIconItems.ResetAndDestroy();

    delete iAvkonIconLoader;

    delete iOtherIconLoader;

    delete iCurrentIconFile;

    delete iCache;

    delete iIconDataPreserver;    

    delete iFileNameCache;

    iHandlerList.ResetAndDestroy();

    RFbsSession::Disconnect();

    iFsSession.Close();

    }

// -----------------------------------------------------------------------------

// CAknIconServer::NewSessionL()

// -----------------------------------------------------------------------------

CSession2* CAknIconServer::NewSessionL(

    const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

    {

    return new( ELeave ) CAknIconSrvSession( );

    }

// -----------------------------------------------------------------------------

// CAknIconServer::RetrieveOrCreateSharedIconL

// -----------------------------------------------------------------------------

//

const CAknIconSrvIconItem* CAknIconServer::RetrieveOrCreateSharedIconL()

    {

    #ifdef __AKNICON_TRACES

    RDebug::Print(_L("AKNICON start"));

    #endif

    TAknIconParams info;

    TPckg<TAknIconParams> infoPack( info );

    TRAPD( err, Message().ReadL( 0, infoPack ) );

	if ( err != KErrNone ) 

    	{

    	((CAknIconSrvSession*)(Message().Session()))->SetClientPanicCode(EBadDescriptor);

    	User::Leave(KAknIconSrvCodePanicClient);

    	}

    TAknIconSrvReturnData retData;

    TPckg<TAknIconSrvReturnData> dataPack( retData );

    CAknIconSrvIconItem* item = NULL;

#ifdef __AKNICON_TRACES

    info.PrintInfo();

#endif     

#ifdef PRECACHE2

     // bitmap handles of precached icons need to be duplicated

     while(iNewPrecachedItems.Count())

        {

        #ifdef __AKNICON_TRACES

        RDebug::Printf("Precache add,%d",iNewPrecachedItems.Count());

        #endif

        CAknIconSrvIconItem* item = iNewPrecachedItems[0];

        CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

        CleanupStack::PushL(bitmap);

        TInt err1 = bitmap->Duplicate(item->iBitmap->Handle());

        iFreePrecacheBitmapHandles.AppendL(item->iBitmap);

        CleanupStack::Pop();

        item->iBitmap = bitmap;

        CFbsBitmap* mask = NULL;

        if (item->iMask)

            {

            mask = new (ELeave) CFbsBitmap;

            CleanupStack::PushL(mask);

            TInt err2 = mask->Duplicate(item->iMask->Handle());

            iFreePrecacheBitmapHandles.AppendL(item->iMask);

            CleanupStack::Pop();

            item->iMask = mask;

            }

        err1 = iIconItems.InsertInOrder( item, CAknIconSrvIconItem::LinearOrder );

        if (err1 == KErrAlreadyExists)

            {

            iNewPrecachedItems.Remove(0);

            #ifdef __AKNICON_TRACES

            RDebug::Printf("precache warning, already exists!");

            #endif

            TInt index = iIconItems.FindInOrder(item, CAknIconSrvIconItem::LinearOrder );

            CAknIconSrvIconItem* foundItem = iIconItems[index];

            foundItem->iPrecacheItem = ETrue;

            //Set this item to be cached

            if(foundItem->IsExcludedFromCache())

                {

                foundItem->SetCached();

                }

            //Item not in use and hence in Dynamic cache

            //Move item from dynamic cache to precache    

            if( foundItem->iUserCount == 0)

                {

                iCache->DynamicToPrecache( *foundItem);    

                }

            else

                {

                }

            delete item;

            }

        else if (err1 == KErrNone)

            {

            iNewPrecachedItems.Remove(0);

            #ifdef __AKNICON_TRACES

            RDebug::Print(_L("precache load,%S,%d,%d,%d,%d,%d,%d,%d"),

                 item->iFileName,

                 item->iBitmapId,

                 item->iMaskId,

                 item->iSize.iWidth,

                 item->iSize.iHeight,

                 item->iModeAndFlags & 0xffff,

                 item->iRotationAngle,

                 item->iColor.Internal());

            #endif    

            iCurrentIndex = iIconItems.FindInOrder(item, CAknIconSrvIconItem::LinearOrder );

            // delete icon, so it will be moved to icon cache

            if (DeleteOrCacheUnusedIcon(item) == EFalse)

                {

                AknIconConfig::CompressIfPreferred(bitmap, mask,iCompression);

                }

            else

                {

	            #ifdef __AKNICON_TRACES

	            RDebug::Printf("Did not insert into dynamic cache, deleting item");

	            #endif

                }

            }

        else

            {

            #ifdef __AKNICON_TRACES

            RDebug::Printf("precache warning, Unable to insert into iIconItems");

            #endif

            // No point continuing if one item insertion fails, as

            // following requests would result in same error.

            break;

            }

        }

     if (iPrecacheComplete)

        {

        iPreCacheThread.Resume();

        iPrecacheComplete = EFalse;

        }

#endif

    TInt index = RetrieveIcon( info );

    if ( index >= 0 )

        {

        item = iIconItems[index];

        item->iUserCount++;

        if ( info.iMaskId >= 0 )

            {

            // Also mask increases user count.

            item->iUserCount++;

            }

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: %x CAknIconServer::RetrieveOrCreateSharedIconL: existing item=%x, info=%x"), this, item, &info);

#endif   

        }

    // Not found in current icon item list

    else

        {

        // MBM icon case

        if ( info.IsMbmIcon() )

            {

            Message().ReadL( 1, dataPack );

            item = CreateMbmIconL( info, retData );

            }

        // MIF icon case

        else

            {

            item = iIconDataPreserver->CreateIconL( info );

            if ( !item )

                {

                item = CreateIconL( info );

                }

             //PrecacheCache tool

            #ifdef PRECACHELOG                 

            _LIT( KFileLoggingDir, "AknIconPreCacher" );

            _LIT( KFileLog, "Traces.txt" );

            _LIT(lMsg, "AKNICON load,%S,%d,%d,%d,%d,%d,%d,%d,%d");

            RFileLogger::WriteFormat(KFileLoggingDir, KFileLog, EFileLoggingModeAppend, lMsg,

            &info.iFileName,

                     info.iBitmapId,

                     info.iMaskId,

                     info.iSize.iWidth,

                     info.iSize.iHeight,

                     info.iMode,

                     info.iRotationAngle,

                     info.iColor.Internal(),

                     info.IsCompressionDisabled());                 

            #endif

            //PrecacheCache tool

                }

        if ( info.iAppIcon )

            {

            if ( info.IsMbmIcon() )

                {

                AknIconSrvUtils::EnsureValidSizeL(item->iBitmap, item->iMask);   

                }

           #ifndef __NVG

		else 

		    {

		    ReCreateSvgL(info,item);

		    } 

           #endif /*__NVG*/

            }

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: %x CAknIconServer::RetrieveOrCreateSharedIconL: new item=%x, info=%x"), this, item, &info);

#endif   

        CleanupStack::PushL( item );

        // Apply icon color here, if requested.

        ApplyIconColorL( item, info.iColor );

        // Call CompressIfPreferred if bitmap compression is not

        // disabled for the icon

        if (!item->IsCompressionDisabled())

            {

            AknIconConfig::CompressIfPreferred(item->iBitmap, item->iMask,iCompression);     

            }               

        User::LeaveIfError( 

            iIconItems.InsertInOrder( item, CAknIconSrvIconItem::LinearOrder ) );

        CleanupStack::Pop(); // item

        }

    // No leaving code allowed in the end of the function!

    // Otherwise icon item's user count is increased but never decreased,

    // because an error code is returned to the client.

    retData.iBitmapHandle = item->iBitmap->Handle();

    if ( item->iMask )

        {

        retData.iMaskHandle = item->iMask->Handle();

        }

    retData.iContentDimensions = item->iDimensions;

    // Remove item from cache because it is now used by someone.

    iCache->RemoveIfCached( *item );

    #ifdef __AKNICON_TRACES

    RDebug::Print(_L("AKNICON loaded,%S,%d,%d"),&info.iFileName,info.iBitmapId,item->iBitmap->Handle());

    #endif

    // Set if the icon will be cached dynamically after it is not used

    // Note that if the icon was excluded from cache earlier it will remain

    // excluded for its lifetime.

    if (info.IsExcludedFromCache())

        {

        item->ExcludeFromCache();    

        }

    // This does not leave as long as the descriptor is valid in the client side.

    Message().WriteL( 1, dataPack );

    return item;

    }

// -----------------------------------------------------------------------------

// CAknIconServer::FreeBitmapL

//

// Note: This function can only leave when an ASSERT fails. During normal 

//       conditions it should never leave.

// -----------------------------------------------------------------------------

//

const CAknIconSrvIconItem* CAknIconServer::FreeBitmapL()

    {

    TAknIconParams info;

    TPckg<TAknIconParams> paramPack( info );

    TRAPD( err, Message().ReadL( 0, paramPack ) );

    __ASSERT_ALWAYS( err == KErrNone, 

       (

       ((CAknIconSrvSession*)(Message().Session()))->SetClientPanicCode(EBadDescriptor),

       User::Leave( KAknIconSrvCodePanicClient ) // leave to prevent possible server crash

       ));

    iCurrentIndex = RetrieveIcon( info );

    __ASSERT_ALWAYS( iCurrentIndex >= 0, 

        (

        ((CAknIconSrvSession*)(Message().Session()))->SetClientPanicCode(EIconNotFound),

        User::Leave( KAknIconSrvCodePanicClient ) // leave to prevent possible server crash

        ));

    CAknIconSrvIconItem* item = iIconItems[iCurrentIndex];

		  if (info.IsExcludedFromCache())

        {

        item->ExcludeFromCache();    

        }    

    item->iUserCount--;

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: %x CAknIconServer::FreeBitmapL: item=%x, user count=%d"), this, item, item->iUserCount);

#endif 

    DeleteOrCacheUnusedIcon( item );

    // It is safe to return also a pointer to a deleted item.

    return item;

    }

// -----------------------------------------------------------------------------

// CAknIconServer::PreserveIconDataL

// -----------------------------------------------------------------------------

//

const CAknIconDataItem* CAknIconServer::PreserveIconDataL()

    {

    TAknIconParams params;

    TPckg<TAknIconParams> paramsPack( params );

    TRAPD( err, Message().ReadL( 0, paramsPack ) );

	if ( err != KErrNone ) 

    	{

    	((CAknIconSrvSession*)(Message().Session()))->SetClientPanicCode(EBadDescriptor);

    	User::Leave(KAknIconSrvCodePanicClient);

    	}