1 // Copyright (c) 2006-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 //

    15 

    16 

    17 #ifndef AUDIORECTEST_H

    18 #define AUDIORECTEST_H

    19 

    20 #include "char_audiorec_common.h"

    21 

    22 

    23 /*******************************

    24 * Creating Meta Data Variables

    25 ********************************/

    26 

    27 _LIT(name,"<Copyright>");

    28 _LIT(data,"<Symbian (c) 2006 - 2007>");

    29 _LIT(name2,"Artist");

    30 _LIT(data2,"Test");

    31 

    32 /*******************************

    33 * Base Class derived From RAsync

    34 ********************************/

    35 class RAudioRecTestStep : public RAudioRecTest

    36 	{

    37 public:

    38      static RAudioRecTestStep* NewL(const TDesC& aStepName, const TDesC& aFileName);

    39      

    40 	// from RAsyncTestStep

    41 	 void DoKickoffTestL();  //-- for the derived class to implement

    42 	

    43 	//State Machine Functions

    44 	void Fsm(TAudioRecorderState aEventCode);

    45 			

    46 private:

    47 	RAudioRecTestStep(const TDesC& aStepName, const TDesC& aFilename);

    48 	void DoTimerCallback();

    49 	};

    50 

    51 

    52 /**********************************

    53 class for Open an audio file in Opened State.

    54 ***********************************/

    55 class RTestStepAudioRecOpen : public RAudioRecTest

    56 	{

    57 public:

    58      static RTestStepAudioRecOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

    59 	// from RAsyncTestStep

    60 	 void DoKickoffTestL();  //-- for the derived class to implement

    61 	//State Machine Functions

    62 	void Fsm(TAudioRecorderState aEventCode);

    63 			

    64 private:

    65 	RTestStepAudioRecOpen(const TDesC& aStepName, const TDesC& aFilename);

    66 	};

    67 

    68 /**********************************

    69 class for Play an audio file in Playing State.

    70 ***********************************/

    71 class RTestStepAudioRecPlayInPlaying : public RAudioRecTest

    72 	{

    73 public:

    74      static RTestStepAudioRecPlayInPlaying* NewL(const TDesC& aStepName, const TDesC& aFileName);

    75 	// from RAsyncTestStep

    76 	 void DoKickoffTestL();  //-- for the derived class to implement

    77 	//State Machine Functions

    78 	void Fsm(TAudioRecorderState aEventCode);

    79 			

    80 private:

    81 	RTestStepAudioRecPlayInPlaying(const TDesC& aStepName, const TDesC& aFilename);

    82 	};

    83 	

    84 /**********************************

    85 class for Play an audio file Before Open.

    86 ***********************************/

    87 class RTestStepAudioRecPlayBeforeOpen: public RAudioRecTest

    88 	{

    89 public:

    90      static RTestStepAudioRecPlayBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

    91 	// from RAsyncTestStep

    92 	 void DoKickoffTestL();  //-- for the derived class to implement

    93 	//State Machine Functions

    94 	void Fsm(TAudioRecorderState aEventCode);

    95 			

    96 private:

    97 	RTestStepAudioRecPlayBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

    98 	};

    99 

   100 /**********************************

   101 class for Record an audio file Before Open.

   102 ***********************************/

   103 class RTestStepAudioRecRecordBeforeOpen: public RAudioRecTest

   104 	{

   105 public:

   106      static RTestStepAudioRecRecordBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   107 	// from RAsyncTestStep

   108 	 void DoKickoffTestL();  //-- for the derived class to implement

   109 	//State Machine Functions

   110 	void Fsm(TAudioRecorderState aEventCode);

   111 			

   112 private:

   113 	RTestStepAudioRecRecordBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   114 	};

   115 

   116 /**********************************

   117  Record an audio file with maximum size.

   118  ***********************************/

   119 class RTestStepAudioRecRecordMaxSize: public RAudioRecTest

   120 	{

   121 public:

   122      static RTestStepAudioRecRecordMaxSize* NewL(const TDesC& aStepName, const TDesC& aFileName);

   123 	// from RAsyncTestStep

   124 	 void DoKickoffTestL();  //-- for the derived class to implement

   125 	//State Machine Functions

   126 	void Fsm(TAudioRecorderState aEventCode);

   127 			

   128 private:

   129 	RTestStepAudioRecRecordMaxSize(const TDesC& aStepName, const TDesC& aFilename);

   130 	TInt iSetMaxWriteLength;

   131 	};

   132 	

   133 /*************************************************

   134  * Record an audio file While in Recording State.

   135  *************************************************/

   136 class RTestStepAudioRecRecordWhileInRecording: public RAudioRecTest

   137 	{

   138 public:

   139      static RTestStepAudioRecRecordWhileInRecording* NewL(const TDesC& aStepName, const TDesC& aFileName);

   140 	// from RAsyncTestStep

   141 	 void DoKickoffTestL();  //-- for the derived class to implement

   142 	//State Machine Functions

   143 	void Fsm(TAudioRecorderState aEventCode);

   144 			

   145 private:

   146 	RTestStepAudioRecRecordWhileInRecording(const TDesC& aStepName, const TDesC& aFilename);

   147 	TInt iSetMaxWriteLength;

   148 	};

   149 

   150 /*************************************************

   151 *

   152 *     Getting MaxVolume Before Open an Audio file

   153 *

   154 **************************************************/

   155 class RTestStepAudioRecMaxVolBeforeOpen: public RAudioRecTest

   156 	{

   157 public:

   158      static RTestStepAudioRecMaxVolBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   159 	// from RAsyncTestStep

   160 	 void DoKickoffTestL();  //-- for the derived class to implement

   161 	//State Machine Functions

   162 	void Fsm(TAudioRecorderState aEventCode);

   163 			

   164 private:

   165 	RTestStepAudioRecMaxVolBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   166 	TInt iMaxVol;

   167 	};

   168 

   169 /*************************************************

   170 *

   171 *     Set and Get Volume Before Open an Audio file

   172 *

   173 **************************************************/

   174 class RTestStepAudioRecSetGetVolBeforeOpen: public RAudioRecTest

   175 	{

   176 public:

   177      static RTestStepAudioRecSetGetVolBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   178 	// from RAsyncTestStep

   179 	 void DoKickoffTestL();  //-- for the derived class to implement

   180 	//State Machine Functions

   181 	void Fsm(TAudioRecorderState aEventCode);

   182 			

   183 private:

   184 	RTestStepAudioRecSetGetVolBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   185 	TInt iSetVolume;

   186 	};

   187 

   188 /*************************************************

   189 *

   190 *     Set Volume to Less than Zero while in Open state

   191 *

   192 **************************************************/

   193 class RTestStepAudioRecSetVolInOpen: public RAudioRecTest

   194 	{

   195 public:

   196      static RTestStepAudioRecSetVolInOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   197 	// from RAsyncTestStep

   198 	 void DoKickoffTestL();  //-- for the derived class to implement

   199 	//State Machine Functions

   200 	void Fsm(TAudioRecorderState aEventCode);

   201 			

   202 private:

   203 	RTestStepAudioRecSetVolInOpen(const TDesC& aStepName, const TDesC& aFilename);\

   204 	TInt iSetVolume;

   205  	TInt iSetNegativeVol;

   206 	TInt iSetMaxVol;

   207 	};

   208 

   209 /*************************************************

   210 *

   211 *     Setting SetVolumeRamp Before Open an Audio file

   212 *

   213 **************************************************/

   214 class RTestStepAudioRecSetVolRampBeforeOpen: public RAudioRecTest

   215 					  

   216 	{

   217 public:

   218      static RTestStepAudioRecSetVolRampBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   219 	// from RAsyncTestStep

   220 	 void DoKickoffTestL();  //-- for the derived class to implement

   221 	//State Machine Functions

   222 	void Fsm(TAudioRecorderState aEventCode);

   223 			

   224 private:

   225 	RTestStepAudioRecSetVolRampBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);\

   226 	TInt iSetRampDuration;

   227 	};

   228 

   229 /*************************************************

   230 *

   231 *     Getting Maximum Gain Before Open an Audio file

   232 *

   233 **************************************************/

   234 class RTestStepAudioRecMaxGainBeforeOpen: public RAudioRecTest

   235 	{

   236 public:

   237      static RTestStepAudioRecMaxGainBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   238 	// from RAsyncTestStep

   239 	 void DoKickoffTestL();  //-- for the derived class to implement

   240 	//State Machine Functions

   241 	void Fsm(TAudioRecorderState aEventCode);

   242 			

   243 private:

   244 	RTestStepAudioRecMaxGainBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   245 	void DoTimerCallback();

   246 	TInt iMaxGain;

   247 	};

   248 

   249 /*************************************************

   250 *

   251 *   Set And Get gain in All Conditions in All States

   252 *

   253 **************************************************/

   254 class RTestStepAudioRecSetAndGetGaininAllCond: public RAudioRecTest

   255 	{

   256 public:

   257      static RTestStepAudioRecSetAndGetGaininAllCond* NewL(const TDesC& aStepName, const TDesC& aFileName);

   258 	// from RAsyncTestStep

   259 	 void DoKickoffTestL();  //-- for the derived class to implement

   260 	//State Machine Functions

   261 	void Fsm(TAudioRecorderState aEventCode);

   262 			

   263 private:

   264 	RTestStepAudioRecSetAndGetGaininAllCond(const TDesC& aStepName, const TDesC& aFilename);

   265 	void DoTimerCallback();

   266 	TInt iSetGain;

   267 	};

   268 	

   269 /*************************************************

   270 *

   271 *   Set And Get Position in All Conditions in All States

   272 *

   273 **************************************************/

   274 class RTestStepAudioRecSetAndGetPositionInAllCond: public RAudioRecTest

   275 	{

   276 public:

   277      static RTestStepAudioRecSetAndGetPositionInAllCond* NewL(const TDesC& aStepName, const TDesC& aSectName);

   278 	// from RAsyncTestStep

   279 	 void DoKickoffTestL();  //-- for the derived class to implement

   280 	//State Machine Functions

   281 	void Fsm(TAudioRecorderState aEventCode);

   282 			

   283 private:

   284 	RTestStepAudioRecSetAndGetPositionInAllCond(const TDesC& aStepName, const TDesC& aSectName);

   285 	void DoTimerCallback();

   286 	TInt iSetPos;

   287 	};

   288 

   289 /*******************************************************************************

   290 *

   291 *   Record Time Available while in Recording and while before open an audio file.

   292 *

   293 ********************************************************************************/

   294 class RTestStepAudioRecRecodTimeAvailInRecordingAndBeforeOpen: public RAudioRecTest

   295 	{

   296 public:

   297      static RTestStepAudioRecRecodTimeAvailInRecordingAndBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aSectName);

   298 	// from RAsyncTestStep

   299 	 void DoKickoffTestL();  //-- for the derived class to implement

   300 	//State Machine Functions

   301 	void Fsm(TAudioRecorderState aEventCode);

   302 			

   303 private:

   304 	RTestStepAudioRecRecodTimeAvailInRecordingAndBeforeOpen(const TDesC& aStepName, const TDesC& aSectName);

   305 	void DoTimerCallback();

   306 	TInt iSetMaxWriteLength;

   307 	};

   308 

   309 /**********************************************************************************

   310 *

   311 *   Record Time Available while in before Open,Opened and Recording of an audio file.

   312 *   with SetMaxWriteLength

   313 *

   314 ***********************************************************************************/

   315 class RTestStepAudioRecRecodTimeAvailInSetMaxWriteLength: public RAudioRecTest

   316 	{

   317 public:

   318      static RTestStepAudioRecRecodTimeAvailInSetMaxWriteLength* NewL(const TDesC& aStepName, const TDesC& aSectName);

   319 	// from RAsyncTestStep

   320 	 void DoKickoffTestL();  //-- for the derived class to implement

   321 	//State Machine Functions

   322 	void Fsm(TAudioRecorderState aEventCode);

   323 			

   324 private:

   325 	RTestStepAudioRecRecodTimeAvailInSetMaxWriteLength(const TDesC& aStepName, const TDesC& aSectName);

   326 	void DoTimerCallback();

   327 	TInt iSetMaxWriteLength;

   328 	};

   329 

   330 

   331 /*******************************************************************************

   332 *

   333 *   Getting Duration in all states i,e. while in before open,Recording and Playing an audio file.

   334 *

   335 ********************************************************************************/

   336 class RTestStepAudioRecDurationBeforeOpenRecordingPlaying: public RAudioRecTest

   337 	{

   338 public:

   339      static RTestStepAudioRecDurationBeforeOpenRecordingPlaying* NewL(const TDesC& aStepName, const TDesC& aSectName);

   340 	// from RAsyncTestStep

   341 	 void DoKickoffTestL();  //-- for the derived class to implement

   342 	//State Machine Functions

   343 	void Fsm(TAudioRecorderState aEventCode);

   344 			

   345 private:

   346 	RTestStepAudioRecDurationBeforeOpenRecordingPlaying(const TDesC& aStepName, const TDesC& aSectName);

   347 	void DoTimerCallback();

   348 	};

   349 

   350 /*******************************************************************************

   351 *

   352 *   User wants to define the window(SetPlayWindow()) on the audio sample data i,e. while in before open,Opened and Playing an audio file.

   353 *

   354 ********************************************************************************/

   355 class RTestStepAudioRecSetPlayWindowOpenAndPlaying: public RAudioRecTest

   356 	{

   357 public:

   358      static RTestStepAudioRecSetPlayWindowOpenAndPlaying* NewL(const TDesC& aStepName, const TDesC& aSectName);

   359 	// from RAsyncTestStep

   360 	 void DoKickoffTestL();  //-- for the derived class to implement

   361 	//State Machine Functions

   362 	void Fsm(TAudioRecorderState aEventCode);

   363 			

   364 private:

   365 	RTestStepAudioRecSetPlayWindowOpenAndPlaying(const TDesC& aStepName, const TDesC& aSectName);

   366 	void DoTimerCallback();

   367 	

   368 	TInt iSetPlaywindowStart;

   369 	TInt iSetPlaywindowEnd;

   370 	//These variables added for operational purpose of SetPlayWindow

   371 	TUint iPlayduration1;

   372 	TTime iStart1,iStop1;

   373 	TUint iPlayduration2;

   374   	TTime iStart2,iStop2;

   375 	//Counter variable to count number of PlayL() is called

   376 	TInt iCount;

   377 	};

   378 	

   379 /*******************************************************************************

   380 *

   381 *   User wants to define the window(SetPlayWindow()) on the audio sample data i,e. while in before open.

   382 *

   383 ********************************************************************************/

   384 class RTestStepAudioRecSetPlayWindowbeforeOpen: public RAudioRecTest

   385 	{

   386 public:

   387      static RTestStepAudioRecSetPlayWindowbeforeOpen* NewL(const TDesC& aStepName, const TDesC& aSectName);

   388 	// from RAsyncTestStep

   389 	 void DoKickoffTestL();  //-- for the derived class to implement

   390 	//State Machine Functions

   391 	void Fsm(TAudioRecorderState aEventCode);

   392 			

   393 private:

   394 	RTestStepAudioRecSetPlayWindowbeforeOpen(const TDesC& aStepName, const TDesC& aSectName);

   395 	TInt iSetPlaywindowStart;

   396 	TInt iSetPlaywindowEnd;

   397 	//These variables added for operational purpose of SetPlayWindow

   398 	TUint iPlayduration1;

   399 	TTime iStart1,iStop1;

   400 	};

   401 

   402 /*******************************************************************************

   403 *

   404 *   User wants to Remove the window(ClearPlayWindow()) on the audio sample data i,e. while in before open,Opened and Playing an audio file.

   405 *

   406 ********************************************************************************/

   407 class RTestStepAudioRecClearPlayWindow: public RAudioRecTest

   408 	{

   409 public:

   410      static RTestStepAudioRecClearPlayWindow* NewL(const TDesC& aStepName, const TDesC& aSectName);

   411 	// from RAsyncTestStep

   412 	 void DoKickoffTestL();  //-- for the derived class to implement

   413 	//State Machine Functions

   414 	void Fsm(TAudioRecorderState aEventCode);

   415 			

   416 private:

   417 	RTestStepAudioRecClearPlayWindow(const TDesC& aStepName, const TDesC& aSectName);

   418 	

   419 	TInt iSetPlaywindowStart;

   420 	TInt iSetPlaywindowEnd;

   421 	//These variables added for operational purpose of SetPlayWindow

   422 	TUint iPlayduration;

   423 	TTime iStart1,iStop1;

   424   	TTime iStart2,iStop2;

   425 	//Counter variable to count number of PlayL called

   426 	TInt iCount;

   427 	};

   428 	

   429 /*******************************************************************************

   430 *

   431 *   User wants to Remove the window(ClearPlayWindow()) on the audio sample data i,e. while in before open.

   432 *

   433 ********************************************************************************/

   434 class RTestStepAudioRecClearPlayWindowBeforeOpen: public RAudioRecTest

   435 	{

   436 public:

   437      static RTestStepAudioRecClearPlayWindowBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aSectName);

   438 	// from RAsyncTestStep

   439 	 void DoKickoffTestL();  //-- for the derived class to implement

   440 	//State Machine Functions

   441 	void Fsm(TAudioRecorderState aEventCode);

   442 			

   443 private:

   444 	RTestStepAudioRecClearPlayWindowBeforeOpen(const TDesC& aStepName, const TDesC& aSectName);

   445 	TInt iSetPlaywindowStart;

   446 	TInt iSetPlaywindowEnd;

   447 	//These variables added for operational purpose of SetPlayWindow

   448 	TUint iPlayduration1;

   449 	TTime iStart1,iStop1;

   450 	};

   451 	

   452 /*****************************************************************************************

   453 * 				SetRepeats()

   454 *Sets the number of times the audio sample is to be repeated while in Opened state.

   455 *

   456 ******************************************************************************************/

   457 class RTestStepAudioRecSetRepeatsInOpen: public RAudioRecTest

   458 	{

   459 public:

   460      static RTestStepAudioRecSetRepeatsInOpen* NewL(const TDesC& aStepName, const TDesC& aSectName);

   461 	// from RAsyncTestStep

   462 	 void DoKickoffTestL();  //-- for the derived class to implement

   463 	//State Machine Functions

   464 	void Fsm(TAudioRecorderState aEventCode);

   465 			

   466 private:

   467 	RTestStepAudioRecSetRepeatsInOpen(const TDesC& aStepName, const TDesC& aSectName);

   468 	

   469 	TInt iRepeatNumberOfTimes;

   470 	TInt iDuration;

   471 	TInt iPlayduration1;

   472 	TTime iStart1,iStop1;

   473 	};

   474 

   475 /*****************************************************************************************

   476 * 				SetRepeats()

   477 *Sets the number of times the audio sample is to be repeated while in Playing state.

   478 *

   479 ******************************************************************************************/

   480 class RTestStepAudioRecSetRepeatsInPlay: public RAudioRecTest

   481 	{

   482 public:

   483      static RTestStepAudioRecSetRepeatsInPlay* NewL(const TDesC& aStepName, const TDesC& aSectName);

   484 	// from RAsyncTestStep

   485 	 void DoKickoffTestL();  //-- for the derived class to implement

   486 	//State Machine Functions

   487 	void Fsm(TAudioRecorderState aEventCode);

   488 			

   489 private:

   490 	RTestStepAudioRecSetRepeatsInPlay(const TDesC& aStepName, const TDesC& aSectName);

   491 	

   492 	TInt iRepeatNumberOfTimes;

   493 	TInt iDuration;

   494 	TInt iPlayduration2;

   495 	TTime iStart2,iStop2;

   496 	TInt iCount;

   497 	};

   498 

   499 /*****************************************************************************************

   500 * 				SetRepeats()

   501 *Sets the number of times the audio sample is to be repeated while Before Open an Audio file..

   502 *

   503 ******************************************************************************************/

   504 class RTestStepAudioRecSetRepeatsBeforeOpen: public RAudioRecTest

   505 	{

   506 public:

   507      static RTestStepAudioRecSetRepeatsBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aSectName);

   508 	// from RAsyncTestStep

   509 	 void DoKickoffTestL();  //-- for the derived class to implement

   510 	//State Machine Functions

   511 	void Fsm(TAudioRecorderState aEventCode);

   512 			

   513 private:

   514 	RTestStepAudioRecSetRepeatsBeforeOpen(const TDesC& aStepName, const TDesC& aSectName);

   515 	

   516 	TInt iRepeatNumberOfTimes;

   517 	TInt iDuration;

   518 	TInt iPlayduration1;

   519 	TTime iStart1,iStop1;

   520 	};

   521 

   522 /**********************************************************

   523 *

   524 *  Sets the maximum size for a file that is being recorded 

   525 *  while in Open State And Boundary condition(Less than Zero).

   526 *

   527 ***********************************************************/

   528 class RTestStepAudioRecMinSizeInOpen: public RAudioRecTest

   529 	{

   530 public:

   531      static RTestStepAudioRecMinSizeInOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   532 	// from RAsyncTestStep

   533 	 void DoKickoffTestL();  //-- for the derived class to implement

   534 	//State Machine Functions

   535 	void Fsm(TAudioRecorderState aEventCode);

   536 			

   537 private:

   538 	RTestStepAudioRecMinSizeInOpen(const TDesC& aStepName, const TDesC& aFilename);

   539 	void DoTimerCallback();

   540 	TInt iSetMaxWriteLength;

   541 	};

   542 

   543 /**********************************************************

   544 *

   545 *  Sets the maximum size for a file that is being recorded 

   546 *  while in Open State And Boundary condition(MAx value).

   547 *

   548 ***********************************************************/

   549 class RTestStepAudioRecMaxSizeInOpen: public RAudioRecTest

   550 	{

   551 public:

   552      static RTestStepAudioRecMaxSizeInOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   553 	// from RAsyncTestStep

   554 	 void DoKickoffTestL();  //-- for the derived class to implement

   555 	//State Machine Functions

   556 	void Fsm(TAudioRecorderState aEventCode);

   557 			

   558 private:

   559 	RTestStepAudioRecMaxSizeInOpen(const TDesC& aStepName, const TDesC& aFilename);

   560 	void DoTimerCallback();

   561 	TInt iSetMaxWriteLength;

   562 	};

   563 	

   564 /**********************************************************

   565 *

   566 *  Sets the maximum size for a file that is being recorded 

   567 *  while in Recording.

   568 *

   569 ***********************************************************/

   570 class RTestStepAudioRecMaxSizeInRecord: public RAudioRecTest

   571 	{

   572 public:

   573      static RTestStepAudioRecMaxSizeInRecord* NewL(const TDesC& aStepName, const TDesC& aFileName);

   574 	// from RAsyncTestStep

   575 	 void DoKickoffTestL();  //-- for the derived class to implement

   576 	//State Machine Functions

   577 	void Fsm(TAudioRecorderState aEventCode);

   578 			

   579 private:

   580 	RTestStepAudioRecMaxSizeInRecord(const TDesC& aStepName, const TDesC& aFilename);

   581 	void DoTimerCallback();

   582 	TInt iSetMaxWriteLength;

   583 	};

   584 	

   585 /**********************************************************

   586 *

   587 *  Sets the maximum size for a file that is being recorded 

   588 *  Before Open an Audio file.

   589 *

   590 ***********************************************************/

   591 class RTestStepAudioRecMaxSizeInBeforeOpen: public RAudioRecTest

   592 	{

   593 public:

   594      static RTestStepAudioRecMaxSizeInBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   595 	// from RAsyncTestStep

   596 	 void DoKickoffTestL();  //-- for the derived class to implement

   597 	//State Machine Functions

   598 	void Fsm(TAudioRecorderState aEventCode);

   599 			

   600 private:

   601 	RTestStepAudioRecMaxSizeInBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   602 	void DoTimerCallback();

   603 	TInt iSetMaxWriteLength;

   604 	};

   605 	

   606 /**********************************************************

   607 *	SetPriority()

   608 *  Sets the Priority a file that is being recorded while in Open state.

   609 *  

   610 *

   611 ***********************************************************/

   612 class RTestStepAudioRecSetPriorityInOpen: public RAudioRecTest

   613 	{

   614 public:

   615      static RTestStepAudioRecSetPriorityInOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   616 	// from RAsyncTestStep

   617 	 void DoKickoffTestL();  //-- for the derived class to implement

   618 	//State Machine Functions

   619 	void Fsm(TAudioRecorderState aEventCode);

   620 			

   621 private:

   622 	RTestStepAudioRecSetPriorityInOpen(const TDesC& aStepName, const TDesC& aFilename);

   623 	void DoTimerCallback();

   624 	TMMFPrioritySettings iPrior;

   625 	};

   626 /**********************************************************

   627 *

   628 *  Set and Get Play Back Balance for a file that is being recorded 

   629 *  Before Open an Audio file.

   630 *

   631 ***********************************************************/

   632 class RTestStepAudioRecSetPlayBackBalBeforeOpen: public RAudioRecTest

   633 	{

   634 public:

   635      static RTestStepAudioRecSetPlayBackBalBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   636 	// from RAsyncTestStep

   637 	 void DoKickoffTestL();  //-- for the derived class to implement

   638 	//State Machine Functions

   639 	void Fsm(TAudioRecorderState aEventCode);

   640 			

   641 private:

   642 	RTestStepAudioRecSetPlayBackBalBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   643 	void DoTimerCallback();

   644 	TInt iSetPlayBackBalance;

   645 	TInt iReturn;

   646 	};

   647 	

   648 /**********************************************************

   649 *

   650 *  Set and Get Play Back Balance for a file that is being recorded 

   651 *  While in Open State(Setting to Maximum Value).

   652 *

   653 ***********************************************************/

   654 class RTestStepAudioRecSetPlayBackBalInOpenedMaxValue: public RAudioRecTest

   655 	{

   656 public:

   657      static RTestStepAudioRecSetPlayBackBalInOpenedMaxValue* NewL(const TDesC& aStepName, const TDesC& aFileName);

   658 	// from RAsyncTestStep

   659 	 void DoKickoffTestL();  //-- for the derived class to implement

   660 	//State Machine Functions

   661 	void Fsm(TAudioRecorderState aEventCode);

   662 			

   663 private:

   664 	RTestStepAudioRecSetPlayBackBalInOpenedMaxValue(const TDesC& aStepName, const TDesC& aFilename);

   665 	void DoTimerCallback();

   666 	TInt iSetPlayBackMaxBalance;

   667 	TInt iReturn;

   668 	};

   669 

   670 /**********************************************************

   671 *

   672 *  Set and Get Play Back Balance for a file that is being recorded 

   673 *  While in Open State(Setting To Minimum Value).

   674 *

   675 ***********************************************************/

   676 class RTestStepAudioRecSetPlayBackBalInOpenedMinValue: public RAudioRecTest

   677 	{

   678 public:

   679      static RTestStepAudioRecSetPlayBackBalInOpenedMinValue* NewL(const TDesC& aStepName, const TDesC& aFileName);

   680 	// from RAsyncTestStep

   681 	 void DoKickoffTestL();  //-- for the derived class to implement

   682 	//State Machine Functions

   683 	void Fsm(TAudioRecorderState aEventCode);

   684 			

   685 private:

   686 	RTestStepAudioRecSetPlayBackBalInOpenedMinValue(const TDesC& aStepName, const TDesC& aFilename);

   687 	void DoTimerCallback();

   688 	TInt iSetPlayBackMinBalance;

   689 	TInt iReturn;

   690 	};

   691 	

   692 /**********************************************************

   693 *

   694 *  Set and Get the current recording balance setting between the left and right stereo microphones 

   695 *  Before Open an Audio file.

   696 *

   697 ***********************************************************/

   698 class RTestStepAudioRecSetRecordBalBeforeOpen: public RAudioRecTest

   699 	{

   700 public:

   701      static RTestStepAudioRecSetRecordBalBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   702 	//from RAsyncTestStep

   703 	 void DoKickoffTestL();  //-- for the derived class to implement

   704 	//State Machine Functions

   705 	void Fsm(TAudioRecorderState aEventCode);

   706 			

   707 private:

   708 	RTestStepAudioRecSetRecordBalBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   709 	void DoTimerCallback();

   710 	TInt iSetRecordBalance;

   711 	TInt iReturn;

   712 	};

   713 	

   714 /**********************************************************

   715 * Set and Get the current recording balance setting between the left and right stereo microphones 

   716 *  While in Open State(Setting to Maximum Value).

   717 *

   718 ***********************************************************/

   719 class RTestStepAudioRecSetRecordBalInOpenMaxValue: public RAudioRecTest

   720 	{

   721 public:

   722      static RTestStepAudioRecSetRecordBalInOpenMaxValue* NewL(const TDesC& aStepName, const TDesC& aFileName);

   723 	// from RAsyncTestStep

   724 	 void DoKickoffTestL();  //-- for the derived class to implement

   725 	//State Machine Functions

   726 	void Fsm(TAudioRecorderState aEventCode);

   727 			

   728 private:

   729 	RTestStepAudioRecSetRecordBalInOpenMaxValue(const TDesC& aStepName, const TDesC& aFilename);

   730 	void DoTimerCallback();

   731 	TInt iSetRecordBalMaxValue;

   732 	TInt iReturn;

   733 	};

   734 	

   735 /**********************************************************

   736 * Set and Get the current recording balance setting between the left and right stereo microphones 

   737 *  While in Open State(Setting to Minimum Value).

   738 *

   739 ***********************************************************/

   740 class RTestStepAudioRecSetRecordBalInOpenMinValue: public RAudioRecTest

   741 	{

   742 public:

   743      static RTestStepAudioRecSetRecordBalInOpenMinValue* NewL(const TDesC& aStepName, const TDesC& aFileName);

   744 	// from RAsyncTestStep

   745 	 void DoKickoffTestL();  //-- for the derived class to implement

   746 	//State Machine Functions

   747 	void Fsm(TAudioRecorderState aEventCode);

   748 			

   749 private:

   750 	RTestStepAudioRecSetRecordBalInOpenMinValue(const TDesC& aStepName, const TDesC& aFilename);

   751 	void DoTimerCallback();

   752 	TInt iSetRecordBalMinValue;

   753 	TInt iReturn;

   754 	};

   755 	

   756 /**********************************************************

   757 * Set and Get the current recording balance setting between the left and right stereo microphones 

   758 *  While in Recording State.

   759 *

   760 ***********************************************************/

   761 class RTestStepAudioRecSetRecordBalInRecording: public RAudioRecTest

   762 	{

   763 public:

   764      static RTestStepAudioRecSetRecordBalInRecording* NewL(const TDesC& aStepName, const TDesC& aFileName);

   765 	// from RAsyncTestStep

   766 	 void DoKickoffTestL();  //-- for the derived class to implement

   767 	//State Machine Functions

   768 	void Fsm(TAudioRecorderState aEventCode);

   769 			

   770 private:

   771 	RTestStepAudioRecSetRecordBalInRecording(const TDesC& aStepName, const TDesC& aFilename);

   772 	void DoTimerCallback();

   773 	TInt iSetRecordBalance;

   774 	TInt iReturn;

   775 	};	

   776 		

   777 /**********************************************************

   778 * Returns a list of the supported codecs for the conversion destination.

   779 *  While in Recording State.

   780 *

   781 ***********************************************************/

   782 class RTestStepAudioRecGetSupportDestDataTypeInRecording: public RAudioRecTest

   783 	{

   784 public:

   785      static RTestStepAudioRecGetSupportDestDataTypeInRecording* NewL(const TDesC& aStepName, const TDesC& aFileName);

   786 	// from RAsyncTestStep

   787 	 void DoKickoffTestL();  //-- for the derived class to implement

   788 	//State Machine Functions

   789 	void Fsm(TAudioRecorderState aEventCode);

   790 			

   791 private:

   792 	RTestStepAudioRecGetSupportDestDataTypeInRecording(const TDesC& aStepName, const TDesC& aFilename);

   793 	void DoTimerCallback();

   794 	TInt ReadExpectedFourCC(RArray<TFourCC>& aExpectedFourCC);	

   795 	RArray<TFourCC> supFourCC;

   796 	RArray<TFourCC> iExpectedFourCCToBeSupported;

   797 	};

   798 		

   799 /**********************************************************

   800 * Returns a list of the supported codecs for the conversion destination.

   801 *  Before Open an Audio file.

   802 *

   803 ***********************************************************/

   804 class RTestStepAudioRecGetSupportDestDataTypeBeforeOpen: public RAudioRecTest

   805 	{

   806 public:

   807      static RTestStepAudioRecGetSupportDestDataTypeBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   808 	// from RAsyncTestStep

   809 	 void DoKickoffTestL();  //-- for the derived class to implement

   810 	//State Machine Functions

   811 	void Fsm(TAudioRecorderState aEventCode);

   812 			

   813 private:

   814 	RTestStepAudioRecGetSupportDestDataTypeBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   815 	void DoTimerCallback();

   816 	TInt ReadExpectedFourCC(RArray<TFourCC>& aExpectedFourCC);

   817 	RArray<TFourCC> supFourCC;

   818 	RArray<TFourCC> iExpectedFourCCToBeSupported;

   819 	};		

   820 	

   821 /**********************************************************

   822 *  Set and Get the codec to use with the record controller.

   823 *  Before Open an Audio file(SetDestinationDataTypeL(),DestinationDataTypeL).

   824 *

   825 ***********************************************************/

   826 class RTestStepAudioRecSetGetDestnDataTypeBeforeOpen: public RAudioRecTest

   827 	{

   828 public:

   829      static RTestStepAudioRecSetGetDestnDataTypeBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   830 	// from RAsyncTestStep

   831 	 void DoKickoffTestL();  //-- for the derived class to implement

   832 	//State Machine Functions

   833 	void Fsm(TAudioRecorderState aEventCode);

   834 			

   835 private:

   836 	RTestStepAudioRecSetGetDestnDataTypeBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   837 	void DoTimerCallback();

   838 	TInt ReadExpectedFourCC(RArray<TFourCC>& aExpectedFourCC);

   839 	RArray<TFourCC>	iExpectedFourCCToBeSupported;

   840 	};		

   841 	

   842 /**********************************************************

   843 * Get the codec to use with the record controller.

   844 *  While in Recording State(DestinationDataTypeL()).

   845 *

   846 ***********************************************************/

   847 class RTestStepAudioRecGetDestnDataTypeInRecording: public RAudioRecTest

   848 	{

   849 public:

   850      static RTestStepAudioRecGetDestnDataTypeInRecording* NewL(const TDesC& aStepName, const TDesC& aFileName);

   851 	// from RAsyncTestStep

   852 	 void DoKickoffTestL();  //-- for the derived class to implement

   853 	//State Machine Functions

   854 	void Fsm(TAudioRecorderState aEventCode);

   855 			

   856 private:

   857 	RTestStepAudioRecGetDestnDataTypeInRecording(const TDesC& aStepName, const TDesC& aFilename);

   858 	void DoTimerCallback();

   859 	};	

   860 	

   861 /**********************************************************

   862 * Set and Get the bit rate of the data sink in bits per second

   863 *  Before Open an Audio file(SetDestinationBitRateL(),DestinationBitRateL).

   864 *

   865 ***********************************************************/

   866 class RTestStepAudioRecSetGetDestnBitRateBeforeOpen: public RAudioRecTest

   867 	{

   868 public:

   869      static RTestStepAudioRecSetGetDestnBitRateBeforeOpen* NewL(const TDesC& aStepName, const TDesC& aFileName);

   870 	// from RAsyncTestStep

   871 	 void DoKickoffTestL();  //-- for the derived class to implement

   872 	//State Machine Functions

   873 	void Fsm(TAudioRecorderState aEventCode);

   874 			

   875 private:

   876 	RTestStepAudioRecSetGetDestnBitRateBeforeOpen(const TDesC& aStepName, const TDesC& aFilename);

   877 	void DoTimerCallback();

   878 	TInt iSetDestinationBitRate;

   879 	};		

   880 	

   881 /**********************************************************

   882 * Gets the bit rate of the data sink in bits per second

   883 *  While in recording State(DestinationBitRateL).

   884 *

   885 ***********************************************************/

   886 class RTestStepAudioRecGetDestnBitRateInRecording: public RAudioRecTest

   887 	{

   888 public:

   889      static RTestStepAudioRecGetDestnBitRateInRecording* NewL(const TDesC& aStepName, const TDesC& aFileName);

   890 	// from RAsyncTestStep

   891 	 void DoKickoffTestL();  //-- for the derived class to implement

   892 	//State Machine Functions

   893 	void Fsm(TAudioRecorderState aEventCode);

   894 			

   895 private:

   896 	RTestStepAudioRecGetDestnBitRateInRecording(const TDesC& aStepName, const TDesC& aFilename);

   897 	void DoTimerCallback();

   898 	TInt iSetDestinationBitRate;

   899 	RArray<TUint> supBitRates;

   900 	};		

   901 	

   902 /**********************************************************

   903 * Returns a list of the supported bit rates for recording to the data sink.

   904 * While in Before Open an Audio file(GetSupportedBitRatesL())

   905 ***********************************************************/

   906 class RTestStepAudioRecGetSupportedBitRateBeforeOpenAndRec: public RAudioRecTest

   907 	{

   908 public:

   909      static RTestStepAudioRecGetSupportedBitRateBeforeOpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

   910 	// from RAsyncTestStep

   911 	 void DoKickoffTestL();  //-- for the derived class to implement

   912 	//State Machine Functions

   913 	void Fsm(TAudioRecorderState aEventCode);

   914 			

   915 private:

   916 	RTestStepAudioRecGetSupportedBitRateBeforeOpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

   917 	void DoTimerCallback();

   918 	};		

   919 

   920 /**********************************************************

   921 * Returns the bit rate of the audio clip While Before Open an 

   922 * Audio file and While in Playing State.

   923 * SourceBitRateL()

   924 **********************************************************/

   925 class RTestStepAudioRecSourceBitRateBeforeOpenAndPalying: public RAudioRecTest

   926 	{

   927 public:

   928      static RTestStepAudioRecSourceBitRateBeforeOpenAndPalying* NewL(const TDesC& aStepName, const TDesC& aFileName);

   929 	// from RAsyncTestStep

   930 	 void DoKickoffTestL();  //-- for the derived class to implement

   931 	//State Machine Functions

   932 	void Fsm(TAudioRecorderState aEventCode);

   933 			

   934 private:

   935 	RTestStepAudioRecSourceBitRateBeforeOpenAndPalying(const TDesC& aStepName, const TDesC& aFilename);

   936 	TUint iRetSource;

   937 	};	

   938 		

   939 /****************************************************************************************

   940 * Sets the sample rate for the conversion destination data sink 

   941 * Gets the sample rate in samples/second that the destination data sink 

   942 * currently set to an Audio file ,While Before Open State and While in Recording State.

   943 * 

   944 * SetDestinationSampleRateL()/DestinationSampleRateL()

   945 *

   946 **************************************************************************88*************/

   947 class RTestStepAudioRecSetGetDestnSampleRateBeforeOpenAndRec: public RAudioRecTest

   948 	{

   949 public:

   950      static RTestStepAudioRecSetGetDestnSampleRateBeforeOpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

   951 	// from RAsyncTestStep

   952 	 void DoKickoffTestL();  //-- for the derived class to implement

   953 	//State Machine Functions

   954 	void Fsm(TAudioRecorderState aEventCode);

   955 private:

   956 	RTestStepAudioRecSetGetDestnSampleRateBeforeOpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

   957 	void DoTimerCallback();

   958 	TInt iRetSource;

   959 	RArray<TUint> iSupSampleRates;

   960 	TInt iNumCodecsOpen;

   961   	TInt iNumCodecsRecording;

   962 	};

   963 			

   964 /****************************************************************************************

   965 * Returns a list of supported recording sample rates

   966 * While Before Open State and While in Recording State.

   967 * 

   968 * GetSupportedSampleRatesL()

   969 *

   970 **************************************************************************88*************/

   971 class RTestStepAudioRecGetSupportedSampleRateBeforeOpenAndRec: public RAudioRecTest

   972 	{

   973 public:

   974      static RTestStepAudioRecGetSupportedSampleRateBeforeOpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

   975 	// from RAsyncTestStep

   976 	 void DoKickoffTestL();  //-- for the derived class to implement

   977 	//State Machine Functions

   978 	void Fsm(TAudioRecorderState aEventCode);

   979 			

   980 private:

   981 	RTestStepAudioRecGetSupportedSampleRateBeforeOpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

   982 	void DoTimerCallback();

   983 	RArray<TUint> iSupSampleRates;

   984 	};		

   985 	

   986 /****************************************************************************************

   987 * Sets the format of the audio clip. This can only be done if the audio clip does not exist.

   988 * While Before Open State and While in Recording State.

   989 * 

   990 * SetDestinationFormatL()/DestinationFormatL()

   991 *

   992 **************************************************************************88*************/

   993 class RTestStepAudioRecSetGetDestnFormatBeforeOpenAndRec: public RAudioRecTest

   994 	{

   995 public:

   996      static RTestStepAudioRecSetGetDestnFormatBeforeOpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

   997 	// from RAsyncTestStep

   998 	 void DoKickoffTestL();  //-- for the derived class to implement

   999 	//State Machine Functions

  1000 	void Fsm(TAudioRecorderState aEventCode);

  1001 			

  1002 private:

  1003 	RTestStepAudioRecSetGetDestnFormatBeforeOpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

  1004 	void DoTimerCallback();

  1005 	TUid iFormat;

  1006 	};		

  1007 	

  1008 /****************************************************************************************

  1009 * Sets the number of channels for the recorded audio clip.

  1010 * While Before Open and while Recording State.

  1011 * 

  1012 * SetDestinationNumberOfChannelsL()/DestinationNumberOfChannelsL()

  1013 *

  1014 **************************************************************************88*************/

  1015 class RTestStepAudioRecSetGetDestnNumberChannelBeforeOpenAndRec: public RAudioRecTest

  1016 	{

  1017 public:

  1018      static RTestStepAudioRecSetGetDestnNumberChannelBeforeOpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

  1019 	// from RAsyncTestStep

  1020 	 void DoKickoffTestL();  //-- for the derived class to implement

  1021 	//State Machine Functions

  1022 	void Fsm(TAudioRecorderState aEventCode);

  1023 			

  1024 private:

  1025 	RTestStepAudioRecSetGetDestnNumberChannelBeforeOpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

  1026 	void DoTimerCallback();

  1027 	TUint iChannel;

  1028 	};		

  1029 	

  1030 /****************************************************************************************

  1031 * Returns a list of the supported number of channels for recording.

  1032 * While Before Open and While in Recording State.

  1033 * 

  1034 * GetSupportedNumberOfChannelsL()

  1035 *

  1036 **************************************************************************88*************/

  1037 class RTestAudioRecGetSuptedNoOfChanlsB4OpenAndRec: public RAudioRecTest

  1038 	{

  1039 public:

  1040      static RTestAudioRecGetSuptedNoOfChanlsB4OpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

  1041 	// from RAsyncTestStep

  1042 	 void DoKickoffTestL();  //-- for the derived class to implement

  1043 	//State Machine Functions

  1044 	void Fsm(TAudioRecorderState aEventCode);

  1045 			

  1046 private:

  1047 	RTestAudioRecGetSuptedNoOfChanlsB4OpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

  1048 	void DoTimerCallback();

  1049 	TUint iChannel;

  1050 	};	

  1051 				

  1052 /****************************************************************************************

  1053 * Returns the number of meta data entries associated with this clip.

  1054 * While Before Open, Opened, Recording and While in Playing State.

  1055 * 

  1056 * GetNumberOfMetaDataEntries()

  1057 *

  1058 **************************************************************************88*************/

  1059 class RTestAudioRecGetNumOfMetaDataEntB4OpenAndRec: public RAudioRecTest

  1060 	{

  1061 public:

  1062      static RTestAudioRecGetNumOfMetaDataEntB4OpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

  1063 	// from RAsyncTestStep

  1064 	 void DoKickoffTestL();  //-- for the derived class to implement

  1065 	//State Machine Functions

  1066 	void Fsm(TAudioRecorderState aEventCode);

  1067 			

  1068 private:

  1069 	RTestAudioRecGetNumOfMetaDataEntB4OpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

  1070 	void DoTimerCallback();

  1071 	TInt iMetaData;

  1072 	TInt iExpErrorWhenIdle;

  1073 	TInt iExpErrorWhenOpened;

  1074 	TInt iExpErrorWhenPlaying;

  1075 	TInt iExpErrorWhenRecording;

  1076 	};

  1077 			

  1078 /****************************************************************************************

  1079 * Returns the specified meta data entry from the current audio clip.

  1080 * While Before Open,Recording and While in Playing State.

  1081 * 

  1082 * GetMetaDataEntryL()

  1083 *

  1084 **************************************************************************88*************/

  1085 class RTestAudioRecGetMetaDataEntB4OpenAndPly: public RAudioRecTest

  1086 	{

  1087 public:

  1088      static RTestAudioRecGetMetaDataEntB4OpenAndPly* NewL(const TDesC& aStepName, const TDesC& aFileName);

  1089 	// from RAsyncTestStep

  1090 	 void DoKickoffTestL();  //-- for the derived class to implement

  1091 	//State Machine Functions

  1092 	void Fsm(TAudioRecorderState aEventCode);

  1093 			

  1094 private:

  1095 	RTestAudioRecGetMetaDataEntB4OpenAndPly(const TDesC& aStepName, const TDesC& aFilename);

  1096 	void DoTimerCallback();

  1097 	TInt iExpErrorWhenIdle;

  1098 	TInt iExpErrorWhenPlaying;

  1099 	TInt iExpErrorWhenRecording;

  1100 	};		

  1101 			

  1102 /****************************************************************************************

  1103 * Adds a meta data entry to an Audio file ,While Before Open and While in Recording State.

  1104 * 

  1105 * AddMetaDataEntryL()

  1106 *

  1107 **************************************************************************88*************/

  1108 class RTestAudioRecAddMetaDataEntB4OpenAndRec: public RAudioRecTest

  1109 	{

  1110 public:

  1111      static RTestAudioRecAddMetaDataEntB4OpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);

  1112 	// from RAsyncTestStep

  1113 	 void DoKickoffTestL();  //-- for the derived class to implement

  1114 	//State Machine Functions

  1115 	void Fsm(TAudioRecorderState aEventCode);

  1116 			

  1117 private:

  1118 	RTestAudioRecAddMetaDataEntB4OpenAndRec(const TDesC& aStepName, const TDesC& aFilename);

  1119 	void DoTimerCallback();

  1120 	CMMFMetaDataEntry* iMetadata[2];

  1121 	TInt iExpErrorWhenIdle;

  1122 	TInt iExpErrorWhenRecording;

  1123 	};	

  1124 				

  1125 /****************************************************************************************

  1126 * Removes a specified meta data entry from the audio clip.While Before Open and While in Recording State.

  1127 * 

  1128 * RemoveMetaDataEntry()

  1129 *

  1130 **************************************************************************88*************/

  1131 class RTestAudioRecRemvMetaDataEntB4OpenAndRec: public RAudioRecTest

  1132 	{

  1133 public:

  1134      static RTestAudioRecRemvMetaDataEntB4OpenAndRec* NewL(const TDesC& aStepName, const TDesC& aFileName);