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

 //

 #include "tdirectgdieglcontent_server.h"

 #include "tdirectgdieglcontent_cube.h"

 #include "tdirectgdieglcontent_clientserver.h"

 #include "tdisplaymode_mapping.h"

 #include <e32debug.h>

 #include <fbs.h>

 #include <graphics/sgimage_sw.h>

 /**

 Static constructor.

 */

 CEglContent* CEglContent::NewL()

 	{

 	CEglContent* self = NewLC();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CEglContent* CEglContent::NewLC()

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 /**

 1st phase constructor

 */

 CEglContent::CEglContent() : CTimer(CActive::EPriorityStandard), iMode(ESync)

 	{

 	CActiveScheduler::Add(this);

 	}

 /**

 2nd phase constructor

 */

 void CEglContent::ConstructL()

 	{

 	CTimer::ConstructL();

 	iCube = CGLCube::NewL(EUidPixelFormatXRGB_8888, TSize(200, 200));

 	}

 /**

 Destructor

 */

 CEglContent::~CEglContent()

 	{

 	Cancel();

 	delete iCube;

 	}

 /**

 Handles an active object's request completion event.

 */

 void CEglContent::RunL()

 	{

 	if(iStatus.Int() == KErrNone)

 		{

 		RenderNextFrame();

 		iFrame = iFrame % KEglContentAsyncMaxFrames;

 		if(iMode == EAsync)

 			{

 			// issue request for next frame

 			After(KEglContentDelay);

 			}

 		}

 	}

 /**

 Render next frame of animation.

 Function returns when rendering is finished. Animation is set to next frame.

 */

 void CEglContent::RenderNextFrame()

 	{

 	iCube->Render(iFrame);

 	iLastFrame = iFrame;

 	iFrame++;

 	}

 /**

 Set rendering mode to synchronous or asynchronous

 @param aMode Rendering mode to set.

 */

 void CEglContent::SetMode(TMode aMode)

 	{

 	if(aMode == iMode)

 		return;

 	iMode = aMode;

 	// reset mode

 	if(aMode == ESync)

 		{

 		// cancel request for next frame

 		Cancel();

 		iFrame = 0;

 		}

 	else if(aMode == EAsync)

 		{

 		// render init frame

 		iFrame = 0;

 		RenderNextFrame();

 		// issue request for next frame

 		After(KEglContentDelay);

 		}

 	else // EAsyncDebug

 		{

 		// render init frame

 		iFrame = 0;

 		RenderNextFrame();

 		}

 	}

 /**

 Get image id of current frame. Current image to render is switch to next.

 @param aId Reference to drawable id class to store image id.

 @return number of frame stored in image

 */

 TInt CEglContent::GetImage(TSgDrawableId& aId)

 	{

 	if(iMode == ESync)

 		{

 		// if rendering mode is synchrounous, we need to render current frame

 		RenderNextFrame();

 		}

 	iCube->GetImage(aId);

 	if(iMode == EAsyncDebug)

 		{	

 		// Added this as a panic can occur if After() is called while the server is active. 

 		// Before this was added the server could get stuck in an active state

 		// occasionally when running the tests in SW mode.

 		if (IsActive())					

 			Cancel();

 		// if rendering mode is asynchrounous debug, we start rendering next frame (only one) immediately

 		After(0);

 		}

 	return iLastFrame;

 	}

 /**

 Static constructor

 */

 CServer2* CEglContentServer::NewLC()

 	{

 	CEglContentServer* self = new(ELeave) CEglContentServer;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 /**

 1st phase constructor

 */

 CEglContentServer::CEglContentServer() : CServer2(0, ESharableSessions)

 	{

 	}

 /**

 2nd phase construction - ensure the content renderer and server objects are running

 */

 void CEglContentServer::ConstructL()

 	{

 	StartL(KEglContentServerName);

 	iContent = CEglContent::NewL();

 	}

 /**

 Destructor.

 */

 CEglContentServer::~CEglContentServer()

 	{

 	delete iContent;

 	}

 /**

 Cretae a new client session.

 */

 CSession2* CEglContentServer::NewSessionL(const TVersion&, const RMessage2&) const

 	{

 	return new(ELeave) CEglContentSession();

 	}

 /*

 A new session is being created

 */

 void CEglContentServer::AddSession()

 	{

 	++iSessionCount;

 	}

 /*

 A session is being destroyed

 */

 void CEglContentServer::DropSession()

 	{

 	--iSessionCount;

 	}

 /**

 Get image in synchronous mode.

 @param aId Reference to drawable id class to store image id.

 */

 void CEglContentServer::GetSyncImage(TSgDrawableId& aId)

 	{

 	if(iContent)

 		{

 		iContent->SetMode(CEglContent::ESync);

 		iContent->GetImage(aId);

 		}

 	}

 /**

 Get image in asynchronous mode.

 @param aId Reference to drawable id class to store image id.

 @return number of frame stored in image

 */

 TInt CEglContentServer::GetAsyncImage(TSgDrawableId& aId)

 	{

 	if(iContent)

 		{

 		iContent->SetMode(CEglContent::EAsync);

 		return iContent->GetImage(aId);

 		}

 	return -1;

 	}

 /**

 Get image in asynchronous debug mode.

 @param aId Reference to drawable id class to store image id.

 @return number of frame stored in image

 */

 TInt CEglContentServer::GetAsyncImageDebug(TSgDrawableId& aId)

 	{

 	if(iContent)

 		{

 		iContent->SetMode(CEglContent::EAsyncDebug);

 		return iContent->GetImage(aId);

 		}

 	return -1;

 	}

 /**

 1st phase constructor

 */

 CEglContentSession::CEglContentSession()

 	{

 	}

 /**

 2nd phase construct for sessions - called by the CServer framework

 */

 void CEglContentSession::Create()

 	{

 	Server().AddSession();

 	}

 /**

 Destructor.

 */

 CEglContentSession::~CEglContentSession()

 	{

 	Server().DropSession();

 	}

 /**

 Get server object.

 @return a reference to server object

 */

 CEglContentServer& CEglContentSession::Server()

 	{

 	return *static_cast<CEglContentServer*>(const_cast<CServer2*>(CSession2::Server()));

 	}

 /**

 Handle a client request.

 Leaving is handled by CEglContentSession::ServiceError() which reports

 the error code to the client

 */

 void CEglContentSession::ServiceL(const RMessage2& aMessage)

 	{

 	switch(aMessage.Function())

 		{

 		case ETerminateServer:

 			{

 			aMessage.Complete(KErrNone);

 			CActiveScheduler::Stop();

 			break;

 			}

 		case EGetSyncImage:

 			{

 			// Get the current image synchronously, the frame

 			// number is not returned as the client will already know the frame number

 			// as it controls when a frame is drawn

 			TSgDrawableId id;

 			Server().GetSyncImage(id);

 			TPckg<TSgDrawableId> idPckg(id);

 			aMessage.Write(0, idPckg);

 			aMessage.Complete(KErrNone);

 			break;

 			}

 		case EGetAsyncImage:

 			{

 			// Get the current image and it's frame number, the drawing is

 			// asynchronous so the client needs to know which one this as it cannot tell otherwise

 			TSgDrawableId id;

 			TInt fnum = Server().GetAsyncImage(id);

 			TPckg<TSgDrawableId> idPckg(id);

 			aMessage.Write(0, idPckg);

 			TPckg<TInt> fnumPckg(fnum);

 			aMessage.Write(1, fnumPckg);

 			aMessage.Complete(KErrNone);

 			break;

 			}

 		case EGetAsyncImageDebug:

 			{

 			// Get the current image and it's frame number, the drawing is

 			// asynchronous so the client needs to know which one this as it cannot tell otherwise

 			TSgDrawableId id;

 			TInt fnum = Server().GetAsyncImageDebug(id);			

 			TPckg<TSgDrawableId> idPckg(id);

 			aMessage.Write(0, idPckg);

 			TPckg<TInt> fnumPckg(fnum);

 			aMessage.Write(1, fnumPckg);

 			aMessage.Complete(KErrNone);

 			break;

 			}

 		default:

 			{

 			PanicClient(aMessage, EPanicIllegalFunction);

 			}

 		}

 	}

 /**

 Handle an error from CEglContentSession::ServiceL()

 */

 void CEglContentSession::ServiceError(const RMessage2& aMessage, TInt aError)

 	{

 	if(aError == KErrBadDescriptor)

 		PanicClient(aMessage, EPanicBadDescriptor);

 	CSession2::ServiceError(aMessage, aError);

 	}

 /**

 RMessage::Panic() also completes the message.

 */

 void PanicClient(const RMessagePtr2& aMessage, TEglContentPanic aPanic)

 	{

 	aMessage.Panic(KEglContentServerName, aPanic);

 	}

 /**

 Perform all server initialisation, in particular creation of the

 scheduler and server and then run the scheduler

 */

 static void RunServerL()

 	{

 	// naming the server thread after the server helps to debug panics

 	User::LeaveIfError(RThread::RenameMe(KEglContentServerName));

 	//

 	// create and install the active scheduler we need

 	CActiveScheduler* s = new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(s);

 	CActiveScheduler::Install(s);

 	//

 	// create the server (leave it on the cleanup stack)

 	CEglContentServer::NewLC();

 	//

 	// Initialisation complete, now signal the client

 	RProcess::Rendezvous(KErrNone);

 	//

 	// Ready to run

 	CActiveScheduler::Start();

 	//

 	// Cleanup the server and scheduler

 	CleanupStack::PopAndDestroy(2);

 	}

 /**

 Entry point of server executable.

 */

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

 	RDebug::Print(_L("%S started"), &KEglContentServerName);

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TInt r = KErrNoMemory;

 	if(cleanup)

 		{

 		TRAP(r, RunServerL());

 		delete cleanup;

 		}

 	RDebug::Print(_L("%S terminated"), &KEglContentServerName);

 	__UHEAP_MARKEND;

 	return r;

 	}