/*

* Copyright (c) 2007-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:  Implementation file for CAknLocalSkinInstance

*

*/

#include "aknlocalskinlib.h"

#include <AknsSrvDescriptorFileLayout.h>

#include <AknsConstants.h>

#include <AknsUtils.h>

#include <AknsImageAttributeData.h>

#include <AknsSrvVariant.hrh>

#include <caf/content.h>

#include <DRMHelper.h>

#include <caf/rightsmanager.h>

#include <centralrepository.h>

#include <AknLayoutDef.h>

// CenRep keys.

#include <AvkonInternalCRKeys.h>                // KAknLayoutId

#include <AknSkinsInternalCRKeys.h>             // KPslnActiveSkinUid, ...

#include <versioninfo.h>

using namespace ContentAccess;

// Max of 32 effects per queue and 64 params per effect should be enough

static const TInt KAknsSrvMaxEffectCount      = 0x20;

static const TInt KAknsSrvMaxEffectParamCount = 0x40;

// There are nine images in one frame.

const TInt KAknsSrvFrameIconCount = 9;

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

_LIT(KAknsSrvScalableRomBmpOldLocation, ":\\private\\10207114\\import\\");

_LIT(KAknsSrvPathEndSeparator, "\\");

_LIT(KDefaultSkinFilename, "Z:\\private\\10207114\\import\\101f84b9\\series60skin.skn");

class CSkinFilename : public CBase

    {

    HBufC* iFilename;

    TInt iId;

    };

TInt Int32(TUint8* dataPtr,TUint32 aOffset)

    {

    return *((TInt*)(dataPtr+aOffset));

    }

TUint Uint32(TUint8* dataPtr,TUint32 aOffset)

    {

    return *((TUint32*)(dataPtr+aOffset));

    }

TInt16 Int16(TUint8* dataPtr, TUint32 aOffset)

    {

    return *((TInt16*)(dataPtr+aOffset));

    }

TUint16 Uint16(TUint8* dataPtr, TUint32 aOffset)

    {

    return *((TUint16*)(dataPtr+aOffset));

    }

TInt8 Int8(TUint8* dataPtr, TUint32 aOffset)

    {

    return *((TInt8*)(dataPtr+aOffset));

    }

TUint8 Uint8(TUint8* dataPtr, TUint32 aOffset)

    {

    return *((TUint8*)(dataPtr+aOffset));

    }

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

// Constructor.

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

//

EXPORT_C CAknLocalSkinInstance* CAknLocalSkinInstance::NewL(

    const RFs& aFileSystem, const RAknsSrvSession& aSkinSrv)

    {

    CAknLocalSkinInstance* self =

        new (ELeave) CAknLocalSkinInstance(aFileSystem, aSkinSrv);

    VersionInfo::TPlatformVersion platformVersion;

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

    if ( !err )

        {

        self->iPlatformMajor = platformVersion.iMajorVersion;

        self->iPlatformMinor = platformVersion.iMinorVersion;

        }

    else 

        {

        self->iPlatformMajor = 0;

        self->iPlatformMinor = 0;

        } 

    return self;

    }

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

// Apply the local skin.

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

//

EXPORT_C void CAknLocalSkinInstance::ApplyL(

    const TDesC& aFilename, RArray<TAknsItemID>& aItemsToOverride)

    {

    iOverriddenItems.Reset();

    iNoColors = EFalse;

    iColorsFound = EFalse;

    iItemsToOVerride = aItemsToOverride;

    iInitialCount = iItemsToOVerride.Count();

    TRAPD(err,DoApplyL(aFilename));

    User::LeaveIfError(err);

    }

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

// Start Apply procedure.

//

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

//

