// Copyright (c) 1995-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:

 //

 #ifndef OPENWFCJOBMANAGER_H_

 #define OPENWFCJOBMANAGER_H_

 #include <e32std.h>

 #include <e32base.h>

 #include <e32debug.h>

 #include <EGL/egl.h>

 #include <graphics/eglsynchelper.h>

 #include <WF/wfc.h>

 class COpenWfcWrapper;

 class COpenWfcMonitorThread;

 class TOpenWfcJob;

 #if defined(ENABLE_JQ_LOGGING)

 #define JQLOG(X)  RDebug::Printf X

 #else

 #define JQLOG(X)

 #endif

 /**

  * Controls the OpenWF composition

  */

 class COpenWfcJobManger : public CBase

 	{

 private:

     enum EOpenWfcJobId

         {

             EOpenWfcInvalidJobId = 0,

             EOpenWfcComposeJobId,

             EOpenWfcPauseCompositionJobId,

             EOpenWfcResumeCompositionJobId,

         };

 	/**

 	 * Stores the parameters associated with a composition

 	 */

 	struct TComposeRequestDetails

 		{

 		TComposeRequestDetails();

 		void Set(TRequestStatus* aCommitRequest, TThreadId aCallingThread);

 		void Reset();

 		TRequestStatus* iCommitRequest;

 		TThreadId iCallingThread;

 		TDblQueLink iDlink;

 		};

 	/**

 	 * Auxilliary class to insure the release of a lock

 	 */

 	class Guard

 		{

 		public:

 		Guard(RMutex& aLock);

 		~Guard();

 		private:

 		    RMutex& iLock;

 		};

 public:

 	/**

 	 * Two-phased constructor.

 	 */

 	static COpenWfcJobManger* NewL(COpenWfcWrapper& aOpenWfcWrapper, 

                                     WFCDevice aDevice, 

                                     WFCContext aContext,

                                     TInt aManagerId);

 	/**

 	 * Two-phased constructor.

 	 */

 	static COpenWfcJobManger* NewLC(COpenWfcWrapper& aOpenWfcWrapper, 

                                     WFCDevice aDevice, 

                                     WFCContext aContext,

                                     TInt aManagerId);

 	/**

 	 * Destructor.

 	 */

 	virtual ~COpenWfcJobManger();

 	/**

 	 * Request to compose the specified scene 

 	 * 

 	 * @param aCompleted The notification to be returned when the composition completes

 	 * @param aUpdatePolicy Update policy to be used

 	 * @param the Pointer to the first element from the element list containing the scene to be used by the next commit

 	 * 

 	 */

 	void ComposeRequest(TRequestStatus* aCompleted);

 	/**

 	 * Request to pause the composition

 	 */

 	void CompositionPauseRequest();

 	/**

 	 * Request to resume the composition

 	 */

 	void CompositionResumeRequest();

     /**

      * Appends to the compose details list the first detail object from the compose detail list

      * 

      * @return NULL if the compose detail pool is empty or a pointer to the appended detail object

      */

 	TComposeRequestDetails* AppendDetailsFromPool();

     /**

      * Executes an outstanding command, if any.

      * 

      */

     void DoExecuteJob();

 private:

     /**

      * Executes a compose request.

      * Intended to be invoked by a job

      * 

      * @param Reference to the invoking job

      */

     void DoComposeJob();

     /**

      * Executes a pause composition request

      * Intended to be invoked by a job

      * 

      * @param Reference to the invoking job

      */

     void DoPauseCompositionJob();

     /**

      * Executes a resume composition request.

      * Intended to be invoked by a job

      * 

      * @param Reference to the invoking job

      */

     void DoResumeCompositionJob();

 	/**

 	 * Private constructor

 	 */

 	COpenWfcJobManger(COpenWfcWrapper& aOpenWfcWrapper, 

 						 WFCDevice aDevice, 

 						 WFCContext aContext,

 						 TInt aManagerId);

 	/**

 	 * Symbian constructor used with the two stage construction pattern

 	 */

 	void ConstructL();

 	/**

 	 * Implements a fence operation

 	 */

 	void Fence();

 	/**

 	 * Waits until the sync is signalled

 	 */

 	void WaitForSync();

 	/**

 	 * Activates the composition on the current context

 	 */

 	void Activate();

 	/**

 	 * Deactivates the composition on the current context

 	 */

 	void Deactivate();

 	/**

 	 * Execute a composition on the current context

 	 */

 	void Compose();

 	/**

 	 * Execute a commit on the current context

 	 */

 	void Commit();

 	/**

 	 * Completes all the outstanding requests stored locally

 	 */

 	void CompleteComposeRequests(TInt aResult);

     /**

      * Completes all the outstanding pause/resumerequests requests

      */

     void CompletePauseResumeRequest(TInt aResult);

 private:

 	// 

 	TDblQue<TComposeRequestDetails> iComposeDetailsPool;

 	TDblQueIter<TComposeRequestDetails> iComposeDetailsPoolIter;

 	TDblQue<TComposeRequestDetails> iComposeDetailsList;

 	TDblQueIter<TComposeRequestDetails> iComposeDetailsListIter;

     RMutex iJobLock;

     RMutex iCommandLock;

     COpenWfcWrapper& iOpenWfcWrapper;

 	WFCDevice iDevice;

 	WFCContext iContext;

 	volatile TBool iCompositionPaused;

 	volatile TBool iPausedComposePending;

 	COpenWfcMonitorThread*	iThreadManager;

 	TInt iManagerId;

 	EGLSyncKHR iSync;

 	EGLDisplay iEglDisplay;

     TRequestStatus iPauseResumeRequestStatus;

     TThreadId iPauseResumeThread;

     EOpenWfcJobId iOutstandingJob;

     static const TInt KComposeDetailsPoolSize = 16;

 	};

 inline void COpenWfcJobManger::Fence()

 	{

     wfcFence(iDevice, iContext, iEglDisplay, iSync);

 	}

 inline void COpenWfcJobManger::WaitForSync()

 	{

 	EGLTimeKHR timeout = (EGLTimeKHR) EGL_FOREVER_KHR;

 	eglClientWaitSyncKHR(iEglDisplay, iSync, 0, timeout);

 	}

 inline void COpenWfcJobManger::Activate()

 	{

 	wfcActivate(iDevice, iContext);

 	}

 inline void COpenWfcJobManger::Deactivate()

 	{

 	wfcDeactivate(iDevice, iContext);

 	}

 inline void COpenWfcJobManger::Compose()

 	{

 	wfcCompose(iDevice, iContext, WFC_TRUE);

 	}

 inline void COpenWfcJobManger::Commit()

 	{

 	wfcCommit(iDevice, iContext, WFC_TRUE);

 	}

 #endif /* OPENWFCJOBMANAGER_H_ */