// Copyright (c) 2003-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:

//

#include <techview/eikon.hrh>

#include <e32property.h> 

#include <e32base.h>

#include <eikenv.h>

#include <eikdialg.h>

#include "HWRMLightTestB.pan"

#include "HWRMLightTestBappui.h"

#include "HWRMLightTestBappview.h"

#include "HWRMLightTestB.hrh"

#include "testcasecontroller.h"

_LIT(KDebugPrefix,"HWRMLightTestB # ");

void CHWRMLightTestBAppUi::ConstructL()

    {

    BaseConstructL();

	//iSession = CRepository::NewL(KCRUidVibraCtrl);

    iAppView = CHWRMLightTestBAppView::NewL(ClientRect());

    AddToStackL(iAppView);

    iTestCaseController = CHwrmTestCaseController::NewL(*this);

    }

CHWRMLightTestBAppUi::CHWRMLightTestBAppUi()                              

    {

    }

CHWRMLightTestBAppUi::~CHWRMLightTestBAppUi()

    {

    if (iAppView)

        {

        iEikonEnv->RemoveFromStack(iAppView);

        delete iAppView;

        iAppView = NULL;

        }

    //delete iSession;

    delete iTestCaseController;

    }

void CHWRMLightTestBAppUi::HandleCommandL(TInt aCommand)

    {

    switch(aCommand)

        {

        case EEikCmdExit:

       // case EAknSoftkeyExit:

            Exit();

            break;

        case EHWRMLightTestBCommand1:

            {

			// Create multiclient test framework instance, create P&S-properties and attach to it 			

			//iMcFramework = iMcFramework->NewL(); 

            iTestCaseController->RunSlaveMode();

            //_LIT(message,"TEST EXECUTED (Slave)");

            //CAknInformationNote* informationNote = new (ELeave) CAknInformationNote;

            //CEikDialog* informationNote = new (ELeave) CEikDialog;

            //informationNote->ExecuteLD(message);

            }

            break;		

        default:

            Panic(EHWRMLightTestBUi);

            break;

        }

    }

void CHWRMLightTestBAppUi::InfoMessage(const TDesC& aMessage)

	{

	iEikonEnv->InfoMsg(aMessage);

	}

// FUTURE TASK: Refactor duplicate code in LogMessage and DebugMessage (could be a good refresher on descriptors...)

void CHWRMLightTestBAppUi::LogMessage(const TDesC& aMessage)

	{

	HBufC* dbgMsg(NULL);

	TRAPD(err,	dbgMsg = HBufC::NewL(KDebugPrefix().Length() + aMessage.Length()));

	if (err != KErrNone)

		return;

	CleanupStack::PushL(dbgMsg);

	dbgMsg->Des().Append(KDebugPrefix);

	dbgMsg->Des().Append(aMessage);

	iLog.Printf(*dbgMsg);

	CleanupStack::PopAndDestroy(dbgMsg);

	}

void CHWRMLightTestBAppUi::DebugMessage(const TDesC& aMessage)

	{

	HBufC* dbgMsg(NULL);

	TRAPD(err,	dbgMsg = HBufC::NewL(KDebugPrefix().Length() + aMessage.Length()));

	if (err != KErrNone)

		return;

	CleanupStack::PushL(dbgMsg);

	dbgMsg->Des().Append(KDebugPrefix);

	dbgMsg->Des().Append(aMessage);

	RDebug::Print(*dbgMsg);

	CleanupStack::PopAndDestroy(dbgMsg);

	}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::RunTestCases

// Run test cases

// -----------------------------------------------------------------------------

//

#ifdef COMMENTED_OUTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

void CHWRMLightTestBAppUi::RunTestCases(TInt aCasesFrom, TInt aCasesTo)

