/*

* Copyright (c) 2002-2006 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:  

*           Plugin and view id caching support

*

*/

// INCLUDE FILES

#include "GSPluginAndViewIdCache.h"

// System includes

#include <bautils.h>

#include <s32file.h>

#include <eikappui.h>

// User includes

#include "GSShimmedView.h"

#include "GSPlaceholderView.h"

// Constants

_LIT( KGSCacheFileName, "PluginUidToViewIdCache.dat" );

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

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

// CGSPluginAndViewIdCache::CGSPluginAndViewIdCache

// C++ constructor.

//

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

//

CGSPluginAndViewIdCache::CGSPluginAndViewIdCache( CEikAppUi& aAppUi )

:   iAppUi( aAppUi ), iFsSession(CCoeEnv::Static()->FsSession()),iLookupTable( &HashFunction, &HashIdentityRelation )

    {

    }

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

// CGSPluginAndViewIdCache::~CGSPluginAndViewIdCache

// C++ destructor.

//

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

//

CGSPluginAndViewIdCache::~CGSPluginAndViewIdCache()

    {

    TRAP_IGNORE( StoreL() );

    //

    delete iPlaceholderView;

    DestroyShims();

    iLookupTable.Close();

    //

    }

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

// CGSPluginAndViewIdCache::ConstructL

// 

//

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

//

void CGSPluginAndViewIdCache::ConstructL()

    {

    User::LeaveIfError( iFsSession.CreatePrivatePath( EDriveC ) );

    //

    iPlaceholderView = CGSPlaceholderView::NewL( iAppUi );

    //

    TRAP_IGNORE( RestoreL() );

    }

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

// CGSPluginAndViewIdCache::NewL

// 

//

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

//

