/*

* Copyright (c) 2008-2009 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:    Manager of media item cache

*

*/

#include "glxcachemanager.h"

#include <mpxcollectionutility.h>

#include <glxtracer.h>

#include <glxthumbnailattributeinfo.h>

#include <glxthumbnail.h>

#include <glxsingletonstore.h>

#include <glximageviewermanager.h>

#include "glxcache.h"

#include "glxerrormanager.h"

#include "glxgarbagecollector.h"

#include "glxmedialist.h"

#include <hal.h>

#include <glxcollectionpluginimageviewer.hrh>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmediadrmdefs.h>

#include <f32file.h>

#include <lbsposition.h>

#include <apgcli.h>

#include <caf/content.h>

#include <caf/attributeset.h>

#include <DRMHelper.h>

#ifdef USE_S60_TNM

#include <thumbnaildata.h>

const TInt KMaxGridThumbnailWidth = 200;

_LIT(KFileIdentifier, ":\\");

#endif

_LIT(KDefaultType, "image/jpg");

/// How long to wait before rechecking for cleared temporary errors

/// @todo Find optimal value for this

const TInt KGlxTemporaryErrorRecheckPeriodInSeconds = 5;

const TInt KGlxLowerMemoryLimitForCleanUp = 15000000;

const TInt KGlxUpperMemoryLimitForCleanUp = 25000000;

//Defining number of pages to be flushed in critical low memory conditions.

const TInt KGlxNoOfPagesToFlushInCriticalLowMemory = 4;

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

// InstanceL

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

//

CGlxCacheManager* CGlxCacheManager::InstanceL()

	{

	TRACER("CGlxCacheManager::InstanceL");

	return CGlxSingletonStore::InstanceL(&NewL);

	}

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

// NewL

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

//

