// Copyright (c) 2006-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 "surfaceupdateserver.h"

#include <graphics/compositionsurfaceupdate.h>

#include <graphics/extensioncontainer.h>

#include "surfaceupdate.h"

#include "suerror.h"

#ifdef TEST_SURFACE_UPDATE

#include "surfaceupdatetest.h"

#endif

const TUint KDefaultHeapSize=0x10000;

/**

The server maintains session with the clients. 

It starts during the initialization of the Content update receiver thread.  

*/

CSurfaceUpdateServer* CSurfaceUpdateServer::NewL()

	{

	CSurfaceUpdateServer* server = new (ELeave) CSurfaceUpdateServer(EPriorityStandard);

	CleanupStack::PushL(server);

	server->ConstructL();

	CleanupStack::Pop();

	return server;	

	}

CSurfaceUpdateServer::CSurfaceUpdateServer(CActive::TPriority aPriority) :

	CServer2(aPriority)

	{

	}

CSurfaceUpdateServer::~CSurfaceUpdateServer()

	{

	iUpdateReceiver.Close();

	iUpdateReceiverPriorityOrder.ResetAndDestroy();

	delete iServerProvider;

	}	

void CSurfaceUpdateServer::ConstructL()

	{

	iServerProvider = CSurfaceUpdateServerProvider::NewL(EPriorityStandard, this);

	}

/**

Assign Content update receiver instance to particular screen. 

The following calls of this function will override the previous. 

@see MSurfaceUpdateServerProvider::Register

*/	

TInt CSurfaceUpdateServer::Register(TInt aScreen, CBase* aUpdateReceiver, TInt aPriority)

	{

	if(aScreen < 0)

		{

		return KErrArgument;

		}

	TInt err = KErrNone;

	while((iUpdateReceiver.Count() <= aScreen) && (err == KErrNone))

		{

		err = iUpdateReceiver.Append(NULL);

		}

	if(err == KErrNone)

		{

		TUpdateReceiverPriorityEntry *receiverPriorityEntry = NULL; 

		if(!aUpdateReceiver)

			{//Client wants to unregister the Content update receiver which has been associated with the given screen number.

			MCompositionSurfaceUpdate* receiver = iUpdateReceiver[aScreen];

			if(receiver)

				{

				TInt num = iUpdateReceiverPriorityOrder.Count() - 1;

				for(;;)

					{//Content update receiver must be in priority list, therefore we don't need to check num >= 0

					receiverPriorityEntry = iUpdateReceiverPriorityOrder[num];

					if(receiverPriorityEntry->iUpdateReceiver == receiver)

						{//remove the Content update receiver from the priority list

						iUpdateReceiverPriorityOrder.Remove(num);

						delete receiverPriorityEntry;

						break;

						}

					num--;

					}

				iUpdateReceiver[aScreen] = NULL; //unregister the Content update receiver by setting the entry to NULL

				}

			}

		else

			{

	        CExtensionContainer* extCont=static_cast<CExtensionContainer*>(aUpdateReceiver);

	        MCompositionSurfaceUpdate* updateReceiver=extCont->GetInterface<MCompositionSurfaceUpdate>();

	        if (updateReceiver)

	            {

                receiverPriorityEntry = new TUpdateReceiverPriorityEntry;

                if(!receiverPriorityEntry)

                    return KErrNoMemory;

                receiverPriorityEntry->iPriority = aPriority;

                receiverPriorityEntry->iUpdateReceiver = updateReceiver;

                err = iUpdateReceiverPriorityOrder.InsertInOrder(receiverPriorityEntry, CSurfaceUpdateServer::CompareUpdateReceiverPriority);

                if(err == KErrNone)

                    {

                    iUpdateReceiver[aScreen] = updateReceiver;

                    }

                else

                    {

                    delete receiverPriorityEntry;

                    }

	            }

	        else

	            {

	            err=KErrArgument;

	            }

			}	

		}

	return err;

	}

/**

Create a new session with a server. Derived from CSession2.

@param aVersion required version of the server

@param aMessage message from the client.

@return New instance of the CSurfaceUpdateSession.

*/

