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

// Header file: Declaration for Various Classes used for Audio Resource Notification tests.

// 

//

/**

 @file TestAudioClientUtilitiesARN.h

*/

#ifndef TESTAUDIOCLIENTUTILITIESARN_H

#define TESTAUDIOCLIENTUTILITIESARN_H

#include "mdaaudiosampleplayer.h"

#include "mdaaudiosampleeditor.h"

#include "mdaaudiooutputstream.h"

#include "TestPlayerUtils.h"

#include "TestRecorder.h"

#include "TSI_MMFACLNT.h"

#include <mmf/common/mmfaudio.h>

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

//********************PREQ 797 - Audio Resource Notification********************

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

/**

 * stopActiveScheduler

 */

static TInt stopActiveScheduler(TAny*)

	{

	CActiveScheduler::Stop();

	return KErrNone;

	}

//

//Declarations//

//

//

//Custom Error Codes & CONST Declarations.

//

const TInt KErrUser = -1000;

const TInt KErrBadResult = (KErrUser - 1);

const TInt KMicroSecsInOneSec = 1000000; 

const TUint KSampleRate8000Hz  = 8000;

//

//Forward class declarations

//

class CCallbackTimer;

class CTestMdaAudioPlayerCallbackSupport;

class CTestMdaAudioRecorderCallbackSupport;

class CTestMdaAudioOutputStreamCallbackSupport;

class CTestMdaAudioMultiClientCallbackSupport;

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

//******************PREQ 797 - Audio Player Test Declarations*******************

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

class CMultiEventChecker: public CBase

  {	

public:

	// MultiEvent checker utility enums

	enum TClientUtilityType

		{

		EAudioPlayer = 0,

		EAudioRecorder,

		EAudioStream	

		};

public:

	static CMultiEventChecker* NewL();

    TBool CheckFsm(TInt aClientNumber, TClientUtilityType aClientType,TInt aEventCode, TInt aError=KErrNone,CMdaAudioClipUtility::TState aRecorderState=CMdaAudioClipUtility::ENotReady);

	void StopTest();

	void SetExpectedState(TInt aState);

	void SetExpectedEvent(TInt aClientNumber, TInt aEvent,TInt aError,CMdaAudioClipUtility::TState aRecorderState=CMdaAudioClipUtility::ENotReady);

	void RegisterClientEventToMonitor(TInt aClientNumber, TInt aEventCode, TInt aError, TInt aState,CMdaAudioClipUtility::TState aRecorderState=CMdaAudioClipUtility::ENotReady);

	void EnableMultipleEventMonitor()

		{

		iMonitorMultipleEvents = ETrue;	

		}

	void DisableMultipleEventMonitor()

		{

		iMonitorMultipleEvents = EFalse;		

		}

	TBool IsMutipleEventMonitorEnabled()

		{

		return iMonitorMultipleEvents;

		}

	TInt NextState()

		{

		return iNextState;			

		}

	TBool IsMonitoringFinished();

protected:

	void ConstructL();

	CMultiEventChecker();	

	//Register client events to monitor

	TInt iExpectedEvent;

	TInt iExpectedError;

	CMdaAudioClipUtility::TState iExpectedRecorderState;

	TInt iNextState;

	TFixedArray <TInt, 4> iClientEventsToMonitor;

	TFixedArray <TInt, 4> iClientError;

	TFixedArray <TInt, 4> iFsmStateforClient;

	TInt iClientsRegistered;

	TBool iMonitorMultipleEvents;

	};

//

//BASE CLASS DECLARATIONS//

//

/**

 * Observer class to identify and pass events to the test step class

 * 

 * @class MTestAudioPlayerCallback

 *

 */

class MTestAudioPlayerCallback

	{

public :

	virtual void MapcInitCompleteTest(TInt aError, const TTimeIntervalMicroSeconds& aDuration, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport) = 0;

	virtual void MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport) = 0;

	virtual void MapcPlayCompleteTest(TInt aError, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport) = 0;

	};

/**

 * Support class to pass the events to the test step class using the MTestAudioPlayerCallback

 * 

 * @class CTestMdaAudioPlayerCallbackSupport

 *

 */

class CTestMdaAudioPlayerCallbackSupport : public CBase, public MMdaAudioPlayerCallback, public MMMFAudioResourceNotificationCallback

	{

public :

	static CTestMdaAudioPlayerCallbackSupport* NewL(MTestAudioPlayerCallback& aCallback);

	virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration);

	virtual void MapcPlayComplete(TInt aError);

	virtual void MarncResourceAvailable(TUid aNotificationEventId, const TDesC8& aNotificationData);

protected:

	CTestMdaAudioPlayerCallbackSupport(MTestAudioPlayerCallback& aCallback);

	void ConstructL();

private :

	MTestAudioPlayerCallback& iCallback;

	};

/**

 * Base Class for ARN functionality for most ARN audio player tests

 * 

 * @class CTestMmfAclntAudioPlayerARN

 *

 */

