// 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;

	}