void CAknLocalSkinInstance::DoApplyL(const TDesC& aFilename)

    {

    ProcessSkinFileL( KDefaultSkinFilename , ETrue );

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

    MAknsSkinInstance* si = AknsUtils::SkinInstance();

    si->SetChangeEventsEnabled( EFalse );

    si->RemoveLocalItemDefs();

    TInt count = 0;   

    // force scalable elements to NULL if they are not found from the skin

    CAknsEffectQueueItemDef* override = NULL;

    if (iInitialCount != iItemsToOVerride.Count())

        {

        for  (count = 0; count < iItemsToOVerride.Count(); count++)

            {

            TAknsItemID id = iItemsToOVerride[count];

            if ( IsScalableItem( id ) && !AlreadyOverrideElement(id) )

                {

                override = CAknsEffectQueueItemDef::NewL(id);

                override->SetReference(KAknsIIDNone);

                si->SetLocalItemDefL( override ); // ownership is transferred

                count--;

                }

            }    

        }

    // and read the rest of the remaining elements from the default skin

    ProcessSkinFileL( aFilename , EFalse );

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

    for (count = 0; count < iOverriddenItems.Count(); count++)

        {

        si->SetLocalItemDefL( (CAknsItemDef*)iOverriddenItems.operator[](count));

        }

   TAknsItemID id;

   for  (count = 0; count < iItemsToOVerride.Count(); count++)

        {

        id = iItemsToOVerride[count];

        if( !AlreadyOverrideElement(id) )

            {

            override = CAknsEffectQueueItemDef::NewL(id);

            override->SetReference(KAknsIIDNone);

            si->SetLocalItemDefL( override ); // ownership is transferred

            }

        }

    // and finally disable all highlight animations....

    override = CAknsEffectQueueItemDef::NewL(KAknsIIDQsnAnimGrid);

    override->SetReference(KAknsIIDNone);

    si->SetLocalItemDefL( override );

    override = CAknsEffectQueueItemDef::NewL(KAknsIIDQsnAnimList);

    override->SetReference(KAknsIIDNone);

    si->SetLocalItemDefL( override );

    override = CAknsEffectQueueItemDef::NewL(KAknsIIDQsnAnimSetOptFoc);

    override->SetReference(KAknsIIDNone);

    si->SetLocalItemDefL( override );

    si->SetChangeEventsEnabled( ETrue );

    }

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

//  Destructor.

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

//

EXPORT_C CAknLocalSkinInstance::~CAknLocalSkinInstance()

    {

    delete iSknBuffer;

    delete iDefaultSknBuffer;

    delete iBitmapPath;

    delete iBitmapFilename;

    iOverriddenItems.Close();

    }

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

// C++ constructor.

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

//

CAknLocalSkinInstance::CAknLocalSkinInstance(

    const RFs& aFileSystem, const RAknsSrvSession& aSkinSrv)

    : iFs(aFileSystem), iSkinSrv(aSkinSrv)

    {

    RetrieveAHMirroringState();

    }

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

// Start processing the skin chunks.

//

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

//

TInt CAknLocalSkinInstance::ProcessChunksL( TUint32 aOffset, TUint32 aChunkCount )

    {

    TInt offset = aOffset;

    TUint16 chunktype = 65535;

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

        {

        TInt32 chunksize = Int32(

            iDataPtr, offset+EAknsSrvDFOCommonLength );

        chunktype = Uint16(

            iDataPtr, offset+EAknsSrvDFOCommonType );

        // filename chunk

        if (chunktype == EAknsSkinDescFilename)

            {

            offset+=HandleFilenameChunkL(offset);

            }

        // class chunk

        else if (chunktype == EAknsSkinDescSkinDescClass)

            {

            offset+=HandleClassChunkL(offset);

            }

        // release restriction chunk (2.6)

        else if( chunktype == EAknsSkinDescRelease26 )

            {

            offset+=Handle26RelRestrictionChunkL(offset);

            }

        // release restriction chunk (generic)

        else if( chunktype == EAknsSkinDescReleaseGeneric )

            {

            offset+=HandleGenericRelRestrictionChunkL(offset);

            }

        else if (chunktype == EAknsSkinDescLanguage) // language restriction chunk

            {

            offset+=HandleLangRestrictionChunkL(offset);

            }

        else

            {

            // chunk not supported/not used, proceed....

            offset+=chunksize;

            }

        if( Uint8(iDataPtr,offset-1) != 0xf5 )

            {

            User::Leave(KErrCorrupt);

            }

        }

    return offset;

    }

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

// Handle filename chunk.

//

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

//