class CTestMmfAclntAudioPlayerARN : public CTestMmfAclntStep, public MTestAudioPlayerCallback

	{

public:

	// Enum to describe the current state.

	enum TMmfAudioPlayerState

		{

		EStateBegin = 0,

		EStateOpenPlayer1,

		EStateOpenPlayer2,

		EStateOpenPlayer3,

		EStatePlaying1,

		EStatePlaying2,

		EStatePlaying3,

		EStateEndPlay1,

		EStateEndPlay2,

		EStateEndPlay3,

		EStateErrInUsePlayer1,

		EStateErrInUsePlayer2,

		EStateErrInUsePlayer3,

		EStateNotifiedPlayer1,

		EStateNotifiedPlayer2,

		EStateNotifiedPlayer3,

		EStateErrInUsePlayer1A,

		EStateNotifiedPlayer1A,

		EStatePlaying2A,

		EStateEndPlay2A

		};

	// Enum to decide which Event has occured.

	enum TMmfAudioPlayerEvents

		{

		EIdlePlayer = 0,

		EMapcInitComplete1,

		EMapcInitComplete2,

		EMapcInitComplete3,

		EMapcPlayComplete1,

		EMapcPlayComplete2,

		EMapcPlayComplete3,

		EMarncResourceAvailable1,

		EMarncResourceAvailable2,

		EMarncResourceAvailable3

		};

public :

	// Constructor

	CTestMmfAclntAudioPlayerARN(const TDesC& aTestName, const TDesC& aSectName);

	// Virtual methods for Preamble and Postamble.

	virtual TVerdict DoTestStepPreambleL();

	virtual TVerdict DoTestStepPostambleL();

	// Virtual function to access test specific methods

	virtual TVerdict DoTestStepL();

	// Pure function to access test specific methods

	virtual TVerdict DoTestL()=0;

	// from MTestAudioPlayerCallback

	virtual void MapcInitCompleteTest(TInt aError, const TTimeIntervalMicroSeconds& aDuration, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport);

	virtual void MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport);

	virtual void MapcPlayCompleteTest(TInt aError, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport);

	// Centralised State Handler

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)=0;

	virtual TBool FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected :	

		// StateInit Function

	void StateInit();

	// StateChange Function

	void StateChange(TMmfAudioPlayerState aState, TMmfAudioPlayerEvents aExpectedEvent, TInt aExpectedError=KErrNone);

protected :	

	// CMdaAudioPlayerUtility instances

	CMdaAudioPlayerUtility* iTestAudioPlayer1;

	CMdaAudioPlayerUtility* iTestAudioPlayer2;

	CMdaAudioPlayerUtility* iTestAudioPlayer3;

	// CTestMdaAudioPlayerCallbackSupport instances

	CTestMdaAudioPlayerCallbackSupport* iMdaAudioPlayerCallbackSupport1;

	CTestMdaAudioPlayerCallbackSupport* iMdaAudioPlayerCallbackSupport2;

	CTestMdaAudioPlayerCallbackSupport* iMdaAudioPlayerCallbackSupport3;

	// Other class variable declarations

	TBuf<KSizeBuf> iFilename1;

	TBuf<KSizeBuf> iFilename2;

	TBuf<KSizeBuf> iFilename3;

	TTimeIntervalMicroSeconds iPosition;

	TTimeIntervalMicroSeconds iDuration;

	TInt iError;

	TMmfAudioPlayerState iState;

	TRequestStatus iRequestStatus;

	CCallBackTimer* iCallBackTimer;

	TMmfAudioPlayerEvents iExpectedEvent;

	TInt iExpectedError;

	TMmfAudioPlayerEvents iEventOccured;

	TBuf<KNameBufSize> iSectName;		// Section name for retrieving filename

	CMultiEventChecker* iEventChecker;

	};

//

//POSITIVE TESTS//

//

/** 

 * Register for notification, but make no request to play audio.

 *

 * @class CTestMmfAclntARN8101

 * 

 */

class CTestMmfAclntARN8101 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8101* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8101( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

	};

/** 

 * Register (b4 play, after Open) and Receive Notification of a Resource Available Event.

 * (when audio resource is currently unavailable and then available)

 *

 * @class CTestMmfAclntARN8102

 * 

 */

class CTestMmfAclntARN8102 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8102* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8102( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

	};

/** 

 * Register (at the time of Play) and Receive Notification of a Resource Available Event.

 * (when audio resource is currently available and subsequently unavailable, and then available)

 *

 * @class CTestMmfAclntARN8103

 * 

 */

class CTestMmfAclntARN8103 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8103* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

	virtual TBool FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8103( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

	};

/** 

 * Registration (b4 File Open) and Cancellation of  the notification request

 *

 * @class CTestMmfAclntARN8104

 * 

 */

class CTestMmfAclntARN8104 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8104* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8104( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

	};

/** 

 * Register (after Play Error) and Get the actual position from where the paused audio can be resumed.

 * Low priority client is played first.

 *

 * @class CTestMmfAclntARN8105

 * 

 */

class CTestMmfAclntARN8105 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8105* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

	virtual TBool FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8105( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

private:

	TTimeIntervalMicroSeconds iPositionStop;

	TTimeIntervalMicroSeconds iPositionResume;

	};

