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

// te_hwrm.exe

// 

//

#include <centralrepository.h>

#include <hwrmvibrasdkcrkeys.h>

#include <hwrmlightdomaincrkeys.h>

#include <hwrmpowerdomaincrkeys.h>

#include <hwrmfmtxdomaincrkeys.h>

#include <hwrmfmtxaudiopolicydomainpskeys.h>

#include "HWRMFmTxInternalCRKeys.h"

#include "hwrmtestbase.h"

#include "hwrmtestmacros.h"

#include "HWRMPrivatePSKeys.h"

_LIT(KVibraModeON, "EVibraModeON");

_LIT(KVibraModeOFF, "EVibraModeOFF");

_LIT(KVibraModeUnknown, "EVibraModeUnknown");

_LIT(KVibraStatusUnknown, "EVibraStatusUnknown");

_LIT(KVibraStatusNotAllowed, "EVibraStatusNotAllowed");

_LIT(KVibraStatusStopped, "EVibraStatusStopped");

_LIT(KVibraStatusOn, "EVibraStatusOn");

_LIT(KLightStatusUnknown, "ELightStatusUnknown");

_LIT(KLightOn, "ELightOn");

_LIT(KLightOff, "ELightOff");

_LIT(KLightBlink, "ELightBlink");

_LIT(KFmTxStateOff, "EFmTxStateOff");

_LIT(KFmTxStateActive, "EFmTxStateActive");

_LIT(KFmTxStateInactive, "EFmTxStateInactive");

_LIT(KFmTxStatePowerSaveInactivity, "EFmTxStatePowerSaveInactivity");

_LIT(KFmTxStatePowerSaveAccessory, "EFmTxStatePowerSaveAccessory");

_LIT(KFmTxStateScanning, "EFmTxStateScanning");

_LIT(KFmTxStateUnknown, "EFmTxStateUnkown");