CSession2* CSurfaceUpdateServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

	{

      // Check that the version is OK

	TVersion v(KSurfaceUpdateServMajorVersionNumber,KSurfaceUpdateServMinorVersionNumber,KSurfaceUpdateServBuildVersionNumber);

	if (!User::QueryVersionSupported(v,aVersion))

		User::Leave(KErrNotSupported);	

	// Security is not an issue, any client can have connection to the server	

	// Create the session.

	return new (ELeave) CSurfaceUpdateSession(UpdateReceiverPriority());

	}

/**

Utility function to panic the server

@param aPanic Panic code

*/

void CSurfaceUpdateServer::PanicServer(TSurfaceUpdateServPanic aPanic)

	{

	_LIT(KTxtServerPanic,"Surface Update Server panic");

	User::Panic(KTxtServerPanic, aPanic);

	}

/**

Provide composition receiver.

@param aScreen targeted screen

@return Composition receiver object, associated to particular screen

*/

MCompositionSurfaceUpdate* CSurfaceUpdateServer::UpdateReceiver(TInt aScreen) const

	{

	if(aScreen >= iUpdateReceiver.Count())//negative value won't reach this point 

		return NULL;

	return iUpdateReceiver[aScreen];	

	}

TInt CSurfaceUpdateServer::ThreadFunction(TAny* aAny)

	{

	  // get clean-up stack

	CTrapCleanup* cleanup=CTrapCleanup::New();

	__ASSERT_ALWAYS(cleanup!=NULL, CSurfaceUpdateServer::PanicServer(EUpdateServPanicNoMemory));

	  // create an active scheduler and server

	CActiveScheduler *pA = new CActiveScheduler;

	__ASSERT_ALWAYS(pA != NULL, CSurfaceUpdateServer::PanicServer(EUpdateServPanicNoMemory));

	  //Install the active scheduler

	CActiveScheduler::Install(pA);

	CSurfaceUpdateServer *pS = NULL;

	TRAPD(err, pS = CSurfaceUpdateServer::NewL());

	__ASSERT_ALWAYS(err == KErrNone, CSurfaceUpdateServer::PanicServer(EUpdateServPanicNoMemory));

	  // Start the server

#ifndef TEST_SURFACE_UPDATE

	err = pS->Start(KSurfaceUpdateServerName);

#else

	err = pS->Start(KTestSurfaceUpdateServerName);

#endif

	if (err != KErrNone)

		{

		CSurfaceUpdateServer::PanicServer(EUpdateServPanicStartUp);

		}

	*(static_cast <MSurfaceUpdateServerProvider**> (aAny)) = pS->SurfaceUpdateProvider();

      // Let everyone know that we are ready to

      // deal with requests.

	RThread::Rendezvous(KErrNone);

	  // And start fielding requests from client(s).

	CActiveScheduler::Start();

     // Tidy up... 	

	delete pS;

	delete pA;

	delete cleanup; 

	return KErrNone;

	}

inline TInt CSurfaceUpdateServer::NumUpdateReceivers() const

	{

	return iUpdateReceiver.Count(); 

	}

/**

Compare two content update receiver entries according to their priority. 

The function is used when receiver priority entry is inserted/retrieved from the array (iCompReceiverPriorityOrder).

@return zero, if the priorities of two receivers are equal; 

a negative value, if the priority of the first receiver is less than the priority of the second one; 

a positive value, if the priority of the first receiver is greater than the priority of the second one.

*/

TInt CSurfaceUpdateServer::CompareUpdateReceiverPriority(const TUpdateReceiverPriorityEntry& aEntry1, const TUpdateReceiverPriorityEntry& aEntry2)

	{

	return aEntry2.iPriority - aEntry1.iPriority;

	}

/**

class CSurfaceUpdateSession

Maintain the channel between clients and the server. 

Functions are provided will respond appropriately to client messages. 

*/

CSurfaceUpdateSession::CSurfaceUpdateSession(const RPointerArray<TUpdateReceiverPriorityEntry>& aEntryList) :

	CSession2(),

	iUpdateReceiverEntryList(aEntryList)

	{

	}

/**

Cancel any outstanding client notification requests. 

All resources owned by the session will either be immediately released or 

scheduled for deferred deletion.

*/

CSurfaceUpdateSession::~CSurfaceUpdateSession()

	{

	CancelAllUpdateNotifications();

	iUpdateReceiverNotificationBatches.ResetAndDestroy();

	}