TInt CAknLocalSkinInstance::HandleFilenameChunkL(TUint32 aOffset)

    {

    // todo: figure out a way to get the filename by other means than hardcoding.....

    TUint32 size = Int32(iDataPtr, EAknsSrvDFOCommonLength+aOffset);

    TUint8* filenamechunk = (iDataPtr+aOffset);

    if (iBitmapFilename)

        {

        return size;

        }

    TUint16 filenamelen = *((TUint16*)(filenamechunk+EAknsSrvDFOFilenameLen));

    iBitmapFilename = HBufC16::NewL(filenamelen+100);

    iBitmapFilename->Des().Append(*iBitmapPath);

    TUint8* fn = new TUint8[filenamelen * 2];

    memcpy ( fn,( filenamechunk+EAknsSrvDFOFilenameFilename ),filenamelen * 2 );

    TPtr16 filenamePtr( (TUint16*)(fn),filenamelen,filenamelen );

    iBitmapFilename->Des().Append(KAknsSrvPathEndSeparator);

    iBitmapFilename->Des().Append(filenamePtr);

    iBitmapFilename->Des().Replace(iBitmapFilename->Length()-3, 3 ,_L("mif"));

    TUint att = 0;

    if (iFs.Att(*iBitmapFilename,att))

        {

        iBitmapFilename->Des().Zero();

        iBitmapFilename->Des().Append((*iBitmapPath)[0]);

        iBitmapFilename->Des().Append(KAknsSrvScalableRomBmpOldLocation);

        iBitmapFilename->Des().AppendNumFixedWidthUC( iPkg.iNumber, EHex, 8 );

        if( !iPkg.IsUid() )

            {

            iBitmapFilename->Des().AppendNumFixedWidthUC( iPkg.iTimestamp, EHex, 8 );

            }

        iBitmapFilename->Des().Append(KAknsSrvPathEndSeparator);

        iBitmapFilename->Des().Append(filenamePtr);

        }

    delete[] fn;

    return size;

    }

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

// Handle class chunk.

//

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

//

TInt CAknLocalSkinInstance::HandleClassChunkL(TUint32 aOffset)

    {

    TUint32 size = Int32(

        iDataPtr, aOffset+EAknsSrvDFOCommonLength);

    TInt fileoffset = aOffset;

    TInt32 chunklen = Int32( iDataPtr,

        fileoffset+EAknsSrvDFOCommonLength );

    TInt16 chunktype = Uint16( iDataPtr,

        fileoffset+EAknsSrvDFOCommonType );

    TInt32 chunkcount = Int32( iDataPtr,

        fileoffset+EAknsSrvDFOClassChunksN );

    fileoffset += EAknsSrvDFOClassContent;

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

        {

        chunklen = Int32( iDataPtr,

            fileoffset+EAknsSrvDFOCommonLength );

        chunktype = Uint16( iDataPtr,

            fileoffset+EAknsSrvDFOCommonType );

        switch(chunktype)

            {

            case EAknsSkinDescSkinDescBmpItemDef:

                DoOverrideBitmapDefinitionL( fileoffset );

                break;

            case EAknsSkinDescSkinDescColorTblItemDef:

                DoOverrideColorTableDefinitionL( fileoffset );

                break;

            case EAknsSkinDescSkinDescImgTblItemDef:

                DoOverrideImageTableDefinitionL( fileoffset);

                break;

            case EAknsSkinDescSkinDescImgBmpAnim:

                break;

            case EAknsSkinDescSkinDescStringItemDef:

                break;

            case EAknsSkinDescEffectQueue:

                DoOverrideEffectQueueL(fileoffset);

                break;

            case EAknsSkinDescAnimation:

                break;

            default:

                break;

            }

        fileoffset+=chunklen;

        if( Uint8( iDataPtr, fileoffset-1 ) != 0xf5 )

            {

            User::Leave( KErrCorrupt );

            }

        }

    return size;

    }

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

// Override effect queue.

//

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

//