void CHWRMTestBase::OpenSessionsL(TInt aNoLightSessionsToOpen, TInt aNoVibraSessionsToOpen, TInt aNoExtLightSessionsToOpen, TInt aNoFmTxSessionsToOpen, TInt aNoPowerSessionsToOpen)

	{

	INFO_PRINTF1(_L("--START CHWRMTestBase::OpenSessionsL"));

	aNoLightSessionsToOpen = (aNoLightSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoLightSessionsToOpen;

	aNoVibraSessionsToOpen = (aNoVibraSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoVibraSessionsToOpen;

	aNoExtLightSessionsToOpen = (aNoExtLightSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoExtLightSessionsToOpen;

	aNoPowerSessionsToOpen = (aNoPowerSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoPowerSessionsToOpen;

	aNoFmTxSessionsToOpen = (aNoFmTxSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoFmTxSessionsToOpen;

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

		{

		if(i==0)

			{

			//used first session as one listening for callbacks

			iVibraSessions[i] = CHWRMVibra::NewL(this);

			}

		else

			{

			iVibraSessions[i] = CHWRMVibra::NewL();	

			}		

		}

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

		{

		if(i==0)

			{

			//used first session as one listening for callbacks

			INFO_PRINTF1(_L("CHWRMTestBase::OpenSessionsL - BEFORE CREATING FIRST LIGHT SESSION"));

			iLightSessions[i] = CHWRMLight::NewL(this);

			INFO_PRINTF1(_L("CHWRMTestBase::OpenSessionsL - AFTER CREATING FIRST LIGHT SESSION"));

			}

		else

			{

			iLightSessions[i] = CHWRMLight::NewL();	

			}		

		}

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

		{

		if(i==0)

			{

			//used first session as one listening for callbacks

			iExtLightSessions[i] = CHWRMExtendedLight::NewL(this);

			}

		else

			{

			iExtLightSessions[i] = CHWRMExtendedLight::NewL();	

			}		

		}

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

		{

		if(i==0)

			{

			//used first session as one listening for callbacks

			iPowerSessions[i] = CHWRMPower::NewL();	

			}

		else

			{

			iPowerSessions[i] = CHWRMPower::NewL();	

			}

		}

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

		{

		if(i==0)

			{

			//used first session as one listening for callbacks

			iFmTxSessions[i] = CHWRMFmTx::NewL(this);

			}

		else

			{

			iFmTxSessions[i] =  CHWRMFmTx::NewL();	

			}		

		}

	INFO_PRINTF1(_L("CHWRMTestBase::OpenSessionsL - BEFORE OPENING MOCKSY SESSIONS"));

	// Open sessions to MockSY	

	if (aNoLightSessionsToOpen > 0 && !iIsMockLightSessionOpen)

		{

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

		iIsMockLightSessionOpen = ETrue;

		}

	if (aNoVibraSessionsToOpen > 0 && !iIsMockVibraSessionOpen)

		{

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

		iIsMockVibraSessionOpen = ETrue;

		}

	if (aNoExtLightSessionsToOpen > 0 && !iIsMockLightSessionOpen)

		{

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

		iIsMockLightSessionOpen = ETrue;

		}

	if (aNoPowerSessionsToOpen > 0 && !iIsMockPowerSessionOpen)

		{

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

		iIsMockPowerSessionOpen = ETrue;

		}

	if (aNoFmTxSessionsToOpen > 0 && !iIsMockFmTxSessionOpen)

		{

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

		iIsMockFmTxSessionOpen = ETrue;

		}

	INFO_PRINTF1(_L("--END CHWRMTestBase::OpenSessionsL"));	

	}

void CHWRMTestBase::OpenLightSessionEnhancedL(TInt aNoEnhancedLightSessionsToOpen)

	{

	INFO_PRINTF1(_L("--START CHWRMTestBase::OpenEnhancedLightSessionL"));

	aNoEnhancedLightSessionsToOpen = (aNoEnhancedLightSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoEnhancedLightSessionsToOpen;

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

		{

		if(i==0)

			{

			//used first session as one listening for callbacks

			iEnhancedLightSessions[i] = CHWRMEnhancedLight::NewL(this);

			}

		else

			{

			iEnhancedLightSessions[i] = CHWRMEnhancedLight::NewL();	

			}		

		}

	INFO_PRINTF1(_L("CHWRMTestBase::OpenEnhancedLightSessionL - BEFORE OPENING MOCKSY SESSIONS"));

	// Open sessions to MockSY	

	if (aNoEnhancedLightSessionsToOpen > 0 && !iIsMockLightSessionOpen)

		{

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

		iIsMockLightSessionOpen = ETrue;

		}

	INFO_PRINTF1(_L("--END CHWRMTestBase::OpenSessionsL"));	

	}

void CHWRMTestBase::OpenPowerStateSessionL()

	{

	if (!iIsMockPowerStateSessionOpen)

		{

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

		iIsMockPowerStateSessionOpen = ETrue;

		}

	// P&S property observers

	CleanupPropertyObservers();

	iBatteryLevelObserver = CPsPropertyObserver::NewL(KPSUidHWRMPowerState, KHWRMBatteryLevel,*this);

	iBatteryStatusObserver = CPsPropertyObserver::NewL(KPSUidHWRMPowerState, KHWRMBatteryStatus,*this);

	iChargingStatusObserver = CPsPropertyObserver::NewL(KPSUidHWRMPowerState, KHWRMChargingStatus,*this);

	}

void CHWRMTestBase::CleanupPropertyObservers()

	{

	delete iBatteryLevelObserver;

	iBatteryLevelObserver = NULL;

	delete iBatteryStatusObserver;

	delete iChargingStatusObserver;

	}

void CHWRMTestBase::GetCRVibraAttributeL(TUint32 aVibraKey, TInt &aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidVibraCtrl);

    User::LeaveIfError(rep->Get(aVibraKey, aValue));

    CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::GetVibraTimeAttributesL()

	{

	GetCRVibraAttributeL(KVibraMinOffTime, iVibraMinOffTime);

    if ( iVibraMinOffTime < 0 )

        {

        iVibraMinOffTime = 0;  // do not allow negative value

        }

    GetCRVibraAttributeL(KVibraCtrlMaxTime, iVibraMaxOnTime);

    if ( iVibraMaxOnTime < 0 )

        {

        iVibraMaxOnTime = 0;  // do not allow negative value

        }

    GetCRVibraAttributeL(KVibraCtrlFeedbackIntensity, iPulseMaxIntensity);

    if ( iPulseMaxIntensity < 0 )

        {

        iPulseMaxIntensity = 0;  // do not allow negative value

        }

    GetCRVibraAttributeL(KVibraCtrlFeedbackDuration, iPulseMaxDuration);

    if ( iPulseMaxDuration < 0 )

        {

        iPulseMaxDuration = 0;  // do not allow negative value

        }

    }

void CHWRMTestBase::SetCRVibraAttributeL(TUint32 aVibraKey, TInt aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidVibraCtrl);

    User::LeaveIfError(rep->Set(aVibraKey, aValue));

	CleanupStack::PopAndDestroy(rep);

	}

TInt CHWRMTestBase::SetCRVibraAttribute(TUint32 aVibraKey, TInt aValue)

	{

	CRepository* rep = CRepository::NewL(KCRUidVibraCtrl);

    TInt err = rep->Set(aVibraKey, aValue);

	return err;

	}

void CHWRMTestBase::SetCRLightAttributes(TUint32 aLightKey, TInt aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidLightSettings);

    User::LeaveIfError(rep->Set(aLightKey, aValue));

	CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::GetCRLightAttributes(TUint32 aLightKey, TInt &aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidLightSettings);

    User::LeaveIfError(rep->Get(aLightKey, aValue));

    CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::SetLightControlAttributes(TInt aIntensity, TInt aSensitivity, TInt aInUse)

	{

	iLightDefaultIntensity = aIntensity;

	iLightDefaultSensitivity = aSensitivity;

	iLightSensorEnabled = aInUse;

	SetCRLightAttributes(KLightIntensity, iLightDefaultIntensity);

	SetCRLightAttributes(KLightSensorSensitivity, iLightDefaultSensitivity);

	SetCRLightAttributes(KLightSensorInUse, iLightSensorEnabled);

	}

void CHWRMTestBase::GetLightControlAttributes()

	{

	GetCRVibraAttributeL(KLightIntensity, iLightDefaultIntensity);

	GetCRVibraAttributeL(KLightSensorSensitivity, iLightDefaultSensitivity);

	GetCRVibraAttributeL(KLightSensorInUse, iLightSensorEnabled);

	}

void CHWRMTestBase::GetCRPowerAttributeL(TUint32 aPowerKey, TInt &aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidPowerSettings);

    User::LeaveIfError(rep->Get(aPowerKey, aValue));

    CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::GetPowerAttributesL()

	{

	TInt value;

	GetCRVibraAttributeL(KPowerBaseTimeInterval, value);

	iPowerBaseIntervalMicroSeconds = 1000 * value; //from milli to microseconds

	GetCRVibraAttributeL(KPowerMaxReportingPeriod, value); //from milli to microseconds

	iPowerMaxReportingPeriodMicroSeconds = 1000 * value;

	}

void CHWRMTestBase::SetCRPowerAttributeL(TUint32 aPowerKey, TInt aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidPowerSettings);

    User::LeaveIfError(rep->Set(aPowerKey, aValue));

	CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::SetCRFmTxAttributeL(TUint32 aFmTxKey, TInt aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidFmTxCenRes);

    User::LeaveIfError(rep->Set(aFmTxKey, aValue));

    CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::GetCRFmTxAttributeL(TUint32 aFmTxKey, TInt &aValue)

	{

	CRepository* rep = CRepository::NewLC(KCRUidFmTxCenRes);

    User::LeaveIfError(rep->Get(aFmTxKey, aValue));

    CleanupStack::PopAndDestroy(rep);

	}

void CHWRMTestBase::GetFmTxFrequencyStepSizeL()

	{

	GetCRFmTxAttributeL(KFmTxCenResKeyStepSize, iFmTxFrequencyStepSize);

	}

void CHWRMTestBase::SetFmTxFrequencyRangeEuropeL()

	{

	SetCRFmTxAttributeL(KFmTxCenResKeyMinFrequency, 88100);

	SetCRFmTxAttributeL(KFmTxCenResKeyMaxFrequency, 107900);

	SetCRFmTxAttributeL(KFmTxCenResKeyStepSize, 50);

	}

void CHWRMTestBase::SetFmTxFrequencyRangeJapanL()

	{

	SetCRFmTxAttributeL(KFmTxCenResKeyMinFrequency, 88100);

	SetCRFmTxAttributeL(KFmTxCenResKeyMaxFrequency, 90000);

	SetCRFmTxAttributeL(KFmTxCenResKeyStepSize, 50);

	}

void CHWRMTestBase::SetFmTxInactivityTimeOutL(TUint aInactivityTimeOut)

	{

	SetCRFmTxAttributeL(KFmTxCenResKeyPowerSaveTimerLength, aInactivityTimeOut);

	}

void CHWRMTestBase::ExpectBatteryLevelNotificationL(EPSHWRMBatteryLevel aBatteryLevel)

	{

	iExpectedBatteryLevelNotifications.AppendL(aBatteryLevel);

	}

void CHWRMTestBase::ExpectBatteryStatusNotificationL(EPSHWRMBatteryStatus aStatus)

	{

	iExpectedBatteryStatusNotifications.AppendL(aStatus);

	}

void CHWRMTestBase::ExpectedChargingStatusNotificationsL(EPSHWRMChargingStatus aStatus)

	{

	iExpectedChargingStatusNotifications.AppendL(aStatus);

	}

void CHWRMTestBase::ExpectVibraStatusNotificationL(CHWRMVibra::TVibraStatus aStatus)

	{

	iExpectedVibraStatusNotifications.AppendL(aStatus);

	}

void CHWRMTestBase::ExpectLightStatusNotificationL(TInt aTarget, CHWRMLight::TLightStatus aStatus)

	{

	if (IgnoringStatusNotifications())

		{

		return;

		}

	TLightNotification notification;

	notification.iTarget = aTarget;

	notification.iStatus = aStatus; 	

	iExpectedLightNotifications.AppendL(notification);

	}

void CHWRMTestBase::ExpectExtLightStatusNotificationL(TInt aTarget, CHWRMExtendedLight::TLightStatus aStatus)

	{

	if (IgnoringStatusNotifications())

		{

		return;

		}

	TExtLightNotification notification;

	notification.iTarget = aTarget;

	notification.iStatus = aStatus; 	

	iExpectedExtLightNotifications.AppendL(notification);

	}

void CHWRMTestBase::ExpectFmTxStatusNotificationL(TFmTxState aStatus1,TFmTxState aStatus2)

	{

	TFmTxNotification notification;

	notification.iState1=aStatus1;

	notification.iState2=aStatus2;

	iExpectedFmTxStatusNotifications.AppendL(notification);

	}

void CHWRMTestBase::ExpectFmTxStatusNotificationL(TFmTxState aStatus)

	{

	ExpectFmTxStatusNotificationL(aStatus, aStatus);

	}

void CHWRMTestBase::ExpectFmTxFrequencyNotificationL(TInt aFrequency)

	{

	iExpectedFmTxFrequencyNotifications.AppendL(aFrequency);

	}

void CHWRMTestBase::ExpectVibraModeNotificationL()

	{

	TInt value(-1);

	GetCRVibraAttributeL(KVibraCtrlProfileVibraEnabled,value);

	CHWRMVibra::TVibraModeState expectedVibraMode = 

			(value == 0) ? CHWRMVibra::EVibraModeOFF : CHWRMVibra::EVibraModeON;

	ExpectVibraModeNotificationL(expectedVibraMode);

	}

void CHWRMTestBase::ExpectVibraModeNotificationL(CHWRMVibra::TVibraModeState aState)

	{

	iExpectedVibraModeNotifications.AppendL(aState);

	}

void CHWRMTestBase::ExpectVibraFeedbackModeNotificationL(CHWRMVibra::TVibraFeedbackModeState aState)

	{

	iExpectedVibraFeedbackModeNotifications.AppendL(aState);

	}

//callbacks of state change

 void CHWRMTestBase::VibraModeChanged(CHWRMVibra::TVibraModeState aStatus)

 	{

 	switch (aStatus)

        {

	    case CHWRMVibra::EVibraModeUnknown:

	        INFO_PRINTF1(_L("Vibra mode changed: EVibraModeUnknown"));

	        break;

	    case CHWRMVibra::EVibraModeON:

	        INFO_PRINTF1(_L("Vibra mode changed: EVibraModeON"));

	        break;

	    case CHWRMVibra::EVibraModeOFF:

	        INFO_PRINTF1(_L("Vibra mode changed: EVibraModeOFF"));

	        break;

	    default:

	        INFO_PRINTF1(_L("Vibra mode changed: UNDEFINED ! "));

	        break;

        }

  	if (iExpectedVibraModeNotifications.Count() > 0)

  		{

  		if (aStatus != iExpectedVibraModeNotifications[0])

  			{

	  		INFO_PRINTF3(_L("### ERROR: VibraModeChanged, expected:%d, actual:%d"),iExpectedVibraModeNotifications[0],aStatus);

	  		SetTestFail();

  			}

        iExpectedVibraModeNotifications.Remove(0);

 		}

 	else

 		{

 	  	INFO_PRINTF2(_L("### ERROR: VibraModeChanged, expected:NONE, actual:%d"),aStatus);

	  	SetTestFail();

 		}

    CheckForEndOfTransition();

 	}

void CHWRMTestBase::VibraStatusChanged(CHWRMVibra::TVibraStatus aStatus)

	{

	switch (aStatus)

        {

    case CHWRMVibra::EVibraStatusUnknown:

        INFO_PRINTF1(_L("Vibra state changed: EVibraStatusUnknown"));

        break;

    case CHWRMVibra::EVibraStatusNotAllowed:

        INFO_PRINTF1(_L("Vibra state changed: EVibraStatusNotAllowed"));

        break;

    case CHWRMVibra::EVibraStatusStopped:

        INFO_PRINTF1(_L("Vibra state changed: EVibraStatusStopped"));        

        break;

    case CHWRMVibra::EVibraStatusOn:

        INFO_PRINTF1(_L("Vibra state changed: EVibraStatusOn"));

        break;

    default:

        INFO_PRINTF1(_L("Vibra state changed: UNDEFINED !"));

        break;

        }

   	if (iExpectedVibraStatusNotifications.Count() > 0)

  		{

  		if (aStatus != iExpectedVibraStatusNotifications[0])

  			{

	  		INFO_PRINTF3(_L("### ERROR: VibraStatusChanged, expected:%d, actual:%d"),iExpectedVibraStatusNotifications[0],aStatus);

	  		SetTestFail();

  			}        

        iExpectedVibraStatusNotifications.Remove(0);