/*

* Copyright (c) 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 of haptics client's IVT-data cache.

*

*/

#include "hwrmhapticsivtdatacache.h"

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

// Two-phase constructor.

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

//

CHWRMHapticsIVTDataCache* CHWRMHapticsIVTDataCache::NewL()

    {        

    CHWRMHapticsIVTDataCache* self = CHWRMHapticsIVTDataCache::NewLC();

    CleanupStack::Pop( self );

    return self;      

    }

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

// Two-phase asynchronous constructor.

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

//

CHWRMHapticsIVTDataCache* CHWRMHapticsIVTDataCache::NewLC()

    {

    CHWRMHapticsIVTDataCache* self = new ( ELeave ) CHWRMHapticsIVTDataCache();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor.

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

//

CHWRMHapticsIVTDataCache::~CHWRMHapticsIVTDataCache()

    {

    Reset();

    if ( iIdle )

        {

        iIdle->Cancel();

        delete iIdle;

        }

    iCache.Close();

    }

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

// Adds a new IVT-data item to the cache.

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

//

TInt CHWRMHapticsIVTDataCache::AddCacheItem( const TDesC8& aIVTData, 

                                             TInt& aFileHandle )

    {

    TInt err = KErrNoMemory;

    TCacheItem newItem;

    newItem.iIVTData = aIVTData.Alloc();

    newItem.iClientFileHandle = ++iInternalHandle;

    newItem.iDeletionRequested = EFalse;

    newItem.iLoadObserver = NULL;

    aFileHandle = iInternalHandle;

    if ( newItem.iIVTData )

        {

        err = iCache.Append( newItem );

        }

    return err;

    }

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

// Adds a new IVT-data item to the cache. This overload is meant for 

// asynch calls.

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

//

TBool CHWRMHapticsIVTDataCache::UpdateCacheItemListener( 

        TInt aFileHandle,

        TRequestStatus& aClientStatus,

        RHWRMHapticsSession* aClientSession,

        const TIpcArgs& aArgs )

    {

    TBool retVal( EFalse );

    TInt itemIndex = FindItem( aFileHandle );

    if ( itemIndex >= 0 )

        {

        // New load observer listener is only instantiated if there isn't

        // already a listener for the cache item. Note that if there already

        // were one, this method will return EFalse, and the actual asynch

        // call will be made with the original client's status in Impl class.

        if ( !iCache[itemIndex].iLoadObserver )

            {

            // If the below leaves this method will return EFalse,

            // and the actual asynch call will be made with the original 

            // client's status.

            TRAPD(err,  

                  iCache[itemIndex].iLoadObserver = 

                    CHWRMHapticsIVTDataCacheAO::NewL( aFileHandle,

                                                      this,

                                                      aClientStatus ) );

            if ( !err )

                {

                iCache[itemIndex].iLoadObserver->PlayEffectAsynch

                    ( aClientSession, aArgs );

                retVal = ETrue;

                }

            }

        }

    return retVal;

    }

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

// Removes a cache item identified by the given filehandle.

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

//

TInt CHWRMHapticsIVTDataCache::RemoveCacheItem( TInt aFileHandle )

    {

    TInt err = KErrNotFound;

    // search for the item in the cache

    TInt itemIndex = FindItem( aFileHandle );

    if ( itemIndex >= 0 )

        {

        // item was found, either mark it for deletion (if there's active

        // load observer active object waiting for response for previous 

        // play with data request) or otherwise delete and remove it.

        if ( iCache[itemIndex].iLoadObserver && 

             iCache[itemIndex].iLoadObserver->IsActive() )

            {

            iCache[itemIndex].iDeletionRequested = ETrue;

            }

        else

            {

            delete iCache[itemIndex].iIVTData;

            iCache[itemIndex].iIVTData = NULL;

            delete iCache[itemIndex].iLoadObserver;

            iCache[itemIndex].iLoadObserver = NULL;

            iCache.Remove( itemIndex );

            err = KErrNone;

            // update loaded item index, if needed

            if ( iLoadedItem == itemIndex )

                {

                iLoadedItem = KErrNotFound;

                }

            else if ( iLoadedItem > itemIndex )

                {

                --iLoadedItem;

                }

            }

        }

    return err;

    }

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

// Removes all items from the cache.

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

//

void CHWRMHapticsIVTDataCache::Reset()

    {

    // delete and remove all items

    while ( iCache.Count() )

        {

        delete iCache[0].iIVTData;

        iCache[0].iIVTData = NULL;

        delete iCache[0].iLoadObserver;

        iCache[0].iLoadObserver = NULL;

        iCache.Remove( 0 );

        }

    iLoadedItem = KErrNotFound;

    }

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

// Returns a pointer to the IVT-data buffer, which corresponds to

// the given filehandle.

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

//

const HBufC8* CHWRMHapticsIVTDataCache::IVTData( TInt aFileHandle ) const

    {

    HBufC8* ivtData = NULL;

    // search for the item in the cache

    TInt itemIndex = FindItem( aFileHandle );

    if ( itemIndex >= 0 )

        {

        ivtData = iCache[itemIndex].iIVTData;

        }

    return ivtData;

    }

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

// Returns whether or not the IVT-data of the given filehandle

// is currently loaded into the haptics system.

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

//

TBool CHWRMHapticsIVTDataCache::IsLoaded( TInt aFileHandle ) const

    {

    TInt ret = EFalse;

    TInt index = FindItem( aFileHandle );

    // if index was found and the index is the loaded item's index,

    // this data is already loaded

    if ( index >= 0 && index == iLoadedItem )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// Updates server side file handle

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

//

void CHWRMHapticsIVTDataCache::UpdateCacheItem( TInt aClientFileHandle,

                                                TBool aSetLoaded )

    {

    // find the item from cache with the given filehandle

    TInt itemIndex = FindItem( aClientFileHandle );

    if ( itemIndex >= 0 )

        {

        if ( aSetLoaded && !iCache[itemIndex].iDeletionRequested )

            {

            iLoadedItem = itemIndex;

            }

        }

    }

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

// Returns client side file handle

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

//

TInt CHWRMHapticsIVTDataCache::ClientFileHandle( const TDesC8& aIVTData )

    {

    // find the item from cache with the given filehandle

    TInt clientFileHandle( KErrNotFound );

    TInt count( iCache.Count() );

    for ( TInt i( 0 ); i < count && KErrNotFound == clientFileHandle; ++i )

        {

        TPtr8 cachedData = iCache[i].iIVTData->Des();

        if ( cachedData == aIVTData )

            {

            clientFileHandle = iCache[i].iClientFileHandle;

            }

        }

    return clientFileHandle;

    }

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

// Method for starting the idle object that then calls garbage collection

// callback.

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

//

void CHWRMHapticsIVTDataCache::RequestGarbageCollection()

    {

    if ( iIdle && !iIdle->IsActive() )

        {

        iIdle->Start( TCallBack ( CollectGarbageIdle, this ) );

        }

    }

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

// Garbage collection static callback.

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

//

TInt CHWRMHapticsIVTDataCache::CollectGarbageIdle( TAny* aObjectPtr )

    {

    CHWRMHapticsIVTDataCache* self = 

        reinterpret_cast<CHWRMHapticsIVTDataCache*>( aObjectPtr );

    if ( self )

        {

        self->CollectGarbage();

        }

    return KErrNone;

    }

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

// Garbage collection actual (object specific) callback. Cleans obsolete

// load observers and whole TCacheItems if needed.

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

//

void CHWRMHapticsIVTDataCache::CollectGarbage()

    {

    for ( TInt i = iCache.Count() - 1; i >= 0; --i )

        {

        // This garbage collection is only interested in those entries for

        // which there has been load observer running, i.e., for which the

        // iLoadObserver is non-NULL, and for which the running has stopped,

        // i.e., the iLoadObserver.IsActive() check returns EFalse

        if ( iCache[i].iLoadObserver && !iCache[i].iLoadObserver->IsActive() )

            {

            delete iCache[i].iLoadObserver;

            iCache[i].iLoadObserver = NULL;

            // If the entry was also marked for deletion, delete the whole

            // entry from TCacheItem array

            if ( iCache[i].iDeletionRequested )

                {

                delete iCache[i].iIVTData;

                iCache[i].iIVTData = NULL;

                iCache.Remove( i );

                // update loaded item index, if needed

                if ( iLoadedItem == i )

                    {

                    iLoadedItem = KErrNotFound;

                    }

                else if ( iLoadedItem > i )

                    {

                    --iLoadedItem;

                    }

                }

            }

        }

    }

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

// C++ constructor.

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

//

CHWRMHapticsIVTDataCache::CHWRMHapticsIVTDataCache()

    : iLoadedItem( KErrNotFound )

    {

    }

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

// Second phase construction.

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

//

void CHWRMHapticsIVTDataCache::ConstructL()

    {

    iIdle = CIdle::NewL( CActive::EPriorityIdle );

    }

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

// Searches the cache for an item with the given filehandle.

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

//

TInt CHWRMHapticsIVTDataCache::FindItem( TInt aClientFileHandle ) const

    {

    TInt index = KErrNotFound;

    // find the item from cache with the given filehandle

    for ( TInt i = 0; i < iCache.Count() && index == KErrNotFound; ++i )

        {

        if ( iCache[i].iClientFileHandle == aClientFileHandle )

            {

            index = i;

            }

        }

    return index;

    }

//  End of File