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

//

/**

 @file

 @test

 @internalComponent

*/

#include <s32file.h>

#include <hal.h>

#include <libc/limits.h> //UINT_MAX

#include "t_pseudoappeng.h"

#include "t_pseudoapputils.h"

#include "t_wservconsts.h"

#include "t_winutils.h"

#include <graphics/suerror.h>

#include "t_pseudoappshared.h"

//

// class CTPseudoAppEng

//

CTPseudoAppEng::CTPseudoAppEng(RWsSession& aClient, CWsScreenDevice& aScreenDevice, RWindow& aWindow)

: CTimer(CActive::EPriorityStandard),

	iClient(aClient),

	iWindow(aWindow),

	iScreenDevice(aScreenDevice),

	iDrawing(EFalse)

	{

	}

CTPseudoAppEng* CTPseudoAppEng::NewL(RWsSession& aClient, CWsScreenDevice& aScreenDevice, RWindow& aWindow)

    {

    CTPseudoAppEng* self = new (ELeave) CTPseudoAppEng(aClient, aScreenDevice, aWindow);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self;

    return self;

    }

CTPseudoAppEng::~CTPseudoAppEng()

	{

	iSurfaceUpdateSession.Close();

    if(IsActive())

    	{

	    Cancel();

    	}

	delete iPseudoAppShared;

	delete iUtils;

	}

void CTPseudoAppEng::ConstructL()

	{

	CTimer::ConstructL();

	//Create CIniData class for reading in values form ini files

#ifndef T_PSEUDOAPP1

	iUtils = CIniData::NewL(KWServPseudoAppConfigFile);

#else

	iUtils = CIniData::NewL(KWServPseudoApp1ConfigFile);

#endif //T_PSEUDOAPP1

	//Connect to the surface update server

	TInt err = iSurfaceUpdateSession.Connect();

	if (err!=KErrNone)

		{

		RDebug::Print(_L("error in connecting surface update session\n"));

	 	User::Exit(0);

		}

	User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency, iCounterFreq));

	//Enter the animation loop

	RDebug::Print(_L("Enter Animation Loop\n"));

	CActiveScheduler::Add(this);

	}

void CTPseudoAppEng::StartDrawingL()

	{

	/* Read in the configuration fron the config file *

	 * and check the validity of the parameters. If   *

	 * invalid, take remedial action                  *

	 * Exit if the config is really unusable          *

	 * Window and animation classes are created if    *

	 * the configs are ok                             */

	RDebug::Print(_L("Import configuration for t_pseudoapp class and create test screen(s)\n"));

	ImportPseudoAppConfigL();

	RDebug::Print(_L("Test screen(s) created for t_pseudoapp\n"));

	if (iDrawing)

		{

		User::Panic(KTPseudoAppPanicTxt(), TPseudoAppEngAlreadyStarted);

		}

	iDrawing = ETrue;

	//A value of 0 will provoke a E32User-Cbase 46 panic

	After(TTimeIntervalMicroSeconds32(100000));

	//Set iStartTime to current time

	iStartTime.UniversalTime();

	}

void CTPseudoAppEng::StopDrawing()

	{

	if (!iDrawing)

		{

		User::Panic(KTPseudoAppPanicTxt(), TPseudoAppEngAlreadyStopped);

		}

	// Cancel timer and display

	Cancel();

	iDrawing = EFalse;

	}

void CTPseudoAppEng::TestFinishedL(const TDesC& aFileName)

	{

	RFs myFs;

	User::LeaveIfError(myFs.Connect());

	RFileWriteStream writer;

	writer.PushL(); // writer on cleanup stack

	User::LeaveIfError(writer.Replace(myFs, aFileName, EFileWrite));

	writer << _L("Surfaces Test Finished");

	writer.CommitL();

	CleanupStack::PopAndDestroy(&writer);

	myFs.Close();

	}

void CTPseudoAppEng::WriteResultsL(const TDesC& aFileName)

	{

	RFs myFs;

	User::LeaveIfError(myFs.Connect());

	TInt err = myFs.MkDirAll(aFileName);

	if (err==KErrNone || err==KErrAlreadyExists)

		{

		RFileWriteStream writer;

		writer.PushL(); // writer on cleanup stack

		User::LeaveIfError(writer.Replace(myFs, aFileName, EFileStreamText|EFileWrite));

		writer.CommitL();

		CleanupStack::PopAndDestroy(&writer); // writer

		CIniData* myData = CIniData::NewL(aFileName);

		CleanupStack::PushL(myData);

		TBuf<255> tempStore;

		_LIT(KIntData, "%d");

		_LIT(KRealData, "%4.1f");

		//Write out the test result, which is essentially a pass if the code reaches here

		tempStore.Format(KIntData, 1);

		TInt err = myData->AddValue(KDefaultSectionName, KGraphicsWservSurfaceTestResult, tempStore);

		User::LeaveIfError(err);

		myData->WriteToFileL();

		//Write out the theoretical maximum frame rate

		TReal frameRate = (iCounterFreq*static_cast<TReal>(iFrameDuration))/iGceTestResults.iTotalCompoTime;

		tempStore.Format(KRealData, frameRate);

		err = myData->AddValue(KDefaultSectionName, KGraphicsWservSurfaceFrameRate, tempStore);

		myData->WriteToFileL();

		//Write out the total test time

		TReal compoTime = static_cast<TReal>(iGceTestResults.iElapsedTime)/1000;

		tempStore.Format(KRealData, compoTime);

		err = myData->AddValue(KDefaultSectionName, KGraphicsWservSurfaceTotalTestTime, tempStore);

		myData->WriteToFileL();

		CleanupStack::PopAndDestroy(myData);

		}

	myFs.Close();

	}