{

	//iLog.Printf(_L("Running test cases from %d to %d.."), aCasesFrom, aCasesTo);

	TInt i;

	TInt errCode;

	for (i = aCasesFrom; i < aCasesTo; i++)

	{

		errCode = KErrNone;

		switch(i)

		{

			case 1:

				errCode = LightTargetDisplayTest( );

				LogResult(_L("HWRM [LightOnWithDisplayTarget] "), errCode);

				break;

			case 2:

				errCode = LightTargetKeyboardTest();

				LogResult(_L("HWRM [LightOnWithKeyboardTarget] "), errCode);

				break;

			case 3:

				errCode = LightOnDurationTest();

				LogResult(_L("HWRM [LightOnWithDuration] "), errCode);

				break;

			case 4:

				errCode = LightOffDurationTest();

				LogResult(_L("HWRM [LightOffWithDuration] "), errCode);

				break;

			case 5:

				errCode = LightIntensityTest();

				LogResult(_L("HWRM [LightOnWithIntensity] "), errCode);

				break;

			case 6:

				errCode = LightBlinkTargetTest();

				LogResult(_L("HWRM [LightBlinkWithTarget] "), errCode);

				break;

			case 7:

				errCode = LightBlinkDurationTest();

				LogResult(_L("HWRM [LightBlinkWithDuration] "), errCode);

				break;

			case 8:

				errCode = LightBlinkOnOff();

				LogResult(_L("HWRM [LightBlinkOnOff] "), errCode);

				break;

			case 9:

				errCode = LightWithDifferentTargets();

				LogResult(_L("HWRM [LightWithDifferentTargets] "), errCode);

				break;

			case 10:

				errCode = LightWithInvalidDuration();

				LogResult(_L("HWRM [LightWithInvalidDuration] "), errCode);

				break;

			default:

				break;

		}

	}

}

/* TeK -> */

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::RunSlaveMode

//

// This method is called when application is started in SLAVE-mode

// 

// -----------------------------------------------------------------------------

//

void CHWRMLightTestBAppUi::RunSlaveMode()

{

	TInt tcase = 0;

	TInt recStat = KErrNone;	  

	while (tcase != EHWRMQuitTest)

	{

		tcase = iMcFramework->WaitTestToStart();

		if (tcase != EHWRMQuitTest)

		{

			switch(tcase)

			{

				case (EMultiClientCase1):

					recStat = MC_Primary_display_light_S();

					iMcFramework->StepExecuted(recStat);					

					break;

				case (EMultiClientCase2):

					recStat = MC_Display_on_and_keyboard_blink_S();

					iMcFramework->StepExecuted(recStat);					

					break;

				case (EMultiClientCase3):

					recStat = MC_Display_on_and_keyboard_reserved_S();	

					iMcFramework->StepExecuted(recStat);					

					break;

				case (EMultiClientCase4):

					recStat = MC_Display_and_keyboard_blink_S();

					iMcFramework->StepExecuted(recStat);

					break;

				case (EMultiClientCase5):

					recStat = MC_Vibra_Basic_Usage_S();

					iMcFramework->StepExecuted(recStat);

					break;

				case (EMultiClientCase6):

					recStat = Verify_MCFramework_S();

					iMcFramework->StepExecuted(recStat);

					break;

				case (EMultiClientCase7):

					recStat = MC_Combined_light_and_vibra_usage_S();

					iMcFramework->StepExecuted(recStat);

					break;

				case (EMultiClientCase8):

					recStat = MC_Combined_light_and_vibra_usage_2_S();

					iMcFramework->StepExecuted(recStat);

					break;

				case (EMultiClientCase9):

					recStat = MC_FmTx_Basic_Usage_S();

					iMcFramework->StepExecuted(recStat);

					break;												

				default:

					iMcFramework->StepExecuted(KErrGeneral);	

			}

		}

	}

}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::Verify_MCFramework_S

// Slave side test case to verify McFramework functionality 

// -----------------------------------------------------------------------------

//

TInt CHWRMLightTestBAppUi::Verify_MCFramework_S()

{

	RDebug::Print(_L("Verify_MCFramework_S() starting"));

	CTestScheduler::StartAndStopL(1000); // Testin suoritusta

	iMcFramework->StepExecuted(KErrNone); // palautetaan testistepin tulos

	TInt execStep = iMcFramework->WaitNextTestStep(); // mennään odottamaan seuraavaa steppiä

	CTestScheduler::StartAndStopL(1000); // Testin suoritus jatkuu

	//iMcFramework->StepExecuted(KErrNone); last step execution is reported in RunSlaveMode()

	RDebug::Print(_L("Verify_MCFramework_S() done"));

	return KErrNone;

}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::TestLightOn

// This method 

// blaa blaa

// -----------------------------------------------------------------------------

//

TInt CHWRMLightTestBAppUi::TestLightOn(TInt aTarget, TInt aDur, TInt aIntens, TBool aFadeIn)