/** 

 * Register (after Play Error) and Get the actual position from where the paused audio can be resumed.

 * High priority client is played first.

 *

 * @class CTestMmfAclntARN8106

 * 

 */

class CTestMmfAclntARN8106 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8106* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

	virtual TBool FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8106( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

private:

	TTimeIntervalMicroSeconds iPositionStop;

	TTimeIntervalMicroSeconds iPositionResume;

	};

/** 

 * Client does not need to Re-register for the same event when the event is received 

 * i.e API is not one shot.

 *

 * @class CTestMmfAclntARN8107

 * 

 */

class CTestMmfAclntARN8107 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8107* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

	virtual TBool FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

	CTestMmfAclntARN8107( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

	};

/** 

 * High priority client plays with repeats and low priority client doesn't get resources

 *

 * @class CTestMmfAclntARN8109

 * 

 */

class CTestMmfAclntARN8109 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8109* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

	virtual TBool FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError);

		// from MTestAudioPlayerCallback

	virtual void MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport);

	virtual void MapcPlayCompleteTest(TInt aError, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport);

protected:

	CTestMmfAclntARN8109( const TDesC& aTestName, const TDesC& aSectName );

	TVerdict PerformTestL();

	TBool TimeComparison(const TUint aActual, const TUint aExpected, const TUint aDeviation);

private:

	TTime iStart;

	TTime iStop;

	TInt  iDuration;

	TUint iActualDuration;

	TBool iPlayComplete2;

	TBool iResourceAvailable1;

	};

/** 

 * Call WillResumePlay()

 *

 * @class CTestMmfAclntARN8108

 * 

 */

class CTestMmfAclntARN8108 : public CTestMmfAclntAudioPlayerARN

	{

public:

	static CTestMmfAclntARN8108* NewL( const TDesC& aTestName, const TDesC& aSectName );

	virtual TVerdict DoTestL();

	virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

	virtual void DecideFsmState(TInt aClientNumber,CMultiEventChecker::TClientUtilityType aClientType, TInt aEventCode, TInt aError=KErrNone);

protected:

	TVerdict HandleStateOpenPlayer1();

	TVerdict HandleStateOpenPlayer3();

	TVerdict HandleStateOpenPlayer2();

	TVerdict HandleStateErrInUsePlayer1();

	TVerdict HandleStateErrInUsePlayer3();

	TVerdict HandleStateNotifiedPlayer1();

	TVerdict HandleStateNotifiedPlayer3();

	TVerdict HandleStatePlaying1();

	CTestMmfAclntARN8108( const TDesC& aTestName, const TDesC& aSectName );

	void InitTest();

	void StartTestL();

	TVerdict PerformTestL();

	typedef TVerdict (CTestMmfAclntARN8108::*fp)();

	TFixedArray<fp,30> iStateHandlers;

	};

/** 

 * Dont register for ARN, get pre-empted and then resume from same position.

 * Test case for DevCR KEVN-7T5EHA 

 * @class CTestMmfAclntARN8110

 * 

 */

class CTestMmfAclntARN8110 : public CTestMmfAclntAudioPlayerARN

    {

public:

    static CTestMmfAclntARN8110* NewL( const TDesC& aTestName, const TDesC& aSectName );

    virtual TVerdict DoTestL();

    virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

    CTestMmfAclntARN8110( const TDesC& aTestName, const TDesC& aSectName );

    TVerdict PerformTestL();

    TTimeIntervalMicroSeconds iPlayer1Pos;

    };

/** 

 * Dont register for ARN, get pre-empted, stop and chk if position is reset, start play again.

 * Test case for DevCR KEVN-7T5EHA 

 * @class CTestMmfAclntARN8111

 * 

 */

class CTestMmfAclntARN8111 : public CTestMmfAclntAudioPlayerARN

    {

public:

    static CTestMmfAclntARN8111* NewL( const TDesC& aTestName, const TDesC& aSectName );

    virtual TVerdict DoTestL();

    virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

    CTestMmfAclntARN8111( const TDesC& aTestName, const TDesC& aSectName );

    TVerdict PerformTestL();

    TTimeIntervalMicroSeconds iPlayer1Pos;

    };

/** 

 * Play higher priority first, then start playing low priority

 * Test case for DevCR KEVN-7T5EHA 

 * @class CTestMmfAclntARN8112

 * 

 */

class CTestMmfAclntARN8112 : public CTestMmfAclntAudioPlayerARN

    {

public:

    static CTestMmfAclntARN8112* NewL( const TDesC& aTestName, const TDesC& aSectName );

    virtual TVerdict DoTestL();

    virtual void FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError);

protected:

    CTestMmfAclntARN8112( const TDesC& aTestName, const TDesC& aSectName );

    TVerdict PerformTestL();

    TTimeIntervalMicroSeconds iPlayer1Pos;

    };

//

//NEGATIVE TESTS//

//

/** 

 * Register for notification with an unsupported event type.

 *

 * @class CTestMmfAclntARN1301