/**

Main function which deals with requests from clients.

*/	

void CSurfaceUpdateSession::ServiceL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

	case EUpdateServNotifyWhenAvailable:

		NotifyWhenAvailable(aMessage);

		return;

	case EUpdateServNotifyWhenDisplayed:

		NotifyWhenDisplayed(aMessage);

		return;

	case EUpdateServNotifyWhenDisplayedXTimes:

		NotifyWhenDisplayedXTimes(aMessage);

		return;

	case EUpdateServSubmitUpdate:

		SubmitUpdate(aMessage);

		return;

	case EUpdateServCancelAllNotifications:

		CancelAllUpdateNotifications();

		aMessage.Complete(KErrNone);

		return;

#ifdef TEST_SURFACE_UPDATE

	case EUpdateServOOM:

		{

		SetHeapFailure(aMessage);

		return;

		}

#endif

	default:

		PanicClient(aMessage, EUpdateServPanicBadRequest);

		return;

		}	 

	}

#ifdef TEST_SURFACE_UPDATE

/**

  Simulate heap allocation failure for the SUS thread's heap.

  Aim for OOM testing.

 */

void CSurfaceUpdateSession::SetHeapFailure(const RMessage2& aMessage)

	{

	TInt numElement = iUpdateReceiverNotificationBatches.Count();

	TInt index = 0;

	while(numElement)

		{

		CUpdateReceiverNotificationBatch* batch = iUpdateReceiverNotificationBatches[index];

		if(batch->iType == EUpdateSrvReusable)

			{

			iUpdateReceiverNotificationBatches.Remove(index);

			delete batch;

			}

		else

			{

			index++;

			}

		numElement--;            

		}

	if(numElement == 0)

		{

		iUpdateReceiverNotificationBatches.Reset();

		}

	TInt failRate = aMessage.Int0();

	if(!failRate)

		{

		__UHEAP_RESET;

		}

	else

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic, failRate);

		}

	aMessage.Complete(KErrNone);

	}

#endif

void CSurfaceUpdateSession::PanicClient(const RMessage2& aMessage, TInt aPanic) const

	{

	_LIT(KTxtServer,"SurfUpServ");

	aMessage.Panic(KTxtServer, aPanic);

	}

/**

Return first inactive spare notification object stored in the notification array, 

create a new one if fail to find it in the array.

*/	

CUpdateReceiverNotificationBatch* CSurfaceUpdateSession::UpdateReceiverNotificationBatchL()

	{

	TInt numElement = iUpdateReceiverNotificationBatches.Count();

	CUpdateReceiverNotificationBatch* notifier = NULL;

	for(TInt index = 0; index < numElement; index++)

		{

		notifier = iUpdateReceiverNotificationBatches[index];

		if(notifier->iType == EUpdateSrvReusable)

			{

			__ASSERT_ALWAYS(notifier->iMsg.IsNull(), CSurfaceUpdateServer::PanicServer(EUpdateServPanicDataIntegrity));

			if(numElement > index + 1)

				{

			//to improve a search, append the element to the end of the array

				iUpdateReceiverNotificationBatches.Remove(index);

				iUpdateReceiverNotificationBatches.AppendL(notifier);

				}

			return notifier;

			}

		}

	CSurfaceUpdateServer* server = (CSurfaceUpdateServer*) Server();

	notifier = new (ELeave) CUpdateReceiverNotificationBatch(this, server->NumUpdateReceivers());

	CleanupStack::PushL(notifier);

	iUpdateReceiverNotificationBatches.AppendL(notifier);

	CleanupStack::Pop();

	return notifier;

	}

void CSurfaceUpdateSession::NotifyWhenAvailable(const RMessage2& aMessage)

	{

	StoreNotification(iAvailable, aMessage, EUpdateSrvAvailable);

	}

void CSurfaceUpdateSession::NotifyWhenDisplayed(const RMessage2& aMessage)

	{

	StoreNotification(iDisplayed, aMessage, EUpdateSrvDisplayed);

	}

void CSurfaceUpdateSession::NotifyWhenDisplayedXTimes(const RMessage2& aMessage)

	{

	StoreNotification(iDisplayedXTimes, aMessage, EUpdateSrvDisplayedXTimes);

	}

