/*

* Copyright (c) 2002-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:  Defines an internal concrete class CAknsAppSkinInstance and

*                related types. This class encapsulates the concrete skin

*                instance which is a singleton in thread scope.

*

*/ 

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefconst.h>

#endif

#include "AknsCppPreface.h"

#include <eikenv.h>

#include <eikappui.h>

#include <eikapp.h>

#include <AknCapServerDefs.h>

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include <apgcli.h>

#include <AknsItemData.h>

#include <AknsImageAttributeData.h>

#include <AknsItemDef.h>

#include <AknsConstants.h>

#include <AknsUtils.h>

#include "AknsAppSkinInstance.h"

#include "AknsItemDataFactory.h"

#include "AknsASICacheEntry.h"

#include "AknsTemporaryBitmap.h"

#include "AknsScalabilityUtils.h"

#include "AknsRlDefaultRenderer.h"

#include "AknsRlMasterLayout.h"

#include "AknsDebug.h"

#include <pslninternalcrkeys.h>

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

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

// CAknsAppSkinInstance::CAknsAppSkinInstance

// C++ default constructor can NOT contain any code, that might leave.

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

//

CAknsAppSkinInstance::CAknsAppSkinInstance() :

    CCoeStatic( KAknsSkinInstanceTls, EThread ), iChangeEventsEnabled( ETrue ),

    // CBase initializes: iChunkLookup(0), iRenderer(0), iMasterLayout(0),

    //                    iVariantHlAnimStatus(0)

    {

    }

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

// CAknsAppSkinInstance::ContructL

// EPOC default constructor can leave.

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

//

void CAknsAppSkinInstance::ConstructL()

    {

    User::LeaveIfError( iSession.Connect( this ) );

    iChunkLookup = iSession.CreateChunkLookupL();

    iRenderer = CAknsRlDefaultRenderer::NewL(&iSession);

    iMasterLayout = CAknsRlMasterLayout::NewL();

    InitPslnCenrepL();

    InitAnimBackgroundL( );

    }

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

// CAknsAppSkinInstance::InitAnimBackgroundL

// Initalize Animation background State

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

//

void CAknsAppSkinInstance::InitAnimBackgroundL( )

    {

    CRepository* theme = CRepository::NewL(KCRUidThemes);

    iAnimBgState = EFalse;

    TInt value = KMaxTInt;

    TInt err = theme->Get( KThemesAnimBackgroundSupport, value );

    delete theme;

    if( !err && !value )

        {

        iAnimBgState = ETrue;

        }

    }

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

// CAknsAppSkinInstance::AnimBackgroundState

// Get Animation background State

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

//

TBool CAknsAppSkinInstance::AnimBackgroundState( ) const

    {

    return iAnimBgState;

    }

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

// CAknsAppSkinInstance::InitPslnCenrepL

// Get Psln Cenrep

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

//

void CAknsAppSkinInstance::InitPslnCenrepL( TBool aOnlyWP )

    {

    CRepository* rep = CRepository::NewL( KCRUidPersonalisation );

    CleanupStack::PushL( rep );

    TInt err = 0;

    if ( !aOnlyWP )

        {

        TInt value = 0;

        // Product variant's animation status is read-only -> can be safely cached

        // for fast access.

        err = rep->Get( KPslnHighlightAnimationEnabled, value );

        if( err || !value )

            {

            iVariantHlAnimStatus = EFalse;

            }

        else // No error and enable flag was set

            {

            iVariantHlAnimStatus = ETrue;

            }

        }

    iWallpaperDefined = EFalse;

    TFileName name;

    err = rep->Get( KPslnIdleBackgroundImagePath, name );

    if ( !err && name.Length())

        {

        iWallpaperDefined = ETrue;

        }

    CleanupStack::PopAndDestroy( rep );

    }

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

// CAknsAppSkinInstance::WallpaperType

// Get wallpaper type

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

//

TBool CAknsAppSkinInstance::WallpaperDefined( ) const

    {

    return iWallpaperDefined;

    }

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

// CAknsAppSkinInstance::CreateSingletonL

// Two-phased constructor.

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

//

void CAknsAppSkinInstance::CreateSingletonL()

    {

    AKNS_TRACE_INFO("CAknsAppSkinInstance::CreateSingletonL");

    CAknsAppSkinInstance* self = new (ELeave) CAknsAppSkinInstance;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    }

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

// Destructor

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

//

CAknsAppSkinInstance::~CAknsAppSkinInstance()

    {

    AKNS_TRACE_INFO("CAknsAppSkinInstance::destructor");

    iLocalItemDefArray.ResetAndDestroy();

    iCache.ResetAndDestroy();

    iControlPositionList.Close();

    iPointerStoreList.Close();

    iTmpBmpArray.ResetAndDestroy();

    iLayoutBmpArray.ResetAndDestroy();

    iSession.Close();

    delete iChunkLookup;

    delete iRenderer;

    delete iMasterLayout;

    if (iCachedApaSession)

        {

        iCachedApaSession->Close();

        }

    delete iCachedApaSession;

    } //lint !e1740 Debug variables not freed

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

