diff -r 000000000000 -r b8ed18f6c07b mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestPlayerUtils.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestPlayerUtils.h Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,1048 @@ + +// Copyright (c) 2001-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: Basic tests. +// +// + +/** + @file TestPlayerUtils.h +*/ + +#ifndef TESTPLAYERUTILS_H +#define TESTPLAYERUTILS_H + + +#include "TSI_MMFACLNT.h" + +// parameter structure for repeat tests +class TRepeatParameters + { +public: + const TText* iFilename; + TInt iRepeatCount; + TInt64 iSilence; + }; + +const TInt KNegativeRepeat = -4; +/** + * MDelayedMethodCall & CDelayedMethodCall provide a mechanism whereby a method can be called + * from the ActiveScheduler after a certain length of time. + * + */ +class MDelayedMethodCall +{ +public: + virtual void DelayedMethodCallL() =0; +}; + +class CDelayedMethodCall : public CTimer +{ +public: + static CDelayedMethodCall* NewL(MDelayedMethodCall* aThat); + + virtual void RunL(); + virtual TInt RunError(TInt aError); +protected: + CDelayedMethodCall(MDelayedMethodCall* aThat); + +private: + MDelayedMethodCall* const iThat; +}; + + + + +/** + * Load and initialise an audio file. + * + * @class CTestMmfAclntFile + * + */ +class CTestMmfAclntFile : public CTestMmfAclntStep, public MMdaAudioPlayerCallback + { +public: + static CTestMmfAclntFile* NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError); + static CTestMmfAclntFile* NewLC(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError); + virtual TVerdict DoTestStepL(); + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + +private: + CTestMmfAclntFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError); + +private: + TInt iError; + TBuf iSectName; // Section name for retrieving filename + TBuf iKeyName; // Key name for retrieving filename + TTimeIntervalMicroSeconds iDuration;// Stores duration of audio + const TBool iPlay; // Does this test require playing the audio + const TInt iExpectedError; // Is this a negative test + }; + +/** + * Load and play an audio sequence file. + * + * @class CTestMmfAclntSEQNFile + * + */ +class CTestMmfAclntSEQNFile : public CTestMmfAclntStep, public MMdaAudioPlayerCallback, public MDelayedMethodCall + { +public: + static CTestMmfAclntSEQNFile* NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TBool aIsFile); + static CTestMmfAclntSEQNFile* NewLC(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TBool aIsFile); + virtual TVerdict DoTestStepL(); + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + + //Used to stop playing after 1 second + void DelayedMethodCallL(); + +private: + CTestMmfAclntSEQNFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TBool aIsFile); + +private: + TInt iError; + TBuf iSectName; // Section name for retrieving filename + TBuf iKeyName; // Key name for retrieving filename + TTimeIntervalMicroSeconds iDuration;// Stores duration of audio + const TBool iPlay; // Does this test require playing the audio + const TBool iIsFile; // Is this a negative test + }; + + + + +/** + * Load and initialise an audio descriptor. + * + * @class CTestMmfAclntDesc + * + */ +class CTestMmfAclntDesc : public CTestMmfAclntStep, public MMdaAudioPlayerCallback + { +public: + static CTestMmfAclntDesc* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError = KErrNone); + static CTestMmfAclntDesc* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError); + virtual TVerdict DoTestStepL(); + virtual TVerdict DoTestStepPreambleL(); + virtual TVerdict DoTestStepPostambleL(); + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + +protected: + CTestMmfAclntDesc(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError) ; + +private: + TBuf iSectName; // Section name for retrieving filename + TBuf iKeyName; // Key name for retrieving filename + TTimeIntervalMicroSeconds iDuration;// Stores duration of audio + +protected: + const TBool iPlay; // Does this test require playing the audio + CMdaAudioPlayerUtility * iPlayer; + HBufC8* iAudio; // Buffer for holding audio descriptor data + TInt iError; // Stores error values for testing + const TInt iExpectedError; // Is this a negative test + }; + +/** + * Load and initialise an audio descriptor (read-only). + * + * @class CTestMmfAclntDescReadOnly + * + */ +class CTestMmfAclntDescReadOnly : public CTestMmfAclntDesc + { +public: + static CTestMmfAclntDescReadOnly* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError = KErrNone); + static CTestMmfAclntDescReadOnly* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError); + virtual TVerdict DoTestStepL(); + +private: + CTestMmfAclntDescReadOnly(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError) ; + + }; + +/** + * Load and initialise an audio descriptor (using Open only). + * + * @class CTestMmfAclntDescOpen + * + */ +class CTestMmfAclntDescOpen : public CTestMmfAclntDesc + { +public: + static CTestMmfAclntDescOpen* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError = KErrNone); + static CTestMmfAclntDescOpen* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError); + virtual TVerdict DoTestStepL(); + +private: + CTestMmfAclntDescOpen(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError) ; + + }; + +/** + * Open audio form a URL and play. + * + * @class CTestMmfAclntUrl + * + */ +class CTestMmfAclntUrl : public CTestMmfAclntStep, public MMdaAudioPlayerCallback + { +public: + static CTestMmfAclntUrl* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay); + static CTestMmfAclntUrl* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay); + virtual TVerdict DoTestStepL(); + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + +private: + CTestMmfAclntUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay); + +private: + TBuf iSectName; // Section name for retrieving filename + TBuf iKeyName; // Key name for retrieving filename + TTimeIntervalMicroSeconds iDuration;// Stores duration of audio + TInt iError; // Stores error values for testing + const TBool iPlay; // Does this test require playing the audio + HBufC8* iAudio; // Buffer for holding audio descriptor data + }; + + +/** + * Base functionality for most audio player tests + * + * @class CTestMmfAclntAudioPlayerUtil + * + */ +class CTestMmfAclntAudioPlayerUtil : public CTestMmfAclntStep, public MMdaAudioPlayerCallback + { +public: + CTestMmfAclntAudioPlayerUtil(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestStepL(); + // Pure function to access test specific methods + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer)=0; + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + +protected: + TInt iError; + TInt iState; + TBool iStop; + TTimeIntervalMicroSeconds iDuration; + TBuf iSectName; // Section name for retrieving filename + } ; + + // + // RAsyncTestStep + // + /** + * + * Base Async Test class + * + */ +class CFsmTrigger; +class CAsyncTestMmfAclntAudioPlayerUtil : public RAsyncTestStep, public MMdaAudioPlayerCallback + { +public: + CAsyncTestMmfAclntAudioPlayerUtil( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + // state machine to access test specific functions + virtual void FsmL() = 0; + // from RAsyncTestStep + virtual void KickoffTestL(); + virtual void CloseTest(); + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); +protected: + TBool TimeComparison(const TUint aActual, const TUint aExpected, const TUint aDeviation); + +protected: + TInt iError; + enum TTestState + { + EStateOpen=0, + EStateOpened, + EStatePlay, + EStatePause, + EStateSetRepeat, + EStateStop, + EStateGetPosition, + EStateStopTest, + EStateSetPosition + }; + TTestState iTestState; + enum TPlayerState + { + EOpening = 0, + EOpened, + EPlaying, + EPaused, + EStopped + }; + TPlayerState iPlayerState; + + TTimeIntervalMicroSeconds iClipDuration; + TBuf iSectName; // Section name for retrieving filename + TBuf iFileName; + TBuf iKeyName; + + TTime iStart; + TTime iStop; + + TInt iDuration; + TUint iActualDuration; + TUint iPausedDuration; + TUint iResumedDuration; + TInt iNumOfRepeatsSet; + TTimeIntervalMicroSeconds iSilence; + CMdaAudioPlayerUtility* iPlayer; + // AO to invoke the FsmL + CFsmTrigger* iTrigger; + } ; + + +class CFsmTrigger: public CActive + { +public: + static CFsmTrigger* NewL(CAsyncTestMmfAclntAudioPlayerUtil& aObserver); + virtual ~CFsmTrigger(); + + // From CActive + virtual void RunL(); + virtual void DoCancel(); + + void StartTimer(TTimeIntervalMicroSeconds32 aDelay); + +protected: + CFsmTrigger(CAsyncTestMmfAclntAudioPlayerUtil& aObserver); + void ConstructL(); + +private: + RTimer iTimer; + CAsyncTestMmfAclntAudioPlayerUtil& iObserver; + }; + +/* +========================================== +RAsyncTest for Different SetRepeat scenario +========================================== +*/ +/** + * RAsynctest audio player: repeat play Pause play + * + * @class CAsyncTestMmfAclntAudioRepeatPlayPausePlay + * + */ +class CAsyncTestMmfAclntAudioRepeatPlayPausePlay: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatPlayPausePlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CTestStepAudInStreamAsyncTest + void FsmL(); +private: + CAsyncTestMmfAclntAudioRepeatPlayPausePlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: repeat play SetPosition play + * + * @class CAsyncTestMmfAclntAudioRepeatPlayPausePlay + * + */ +class CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition); + + // from CTestStepAudInStreamAsyncTest + void FsmL(); +private: + CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition); +private: + TTimeIntervalMicroSeconds iPosition; + }; + +/** + * RAsynctest audio player: repeat play Pause Repeat play + * + * @class CAsyncTestMmfAclntAudioRepeatPlayPausePlay + * + */ +class CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + + +/** + * RAsynctest audio player: repeat play Pause Repeat play + * + * @class CAsyncTestMmfAclntAudioPlayPauseRepeatPlay + * + */ +class CAsyncTestMmfAclntAudioPlayPauseRepeatPlay: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioPlayPauseRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioPlayPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Play Repeat i,e setting repeat while playing. + * + * @class CAsyncTestMmfAclntAudioPlayRepeat + * + */ +class CAsyncTestMmfAclntAudioPlayRepeat: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioPlayRepeat* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioPlayRepeat( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Play Repeat i,e setting repeats before open . + * + * @class CAsyncTestMmfAclntAudioRepeatBeforeOpen + * + */ +class CAsyncTestMmfAclntAudioRepeatBeforeOpen: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatBeforeOpen* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + void KickoffTestL(); + +private: + CAsyncTestMmfAclntAudioRepeatBeforeOpen( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Play Repeat i,e setting repeats before open . + * + * @class CAsyncTestMmfAclntAudioRepeatBeforeOpen + * + */ +class CAsyncTestMmfAclntRepeatMultipleFiles: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntRepeatMultipleFiles* NewL( const TDesC& aTestName, const TDesC& aSectName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + void KickoffTestL(); + + // PDEF131534 SPPR_PERF: Music player crashes when opening corrupted wav file. + // WAV file of 96000 Hz is not supported. + void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration); + +private: + CAsyncTestMmfAclntRepeatMultipleFiles( const TDesC& aTestName, const TDesC& aSectName); + TInt iCount; + }; + +/** + * RAsynctest audio player: Pplay Pause repeat play + * + * @class CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay + * + */ +class CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Pplay Pause repeat play + * + * @class CAsyncTestMmfAclntAudioRepeatPlayStopPlay + * + */ +class CAsyncTestMmfAclntAudioRepeatPlayStopPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatPlayStopPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioRepeatPlayStopPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Repeat Play Repeat play + * + * @class CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay + * + */ +class CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Play/Repeat/Repeat/Play/ + * + * @class CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay + * + */ +class CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + +/** + * RAsynctest audio player: Play/Repeat/SetVolRamp/Play/ + * + * @class CAsyncTestMmfAclntAudioPlayRepeatRamp + * + */ +class CAsyncTestMmfAclntAudioPlayRepeatRamp : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioPlayRepeatRamp* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioPlayRepeatRamp( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); +private: + TInt iNumOfRepeats; + }; + +/** + * RAsynctest audio player: Play/SetRepeatForever/Play/ + * + * @class CAsyncTestMmfAclntAudioRepeatForeverPlay + * + */ +class CAsyncTestMmfAclntAudioRepeatForeverPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatForeverPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TTimeIntervalMicroSeconds aTrailingSilence); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioRepeatForeverPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TTimeIntervalMicroSeconds aTrailingSilence); +private: + TTimeIntervalMicroSeconds iTrailingSilence; + }; + +/** + * RAsynctest audio player: + * + * @class CAsyncTestMmfAclntAudioRepeatPlayGetPosition + * + */ + +class CAsyncTestMmfAclntAudioRepeatPlayGetPosition : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioRepeatPlayGetPosition* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioRepeatPlayGetPosition( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); +private: + TTimeIntervalMicroSeconds iPosition; + }; + +/** + * RAsynctest audio player: Play/SetRepeatForever/Play/ + * + * @class CAsyncTestMmfAclntAudioRepeatForeverPlay + * + */ + +class CAsyncTestMmfAclntDRMRepeatPlay: public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntDRMRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TDesC& aUniqueId, const TInt aRepeatCount); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + void KickoffTestL(); + + void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration); + void MapcPlayComplete(TInt aError); + +private: + CAsyncTestMmfAclntDRMRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName,const TDesC& aUniqueId, const TInt aRepeatCount); +private: + TBuf iUniqueId; + }; + +//=================================================================================== +//NEGATIVE TESTS +//======================================================= +/** + * RAsynctest audio player: Set _ve Repeat/Play + * + * @class CAsyncTestMmfAclntAudioPlayRepeatRamp + * + */ +class CAsyncTestMmfAclntAudioNegativeRepeatPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioNegativeRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioNegativeRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; + + +/** + * RAsynctest audio player: Set _ve Repeat/Play + * + * @class CAsyncTestMmfAclntAudioPlayRepeatRamp + * + */ +class CAsyncTestMmfAclntAudioPlayNegativeRepeat : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioPlayNegativeRepeat* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioPlayNegativeRepeat( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + }; +/** + * RAsynctest audio player: SetPlayWindow and Repeat play + * + * @class CAsyncTestMmfAclntAudioPlayRepeatRamp + * + */ +class CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay : public CAsyncTestMmfAclntAudioPlayerUtil + { +public: + static CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + + // from CAsyncTestMmfAclntAudioPlayerUtil + void FsmL(); + +private: + CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); +private: + TInt iWindowDuration; + }; + +//================================================================================================== + +/** + * test audio pausing. + * + * @class CTestMmfAclntAudioPlayStopStart + * + */ +class CTestMmfAclntAudioPlayStopStart : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioPlayStopStart(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioPlayStopStart* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * test audio pausing. + * + * @class CTestMmfAclntAudioPlayStopStart + * + */ +class CTestMmfAclntAudioPlayPauseStart : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioPlayPauseStart(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioPlayPauseStart* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * Further testing of audio pausing. + * + * @class CTestMmfAclntAudioPlayPausePlayTest + * + */ +class CTestMmfAclntAudioPlayPausePlayTest : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioPlayPausePlayTest(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioPlayPausePlayTest* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * test audio volume + * + * @class CTestMmfAclntAudioPlayVolume + * + */ +class CTestMmfAclntAudioPlayVolume : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioPlayVolume(const TDesC& aTestName, const TDesC& aSectName, const TInt aVolume,TBool aNegativeTest); + static CTestMmfAclntAudioPlayVolume* NewL(const TDesC& aTestName, const TDesC& aSectName, const TInt aVolume=-1, TBool aNegativeTest = EFalse); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + +private: + TInt iVolume; + TBool iNegativeTest; + }; + +/** + * test audio player repeat play + * + * @class CTestMmfAclntAudioRepeat + * + */ +class CTestMmfAclntAudioRepeat : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioRepeat(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioRepeat* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + + +/** + * test audio balance + * + * @class CTestMmfAclntAudioBalance + * + */ +class CTestMmfAclntAudioBalance : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioBalance(const TDesC& aTestName, const TDesC& aSectName, const TInt aValue, const TInt aExpectedError); + static CTestMmfAclntAudioBalance* NewL(const TDesC& aTestName, const TDesC& aSectName, const TInt aExpectedError, const TInt aValue);//=-1,); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + +private: + TInt iBalance; + TInt iExpectedError; + }; + +/** + * test audio duration + * + * @class CTestMmfAclntAudioDuration + * + */ +class CTestMmfAclntAudioDuration : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioDuration(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioDuration* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + + +/** + * test audio postions + * + * @class CTestMmfAclntAudioPosition + * + */ +class CTestMmfAclntAudioPosition : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioPosition(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition); + static CTestMmfAclntAudioPosition* NewL(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + +private: + TTimeIntervalMicroSeconds iPosition; + }; + +/** + * test audio play window + * + * @class CTestMmfAclntAudioPlayWindow + * + */ +class CTestMmfAclntAudioPlayWindow : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioPlayWindow(const TDesC& aTestName, const TDesC& aSectName, const TBool aNegative); + static CTestMmfAclntAudioPlayWindow* NewL(const TDesC& aTestName, const TDesC& aSectName, const TBool aNegative = EFalse); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); +private: + TBool iNegative; + }; + +/** + * get audio type + * + * @class CTestMmfAclntAudioType + * + */ +class CTestMmfAclntAudioType : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioType(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioType* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * test audio ramp + * + * @class CTestMmfAclntAudioRamp + * + */ +class CTestMmfAclntAudioRamp : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioRamp(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioRamp* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * view meta data + * + * @class CTestMmfAclntAudioMeta + * + */ +class CTestMmfAclntAudioMeta : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioMeta(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioMeta* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * close and then open the audio clip + * + * @class CTestMmfAclntAudioCloseOpen + * + */ +class CTestMmfAclntAudioCloseOpen : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioCloseOpen(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioCloseOpen* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * query audio formats + * + * @class CTestMmfAclntAudioQuery + * + */ +class CTestMmfAclntAudioQuery : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntAudioQuery(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntAudioQuery* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + + +/** + * get audio bit rate + * + * @class CTestMmfAclntAudioBitRate + * + */ + +class CTestMmfAclntAudioBitRate : public CTestMmfAclntStep, public MMdaAudioPlayerCallback + { +public: + static CTestMmfAclntAudioBitRate* NewL(const TDesC& aTestName,const TDesC& aKeyName1, const TDesC& aKeyName2); + virtual TVerdict DoTestStepL(); + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + +private: + CTestMmfAclntAudioBitRate(const TDesC& aTestName,const TDesC& aKeyName1, const TDesC& aKeyName2); + +private: + TBuf iKeyFileName; // Key name for retrieving filename + TBuf iKeyBitRateName; // Key name for retrieving bit rate + TTimeIntervalMicroSeconds iDuration;// Stores duration of audio + TInt iError; // Stores error values for testing + TInt iExpectedBitRate; // Expected bps of the file + }; + +/** + * Audio priority. + * + * @class CTestMmfAclntPriority + * + */ +class CTestMmfAclntPriority : public CTestMmfAclntStep, public MCallbackHandlerObserver, public MDelayedMethodCall + { +public: + virtual TVerdict DoTestStepL(); + void MchoComplete(TInt aID, TInt aError); + static CTestMmfAclntPriority* NewL(const TDesC& aTestName, const TDesC& aSectName, const TMdaPriority aPriority); + static CTestMmfAclntPriority* NewL(const TDesC& aTestName, const TDesC& aSectName); + + //Used to start playing file 0 after file 1 has already started + void DelayedMethodCallL(); +private: + CTestMmfAclntPriority(const TDesC& aTestName, const TDesC& aSectName, const TMdaPriority aPriority); + CTestMmfAclntPriority(const TDesC& aTestName, const TDesC& aSectName); + +private: + CMdaAudioPlayerUtility* audioUtil[2]; + + TInt iCallbackCount; + TInt iCallbackError[2]; + + TInt iFirstCallback; + TInt iError; + TMdaPriority iPriority; + TBool iPriorityManual; + TBuf iSectName; // Section name for retrieving filename + } ; + + +// +// NEGATIVE TESTS +// + +/** + * + * Play with no loaded sound file. + * + * @class CTestMmfAclntNoLoad + * + */ +class CTestMmfAclntNoLoad : public CTestMmfAclntAudioPlayerUtil + { + +public: + CTestMmfAclntNoLoad(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntNoLoad* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + virtual TVerdict DoTestStepL(); + }; + +/** + * Audio clip - Delete object before play operation has completed. + * + * @class CTestMmfAclntDeletePlay + * + */ +class CTestMmfAclntDeletePlay : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntDeletePlay(const TDesC& aTestName, const TDesC& aSectName); + static CTestMmfAclntDeletePlay* NewL(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); + }; + +/** + * Open new file while audio player is playing. + * + * @class CTestMmfAclntPlayPlay + * + */ +class CTestMmfAclntPlayPlay : public CTestMmfAclntAudioPlayerUtil + { +public: + CTestMmfAclntPlayPlay(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + static CTestMmfAclntPlayPlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName); + virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer); +private: + TBuf iKeyName; // Key name for retrieving filename + }; + +/** + * Play using a corrupt descriptor. + * + * @class CTestMmfAclntCorruptDes + * + */ +class CTestMmfAclntCorruptDes : public CTestMmfAclntStep, public MMdaAudioPlayerCallback + { +public: + CTestMmfAclntCorruptDes(const TDesC& aTestName, const TDesC& aSectName); + virtual TVerdict DoTestStepL(); + virtual TVerdict DoTestStepPreambleL(); + virtual TVerdict DoTestStepPostambleL(); + // from MMdaAudioPlayerCallback + virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + virtual void MapcPlayComplete(TInt aError); + +private: + HBufC8* iAudio; + TInt iError; + TBuf iSectName; // Section name for retrieving filename + } ; + + +#endif