1 // Copyright (c) 2005-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 program is designed the test of the MMF_ACLNT.

    15 // 

    16 //

    17 

    18 /**

    19  @file TestRecorder.cpp

    20 */

    21 

    22 #include "mmfwavformat.h"

    23 #include <hal.h>

    24 #include "TestRecorder.h"

    25 

    26 //copy util

    27 TInt	CopyFile(TPtrC aFileNameSrc, TPtrC aFileNameDst)

    28 {

    29 	TInt theErr = KErrNone;

    30 

    31 	RFs		fs;

    32 	fs.Connect();

    33 	RFile	theFileNew;

    34 	RFile	theFile;

    35 

    36 	fs.MkDirAll(aFileNameDst);

    37 	theFile.Open(fs, aFileNameSrc, EFileShareReadersOnly);

    38 	TInt	theSize;

    39 	theFile.Size(theSize);

    40 	

    41 	TBuf8<KSizeBuf>	theBuf;

    42 	TInt	theStep = KSizeBuf;

    43 	if(theStep > theSize)

    44 		{

    45 		theStep = theSize;

    46 		}

    47 	

    48 	TInt theRes = theFileNew.Create(fs, aFileNameDst, EFileShareAny);

    49 	if(theRes == KErrAlreadyExists)

    50 		{

    51 		theRes = theFileNew.Replace(fs, aFileNameDst, EFileShareAny);

    52 		}

    53 		

    54 

    55 	if(theRes != KErrNone)

    56 		{

    57 		return theRes;

    58 		}

    59 		

    60 

    61 	TInt	theCurLength = 0;

    62 	while(theCurLength < theSize)

    63 		{

    64 		theFile.Read(theBuf, theStep);

    65 		theFileNew.Write(theBuf, theStep);

    66 		theCurLength += theStep;

    67 		

    68 		if(theCurLength + theStep > theSize )

    69 			{

    70 			theStep = theSize - theCurLength;

    71 			}

    72 		}

    73 

    74 	theFileNew.Close();

    75 	theFile.Close();

    76 	fs.Close();

    77 

    78 	return theErr;

    79 }

    80 

    81 

    82 CTestMmfAclntRecord::CTestMmfAclntRecord(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) :

    83 	iNegative(aNegative)

    84 	{

    85 	// store the name of this test case

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

    87     // Each test step initialises it's own name

    88 	iTestStepName = aTestName;

    89 	iSectName = aSectName;

    90 	}

    91 

    92 void CTestMmfAclntRecord::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

    93 	{

    94 	iError = aErrorCode;

    95 	iObject = aObject;

    96 	iPreviousState = aPreviousState;

    97 	iCurrentState = aCurrentState;

    98 	INFO_PRINTF1( _L("CTestMmfAclntRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete"));

    99 	INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState);

   100 	CActiveScheduler::Stop();

   101 	}

   102 

   103 TVerdict CTestMmfAclntRecord::DoTestStepL( void )

   104 	{

   105 	INFO_PRINTF1( _L("TestRecorder"));

   106 	TVerdict ret = EFail;

   107 

   108 	iError = KErrTimedOut;

   109 

   110 	TBuf<KSizeBuf>	filename;

   111 	TPtrC			filename1; 

   112 	TPtrC			filename2; 

   113 	

   114 	if(!GetStringFromConfig(iSectName, _L("cropAudioFile"), filename1))

   115 		{

   116 		return EInconclusive;

   117 		}

   118 		

   119 

   120 	if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename2))

   121 		{

   122 		return EInconclusive;

   123 		}

   124 		

   125 	

   126 	

   127 	GetDriveName(filename);

   128 	filename.Append(filename1);

   129 

   130 	CopyFile(filename2, filename);

   131 

   132 	CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this);

   133 	CleanupStack::PushL(recUtil);

   134 	recUtil->OpenFileL(filename);

   135 	// wait

   136 	INFO_PRINTF1(_L("Initialise CMdaAudioRecorderUtility"));

   137 	CActiveScheduler::Start();

   138 

   139 

   140 	if(iError == KErrNone)

   141 		{

   142 		INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename);

   143 		ret = DoTestL(recUtil);

   144 		}

   145 

   146 	CleanupStack::PopAndDestroy(recUtil);

   147 	User::After(KTwoSeconds);

   148 	ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError );

   149 	return ret;

   150 	}

   151 

   152 CTestMmfAclntRecGain::CTestMmfAclntRecGain(const TDesC& aTestName, const TDesC& aSectName, const TInt aGain, TBool aNegative)

   153 	:CTestMmfAclntRecord(aTestName, aSectName, aNegative)	

   154 	, iGain (aGain)

   155 	{}

   156 

   157 CTestMmfAclntRecGain* CTestMmfAclntRecGain::NewL(const TDesC& aTestName, const TDesC& aSectName,const TInt aGain, TBool aNegative)

   158 	{

   159 	CTestMmfAclntRecGain* self = new (ELeave) CTestMmfAclntRecGain(aTestName, aSectName, aGain, aNegative);

   160 	return self;

   161 	}

   162 

   163 /**

   164  * RecordUtils test: Set gain to maximum and enquire gain.

   165  */

   166 TVerdict CTestMmfAclntRecGain::DoTestL(CMdaAudioRecorderUtility* aRecUtil)

   167 	{

   168 	INFO_PRINTF2( _L("TestRecorder : Gain - (%d)"), iGain);

   169 

   170 	TVerdict ret = EFail;

   171 

   172 	// Set up a file to record to

   173 	TPtrC filename;

   174 	if (!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename))

   175 		{

   176 		INFO_PRINTF1(_L("Error getting filename from INI file"));

   177 		return EInconclusive;

   178 		}

   179 

   180 	RFs fs;

   181 	TInt err = fs.Connect();

   182 	if (err != KErrNone)

   183 		{

   184 		INFO_PRINTF2(_L("Error connecting file session"), err);

   185 		fs.Close();

   186 		return EInconclusive;

   187 		}

   188 

   189 	err = fs.Delete(filename);

   190 	

   191 	if (!((err == KErrNone) || (err == KErrNotFound)))

   192 		{

   193 		INFO_PRINTF2(_L("Error deleting output file"), err);

   194 		return EInconclusive;

   195 		}

   196 	

   197 	// Add create file for Ogg-tests

   198 	if(iSectName == _L("SectionOggRec"))

   199 		{

   200 		RFs fs;

   201 		User::LeaveIfError(fs.Connect());

   202 		RFile file;

   203 		User::LeaveIfError(file.Replace(fs,filename,EFileWrite));

   204 		file.Close();

   205 		fs.Close();

   206 		}

   207 

   208 	aRecUtil->OpenFileL(filename);

   209 	INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename);

   210 	CActiveScheduler::Start();

   211 

   212 	if (iError != KErrNone)

   213 		{

   214 		INFO_PRINTF2(_L("Error opening file for recording"), iError);

   215 		return EInconclusive;

   216 		}

   217 

   218 	// Set gain

   219 	if(iGain == 0)

   220 		{

   221 		iGain = aRecUtil->MaxGain();

   222 		}

   223 		

   224 	aRecUtil->SetGain(iGain);

   225 

   226 	// Set expected value

   227 	TInt expectedGain = 0;

   228 	if (iGain > aRecUtil->MaxGain())

   229 		{

   230 		expectedGain = aRecUtil->MaxGain();

   231 		}

   232 		

   233 	else if (iGain < 0)

   234 		{

   235 		expectedGain = 0;

   236 		}

   237 		

   238 	else

   239 		{

   240 		expectedGain = iGain;

   241 		}

   242 		

   243 

   244 	aRecUtil->SetDestinationSampleRateL(8000);	

   245 

   246 	// Start recording

   247 	aRecUtil->RecordL();

   248 	CActiveScheduler::Start();

   249 	User::After(1000000);

   250 

   251 	// Get gain

   252 	TInt gain;

   253 	aRecUtil->GetGain(gain);

   254 

   255 	// The gain should be not be more than max gain

   256 	if (gain > aRecUtil->MaxGain())

   257 		{

   258 		INFO_PRINTF3(_L("ERROR: GetGain value greater than MaxGain (%d > %d)"), gain, aRecUtil->MaxGain());

   259 		ret = EFail;

   260 		}

   261 	// The gain should not be less than 0

   262 	else if (gain < 0)

   263 		{

   264 		INFO_PRINTF3(_L("ERROR: GetGain value less than minimum gain (%d < %d)"), gain, 0);

   265 		ret = EFail;

   266 		}

   267 	else if (gain != expectedGain)

   268 		{

   269 		ERR_PRINTF3(_L("ERROR: GetGain value not equal to expected value (%d != %d)"), gain, expectedGain);

   270 		ret = EFail;

   271 		}

   272 	else

   273 		{

   274 		ret = EPass;	

   275 		}

   276 

   277 	// stop the recording - only necessary if anyone wanted to look at the output file

   278 	aRecUtil->Stop();

   279 

   280 	return ret;

   281 	}

   282 

   283 //------------------------------------------------------------------

   284 

   285 CTestMmfAclntRecStateTran::CTestMmfAclntRecStateTran(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative)

   286 	:CTestMmfAclntRecord(aTestName, aSectName, aNegative)	

   287 	{}

   288 

   289 CTestMmfAclntRecStateTran* CTestMmfAclntRecStateTran::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative)

   290 	{

   291 	CTestMmfAclntRecStateTran* self = new (ELeave) CTestMmfAclntRecStateTran(aTestName, aSectName, aNegative);

   292 	return self;

   293 	}

   294 

   295 TVerdict CTestMmfAclntRecStateTran::DoTestStepL()

   296 	{

   297 	INFO_PRINTF1( _L("TestRecorder : Transition"));

   298 	TVerdict ret = EFail;

   299 

   300 	iError = KErrTimedOut;

   301 

   302 	TPtrC filename; 

   303 

   304 

   305 	if(!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename))

   306 		{

   307 		return EInconclusive;

   308 		}

   309 		

   310 	RFs	fs;

   311 	fs.Connect();

   312 	fs.Delete(filename);

   313 	fs.Close();

   314 

   315 	CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this);

   316 	CleanupStack::PushL(recUtil);

   317 	

   318 	// Add create file for Ogg-tests

   319 	if(iSectName == _L("SectionOggRecState"))

   320 		{

   321 		RFs fs;

   322 		User::LeaveIfError(fs.Connect());

   323 		RFile file;

   324 		User::LeaveIfError(file.Replace(fs,filename,EFileWrite));

   325 		file.Close();

   326 		fs.Close();

   327 		}

   328 	

   329 	INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename);

   330 	recUtil->OpenFileL(filename);

   331 	// wait

   332 	INFO_PRINTF1(_L("Initialise CMdaAudioRecorderUtility"));

   333 	CActiveScheduler::Start();

   334 

   335 	if(iError == KErrNone)

   336 		{

   337 		ret = DoTestL(recUtil);

   338 		}

   339 		

   340 

   341 	CleanupStack::PopAndDestroy(recUtil);

   342 	User::After(KTwoSeconds);

   343 	ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError );

   344 	return ret;

   345 	}

   346 

   347 /**

   348  * Enquire state at each state transition.

   349  */

   350 TVerdict CTestMmfAclntRecStateTran::DoTestL(CMdaAudioRecorderUtility* aRecUtil)

   351 	{

   352 	INFO_PRINTF1( _L("TestRecorder : State Transition"));

   353 

   354 	TVerdict ret= EFail;

   355 

   356 	iReportedState = aRecUtil->State();

   357 	if( iReportedState == CMdaAudioClipUtility::EOpen )

   358 		{

   359 		INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility"));

   360 		aRecUtil->RecordL();

   361 		CActiveScheduler::Start(); // wait for open -> record

   362 		if (iError != KErrNone)

   363 			{

   364 			return EFail;

   365 			}

   366 			

   367 		iReportedState = aRecUtil->State();

   368 		if(iReportedState == CMdaAudioClipUtility::ERecording )

   369 			{

   370 			ret = EPass;

   371 			}

   372 			

   373 		User::After(KTwoSeconds);

   374 		aRecUtil->Stop();

   375 

   376 		iReportedState = aRecUtil->State();

   377 		if(iReportedState != CMdaAudioClipUtility::EOpen )

   378 			{

   379 			return EFail;

   380 			}

   381 			

   382 		aRecUtil->PlayL();

   383 		CActiveScheduler::Start(); // wait for open -> play

   384 		if (iError != KErrNone)

   385 			{

   386 			return EFail;

   387 			}

   388 			

   389 		iReportedState = aRecUtil->State();

   390 		if( iReportedState == CMdaAudioClipUtility::EPlaying )

   391 			{

   392 			// Wait for play to complete

   393 			CActiveScheduler::Start();

   394 			if (iError != KErrNone)

   395 				{

   396 				return EFail;

   397 				}

   398 				

   399 			//copy file

   400 			}

   401 		}

   402 	return ret;

   403 	}

   404 

   405 //---------------------------------------------------------------------------------

   406 

   407 CTestMmfFormatRead::CTestMmfFormatRead(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative)

   408 	:CTestMmfAclntRecord(aTestName, aSectName, aNegative)	

   409 	{

   410 	}

   411 

   412 CTestMmfFormatRead* CTestMmfFormatRead::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative)

   413 	{

   414 	CTestMmfFormatRead* self = new (ELeave) CTestMmfFormatRead(aTestName, aSectName, aNegative);

   415 	return self;

   416 	}

   417 

   418 _LIT(KFileXyz, "\\AclntITestData\\Test.xyz");

   419 _LIT(KFileAbc, "\\AclntITestData\\Test.abc");

   420 

   421 TVerdict CTestMmfFormatRead::DoTestStepL()

   422 	{

   423 	INFO_PRINTF1( _L("CTestMmfFormatRead : Opening the test files"));

   424 	TVerdict ret = EPass;

   425 

   426 	INFO_PRINTF1( _L("Opening the test file test.xyz"));

   427 

   428 	TPtrC fileXyz(KFileXyz);

   429 

   430 	// File with extension .xyz does not have a plugin and hence opening this file should fail.

   431 	CMdaAudioRecorderUtility* recUtilXyz = CMdaAudioRecorderUtility::NewL(*this);

   432 	CleanupStack::PushL(recUtilXyz);

   433 	TRAP_IGNORE(recUtilXyz->OpenFileL(fileXyz));

   434 	CActiveScheduler::Start(); 

   435 		 

   436 	if (recUtilXyz->State() == CMdaAudioClipUtility::EOpen)

   437 		{

   438 		INFO_PRINTF1( _L("Opening the test file test.xyz failed"));

   439 		ret = EFail;

   440 		}

   441 	

   442 	CleanupStack::PopAndDestroy(recUtilXyz);

   443 

   444 	INFO_PRINTF1( _L("Opening the test file test.abc"));

   445 	TPtrC fileAbc(KFileAbc);

   446 	

   447 	// File with extension .abc does have a plugin and hence opening this file should pass.

   448 	CMdaAudioRecorderUtility* recUtilAbc = CMdaAudioRecorderUtility::NewL(*this);

   449 	CleanupStack::PushL(recUtilAbc);

   450 	TRAP_IGNORE(recUtilAbc->OpenFileL(fileAbc));

   451 	CActiveScheduler::Start(); 

   452 	

   453 	if (recUtilAbc->State() != CMdaAudioClipUtility::EOpen)

   454 		{

   455 		INFO_PRINTF1( _L("Opening the test file test.abc failed"));

   456 		ret = EFail;

   457 		}

   458 	

   459 	CleanupStack::PopAndDestroy(recUtilAbc);

   460 

   461 	return ret;

   462 	}

   463 

   464 /**

   465  * Enquire state at each state transition.

   466  */

   467 

   468 TVerdict CTestMmfFormatRead::DoTestL(CMdaAudioRecorderUtility* /*aRecUtil*/)

   469 	{

   470 	INFO_PRINTF1( _L("CTestMmfFormatRead::DoTestL"));

   471 	return (TVerdict(EPass));

   472 	}

   473 

   474 //------------------------------------------------------------------

   475 

   476 /**

   477  * Constructor

   478  */

   479 CTestMmfAclntCrop::CTestMmfAclntCrop(const TDesC& aTestName, const TDesC& aSectName, const TBool aCropToEnd, TBool aNegative)

   480 	:CTestMmfAclntRecord(aTestName, aSectName, aNegative)	

   481 	{

   482 	iCropToEnd = aCropToEnd;

   483 	}

   484 

   485 CTestMmfAclntCrop* CTestMmfAclntCrop::NewL(const TDesC& aTestName, const TDesC& aSectName, const TBool aCropToEnd, TBool aNegative)

   486 	{

   487 	CTestMmfAclntCrop* self = new (ELeave) CTestMmfAclntCrop(aTestName, aSectName, aCropToEnd, aNegative);

   488 	return self;

   489 	}

   490 

   491 

   492 

   493 /**

   494  * Audio croping.

   495  */

   496 TVerdict CTestMmfAclntCrop::DoTestL(CMdaAudioRecorderUtility* aRecUtil)

   497 	{

   498  	TTimeIntervalMicroSeconds expectedDuration(KPcm16FrameInterval * 5), duration;

   499 

   500 	duration = aRecUtil->Duration();

   501 	INFO_PRINTF3(_L("Duration of Original file, expected =  %f, actual: %f"),

   502 					I64REAL(expectedDuration.Int64()), I64REAL(duration.Int64()));

   503 					

   504 	if(expectedDuration == duration)

   505 		{

   506 		return EInconclusive;

   507 		}

   508 	

   509 	if(duration > expectedDuration)

   510 		{

   511 		aRecUtil->SetPosition(expectedDuration);

   512 		

   513 		if(iCropToEnd)

   514 			{

   515 			TRAP(iError, aRecUtil->CropL());

   516 			}

   517 		else

   518 			{

   519 			TRAP(iError, aRecUtil->CropFromBeginningL());

   520 			}

   521 		if(iError != KErrNone)

   522 			{

   523 			ERR_PRINTF2(_L("Crop left with error =  %d"),iError);

   524 			return EFail;

   525 			}

   526 		if(iCropToEnd)

   527 			{

   528 			TTimeIntervalMicroSeconds actualDuration = aRecUtil->Duration();

   529 			if (TimeComparison(I64INT(actualDuration.Int64()), I64INT(expectedDuration.Int64()), KExpectedDurationDeviation))

   530 				{

   531 				INFO_PRINTF1(_L("Duration within expected deviation"));

   532 				return EPass;

   533 				}

   534 			else

   535 				{

   536 				ERR_PRINTF3(_L("Duration cropped file, expected =  %f, actual: %f"),

   537 					I64REAL(expectedDuration.Int64()), I64REAL(actualDuration.Int64()));

   538 				}

   539 			}

   540 		if(!iCropToEnd)

   541 			{

   542 			TInt64 theDelta = duration.Int64() - expectedDuration.Int64();

   543 

   544 			TTimeIntervalMicroSeconds actualDuration = aRecUtil->Duration();

   545 			if (TimeComparison(I64INT(actualDuration.Int64()), I64INT(theDelta), KExpectedDurationDeviation))

   546 				{

   547 				INFO_PRINTF1(_L("Duration within expected deviation"));

   548 				return EPass;

   549 				}

   550 			else

   551 				{

   552 				ERR_PRINTF3(_L("Duration cropped file, expected =  %f, actual: %f"),

   553 					I64REAL(theDelta), 

   554 					I64REAL(aRecUtil->Duration().Int64()));

   555 				}

   556 			}

   557 		}

   558 	return	EFail ;

   559 	}

   560 

   561 

   562 //------------------------------------------------------------------

   563 

   564 CTestMmfAclntRecCloseOpen::CTestMmfAclntRecCloseOpen(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative)

   565 	:CTestMmfAclntRecord(aTestName, aSectName, aNegative)	

   566 	{

   567 	}

   568 

   569 CTestMmfAclntRecCloseOpen* CTestMmfAclntRecCloseOpen::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative)

   570 	{

   571 	CTestMmfAclntRecCloseOpen* self = new (ELeave) CTestMmfAclntRecCloseOpen(aTestName, aSectName, aNegative);

   572 	return self;

   573 	}

   574 

   575 TVerdict CTestMmfAclntRecCloseOpen::DoTestL(CMdaAudioRecorderUtility* aRecUtil)

   576 /**

   577  * Open, Close and open a new audio clip.

   578  */

   579 	{

   580 	INFO_PRINTF1( _L("TestRecorder : Close/Open"));

   581 

   582 	TBuf<KSizeBuf>	filename;

   583 	TPtrC			filename1; 

   584 

   585 	if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename1))

   586 		{

   587 		return EInconclusive;

   588 		}

   589 		

   590 	GetDriveName(filename);

   591 	filename.Append(filename1);

   592 

   593 	iError = KErrTimedOut;

   594 	

   595 

   596 	aRecUtil->Close();

   597 	aRecUtil->OpenFileL(filename);

   598 	INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));

   599 	//wait

   600 	CActiveScheduler::Start(); 

   601 	if(iError == KErrNone)

   602 		{

   603 		return EPass;	

   604 		}

   605 		

   606 	return	EFail ;

   607 	}

   608 

   609 

   610 //------------------------------------------------------------------

   611 

   612 /**

   613  * Constructor

   614  */

   615 CTestMmfAclntRecFile::CTestMmfAclntRecFile(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile)

   616 

   617 	{

   618 	iTestStepName = aTestName;

   619 	iHeapSize = 200000;		// playback part of test loads whole sound file into buffer, so need large heap

   620 	iSectName = aSectName;

   621 	iKeyName = aKeyName;

   622 	iTestFormat = aFormat;

   623 	iCreateFile = aCreateFile;

   624 	}

   625 

   626 CTestMmfAclntRecFile* CTestMmfAclntRecFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile)

   627 	{

   628 	CTestMmfAclntRecFile* self = new (ELeave) CTestMmfAclntRecFile(aTestName,aSectName,aKeyName,aFormat,aCreateFile);

   629 	return self;

   630 	}

   631 

   632 CTestMmfAclntRecFile* CTestMmfAclntRecFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile)

   633 	{

   634 	CTestMmfAclntRecFile* self = CTestMmfAclntRecFile::NewLC(aTestName,aSectName,aKeyName,aFormat,aCreateFile);

   635 	CleanupStack::PushL(self);

   636 	return self;

   637 	}

   638 

   639 void CTestMmfAclntRecFile::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode)

   640 	{

   641 	iError = aErrorCode;

   642 	INFO_PRINTF1( _L("CTestMmfAclntRecFile : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete"));

   643 	INFO_PRINTF2( _L("iError %d "), iError);

   644 

   645     if(aCurrentState == CMdaAudioClipUtility::ERecording)

   646         {

   647         User::After(KFiveSeconds);

   648         }

   649 	CActiveScheduler::Stop();

   650 	}

   651 

   652 // Audio utility callbacks

   653 void CTestMmfAclntRecFile::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)

   654 	{

   655 	iError = aError;

   656 	CActiveScheduler::Stop();

   657 	}

   658 

   659 void CTestMmfAclntRecFile::MapcPlayComplete(TInt aError)

   660 	{

   661 	iError = aError;

   662 	CActiveScheduler::Stop();

   663 	}

   664 

   665 // Audio output stream callbacks

   666 void CTestMmfAclntRecFile::MaoscOpenComplete(TInt aError)

   667 	{

   668 	iError = aError;

   669 	CActiveScheduler::Stop();

   670 	}

   671 

   672 void CTestMmfAclntRecFile::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)

   673 	{

   674 	iError = aError;

   675 	CActiveScheduler::Stop();

   676 	}

   677 

   678 void CTestMmfAclntRecFile::MaoscPlayComplete(TInt aError)

   679 	{

   680 	iError = aError;

   681 	CActiveScheduler::Stop();

   682 	}

   683 

   684 

   685 TVerdict CTestMmfAclntRecFile::DoTestStepPreambleL()

   686 	{

   687 	TVerdict ret = EPass;

   688 

   689 	SetupFormatL(iTestFormat);

   690 

   691 	if(iCreateFile)

   692 		{

   693 		// Make sure file doesn't exist (maybe from a previous test)

   694 		TParse fullFileName;

   695 		TBuf<KSizeBuf>	filename;

   696 		TPtrC			filename1; 

   697 

   698 		if(!GetStringFromConfig(iSectName, iKeyName, filename1))

   699 			{

   700 			return EInconclusive;

   701 			}

   702 			

   703 		GetDriveName(filename);

   704 		filename.Append(filename1);

   705 		

   706 

   707 		// parse the filenames

   708 		if(!fullFileName.Set(filename, &KDefault, NULL))

   709 			{

   710 			RFs fs;

   711 			User::LeaveIfError(fs.Connect());

   712 			fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); 

   713 			TInt error = fs.Delete(fullFileName.FullName());

   714 

   715 			if(error == KErrPathNotFound)

   716 			{

   717 				error = fs.MkDirAll(fullFileName.DriveAndPath());

   718 				INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName());	

   719 			}

   720 			else  if(error == KErrNotFound)

   721 				INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName());	

   722 			else if(error==KErrNone)

   723 				INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName());	

   724 			else

   725 				{

   726 				ret = EInconclusive;

   727 				}

   728 			fs.Close();

   729 			}

   730 		

   731 		}

   732 

   733 	if((ret == EInconclusive) || (ret == EFail))

   734 		{

   735 		return ret;	

   736 		}

   737 		

   738 	return CTestMmfAclntStep::DoTestStepPreambleL();

   739 	}

   740 

   741 /**

   742  * Open a file based clip and record

   743  */

   744 TVerdict CTestMmfAclntRecFile::DoTestStepL()

   745 	{

   746 	INFO_PRINTF1( _L("TestRecorder : Record File"));

   747 	TVerdict ret = EFail;

   748 	iError = KErrTimedOut;

   749 

   750 	TPtrC filename;

   751 	if(!GetStringFromConfig(iSectName, iKeyName, filename))

   752 		{

   753 		return EInconclusive;

   754 		}

   755 		

   756 	

   757 	CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this);

   758 	CleanupStack::PushL(recUtil);

   759 

   760 	TMdaFileClipLocation location(filename);

   761 	

   762 	INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename);

   763 	if(!iCreateFile)

   764 		{

   765 		if(iSectName == _L("SectionOggRec")) // - Added to use OpenFileL only as OpenL parameters are deprected.

   766 			{

   767 			TPtrC filename2; 

   768 

   769 			if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename2))

   770 				{

   771 				return EInconclusive;

   772 				}

   773 				

   774 			CopyFile(filename2, filename);

   775 			}

   776 		recUtil->OpenFileL(filename);

   777 		}

   778 	else

   779 		{

   780 		RFs fs;

   781 		fs.Connect();

   782 		fs.Delete(filename);

   783 		fs.Close();

   784 		if(iSectName == _L("SectionOggRec")) // - Added to use OpenFileL only as OpenL parameters are deprected.

   785 			{

   786 			recUtil->OpenFileL(filename); // - Should create the file internally

   787 			}

   788 		else

   789 			{

   790 			recUtil->OpenL(&location,iFormat,iCodec,&iAudioSettings);	

   791 			}

   792 		}

   793 

   794 	INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));

   795 	CActiveScheduler::Start();

   796 

   797 	if(iError == KErrNone)

   798 		{

   799 		iError = KErrTimedOut;

   800 		recUtil->RecordL();

   801 		INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility"));

   802 		CActiveScheduler::Start(); // open -> record

   803 		

   804 		recUtil->Stop();

   805 		}

   806 

   807 

   808 	CleanupStack::PopAndDestroy(recUtil);

   809 	recUtil = NULL;

   810 

   811 	// Playback the file

   812 	if (iError == KErrNone)

   813 		{

   814 		if (filename.Right(4).Compare(_L(".raw"))==0)

   815 			{

   816 			// Raw file playback

   817 			CMdaAudioOutputStream* outputStream = CMdaAudioOutputStream::NewL(*this);

   818 			CleanupStack::PushL(outputStream);

   819 

   820 			outputStream->Open(NULL);

   821 			CActiveScheduler::Start();

   822 			if (iError != KErrNone)

   823 				{

   824 				INFO_PRINTF2(_L("Error opening output stream for playback = %d"), iError);

   825 				CleanupStack::PopAndDestroy(outputStream);

   826 				return EFail;

   827 				}

   828 

   829 			// Connect file session

   830 			RFs fs;

   831 			TInt err = fs.Connect();

   832 			if (err != KErrNone)

   833 				{

   834 				INFO_PRINTF2(_L("Error connecting to file session = %d"), err);

   835 				return EFail;

   836 				}

   837 			CleanupClosePushL(fs);

   838 

   839 			// Open file

   840 			RFile file;

   841 			err = file.Open(fs, filename, EFileRead);

   842 			if (err != KErrNone)

   843 				{

   844 				INFO_PRINTF2(_L("Error opening file = %d"), err);

   845 				CleanupStack::PopAndDestroy(2, outputStream);	// fs, outputStream

   846 				return EFail;

   847 				}

   848 			CleanupClosePushL(file);

   849 

   850 			// Get size of file

   851 			TInt fileSize = 0;

   852 			err = file.Size(fileSize);

   853 			if (err != KErrNone)

   854 				{

   855 				INFO_PRINTF2(_L("Error getting size of file = %d"), err);

   856 				CleanupStack::PopAndDestroy(3, outputStream);	// file, fs, outputStream

   857 				return EFail;

   858 				}

   859 

   860 			// Read file

   861 			HBufC8* buf = HBufC8::NewLC(fileSize);

   862 			TPtr8 ptr(buf->Des());

   863 			err = file.Read(ptr);

   864 			if (err != KErrNone)

   865 				{

   866 				INFO_PRINTF2(_L("Error reading file %d"), err);

   867 				}

   868 			else

   869 				{

   870 				outputStream->WriteL(ptr);

   871 				CActiveScheduler::Start();

   872 				if (iError != KErrNone)

   873 					INFO_PRINTF2(_L("Error writing file on audio output stream %d"), iError);

   874 				}

   875 

   876 			CleanupStack::PopAndDestroy(4, outputStream);	// buf, file, fs, outputStream

   877 			}

   878 		else

   879 			{

   880 			// Wav file playback

   881 			CMdaAudioPlayerUtility* playUtil = CMdaAudioPlayerUtility::NewL(*this);

   882 			CleanupStack::PushL(playUtil);

   883 			TRAPD(err, playUtil->OpenFileL(filename));

   884 			if (err != KErrNone)

   885 				{

   886 				INFO_PRINTF2(_L("Error opening file for playback err = %d"), err);

   887 				CleanupStack::PopAndDestroy(playUtil);

   888 				return EFail;

   889 				}

   890 			CActiveScheduler::Start();

   891 			if (iError != KErrNone)

   892 				{

   893 				INFO_PRINTF2(_L("Error opening file for playback iError = %d"), iError);

   894 				CleanupStack::PopAndDestroy(playUtil);

   895 				return EFail;

   896 				}

   897 			playUtil->Play();

   898 			CActiveScheduler::Start();

   899 			CleanupStack::PopAndDestroy(playUtil);

   900 			if (iError != KErrNone)

   901 				{

   902 				INFO_PRINTF2(_L("Error during playback of recorded file iError=%d"), iError);

   903 				return EFail;

   904 				}

   905 			}

   906 		}

   907 	// DEF127335

   908    	// OggRecordController does not support recording into an already existing file.

   909    	// This is due to unavailability of APIs at the level of Ogg Vorbis C libraries.

   910 	else if (iTestStepName == _L("MM-MMF-ACLNTOGG-I-0102-CP") && iError == KErrNotSupported)

   911 		{

   912     	INFO_PRINTF1(_L("Expected Result: OggRecordController returned KErrNotSupported(-5)"));

   913 		return EPass;

   914 		}

   915 

   916 	if( iError == KErrNone ) 

   917 		{

   918 		RFs fs;

   919 		RFile file;

   920 		TInt size = 0;

   921 		User::LeaveIfError(fs.Connect());

   922 		User::LeaveIfError(file.Open(fs,filename,EFileRead));

   923 		CleanupClosePushL(file);

   924 		User::LeaveIfError(file.Size(size));

   925 

   926 		if(size > 0)

   927 			{

   928 			ret = EPass;

   929 			}

   930 			

   931 		CleanupStack::PopAndDestroy(); //file

   932 		}

   933 

   934 	ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError );

   935 	User::After(KOneSecond);

   936 	return	ret;

   937 	}

   938 

   939 

   940 

   941 //------------------------------------------------------------------

   942 

   943 /**

   944  * Constructor

   945  */

   946 CTestMmfAclntRecFileForceFormat::CTestMmfAclntRecFileForceFormat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat)

   947 	{

   948 	// store the name of this test case

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

   950 	// Each test step initialises it's own name

   951 	iTestStepName = aTestName;

   952 	iSectName = aSectName;

   953 	iKeyName = aKeyName;

   954 	iFormat = aFormat;

   955 	}

   956 

   957 CTestMmfAclntRecFileForceFormat* CTestMmfAclntRecFileForceFormat::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat)

   958 	{

   959 	CTestMmfAclntRecFileForceFormat* self = new (ELeave) CTestMmfAclntRecFileForceFormat(aTestName,aSectName,aKeyName,aFormat);

   960 	return self;

   961 	}

   962 

   963 CTestMmfAclntRecFileForceFormat* CTestMmfAclntRecFileForceFormat::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat)

   964 	{

   965 	CTestMmfAclntRecFileForceFormat* self = CTestMmfAclntRecFileForceFormat::NewLC(aTestName,aSectName,aKeyName,aFormat);

   966 	CleanupStack::PushL(self);

   967 	return self;

   968 	}

   969 

   970 void CTestMmfAclntRecFileForceFormat::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode)

   971 	{

   972 	iError = aErrorCode;

   973 	INFO_PRINTF1( _L("CTestMmfAclntRecFile : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete"));

   974 	INFO_PRINTF2( _L("iError %d "), iError);

   975 

   976 	//dont stop the playing track

   977 	if (aCurrentState != CMdaAudioClipUtility::EPlaying || iError != KErrNone)

   978 		{

   979 		CActiveScheduler::Stop();

   980 		}

   981 	}

   982 

   983 

   984 TVerdict CTestMmfAclntRecFileForceFormat::DoTestStepPreambleL()

   985 	{

   986 	TVerdict ret = EPass;

   987 

   988 	// Make sure file doesn't exist (maybe from a previous test)

   989 	TParse fullFileName;

   990 	TBuf<KSizeBuf>	filename;

   991 	TPtrC			filename1; 

   992 

   993 	if(!GetStringFromConfig(iSectName, iKeyName, filename1))

   994 		{

   995 		return EInconclusive;

   996 		}

   997 		

   998 

   999 	GetDriveName(filename);

  1000 	filename.Append(filename1);

  1001 		

  1002 

  1003 	// parse the filenames

  1004 	if(!fullFileName.Set(filename, &KDefault, NULL))

  1005 		{

  1006 		RFs fs;

  1007 		User::LeaveIfError(fs.Connect());

  1008 		fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); 

  1009 		TInt error = fs.Delete(fullFileName.FullName());

  1010 

  1011 		if(error == KErrPathNotFound)

  1012 			{

  1013 			error = fs.MkDirAll(fullFileName.DriveAndPath());

  1014 			INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName());	

  1015 			}

  1016 		else  if(error == KErrNotFound)

  1017 			INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName());	

  1018 		else if(error==KErrNone)

  1019 			INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName());	

  1020 		else

  1021 			{

  1022 			ret = EInconclusive;

  1023 			}

  1024 		fs.Close();

  1025 		}

  1026 

  1027 	if((ret == EInconclusive) || (ret == EFail))

  1028 		{

  1029 		return ret;	

  1030 		}

  1031 		

  1032 	return CTestMmfAclntStep::DoTestStepPreambleL();

  1033 	}

  1034 

  1035 /**

  1036  * Open a file based clip and record

  1037  */

  1038 

  1039 

  1040 TVerdict CTestMmfAclntRecFileForceFormat::DoTestStepL()

  1041 	{

  1042 	INFO_PRINTF1( _L("TestRecorder : Record File"));

  1043 	TVerdict ret = EFail;

  1044 	iError = KErrTimedOut;

  1045 

  1046 	TPtrC			filename; 

  1047 	if(!GetStringFromConfig(iSectName, iKeyName, filename))

  1048 		{

  1049 		return EInconclusive;

  1050 		}

  1051 		

  1052 

  1053 	CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this);

  1054 	CleanupStack::PushL(recUtil);

  1055 

  1056 	TMdaFileClipLocation location(filename);

  1057 

  1058 	RFs fs;

  1059 	fs.Connect();

  1060 	fs.Delete(filename);

  1061 	fs.Close();

  1062 

  1063 	recUtil->OpenL(&location,&iFormat);

  1064 

  1065 	INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));

  1066 	CActiveScheduler::Start();

  1067 

  1068 	if(iError == KErrNone)

  1069 		{

  1070 		iError = KErrTimedOut;

  1071 		recUtil->RecordL();

  1072 		INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility"));

  1073 		CActiveScheduler::Start(); // open -> record

  1074 

  1075 		User::After(KTwoSeconds);

  1076 		recUtil->Stop();

  1077 

  1078 		//now try to play the file as a check that it recorded correctly

  1079 		recUtil->PlayL();

  1080 		CActiveScheduler::Start();

  1081 

  1082 		recUtil->Close();

  1083 

  1084 	

  1085 		if(iError == KErrNone) 

  1086 			{

  1087 			RFs fs;

  1088 			RFile file;

  1089 			TInt size = 0;

  1090 

  1091 			User::LeaveIfError(fs.Connect());

  1092 			User::LeaveIfError(file.Open(fs,filename,EFileRead));

  1093 			CleanupClosePushL(file);

  1094 			User::LeaveIfError(file.Size(size));

  1095 

  1096 			if(size > 0)

  1097 				{

  1098 				ret = EPass;

  1099 				}

  1100 				

  1101 			CleanupStack::PopAndDestroy(); //file

  1102 			}

  1103 		}

  1104 	ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError );

  1105 	CleanupStack::PopAndDestroy(recUtil);

  1106 	User::After(KOneSecond);

  1107 	return	ret;

  1108 	}

  1109 

  1110 

  1111 //------------------------------------------------------------------

  1112 

  1113 /**

  1114  * Constructor

  1115  */

  1116 CTestMmfAclntRecDes::CTestMmfAclntRecDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateDes):

  1117 	iAudioPtr(NULL,0,0)

  1118 	{

  1119 	// store the name of this test case

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

  1121 	// Each test step initialises it's own name

  1122 	iTestStepName = aTestName;

  1123 	iSectName = aSectName;

  1124 	iKeyName = aKeyName;

  1125 	iTestFormat = aFormat;

  1126 	iCreateDes = aCreateDes;

  1127 	iSize = 0;

  1128 	iAudio = NULL;

  1129 	iHeapSize = 100000;

  1130 	}

  1131 

  1132 CTestMmfAclntRecDes* CTestMmfAclntRecDes::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat,const TBool aCreateDes)

  1133 	{

  1134 	CTestMmfAclntRecDes* self = new (ELeave) CTestMmfAclntRecDes(aTestName,aSectName,aKeyName,aFormat,aCreateDes);