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

#include <hal.h>

_LIT(KPerformanceTimingChunk, "PerformanceTimingChunk");

// Number of iterations for eventset

const TInt KNumOfIterations = 100;

// Maximum descriptor length for results

const TInt KMaxDescLength = 528;

// Static variables used for synchronisation between threads

GLDEF_D TInt NumOfEventsAdded = 0;

GLDEF_D RMutex Mutex;

GLDEF_D RCondVar ConVar;

void MultiPtrPerfPanic(TInt aPanic)

	{

	User::Panic(_L("MultiPterEventHanldingPerformancePanic"), aPanic);

	}

// This function opens the chunk and adds the failure description followed by '*'

TInt CMultiPtrPerfTestControl::Failed(TPoint3D aExp3DPoint, TPoint3D aActual3DPoint, TInt aErrorCode, TInt aExpPtrNum, TInt aActPtrNum)

	{

	TInt ret = iChunk.OpenGlobal(KPerformanceTimingChunk, ETrue);

	if (ret != KErrNone)

		{

		return ret;

		}

	TUint8* desPtr = iChunk.Base() + iChunkOffset;

	TPtr8 ptrDes(desPtr, 0, KMaxDescLength);

	TBuf<80> buf;

	if (aExpPtrNum != aActPtrNum)

		{

		_LIT(KFailedPointerNum, "Failed Expected Pointer Num = %d Actual Pointer Num = %d*");

		buf.AppendFormat(KFailedPointerNum, aExpPtrNum, aActPtrNum);

		ptrDes.Append(buf);

		} 

	else if (aErrorCode != KErrNone)

		{

		_LIT(KFailedErrorCode, "Failed Errorcode = %d*");

		buf.AppendFormat(KFailedErrorCode, aErrorCode);

		ptrDes.Append(buf);

		}

	else

		{

		_LIT(KFailedWrongCoord, "Failed Coordinates Expected = [%d, %d, %d] Actual = [%d, %d, %d]*");

		buf.AppendFormat(KFailedWrongCoord, aExp3DPoint.iX, aExp3DPoint.iY, aExp3DPoint.iZ, aActual3DPoint.iX, aActual3DPoint.iY, aActual3DPoint.iZ);

		ptrDes.Append(buf);

		}

	iChunk.Close();

	return ret;

	}

// This function opens the chunk and adds a pointer event not supported message followed by '#'

TInt CMultiPtrPerfTestControl::PointerEventsNotSupported()

    {

    iPointerEventNotSupported = ETrue;

    TInt ret = iChunk.OpenGlobal(KPerformanceTimingChunk, ETrue);

        if (ret != KErrNone)

            {

            return ret;

            }

    TUint8* desPtr = iChunk.Base() + iChunkOffset;

    TPtr8 ptrDes(desPtr, 0, KMaxDescLength);

    TBuf<80> buf;

    _LIT(KPointerEventsNotSupported, "Test Skipped As Pointer Events Are Not Supported By This Configuration#");

    buf.AppendFormat(KPointerEventsNotSupported);

    ptrDes.Append(buf);

    iChunk.Close();

    return ret;

    }

// This function calulates the average latency, opens the chunk and appends

// the same in descriptor form. Then close the child thread and calls function 

// for creating new thread for events. 

// If all the events have been tested then stops the tests

// by calling active CActiveScheduler::Stop. 

TInt CMultiPtrPerfTestControl::CalculateLatencyAndStartThread()

	{

	TInt ret = KErrNone;

	switch (iPtrAppUi->TestCaseNum())

		{

		case 1:

		case 5:

		case 9:

		case 13:	

			iAverageLatency = iLatency/(4*KNumOfIterations);

			break;

		case 2:

		case 6:

		case 10:

		case 14:

			iAverageLatency = iLatency/(8*KNumOfIterations);

			break;

		case 3:

		case 7:

		case 11:

		case 15:

			iAverageLatency = iLatency/(16*KNumOfIterations);

			break;

		case 4:

		case 8:

		case 12:

		case 16:

			iAverageLatency = iLatency/(32*KNumOfIterations);

			break;

		default:

			MultiPtrPerfPanic(EMultiPtrPerfPanicWrongTest);

		}

	ret = iChunk.OpenGlobal(KPerformanceTimingChunk, ETrue);

	if (ret != KErrNone)

		{

		return ret;

		}

	TUint8* desPtr = iChunk.Base() + iChunkOffset;

	TPtr8 ptrDes(desPtr, iLatLenInLetters, KMaxDescLength);

	TBuf<66> buf;

	buf.Num(iAverageLatency);

	buf.Append(',');

	ptrDes.Append(buf);

	// reset the iLatency for next set of test

	iLatency = 0;	

	// For writing the next latency in chunk memory

	iLatLenInLetters = ptrDes.Length();

	iChunk.Close();

	// Before calling the thread Function close the current thread and then call the function

	// here when we kill the child thread it releases both mutex and condvar that it holds

	iPtrAppUi->ChildThread().Kill(KErrNone);

	iPtrAppUi->ChildThread().Close();

	if (iPtrAppUi->TestCaseNum() == 16)

		{

		// It it is the last test case then stop the active scheduler

		CActiveScheduler::Stop();

		return ret;

		}

	else

		{

		return iPtrAppUi->CreateEventSimulatingThreads();

		}

	}