CGlxCacheManager* CGlxCacheManager::NewL()

    {

    TRACER("CGlxCacheManager::NewL");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Close

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

//

void CGlxCacheManager::Close()

	{

	TRACER("CGlxCacheManager::Close");

	CGlxSingletonStore::Close(this);

	}

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

// Constructor

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

//

CGlxCacheManager::CGlxCacheManager()

    {

    TRACER("CGlxCacheManager::Default Constructor");

    }

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

// ConstructL

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

//

void CGlxCacheManager::ConstructL()

    {

    TRACER("CGlxCacheManager::ConstructL");

    iGarbageCollector = CGlxGarbageCollector::NewL( iCaches );

    iTempErrorTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iMaintainCacheCallback = new ( ELeave )

	    CAsyncCallBack( TCallBack( MaintainCacheL, this ), CActive::EPriorityStandard );

#ifdef USE_S60_TNM

    iTnEngine = CThumbnailManager::NewL( *this);

    iTnEngine->SetDisplayModeL( EColor64K );

#endif

    }

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

// Destructor

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

//

CGlxCacheManager::~CGlxCacheManager()

	{

	TRACER("CGlxCacheManager::Destructor");

 	iObserverList.ResetAndDestroy();

 	iCaches.ResetAndDestroy();

 	delete iTempThumbnail;

 	iRequestedItemIds.Reset();

 	iRequestedAttrs.Reset();

 	iRequestedItemIndexes.Reset();

    if(iReader)

        {

        delete iReader;

        }

 	delete iGarbageCollector;

    if (iTempErrorTimer)

        {

		iTempErrorTimer->Cancel();	

		delete iTempErrorTimer;

        }

#ifdef USE_S60_TNM

    GLX_DEBUG2("CGlxCacheManager::~CGlxCacheManager() TN Ids count()=%d",

										 iThumbnailRequestIds.Count());

    for (TInt i = 0; i < iThumbnailRequestIds.Count(); i++)

        {

        iTnEngine->CancelRequest(iThumbnailRequestIds[i].iId);

        }

	iThumbnailRequestIds.Reset();

    delete iTnEngine;

    delete iMPXMedia;

#endif

    delete iMaintainCacheCallback;

	}

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

// HandleWindowChangedL

// From MVieMediaItemListManager

// The list calls this function to hint the list manager, that the items 

// the list contains might not all be loaded, and it would be nice if the list

// manager could load the missing items to the cache.

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

//

void CGlxCacheManager::HandleWindowChangedL(CGlxMediaList* /*aList*/) 

	{

	TRACER("CGlxCacheManager::HandleWindowChangedL");

	GLX_LOG_INFO("---- MGallery - CGlxCacheManager::HandleWindowChangedL()---- ");

    iMaintainCacheCallback->CallBack();

    // Its Better if we are not Cleaning Cache here; Instaed Can Do inside MainTainCache

    //MaintainCacheL();

    //iGarbageCollector->Cleanup();

    }

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

// CancelPreviousRequest

// This API cancels the pending attributes and thumbnail request  

// when the media item in focus is NULL

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

//

void CGlxCacheManager::CancelPreviousRequest()

	{

	TRACER("CGlxCacheManager::CancelPreviousRequest");		

	// iRequestOwner is NULL, if there are no pending attribute/thumbnail request

	// If no pending request, do nothing, else cancel the the pending requests

	if(iRequestOwner)

		{		

		MMPXCollection& collection = iRequestOwner->Collection();

		// Cancel the pending attribute request

		collection.CancelRequest();	

#ifdef USE_S60_TNM

		GLX_DEBUG2("CGlxCacheManager::CancelPreviousRequest() iThumbnailRequestIds.Count() %d", iThumbnailRequestIds.Count());

		// Check if any thumbnail requests are pending and cancel the requests.		

		for (TInt i = 0; i < iThumbnailRequestIds.Count(); i++)

			{ 			

			iTnEngine->CancelRequest(iThumbnailRequestIds[i].iId);									

			}

		iThumbnailRequestIds.Reset();		

#endif

		iRequestOwner = NULL;

		}

	}

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

// HandleGarbageCollection

// Garbage Collection Quick or with Timer

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

//

void CGlxCacheManager::HandleGarbageCollectionL(TBool aStart)

    {

    TRACER("CGlxCacheManager::HandleGarbageCollection");

    TInt freeMemory = 0;

    HAL::Get( HALData::EMemoryRAMFree, freeMemory );

    if(aStart)

        {

           if(freeMemory < KGlxLowerMemoryLimitForCleanUp)

               {

               // 2 page - 30 Items for Flush

               TInt count = 2;  

               if(freeMemory < (KGlxLowerMemoryLimitForCleanUp/2))

                   {

                   // If Memory is below this limit it's ok i can wait for 60 items to clean-up

                   count = KGlxNoOfPagesToFlushInCriticalLowMemory;

                   }

               // Cancel Clean-up before Flush Page; Clean-up will be starting just after Flush page

               iGarbageCollector->CancelCleanup(); 

               iGarbageCollector->FlushPagesL(count);

               iGarbageCollector->CleanupL();

               iCleanUpOnGoing = ETrue;         // Clean up is Started now i can call CancelClean-up to Stop Clean Up

               }

           else if((freeMemory < KGlxUpperMemoryLimitForCleanUp) && !iCleanUpOnGoing)

               {

               iGarbageCollector->CleanupL();

               iCleanUpOnGoing = ETrue;         // Clean up is Started now i can call CancelClean-up to Stop Clean Up

               }

           // This is Added to Keep Assure Clean-up is not going to Disturb normal Flow if there is Enough Memory

           // We Remove this Code After Evaluation of Use of this Code

           else if(iCleanUpOnGoing)

               {

               iGarbageCollector->CancelCleanup();

               iCleanUpOnGoing = EFalse;

               }

           }

       else if(freeMemory < KGlxLowerMemoryLimitForCleanUp)

           {

           // 2 page - 30 Items for Flush

           TInt count = 2;

           if(freeMemory < (KGlxLowerMemoryLimitForCleanUp/2))

               {

               // If Memory is below this limit it's ok i can wait for 60 items to clean-up

               count = KGlxNoOfPagesToFlushInCriticalLowMemory;

               }

           // Cancel Clean-up before Flush Page; Clean-up will be starting just after Flush page

           iGarbageCollector->CancelCleanup();

           iGarbageCollector->FlushPagesL(count);

        iGarbageCollector->CleanupL();

        iCleanUpOnGoing = ETrue;         // Clean up is Started now i can call CancelClean-up to Stop Clean Up

        }

    else if(iCleanUpOnGoing)

        {

        iGarbageCollector->CancelCleanup();

        iCleanUpOnGoing = EFalse;

        }

    }

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

// Match

// return ETrue if path levels match

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

//

TBool CGlxCacheManager::Match(const CMPXCollectionPath& aPath1, 

		const CMPXCollectionPath& aPath2)

	{

	TRACER("CGlxCacheManager::Match");

	TInt levels1 = aPath1.Levels();

	TInt levels2 = aPath2.Levels();

	// Paths must be as deep to match

	if (levels1 != levels2) 

		{

		return EFalse; 

		}

	// Check if all levels match

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

		{

		if (aPath1.Index(i) != aPath2.Index(i))

			{

			return EFalse;

			}

		}

	return ETrue;

	}

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

// HandleCollectionMediaL

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

//

void CGlxCacheManager::HandleCollectionMediaL(const TGlxIdSpaceId& aIdSpaceId, const CMPXMedia& aMedia, TInt aError)

    {

    TRACER("CGlxCacheManager::HandleCollectionMediaL");

    iRequestOwner = NULL;

    if ( KErrNone == aError )

        {

        // Update the cache

        CGlxCache* cache = FindCacheForceCreateL(aIdSpaceId);

        cache->MediaUpdatedL(aMedia);

        }

    else

        {

        RPointerArray< MGlxMediaUser > users;

        CleanupClosePushL( users );

        // Record the error on all requested attributes

        TInt idCount = iRequestedItemIds.Count();

        for( TInt idIndex = 0; idIndex < idCount; idIndex++ )

            {

            CGlxMedia* item = MediaForceCreateL(aIdSpaceId, iRequestedItemIds[idIndex]);

            GlxErrorManager::SetAttributeErrorL(item, iRequestedAttrs, aError);

            // Keep track of media lists to notify later

            TInt userCount = item->UserCount();

            for ( TInt userIndex = 0; userIndex < userCount; userIndex++ )

                {

                }

            }

        // Notify all affected users of error

        TInt userCount = users.Count();

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

            {

            users[ i ]->HandleError( aError );

            }

        CleanupStack::PopAndDestroy( &users );

        }

    MaintainCacheL();

    }

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

// FindCacheForceCreateL

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

//

CGlxCache* CGlxCacheManager::FindCacheForceCreateL(const TGlxIdSpaceId& aIdSpaceId)

    {

    TRACER("CGlxCacheManager::FindCacheForceCreateL");

    CGlxCache* cache = NULL;

    // Look for existing cache

    TInt index = iCaches.FindInOrder(aIdSpaceId, (&CacheOrderByKey));

    if ( KErrNotFound == index )

        {

        // Not found: create one

    	TLinearOrder<CGlxCache> orderer (&CacheOrderById);

        cache = new (ELeave) CGlxCache(aIdSpaceId, this);

        CleanupStack::PushL(cache);

        iCaches.InsertInOrderL(cache, orderer);

        CleanupStack::Pop(cache);

        }

    else

        {

        cache = iCaches[index];

        }

    return cache;

    }

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

// Media

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

//

CGlxMedia* CGlxCacheManager::Media( const TGlxIdSpaceId& aIdSpaceId, 

        const TGlxMediaId& aMediaId ) const

    {

    TRACER("CGlxCacheManager::Media");

    // Look for the correct subcache

    TInt index = iCaches.FindInOrder( aIdSpaceId, &CacheOrderByKey );

    if ( KErrNotFound == index )

        {

        // No caches exist with this space id

        return NULL;

        }

    else

        {

        return iCaches[index]->Media( aMediaId );

        }

    }

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

// MediaForceCreateL

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

//

CGlxMedia* CGlxCacheManager::MediaForceCreateL(const TGlxIdSpaceId& aIdSpaceId, const TGlxMediaId& aMediaId)

    {

    TRACER("CGlxCacheManager::MediaForceCreateL");

    CGlxCache* cache = FindCacheForceCreateL(aIdSpaceId);

    return cache->FindItemForceCreateL(aMediaId);

    }

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

// AddObserverL

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

//

void CGlxCacheManager::AddObserverL(MGlxCacheObserver* aObserver)

    {

    TRACER("CGlxCacheManager::AddObserverL");

    if ( aObserver )

        {

        if ( KErrNotFound == iObserverList.Find( aObserver ))

            {

            iObserverList.AppendL(aObserver);

            }

        }

    }

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

// RemoveObserver

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

//

void CGlxCacheManager::RemoveObserver(MGlxCacheObserver* aObserver)

    {

    TRACER("CGlxCacheManager::RemoveObserver");

    if ( aObserver )

        {

        TInt index = iObserverList.Find( aObserver );

        if ( KErrNotFound != index )

            {

            iObserverList.Remove(index);

            }

        }

    }

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

// Refresh

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

//

void CGlxCacheManager::RefreshL()

    {

    TRACER("CGlxCacheManager::Refresh");

    if ( !iRequestOwner )

        {

        // Currently idle, so trigger timer immediately to begin refresh

        iTempErrorTimer->Cancel();

        iTempErrorTimer->Start( 0, 0,

                            TCallBack( TempErrorTimerCallbackL, this ) );

        HandleGarbageCollectionL(ETrue);  // Clean-up is needed here; Considering Current Memory Condition

        }

    }

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

// MaintainCache

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

//

TInt CGlxCacheManager::MaintainCacheL(TAny* aPtr)

    {

    TRACER("CGlxCacheManager::MaintainCache");

    CGlxCacheManager* self

                    = reinterpret_cast<CGlxCacheManager*>( aPtr );

    self->MaintainCacheL();

    // Clean-up is needed here; Considering Current Memory Condition

    // For Every HandleWindowChangedL; We Should not do Clean-up 

    self->HandleGarbageCollectionL(ETrue);  

    return 0;

    }

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

// MaintainCacheL

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

//

void CGlxCacheManager::MaintainCacheL() 

    {

    TRACER("CGlxCacheManager::MaintainCacheL");

	// Handle lists in priority order: all data for the highest priority list 

	// is retrieved before the data for a lower priority list. NOTE: This

	// may need to be changed, since it might not always lead to the best

	// user experienced. (It may be sensible to retrieve item properties

	// for a lower priority list before all thumbnails for a higher priority 

	// list, but this probably depends on the speed of the data sources.

	// It might be wise to decouple the contexts from the media lists

    if (!iRequestOwner)

        {

        iTempError = EFalse;

        iTempErrorTimer->Cancel();

    	RPointerArray<CGlxMediaList>& mediaLists = CGlxMediaList::MediaListsL();

     	iRequestedItemIds.Reset();

     	iRequestedAttrs.Reset();