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

//

#ifndef hwrmtestbase_h

#define hwrmtestbase_h

#include <test/tefunit.h>

#include <hwrmvibra.h>

#include <hwrmlight.h>

#include <hwrm/hwrmextendedlight.h>

#include <hwrm/hwrmenhancedlight.h>

#include <hwrmpower.h>

#include <hwrm/hwrmfmtx.h>

#include <rmocklight.h>

#include <rmockpowerstate.h>

#include <rmockvibra.h>

#include <rmockpower.h>

#include <rmockfmtx.h>

#include <e32property.h>

#include <hwrmpowerstatesdkpskeys.h>

#include "endstatetimer.h"

#include "pspropertyobserver.h"

const TInt KMaxNoOpenSessionsForResource = 3;

const TInt KMaxNoStateTransitions = 5;

const TInt KDefaultVibraMinOffTime = 0;

// temp, may need to move but in original test was in main.cpp

const TUint32 KHWRMTestLightIntensityValue      = 0x10000007;

const TUint32 KHWRMTestLightSensitivityValue    = 0x10000008;

class CHWRMTestBase : 	public CTestFixture , 

						public MHWRMVibraObserver, 

						public MHWRMLightObserver, 

						public MHWRMExtendedLightObserver,

						public MHWRMBatteryPowerObserver,

						public MHWRMFmTxObserver,

						public MTimerExpired, 

						public MPsPropertyObserver,

						public MHWRMVibraFeedbackObserver

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

						,

						public MHWRMBatteryChargingStatusObserver,

						public MHWRMBatteryFullChargingTimeObserver,

						public MHWRMBatteryChargingCurrentObserver

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	{

public:// from MHWRMVibraObserver

    virtual void VibraModeChanged(CHWRMVibra::TVibraModeState aStatus);

    virtual void VibraStatusChanged(CHWRMVibra::TVibraStatus aStatus);

    // from MHWRMVibraFeedbackObserver

    virtual void VibraFeedbackModeChanged(CHWRMVibra::TVibraFeedbackModeState aMode);

public: // from MHWRMLightObserver

    virtual void LightStatusChanged(TInt aTarget, CHWRMLight::TLightStatus aStatus);

public: //from MHWRMExtendedLightObserver

	virtual void LightStatusChanged(TInt aTarget, CHWRMExtendedLight::TLightStatus aStatus);

public: //from MHWRMBatteryPowerObserver

	virtual void PowerMeasurement(TInt aErrorCode, CHWRMPower::TBatteryPowerMeasurementData& aMeasurement);

public: //from MHWRMFmTxObserver

	virtual void FmTxStatusChanged(TFmTxState aState);

	virtual void FmTxFrequencyChanged(TInt aFrequency);

public: // from MPsPropertyObserver

	virtual void PsPropertyChanged(TInt aKey, TInt aValue);

public: //from MTimerExpired

	void EndStateTimerExpired(TInt aError);

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

public:

	//from MHWRMBatteryChargingStatusObserver

    void ChargingStatusChange(TInt aErrorCode, CHWRMPower::TBatteryChargingStatus aChrgStatus);

	//from MHWRMBatteryFullChargingTimeObserver

	void BatteryFullChargingTimeChange(TInt aErrorCode, TUint aTime);

	//from MHWRMBatteryChargingCurrentObserver

	void AverageChargingCurrentChange(TInt aErrorCode, TInt aMeasurement);

#endif //SYMBIAN_HWRM_EXTPOWERINFO

public:

	// SetUp and TearDown code

	void SetupL();

	void TearDownL();

	inline void SetTestFail();

protected: //useful functions

	template <class T>

	void AddTestStateL(T* aObject, void (T::*aTestStateFptr)(),TReal aMaxDurationIsSecs);

	void OpenSessionsL(TInt aNoLightSessionsToOpen, TInt aNoVibraSessionsToOpen, TInt aNoExtLightSessionsToOpen = 0, TInt aNoFmTxSessionsToOpen = 0, TInt aNoPowerSessionsToOpen = 0);

	void OpenPowerStateSessionL();

	void OpenLightSessionEnhancedL(TInt aNoEnhancedLightSessionsToOpen);

	inline CHWRMVibra& GetVibraSessionL(TInt aIndex);

	inline CHWRMLight& GetLightSessionL(TInt aIndex);

	inline CHWRMExtendedLight& GetExtLightSessionL(TInt aIndex);

	inline CHWRMEnhancedLight& GetEnhancedLightSessionL(TInt aIndex);

	inline CHWRMPower& GetPowerSessionL(TInt aIndex);

	inline CHWRMFmTx& GetFmTxSessionL(TInt aIndex);

	inline CHWRMVibra& GetVibraSessionWithCallbackRegisteredL();

	inline CHWRMLight& GetLightSessionWithCallbackRegisteredL();

	inline CHWRMExtendedLight& GetExtLightSessionWithCallbackRegisteredL();

	inline CHWRMEnhancedLight& GetEnhancedLightSessionWithCallbackRegisteredL();

	inline CHWRMPower& GetPowerSessionWithCallbackRegisteredL();

	inline CHWRMFmTx& GetFmTxSessionWithCallbackRegisteredL();

	void SetCRVibraAttributeL(TUint32 aVibraKey, TInt aValue);

	TInt SetCRVibraAttribute(TUint32 aVibraKey, TInt aValue);

	void GetCRVibraAttributeL(TUint32 aVibraKey, TInt& aValue);

	void GetVibraTimeAttributesL();

	void SetCRLightAttributes(TUint32 aLightKey, TInt aValue);

	void GetCRLightAttributes(TUint32 aLightKey, TInt &aValue);

	void SetLightControlAttributes(TInt aIntensity, TInt aSensitivity, TInt aInUse);

	void GetLightControlAttributes();

	void SetCRPowerAttributeL(TUint32 aVibraKey, TInt aValue);

	void GetCRPowerAttributeL(TUint32 aVibraKey, TInt &aValue);

	void GetPowerAttributesL();

	void SetPowerAttributesMeasurementProcessingTime(TUint aMeasurementProcessingTime);

	void SetCRFmTxAttributeL(TUint32 aVibraKey, TInt aValue);

	void GetCRFmTxAttributeL(TUint32 aVibraKey, TInt &aValue);

	void GetFmTxFrequencyStepSizeL();

	void SetFmTxFrequencyRangeJapanL();

	void SetFmTxFrequencyRangeEuropeL();

	void SetFmTxInactivityTimeOutL(TUint aInactivityTimeOut);

	void ResetDefaultsL();

	inline RMockLight& GetMockLight();

	inline RMockVibra& GetMockVibra();

	inline RMockFmTx& GetMockFmTx();

	inline RMockPowerState& GetMockPowerState();	

	inline RMockPower& GetMockPower();

	void ExpectVibraStatusNotificationL(CHWRMVibra::TVibraStatus aStatus);

	void ExpectVibraModeNotificationL(CHWRMVibra::TVibraModeState aState);

	void ExpectVibraModeNotificationL();

	void ExpectVibraFeedbackModeNotificationL(CHWRMVibra::TVibraFeedbackModeState aStatus);

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

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

	void ExpectFmTxStatusNotificationL(TFmTxState aStatus);

	void ExpectFmTxStatusNotificationL(TFmTxState aStatus1, TFmTxState aStatus2);

	void ExpectFmTxFrequencyNotificationL(TInt aFrequency);	

	void ExpectBatteryLevelNotificationL(EPSHWRMBatteryLevel aBatteryLevel);

	void ExpectBatteryStatusNotificationL(EPSHWRMBatteryStatus aStatus);

	void ExpectedChargingStatusNotificationsL(EPSHWRMChargingStatus aStatus);

	// TO DO: temp solution, need to add counters

	void CheckPluginInsensitivity();

	void ExpectLeave(TInt aError);

	void EndExpectLeaveL(TInt aErr, const TText8* aFile,TInt aLine);

	void CheckMockSYResultL();

	void CheckAllExpectedNotificationsReceived();

	void ExecuteTestL();

	void CheckForEndOfTransition();

	void CleanupPropertyObservers();

	void BatteryLevelChanged(TInt aBatteryLevel);

	void BatteryStatusChanged(TInt aBatteryStatus);

	void ChargingStatusChanged(TInt aChargingStatus);

	const TDesC& MapVibraModeState(CHWRMVibra::TVibraModeState aState);

	const TDesC& MapVibraModeStatus(CHWRMVibra::TVibraStatus aStatus);

	const TDesC& MapLightStatus(CHWRMLight::TLightStatus aStatus);

	const TDesC& MapFmTxStatus(TFmTxState aStatus);

	void SetIgnoreStatusNotifications(TBool aIgnore);

	TBool IgnoringStatusNotifications() const;

	void GetTargetsOn(TInt& aTargetsOnMask) const;

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

	void OpenPowerStateSessionforChrgStatusL();

	void SetPowerChargingCurrentMeasurementProcessingTime(TUint aCallbackProcessingTime);

	void ExpectBatteryChargingStatusErrorL(TInt aErrorCode);

	void ExpectBatteryChargingTimeMeasurementsErrorL(TInt aErrorCode);

	void ExpectBatteryChargingCurrentMeasurementsErrorL(TInt aErrorCode);

#endif

protected:

	TFixedArray<CHWRMVibra*,KMaxNoOpenSessionsForResource> iVibraSessions;

	TFixedArray<CHWRMLight*,KMaxNoOpenSessionsForResource> iLightSessions;

	TFixedArray<CHWRMExtendedLight*,KMaxNoOpenSessionsForResource> iExtLightSessions;

	TFixedArray<CHWRMPower*,KMaxNoOpenSessionsForResource> iPowerSessions;

	TFixedArray<CHWRMFmTx*,KMaxNoOpenSessionsForResource> iFmTxSessions;

	TFixedArray<CHWRMEnhancedLight*,KMaxNoOpenSessionsForResource> iEnhancedLightSessions;

	RMockLight iMockLight;

	TBool iIsMockLightSessionOpen;

	RMockVibra iMockVibra;

	TBool iIsMockVibraSessionOpen;

	RMockPowerState iMockPowerState;

	TBool iIsMockPowerStateSessionOpen;

	RMockPower iMockPower;

	TBool iIsMockPowerSessionOpen;

	RMockFmTx iMockFmTx;

	TBool iIsMockFmTxSessionOpen;

	struct TStepStateBase

		{

		virtual void ExecuteTestState() =0;

		TReal iMaxDurationInSecs;

		};

	template <class T>

	struct TStepState : public TStepStateBase

		{

		typedef void (T::*TTestStateFptr)();

		T* iObject;

		TTestStateFptr iStateFptr;

		virtual void ExecuteTestState();

		};

	RPointerArray<TStepStateBase> iStepStates;

	CActiveScheduler* iScheduler;

	CEndStateTimer* iEndStateTimer;

	TInt iTestResult;

	TInt iCurrentState;

	TInt iExpectedLeaveCode;

	RArray<CHWRMVibra::TVibraStatus> 	iExpectedVibraStatusNotifications;

	RArray<CHWRMVibra::TVibraModeState> iExpectedVibraModeNotifications;

    RArray<CHWRMVibra::TVibraFeedbackModeState>	iExpectedVibraFeedbackModeNotifications;

	RArray<EPSHWRMBatteryLevel> iExpectedBatteryLevelNotifications;

	RArray<EPSHWRMBatteryStatus> iExpectedBatteryStatusNotifications;

	RArray<EPSHWRMChargingStatus> iExpectedChargingStatusNotifications;

	RArray<TInt> iExpectedBatteryPowerMeasurementsError;

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

	RArray<TInt> iExpectedBatteryChargingTimeMeasurementsError;

	RArray<TInt> iExpectedBatteryChargingCurrentMeasurementsError;

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	struct TLightNotification

		{

		TInt iTarget;

		CHWRMLight::TLightStatus iStatus;

		};

	RArray<TLightNotification> iExpectedLightNotifications;

	struct TExtLightNotification

		{

		TInt iTarget;

		CHWRMExtendedLight::TLightStatus iStatus;

		};

	RArray<TExtLightNotification> iExpectedExtLightNotifications;

	struct TFmTxNotification

		{

		TFmTxState iState1;

		TFmTxState iState2;

		};

	RArray<TFmTxNotification> iExpectedFmTxStatusNotifications;

	RArray<TInt> iExpectedFmTxFrequencyNotifications;

	//vibra control attributes

	TInt iVibraMinOffTime;

	TInt iVibraMaxOnTime;

	TInt iPulseMaxDuration;

	TInt iPulseMaxIntensity;

	//light control attributes

	TInt iLightDefaultIntensity;

	TInt iLightDefaultSensitivity;

	TInt iLightSensorEnabled;

	RProperty iLightIntensityProperty;

	RProperty iLightSensitivityProperty;

	TInt iPowerMaxReportingPeriodMicroSeconds;

	TInt iPowerBaseIntervalMicroSeconds;

	TUint iPowerAttributesMeasurementProcessingTime;// milliseconds

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

	TUint iPowerChargingCurrentMeasurementProcessingTime; //milliseconds

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	TInt iFmTxFrequencyStepSize; // KHz

	TBool iSensorSupported;

#ifdef INSECURE_AUDIO_POLICY_KEYS

	//fmtx control attributes

	// Used to mimic Audio Policy behaviour

	RProperty iAudioRoutedProperty;

#endif // INSECURE_AUDIO_POLICY_KEYS  	

	// P&S property observers

	CPsPropertyObserver* iBatteryLevelObserver;

	CPsPropertyObserver* iBatteryStatusObserver;

	CPsPropertyObserver* iChargingStatusObserver;

	TBool iTearingDown;

	TBool iIgnoreStatusNotifications;

	};