{

	TInt errorStatus;			

	TRAP(errorStatus, iMyLight->LightOnL(aTarget, aDur, aIntens, aFadeIn));

	CTestScheduler::StartAndStopL(100);

	//iLog.Printf(_L("HWRMLightTestB ***Light ON*** Target:%d, Duration:%ds, Intensity %d, Fade:%d"), aTarget, aDur/1000, aIntens, aFadeIn);

	RDebug::Print(_L("HWRMLightTestB ***Light ON*** Target:%d, Duration:%ds, Intensity %d, Fade:%d"), aTarget, aDur/1000, aIntens, aFadeIn);

	return errorStatus;

}

TInt CHWRMLightTestBAppUi::TestLightOn(TInt aTarget)

{

	TInt errorStatus;			

	TRAP(errorStatus, iMyLight->LightOnL(aTarget));

	CTestScheduler::StartAndStopL(100);

	//iLog.Printf(_L("HWRMLightTestB ***Light ON*** Target:%d, Duration:infinite"), aTarget);

	RDebug::Print(_L("HWRMLightTestB ***Light ON*** Target:%d, Duration:infinite"), aTarget);

	return errorStatus;

}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::TestLightOff

// This method 

// blaa blaa

// -----------------------------------------------------------------------------

//

TInt CHWRMLightTestBAppUi::TestLightOff(TInt aTarget, TInt aDuration, TBool aFadeOut)

{

	TInt errorStatus;			

	TRAP(errorStatus, iMyLight->LightOffL(aTarget, aDuration, aFadeOut));

	CTestScheduler::StartAndStopL(100);

	//iLog.Printf(_L("HWRMLightTestB ***Light OFF*** Target:%d, Duration:%ds, Fadeout:%d"), aTarget, aDuration/1000, aFadeOut);

	RDebug::Print(_L("HWRMLightTestB ***Light OFF*** Target:%d, Duration:%ds, Fadeout:%d"), aTarget, aDuration/1000, aFadeOut);

	return errorStatus;

}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::TestLightBlink

// This method 

// blaa blaa

// -----------------------------------------------------------------------------

//

TInt CHWRMLightTestBAppUi::TestLightBlink(TInt aTarget, 

		                         		  TInt aDuration, 

		                         		  TInt aOnDuration, 

		                         		  TInt aOffDuration, 

		                         		  TInt aIntensity)

{

	TInt errorStatus;			

	TRAP(errorStatus, iMyLight->LightBlinkL(aTarget, aDuration, aOnDuration, aOffDuration, aIntensity));

	CTestScheduler::StartAndStopL(100);

	//iLog.Printf(_L("HWRMLightTestB ***Light BLINK*** Target:%d, Duration:%ds, On:%d Off:%d, Intensity:%d"), aTarget, aDuration/1000, aOnDuration, aOffDuration, aIntensity);

	RDebug::Print(_L("HWRMLightTestB ***Light BLINK*** Target:%d, Duration:%ds, On:%d Off:%d, Intensity:%d"), aTarget, aDuration/1000, aOnDuration, aOffDuration, aIntensity);

	return errorStatus;

}

TInt CHWRMLightTestBAppUi::TestLightBlink(TInt aTarget, TInt aDuration)

{

	TInt errorStatus;			

	TRAP(errorStatus, iMyLight->LightBlinkL(aTarget, aDuration));

	CTestScheduler::StartAndStopL(100);

	//iLog.Printf(_L("HWRMLightTestB ***Light BLINK*** Target:%d, Duration:%ds"), aTarget, aDuration/1000);

	RDebug::Print(_L("HWRMLightTestB ***Light BLINK*** Target:%d, Duration:%ds"), aTarget, aDuration/1000);

	return errorStatus;

}

TInt CHWRMLightTestBAppUi::TestLightBlink(TInt aTarget)

{

	TInt errorStatus;			

	TRAP(errorStatus, iMyLight->LightBlinkL(aTarget));

	CTestScheduler::StartAndStopL(100);

	//iLog.Printf(_L("HWRMLightTestB ***Light BLINK*** Target:%d"), aTarget);

	RDebug::Print(_L("HWRMLightTestB ***Light BLINK*** Target:%d"), aTarget);

	return errorStatus;

}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::RunTestVibra

// This method 

// - call LightBlinkL method with given parameters

// - Run 100ms delay

// - Print parameters to log 

// -----------------------------------------------------------------------------

//

TInt CHWRMLightTestBAppUi::RunTestVibra( TInt howLong, TInt whatIntensity)

