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

 					}

 				}

 			}

 		}

 	}