//inlines

template <class T>

void CHWRMTestBase::AddTestStateL(T* aObject, void (T::*aTestStateFptr)(),TReal aMaxDurationIsSecs)

	{

	TStepState<T>* testState = new (ELeave)TStepState<T>;

	CleanupStack::PushL(testState);

	testState->iStateFptr = aTestStateFptr;

	testState->iObject = aObject;

	testState->iMaxDurationInSecs = aMaxDurationIsSecs;

	iStepStates.AppendL(testState);

	CleanupStack::Pop(testState);

	}

template <class T>

void CHWRMTestBase::TStepState<T>::ExecuteTestState()

	{

	(iObject->*iStateFptr)();

	}

inline CHWRMVibra& CHWRMTestBase::GetVibraSessionL(TInt aIndex)

	{

	if(!iVibraSessions[aIndex])

		User::Leave(KErrNotFound);

	return *iVibraSessions[aIndex];

	}

inline CHWRMLight& CHWRMTestBase::GetLightSessionL(TInt aIndex)

	{

	if(!iLightSessions[aIndex])

		User::Leave(KErrNotFound);

	return *iLightSessions[aIndex];

	}

inline CHWRMFmTx& CHWRMTestBase::GetFmTxSessionL(TInt aIndex)

	{

	if(!iFmTxSessions[aIndex])

		User::Leave(KErrNotFound);

	return *iFmTxSessions[aIndex];

	}