void CSurfaceUpdateSession::StoreNotification(CUpdateReceiverNotificationBatch*& aNotifier, const RMessage2& aMessage, TNotificationType aType)

	{

	if(aNotifier)

		{

		if(!aNotifier->iMsg.IsNull())

			{//not expected behaviour

			//would happen if a client sends the same notification request in a row

			IssueRequestComplete(KErrCancel);

			PanicClient(aMessage, EUpdateServPanicDataIntegrity);

			return;

			}

		}

	else

		{

		TRAPD(res, aNotifier = UpdateReceiverNotificationBatchL());

		if(res != KErrNone)

			{

			aMessage.Complete(res);

			return;

			}

		}	

	aNotifier->iMsg = aMessage;

	aNotifier->iType=aType;

	}

/*

Complete the outstanding requests and reset internal request variables to zero.

@param aErr Error code for completion.   

*/ 	

void CSurfaceUpdateSession::IssueRequestComplete(TInt aErr)

	{

	if(iAvailable)

		{

		if(!iAvailable->iMsg.IsNull())

			{

			iAvailable-> iMsg.Complete(aErr);

			iAvailable->CheckForReuse();	 

			}

		iAvailable = NULL;

		}

	if(iDisplayed)

		{

		if(!iDisplayed -> iMsg.IsNull())

			{

			iDisplayed -> iMsg.Complete(aErr);

			iDisplayed->CheckForReuse();

			}

		iDisplayed = NULL;

		}

	if(iDisplayedXTimes)

		{

		if(!iDisplayedXTimes->iMsg.IsNull())

			{

			iDisplayedXTimes->iMsg.Complete(aErr);

			iDisplayedXTimes->CheckForReuse();

			}

		iDisplayedXTimes=NULL;

		}

	}

/**

Redirect call to the DoSubmitUpdateL; error handling

*/

void CSurfaceUpdateSession::SubmitUpdate(const RMessage2& aMessage)

	{

	TInt err = KErrNone;

	TRAP(err, DoSubmitUpdateL(aMessage));

	if(err != KErrNone)

		{

		IssueRequestComplete(err);

		}

	aMessage.Complete(err);	

	}

/**

Issue request for the update to the composition receiver; 

ask notification on composition event if required.

*/	

void CSurfaceUpdateSession::DoSubmitUpdateL(const RMessage2& aMessage)

	{

	TInt displayedXTimes = 0;

	TInt screen;

	TInt buffer;

	TSurfaceId surfaceId;

	TPckg<TSurfaceId> surfaceIdPckg(surfaceId);

	RRegion *region = NULL;

	TRect *rectangleList = NULL;

	//extract the composition data

	aMessage.ReadL(1, surfaceIdPckg);

	screen = aMessage.Int0();

	buffer = aMessage.Int2();

	//validate parameters

	if((screen < 0) || (buffer < 0))

		{

		User::Leave(KErrArgument);

		}

	//Check that we haven't used another update method before

	//The comparison is slightly optimized for performance as oppose to code size

	if(iUpdateMethod == EUpdateMethodGlobal) 

		{

		if(screen != KAllScreens)

			User::Leave(KErrNotSupported);

		}

	else if(iUpdateMethod == EUpdateMethodPerScreen) 

		{

		if(screen == KAllScreens)

			User::Leave(KErrNotSupported);

		}

	TInt len = aMessage.GetDesLength(3);

	if(len > 0)

		{

		rectangleList = (TRect*) (User::AllocL(len));

		CleanupStack::PushL(rectangleList);

		TPtr8 ptrRect(reinterpret_cast<TUint8*> (rectangleList), len);

		aMessage.ReadL(3, ptrRect);

		TInt regionCount = len / sizeof(TRect);

		region = new (ELeave) RRegion(regionCount, rectangleList);

		CleanupStack::PushL(region);

		}

	if(iDisplayedXTimes)

		{

		displayedXTimes = iDisplayedXTimes -> iMsg.Int0();

		if(displayedXTimes < 1)

			{

			iDisplayedXTimes->iMsg.Complete(KErrArgument);

			iDisplayedXTimes->CheckForReuse();

			iDisplayedXTimes = NULL;