/*

* 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:    Garbage collector

*

*/

#ifndef C_GLXGARBAGECOLLECTOR_H

#define C_GLXGARBAGECOLLECTOR_H

#include <e32base.h>

class CGlxMedia;

class CGlxCache;

class T_CGlxGarbageCollector;

class TMPXAttribute;

/**

 * CGlxGarbageCollector

 *

 * Garbage collector for the media item cache

 *

 * @lib glxmedialists.lib

 */

class CGlxGarbageCollector : public CBase

    {

public:

    /**

     * Two-phase constructor

     * @return new garbage collector instance

     */

    static CGlxGarbageCollector* NewL( const RPointerArray<CGlxCache>& aCaches );

    /**

     * Destructor

     */

    ~CGlxGarbageCollector();

    /**

     * Start background garbage collection

     */

    void CleanupL();

    /**

     * Cancel background garbage collection

     */

    void CancelCleanup();

    /**

     * Flush Some Pages As System Reach Low Memory Limit

     * pointer to be used

     */

    void FlushPagesL(TInt aCount);

private:

    /**

     * Constructor

     */

    CGlxGarbageCollector( const RPointerArray<CGlxCache>& aCaches );

    /**

     * Second-phase constructor

     */

    void ConstructL();

    /**

     * Callback for periodic timer

     * @see TCallBack

     */

    static TInt PeriodicCallbackL( TAny* aPtr );

    /**

     * Callback for periodic timer, non-static, and hence allows this

     * pointer to be used

     */

    void PeriodicCallbackL();

    /**

     * Perform garbage collection on all caches

     * Only cleans up only a certain number of items each call, to avoid

     * this call taking a very long time, as this will be called

     * from the periodic timer callback

     * @param aCount 

     * @return ETrue if reached the end of caches; EFalse if not

     */

    TBool CleanupCaches(TInt aCount = 1);

    /**

     * Perform garbage collection on specified cache

     * Only cleans up only aRemainingScanCount amount of items.

     * @param aRemainingScanCount maximum number of items to scan

     * @return the remaining scan count

     */

    TInt CleanupCache( CGlxCache& aCache, TInt aRemainingScanCount );

    /**

     * Clean a particular media object: remove attributes that no fetch contexts want

     */

    void CleanupMediaL( CGlxCache& aCache, CGlxMedia& aMedia );

    /**

     * Get a list of all attributes that should not  be deleted form a given 

     * media object

     * @param aMedia Media object for which attributes are required

     * @return aNeededAttributes list of attributes that should not be 

     *                           deleted 

     */

    void GetAttributesInUseL( const CGlxMedia& aMedia, 

        RArray<TMPXAttribute>& aNeededAttributes ) const;

    /**

     * Delete attributes from a media object other than those specified

	 * Removes the fullscreen texture if the fullscreen thumbnail att is deleted

     * @param aMedia Media object from which to delete attributes

     * @return aAttributesToKeep List of attributes that will not be deleted

     */

    void DeleteOtherAttributes( CGlxCache& aCache, CGlxMedia& aMedia, 

        const RArray<TMPXAttribute>& aAttributesToKeep ) const;

    /**

     * Check user count in remaining caches for media item to be deleted

     * @param aMedia Media id which is to be checked

     * @return EFalse if user count is zero in all caches

     *	       ETrue if user count is non zero in any of the caches  

     */

    TBool MediaInUse(const CGlxMedia& aMedia) const;

private:

    /**

     * Abstraction of indexes that control the scanning of the cache across idle 

     * callbacks

     */

    struct TScanIndexes 

        {

        /// Index of the cache index that is currently being cleaned up

    	TInt iCurrentCacheIndex;

        /// Index of the media index in the current cache that should next be cleaned up

        TInt iNextMediaIndexToCleanup;

        };

private: // Data

    /// Single instance of the garbage collector

    static CGlxGarbageCollector* iGarbageCollector;

    /// A list of caches that should be kept clean

    /// not own (pointed cache objects)

    const RPointerArray<CGlxCache>& iCaches;

    // A list of attributes that are still in use by an item

    RArray<TMPXAttribute> iAttributesInUse;

    /// Periodic timer active object to use for callbacks

    /// own

    CPeriodic* iPeriodic; 

    /// Scan indexes of the current scanning position in the caches

    TScanIndexes iScanningPosition;

    /// Info of whether a full cleanup round should be performed to have all

    /// garbage freed from all caches.

    /// ETrue if cleanup should be run from the start before fully cleaned

    /// EFalse if the caches are clean currently or after the current cleanup

    /// round completes.

    TBool iRequiresFullCleanupRound;

    friend class T_CGlxGarbageCollector;

    };

#endif // C_GLXGARBAGECOLLECTOR_H