inline CHWRMExtendedLight& CHWRMTestBase::GetExtLightSessionL(TInt aIndex)

	{

	if(!iExtLightSessions[aIndex])

		User::Leave(KErrNotFound);

	return *iExtLightSessions[aIndex];

	}

inline CHWRMEnhancedLight& CHWRMTestBase::GetEnhancedLightSessionL(TInt aIndex)

	{

	if(!iEnhancedLightSessions[aIndex])

		User::Leave(KErrNotFound);

	return *iEnhancedLightSessions[aIndex];

	}

inline CHWRMPower& CHWRMTestBase::GetPowerSessionL(TInt aIndex)

{

	if(!iPowerSessions[aIndex])

		User::Leave(KErrNotFound);

	return *iPowerSessions[aIndex];

}

inline CHWRMVibra& CHWRMTestBase::GetVibraSessionWithCallbackRegisteredL()

	{

	if(!iVibraSessions[0]) //its always @ idx = 0

		User::Leave(KErrNotFound);

	return *iVibraSessions[0];

	}

inline CHWRMLight& CHWRMTestBase::GetLightSessionWithCallbackRegisteredL()

	{

	if(!iLightSessions[0]) //its always @ idx = 0

		User::Leave(KErrNotFound);

	return *iLightSessions[0];

	}