void CAknLocalSkinInstance::DoOverrideEffectQueueL(TUint32 aOffset)

    {

    TInt32 major = Int32( iDataPtr, aOffset+EAknsSrvDFOEffectQueueMajor );

    TInt32 minor = Int32( iDataPtr, aOffset+EAknsSrvDFOEffectQueueMinor );

    TAknsItemID id;

    id.Set(major,minor);

    if (!OverrideElement(id))

        {

        return;

        }

    TInt32 refmajor = Int32( iDataPtr, aOffset+EAknsSrvDFOEffectQueueRefMajor );

    TInt32 refminor = Int32( iDataPtr, aOffset+EAknsSrvDFOEffectQueueRefMinor );

    TUint8 inputlayerindex = Uint8( iDataPtr, aOffset + EAknsSrvDFOEffectQueueInputLayerIndex);

    TUint8 inputlayermode = Uint8( iDataPtr, aOffset + EAknsSrvDFOEffectQueueInputLayerMode);

    TUint8 outputlayerindex = Uint8( iDataPtr, aOffset + EAknsSrvDFOEffectQueueOutputLayerIndex);

    TUint8 outputlayermode = Uint8( iDataPtr, aOffset + EAknsSrvDFOEffectQueueOutputLayerMode);

    TUint16 effectcount = Uint16( iDataPtr, aOffset + EAknsSrvDFOEffectQueueEffectCount);

    if( inputlayermode > 0x08 ||

        outputlayermode > 0x08 ||

        effectcount > KAknsSrvMaxEffectCount )

        {

        User::Leave(KErrCorrupt);

        }

    CAknsEffectQueueItemDef* queue = CAknsEffectQueueItemDef::NewL(id);

    CleanupStack::PushL(queue);

    UpdateOverriddenItem(queue);

    CleanupStack::Pop(queue);

    if (refmajor && refminor)

        {

        TAknsItemID ref;

        ref.Set(refmajor, refminor);

        return;

        }

    // process all effect chunks inside

    TUint32 eqBase = EAknsSrvDFOEffectQueueEffects;

    // process all effect chunks inside

    DoOverrideEffectCommandsL( aOffset, eqBase, queue, effectcount );

    }

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

// Override effect commands.

//

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

//

TUint32 CAknLocalSkinInstance::DoOverrideEffectCommandsL(

    const TUint aOffset, TUint32& aBase,

    CAknsEffectQueueItemDef* aEffectQueue, const TUint16 aEffectCount )

    {

    TUint32 totalSize = 0;

    for( TInt i = 0; i < aEffectCount; i++)

        {

        TInt32 effectuid = Int32( iDataPtr, aOffset+aBase + 8  );

        TUint8 inAindex = Uint8( iDataPtr, aOffset+ aBase+ 12);

        TUint8 inAmode = Uint8( iDataPtr, aOffset+ aBase+ 13);

        TUint8 inBindex = Uint8( iDataPtr, aOffset+ aBase+ 14);

        TUint8 inBmode = Uint8( iDataPtr, aOffset+ aBase+ 15);

        TUint8 outIndex = Uint8( iDataPtr, aOffset+ aBase+ 16);

        TUint8 outMode = Uint8( iDataPtr, aOffset+ aBase+ 17);

        // Check that at least some values are meaningful

        if (inAmode > 0x08 || inBmode > 0x08 || outMode > 0x08 )

            {

            User::Leave(KErrCorrupt);

            }

        TUint16 paramcount = Uint16( iDataPtr, aOffset+ aBase+ 18);

        if (paramcount > KAknsSrvMaxEffectParamCount)

            {

            User::Leave(KErrCorrupt);

            }

        aBase+=20;

        // process all parameters inside single effect

        TUid uid;

        uid.iUid = effectuid;

        CAknsEffectItemDef* effect = CAknsEffectItemDef::NewL();

        CleanupStack::PushL(effect);

        effect->SetEffectUid(uid);

        effect->SetLayerIndexesAndModes(

            inAindex, inAmode,

            inBindex, inBmode,

            outIndex, outMode );

        aEffectQueue->AddEffectL(effect);

        CleanupStack::Pop( effect );

        TUint32 totalparamsize =

            DoOverrideParamsL( aOffset, aBase, effect, paramcount );

        aBase+=1;

        }

    return totalSize;

    }

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

// Override effect parameters.

//

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

//

TUint32 CAknLocalSkinInstance::DoOverrideParamsL(const TUint aOffset, TUint32& aEqBase,

    CAknsEffectItemDef* aEffect, const TUint16 aParamCount )

    {

    TUint32 totalparamsize = 0; // total size of all parameters

    for( TInt i = 0; i < aParamCount; i++ )

        {

        TUint16 totalparamlen = Uint16( iDataPtr, aOffset + aEqBase);

        TUint32 datasize = totalparamlen-4; //ParamLength(TUint16)-Reserved(TUint8)-ParamType(TUint8)

        // lets assume that one effect cannot be larger than 32kb (should be more than enough)

        if (datasize >= 0x8000)

            {

            User::Leave(KErrCorrupt);