// This function is called by Cone whenever a event is outstanding

// Here we check if the sent event is same as the expected event in array.

// Then resumes the thread for next set of events. When all the events are completed

// calls CalculateLatencyAndStartThread

void CMultiPtrPerfTestControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

    ASSERT(!iPointerEventNotSupported);

	// The event that is received is (0,0,0) then it is the first event that the test code is sending

	const TAdvancedPointerEvent* advancedPointerEvent = aPointerEvent.AdvancedPointerEvent();

	if (iPtrAppUi->TestCaseNum() == 0)

		{

		if (advancedPointerEvent->PointerNumber() == 0 && advancedPointerEvent->Position3D() == TPoint3D())

			{

			iPtrAppUi->CreateEventSimulatingThreads();

			return;

			}

		else

			{

			return;	// ignore other events before starting the tests

			}

		}

	// Get the current time.

	// Subtract from the test start time.

	TTime currentTime;

	currentTime.UniversalTime();

	TInt64 curTime64 = currentTime.Int64();

	TInt timeSinceTestStart = curTime64 - iPtrAppUi->TestStartTime();

	// Get the event, get the time stored in Z corodinate

	// Then subtract the calculated time from Z coordinate

	iLatency += timeSinceTestStart - advancedPointerEvent->ProximityAndPressure(); 

	// Get the current event from buffer and compare it with got event

	TAdvancedPointerEvent expectedPtrEvent;

	if(0 == iEventBuffer.Remove(&expectedPtrEvent))

		{

		iPtrAppUi->Failed(TPoint3D(), TPoint3D(), KErrNotFound);

		return;

		}

	// Here Z corodinate is not checked.

	if (expectedPtrEvent.iPosition != advancedPointerEvent->iPosition)

		{

		iPtrAppUi->Failed(expectedPtrEvent.Position3D(), advancedPointerEvent->Position3D(), KErrNone);

		return;

		}

	if (expectedPtrEvent.PointerNumber() != advancedPointerEvent->PointerNumber())

		{

		iPtrAppUi->Failed(TPoint3D(), TPoint3D(), KErrNone, expectedPtrEvent.PointerNumber(), advancedPointerEvent->PointerNumber());

		return;

		}

	iPtrAppUi->DecrementEventCount();

	NumOfEventsAdded--;

	// Event count is zero when all the events have been tested

	if (iPtrAppUi->EventCount() == 0)

		{

		TInt ret = CalculateLatencyAndStartThread(); 

		if (ret != KErrNone)

			{

			iPtrAppUi->Failed(TPoint3D(), TPoint3D(), ret);

			return;

			}

		}

	else if (NumOfEventsAdded == 0) 

		{

		ConVar.Signal();

		}

	}

void CMultiPtrPerfTestControl::AddExpectedEvent(TAdvancedPointerEvent& aExpEvent)

	{

	iEventBuffer.Add(&aExpEvent);

	}

CMultiPtrPerfTestControl::~CMultiPtrPerfTestControl()

	{

	iChunk.Close();

	}

void CMultiPtrPerfTestControl::ConstructL()

	{

    iPointerEventNotSupported = EFalse;

	ConstructL(TPoint(), ControlEnv()->ScreenDevice()->SizeInPixels());

	}

void CMultiPtrPerfTestControl::ConstructL(TPoint aOrigin, TSize aSize)

	{

    iEventBuffer.SetLengthL(EEventBufferSize);

    iPtrAppUi = static_cast<CMultiPtrPerfTestAppUi*>(ControlEnv()->AppUi());

    CreateWindowL();

    Window().EnableAdvancedPointers();

    EnableDragEvents();

    SetExtent(aOrigin, aSize);

    ActivateL();

 	// Get the cmdline argument of this process in descriptor

 	// convert the descriptor to number and store it in iChunkOffset

 	TBuf<128> buf;

 	User::CommandLine(buf);

 	TLex lex(buf);

 	User::LeaveIfError(lex.Val(iChunkOffset));

	}