inline CHWRMExtendedLight& CHWRMTestBase::GetExtLightSessionWithCallbackRegisteredL()

	{

	if(!iExtLightSessions[0]) //its always @ idx = 0

		User::Leave(KErrNotFound);

	return *iExtLightSessions[0];	

	}

inline CHWRMEnhancedLight& CHWRMTestBase::GetEnhancedLightSessionWithCallbackRegisteredL()

	{

	if(!iEnhancedLightSessions[0]) //its always @ idx = 0

		User::Leave(KErrNotFound);

	return *iEnhancedLightSessions[0];	

	}

inline CHWRMPower& CHWRMTestBase::GetPowerSessionWithCallbackRegisteredL()

	{

	if(!iPowerSessions[0]) //its always @ idx = 0

		User::Leave(KErrNotFound);

	return *iPowerSessions[0];

	}

inline CHWRMFmTx& CHWRMTestBase::GetFmTxSessionWithCallbackRegisteredL()

	{

	if(!iFmTxSessions[0]) //its always @ idx = 0

		User::Leave(KErrNotFound);

	return *iFmTxSessions[0];

	}

inline RMockLight& CHWRMTestBase::GetMockLight()

	{

	return iMockLight;

	}

inline RMockVibra& CHWRMTestBase::GetMockVibra()

	{

	return iMockVibra;

	}

inline RMockPowerState& CHWRMTestBase::GetMockPowerState()

	{

	return iMockPowerState;

	}

inline RMockPower& CHWRMTestBase::GetMockPower()

	{

	return iMockPower;

	}

inline RMockFmTx& CHWRMTestBase::GetMockFmTx()

	{

	return iMockFmTx;

	}

inline void CHWRMTestBase::SetTestFail()

	{

	if(!iTestResult)

		{

		iTestResult = KErrTEFUnitFail;

		}

	}

inline void CHWRMTestBase::ExpectLeave(TInt aError)

	{

	iExpectedLeaveCode = aError;

	}

inline void CHWRMTestBase::SetIgnoreStatusNotifications(TBool aIgnore)

	{

	iIgnoreStatusNotifications = aIgnore;

	}

inline TBool CHWRMTestBase::IgnoringStatusNotifications() const

	{

	return iIgnoreStatusNotifications;

	}

#endif // hwrmtest_h