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

	}