/*

* 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:   Task manager for multiple tasks. Allows asynchronosity and 

*                tracking/callback for long running tasks.

*

*/

/**

 * @internal reviewed 30/07/2007 by Simon Brooks

 */

#ifndef C_GLXTNTASKMANAGER_H

#define C_GLXTNTASKMANAGER_H

#include "glxtnstd.h"

#include <glxmediaid.h>

#include <e32base.h>

// Forward declarations

class CGlxtnTask;

class MGlxtnThumbnailStorage;

/**

 * Active object which maintains a priority queue of long running tasks, and

 * provides callback upon task completion or error.

 *

 * The highest priority task in the queue which has @ref CGlxtnTask::TState "state"

 * EStarting is started and the task manager's RunL then delegates to the task's

 * RunL until the task is complete, or is cancelled.  The task is then deleted

 * and another task is started, if any are ready to start.

 *

 * The task manager's DoCancel and RunError methods also delegate to the current

 * task, if any.

 *

 * @ingroup glx_thumbnail_creator

 */

NONSHARABLE_CLASS(CGlxtnTaskManager) : public CActive

    {

public:

	enum TExecutionOrder

		{

		ELastOut,	// Old tasks with the same priority get executed before the new task

		EFirstOut	// New task gets executed before other tasks with the same priority

		};

public:

    /**

     * Static constructor.

     */

    static CGlxtnTaskManager* NewL();

    /**

     * Destructor.

     */

    ~CGlxtnTaskManager();

public:

    /**

     * @returns CVieTask task at an index

     */

    inline CGlxtnTask* Task(TInt aIndex) const { return iTasks[aIndex]; };

     /**

      * Returns the highest priority task with the id.

      * If there are multiple tasks with same id and priority, 

      * returns the one of those that will be executed first 

      */

   	CGlxtnTask* Task(const TGlxtnTaskId& aId) const;

    /**

     * Adds a task to the task list.  If no task is currently running, the task

     * is started.

     *

     * @param aTask Task to add.  Takes ownership, task is deleted if a leave occurs.

     *

     * @param aExecutionOrder -if ELastOut, the tast gets added to the bottom 

     *					  	  of the queue of the tasks with the same priority 

     * 					      as the new tasks. This means that the task is 

     *						  executed after the previously added tasks (with 

     *						  same priority) have been run.

     *						  -if EFirstOut, the task gets added to the top,

     *						  and will be executed before the other tasks

     *						  with the same priority (unless more tasks added 

     *						  later, of course)

     */

    void AddTaskL(CGlxtnTask* aTask, TExecutionOrder aExecutionOrder = ELastOut);

    /**

     * Cancel all tasks relating to a given media item.

     * @param aItemId ID of media item.

     */

    void CancelTasks(const TGlxMediaId& aItemId);

    /**

     * Cancel all tasks using a given storage.

     * @param aClient Reference to thumbnail storage.

     */

    void CancelTasks(MGlxtnThumbnailStorage* aStorage);

    /**

     * Gets the total task count

     *

     * @return TInt task count

     */

    inline TInt TaskCount() const { return iTasks.Count(); };

protected:

    /**

     * Constructors

     */

    CGlxtnTaskManager();

    void ConstructL(); 

private: // From CActive

	void RunL();		

	void DoCancel();

    TInt RunError(TInt aError);

private:

    /**

     * Issue a self-completing request causing RunL to be called.

     */

    void AsyncRun();

private:

    /**

     * Task list in priority order

     */

    RPointerArray<CGlxtnTask> iTasks;

    /**

     * Task that is currently being run.

     */

    CGlxtnTask* iCurrentTask;

    };

#endif // C_GLXTNTASKMANAGER_H