1 

     2 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 // All rights reserved.

     4 // This component and the accompanying materials are made available

     5 // under the terms of "Eclipse Public License v1.0"

     6 // which accompanies this distribution, and is available

     7 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 //

     9 // Initial Contributors:

    10 // Nokia Corporation - initial contribution.

    11 //

    12 // Contributors:

    13 //

    14 // Description:

    15 // Header file: Basic  tests.

    16 // 

    17 //

    18 

    19 /**

    20  @file TestPlayerUtils.h

    21 */

    22 

    23 #ifndef TESTPLAYERUTILS_H

    24 #define TESTPLAYERUTILS_H

    25 

    26 

    27 #include "TSI_MMFACLNT.h"

    28 

    29 // parameter structure for repeat tests

    30 class TRepeatParameters

    31 	{	

    32 public:

    33 	const TText* iFilename;

    34 	TInt	iRepeatCount;

    35 	TInt64 iSilence;

    36 	};

    37 	

    38 const TInt KNegativeRepeat = -4;

    39 /**

    40  * MDelayedMethodCall & CDelayedMethodCall provide a mechanism whereby a method can be called 

    41  * from the ActiveScheduler after a certain length of time. 

    42  *

    43  */

    44 class MDelayedMethodCall

    45 {

    46 public:

    47 	virtual void DelayedMethodCallL() =0;

    48 };

    49 

    50 class CDelayedMethodCall : public CTimer

    51 {

    52 public:

    53 	static CDelayedMethodCall* NewL(MDelayedMethodCall* aThat);

    54 

    55 	virtual void RunL();

    56 	virtual TInt RunError(TInt aError);

    57 protected:

    58 	CDelayedMethodCall(MDelayedMethodCall* aThat);

    59 

    60 private:

    61 	MDelayedMethodCall* const iThat;

    62 };

    63 

    64 

    65 

    66 

    67 /**

    68  * Load and initialise an audio file.

    69  *

    70  * @class CTestMmfAclntFile

    71  *

    72  */         

    73 class CTestMmfAclntFile :  public CTestMmfAclntStep, public MMdaAudioPlayerCallback

    74 	{

    75 public:

    76 	static CTestMmfAclntFile* NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError);

    77 	static CTestMmfAclntFile* NewLC(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError);

    78 	virtual TVerdict DoTestStepL();

    79 	// from MMdaAudioPlayerCallback

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

    81     virtual void MapcPlayComplete(TInt aError);

    82 

    83 private:

    84 	CTestMmfAclntFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TInt aExpectedError);

    85 	

    86 private:

    87 	TInt iError;

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

    89 	TBuf<KNameBufSize> iKeyName;		// Key name for retrieving filename

    90 	TTimeIntervalMicroSeconds iDuration;// Stores duration of audio

    91 	const TBool iPlay;					// Does this test require playing the audio

    92 	const TInt	iExpectedError;			// Is this a negative test

    93 	};

    94 

    95 /**

    96  * Load and play an audio sequence file.

    97  *

    98  * @class CTestMmfAclntSEQNFile

    99  *

   100  */         

   101 class CTestMmfAclntSEQNFile :  public CTestMmfAclntStep, public MMdaAudioPlayerCallback, public MDelayedMethodCall

   102 	{

   103 public:

   104 	static CTestMmfAclntSEQNFile* NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TBool aIsFile);

   105 	static CTestMmfAclntSEQNFile* NewLC(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TBool aIsFile);

   106 	virtual TVerdict DoTestStepL();

   107 	// from MMdaAudioPlayerCallback

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

   109     virtual void MapcPlayComplete(TInt aError);

   110 

   111 	//Used to stop playing after 1 second

   112 	void DelayedMethodCallL();

   113 

   114 private:

   115 	CTestMmfAclntSEQNFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay, const TBool aIsFile);

   116 	

   117 private:

   118 	TInt iError;

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

   120 	TBuf<KNameBufSize> iKeyName;		// Key name for retrieving filename

   121 	TTimeIntervalMicroSeconds iDuration;// Stores duration of audio

   122 	const TBool iPlay;					// Does this test require playing the audio

   123 	const TBool iIsFile;			// Is this a negative test

   124 	};

   125 

   126 

   127 

   128 

   129 /**

   130  * Load and initialise an audio descriptor.

   131  *

   132  * @class CTestMmfAclntDesc

   133  *

   134  */

   135 class CTestMmfAclntDesc : public CTestMmfAclntStep, public MMdaAudioPlayerCallback

   136 	{

   137 public:

   138 	static CTestMmfAclntDesc* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError = KErrNone);

   139 	static CTestMmfAclntDesc* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError);

   140 	virtual TVerdict DoTestStepL();

   141 	virtual TVerdict DoTestStepPreambleL();

   142 	virtual TVerdict DoTestStepPostambleL();

   143 	// from MMdaAudioPlayerCallback

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

   145     virtual void MapcPlayComplete(TInt aError);

   146 

   147 protected:

   148 	CTestMmfAclntDesc(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError) ;

   149 

   150 private:

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

   152 	TBuf<KNameBufSize> iKeyName;		// Key name for retrieving filename

   153 	TTimeIntervalMicroSeconds iDuration;// Stores duration of audio

   154 

   155 protected:

   156 	const TBool iPlay;						// Does this test require playing the audio

   157 	CMdaAudioPlayerUtility * iPlayer;

   158 	HBufC8* iAudio;						// Buffer for holding audio descriptor data

   159 	TInt iError;						// Stores error values for testing

   160 	const TInt	iExpectedError;			// Is this a negative test

   161 	};

   162 

   163 /**

   164  * Load and initialise an audio descriptor (read-only).

   165  *

   166  * @class CTestMmfAclntDescReadOnly

   167  *

   168  */

   169 class CTestMmfAclntDescReadOnly : public CTestMmfAclntDesc

   170 	{

   171 public:

   172 	static CTestMmfAclntDescReadOnly* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError = KErrNone);

   173 	static CTestMmfAclntDescReadOnly* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError);

   174 	virtual TVerdict DoTestStepL();

   175 

   176 private:

   177 	CTestMmfAclntDescReadOnly(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError) ;

   178 

   179 	};

   180 

   181 /**

   182  * Load and initialise an audio descriptor (using Open only).

   183  *

   184  * @class CTestMmfAclntDescOpen

   185  *

   186  */

   187 class CTestMmfAclntDescOpen : public CTestMmfAclntDesc

   188 	{

   189 public:

   190 	static CTestMmfAclntDescOpen* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError = KErrNone);

   191 	static CTestMmfAclntDescOpen* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError);

   192 	virtual TVerdict DoTestStepL();

   193 

   194 private:

   195 	CTestMmfAclntDescOpen(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay,const TInt aExpectedError) ;

   196 

   197 	};

   198 

   199 /**

   200  * Open audio form a URL and play.

   201  *

   202  * @class CTestMmfAclntUrl

   203  *

   204  */

   205 class CTestMmfAclntUrl : public CTestMmfAclntStep, public MMdaAudioPlayerCallback

   206 	{

   207 public:

   208 	static CTestMmfAclntUrl* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay);

   209 	static CTestMmfAclntUrl* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay);

   210 	virtual TVerdict DoTestStepL();

   211 	// from MMdaAudioPlayerCallback

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

   213     virtual void MapcPlayComplete(TInt aError);

   214 

   215 private:

   216 	CTestMmfAclntUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay);

   217 

   218 private:

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

   220 	TBuf<KNameBufSize> iKeyName;		// Key name for retrieving filename

   221 	TTimeIntervalMicroSeconds iDuration;// Stores duration of audio

   222 	TInt iError;						// Stores error values for testing

   223 	const TBool iPlay;					// Does this test require playing the audio

   224 	HBufC8* iAudio;						// Buffer for holding audio descriptor data

   225 	};

   226 

   227 

   228 /**

   229  * Base functionality for most audio player tests

   230  * 

   231  * @class CTestMmfAclntAudioPlayerUtil

   232  *

   233  */

   234 class CTestMmfAclntAudioPlayerUtil : public CTestMmfAclntStep, public MMdaAudioPlayerCallback

   235 	{

   236 public:

   237 	CTestMmfAclntAudioPlayerUtil(const TDesC& aTestName, const TDesC& aSectName);

   238 	virtual TVerdict DoTestStepL();

   239 	// Pure function to access test specific methods

   240 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer)=0;

   241 	// from MMdaAudioPlayerCallback

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

   243     virtual void MapcPlayComplete(TInt aError);

   244 

   245 protected:

   246 	TInt iError;

   247 	TInt iState;

   248 	TBool iStop;

   249 	TTimeIntervalMicroSeconds iDuration;

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

   251 	} ;

   252 

   253 	//

   254 	// RAsyncTestStep

   255 	//

   256 	/**

   257 	 *

   258 	 * Base Async Test class

   259 	 *

   260 	 */	

   261 class CFsmTrigger;

   262 class CAsyncTestMmfAclntAudioPlayerUtil : public RAsyncTestStep, public MMdaAudioPlayerCallback

   263 	{

   264 public:

   265 	CAsyncTestMmfAclntAudioPlayerUtil( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   266 	// state machine to access test specific functions

   267 	virtual void FsmL() = 0;

   268 	// from RAsyncTestStep

   269 	virtual void KickoffTestL();

   270 	virtual void CloseTest();

   271 	// from MMdaAudioPlayerCallback

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

   273     virtual void MapcPlayComplete(TInt aError);

   274 protected:

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

   276 

   277 protected:

   278 	TInt iError;

   279 	enum TTestState

   280 		{

   281 		EStateOpen=0,

   282 		EStateOpened,

   283 		EStatePlay,

   284 		EStatePause,

   285 		EStateSetRepeat,

   286 		EStateStop,

   287 		EStateGetPosition,

   288 		EStateStopTest,

   289 		EStateSetPosition

   290 		};

   291 	TTestState iTestState;

   292 	enum TPlayerState

   293 		{

   294 		EOpening = 0,

   295 		EOpened,

   296 		EPlaying,

   297 		EPaused,

   298 		EStopped		

   299 		};

   300 	TPlayerState iPlayerState;

   301 		

   302 	TTimeIntervalMicroSeconds iClipDuration;

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

   304 	TBuf<KSizeBuf>	iFileName;

   305 	TBuf<KNameBufSize> iKeyName;

   306 		

   307 	TTime iStart;

   308 	TTime iStop;

   309 	

   310 	TInt  iDuration;

   311 	TUint iActualDuration;

   312 	TUint iPausedDuration;

   313 	TUint iResumedDuration;

   314 	TInt  iNumOfRepeatsSet;

   315 	TTimeIntervalMicroSeconds  iSilence;

   316 	CMdaAudioPlayerUtility* iPlayer;

   317 	// AO to invoke the FsmL

   318 	CFsmTrigger* iTrigger;

   319 	} ;	

   320 	

   321 	

   322 class CFsmTrigger:	public CActive

   323 	{

   324 public:

   325 	static CFsmTrigger* NewL(CAsyncTestMmfAclntAudioPlayerUtil& aObserver);

   326 	virtual ~CFsmTrigger();

   327 	

   328 	// From CActive

   329 	virtual void RunL();

   330 	virtual void DoCancel();

   331 

   332 	void StartTimer(TTimeIntervalMicroSeconds32 aDelay);

   333 	

   334 protected:

   335 	CFsmTrigger(CAsyncTestMmfAclntAudioPlayerUtil& aObserver);

   336 	void ConstructL();

   337 

   338 private:

   339 	RTimer iTimer;

   340 	CAsyncTestMmfAclntAudioPlayerUtil& iObserver;

   341 	};

   342 

   343 /*

   344 ==========================================

   345 RAsyncTest for Different SetRepeat scenario

   346 ==========================================

   347 */	

   348 /**

   349  * RAsynctest audio player: repeat play Pause play

   350  *

   351  * @class CAsyncTestMmfAclntAudioRepeatPlayPausePlay

   352  *

   353  */

   354 class CAsyncTestMmfAclntAudioRepeatPlayPausePlay:	public CAsyncTestMmfAclntAudioPlayerUtil

   355 	{

   356 public:

   357 	static CAsyncTestMmfAclntAudioRepeatPlayPausePlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   358 

   359 	// from CTestStepAudInStreamAsyncTest

   360 	void FsmL();

   361 private:

   362 	CAsyncTestMmfAclntAudioRepeatPlayPausePlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   363 	};

   364 		

   365 /**

   366  * RAsynctest audio player: repeat play SetPosition play

   367  *

   368  * @class CAsyncTestMmfAclntAudioRepeatPlayPausePlay

   369  *

   370  */

   371 class CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay:	public CAsyncTestMmfAclntAudioPlayerUtil

   372 	{

   373 public:

   374 	static CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition);

   375 

   376 	// from CTestStepAudInStreamAsyncTest

   377 	void FsmL();

   378 private:

   379 	CAsyncTestMmfAclntAudioRepeatPlayRepositionPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition);

   380 private:

   381 	TTimeIntervalMicroSeconds iPosition;

   382 	};

   383 	

   384 /**

   385  * RAsynctest audio player: repeat play Pause Repeat play

   386  *

   387  * @class CAsyncTestMmfAclntAudioRepeatPlayPausePlay

   388  *

   389  */		

   390 class CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay:	public CAsyncTestMmfAclntAudioPlayerUtil

   391 	{

   392 public:

   393 	static CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   394 

   395 	// from CAsyncTestMmfAclntAudioPlayerUtil

   396 	void FsmL();

   397 

   398 private:

   399 	CAsyncTestMmfAclntAudioRepeatPlayPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   400 	};

   401 	

   402 

   403 /**

   404  * RAsynctest audio player: repeat play Pause Repeat play

   405  *

   406  * @class CAsyncTestMmfAclntAudioPlayPauseRepeatPlay

   407  *

   408  */		

   409 class CAsyncTestMmfAclntAudioPlayPauseRepeatPlay:	public CAsyncTestMmfAclntAudioPlayerUtil

   410 	{

   411 public:

   412 	static CAsyncTestMmfAclntAudioPlayPauseRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   413 

   414 	// from CAsyncTestMmfAclntAudioPlayerUtil

   415 	void FsmL();

   416 

   417 private:

   418 	CAsyncTestMmfAclntAudioPlayPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   419 	};

   420 

   421 /**

   422  * RAsynctest audio player: Play Repeat i,e setting repeat while playing.

   423  *

   424  * @class CAsyncTestMmfAclntAudioPlayRepeat

   425  *

   426  */		

   427 class CAsyncTestMmfAclntAudioPlayRepeat:	public CAsyncTestMmfAclntAudioPlayerUtil

   428 	{

   429 public:

   430 	static CAsyncTestMmfAclntAudioPlayRepeat* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   431 

   432 	// from CAsyncTestMmfAclntAudioPlayerUtil

   433 	void FsmL();

   434 

   435 private:

   436 	CAsyncTestMmfAclntAudioPlayRepeat( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   437 	};

   438 

   439 /**

   440  * RAsynctest audio player: Play Repeat i,e setting repeats before open .

   441  *

   442  * @class CAsyncTestMmfAclntAudioRepeatBeforeOpen

   443  *

   444  */		

   445 class CAsyncTestMmfAclntAudioRepeatBeforeOpen:	public CAsyncTestMmfAclntAudioPlayerUtil

   446 	{

   447 public:

   448 	static CAsyncTestMmfAclntAudioRepeatBeforeOpen* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   449 

   450 	// from CAsyncTestMmfAclntAudioPlayerUtil

   451 	void FsmL();

   452 	void KickoffTestL();

   453 

   454 private:

   455 	CAsyncTestMmfAclntAudioRepeatBeforeOpen( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   456 	};

   457 

   458 /**

   459  * RAsynctest audio player: Play Repeat i,e setting repeats before open .

   460  *

   461  * @class CAsyncTestMmfAclntAudioRepeatBeforeOpen

   462  *

   463  */		

   464 class CAsyncTestMmfAclntRepeatMultipleFiles:	public CAsyncTestMmfAclntAudioPlayerUtil

   465 	{

   466 public:

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

   468 

   469 	// from CAsyncTestMmfAclntAudioPlayerUtil

   470 	void FsmL();

   471 	void KickoffTestL();

   472 

   473 	// PDEF131534 SPPR_PERF: Music player crashes when opening corrupted wav file.

   474 	// WAV file of 96000 Hz is not supported.	

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

   476 

   477 private:

   478 	CAsyncTestMmfAclntRepeatMultipleFiles( const TDesC& aTestName, const TDesC& aSectName);

   479 	TInt iCount;

   480 	};

   481 	

   482 /**

   483  * RAsynctest audio player: Pplay Pause repeat play

   484  *

   485  * @class CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay

   486  *

   487  */		

   488 class CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   489 	{

   490 public:

   491 	static CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   492 

   493 	// from CAsyncTestMmfAclntAudioPlayerUtil

   494 	void FsmL();

   495 	

   496 private:

   497 	CAsyncTestMmfAclntAudioPlayRepeatPauseRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   498 	};

   499 				

   500 /**

   501  * RAsynctest audio player: Pplay Pause repeat play

   502  *

   503  * @class CAsyncTestMmfAclntAudioRepeatPlayStopPlay

   504  *

   505  */		

   506 class CAsyncTestMmfAclntAudioRepeatPlayStopPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   507 	{

   508 public:

   509 	static CAsyncTestMmfAclntAudioRepeatPlayStopPlay* NewL( const TDesC& aTestName, const TDesC& aSectName,	const TDesC& aKeyName);

   510 

   511 	// from CAsyncTestMmfAclntAudioPlayerUtil

   512 	void FsmL();

   513 		

   514 private:

   515 	CAsyncTestMmfAclntAudioRepeatPlayStopPlay( const TDesC& aTestName, const TDesC& aSectName,	const TDesC& aKeyName);

   516 	};

   517 

   518 /**

   519  * RAsynctest audio player: Repeat Play Repeat play

   520  *

   521  * @class CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay

   522  *

   523  */		

   524 class CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   525 	{

   526 public:

   527 	static CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName,	const TDesC& aKeyName);

   528 

   529 	// from CAsyncTestMmfAclntAudioPlayerUtil

   530 	void FsmL();	

   531 

   532 private:

   533 	CAsyncTestMmfAclntAudioRepeatPlayRepeatPlay( const TDesC& aTestName, const TDesC& aSectName,	const TDesC& aKeyName);

   534 	};

   535 	

   536 /**

   537  * RAsynctest audio player: Play/Repeat/Repeat/Play/

   538  *

   539  * @class CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay

   540  *

   541  */		

   542 class CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   543 	{

   544 public:

   545 	static CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   546 

   547 	// from CAsyncTestMmfAclntAudioPlayerUtil

   548 	void FsmL();

   549 

   550 private:

   551 	CAsyncTestMmfAclntAudioPlayRepeatRepeatPlay( const TDesC& aTestName, const TDesC& aSectName,	const TDesC& aKeyName);

   552 	};				

   553 		

   554 /**

   555  * RAsynctest audio player: Play/Repeat/SetVolRamp/Play/

   556  *

   557  * @class CAsyncTestMmfAclntAudioPlayRepeatRamp

   558  *

   559  */		

   560 class CAsyncTestMmfAclntAudioPlayRepeatRamp :	public CAsyncTestMmfAclntAudioPlayerUtil

   561 	{

   562 public:

   563 	static CAsyncTestMmfAclntAudioPlayRepeatRamp* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   564 

   565 	// from CAsyncTestMmfAclntAudioPlayerUtil

   566 	void FsmL();

   567 

   568 private:

   569 	CAsyncTestMmfAclntAudioPlayRepeatRamp( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   570 private:

   571 	TInt iNumOfRepeats;

   572 	};	

   573 	

   574 /**

   575  * RAsynctest audio player: Play/SetRepeatForever/Play/

   576  *

   577  * @class CAsyncTestMmfAclntAudioRepeatForeverPlay

   578  *

   579  */		

   580 class CAsyncTestMmfAclntAudioRepeatForeverPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   581 	{

   582 public:

   583 	static CAsyncTestMmfAclntAudioRepeatForeverPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TTimeIntervalMicroSeconds aTrailingSilence);

   584 

   585 	// from CAsyncTestMmfAclntAudioPlayerUtil

   586 	void FsmL();

   587 

   588 private:

   589 	CAsyncTestMmfAclntAudioRepeatForeverPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TTimeIntervalMicroSeconds aTrailingSilence);

   590 private:

   591 	TTimeIntervalMicroSeconds iTrailingSilence;	

   592 	};

   593 

   594 /**

   595  * RAsynctest audio player: 

   596  *

   597  * @class CAsyncTestMmfAclntAudioRepeatPlayGetPosition

   598  *

   599  */		

   600 

   601 class CAsyncTestMmfAclntAudioRepeatPlayGetPosition :	public CAsyncTestMmfAclntAudioPlayerUtil

   602 	{

   603 public:

   604 	static CAsyncTestMmfAclntAudioRepeatPlayGetPosition* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   605 

   606 	// from CAsyncTestMmfAclntAudioPlayerUtil

   607 	void FsmL();

   608 

   609 private:

   610 	CAsyncTestMmfAclntAudioRepeatPlayGetPosition( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   611 private:

   612 	TTimeIntervalMicroSeconds iPosition;	

   613 	};

   614 		

   615 /**

   616  * RAsynctest audio player: Play/SetRepeatForever/Play/

   617  *

   618  * @class CAsyncTestMmfAclntAudioRepeatForeverPlay

   619  *

   620  */		

   621 

   622 class CAsyncTestMmfAclntDRMRepeatPlay:	public CAsyncTestMmfAclntAudioPlayerUtil

   623 	{

   624 public:

   625 	static CAsyncTestMmfAclntDRMRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, const TDesC& aUniqueId, const TInt aRepeatCount);

   626 

   627 	// from CAsyncTestMmfAclntAudioPlayerUtil

   628 	void FsmL();

   629 	void KickoffTestL();

   630 	

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

   632 	void MapcPlayComplete(TInt aError);

   633 

   634 private:

   635 	CAsyncTestMmfAclntDRMRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName,const TDesC& aUniqueId, const TInt aRepeatCount);

   636 private:

   637 	TBuf<KIDBufSize> iUniqueId;

   638 	};		

   639 		

   640 //===================================================================================

   641 //NEGATIVE TESTS

   642 //=======================================================

   643 /**

   644  * RAsynctest audio player: Set _ve Repeat/Play

   645  *

   646  * @class CAsyncTestMmfAclntAudioPlayRepeatRamp

   647  *

   648  */		

   649 class CAsyncTestMmfAclntAudioNegativeRepeatPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   650 	{

   651 public:

   652 	static CAsyncTestMmfAclntAudioNegativeRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   653 

   654 	// from CAsyncTestMmfAclntAudioPlayerUtil

   655 	void FsmL();

   656 	

   657 private:

   658 	CAsyncTestMmfAclntAudioNegativeRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   659 	};		

   660 		

   661 		

   662 /**

   663  * RAsynctest audio player: Set _ve Repeat/Play

   664  *

   665  * @class CAsyncTestMmfAclntAudioPlayRepeatRamp

   666  *

   667  */		

   668 class CAsyncTestMmfAclntAudioPlayNegativeRepeat :	public CAsyncTestMmfAclntAudioPlayerUtil

   669 	{

   670 public:

   671 	static CAsyncTestMmfAclntAudioPlayNegativeRepeat* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   672 

   673 	// from CAsyncTestMmfAclntAudioPlayerUtil

   674 	void FsmL();

   675 	

   676 private:

   677 	CAsyncTestMmfAclntAudioPlayNegativeRepeat( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   678 	};			

   679 /**

   680  * RAsynctest audio player: SetPlayWindow and Repeat play

   681  *

   682  * @class CAsyncTestMmfAclntAudioPlayRepeatRamp

   683  *

   684  */		

   685 class CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay :	public CAsyncTestMmfAclntAudioPlayerUtil

   686 	{

   687 public:

   688 	static CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay* NewL( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   689 

   690 	// from CAsyncTestMmfAclntAudioPlayerUtil

   691 	void FsmL();

   692 	

   693 private:

   694 	CAsyncTestMmfAclntAudioSetPlayWindowRepeatPlay( const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

   695 private:

   696 	TInt iWindowDuration;

   697 	};	

   698 

   699 //==================================================================================================	

   700 	

   701 /**

   702  * test audio pausing.

   703  *

   704  * @class CTestMmfAclntAudioPlayStopStart

   705  *

   706  */

   707 class CTestMmfAclntAudioPlayStopStart : public CTestMmfAclntAudioPlayerUtil

   708 	{

   709 public:

   710 	CTestMmfAclntAudioPlayStopStart(const TDesC& aTestName, const TDesC& aSectName);

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

   712 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   713 	};

   714 

   715 /**

   716  * test audio pausing.

   717  *

   718  * @class CTestMmfAclntAudioPlayStopStart

   719  *

   720  */

   721 class CTestMmfAclntAudioPlayPauseStart : public CTestMmfAclntAudioPlayerUtil

   722 	{

   723 public:

   724 	CTestMmfAclntAudioPlayPauseStart(const TDesC& aTestName, const TDesC& aSectName);

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

   726 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   727 	};

   728 

   729 /**

   730  * Further testing of audio pausing.

   731  *

   732  * @class CTestMmfAclntAudioPlayPausePlayTest 

   733  *

   734  */

   735 class CTestMmfAclntAudioPlayPausePlayTest : public CTestMmfAclntAudioPlayerUtil

   736 	{

   737 public:

   738 	CTestMmfAclntAudioPlayPausePlayTest(const TDesC& aTestName, const TDesC& aSectName);

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

   740 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   741 	};

   742 

   743 /**

   744  * test audio volume

   745  *

   746  * @class CTestMmfAclntAudioPlayVolume

   747  *

   748  */

   749 class CTestMmfAclntAudioPlayVolume : public CTestMmfAclntAudioPlayerUtil

   750 	{

   751 public:

   752 	CTestMmfAclntAudioPlayVolume(const TDesC& aTestName, const TDesC& aSectName, const TInt aVolume,TBool aNegativeTest);

   753 	static CTestMmfAclntAudioPlayVolume* NewL(const TDesC& aTestName, const TDesC& aSectName, const TInt aVolume=-1, TBool aNegativeTest = EFalse);

   754 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   755 

   756 private:

   757 	TInt iVolume;

   758 	TBool iNegativeTest;

   759 	};

   760 

   761 /**

   762  * test audio player repeat play

   763  *

   764  * @class CTestMmfAclntAudioRepeat

   765  *

   766  */

   767 class CTestMmfAclntAudioRepeat : public CTestMmfAclntAudioPlayerUtil

   768 	{

   769 public:

   770 	CTestMmfAclntAudioRepeat(const TDesC& aTestName, const TDesC& aSectName);

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

   772 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   773 	};

   774 

   775 

   776 /**

   777  * test audio balance

   778  *

   779  * @class CTestMmfAclntAudioBalance

   780  *

   781  */

   782 class CTestMmfAclntAudioBalance : public CTestMmfAclntAudioPlayerUtil

   783 	{

   784 public:

   785 	CTestMmfAclntAudioBalance(const TDesC& aTestName, const TDesC& aSectName, const TInt aValue, const TInt aExpectedError);

   786 	static CTestMmfAclntAudioBalance* NewL(const TDesC& aTestName, const TDesC& aSectName, const TInt aExpectedError, const TInt aValue);//=-1,);

   787 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   788 

   789 private:

   790 	TInt iBalance;

   791 	TInt iExpectedError;

   792 	};

   793 

   794 /**

   795  * test audio duration

   796  *

   797  * @class CTestMmfAclntAudioDuration

   798  *

   799  */

   800 class CTestMmfAclntAudioDuration : public CTestMmfAclntAudioPlayerUtil

   801 	{

   802 public:

   803 	CTestMmfAclntAudioDuration(const TDesC& aTestName, const TDesC& aSectName);

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

   805 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   806 	};

   807 

   808 

   809 /**

   810  * test audio postions

   811  *

   812  * @class CTestMmfAclntAudioPosition

   813  *

   814  */

   815 class CTestMmfAclntAudioPosition : public CTestMmfAclntAudioPlayerUtil

   816 	{

   817 public:

   818 	CTestMmfAclntAudioPosition(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition);

   819 	static CTestMmfAclntAudioPosition* NewL(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition);

   820 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   821 

   822 private:

   823 	TTimeIntervalMicroSeconds iPosition;

   824 	};

   825 

   826 /**

   827  * test audio play window

   828  *

   829  * @class CTestMmfAclntAudioPlayWindow

   830  *

   831  */

   832 class CTestMmfAclntAudioPlayWindow : public CTestMmfAclntAudioPlayerUtil

   833 	{

   834 public:

   835 	CTestMmfAclntAudioPlayWindow(const TDesC& aTestName, const TDesC& aSectName, const TBool aNegative);

   836 	static CTestMmfAclntAudioPlayWindow* NewL(const TDesC& aTestName, const TDesC& aSectName, const TBool aNegative = EFalse);

   837 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   838 private:

   839 	TBool iNegative;

   840 	};

   841 

   842 /**

   843  * get audio type

   844  *

   845  * @class CTestMmfAclntAudioType

   846  *

   847  */

   848 class CTestMmfAclntAudioType : public CTestMmfAclntAudioPlayerUtil

   849 	{

   850 public:

   851 	CTestMmfAclntAudioType(const TDesC& aTestName, const TDesC& aSectName);

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

   853 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   854 	};

   855 

   856 /**

   857  * test audio ramp

   858  *

   859  * @class CTestMmfAclntAudioRamp

   860  *

   861  */

   862 class CTestMmfAclntAudioRamp : public CTestMmfAclntAudioPlayerUtil

   863 	{

   864 public:

   865 	CTestMmfAclntAudioRamp(const TDesC& aTestName, const TDesC& aSectName);

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

   867 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   868 	};

   869 

   870 /**

   871  * view meta data

   872  *

   873  * @class CTestMmfAclntAudioMeta

   874  *

   875  */

   876 class CTestMmfAclntAudioMeta : public CTestMmfAclntAudioPlayerUtil

   877 	{

   878 public:

   879 	CTestMmfAclntAudioMeta(const TDesC& aTestName, const TDesC& aSectName);

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

   881 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   882 	};

   883 

   884 /**

   885  * close and then open the audio clip

   886  *

   887  * @class CTestMmfAclntAudioCloseOpen

   888  *

   889  */

   890 class CTestMmfAclntAudioCloseOpen : public CTestMmfAclntAudioPlayerUtil

   891 	{

   892 public:

   893 	CTestMmfAclntAudioCloseOpen(const TDesC& aTestName, const TDesC& aSectName);

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

   895 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   896 	};

   897 

   898 /**

   899  * query audio formats

   900  *

   901  * @class CTestMmfAclntAudioQuery

   902  *

   903  */

   904 class CTestMmfAclntAudioQuery : public CTestMmfAclntAudioPlayerUtil

   905 	{

   906 public:

   907 	CTestMmfAclntAudioQuery(const TDesC& aTestName, const TDesC& aSectName);

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

   909 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   910 	};

   911 

   912 

   913 /**

   914  * get audio bit rate

   915  *

   916  * @class CTestMmfAclntAudioBitRate

   917  *

   918  */

   919 

   920 class CTestMmfAclntAudioBitRate : public CTestMmfAclntStep, public MMdaAudioPlayerCallback

   921 	{

   922 public:

   923 	static	CTestMmfAclntAudioBitRate* NewL(const TDesC& aTestName,const TDesC& aKeyName1, const TDesC& aKeyName2);

   924     virtual TVerdict DoTestStepL();

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

   926     virtual void MapcPlayComplete(TInt aError);

   927     

   928 private:

   929 	CTestMmfAclntAudioBitRate(const TDesC& aTestName,const TDesC& aKeyName1, const TDesC& aKeyName2);

   930 

   931 private:

   932 	TBuf<KNameBufSize> iKeyFileName;	// Key name for retrieving filename

   933 	TBuf<KNameBufSize> iKeyBitRateName; // Key name for retrieving bit rate

   934 	TTimeIntervalMicroSeconds iDuration;// Stores duration of audio

   935 	TInt iError;						// Stores error values for testing

   936 	TInt iExpectedBitRate;		// Expected bps of the file

   937 	};

   938 

   939 /**

   940  * Audio priority.

   941  *

   942  * @class CTestMmfAclntPriority

   943  *

   944  */

   945 class CTestMmfAclntPriority : public CTestMmfAclntStep, public MCallbackHandlerObserver, public MDelayedMethodCall

   946 	{

   947 public:

   948 	virtual TVerdict DoTestStepL();

   949 	void MchoComplete(TInt aID, TInt aError);

   950 	static CTestMmfAclntPriority* NewL(const TDesC& aTestName, const TDesC& aSectName, const TMdaPriority aPriority);

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

   952 

   953 	//Used to start playing file 0 after file 1 has already started

   954 	void DelayedMethodCallL();

   955 private:

   956 	CTestMmfAclntPriority(const TDesC& aTestName, const TDesC& aSectName, const TMdaPriority aPriority);

   957 	CTestMmfAclntPriority(const TDesC& aTestName, const TDesC& aSectName);

   958 

   959 private:

   960 	CMdaAudioPlayerUtility* audioUtil[2];

   961 

   962 	TInt iCallbackCount;

   963 	TInt iCallbackError[2];

   964 

   965 	TInt iFirstCallback;

   966 	TInt iError;

   967 	TMdaPriority iPriority;

   968 	TBool iPriorityManual;

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

   970 	} ;

   971 

   972 

   973 //

   974 // NEGATIVE TESTS

   975 //

   976 

   977 /** 

   978  *

   979  * Play with no loaded sound file.

   980  *

   981  * @class CTestMmfAclntNoLoad

   982  *

   983  */

   984 class CTestMmfAclntNoLoad : public CTestMmfAclntAudioPlayerUtil

   985 	{

   986 

   987 public:

   988 	CTestMmfAclntNoLoad(const TDesC& aTestName, const TDesC& aSectName);

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

   990 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

   991 	virtual TVerdict DoTestStepL();

   992 	};

   993 

   994 /**

   995  * Audio clip - Delete object before play operation has completed.

   996  *

   997  * @class CTestMmfAclntDeletePlay

   998  *

   999  */

  1000 class CTestMmfAclntDeletePlay : public CTestMmfAclntAudioPlayerUtil

  1001 	{

  1002 public:

  1003 	CTestMmfAclntDeletePlay(const TDesC& aTestName, const TDesC& aSectName);

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

  1005 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

  1006 	};

  1007 

  1008 /** 

  1009  * Open new file while audio player is playing.

  1010  *

  1011  * @class CTestMmfAclntPlayPlay

  1012  * 

  1013  */

  1014 class CTestMmfAclntPlayPlay : public CTestMmfAclntAudioPlayerUtil

  1015 	{

  1016 public:

  1017 	CTestMmfAclntPlayPlay(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

  1018 	static CTestMmfAclntPlayPlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName);

  1019 	virtual TVerdict DoTestL(CMdaAudioPlayerUtility* aPlayer);

  1020 private:

  1021 	TBuf<KNameBufSize> iKeyName;		// Key name for retrieving filename

  1022 	};

  1023 

  1024 /**

  1025  * Play using a corrupt descriptor.

  1026  *

  1027  * @class CTestMmfAclntCorruptDes

  1028  *

  1029  */

  1030 class CTestMmfAclntCorruptDes : public CTestMmfAclntStep, public MMdaAudioPlayerCallback

  1031 	{

  1032 public:

  1033 	CTestMmfAclntCorruptDes(const TDesC& aTestName, const TDesC& aSectName);

  1034 	virtual TVerdict DoTestStepL();

  1035 	virtual TVerdict DoTestStepPreambleL();

  1036 	virtual TVerdict DoTestStepPostambleL();

  1037 	// from MMdaAudioPlayerCallback

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

  1039     virtual void MapcPlayComplete(TInt aError);

  1040 

  1041 private:

  1042 	HBufC8* iAudio;

  1043 	TInt iError;

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

  1045 	} ;

  1046 

  1047 

  1048 #endif