/*

* Copyright (c) 2003-2008 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:  Chunk maintainer.

*

*/

// INCLUDE FILES

#include "AknsSrvChunkMaintainer.h"

#include <AknsSrvClient.h>

#include "AknsSrvUtils.h"

#include <AknsConstants.h>

#include "AknsSrvDescriptorFileLayout.h"

#include "AknsSrvBitmapStore.h"

#include <fbs.h>

#include <bautils.h>

#include "AknsSrvVariant.hrh"

#include <versioninfo.h>

#include <AknsSkinUID.h>

#include "AknsDebug.h"

// CONSTANTS

static const TInt KAknsSrvMinMorphingInterval = 60; // in seconds

static const TInt KAknsSrvSkipMajor = -3;

static const TInt KAknsSrvSkipMinor = -3;

static const TInt KAknsSrvRewriteMajor = -4;

static const TInt KAknsSrvRewriteBase = -256;

static const TInt KAknsSrvMaxChunkReaders = 127;

static const TInt KAknsSrvTextColorGroupCount = 63;

// All of the following constants _MUST_ be divisible by 4

// This value seems to be most efficient when comparing memory consumption:

static const TInt KAknsSrvSharedChunkInitialSize = 160*1024;

static const TInt KAknsSrvSharedChunkMaxSize = 384*1024;

// This value seems to be most efficient when comparing memory consumption:

static const TInt KAknsSrvSharedChunkGranularity = 4*1024;

static const TInt KAknsSrvSharedChunkHeaderAreaSize = 16*4;

static const TInt KAknsSrvMaxHashList = 128;

static const TInt KAknsSrvMaxHashSize = 1024;

static const TInt32 KAknsSrvIdleWallpaperFilenameID = 0xc0def00d;

static const TInt KAknsSrvMaxScalableGfxItems =

    KAknsSrvSharedChunkGranularity / sizeof(TAknsSrvScalableItemDef);

_LIT(KAknsSrvScalableRomBmpLocation,":\\resource\\skins\\");

_LIT(KAknsSrvPathEndSeparator, "\\");

// ============================= LOCAL FUNCTIONS ===============================

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

// TAknsSrvCMPostOp::LinearOrder

//

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

//