// Timer's RunL()

void CTPseudoAppEng::RunL()

	{

	if(iFrameCounter != iFrameDuration)

		{

		//If no surface update is required, aSurfaceId will remain as 0

		TSurfaceId temp;

		iSurfDetails.aSurfaceId = temp.CreateNullId() ;

		while(iScreenCounter < iPseudoAppShared->iTestScreens.Count())

			{

			iPseudoAppShared->iTestScreens[iScreenCounter]->UpdateL(iSurfDetails);

			iScreenCounter++;

			break;

			}

		if(!iSurfDetails.aSurfaceId.IsNull())

			{

			if(iUseGlobalUpdate)

				{

				SendUpdateRequest(KAllScreens);				

				}

			else

				{

				SendUpdateRequest(iScreenCounter - 1);

				}

			}

		if(iScreenCounter == iPseudoAppShared->iTestScreens.Count())

			{

			iScreenCounter = 0;

			iFrameCounter++;

			}

		// Renew request

		After(TTimeIntervalMicroSeconds32(iFrameDelay));

		}

	else

		{

#ifndef T_PSEUDOAPP1

		WriteResultsL(KWServPseudoAppResultFile);

		TestFinishedL(KWServPseudoAppFinishFile);

#else

		WriteResultsL(KWServPseudoApp1ResultFile);

		TestFinishedL(KWServPseudoApp1FinishFile);

#endif //T_PSEUDOAPP1

		}

	}

// Timer's DoCancel()

void CTPseudoAppEng::DoCancel()

	{

	// Cancel timer

	CTimer::DoCancel();

	}

TBool  CTPseudoAppEng::Drawing()

	{

	return iDrawing;

	}

void CTPseudoAppEng::SendUpdateRequest(TInt /*aScreen*/)

 	{

 	//Submit update

	TRect rc[1] =

			{

			TRect(0, 0, iSurfDetails.aSurfaceSize.iWidth, iSurfDetails.aSurfaceSize.iHeight)

			};

	RRegion region(1, rc);

	//Use timestamp notification to measure frame rate

	TRequestStatus status;

	TTimeStamp timeStamp;

	iSurfaceUpdateSession.NotifyWhenDisplayed(status, timeStamp);

	iTimeStampBefore = User::FastCounter();

	TInt ret = iSurfaceUpdateSession.SubmitUpdate(KAllScreens, iSurfDetails.aSurfaceId, iSurfDetails.aBufferNumber, &region);

	User::WaitForRequest(status);

	TUint64 time = timeStamp();

	if(time < iTimeStampBefore)

		{

		time += UINT_MAX;

		}

	iTotalCompositionTime += (time - iTimeStampBefore);

	TTime currentTime;

	currentTime.UniversalTime();

	TTimeIntervalMicroSeconds elapsedTime = currentTime.MicroSecondsFrom(iStartTime);

	iGceTestResults.iElapsedTime = (TUint32)(elapsedTime.Int64()/1000);

	iGceTestResults.iTotalCompoTime = (TUint32)(iTotalCompositionTime);

	if(ret != KErrNone)

		{

		RDebug::Print(_L("Error submitting update request\n"));

		}

 	}

void CTPseudoAppEng::ImportPseudoAppConfigL()

	{

	TDisplayMode mode;

	TSize aScreenSize;

	TInt numberOfScreens;

	READ_INI1(number_of_screens, numberOfScreens, iUtils);

	iPseudoAppShared = new(ELeave) CTPseudoAppShared;

	for(TInt i=0; i<numberOfScreens; i++)

		{

		RDebug::Print(_L("Set up screen %d\n"), i);

		TImportPseudoAppConfig::ImportPseudoAppConfigL(i, iFrameDuration, iFrameDelay, mode, aScreenSize, iUtils);

#ifndef T_PSEUDOAPP1

		iPseudoAppShared->AddTestScreenL(i, mode, iFrameDuration, aScreenSize, &iGceTestResults, KWServPseudoAppConfigFile);

#else

		iPseudoAppShared->AddTestScreenL(i, mode, iFrameDuration, aScreenSize, &iGceTestResults, KWServPseudoApp1ConfigFile);

#endif //T_PSEUDOAPP1

		}

	READ_INI2A(KNullDesC, use_global_surface_update, True, False, iUseGlobalUpdate, ETrue, EFalse, iUtils);

	}

void CTPseudoAppEng::RotateL()

	{

	if (iPseudoAppShared)

		{

		for(TInt i=0; i<iPseudoAppShared->iTestScreens.Count(); i++)

			{

			if (iPseudoAppShared->iTestScreens[i])

				{

				if(iPseudoAppShared->iTestScreens[i]->Rotation())

					{

					iPseudoAppShared->iTestScreens[i]->RotateL(i, iFrameCounter);

					}

				}

			}

		}

	}