1 // Copyright (c) 2003-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 // This file contains an example Test step implementation

    15 // This demonstrates the various functions provided

    16 // by the CTestStep base class which are available within

    17 // a test step

    18 // 

    19 //

    20 

    21 // EPOC includes

    22 #include <e32base.h>

    23 #include <e32test.h>

    24 #include <e32keys.h>

    25 #include <c32comm.h>

    26 #include <f32file.h>

    27 #include <etel.h>

    28 #include <etelmm.h>

    29 #include <testframework.h>

    30 

    31 //#include <MdaAudioSamplePlayer.h>

    32 #include <mdaaudiosampleeditor.h>

    33 #include <mdaaudiotoneplayer.h>

    34 

    35 // Test system includes

    36 #include <testframework.h>

    37 

    38 // Specific includes for this test suite

    39 #include "TestStepUnitMMFAudClient.h"

    40 #include "TestSuiteUnitMMFAudClient.h"

    41 

    42 // Specific includes for these test steps

    43 #include "TestStepRecorder.h"

    44 

    45 

    46 #include "MmfAudioController.h"

    47 #include "mmfclientaudiorecorder.h"

    48 // --------------------------------------------

    49 // --------------------------------------------

    50 

    51 /**

    52  *

    53  * Static constructor for CTestStepRecorderSimultaneousPlay1.

    54  *

    55  *

    56  * @return	"CTestStepRecorderSimultaneousPlay1*"

    57  *			The constructed CTestStepRecorderSimultaneousPlay1

    58  *

    59  * @xxxx

    60  *

    61  */

    62 CTestStepRecorderSimultaneousPlay1* CTestStepRecorderSimultaneousPlay1::NewL()

    63 	{

    64 	CTestStepRecorderSimultaneousPlay1* self = new(ELeave) CTestStepRecorderSimultaneousPlay1;

    65 	return self;

    66 	}

    67 

    68 /**

    69  *

    70  * Test step constructor.

    71  * Each test step initialises its own name.

    72  *

    73  * @xxxx

    74  *

    75  */

    76 CTestStepRecorderSimultaneousPlay1::CTestStepRecorderSimultaneousPlay1()

    77 	{

    78 	// store the name of this test case

    79 	// this is the name that is used by the script file

    80 	iTestStepName = _L("MM-MMF-ACLNT-U-0810-HP");

    81 	}

    82 

    83 /**

    84  *

    85  * Test step destructor.

    86  *

    87  * @xxxx

    88  *

    89  */

    90 CTestStepRecorderSimultaneousPlay1::~CTestStepRecorderSimultaneousPlay1()

    91 	{

    92 	}

    93 

    94 /**

    95  *

    96  * Test step Close

    97  * handles all deletion

    98  * @xxxx

    99  *

   100  */

   101 void CTestStepRecorderSimultaneousPlay1::Close()

   102 	{

   103 	}

   104 

   105 /**

   106  *

   107  * Test step Preamble.

   108  *

   109  * @xxxx

   110  *

   111  */

   112 enum TVerdict CTestStepRecorderSimultaneousPlay1::DoTestStepPreambleL(void)

   113 	{

   114 	TVerdict verdict;

   115 	 // this installs the scheduler

   116 	verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();

   117 

   118 	// Printing to the console and log file

   119 	INFO_PRINTF2(_L("%S"), &iTestStepName);

   120 	INFO_PRINTF1(_L("this is a test of calling CMdaAudioRecorderUtility::PlayL() while a tone is playing"));

   121 

   122 	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file

   123 		{

   124 		return EInconclusive;

   125 		}

   126 

   127 	return verdict;

   128 	}

   129 

   130 /**

   131  *

   132  * Test step Postamble.

   133  *

   134  * @xxxx

   135  *

   136  */

   137 enum TVerdict CTestStepRecorderSimultaneousPlay1::DoTestStepPostambleL(void)

   138 	{

   139 	//[ Destroy the scheduler ]

   140 	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();

   141 	}

   142 

   143 /**

   144  *

   145  * Callback Handle.

   146  *

   147  * @xxxx

   148  *

   149  */

   150 void CTestStepRecorderSimultaneousPlay1::MoscoStateChangeEvent(CBase* aObject,

   151 														  TInt aPreviousState,

   152 														  TInt aCurrentState,

   153 														  TInt aErrorCode)

   154 	{

   155 	INFO_PRINTF5(_L("MoscoStateChangeEvent(object=0x%08x, ps=%d, cs=%d, error = %d)"),

   156 		aObject,

   157 		aPreviousState,

   158 		aCurrentState,

   159 		aErrorCode);

   160 	iError = aErrorCode;

   161 	iCurrentState = aCurrentState;

   162 	CActiveScheduler::Stop();

   163 	}

   164 

   165 

   166 void CTestStepRecorderSimultaneousPlay1::MatoPrepareComplete(TInt aError)

   167 	{

   168 	INFO_PRINTF2(_L("MatoPrepareComplete(): error = %d"), aError);

   169 	iErrorTone = aError;

   170 	CActiveScheduler::Stop();

   171 	}

   172 

   173 void CTestStepRecorderSimultaneousPlay1::MatoPlayComplete(TInt aError)

   174 	{

   175 	INFO_PRINTF2(_L("MatoPlayComplete(): error = %d"), aError);

   176 	iErrorTone = aError;

   177 	CActiveScheduler::Stop();

   178 	}

   179 

   180 /**

   181  *

   182  * Do the test step.

   183  * Each test step must supply an implementation for DoTestStepL.

   184  *

   185  * @return	"TVerdict"

   186  *			The result of the test step

   187  *

   188  * @xxxx

   189  *

   190  */

   191 TVerdict CTestStepRecorderSimultaneousPlay1::DoTestStepL()

   192 	{

   193 	iTestStepResult = EFail;

   194 

   195 	iToneUtility = CMdaAudioToneUtility::NewL(*this);

   196 	CleanupStack::PushL(iToneUtility);

   197 

   198 	iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this);

   199 	CleanupStack::PushL(iRecorderUtility);

   200 

   201 	do

   202 		{

   203 		// open the sound file

   204 		INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility"));

   205 		iRecorderUtility->OpenFileL(iFileName);

   206 		CActiveScheduler::Start();

   207 		if (iCurrentState != CMdaAudioRecorderUtility::EOpen)

   208 			{

   209 			break;

   210 			}

   211 

   212 		// prepare the tone

   213 		INFO_PRINTF1( _L("Initialize CMdaAudioToneUtility"));

   214 		iToneUtility->PrepareToPlayTone(KToneFrequency, TTimeIntervalMicroSeconds(KTwoSeconds));

   215 		// Wait for prepare

   216 		iErrorTone = KErrGeneral;	// set so we know callback has occurred

   217 		CActiveScheduler::Start();

   218 		if (iErrorTone != KErrNone)

   219 			{

   220 			break;

   221 			}

   222 

   223 		// start playing the tone & wait 0.25 secs to make sure it gets started

   224 		INFO_PRINTF1( _L("Playing tone..."));

   225 		iToneUtility->Play();

   226 		User::After(KQuarterScond);

   227 

   228 		// start playing the file

   229 		INFO_PRINTF1( _L("Playing sound file..."));

   230 		iRecorderUtility->PlayL();

   231 		// wait once for start of play

   232 		// NB this "EPlaying" callback does not occur in 6.1 !

   233 		CActiveScheduler::Start();

   234 		if ((iError != KErrNone) || (iCurrentState != CMdaAudioRecorderUtility::EPlaying))

   235 			{

   236 			break;

   237 			}

   238 

   239 		// wait once for end of play - this should produce KErrInUse

   240 		INFO_PRINTF1( _L("Waiting for end of play..."));

   241 		CActiveScheduler::Start();

   242 		if ((iError != KErrInUse) || (iCurrentState != CMdaAudioRecorderUtility::EOpen))

   243 			{

   244 			break;

   245 			}

   246 		// wait once tone to finsh playing

   247 		CActiveScheduler::Start();

   248 

   249 		// now that the tone player has finished, try playing

   250 		// the sound file again (this should work now)

   251 

   252 		INFO_PRINTF1( _L("Calling iRecorderUtility->PlayL..."));

   253 		iRecorderUtility->PlayL();

   254 		// wait once for start of play

   255 		CActiveScheduler::Start();

   256 		if ((iError != KErrNone) || (iCurrentState != CMdaAudioRecorderUtility::EPlaying))

   257 			{

   258 			break;

   259 			}

   260 

   261 		// wait once for end of play - this should produce KErrNone

   262 		CActiveScheduler::Start();

   263 		if ((iError != KErrNone) || (iCurrentState != CMdaAudioRecorderUtility::EOpen))

   264 			{

   265 			break;

   266 			}

   267 

   268 		iTestStepResult = EPass;

   269 		}

   270 	while (EFalse);

   271 

   272 	CleanupStack::PopAndDestroy(iRecorderUtility);

   273 	CleanupStack::PopAndDestroy(iToneUtility);

   274 	iRecorderUtility = NULL;

   275 	iToneUtility = NULL;

   276 

   277 	INFO_PRINTF1(_L("finished with this test step"));

   278 

   279 	// test steps return a result

   280 	return iTestStepResult;

   281 	}

   282 

   283 //

   284 

   285 

   286 /**

   287  *

   288  * Static constructor for CTestStepRecorderSimultaneousPlay2.

   289  *

   290  *

   291  * @return	"CTestStepRecorderSimultaneousPlay2*"

   292  *			The constructed CTestStepRecorderSimultaneousPlay2

   293  *

   294  * @xxxx

   295  *

   296  */

   297 CTestStepRecorderSimultaneousPlay2* CTestStepRecorderSimultaneousPlay2::NewL()

   298 	{

   299 	CTestStepRecorderSimultaneousPlay2* self = new(ELeave) CTestStepRecorderSimultaneousPlay2;

   300 	return self;

   301 	}

   302 

   303 /**

   304  *

   305  * Test step constructor.

   306  * Each test step initialises its own name.

   307  *

   308  * @xxxx

   309  *

   310  */

   311 CTestStepRecorderSimultaneousPlay2::CTestStepRecorderSimultaneousPlay2()

   312 	{

   313 	// store the name of this test case

   314 	// this is the name that is used by the script file

   315 	iTestStepName = _L("MM-MMF-ACLNT-U-0811-HP");

   316 	}

   317 

   318 /**

   319  *

   320  * Test step destructor.

   321  *

   322  * @xxxx

   323  *

   324  */

   325 CTestStepRecorderSimultaneousPlay2::~CTestStepRecorderSimultaneousPlay2()

   326 	{

   327 	}

   328 

   329 /**

   330  *

   331  * Test step Close

   332  * handles all deletion

   333  *

   334  * @xxxx

   335  *

   336  */

   337 void CTestStepRecorderSimultaneousPlay2::Close()

   338 	{

   339 	delete iToneUtility;

   340 	delete iRecorderUtility;

   341 	}

   342 

   343 

   344 /**

   345  *

   346  * Test step Preamble.

   347  *

   348  * @xxxx

   349  *

   350  */

   351 enum TVerdict CTestStepRecorderSimultaneousPlay2::DoTestStepPreambleL(void)

   352 	{

   353 	TInt err;

   354 

   355 	TVerdict verdict;

   356 	 // this installs the scheduler

   357 	verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();

   358 

   359 	// Printing to the console and log file

   360 	INFO_PRINTF2(_L("%S"), &iTestStepName);

   361 	INFO_PRINTF1(_L("this is a test of playing a high priority tone over a low priority .wav file"));

   362 

   363 	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file

   364 		{

   365 		return EInconclusive;

   366 		}

   367 

   368 	// create a record utility

   369 	TRAP(err, iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin));

   370 	if (err != KErrNone)

   371 		return EInconclusive;

   372 	// create a tone utility

   373 	TRAP(err, iToneUtility = CMdaAudioToneUtility::NewL(*this, NULL, EMdaPriorityMax));

   374 	if (err != KErrNone)

   375 		return EInconclusive;

   376 

   377 	return verdict;

   378 

   379 	}

   380 

   381 /**

   382  *

   383  * Test step Postamble.

   384  *

   385  * @xxxx

   386  *

   387  */

   388 enum TVerdict CTestStepRecorderSimultaneousPlay2::DoTestStepPostambleL(void)

   389 	{

   390 	//[ Destroy the scheduler ]

   391 	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();

   392 	}

   393 

   394 /**

   395  *

   396  * Callback Handle.

   397  *

   398  * @xxxx

   399  *

   400  */

   401 void CTestStepRecorderSimultaneousPlay2::MoscoStateChangeEvent(CBase* /*aObject*/,

   402 														  TInt aPreviousState,

   403 														  TInt aCurrentState,

   404 														  TInt aErrorCode)

   405 	{

   406 	INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"),

   407 		aPreviousState,

   408 		aCurrentState,

   409 		aErrorCode);

   410 	iError = aErrorCode;

   411 	iCurrentState = aCurrentState;

   412 	CActiveScheduler::Stop();

   413 	}

   414 

   415 

   416 void CTestStepRecorderSimultaneousPlay2::MatoPrepareComplete(TInt aError)

   417 	{

   418 	INFO_PRINTF2(_L("MatoPrepareComplete(): error = %d"), aError);

   419 	iErrorTone = aError;

   420 	CActiveScheduler::Stop();

   421 	}

   422 

   423 void CTestStepRecorderSimultaneousPlay2::MatoPlayComplete(TInt aError)

   424 	{

   425 	INFO_PRINTF2(_L("MatoPlayComplete(): error = %d"), aError);

   426 	iErrorTone = aError;

   427 	CActiveScheduler::Stop();

   428 	}

   429 

   430 /**

   431  *

   432  * Do the test step.

   433  * Each test step must supply an implementation for DoTestStepL.

   434  *

   435  * @return	"TVerdict"

   436  *			The result of the test step

   437  *

   438  * @xxxx

   439  *

   440  */

   441 TVerdict CTestStepRecorderSimultaneousPlay2::DoTestStepL()

   442 	{

   443 	iTestStepResult = EPass;

   444     TInt err       = KErrNone;

   445 

   446 	// open the sound file

   447 	INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility"));

   448 	TRAP(err, iRecorderUtility->OpenFileL(iFileName));

   449 	if (err != KErrNone)

   450 		return EInconclusive;

   451 

   452 	// wait for open to complete

   453 	CActiveScheduler::Start();

   454 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen))

   455 		{

   456 		iTestStepResult = EFail;

   457 		return iTestStepResult;

   458 		}

   459 

   460 	// prepare the tone

   461 	INFO_PRINTF1( _L("Initialize CMdaAudioToneUtility"));

   462 	iToneUtility->PrepareToPlayTone(KToneFrequency,TTimeIntervalMicroSeconds(KTwoSeconds));

   463 	// Wait for prepare

   464 	iErrorTone = KErrGeneral;	// set so we know tone callback has occurred

   465 	CActiveScheduler::Start();

   466 	if (iErrorTone != KErrNone)

   467 		{

   468 		iTestStepResult = EFail;

   469 		return iTestStepResult;

   470 		}

   471 

   472 	// start playing the file and give it time to start

   473 	INFO_PRINTF1( _L("Playing sound file (1)...low priority"));

   474 	TRAP(err, iRecorderUtility->PlayL());

   475 	if (err != KErrNone)

   476 		return EInconclusive;

   477 	CActiveScheduler::Start();

   478 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying))

   479 		{

   480 		iTestStepResult = EFail;

   481 		return iTestStepResult;

   482 		}

   483 	User::After(KQuarterScond);

   484 

   485 

   486 	// start playing the tone and wait for completion

   487 	// Two observer callbacks to catch here:

   488 	// One is high priority tone starting playing, and the other is the low

   489 	// priority recorder being kicked off. We are ignoring the order of these.

   490 	INFO_PRINTF1( _L("Playing tone...high priority"));

   491 	iToneUtility->Play();

   492 	iErrorTone = KErrGeneral;	// set so we know tone callback has occurred

   493 	CActiveScheduler::Start();

   494 	if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) &&

   495 		!(iErrorTone == KErrNone))

   496 		{

   497 		iTestStepResult = EFail;

   498 		return iTestStepResult;

   499 		}

   500 	iErrorTone = KErrGeneral;	// set so we know tone callback has occurred

   501 	CActiveScheduler::Start();

   502 	if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) &&

   503 		!(iErrorTone == KErrNone))

   504 		{

   505 		iTestStepResult = EFail;

   506 		return iTestStepResult;

   507 		}

   508 

   509 

   510 	// start playing the file again and wait for completion

   511 	INFO_PRINTF1( _L("Playing sound file (2)...low priority"));

   512 	TRAP(err, iRecorderUtility->PlayL());

   513 	if (err != KErrNone)

   514 		return EInconclusive;

   515 	CActiveScheduler::Start();

   516 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying))

   517 		{

   518 		iTestStepResult = EFail;

   519 		return iTestStepResult;

   520 		}

   521 

   522 	// Wait for end of play

   523 	CActiveScheduler::Start();

   524 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen))

   525 		{

   526 		iTestStepResult = EFail;

   527 		return iTestStepResult;

   528 		}

   529 

   530 	INFO_PRINTF1(_L("finished with this test step"));

   531 

   532 	// test steps return a result

   533 	return iTestStepResult;

   534 	}

   535 

   536 

   537 //

   538 

   539 

   540 /**

   541  *

   542  * Static constructor for CTestStepRecorderSimultaneousPlay3.

   543  *

   544  *

   545  * @return	"CTestStepRecorderSimultaneousPlay3*"

   546  *			The constructed CTestStepRecorderSimultaneousPlay3

   547  *

   548  * @xxxx

   549  *

   550  */

   551 CTestStepRecorderSimultaneousPlay3* CTestStepRecorderSimultaneousPlay3::NewL()

   552 	{

   553 	CTestStepRecorderSimultaneousPlay3* self = new(ELeave) CTestStepRecorderSimultaneousPlay3;

   554 	return self;

   555 	}

   556 

   557 /**

   558  *

   559  * Test step constructor.

   560  * Each test step initialises its own name.

   561  *

   562  * @xxxx

   563  *

   564  */

   565 CTestStepRecorderSimultaneousPlay3::CTestStepRecorderSimultaneousPlay3()

   566 	{

   567 	// store the name of this test case

   568 	// this is the name that is used by the script file

   569 	iTestStepName = _L("MM-MMF-ACLNT-U-0812-HP");

   570 	}

   571 

   572 /**

   573  *

   574  * Test step destructor.

   575  *

   576  * @xxxx

   577  *

   578  */

   579 CTestStepRecorderSimultaneousPlay3::~CTestStepRecorderSimultaneousPlay3()

   580 	{

   581 	}

   582 

   583 /**

   584  *

   585  * Test step destructor.

   586  *

   587  * @xxxx

   588  *

   589  */

   590 void CTestStepRecorderSimultaneousPlay3::Close()

   591 	{

   592 	delete iRecorderUtility1;

   593 	delete iRecorderUtility2;

   594 	}

   595 

   596 /**

   597  *

   598  * Test step Preamble.

   599  *

   600  * @xxxx

   601  *

   602  */

   603 enum TVerdict CTestStepRecorderSimultaneousPlay3::DoTestStepPreambleL(void)

   604 	{

   605 	TInt err;

   606 

   607 	TVerdict verdict;

   608 	 // this installs the scheduler

   609 	verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();

   610 

   611 	// Printing to the console and log file

   612 	INFO_PRINTF2(_L("%S"), &iTestStepName);

   613 	INFO_PRINTF1(_L("this is a test of playing a high priority .wav file over a low priority .wav file"));

   614 

   615 	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName1)) // long wav file

   616 		{

   617 		return EInconclusive;

   618 		}

   619 

   620 	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName1"), iFileName2)) // short wav file

   621 		{

   622 		return EInconclusive;

   623 		}

   624 

   625 	// create record utilities. A low priority and a high priority

   626 	TRAP(err, iRecorderUtility1 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin));

   627 	if (err != KErrNone)

   628 		return EInconclusive;

   629 

   630 	TRAP(err, iRecorderUtility2 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax));

   631 	if (err != KErrNone)

   632 		return EInconclusive;

   633 

   634 	return verdict;

   635 

   636 	}

   637 

   638 /**

   639  *

   640  * Test step Postamble.

   641  *

   642  * @xxxx

   643  *

   644  */

   645 enum TVerdict CTestStepRecorderSimultaneousPlay3::DoTestStepPostambleL(void)

   646 	{

   647 	//[ Destroy the scheduler ]

   648 	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();

   649 	}

   650 

   651 /**

   652  *

   653  * Callback Handle.

   654  *

   655  * @xxxx

   656  *

   657  */

   658 void CTestStepRecorderSimultaneousPlay3::MoscoStateChangeEvent(CBase* /*aObject*/,

   659 														  TInt aPreviousState,

   660 														  TInt aCurrentState,

   661 														  TInt aErrorCode)

   662 	{

   663 	INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"),

   664 		aPreviousState,

   665 		aCurrentState,

   666 		aErrorCode);

   667 	iError = aErrorCode;

   668 	iCurrentState = aCurrentState;

   669 	CActiveScheduler::Stop();

   670 	}

   671 

   672 

   673 /**

   674  *

   675  * Do the test step.

   676  * Each test step must supply an implementation for DoTestStepL.

   677  *

   678  * @return	"TVerdict"

   679  *			The result of the test step

   680  *

   681  * @xxxx

   682  *

   683  */

   684 TVerdict CTestStepRecorderSimultaneousPlay3::DoTestStepL()

   685 	{

   686 	iTestStepResult = EPass;

   687     TInt err       = KErrNone;

   688 

   689 	// open the sound file

   690 	INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility1"));

   691 	TRAP(err, iRecorderUtility1->OpenFileL(iFileName1));

   692 	if (err != KErrNone)

   693 		return EInconclusive;

   694 	// wait for open to complete

   695 	CActiveScheduler::Start();

   696 	if (iCurrentState != CMdaAudioRecorderUtility::EOpen)

   697 		return EFail;

   698 

   699 	// open the sound file

   700 	INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility2"));

   701 	TRAP(err, iRecorderUtility2->OpenFileL(iFileName2));

   702 	if (err != KErrNone)

   703 		return EInconclusive;

   704 	// wait for open to complete

   705 	CActiveScheduler::Start();

   706 	if (iCurrentState != CMdaAudioRecorderUtility::EOpen)

   707 		return EFail;

   708 

   709 	// start playing the first file and give it time to start

   710 	INFO_PRINTF1( _L("Playing sound file (1)...low priority"));

   711 	TRAP(err, iRecorderUtility1->PlayL());

   712 	if (err != KErrNone)

   713 		return EInconclusive;

   714 	CActiveScheduler::Start();

   715 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying))

   716 		{

   717 		iTestStepResult = EFail;

   718 		return iTestStepResult;

   719 		}

   720 	User::After(KQuarterScond);

   721 

   722 	// start playing the second file and wait for completion

   723 	// Two observer callbacks to catch here:

   724 	// One is high priority recorder starting playing, and the other is the low

   725 	// priority recorder being kicked off. We are ignoring the order of these.

   726 	INFO_PRINTF1( _L("Playing sound file (2)...high priority"));

   727 	TRAP(err, iRecorderUtility2->PlayL());

   728 	if (err != KErrNone)

   729 		return EFail;

   730 	CActiveScheduler::Start();

   731 	if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) &&

   732 		!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying))

   733 		{

   734 		iTestStepResult = EFail;

   735 		return iTestStepResult;

   736 		}

   737 	CActiveScheduler::Start();

   738 	if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) &&

   739 		!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying))

   740 		{

   741 		iTestStepResult = EFail;

   742 		return iTestStepResult;

   743 		}

   744 

   745 	// Wait for end of play for file 2

   746 	CActiveScheduler::Start();

   747 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen))

   748 		{

   749 		iTestStepResult = EFail;

   750 		return iTestStepResult;

   751 		}

   752 

   753 	// start playing the first file again and wait for completion

   754 	INFO_PRINTF1( _L("Playing sound file (3)...low priority"));

   755 	TRAP(err, iRecorderUtility1->PlayL());

   756 	if (err != KErrNone)

   757 		return EFail;

   758 	CActiveScheduler::Start();

   759 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying))

   760 		{

   761 		iTestStepResult = EFail;

   762 		return iTestStepResult;

   763 		}

   764 	User::After(KQuarterScond);

   765 

   766 	// Wait for end of play

   767 	CActiveScheduler::Start();

   768 	if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen))

   769 		{

   770 		iTestStepResult = EFail;

   771 		return iTestStepResult;

   772 		}

   773 

   774 	INFO_PRINTF1(_L("finished with this test step"));

   775 

   776 	// test steps return a result

   777 	return iTestStepResult;

   778 	}

   779 

   780 

   781 //

   782 

   783 

   784 /**

   785  *

   786  * Static constructor for CTestStepRecorderSimultaneousPlay4.

   787  *

   788  *

   789  * @return	"CTestStepRecorderSimultaneousPlay4*"

   790  *			The constructed CTestStepRecorderSimultaneousPlay4

   791  *

   792  * @xxxx

   793  *

   794  */

   795 CTestStepRecorderSimultaneousPlay4* CTestStepRecorderSimultaneousPlay4::NewL()

   796 	{

   797 	CTestStepRecorderSimultaneousPlay4* self = new(ELeave) CTestStepRecorderSimultaneousPlay4;

   798 	return self;

   799 	}

   800 

   801 /**

   802  *

   803  * Test step constructor.

   804  * Each test step initialises its own name.

   805  *

   806  * @xxxx

   807  *

   808  */

   809 CTestStepRecorderSimultaneousPlay4::CTestStepRecorderSimultaneousPlay4()

   810 	{

   811 	// store the name of this test case

   812 	// this is the name that is used by the script file

   813 	iTestStepName = _L("MM-MMF-ACLNT-U-0813-HP");

   814 	}

   815 

   816 /**

   817  *

   818  * Test step destructor.

   819  *

   820  * @xxxx

   821  *

   822  */

   823 CTestStepRecorderSimultaneousPlay4::~CTestStepRecorderSimultaneousPlay4()

   824 	{

   825 	}

   826 

   827 /**

   828  *

   829  * Test step Close

   830  * handles all deletion

   831  * @xxxx

   832  *

   833  */

   834 void CTestStepRecorderSimultaneousPlay4::Close()

   835 	{

   836 	delete iRecorderUtility1;

   837 	delete iRecorderUtility2;

   838 	}

   839 

   840 /**

   841  *

   842  * Test step Preamble.

   843  *

   844  * @xxxx

   845  *

   846  */

   847 enum TVerdict CTestStepRecorderSimultaneousPlay4::DoTestStepPreambleL(void)

   848 	{

   849 	TInt err;

   850 

   851 	TVerdict verdict;

   852 	 // this installs the scheduler

   853 	verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();

   854 

   855 	// Printing to the console and log file

   856 	INFO_PRINTF2(_L("%S"), &iTestStepName);

   857 	INFO_PRINTF1(_L("this is a test of playing a high priority .wav file over the same low priority .wav file"));

   858 

   859 	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName1)) // long wav file

   860 		{

   861 		return EInconclusive;

   862 		}

   863 

   864 	// create record utilities. A low priority and a high priority

   865 	TRAP(err, iRecorderUtility1 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin));

   866 	if (err != KErrNone)

   867 		return EInconclusive;

   868 

   869 	TRAP(err, iRecorderUtility2 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax));

   870 	if (err != KErrNone)

   871 		return EInconclusive;

   872 

   873 	return verdict;

   874 

   875 	}

   876 

   877 /**

   878  *

   879  * Test step Postamble.

   880  *

   881  * @xxxx

   882  *

   883  */

   884 enum TVerdict CTestStepRecorderSimultaneousPlay4::DoTestStepPostambleL(void)

   885 	{

   886 	//[ Destroy the scheduler ]

   887 	return CTestStepUnitMMFAudClient::DoTestStepPostambleL();

   888 	}

   889 

   890 /**

   891  *

   892  * Callback Handle.

   893  *

   894  * @xxxx

   895  *

   896  */

   897 void CTestStepRecorderSimultaneousPlay4::MoscoStateChangeEvent(CBase* aObject,

   898 														  TInt aPreviousState,

   899 														  TInt aCurrentState,

   900 														  TInt aErrorCode)

   901 	{

   902 	_LIT(KRecordUtility1, "RecorderUtility1");

   903 	_LIT(KRecordUtility2, "RecorderUtility2");

   904 	INFO_PRINTF5(_L("MoscoStateChangeEvent(): %S : Previous state = %d, current state = %d, error = %d"),

   905 		(aObject == iRecorderUtility1)?&KRecordUtility1:&KRecordUtility2,

   906 		aPreviousState,

   907 		aCurrentState,

   908 		aErrorCode);

   909 	iError = aErrorCode;

   910 

   911 	if (aObject == iRecorderUtility1)

   912 		iCurrentState1 = aCurrentState;

   913 	else if (aObject == iRecorderUtility2)

   914 		iCurrentState2 = aCurrentState;

   915 

   916 

   917 	CActiveScheduler::Stop();

   918 	}

   919 

   920 

   921 /**

   922  *

   923  * Do the test step.

   924  * Each test step must supply an implementation for DoTestStepL.

   925  *

   926  * @return	"TVerdict"

   927  *			The result of the test step

   928  *

   929  * @xxxx

   930  *

   931  */

   932 TVerdict CTestStepRecorderSimultaneousPlay4::DoTestStepL()

   933 	{

   934 	iTestStepResult = EPass;

   935     TInt err       = KErrNone;

   936 

   937 	INFO_PRINTF2(_L("File to play = %S"), &iFileName1);

   938 

   939 	// Get the first recorder utility to open the sound file

   940 	INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility1"));

   941 	TRAP(err, iRecorderUtility1->OpenFileL(iFileName1));

   942 	if (err != KErrNone)

   943 		return EInconclusive;

   944 	// wait for open to complete

   945 	CActiveScheduler::Start();

   946 	if (iCurrentState1 != CMdaAudioRecorderUtility::EOpen)

   947 		return EFail;

   948 

   949 	// start playing the first file and give it time to start

   950 	INFO_PRINTF1( _L("Playing sound file (Utililty #1)...low priority"));

   951 	TRAP(err, iRecorderUtility1->PlayL());

   952 	if (err != KErrNone)

   953 		return EInconclusive;

   954 	CActiveScheduler::Start();

   955 	if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EPlaying))

   956 		{

   957 		iTestStepResult = EFail;

   958 		return iTestStepResult;

   959 		}

   960 	User::After(KQuarterScond);

   961 

   962 	// Get the second recorder utility to open the sound file

   963 	INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility2"));

   964 	TRAP(err, iRecorderUtility2->OpenFileL(iFileName1));

   965 	if (err != KErrNone)

   966 		return EInconclusive;

   967 	// wait for open to complete

   968 	CActiveScheduler::Start();

   969 	if (iCurrentState2 != CMdaAudioRecorderUtility::EOpen)

   970 		return EFail;

   971 

   972 	// start playing the second file and wait for completion

   973 	// Two observer callbacks to catch here:

   974 	// One is high priority recorder starting playing, and the other is the low

   975 	// priority recorder being kicked off. We are ignoring the order of these.

   976 	INFO_PRINTF1( _L("Playing sound file (Utililty #2)...high priority"));

   977 	TRAP(err, iRecorderUtility2->PlayL());

   978 	if (err != KErrNone)

   979 		return EFail;

   980 	CActiveScheduler::Start();

   981 	if (!(iError == KErrInUse && iCurrentState1 == CMdaAudioRecorderUtility::EOpen) &&

   982 		!(iError == KErrNone && iCurrentState2 == CMdaAudioRecorderUtility::EPlaying))

   983 		{

   984 		iTestStepResult = EFail;

   985 		return iTestStepResult;

   986 		}

   987 	CActiveScheduler::Start();

   988 	if (!(iError == KErrInUse && iCurrentState1 == CMdaAudioRecorderUtility::EOpen) &&

   989 		!(iError == KErrNone && iCurrentState2 == CMdaAudioRecorderUtility::EPlaying))

   990 		{

   991 		iTestStepResult = EFail;

   992 		return iTestStepResult;

   993 		}

   994 

   995 	// Wait for end of play for second recorder utility

   996 	CActiveScheduler::Start();

   997 	if (!(iError == KErrNone && iCurrentState2 == CMdaAudioRecorderUtility::EOpen))

   998 		{

   999 		iTestStepResult = EFail;

  1000 		return iTestStepResult;

  1001 		}

  1002 

  1003 	// start playing the first file again and wait for completion

  1004 	INFO_PRINTF1( _L("Playing sound file (Utililty #1 again)...low priority"));

  1005 	TRAP(err, iRecorderUtility1->PlayL());

  1006 	if (err != KErrNone)

  1007 		return EFail;

  1008 	CActiveScheduler::Start();

  1009 	if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EPlaying))

  1010 		{

  1011 		iTestStepResult = EFail;

  1012 		return iTestStepResult;

  1013 		}

  1014 

  1015 	// Wait for end of play

  1016 	CActiveScheduler::Start();

  1017 	if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EOpen))

  1018 		{

  1019 		iTestStepResult = EFail;

  1020 		return iTestStepResult;

  1021 		}

  1022 

  1023 	INFO_PRINTF1(_L("finished with this test step"));

  1024 

  1025 	// test steps return a result

  1026 	return iTestStepResult;

  1027 	}

  1028 

  1029 

  1030 //

  1031 

  1032 

  1033 /**

  1034  *

  1035  * Static constructor for CTestStepRecorderSimultaneousPlay5

  1036  *

  1037  *

  1038  * @return	"CTestStepRecorderSimultaneousPlay5*"

  1039  *			The constructed CTestStepRecorderSimultaneousPlay5

  1040  *

  1041  * @xxxx

  1042  *

  1043  */

  1044 CTestStepRecorderSimultaneousPlay5* CTestStepRecorderSimultaneousPlay5::NewL()

  1045 	{

  1046 	CTestStepRecorderSimultaneousPlay5* self = new(ELeave) CTestStepRecorderSimultaneousPlay5;

  1047 	return self;

  1048 	}

  1049 

  1050 /**

  1051  *

  1052  * Test step constructor.

  1053  * Each test step initialises its own name.

  1054  *

  1055  * @xxxx

  1056  *

  1057  */

  1058 CTestStepRecorderSimultaneousPlay5::CTestStepRecorderSimultaneousPlay5()

  1059 	{

  1060 	// store the name of this test case

  1061 	// this is the name that is used by the script file

  1062 	iTestStepName = _L("MM-MMF-ACLNT-U-0814-HP");

  1063 	}

  1064 

  1065 /**

  1066  *

  1067  * Test step destructor.

  1068  *

  1069  * @xxxx

  1070  *

  1071  */

  1072 CTestStepRecorderSimultaneousPlay5::~CTestStepRecorderSimultaneousPlay5()

  1073 	{

  1074 	}

  1075 

  1076 /**

  1077  *

  1078  * Test step Close

  1079  * handles all deletion

  1080  * @xxxx

  1081  *

  1082  */

  1083 void CTestStepRecorderSimultaneousPlay5::Close()

  1084 	{

  1085 	delete iRecorderUtility1;

  1086 	delete iRecorderUtility2;

  1087 	}

  1088 

  1089 /**

  1090  *

  1091  * Test step Preamble.

  1092  *

  1093  * @xxxx

  1094  *

  1095  */

  1096 enum TVerdict CTestStepRecorderSimultaneousPlay5::DoTestStepPreambleL(void)

  1097 	{

  1098 	TInt err;

  1099 

  1100 	TVerdict verdict;

  1101 	 // this installs the scheduler

  1102 	verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();

  1103 

  1104 	// Printing to the console and log file

  1105 	INFO_PRINTF2(_L("%S"), &iTestStepName);

  1106 	INFO_PRINTF1(_L("this is a test of Open a low priority recorder and a higher priority recorder with the same file & get the duration in each case"));

  1107 

  1108 	if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName1)) // long wav file

  1109 		{

  1110 		return EInconclusive;

  1111 		}

  1112 

  1113 	// create record utilities. A low priority and a high priority

  1114 	TRAP(err, iRecorderUtility1 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin));

  1115 	if (err != KErrNone)

  1116 		return EInconclusive;

  1117 

  1118 	TRAP(err, iRecorderUtility2 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax));

  1119 	if (err != KErrNone)

  1120 		return EInconclusive;

  1121 

  1122 	return verdict;

  1123 

  1124 	}

  1125 

  1126 /**

  1127  *

  1128  * Test step Postamble.

  1129  *

  1130  * @xxxx

  1131  *

  1132  */

  1133 enum TVerdict CTestStepRecorderSimultaneousPlay5::DoTestStepPostambleL(void)

  1134 	{