// This function gets the current time and subtracts it from the time when the whole test was started.

// Simulates the event and suspends the thread if aWaitAfterEachEvent is ETrue

// If aWaitAfterEachEvent is EFalse then it suspends the thread after each set of event i,e after 4, 8, 16 and 32 events 

void SimulatePointerEvents(TInt aCount, CMultiPtrPerfTestAppUi* appUi, TBool aMultiPtrEvent = EFalse, TBool aWaitAfterEachEvent = ETrue)

	{

	TRawEvent rawEvent;

	TPoint ptrPos;

	TTime currentTime;

	TInt64 testStartTime = appUi->TestStartTime();

	TInt ptrNum = 0;

	TInt ptrMax = 0;

	// HAL as already been tested at the start of these tests. So no need to test once again

	HAL::Get(HALData::EPointerNumberOfPointers, ptrMax);

	appUi->SetNumberOfEvents((KNumOfIterations*aCount)-1);

	// For testing time taken for each event and for each set of events we make use of RMutex and RConvar.

	// RMutex is used not to preempt this thread until events has been added

	// RConVar is used to hold this thread until the events have been tested

	for (TInt loop = 0; loop < KNumOfIterations; loop++)

		{

		ptrNum = 0;

		ptrPos.iX = ptrPos.iY = 0;

		Mutex.Wait();

		for (TInt count = 0; count < aCount/2; count++, ptrNum++)

			{

			if (ptrNum >= ptrMax)

				{

				ptrNum = 0;

				}			

			ptrPos.iX += 2;

			ptrPos.iY += 1;

			TWsEvent event;

			event.InitAdvancedPointerEvent(TPointerEvent::EButton1Down, 0, TPoint3D(ptrPos.iX, ptrPos.iY, 0), (aMultiPtrEvent ? ptrNum : 0));

			appUi->AddExpectedEvent(*event.Pointer());

			currentTime.UniversalTime();

			TInt64 curTime64 = currentTime.Int64();

			TInt timeSinceTestStart = curTime64 - testStartTime;

			rawEvent.Set(TRawEvent::EButton1Down, ptrPos.iX, ptrPos.iY, timeSinceTestStart, (aMultiPtrEvent ? ptrNum : 0));

			UserSvr::AddEvent(rawEvent);

			NumOfEventsAdded++;

			if (aWaitAfterEachEvent)

				{

				while(NumOfEventsAdded)

					ConVar.Wait(Mutex);

				}

			event.InitAdvancedPointerEvent(TPointerEvent::EButton1Up, 0, TPoint3D(ptrPos.iX, ptrPos.iY, 0), (aMultiPtrEvent ? ptrNum : 0));

			appUi->AddExpectedEvent(*event.Pointer());

			currentTime.UniversalTime();

			curTime64 = currentTime.Int64();

			timeSinceTestStart = curTime64 - testStartTime;

			rawEvent.Set(TRawEvent::EButton1Up, ptrPos.iX, ptrPos.iY, timeSinceTestStart, (aMultiPtrEvent ? ptrNum : 0));

			UserSvr::AddEvent(rawEvent);

			NumOfEventsAdded++;

			if (aWaitAfterEachEvent)

				{

				while(NumOfEventsAdded)

					ConVar.Wait(Mutex);

				}

			}

		if (!aWaitAfterEachEvent)

			{

			while(NumOfEventsAdded)

				ConVar.Wait(Mutex);

			}

		Mutex.Signal();

		}

	}

TInt EventSimulatingThreadStartFunc(TAny* aAny)

	{

	CMultiPtrPerfTestAppUi* appUi = static_cast<CMultiPtrPerfTestAppUi*>(aAny);

	switch(appUi->TestCaseNum()++)

		{

		case 0:

			SimulatePointerEvents(4, appUi);

			break;

		case 1:

			SimulatePointerEvents(8, appUi);

			break;

		case 2:

			SimulatePointerEvents(16, appUi);

			break;

		case 3:

			SimulatePointerEvents(32, appUi);

			break;

		case 4:

			SimulatePointerEvents(4, appUi, ETrue);

			break;

		case 5:

			SimulatePointerEvents(8, appUi, ETrue);

			break;

		case 6:

			SimulatePointerEvents(16, appUi, ETrue);

			break;

		case 7:

			SimulatePointerEvents(32, appUi, ETrue);

			break;

		case 8:

			SimulatePointerEvents(4, appUi, EFalse, EFalse);

			break;

		case 9:

			SimulatePointerEvents(8, appUi, EFalse, EFalse);

			break;

		case 10:

			SimulatePointerEvents(16, appUi, EFalse, EFalse);

			break;

		case 11:

			SimulatePointerEvents(32, appUi, EFalse, EFalse);

			break;

		case 12:

			SimulatePointerEvents(4, appUi, ETrue, EFalse);

			break;

		case 13:

			SimulatePointerEvents(8, appUi, ETrue, EFalse);

			break;

		case 14:

			SimulatePointerEvents(16, appUi, ETrue, EFalse);

			break;

		case 15:

			SimulatePointerEvents(32, appUi, ETrue, EFalse);

			break;		

		default:

			break;

		}

	return KErrNone;

	}