// CAknsAppSkinInstance::RootDataContext()

// (documented in the header).

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

//

MAknsDataContext* CAknsAppSkinInstance::RootDataContext()

    {

    return static_cast<MAknsDataContext*>(this);

    }

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

// CAknsAppSkinInstance::GetCachedItemData

// (documented in the header).

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

//

CAknsItemData* CAknsAppSkinInstance::GetCachedItemData( const TAknsItemID& aID,

    const TAknsItemType aType )

    {

    AKNS_TRACE_INFO3("CAknsAppSkinInstance::GetCachedItemData %i,%i %i",

        aID.iMajor,aID.iMinor,aType);

    CAknsAppSkinInstanceCacheEntry* cacheEntry = FindFromCache( aID );

    if( !cacheEntry )

        {

        AKNS_TRACE_INFO("CAknsAppSkinInstance::GetCachedItemData MISS");

        TRAPD(result, (cacheEntry=LookupCreateAndCacheL( aID, aType )) );

        if( result != KErrNone )

            {

            AKNS_TRACE_ERROR1("CAknsAppSkinInstance::GetCachedItemData ERROR %i", result );

            if( result == KErrNoMemory )

                {

                HandleClientError( EAknsClientErrorOOM );

                }

            else

                {

                HandleClientError( EAknsClientErrorUnspecified );

                }

            return NULL;

            }

        if( !cacheEntry )

            {

            return NULL;

            }

        }

    else

        {

        if( !cacheEntry->Data() )

            {

            // Cache entry without data is a cached miss

            AKNS_TRACE_INFO("CAknsAppSkinInstance:GetCachedItemData CACHED MISS");

            return NULL;

            }

        if( !AknsUtils::IsDerivedType( aType, cacheEntry->Data()->Type()) )

            {

            AKNS_TRACE_INFO("CAknsAppSkinInstance::GetCachedItemData TYPE MISMATCH");

            return NULL;

            }

        }

    return cacheEntry->Data();

    }

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

// CAknsAppSkinInstance::GetCachedItemData

// (documented in the header).

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

//

CAknsItemData* CAknsAppSkinInstance::GetCachedItemData( const TAknsItemID& aID )

    {

    return GetCachedItemData( aID, EAknsITUnknown );

    }

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

// CAknsAppSkinInstance::CreateUncachedItemDataL

// (documented in the header).

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

//

CAknsItemData* CAknsAppSkinInstance::CreateUncachedItemDataL(

    const TAknsItemID& aID, const TAknsItemType aType )

    {

    AKNS_TRACE_INFO3("CAknsAppSkinInstance::CreateUncachedItemData %i,%i %i",

        aID.iMajor,aID.iMinor,aType);

    return LookupAndCreateL( aID, aType );

    }

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

// CAknsAppSkinInstance::CreateUncachedItemDataL

// (documented in the header).

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

//

CAknsItemData* CAknsAppSkinInstance::CreateUncachedItemDataL(

    const TAknsItemID& aID )

    {

    AKNS_TRACE_INFO2("CAknsAppSkinInstance::CreateUncachedItemData %i,%i",

        aID.iMajor,aID.iMinor);

    return LookupAndCreateL( aID, EAknsITUnknown );

    }

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

// CAknsAppSkinInstance::SetLocalItemDefL()

// (documented in the header).

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

//

void CAknsAppSkinInstance::SetLocalItemDefL( CAknsItemDef* aDef )

    {

    AKNS_TRACE_INFO("CAknsAppSkinInstance::SetLocalItemDef");

    __ASSERT_DEBUG( aDef, AKNS_DEBUG_PANIC(EAknsDPanicInvalidParameter) );

    TInt index;

    if( iLocalItemDefArray.FindInOrder( aDef, index,

        CAknsItemDef::LinearOrder ) == KErrNone )

        {

        CAknsItemDef* oldEntry = iLocalItemDefArray[index];

        iLocalItemDefArray.Remove( index );

        delete oldEntry;

        CleanupStack::PushL( aDef );

        User::LeaveIfError(

            iLocalItemDefArray.InsertInOrder( aDef,

            CAknsItemDef::LinearOrder ) );

        CleanupStack::Pop( aDef );

        }

    else

        {

        CleanupStack::PushL( aDef );

        User::LeaveIfError(

            iLocalItemDefArray.InsertInOrder( aDef,

            CAknsItemDef::LinearOrder ) );

        CleanupStack::Pop( aDef );

        }

    UpdateCachedItemL( FindFromCache(aDef->ID()), EFalse );

    iLayoutBmpArray.ResetAndDestroy();

    NotifyItemDefChange();

    }

void CAknsAppSkinInstance::RemoveLocalItemDefs()

    {

    iLocalItemDefArray.ResetAndDestroy();

    iCache.ResetAndDestroy();

    iTmpBmpArray.ResetAndDestroy();

    iLayoutBmpArray.ResetAndDestroy();

    NotifyItemDefChange();

    }

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