{

	TInt errorStatus;	

	TRAP(errorStatus, iVibra->StartVibraL(howLong, whatIntensity));

	//iLog.Printf(_L("CHWRMLightTestBAppUi Vibra start for %d seconds with intensity %d Error:%d"), howLong/1000, whatIntensity, errorStatus);

	RDebug::Print(_L("CHWRMLightTestBAppUi Vibra start for %d seconds with intensity %d Error:%d"), howLong/1000, whatIntensity, errorStatus);

	CTestScheduler::StartAndStopL(100);

	return errorStatus;

}

TInt CHWRMLightTestBAppUi::RunTestVibra( TInt howLong)

{

	TInt errorStatus;	

	TRAP(errorStatus, iVibra->StartVibraL(howLong));

	//iLog.Printf(_L("CHWRMLightTestBAppUi Vibra start for %d seconds with default intensity Error:%d"), howLong/1000, errorStatus);

	RDebug::Print(_L("CHWRMLightTestBAppUi Vibra start for %d seconds with default intensity Error:%d"), howLong/1000, errorStatus);

	CTestScheduler::StartAndStopL(100);

	return errorStatus;

}

TInt CHWRMLightTestBAppUi::StopTestVibra()

{

	TInt errorStatus;		

	TRAP(errorStatus, iVibra->StopVibraL());

	//iLog.Printf(_L("CHWRMLightTestBAppUi Vibra stop called Error:%d"),errorStatus);

	RDebug::Print(_L("CHWRMLightTestBAppUi Vibra stop called Error:%d"),errorStatus);

	CTestScheduler::StartAndStopL(100);

	return errorStatus; 

}

// -----------------------------------------------------------------------------

// CHWRMLightTestBAppUi::MC_Primary_display_light_S

// Light usage with two applications / This application is on the background

// -----------------------------------------------------------------------------

//

TInt CHWRMLightTestBAppUi::MC_Primary_display_light_S()

    {

    RDebug::Print(_L("MC_Primary_display_light_S()"));

    TInt iErrVal = KErrNone;

    CHWRMLight::TLightStatus currStatus;

    CHWRMLight::TLightStatus origStatus;

    //create light instance

    TRAP(iErrVal, iMyLight = CHWRMLight::NewL(this));	    

    if (iErrVal == KErrNone)

    {

	    origStatus = iMyLight->LightStatus(CHWRMLight::EPrimaryDisplay);

	    //reserve light, Restore state after release = True, Force CoeNoeEnvOn = True

		TRAP(iErrVal, iMyLight->ReserveLightL(CHWRMLight::EPrimaryDisplay, ETrue, ETrue));

		if (iErrVal == KErrNone)

		{

			// Reservation was OK

			// Set primary display light blinking

			iErrVal = TestLightBlink(CHWRMLight::EPrimaryDisplay, 10000, 1000, 1000, 100);

			if (iErrVal == KErrNone)

			{

				// Check light status

				currStatus = iMyLight->LightStatus(CHWRMLight::EPrimaryDisplay);	

				if (currStatus == CHWRMLight::ELightBlink )

				{

					/* Light status is OK */

					iMcFramework->StepExecuted(KErrNone);

					iErrVal = iMcFramework->WaitNextTestStep();

					if (iErrVal == KErrNone)

					{			

						/* Test execution was OK in peer-application */

						/* Check current light status */

						currStatus = iMyLight->LightStatus(CHWRMLight::EPrimaryDisplay);

						if (currStatus == CHWRMLight::ELightBlink)

						{

							/* OK, light is still blinking */

							/* Wait 10 seconds */

							CTestScheduler::StartAndStopL(10000);

							// Release light, then status should return in state as it was before reservation

							iMyLight->ReleaseLight(CHWRMLight::EPrimaryDisplay);

							CTestScheduler::StartAndStopL(2000);

							/* Check light status */

							currStatus = iMyLight->LightStatus(CHWRMLight::EPrimaryDisplay);			

							if(currStatus == origStatus)

							{

								/* OK, light is not blinking anymore */

								iErrVal = KErrNone;	

								//iMcFramework->StepExecuted(KErrNone); last step execution is reported in RunSlaveMode()

							}

							else

							{

								RDebug::Print(_L("HWRMLightTestB # Wrong light status %d. Expected original: %d"), currStatus, origStatus);

								iErrVal = KErrGeneral; 

							}

						}

						else

						{