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

 //

 /**

  @file

  @test

  @internalComponent - Internal Symbian test code 

 */

 #include <e32std.h>

 #include "tcompositionbackend.h"

 #include <graphics/suerror.h>

 const TInt KNotificationsAtTime = 10; //how many notifications could be processed at a time, varies from 1...

 CTContentUpdateReceiver::CTContentUpdateReceiver(TInt aScreen) :

 	iScreen(aScreen), iVisible(ETrue)

 	{

 	RThread thread;

 	iReceiverThreadId = thread.Id();

 	}

 CTContentUpdateReceiver::~CTContentUpdateReceiver()

 	{

 	if(iPeriodic)

 		iPeriodic->Cancel();

 	delete iPeriodic;

 	iLock.Close();

 	iPriorityLock.Close();

 	}

 void CTContentUpdateReceiver::ConstructL()

 	{

 	TCallBack callback(CallBack);

 	callback.iPtr = this;

 	User::LeaveIfError(iLock.CreateLocal());

 	User::LeaveIfError(iPriorityLock.CreateLocal(0));

     iPeriodic= CPeriodic::NewL(CPeriodic::EPriorityStandard);

     iPeriodic->Start(TTimeIntervalMicroSeconds32(0),TTimeIntervalMicroSeconds32(KCompositionInterval), callback);

 	}

 CTContentUpdateReceiver* CTContentUpdateReceiver::NewL(TInt aScreen)

 	{

 	CTContentUpdateReceiver* receiver = new (ELeave) CTContentUpdateReceiver(aScreen);

 	CleanupStack::PushL(receiver);

 	receiver->ConstructL();

 	CleanupStack::Pop();

 	return receiver;  

 	}

 TInt    CTContentUpdateReceiver::Extension_(TUint aExtensionId, TAny*& aRetIface, TAny* a1)

     {

     switch (aExtensionId)

         {

         case MCompositionSurfaceUpdate::ETypeId:

             aRetIface= static_cast<MCompositionSurfaceUpdate*>(this);

             return KErrNone;

         default:    ;

         }

     return CExtensionContainer::Extension_(aExtensionId,aRetIface,a1);

     }

 TInt CTContentUpdateReceiver::CallBack(TAny *aAny)

 	{

 	return (static_cast <CTContentUpdateReceiver*> (aAny))->CheckNewNotifications();

 	}

 void CTContentUpdateReceiver::Stop()

 	{

     iLock.Wait();

 	iStop = ETrue;

     iLock.Signal();

 	}

 EXPORT_C void CTContentUpdateReceiver::SetVisible(TBool aVisible)

     {

     iLock.Wait();

     iVisible = aVisible;

     iLock.Signal();

     }

 TInt CTContentUpdateReceiver::CheckNewNotifications()

 	{

 	iLock.Wait();

  	if(iStop && (iNumberElements <= 0))

 		{

 	    iLock.Signal();

 		CActiveScheduler::Stop();

 		return 0;//the return value is irrelevant for CPeriodic function

 		}

 	if(iSetInternalPriority)

 		{

 		TRAPD(res, DoSetInternalPriorityL());

 	    iLock.Signal();

 		__ASSERT_ALWAYS(res ==KErrNone, User::Panic(_L("CheckNewNotifications"), KErrGeneral));

 		return 0;//the return value is irrelevant for CPeriodic function

 		}	

 	TInt index = 0;	

 	RThread thread;

 	TInt res = thread.Open(iThreadId);

 	__ASSERT_ALWAYS(res ==KErrNone, User::Panic(_L("CheckNewNotifications"), KErrGeneral));

 		//we will check only one limited amount of requests at the time

 	for(TInt iteration = 0; (iNumberElements > index) && (iteration < KNotificationsAtTime); iteration++)

 		{

 		if(iArray[index].iType == EReqDisplayed)

 			{

 			*(iArray[index].iTimeStamp) = User::FastCounter();

 			if(iCompositionOrder)

 				{

 				iCompositionOrder->SetOrder(EOrderComposition);

 				}

 			}

 		else if(iArray[index].iType == EReqDisplayedXTimes)

 			{

 			iArray[index].iDisplayedXTimes--;

 			if(iArray[index].iDisplayedXTimes > 0)

 				{

 				index++;

 				continue;

 				}

 			}

 		TRequestStatus* status = iArray[index].iStatus;

 		res = iVisible ? KErrNone : KErrNotVisible;

 		Remove(index);

 		thread.RequestComplete(status, res);

 		}

 	thread.Close();	

     iLock.Signal();

 	return 0;//the return value is irrelevant for CPeriodic function

 	}

 void CTContentUpdateReceiver::DoSetInternalPriorityL()

 	{

 	RThread thread;

 	User::LeaveIfError(thread.Open(iReceiverThreadId));

 	thread.SetPriority(iInternalPriority);

 	thread.Close();

 	TInt compositionInterval = KCompositionInterval;

 	CPeriodic::TPriority priority = CPeriodic::EPriorityStandard;

 	if(iInternalPriority < EPriorityNormal)

 		{

 		priority = CPeriodic::EPriorityIdle;

 		compositionInterval = KCompositionIntervalLong;

 		}

 	else if (iInternalPriority > EPriorityNormal)

 		{

 		priority = CPeriodic::EPriorityHigh;

 		compositionInterval = KCompositionIntervalShort;

 		}

 	TCallBack callback(CallBack);

 	callback.iPtr = this;

 	iPeriodic->Cancel();

 	delete iPeriodic;

 	iPeriodic= CPeriodic::NewL(priority);

 	iPeriodic->Start(TTimeIntervalMicroSeconds32(compositionInterval),TTimeIntervalMicroSeconds32(compositionInterval), callback);

 	iSetInternalPriority = EFalse;

 	iPriorityLock.Signal();

 	}

 EXPORT_C TInt CTContentUpdateReceiver::SetInternalPriority(TThreadPriority aInternalPriority)

 	{

 	iLock.Wait();

 	iInternalPriority = aInternalPriority;

 	iSetInternalPriority = ETrue;

     iLock.Signal();

     //wait for the priority changes takes place

     iPriorityLock.Wait();

 	return KErrNone;

 	}

 void CTContentUpdateReceiver::ContentUpdated(const TSurfaceId& aId, 

 				TInt aBuffer, 

 				const TRegion* aRegion, 

 				TRequestStatus* aStatusAvailable, 

 				TRequestStatus* aStatusDisplayed, TUint32* aTimeStamp, 

 				TRequestStatus* aStatusDisplayedXTimes, TInt* aDisplayedXTimes)

 	{

 	(TAny)&aId;

 	(TAny)aBuffer;

 	(TAny)aRegion;

 	iLock.Wait();

 	if(iStop)

 		{

 		if(aStatusAvailable)

 			{

 			User::RequestComplete(aStatusAvailable, KErrDied);

 			}

 		if(aStatusDisplayed)

 			{

 			User::RequestComplete(aStatusDisplayed, KErrDied);

 			}

 		if(aStatusDisplayedXTimes)

 			{

 			User::RequestComplete(aStatusDisplayedXTimes, KErrDied);

 			}

 	    iLock.Signal();

 		return;

 		}

 	RThread thread;

 	iThreadId = thread.Id();

 	if(aStatusAvailable)

 		{

 		Add(aStatusAvailable, EReqAvailable);

 		}

 	if(aStatusDisplayed)

 		{

 		Add(aStatusDisplayed, EReqDisplayed, 0, aTimeStamp);

 		}

 	if(aStatusDisplayedXTimes)

 		{

 		Add(aStatusDisplayedXTimes, EReqDisplayedXTimes, *aDisplayedXTimes);

 		}

     iLock.Signal();

 	}

 /** 

    Add notification to the list. The function is called from the SUS thread.

    The client of this API must use a lock mechanizm to preserve data integrity.

 */

 TInt CTContentUpdateReceiver::Add(TRequestStatus *aStatus, RequestType aType, 

 			TInt aDisplayedXTimes, TUint32* aTimeStamp)

 	{

  	TInt index = iNumberElements;

 	TInt max = sizeof(iArray) / sizeof(iArray[0]) - 1;

 	if(index >= max)

 		return KErrOverflow;

 	iArray[index].iStatus = aStatus;

 	iArray[index].iType = aType;

 	iArray[index].iDisplayedXTimes = aDisplayedXTimes;

 	iArray[index].iTimeStamp = aTimeStamp;

 	iNumberElements++;

 	return KErrNone;

 	}

 /** 

    Remove notification from the list.

    The function is called from the backend thread. 

    The client of this API must use a lock mechanizm to preserve data integrity.

 */

 void CTContentUpdateReceiver::Remove(TInt aIndex) 

 	{

 	TInt max = sizeof(iArray) / sizeof(iArray[0]) - 1;

 	if((aIndex < 0) || (aIndex >= max))

 			return;

 	iNumberElements--;

 	if(aIndex < iNumberElements)

 		{

 		Mem::Move(&iArray[aIndex], &iArray[aIndex + 1], (iNumberElements - aIndex) * sizeof(RequestObject));

 		iArray[iNumberElements].iType= EReqEmpty;

 		}

 	else

 		{

 		iArray[aIndex].iType = EReqEmpty;

 		}	

 	}

 TInt CTContentUpdateReceiver::ThreadFunction(TAny* aAny)

 	{

 	  // get clean-up stack

 	CTrapCleanup* cleanup=CTrapCleanup::New();

 	RThread thread;

 	_LIT(KTestReceiver, "TestReceiver");

 	__ASSERT_ALWAYS(cleanup!=NULL, thread.Panic( KTestReceiver, KErrNoMemory));

 	  // create an active scheduler and server

 	CActiveScheduler *pA = new CActiveScheduler;

 	__ASSERT_ALWAYS(pA != NULL, thread.Panic( KTestReceiver, KErrNoMemory));

 	  //Install the active scheduler

 	CActiveScheduler::Install(pA);

 	CTContentUpdateReceiver *pCB = NULL;

 	TInt screen = * (static_cast <TInt*> (aAny));

 	TRAPD(err, pCB = CTContentUpdateReceiver::NewL(screen));

 	__ASSERT_ALWAYS(err == KErrNone, thread.Panic( KTestReceiver, err));

  	*(static_cast <CTContentUpdateReceiver**> (aAny)) = pCB;

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

 	delete pA;

 	delete cleanup; 

 	return KErrNone;

 	}

 _LIT(KMaskBackend, "CompositionBackend_%d");

 const TUint KDefaultHeapSize=0x10000;

 EXPORT_C TInt StartTestUpdateReceiver(CTContentUpdateReceiver*& aReceiver, TInt aScreen)

 	{

 	RThread compositionThread;

 	TInt res = KErrGeneral;

 	TBuf<64> contentUpdateReceiverThreadName;

 	TBuf<64> contentUpdateReceiverThreadMask;

 	// Guarantee uniqueness of thread name by using timestamp

 	TTime tm;

 	TBuf<32> timeStamp;

 	tm.UniversalTime();

 	TRAP(res, tm.FormatL(timeStamp, _L("_%H%T%S%C")));

 	if(res != KErrNone)

 		{

 		return res;

 		}

 	contentUpdateReceiverThreadName.Format(KMaskBackend, aScreen);

 	contentUpdateReceiverThreadName.Append(timeStamp);

 	contentUpdateReceiverThreadMask = contentUpdateReceiverThreadName;

 	contentUpdateReceiverThreadMask.Insert(0, _L("*"));

 	TFindThread findThread(contentUpdateReceiverThreadMask);

 	TFullName name;

 	  // Need to check that the thread exists.

 	if (findThread.Next(name)!=KErrNone)

 		{

 		aReceiver = reinterpret_cast <CTContentUpdateReceiver*> (aScreen);

 		  // Create the thread for the server.

 		res = compositionThread.Create(contentUpdateReceiverThreadName,

 			CTContentUpdateReceiver::ThreadFunction,

 			KDefaultStackSize,

 			KDefaultHeapSize,

 			KDefaultHeapSize,

 			(TAny*) &aReceiver

 			);

           // The thread has been created OK so get it started - however

           // we need to make sure that it has started before we continue.

 		if (res==KErrNone)

 			{

 			TRequestStatus rendezvousStatus;

 			compositionThread.SetPriority(EPriorityNormal);

 			compositionThread.Rendezvous(rendezvousStatus);

 			compositionThread.Resume();

 			User::WaitForRequest(rendezvousStatus);

 			res = rendezvousStatus.Int();

 			}

 		}

 		compositionThread.Close();

 		return res;

 	}

 EXPORT_C void CloseTestUpdateReceiver(CTContentUpdateReceiver* aReceiver)

 	{

 	if(!aReceiver)

 		return;

 	TBuf<64> contentUpdateReceiverThreadName;

 	contentUpdateReceiverThreadName.Format(KMaskBackend, aReceiver->Screen());

 	TBuf<64> contentUpdateReceiverThreadMask;

 	contentUpdateReceiverThreadMask = contentUpdateReceiverThreadName;

 	contentUpdateReceiverThreadMask.Insert(0, _L("*"));

 	contentUpdateReceiverThreadMask.Append('*');

 	TFindThread findThread(contentUpdateReceiverThreadMask);

 	TFullName name;

 	RThread thread;

 	if((findThread.Next(name)!=KErrNone) ||

 		(thread.Open(findThread) != KErrNone))

 		{

 		thread.Close();

 		return;

 		}

 	TRequestStatus status; 

 	thread.Logon(status);

 	if(aReceiver)

 		aReceiver->Stop();

 	User::WaitForRequest(status);

 	thread.Close();

 	}