// CAknsAppSkinInstance::SetChangeEventsEnabled()

// (documented in the header).

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

//

void CAknsAppSkinInstance::SetChangeEventsEnabled( TBool aEnabled )

    {

    iChangeEventsEnabled = aEnabled;

    if( iChangeEventPending )

        {

        NotifyItemDefChange();

        }

    }

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

// CAknsAppSkinInstance::NotifyClientError()

// (documented in the header).

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

//

void CAknsAppSkinInstance::NotifyClientError( const TAknsClientError aError )

    {

    AKNS_TRACE_ERROR1("CAknsAppSkinInstance::NotifyClientError %i", aError );

    HandleClientError( aError );

    }

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

// CAknsAppSkinInstance::SkinChangeReason()

// (documented in the header).

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

//

TAknsSkinChangeReason CAknsAppSkinInstance::SkinChangeReason()

    {

    return iLastChangeReason;

    }

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

// CAknsAppSkinInstance::ReserveItemL()

// (documented in the header).

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

//

void CAknsAppSkinInstance::ReserveItemL( const TAknsItemID& aID )

    {

    CAknsAppSkinInstanceCacheEntry* entry = FindFromCache( aID );

    if( entry )

        {

        AKNS_TRACE_INFO2("CAknsAppSkinInstance::ReserveItemL %i,%i ref++",

            aID.iMajor, aID.iMinor);

        entry->IncreaseRefCount();

        }

    else

        {

        AKNS_TRACE_INFO2("CAknsAppSkinInstance::ReserveItemL %i,%i NEW",

            aID.iMajor, aID.iMinor);

        // Since the misses are cached as well, there is no reason to leave if

        // not found.

        LookupCreateAndCacheL( aID, EAknsITUnknown );

        }

    }

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

// CAknsAppSkinInstance::ReleaseItem()

// (documented in the header).

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

//

void CAknsAppSkinInstance::ReleaseItem( const TAknsItemID& aID )

    {

    CAknsAppSkinInstanceCacheEntry* entry = FindFromCache( aID );

    //Comment out for BUG:UKAL-7JY8FD

    //__ASSERT_DEBUG( entry, AKNS_DEBUG_PANIC(EAknsDPanicReleaseUnderflow) );

    // For release builds, play it safe

    if( !entry ) //lint !e774 Necessary for UREL

        {

        return;

        }

    AKNS_TRACE_INFO2("CAknsAppSkinInstance::ReleaseItem %i,%i ref--",

        aID.iMajor, aID.iMinor);

    entry->DecreaseRefCount();

    if( !entry->IsReferenced() )

        {

        AKNS_TRACE_INFO2("CAknsAppSkinInstance::ReleaseItem %i,%i DELETE",

            aID.iMajor, aID.iMinor);

        RemoveAndDestroyFromCache( aID );

        }

    }

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

// CAknsAppSkinInstance::FlushLocalCaches()

// (documented in the header).

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

//

void CAknsAppSkinInstance::FlushLocalCaches()

    {

    iTmpBmpArray.ResetAndDestroy();

    iCache.ResetAndDestroy();

    iLayoutBmpArray.ResetAndDestroy();

    }

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

// CAknsAppSkinInstance::SkinContentChanged

// (documented in the header).

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

//

void CAknsAppSkinInstance::SkinContentChanged()

    {

    iUpdateInProgress = ETrue;

    // Reset temporary bitmaps first

    iTmpBmpArray.ResetAndDestroy();

    // Reset cache

    iCache.ResetAndDestroy();

    // Layout bmp reset and notifications are done in SkinConfigurationChanged

    }

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

// CAknsAppSkinInstance::SkinConfigurationChanged

// (documented in the header).

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

//

void CAknsAppSkinInstance::SkinConfigurationChanged(

    const TAknsSkinStatusConfigurationChangeReason aReason )

    {

    if( aReason == EAknsSkinStatusConfigurationDeployed )

        {

        // All clients have now processed SkinContentChanged

        // and server has cleared layout bitmaps

        // Cache is reset - clear layout bitmaps from client

        iLayoutBmpArray.ResetAndDestroy();

        // Update completed

        iUpdateInProgress = EFalse;

        iLastChangeReason = ENormalSkinChange;

        // Finally, notify

        NotifyItemDefChange();

        }

    else if( aReason == EAknsSkinStatusMorphingStateChange )

        {

        // @TODO Only selective update is actually needed

        iUpdateInProgress = ETrue;

        iLayoutBmpArray.ResetAndDestroy();

        iUpdateInProgress = EFalse;

        iLastChangeReason = EMorphingStateChange;

        NotifyItemDefChange(EFalse);

        }

    else if (aReason == EAknsSkinStatusWallpaperChanged )

        {

        TRAP_IGNORE( InitPslnCenrepL( ETrue ));

        iUpdateInProgress = ETrue;

        RemoveAndDestroyFromCache( KAknsIIDWallpaper );

        iLayoutBmpArray.ResetAndDestroy();

        iUpdateInProgress = EFalse;

        iLastChangeReason = EWallpaperChange;