TInt TAknsSrvCMPostOp::LinearOrder(

    const TAknsSrvCMPostOp& aFirst,

    const TAknsSrvCMPostOp& aSecond )

    {

    return TAknsItemID::LinearOrder( aFirst.iIID, aSecond.iIID );

    }

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

 CAknsSrvMorphingTimer* CAknsSrvMorphingTimer::NewL(MAknsSrvMorphingListener* aListener, TInt aInterval)

    {

    CAknsSrvMorphingTimer* self = new (ELeave)CAknsSrvMorphingTimer(aListener, aInterval);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CAknsSrvMorphingTimer::RunL()

    {

    iListener->MorhphingEventTimeout();

    IssueRequest();

    }

void CAknsSrvMorphingTimer::DoCancel()

    {

    iTimer.Cancel();

    }

void CAknsSrvMorphingTimer::IssueRequest()

    {

    if ( !IsActive() )

        {

        TTime now;

        now.HomeTime();

        now+=TTimeIntervalSeconds(iInterval);

        iTimer.At(iStatus, now);

        SetActive();

        }

    }

CAknsSrvMorphingTimer::~CAknsSrvMorphingTimer()

    {

    Cancel();

    iTimer.Close();

    }

void CAknsSrvMorphingTimer::ConstructL()

    {

    User::LeaveIfError(iTimer.CreateLocal());

    }

CAknsSrvMorphingTimer::CAknsSrvMorphingTimer(MAknsSrvMorphingListener* aListener,TInt aInterval) :

        CActive(CActive::EPriorityStandard),

        iListener(aListener),

        iInterval(aInterval)

    {

    CActiveScheduler::Add(this);

    }

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

// Destructor

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

//

CAknsSrvChunkMaintainer::~CAknsSrvChunkMaintainer()

    {

    // We should never reach here, but just in case...

    delete iMorphingTimer;

    iSharedChunk.Close();

    iWaitSema.Close();

    iRenderMutex.Close();

    }

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

// Constructor

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

//

CAknsSrvChunkMaintainer::CAknsSrvChunkMaintainer(CAknsSrvBitmapStore* aBitmapStore)

    {

    // Size sanity checks

    __ASSERT_DEBUG(

        KAknsSrvSharedChunkInitialSize <= KAknsSrvSharedChunkMaxSize,

        User::Panic(KAknSkinSrvPanicCategory, EAknsSrvInvalidBuildConf ) );

    TInt err = iSharedChunk.CreateGlobal(KAKNSSRVSHAREDMEMORYCHUNKNAME,

        KAknsSrvSharedChunkInitialSize, KAknsSrvSharedChunkMaxSize );

    if (!err)

        {

        err = iWaitSema.CreateGlobal(KAKNSSRVWAITSEMAPHORENAME,

            KAknsSrvMaxChunkReaders);

        iInternalSemaCount = 0;

        }

    if( !err )

        {

        err = iRenderMutex.CreateGlobal(KAKNSSRVRENDERMUTEXNAME);

        }

    if (err)

        {

        AKNS_TRACE_ERROR("CAknsSrvChunkMaintainer::Constructor CANNOT CREATE SHARED CHUNK!");

        User::Panic(KAknSkinSrvPanicCategory, EAknsSrvCannotCreateSharedChunk);

        }

    VersionInfo::TPlatformVersion platformVersion;

    TRAP( err,VersionInfo::GetVersion( platformVersion ) );

    if ( !err )

        {

        iPlatformMajor = platformVersion.iMajorVersion;

        iPlatformMinor = platformVersion.iMinorVersion;

        }

    else 

        {

        iPlatformMajor = 0;

        iPlatformMinor = 0;

        }

    iCurrentFilenameID = 0;

    iBitmapStore = aBitmapStore;

    iMergeS60Skin = EFalse;

    }

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

// CAknsSrvChunkMaintainer::MergeSkinDefinitionsL

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

//

void CAknsSrvChunkMaintainer::MergeSkinDefinitionsL( const TPtrC& aFilename,

    const TAknsItemDefClass aClass, const TBool aClearChunk,

    const TAknsSrvExclusionQuery& aExclQuery,

    const TBool aAhOverride,

    const TAknsPkgID& aPID )

    {

    // Do not merge other than bitmap classes

    if( aClass != EAknsItemDefClassBitmaps ) return;

    // Block read access to the shared chunk while writing new values

    BeginWrite();

    iMorphingMinInterval = -1;

    if (iMorphingTimer)

        {

        delete iMorphingTimer;

        iMorphingTimer = NULL;

        }

    if ( aPID == KAknsPIDS60DefaultSkin )

        {

        iMergeS60Skin = ETrue;

        }

    TRAPD( mergeErr, MergeSkinDefinitionsUnprotectedL( aFilename,

        aClearChunk, aExclQuery, aAhOverride, aPID) );

    iMergeS60Skin = EFalse;

    // And allow read access again...

    EndWrite();

    User::LeaveIfError( mergeErr );

    }

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

// CAknsSrvChunkMaintainer::SetWallpaper

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

//

void CAknsSrvChunkMaintainer::SetWallpaper( const TAknsItemID& aIID,

    const TDesC& aFilename, TInt /*aIndex*/ )

    {

    BeginWrite();

    TAknsSrvDef wallpaperDef;

    wallpaperDef.iID.iMajor = EAknsMajorSkin;

    wallpaperDef.iID.iMinor = EAknsMinorWallpaper;

    TInt32 filenameid;

    if( aIID == KAknsIIDWallpaper )

        {

        if (aFilename.Length() > 0)

            {

            filenameid = KAknsSrvIdleWallpaperFilenameID;

            }

        else

            {

            TInt index = FindDefIndex( wallpaperDef.iID );

            TAknsSrvDef* trgDef = NULL;

            if (index >= 0)

                {

                trgDef = (TAknsSrvDef*)( GetAreaBasePtr(EAknsSrvItemDefArea)

                    + index*sizeof(TAknsSrvDef) );

                trgDef->iID.iMajor = KAknsSrvSkipMajor;

                trgDef->iID.iMinor = KAknsSrvSkipMinor;

                }

            EndWrite();

            return;

            }

        }

    else

        {

        EndWrite();

        return;

        }

    UpdateFilename( filenameid, (TUint8*)aFilename.Ptr(),

        (TUint16)(aFilename.Length()), KNullDesC());

    wallpaperDef.iType = EAknsITEffectQueue;

    TAknsSrvEffectQueueDef applyGfxEffectQueue;

    applyGfxEffectQueue.iEffectQueueSize = sizeof(TAknsSrvEffectQueueDef)

        + 2*sizeof(TAknsSrvEffectDef) + 3*sizeof(TAknsSrvEffectParameterDef)

        + 11*sizeof(TInt32);

    applyGfxEffectQueue.iInputLayerIndex =0;

    applyGfxEffectQueue.iInputLayerMode = 2; //RGB

    applyGfxEffectQueue.iOutputLayerIndex = 2;

    applyGfxEffectQueue.iOutputLayerMode = 2; //RGB

    applyGfxEffectQueue.iEffectCount = 2;

    applyGfxEffectQueue.iRefMajor = 0;

    applyGfxEffectQueue.iRefMinor = 0;

    TAknsSrvEffectDef applyGfxEffectDef;

    applyGfxEffectDef.iEffectUid.iUid = 0x101F8748;

    applyGfxEffectDef.iInputLayerAIndex = 0;

    applyGfxEffectDef.iInputLayerAMode = 1;

    applyGfxEffectDef.iInputLayerBIndex = 0;

    applyGfxEffectDef.iInputLayerBMode = 1;

    applyGfxEffectDef.iOutputLayerIndex = 1;

    applyGfxEffectDef.iOutputLayerMode = 8; //  1/RGBA

    applyGfxEffectDef.iEffectParameterCount = 2;

    applyGfxEffectDef.iEffectSize = sizeof(TAknsSrvEffectDef)

        + 2*sizeof(TAknsSrvEffectParameterDef)+4*sizeof(TInt32)+2*sizeof(TInt32);

    TAknsSrvEffectParameterDef applyGfxParams;

    applyGfxParams.iParameterLength =

        sizeof(TAknsSrvEffectParameterDef)+4*sizeof(TInt32);

    applyGfxParams.iParameterType = 2; // graphics file

    TAknsSrvEffectParameterDef applyGfxParams2;

    applyGfxParams2.iParameterLength =

        sizeof(TAknsSrvEffectParameterDef)+2*sizeof(TInt32);

    applyGfxParams2.iParameterType = 0; // int

    TAknsSrvEffectDef alphaBlendEffectDef;

    alphaBlendEffectDef.iEffectUid.iUid = 0x10204add;

    alphaBlendEffectDef.iInputLayerAIndex = 0;

    alphaBlendEffectDef.iInputLayerAMode = 8; // RGBA

    alphaBlendEffectDef.iInputLayerBIndex = 1;

    alphaBlendEffectDef.iInputLayerBMode = 8; // RGBA

    alphaBlendEffectDef.iOutputLayerIndex = 2;

    alphaBlendEffectDef.iOutputLayerMode = 2; // RGB

    alphaBlendEffectDef.iEffectParameterCount = 1;

    alphaBlendEffectDef.iEffectSize = sizeof(TAknsSrvEffectDef)

        + sizeof(TAknsSrvEffectParameterDef)+2*sizeof(TInt32);

    TAknsSrvEffectParameterDef alphaBlendParams;

    alphaBlendParams.iParameterLength =

        sizeof(TAknsSrvEffectParameterDef)+2*sizeof(TInt32);

    alphaBlendParams.iParameterType = 0; // int

    TInt32 bitmapIndex = 0;

    TInt32 maskindex = 0;

    TInt32 filenameOffset = GetFilenameOffsetByID(filenameid);// offset replaces the id

    TUint8* eqblock = NULL;

    TRAPD( err,

        eqblock = new (ELeave) TUint8[

            sizeof(TAknsSrvEffectQueueDef) + 2*sizeof(TAknsSrvEffectDef)

            + 3*sizeof(TAknsSrvEffectParameterDef) + 2*sizeof(TInt32) + 4*sizeof(TInt32) + 2*sizeof(TInt32) ] );

    if ( err != KErrNone )

        {

        EndWrite();

        delete [] eqblock;

        return;

        }

    TUint8 *ptr = eqblock;

    Mem::Copy(ptr,&applyGfxEffectQueue, sizeof(TAknsSrvEffectQueueDef));

    ptr+=sizeof(TAknsSrvEffectQueueDef);

    Mem::Copy(ptr,&applyGfxEffectDef, sizeof(TAknsSrvEffectDef));

    ptr+=sizeof(TAknsSrvEffectDef);

    Mem::Copy(ptr, &applyGfxParams, sizeof(TAknsSrvEffectParameterDef));

    ptr+=sizeof(TAknsSrvEffectParameterDef);

    // applygfx params...

    *((TUint16*)(ptr)) = 1;

    ptr+=2; // sizeof TUint16

    *((TUint16*)(ptr)) = 'f';

    ptr+=2; // sizeof TUint16

    *((TUint32*)(ptr)) = bitmapIndex;

    ptr+=4;

    *((TUint32*)(ptr)) = maskindex;

    ptr+=4;

    *((TUint32*)(ptr)) = filenameOffset;

    ptr+=4;

    // generic image

    Mem::Copy(ptr, &applyGfxParams2, sizeof(TAknsSrvEffectParameterDef));

    ptr+=sizeof(TAknsSrvEffectParameterDef);

    *((TUint16*)(ptr)) = 1;

    ptr+=2; // sizeof TUint16

    *((TUint16*)(ptr)) = 'g';

    ptr+=2;

    *((TUint32*)(ptr)) = 1;

    ptr+=4;

    //alphablend

    Mem::Copy(ptr, &alphaBlendEffectDef, sizeof(TAknsSrvEffectDef));

    ptr+=sizeof(TAknsSrvEffectDef);

    Mem::Copy(ptr, &alphaBlendParams,sizeof(TAknsSrvEffectParameterDef));

    ptr+=sizeof(TAknsSrvEffectParameterDef);

    *((TUint16*)(ptr)) = 1;

    ptr+=2;

    *((TUint16*)(ptr)) = 'm';

    ptr+=2;

    *((TUint32*)(ptr)) = 1;

    ptr+=4;

    TAknsSrvEffectQueueDef* eqDef = (TAknsSrvEffectQueueDef*)eqblock;

    UpdateDef( &wallpaperDef, eqDef,     applyGfxEffectQueue.iEffectQueueSize, -1 );

    delete [] eqblock;

    EndWrite();

    }

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

// CAknsSrvChunkMaintainer::BeginWrite

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

//

void CAknsSrvChunkMaintainer::BeginWrite()

    {

    iInternalSemaCount++;

    if( iInternalSemaCount > 1 )

        {

        // Chunk already locked

        return;

        }

#if defined(_DEBUG)

    if( iInternalSemaCount < 1 )

        {

        AKNS_TRACE_ERROR("CAknsSrvChunkMaintainer::BeginWrite Internal error, internal counter underflow!");

        AKNS_DEBUG_PANIC(EAknsDPanicBadState);

        }

#endif

    // Wait if there is a read in progress...

    for (TInt count = 0;count < KAknsSrvMaxChunkReaders;count++)

        {

        iWaitSema.Wait();

        }

    }

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

// CAknsSrvChunkMaintainer::EndWrite

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

//

void CAknsSrvChunkMaintainer::EndWrite()

    {

    iInternalSemaCount--;

    if( iInternalSemaCount > 0 )

        {

        // Chunk must be left locked

        return;

        }

    iWaitSema.Signal(KAknsSrvMaxChunkReaders);

#if defined(_DEBUG)

    if( iInternalSemaCount < 0 )

        {

        AKNS_TRACE_ERROR("CAknsSrvChunkMaintainer::EndWrite Internal error, internal counter underflow!");

        AKNS_DEBUG_PANIC(EAknsDPanicBadState);

        }

#endif

    AKNS_TRACE_INFO("------------------------------------------------------------------");

    AKNS_TRACE_INFO1("AknSkinSrv: Total SharedChunk size at EndWrite operation %d bytes", iSharedChunk.Size());

    AKNS_TRACE_INFO1("AknSkinSrv: Total ItemDefArea size at EndWrite operation %d bytes", GetAreaAllocatedSize(EAknsSrvItemDefArea));

    AKNS_TRACE_INFO1("AknSkinSrv: Total DataArea size at EndWrite operation %d bytes", GetAreaAllocatedSize(EAknsSrvDataArea));

    AKNS_TRACE_INFO1("AknSkinSrv: Total FilenameArea size after EndWrite operation %d bytes", GetAreaAllocatedSize(EAknsSrvFilenameArea));

    AKNS_TRACE_INFO1("AknSkinSrv: Total ScalableGfxArea(STATIC) size after EndWrite operation %d bytes", GetAreaAllocatedSize(EAknsSrvScalableGfxArea));

    AKNS_TRACE_INFO1("AknSkinSrv: Total unused space in ItemDefArea %d bytes", (GetAreaAllocatedSize(EAknsSrvItemDefArea)-GetAreaCurrentSize(EAknsSrvItemDefArea)));

    AKNS_TRACE_INFO1("AknSkinSrv: Total unused space in DataArea %d bytes", (GetAreaAllocatedSize(EAknsSrvDataArea)-GetAreaCurrentSize(EAknsSrvDataArea)));

    AKNS_TRACE_INFO1("AknSkinSrv: Total unused space in FilenameArea %d bytes", (GetAreaAllocatedSize(EAknsSrvFilenameArea)-GetAreaCurrentSize(EAknsSrvFilenameArea)));

    AKNS_TRACE_INFO1("AknSkinSrv: Total unused space in ScalableGfxArea %d bytes", (GetAreaAllocatedSize(EAknsSrvScalableGfxArea)-GetAreaCurrentSize(EAknsSrvScalableGfxArea)));

    AKNS_TRACE_INFO("------------------------------------------------------------------");

    }

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

// CAknsSrvChunkMaintainer::ResetLevel

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

//

void CAknsSrvChunkMaintainer::ResetLevel()

    {

    iMergingLevel = 0;

    }

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

// CAknsSrvChunkMaintainer::NextLevel

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

//

void CAknsSrvChunkMaintainer::NextLevel()

    {

    iMergingLevel++;

    }

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

// CAknsSrvChunkMaintainer::CheckAndModifyIID

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

//

void CAknsSrvChunkMaintainer::CheckAndModifyIID( TAknsItemID& aIID,

    const TAknsSrvExclusionQuery& aExclQuery )

    {

    if( aIID.iMajor == KAknsSrvRewriteMajor )

        {

        aIID.iMajor = KAknsSrvRewriteBase - iMergingLevel;

        }

    aExclQuery.MapIID( aIID );

    }

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

// CAknsSrvChunkMaintainer::ProcessChunksL

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

//

TInt CAknsSrvChunkMaintainer::ProcessChunksL( CAknsSrvFileBuffer& aFile,

    TUint32 aFileOffset, TUint32 aChunkCount, const TDesC& aFilename,

    const TAknsSrvExclusionQuery& aExclQuery, const TBool aMirrored )

    {

    AKNS_TRACE_INFO1("CAknsSrvChunkMaintainer::ProcessChunksL Starting count=%i", aChunkCount );

    TInt offset = aFileOffset;

#if defined(AKNS_TRACING_ENABLED_ERROR)

    TUint16 prevChunktype = 65535;

#endif

    TUint16 chunktype = 65535;

    for (TUint32 count = 0; count < aChunkCount; count++)

        {

        AKNS_TRACE_INFO2("CAknsSrvChunkMaintainer::ProcessChunksL Step %i/%i", count, aChunkCount );

#if defined(AKNS_TRACING_ENABLED_ERROR)

        prevChunktype = chunktype;

#endif

        if( AknsSrvUtils::GetUInt8L( aFile, offset ) == 0xf5 )

            {

            AKNS_TRACE_ERROR1("CAknsSrvChunkMaintainer::ProcessChunksL Suspicious EOC at BOC, prev=%i", prevChunktype);

            }

        TInt32 chunksize = AknsSrvUtils::GetInt32L(

            aFile, offset+EAknsSrvDFOCommonLength );

        chunktype = AknsSrvUtils::GetUInt16L(

            aFile, offset+EAknsSrvDFOCommonType );

        AKNS_TRACE_INFO2("CAknsSrvChunkMaintainer::ProcessChunksL This chunk size=%i type=%i", chunksize, chunktype );

        if (chunktype == EAknsSkinDescFilename) // filename chunk