1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Declarations of Integration test step classes for A3F DevSound Play cases.

    15 // 

    16 //

    17 

    18 #ifndef TSI_A3F_DEVSOUND_PLAY_H

    19 #define TSI_A3F_DEVSOUND_PLAY_H

    20 

    21 // User includes

    22 #include "tsi_a3f_devsound_teststep.h"

    23 

    24 /*

    25  *

    26  * RTestStepA3FDevSoundPlayBase

    27  *

    28  */

    29 class RTestStepA3FDevSoundPlayBase : public RAsyncTestStep,

    30 									 public MDevSoundObserver

    31 	{

    32 public:

    33 	// From RAsyncTestStep

    34 	virtual void KickoffTestL();

    35 	virtual void CloseTest();

    36 

    37 protected:

    38 	RTestStepA3FDevSoundPlayBase(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

    39 	RTestStepA3FDevSoundPlayBase(const TDesC& aTestName, const TDesC& aSectName);

    40 	RTestStepA3FDevSoundPlayBase(const TDesC& aTestName, const TFourCC& aInputDataType);

    41 	RTestStepA3FDevSoundPlayBase(const TDesC& aTestName);

    42 

    43 	virtual void DoKickoffTestL();

    44 

    45 	// Executes the playing events of DevSound using a Finite State Machine

    46 	virtual void Fsm(TDevSoundPlayEvents aDevSoundEvent, TInt aError);

    47 

    48 	// From MDevSoundObserver

    49 	virtual void InitializeComplete(TInt aError);

    50 	virtual void ToneFinished(TInt aError);

    51 	virtual void BufferToBeFilled(CMMFBuffer* aBuffer);

    52 	virtual void PlayError(TInt aError);

    53 	virtual void BufferToBeEmptied(CMMFBuffer* aBuffer);

    54 	virtual void RecordError(TInt aError);

    55 	virtual void ConvertError(TInt aError);

    56 	virtual void DeviceMessage(TUid aMessageType, const TDesC8& aMsg);

    57 

    58 	// Timer Callback

    59 	static TInt TimerCallback(TAny*);

    60 	virtual void DoTimerCallback();

    61 

    62 	TUint ConvertDesToTMMFSampleRate(const TDesC& aSampleRateString);

    63 	TUint ConvertDesToTMMFMonoStereo(const TDesC& aMonoStereoString);

    64 	void DisplayCodecInfo();

    65 	void SetSampleRateAndChannelMode();

    66 	void CheckConfigAndFourCCUsage();

    67 

    68 protected:

    69 	RFs iFs;

    70 	RFile iFile;

    71 	CMMFDevSound* iMMFDevSound;

    72 	CMMFBuffer* iBuffer;

    73 	CPeriodic* iTimer;

    74 	TCallBack iCallBack;

    75 	TFourCC iInputDataType; // datatype (FourCC) of the Decoder

    76 	TBuf<KNameSize> iSectName;

    77 	TPtrC iFilename;

    78 	TPtrC iSampleRate;

    79 	TPtrC iMonoStereo;

    80 	TDevSoundPlayState iPlayState;

    81 	TInt iBufferCount;

    82 	TBool iConfig;

    83 	TBool iInvalidConfig;

    84 	TBool iUseFourCC;

    85 

    86 	};

    87 

    88 /*

    89  *

    90  * RStepA3FDevSoundPlaySimple

    91  *

    92  */

    93 class RStepA3FDevSoundPlaySimple : public RTestStepA3FDevSoundPlayBase

    94 	{

    95 public:

    96 	static RStepA3FDevSoundPlaySimple* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

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

    98 

    99 private:

   100 	RStepA3FDevSoundPlaySimple(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   101 	RStepA3FDevSoundPlaySimple(const TDesC& aTestName, const TDesC& aSectName);

   102 

   103 	};

   104 

   105 /*

   106  *

   107  *	RStepA3FDevSoundPlayEmpty

   108  *

   109  */

   110 class RStepA3FDevSoundPlayEmpty : public RTestStepA3FDevSoundPlayBase

   111 	{

   112 public:

   113 	static RStepA3FDevSoundPlayEmpty* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   114 

   115 private:

   116 	RStepA3FDevSoundPlayEmpty(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   117 

   118 	// From RTestStepA3FDevSoundPlayBase

   119 	virtual void Fsm(TDevSoundPlayEvents aDevSoundEvent, TInt aError);

   120 

   121 	};

   122 

   123 /*

   124  *

   125  *	RStepA3FDevSoundPlayInvalidConfig

   126  *

   127  */

   128 class RStepA3FDevSoundPlayInvalidConfig : public RTestStepA3FDevSoundPlayBase

   129 	{

   130 public:

   131 	static RStepA3FDevSoundPlayInvalidConfig* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   132 

   133 private:

   134 	RStepA3FDevSoundPlayInvalidConfig(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   135 

   136 	// From RAsyncTestStep

   137 	virtual void KickoffTestL();

   138 

   139 	// From MDevSoundObserver

   140 	virtual void PlayError(TInt aError);

   141 

   142 	};

   143 

   144 /*

   145  *

   146  * RStepA3FDevSoundPlayInvalidFourCC

   147  *

   148  */

   149 class RStepA3FDevSoundPlayInvalidFourCC : public RTestStepA3FDevSoundPlayBase

   150 	{

   151 public:

   152 	static RStepA3FDevSoundPlayInvalidFourCC* NewL(const TDesC& aTestName, const TFourCC& aInputDataType);

   153 

   154 private:

   155 	RStepA3FDevSoundPlayInvalidFourCC(const TDesC& aTestName, const TFourCC& aInputDataType);

   156 

   157 	// From RAsyncTestStep

   158 	virtual void KickoffTestL();

   159 

   160 	// From RTestStepA3FDevSoundPlayBase

   161 	virtual void Fsm(TDevSoundPlayEvents aDevSoundEvent, TInt aError);

   162 

   163 	};

   164 

   165 /*

   166  *

   167  * RStepA3FDevSoundInitializeWithHwDeviceUID

   168  *

   169  */

   170 class RStepA3FDevSoundInitializeWithHwDeviceUID : public RTestStepA3FDevSoundPlayBase

   171 	{

   172 public:

   173 	static RStepA3FDevSoundInitializeWithHwDeviceUID* NewL(const TDesC& aTestName);

   174 

   175 private:

   176 	RStepA3FDevSoundInitializeWithHwDeviceUID(const TDesC& aTestName);

   177 

   178 	// From RAsyncTestStep

   179 	virtual void KickoffTestL();

   180 

   181 	// From RTestStepA3FDevSoundPlayBase

   182 	virtual void Fsm(TDevSoundPlayEvents aDevSoundEvent, TInt aError);

   183 

   184 	};

   185 

   186 /**

   187  *

   188  *	RStepA3FDevSoundReadConfigDuringPlay

   189  */

   190 class RStepA3FDevSoundReadConfigDuringPlay : public RTestStepA3FDevSoundPlayBase

   191 	{

   192 public:

   193 	static RStepA3FDevSoundReadConfigDuringPlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   194 

   195 private:

   196 	RStepA3FDevSoundReadConfigDuringPlay(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   197 

   198 	// From MDevSoundObserver

   199 	virtual void BufferToBeFilled(CMMFBuffer* aBuffer);

   200 

   201 	};

   202 

   203 /*

   204  *

   205  * RStepA3FDevSoundSetVolPlayStopGetVol

   206  *

   207  */

   208 class RStepA3FDevSoundSetVolPlayStopGetVol : public RTestStepA3FDevSoundPlayBase

   209 	{

   210 public:

   211 	static RStepA3FDevSoundSetVolPlayStopGetVol* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   212 

   213 private:

   214 	RStepA3FDevSoundSetVolPlayStopGetVol(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   215 

   216 	// From RTestStepA3FDevSoundPlayBase

   217 	virtual void DoKickoffTestL();

   218 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   219 	virtual void DoTimerCallback();

   220 

   221 private:

   222 	TInt iSetVolume;

   223 	TInt iVolDuringStopped;

   224 	TBool iCheckTimer;

   225 

   226 	};

   227 

   228 /*

   229  *

   230  * RStepA3FDevSoundFlushBuffersPaused

   231  *

   232  */

   233 class RStepA3FDevSoundFlushBuffersPaused : public RTestStepA3FDevSoundPlayBase

   234 	{

   235 public:

   236 	static RStepA3FDevSoundFlushBuffersPaused* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   237 

   238 private:

   239 	RStepA3FDevSoundFlushBuffersPaused(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   240 

   241 	// From RTestStepA3FDevSoundPlayBase

   242 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   243 	virtual void DoTimerCallback();

   244 

   245 	// From MDevSoundObserver

   246 	void BufferToBeFilled(CMMFBuffer* aBuffer);

   247 

   248 private:

   249 	TBool iCheckTimer;

   250 

   251 	};

   252 

   253 /*

   254  *

   255  * RStepA3FDevSoundInvalidStatePlay

   256  *

   257  */

   258 class RStepA3FDevSoundInvalidStatePlay : public RTestStepA3FDevSoundPlayBase

   259 	{

   260 public:

   261 	static RStepA3FDevSoundInvalidStatePlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   262 

   263 private:

   264 	RStepA3FDevSoundInvalidStatePlay(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   265 

   266 	// From RAsyncTestStep

   267 	virtual void KickoffTestL();

   268 

   269 	// From RTestStepA3FDevSoundPlayBase

   270 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   271 

   272 	// From MDevSoundObserver

   273 	virtual void BufferToBeFilled(CMMFBuffer* aBuffer);

   274 	virtual void PlayError(TInt aError);

   275 

   276 	};

   277 

   278 /*

   279  *

   280  * RStepA3FDevSoundFlushBuffersPlaying

   281  *

   282  */

   283 class RStepA3FDevSoundFlushBuffersPlaying : public RTestStepA3FDevSoundPlayBase

   284 	{

   285 public:

   286 	static RStepA3FDevSoundFlushBuffersPlaying* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   287 

   288 private:

   289 	RStepA3FDevSoundFlushBuffersPlaying(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   290 

   291 	// From RTestStepA3FDevSoundPlayBase

   292 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   293 

   294 	};

   295 

   296 /*

   297  *

   298  * RStepA3FDevSoundInitializeWhilePlaying

   299  *

   300  */

   301 class RStepA3FDevSoundInitializeWhilePlaying : public RTestStepA3FDevSoundPlayBase

   302 	{

   303 public:

   304 	static RStepA3FDevSoundInitializeWhilePlaying* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   305 

   306 private:

   307 	RStepA3FDevSoundInitializeWhilePlaying(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   308 

   309 	// From RTestStepA3FDevSoundPlayBase

   310 	void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   311 	void DoTimerCallback();

   312 

   313 private:

   314 	TBool iCheckTimer;

   315 

   316 	};

   317 

   318 /*

   319  *

   320  * RStepA3FDevSoundSetBalanceDuringPlay

   321  *

   322  */

   323 class RStepA3FDevSoundSetBalanceDuringPlay : public RTestStepA3FDevSoundPlayBase

   324 	{

   325 public:

   326 	static RStepA3FDevSoundSetBalanceDuringPlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   327 

   328 private:

   329 	RStepA3FDevSoundSetBalanceDuringPlay(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   330 

   331 	// From RTestStepA3FDevSoundPlayBase

   332 	virtual void DoKickoffTestL();

   333 

   334 	// From MDevSoundObserver

   335 	virtual void BufferToBeFilled(CMMFBuffer* aBuffer);

   336 

   337 private:

   338 	TInt iPlaybalanceLeft;

   339 	TInt iPlaybalanceRight;

   340 

   341 	};

   342 

   343 /*

   344  *

   345  * RStepA3FDevSoundPlayStopMultipleTimes

   346  *

   347  */

   348 class RStepA3FDevSoundPlayStopMultipleTimes : public RTestStepA3FDevSoundPlayBase

   349 	{

   350 public:

   351 	static RStepA3FDevSoundPlayStopMultipleTimes* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   352 

   353 private:

   354 

   355 	RStepA3FDevSoundPlayStopMultipleTimes(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   356 

   357 	// From RTestStepA3FDevSoundPlayBase

   358 	virtual void DoKickoffTestL();

   359 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   360 	virtual void DoTimerCallback();

   361 

   362 private:

   363 	TInt iRepeatCount;

   364 	TInt iRepeatCounter;

   365 	TBool iCheckTimer;

   366 

   367 	};

   368 

   369 /*

   370  *

   371  * RStepA3FDevSoundPlayEOFPlayMultipleTimes

   372  *

   373  */

   374 class RStepA3FDevSoundPlayEOFPlayMultipleTimes : public RTestStepA3FDevSoundPlayBase

   375 	{

   376 public:

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

   378 

   379 private:

   380 	RStepA3FDevSoundPlayEOFPlayMultipleTimes(const TDesC& aTestName, const TDesC& aSectName);

   381 

   382 	// From RTestStepA3FDevSoundPlayBase

   383 	virtual void DoKickoffTestL();

   384 

   385 	// From MDevSoundObserver

   386 	virtual void PlayError(TInt aError);

   387 

   388 private:

   389 	TInt iRepeatCount;

   390 	TInt iRepeatCounter;

   391 

   392 	};

   393 

   394 /*

   395  *

   396  * RStepA3FDevSoundInititalizeDuringInitialize

   397  *

   398  */

   399 class RStepA3FDevSoundInititalizeDuringInitialize : public RTestStepA3FDevSoundPlayBase

   400 	{

   401 public:

   402 	static RStepA3FDevSoundInititalizeDuringInitialize* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   403 

   404 private:

   405 	RStepA3FDevSoundInititalizeDuringInitialize(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   406 

   407 	// From RAsyncTestStep

   408 	virtual void KickoffTestL();

   409 

   410 	// From RTestStepA3FDevSoundPlayBase

   411 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   412 

   413 	// From MDevSoundObserver

   414 	virtual void InitializeComplete(TInt aError);

   415 

   416 private:

   417 	TInt iSecondInitErr;

   418 

   419 	};

   420 

   421 /*

   422  *

   423  * RStepA3FDevSoundPlayInitDuringPlayInit

   424  *

   425  */

   426 class RStepA3FDevSoundPlayInitDuringPlayInit : public RTestStepA3FDevSoundPlayBase

   427 	{

   428 public:

   429 	static RStepA3FDevSoundPlayInitDuringPlayInit* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   430 

   431 private:

   432 	RStepA3FDevSoundPlayInitDuringPlayInit(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   433 

   434 	// From RASyncTestStep

   435 	virtual void KickoffTestL();

   436 

   437 	// From RTestStepA3FDevSoundPlayBase

   438 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   439 

   440 	// From MDevSoundObserver

   441 	virtual void BufferToBeFilled(CMMFBuffer* aBuffer);

   442 

   443 private:

   444 	TInt iFirstPlayInitErr;

   445 	TInt iSecondPlayInitErr;

   446 

   447 	};

   448 

   449 /*

   450  *

   451  * RStepA3FDevSoundVolumeCrop

   452  *

   453  */

   454 class RStepA3FDevSoundVolumeCrop : public RTestStepA3FDevSoundPlayBase

   455 	{

   456 public:

   457 	static RStepA3FDevSoundVolumeCrop* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   458 

   459 private:

   460 	RStepA3FDevSoundVolumeCrop(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   461 

   462 	// From RAsyncTestStep

   463 	virtual void KickoffTestL();

   464 

   465 	// From RTestStepA3FDevSoundPlayBase

   466 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   467 

   468 private:

   469 	TInt iIncreaseMaxVolume;

   470 	TInt iMinVolume;

   471 

   472 	};

   473 

   474 /*

   475  *

   476  * RStepA3FDevSoundInitializeForConverting

   477  *

   478  */

   479 class RStepA3FDevSoundInitializeForConverting : public RTestStepA3FDevSoundPlayBase

   480 	{

   481 public:

   482 	static RStepA3FDevSoundInitializeForConverting* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   483 

   484 private:

   485 	RStepA3FDevSoundInitializeForConverting(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   486 

   487 	// From RAsyncTestStep

   488 	virtual void KickoffTestL();

   489 

   490 	// From RTestStepA3FDevSoundPlayBase

   491 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   492 

   493 	};

   494 

   495 /*

   496  *

   497  * RStepA3FDevSoundGetSampleNumsDuringPlayStop

   498  *

   499  */

   500 class RStepA3FDevSoundGetSampleNumsAfterStop : public RTestStepA3FDevSoundPlayBase

   501 	{

   502 public:

   503 	static RStepA3FDevSoundGetSampleNumsAfterStop* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   504 

   505 private:

   506 	RStepA3FDevSoundGetSampleNumsAfterStop(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   507 

   508 	// From RTestStepA3FDevSoundPlayBase

   509 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   510 	virtual void DoTimerCallback();

   511 

   512 private:

   513 	TBool iCheckTimer;

   514 

   515 	};

   516 

   517 /*

   518  *

   519  * RStepA3FDevSoundCancelInitializePlay

   520  *

   521  */

   522 class RStepA3FDevSoundCancelInitializePlay : public RTestStepA3FDevSoundPlayBase

   523 	{

   524 public:

   525 	static RStepA3FDevSoundCancelInitializePlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   526 

   527 private:

   528 	RStepA3FDevSoundCancelInitializePlay(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   529 

   530 	// From RTestStepA3FDevSoundPlayBase

   531 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   532 	virtual void DoTimerCallback();

   533 	virtual void KickoffTestL();

   534 	

   535 	// From MDevSoundObserver

   536 	virtual void InitializeComplete(TInt aError);

   537 	

   538 	};	

   539 

   540 /*

   541  *

   542  * RStepA3FDevSoundNegCancelInitializePlay

   543  *

   544  */

   545 class RStepA3FDevSoundNegCancelInitializePlay : public RTestStepA3FDevSoundPlayBase

   546 	{

   547 public:

   548 	static RStepA3FDevSoundNegCancelInitializePlay* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   549 

   550 private:

   551 	RStepA3FDevSoundNegCancelInitializePlay(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   552 

   553 	// From RTestStepA3FDevSoundPlayBase

   554 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   555 	virtual void KickoffTestL();

   556 	

   557 	// From MDevSoundObserver

   558 	virtual void InitializeComplete(TInt aError);

   559 

   560 	};

   561 

   562 /*

   563  *

   564  * RStepA3FDevSoundEmptyBuffersInCreatedState

   565  *

   566  */

   567 class RStepA3FDevSoundEmptyBuffersInCreatedState : public RTestStepA3FDevSoundPlayBase

   568 	{

   569 public:

   570 	static RStepA3FDevSoundEmptyBuffersInCreatedState* NewL(const TDesC& aTestName);

   571 

   572 private:

   573 	RStepA3FDevSoundEmptyBuffersInCreatedState(const TDesC& aTestName);

   574 

   575 	// From RTestStepA3FDevSoundPlayBase

   576 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   577 	virtual void KickoffTestL();

   578 	

   579 	};

   580 

   581 /*

   582  *

   583  * RStepA3FDevSoundEmptyBuffersInInitializedState

   584  *

   585  */

   586 class RStepA3FDevSoundEmptyBuffersInInitializedState : public RTestStepA3FDevSoundPlayBase

   587 	{

   588 public:

   589 	static RStepA3FDevSoundEmptyBuffersInInitializedState* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   590 

   591 private:

   592 	RStepA3FDevSoundEmptyBuffersInInitializedState(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   593 

   594 	// From RTestStepA3FDevSoundPlayBase

   595 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   596 	virtual void KickoffTestL();

   597 

   598 	};

   599 	

   600 /*

   601  *

   602  * RStepA3FDevSoundEmptyBuffersInInitializingState

   603  *

   604  */

   605 class RStepA3FDevSoundEmptyBuffersInInitializingState : public RTestStepA3FDevSoundPlayBase

   606 	{

   607 public:

   608 	static RStepA3FDevSoundEmptyBuffersInInitializingState* NewL(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   609 

   610 private:

   611 	RStepA3FDevSoundEmptyBuffersInInitializingState(const TDesC& aTestName, const TDesC& aSectName, const TFourCC& aInputDataType);

   612 

   613 	// From RTestStepA3FDevSoundPlayBase

   614 	virtual void Fsm(TDevSoundPlayEvents aEventCode, TInt aError);

   615 	virtual void KickoffTestL();

   616 	

   617 	// From MDevSoundObserver

   618 	virtual void InitializeComplete(TInt aError);

   619 

   620 	};

   621 	

   622 #endif // TSI_A3F_DEVSOUND_PLAY_H