CGSPluginAndViewIdCache* CGSPluginAndViewIdCache::NewL( CEikAppUi& aAppUi )

    {

    CGSPluginAndViewIdCache* self = new(ELeave) CGSPluginAndViewIdCache( aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CGSPluginAndViewIdCache::ActivatePlaceholderViewL

// 

//

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

//

void CGSPluginAndViewIdCache::ActivatePlaceholderViewL()

    {

    iPlaceholderView->ActivateL();

    }

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

// CGSPluginAndViewIdCache::PriorToPlaceholderActiveViewId

//

// 

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

//

const TVwsViewId& CGSPluginAndViewIdCache::PriorToPlaceholderActiveViewId() const

    {

    return iPlaceholderView->PreviouslyActiveViewId();

    }

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

// CGSPluginAndViewIdCache::SetPriorToPlaceholderActiveViewId

// 

//

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

//

void CGSPluginAndViewIdCache::SetPriorToPlaceholderActiveViewId( const TVwsViewId& aViewId )

    {

    iPlaceholderView->SetPreviouslyActiveViewId( aViewId );

    }

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

// CGSPluginAndViewIdCache::RegisterViewAndImplementationAssociationL

// 

//

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

//

void CGSPluginAndViewIdCache::RegisterViewAndImplementationAssociationL( TUid aViewId, TUid aImplementationUid )

    {

    RegisterViewAndImplementationAssociationL( aViewId, aImplementationUid, EFalse );

    }

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

// CGSPluginAndViewIdCache::PrepareToRegisterPluginInstanceLC

// 

//

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

//

void CGSPluginAndViewIdCache::PrepareToRegisterPluginInstanceLC( TUid aViewId )

    {

    TCacheEntry* value = iLookupTable.Find( aViewId );

    if  ( value && value->iShim )

        {

        // Store cleanup view uid so that we know which shim to re-register

        // if the cleanup item is invoked.

        iTransientCleanupViewUid = aViewId;

        // Prepare item

        TCleanupItem item( ReRegisterShimWithUi, this );

        CleanupStack::PushL( item );

        // Unregister shim view

        value->iShim->DeregisterView();

        // If a leave now occurs, the cleanup stack will unwind and will

        // invoke our cleanup item. This item will then re-add

        // the specified shim to the view framework. See ReRegisterShimWithUiL

        // for further details.

        }

    else

        {

        // Record not found - just push NULL to ensure cleanup stack

        // remains balanced.

        CleanupStack::PushL( (CBase*) NULL );

        }

    }

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

// CGSPluginAndViewIdCache::RegisterPluginInstanceL

// 

//

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

//

void CGSPluginAndViewIdCache::RegisterPluginInstanceL( TUid aViewId, CGSPluginInterface& aPluginInstance )

    {

    TCacheEntry* value = iLookupTable.Find( aViewId );

    ASSERT( value != NULL );

    // Can now associate the plugin instance with the cache entry.

    value->iLoadedPluginImplementation = &aPluginInstance;

    }

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

// CGSPluginAndViewIdCache::PluginImplementationUidForView

// 

//

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

//

TBool CGSPluginAndViewIdCache::IsPluginLoaded( TUid aViewId ) const

    {

    CGSPluginInterface* instance = PluginInstance( aViewId );

    TBool loaded = EFalse;

    if ( instance )

        {

        loaded = ETrue;

        }

    return loaded;

    }

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

// CGSPluginAndViewIdCache::PluginInstance

// 

//

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

//

CGSPluginInterface* CGSPluginAndViewIdCache::PluginInstance( TUid aViewId ) const

    {

    CGSPluginInterface* ret = NULL;

    //

    const TCacheEntry* value = iLookupTable.Find( aViewId );

    if  ( value )

        {

        ret = value->iLoadedPluginImplementation;

        }

    //

    return ret;

    }

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

// CGSPluginAndViewIdCache::PluginImplementationUidForView

// 

//

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

//

TUid CGSPluginAndViewIdCache::PluginImplementationUidForView( TUid aViewId ) const

    {

    TUid pluginUid = KNullUid;

    //

    const TCacheEntry* value = iLookupTable.Find( aViewId );

    if  ( value )

        {

        pluginUid = value->iImplementationUid;

        }

    //

    return pluginUid;

    }

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

// CGSPluginAndViewIdCache::DestroyShims

// 

//

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

//

void CGSPluginAndViewIdCache::DestroyShims()

    {

	RHashMap< TUid, TCacheEntry >::TIter iterator( iLookupTable );

    FOREVER

		{

		const TUid* key = iterator.NextKey();

		if  ( key )

            {

            TCacheEntry* value = iterator.CurrentValue();

            // Destroy shim instance

            delete value->iShim;

            value->iShim = NULL;

            }

        else

            {

			break;

            }

		}

    }

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

// CGSPluginAndViewIdCache::RestoreL

// 

//

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

//

void CGSPluginAndViewIdCache::RestoreL()

    {

    TFileName* cacheFile = new(ELeave) TFileName();

    CleanupStack::PushL( cacheFile );

    GetCacheFileNameL( *cacheFile );

    //

    if  ( BaflUtils::FileExists( iFsSession, *cacheFile ) )

        {

        RFileReadStream cacheStream;

        TInt error = cacheStream.Open( iFsSession, *cacheFile, EFileRead );

        User::LeaveIfError( error );

        CleanupClosePushL( cacheStream );

        // Now read in cache hash table

        TUid key = KNullUid;

        TUid value = KNullUid;

        const TInt entryCount = cacheStream.ReadInt32L();

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

            {

            key.iUid = cacheStream.ReadUint32L();

            value.iUid = cacheStream.ReadUint32L();

            //

            RegisterViewAndImplementationAssociationL( key, value, ETrue );

            }

        CleanupStack::PopAndDestroy( &cacheStream );

        }

    //

    CleanupStack::PopAndDestroy( cacheFile );

    }

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

// CGSPluginAndViewIdCache::StoreL

// 

//

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

//

void CGSPluginAndViewIdCache::StoreL()

    {

    TFileName* intermediateFileName = new(ELeave) TFileName();

    CleanupStack::PushL( intermediateFileName );

    TFileName* cachePath = new(ELeave) TFileName();

    CleanupStack::PushL( cachePath );

    GetCachePathL( *cachePath );

    // Create a temporary file in the GS private data cage to contain

    // the cache data. We'll rename this to the real cache file name

    // once the operation has been completed successfully.

    RFile intermediateCacheFile;

    TInt error = intermediateCacheFile.Temp( iFsSession, *cachePath, *intermediateFileName, EFileWrite );

    User::LeaveIfError( error );

    // Create a stream from the file. Stream takes ownership of file

    RFileWriteStream stream( intermediateCacheFile );

    CleanupClosePushL( stream );

    // Write each entry to the stream

    stream.WriteUint32L( iLookupTable.Count() );

	RHashMap< TUid, TCacheEntry >::TIter iterator( iLookupTable );

    FOREVER

		{

		const TUid* key = iterator.NextKey();

		if  ( key )

            {

            const TCacheEntry* value = iterator.CurrentValue();

            stream.WriteUint32L( key->iUid );

            stream.WriteUint32L( value->iImplementationUid.iUid );

            }

        else

            {

			break;

            }

		}

    // Finalise the stream

    stream.CommitL();

    stream.Close(); // Also closes the file

    CleanupStack::PopAndDestroy( &stream ); 

    // If we got this far it means we created the cache file successfully.

    // Now its okay to replace any pre-existing cache file with the

    // file we just created. We're re-use the cachePath variable for the

    // ultimate filename since it saves allocating another 1/2kb on the heap.

    GetCacheFileNameL( *cachePath );

    if  ( BaflUtils::FileExists( iFsSession, *cachePath ) )

        {

        error = iFsSession.Delete( *cachePath );

        User::LeaveIfError( error );

        }

    // Now rename intermediate file name to ultimate cache file name.

    error = iFsSession.Rename( *intermediateFileName, *cachePath );

    User::LeaveIfError( error );

    CleanupStack::PopAndDestroy( 2, intermediateFileName );

    }

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

// CGSPluginAndViewIdCache::GetCacheFileNameL

// 

//

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

//

void CGSPluginAndViewIdCache::GetCacheFileNameL( TDes& aFileName )

    {

    GetCachePathL( aFileName );

    aFileName.Append( KGSCacheFileName );

    }

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

// CGSPluginAndViewIdCache::GetCachePathL

// 

//

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

//

void CGSPluginAndViewIdCache::GetCachePathL( TDes& aPath )

    {

    aPath.Zero();

    // Get private data cage path

    TInt err = iFsSession.PrivatePath( aPath );

    User::LeaveIfError( err );

    // Combine with C: drive

    const TDriveUnit cDrive( EDriveC );

    const TDriveName cDriveName( cDrive.Name() );

    aPath.Insert( 0, cDriveName );

    }

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

// CGSPluginAndViewIdCache::RegisterViewAndImplementationAssociationL

// 

//

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

//

void CGSPluginAndViewIdCache::RegisterViewAndImplementationAssociationL( TUid aViewId, TUid aImplementationUid, TBool aCreateShim )

    {

    // Check if aViewId is a key within the look up table, so as to avoid

    // adding duplicate entries...

    const TCacheEntry* value = iLookupTable.Find( aViewId );

    if  ( !value )

        {

        // No registration for this view yet, so create a new entry

        TCacheEntry cacheEntry;

        cacheEntry.iImplementationUid = aImplementationUid;

        cacheEntry.iLoadedPluginImplementation = NULL;

        if  ( aCreateShim )

            {

            // Create a new shim

            cacheEntry.iShim = CGSShimmedView::NewLC( aViewId, *this, iAppUi );

            }

        else

            {

            cacheEntry.iShim = NULL;

            }

        // Add entry to table - the shim ownership is also transferred 

        // at this point, since the destructor of this class will

        // destroy all shims.

        iLookupTable.InsertL( aViewId, cacheEntry );

        if  ( aCreateShim )

            {

            CleanupStack::Pop( cacheEntry.iShim );

            }

        }

    }

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

// CGSPluginAndViewIdCache::PrepareForUIDestruction

// 

//

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

//

void CGSPluginAndViewIdCache::PrepareForUIDestruction()

    {

    // Have to remove all UI furniture before the AppUi rug is pulled out

    // from underneath us...

    DestroyShims();

    //

    delete iPlaceholderView;

    iPlaceholderView = NULL;

    }

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

// CGSPluginAndViewIdCache::HandleShimDestruction

// 

//

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

//

void CGSPluginAndViewIdCache::HandleShimDestruction( TUid aViewId )

    {

    TCacheEntry* value = iLookupTable.Find( aViewId );

    if  ( value && value->iShim )

        {

        // The shim has been destroyed.

        value->iShim = NULL;

        }

    }

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

// CGSPluginAndViewIdCache::ReRegisterShimWithUi

// 

//

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

//

void CGSPluginAndViewIdCache::ReRegisterShimWithUi( TAny* aSelf )

    {

    CGSPluginAndViewIdCache* self = reinterpret_cast< CGSPluginAndViewIdCache* >( aSelf );

    //

    if  ( self->iTransientCleanupViewUid != KNullUid )

        {

        TCacheEntry* value = self->iLookupTable.Find( self->iTransientCleanupViewUid );

        if  ( value && value->iShim )

            {

            TRAP_IGNORE( value->iShim->RegisterViewL() );

            }

        }

    //

    self->iTransientCleanupViewUid = KNullUid;

    }

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

// CGSPluginAndViewIdCache::HashFunction

//