TInt CMultiPtrPerfTestAppUi::CreateEventSimulatingThreads()

	{

	// Depending upon the iTestCase number create thread and simulate events in that thread function

	TInt ret = KErrNone;

	_LIT(KSimulateEventsThread, "Events simulating thread");

	ret = iThread.Create(KSimulateEventsThread, EventSimulatingThreadStartFunc, KDefaultStackSize, 0x4000, 0x4000, this, EOwnerThread);

	if (ret == KErrNone)

		{

		iThread.Resume();

		}

	return ret;

	}

void CMultiPtrPerfTestAppUi::AddExpectedEvent(TAdvancedPointerEvent& aExpEvent)

	{

	iControl->AddExpectedEvent(aExpEvent);

	}

void CMultiPtrPerfTestAppUi::Failed(TPoint3D aExp3DPoint, TPoint3D aActual3DPoint, TInt aErrorCode, TInt aExpPtrNum, TInt aActPtrNum)

	{

	// Write error description in the memory of shared chunk 

	// so that the main performance test just stops by saying that it failed

	// and then stop the active scheduler.

	iControl->Failed(aExp3DPoint, aActual3DPoint, aErrorCode, aExpPtrNum, aActPtrNum);

	CActiveScheduler::Stop();

	}

void CMultiPtrPerfTestAppUi::PointerEventsNotSupported()

    {

    // Write a pointer events not supported message in the memory of shared chunk 

    // so that the main performance test just skips the pointer test

    iControl->PointerEventsNotSupported();

    }

CMultiPtrPerfTestAppUi::CMultiPtrPerfTestAppUi()

	{

	}

CMultiPtrPerfTestAppUi::~CMultiPtrPerfTestAppUi()

	{

	RemoveFromStack(iControl);

	delete iControl;

	}

void CMultiPtrPerfTestAppUi::ConstructL()

	{

	CCoeAppUi::ConstructL();

	TTime testStartTime;

	testStartTime.UniversalTime();

	iTestStartTime = testStartTime.Int64();

	iControl = new (ELeave) CMultiPtrPerfTestControl();

	iControl->ConstructL();

	AddToStackL(iControl);

	}

void ConstructControlEnvironmentL(CCoeEnv* aCoe)

	{

 	aCoe->ConstructL();

 	CMultiPtrPerfTestAppUi* appUi=new(ELeave) CMultiPtrPerfTestAppUi();

 	CleanupStack::PushL(appUi);			// If it leaves after this then there is no way of deleting the appui

 	aCoe->SetAppUi(appUi);				// So pushed it on to cleanup stack

 	aCoe->WsSession().SetAutoFlush(ETrue);

 	appUi->ConstructL();

 	User::LeaveIfError(Mutex.CreateLocal(EOwnerProcess));

 	User::LeaveIfError(ConVar.CreateLocal(EOwnerProcess));

 	CleanupStack::Pop(appUi);

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CCoeEnv* coe = new CCoeEnv;

	if (!coe)

		{

		return KErrNoMemory; 

		}

	TRAPD(err, ConstructControlEnvironmentL(coe));

	if (err != KErrNone)

		{

		delete coe;

		}

	else	// If KErrNone then no need to delte coe as it is taken care by ConEnv

		{

        // Check whether the configuration supports pointer events.

        // If it dosn't support pointer events then the pointer cursor area will be empty,

        // in this case skip the test and inform the test framework that the test has been skipped

        TRect pointerCursorArea = coe->WsSession().PointerCursorArea();

        if(pointerCursorArea.IsEmpty())

            {

            RDebug::Printf("PointerCursorArea is Empty");

            CMultiPtrPerfTestAppUi* appUi = static_cast<CMultiPtrPerfTestAppUi*>(coe->AppUi());

            appUi->PointerEventsNotSupported();

            }

        else

            {

            // First event which starts the test from HandlePointerEventL

            TRawEvent rawEvent;

            rawEvent.Set(TRawEvent::EButton1Down, 0, 0, 0, 0);

            UserSvr::AddEvent(rawEvent);

            coe->ExecuteD();

            }

		Mutex.Close();

		ConVar.Close();

	 	}

	__UHEAP_MARKEND;

	return err;

	}