diff -r 000000000000 -r b8ed18f6c07b mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestRecorder.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/TestRecorder.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,9208 @@ +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// This program is designed the test of the MMF_ACLNT. +// +// + +/** + @file TestRecorder.cpp +*/ + +#include "mmfwavformat.h" +#include +#include "TestRecorder.h" + +//copy util +TInt CopyFile(TPtrC aFileNameSrc, TPtrC aFileNameDst) +{ + TInt theErr = KErrNone; + + RFs fs; + fs.Connect(); + RFile theFileNew; + RFile theFile; + + fs.MkDirAll(aFileNameDst); + theFile.Open(fs, aFileNameSrc, EFileShareReadersOnly); + TInt theSize; + theFile.Size(theSize); + + TBuf8 theBuf; + TInt theStep = KSizeBuf; + if(theStep > theSize) + { + theStep = theSize; + } + + TInt theRes = theFileNew.Create(fs, aFileNameDst, EFileShareAny); + if(theRes == KErrAlreadyExists) + { + theRes = theFileNew.Replace(fs, aFileNameDst, EFileShareAny); + } + + + if(theRes != KErrNone) + { + return theRes; + } + + + TInt theCurLength = 0; + while(theCurLength < theSize) + { + theFile.Read(theBuf, theStep); + theFileNew.Write(theBuf, theStep); + theCurLength += theStep; + + if(theCurLength + theStep > theSize ) + { + theStep = theSize - theCurLength; + } + } + + theFileNew.Close(); + theFile.Close(); + fs.Close(); + + return theErr; +} + + +CTestMmfAclntRecord::CTestMmfAclntRecord(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) : + iNegative(aNegative) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + } + +void CTestMmfAclntRecord::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + iObject = aObject; + iPreviousState = aPreviousState; + iCurrentState = aCurrentState; + INFO_PRINTF1( _L("CTestMmfAclntRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecord::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + TPtrC filename2; + + if(!GetStringFromConfig(iSectName, _L("cropAudioFile"), filename1)) + { + return EInconclusive; + } + + + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename2)) + { + return EInconclusive; + } + + + + GetDriveName(filename); + filename.Append(filename1); + + CopyFile(filename2, filename); + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + recUtil->OpenFileL(filename); + // wait + INFO_PRINTF1(_L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + + if(iError == KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + ret = DoTestL(recUtil); + } + + CleanupStack::PopAndDestroy(recUtil); + User::After(KTwoSeconds); + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + return ret; + } + +CTestMmfAclntRecGain::CTestMmfAclntRecGain(const TDesC& aTestName, const TDesC& aSectName, const TInt aGain, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + , iGain (aGain) + {} + +CTestMmfAclntRecGain* CTestMmfAclntRecGain::NewL(const TDesC& aTestName, const TDesC& aSectName,const TInt aGain, TBool aNegative) + { + CTestMmfAclntRecGain* self = new (ELeave) CTestMmfAclntRecGain(aTestName, aSectName, aGain, aNegative); + return self; + } + +/** + * RecordUtils test: Set gain to maximum and enquire gain. + */ +TVerdict CTestMmfAclntRecGain::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF2( _L("TestRecorder : Gain - (%d)"), iGain); + + TVerdict ret = EFail; + + // Set up a file to record to + TPtrC filename; + if (!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename)) + { + INFO_PRINTF1(_L("Error getting filename from INI file")); + return EInconclusive; + } + + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error connecting file session"), err); + fs.Close(); + return EInconclusive; + } + + err = fs.Delete(filename); + + if (!((err == KErrNone) || (err == KErrNotFound))) + { + INFO_PRINTF2(_L("Error deleting output file"), err); + return EInconclusive; + } + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRec")) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + } + + aRecUtil->OpenFileL(filename); + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for recording"), iError); + return EInconclusive; + } + + // Set gain + if(iGain == 0) + { + iGain = aRecUtil->MaxGain(); + } + + aRecUtil->SetGain(iGain); + + // Set expected value + TInt expectedGain = 0; + if (iGain > aRecUtil->MaxGain()) + { + expectedGain = aRecUtil->MaxGain(); + } + + else if (iGain < 0) + { + expectedGain = 0; + } + + else + { + expectedGain = iGain; + } + + + aRecUtil->SetDestinationSampleRateL(8000); + + // Start recording + aRecUtil->RecordL(); + CActiveScheduler::Start(); + User::After(1000000); + + // Get gain + TInt gain; + aRecUtil->GetGain(gain); + + // The gain should be not be more than max gain + if (gain > aRecUtil->MaxGain()) + { + INFO_PRINTF3(_L("ERROR: GetGain value greater than MaxGain (%d > %d)"), gain, aRecUtil->MaxGain()); + ret = EFail; + } + // The gain should not be less than 0 + else if (gain < 0) + { + INFO_PRINTF3(_L("ERROR: GetGain value less than minimum gain (%d < %d)"), gain, 0); + ret = EFail; + } + else if (gain != expectedGain) + { + ERR_PRINTF3(_L("ERROR: GetGain value not equal to expected value (%d != %d)"), gain, expectedGain); + ret = EFail; + } + else + { + ret = EPass; + } + + // stop the recording - only necessary if anyone wanted to look at the output file + aRecUtil->Stop(); + + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecStateTran::CTestMmfAclntRecStateTran(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + {} + +CTestMmfAclntRecStateTran* CTestMmfAclntRecStateTran::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecStateTran* self = new (ELeave) CTestMmfAclntRecStateTran(aTestName, aSectName, aNegative); + return self; + } + +TVerdict CTestMmfAclntRecStateTran::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Transition")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TPtrC filename; + + + if(!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename)) + { + return EInconclusive; + } + + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRecState")) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + } + + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + recUtil->OpenFileL(filename); + // wait + INFO_PRINTF1(_L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError == KErrNone) + { + ret = DoTestL(recUtil); + } + + + CleanupStack::PopAndDestroy(recUtil); + User::After(KTwoSeconds); + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + return ret; + } + +/** + * Enquire state at each state transition. + */ +TVerdict CTestMmfAclntRecStateTran::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : State Transition")); + + TVerdict ret= EFail; + + iReportedState = aRecUtil->State(); + if( iReportedState == CMdaAudioClipUtility::EOpen ) + { + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + aRecUtil->RecordL(); + CActiveScheduler::Start(); // wait for open -> record + if (iError != KErrNone) + { + return EFail; + } + + iReportedState = aRecUtil->State(); + if(iReportedState == CMdaAudioClipUtility::ERecording ) + { + ret = EPass; + } + + User::After(KTwoSeconds); + aRecUtil->Stop(); + + iReportedState = aRecUtil->State(); + if(iReportedState != CMdaAudioClipUtility::EOpen ) + { + return EFail; + } + + aRecUtil->PlayL(); + CActiveScheduler::Start(); // wait for open -> play + if (iError != KErrNone) + { + return EFail; + } + + iReportedState = aRecUtil->State(); + if( iReportedState == CMdaAudioClipUtility::EPlaying ) + { + // Wait for play to complete + CActiveScheduler::Start(); + if (iError != KErrNone) + { + return EFail; + } + + //copy file + } + } + return ret; + } + +//--------------------------------------------------------------------------------- + +CTestMmfFormatRead::CTestMmfFormatRead(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + } + +CTestMmfFormatRead* CTestMmfFormatRead::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfFormatRead* self = new (ELeave) CTestMmfFormatRead(aTestName, aSectName, aNegative); + return self; + } + +_LIT(KFileXyz, "\\AclntITestData\\Test.xyz"); +_LIT(KFileAbc, "\\AclntITestData\\Test.abc"); + +TVerdict CTestMmfFormatRead::DoTestStepL() + { + INFO_PRINTF1( _L("CTestMmfFormatRead : Opening the test files")); + TVerdict ret = EPass; + + INFO_PRINTF1( _L("Opening the test file test.xyz")); + + TPtrC fileXyz(KFileXyz); + + // File with extension .xyz does not have a plugin and hence opening this file should fail. + CMdaAudioRecorderUtility* recUtilXyz = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtilXyz); + TRAP_IGNORE(recUtilXyz->OpenFileL(fileXyz)); + CActiveScheduler::Start(); + + if (recUtilXyz->State() == CMdaAudioClipUtility::EOpen) + { + INFO_PRINTF1( _L("Opening the test file test.xyz failed")); + ret = EFail; + } + + CleanupStack::PopAndDestroy(recUtilXyz); + + INFO_PRINTF1( _L("Opening the test file test.abc")); + TPtrC fileAbc(KFileAbc); + + // File with extension .abc does have a plugin and hence opening this file should pass. + CMdaAudioRecorderUtility* recUtilAbc = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtilAbc); + TRAP_IGNORE(recUtilAbc->OpenFileL(fileAbc)); + CActiveScheduler::Start(); + + if (recUtilAbc->State() != CMdaAudioClipUtility::EOpen) + { + INFO_PRINTF1( _L("Opening the test file test.abc failed")); + ret = EFail; + } + + CleanupStack::PopAndDestroy(recUtilAbc); + + return ret; + } + +/** + * Enquire state at each state transition. + */ + +TVerdict CTestMmfFormatRead::DoTestL(CMdaAudioRecorderUtility* /*aRecUtil*/) + { + INFO_PRINTF1( _L("CTestMmfFormatRead::DoTestL")); + return (TVerdict(EPass)); + } + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntCrop::CTestMmfAclntCrop(const TDesC& aTestName, const TDesC& aSectName, const TBool aCropToEnd, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + iCropToEnd = aCropToEnd; + } + +CTestMmfAclntCrop* CTestMmfAclntCrop::NewL(const TDesC& aTestName, const TDesC& aSectName, const TBool aCropToEnd, TBool aNegative) + { + CTestMmfAclntCrop* self = new (ELeave) CTestMmfAclntCrop(aTestName, aSectName, aCropToEnd, aNegative); + return self; + } + + + +/** + * Audio croping. + */ +TVerdict CTestMmfAclntCrop::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + TTimeIntervalMicroSeconds expectedDuration(KPcm16FrameInterval * 5), duration; + + duration = aRecUtil->Duration(); + INFO_PRINTF3(_L("Duration of Original file, expected = %f, actual: %f"), + I64REAL(expectedDuration.Int64()), I64REAL(duration.Int64())); + + if(expectedDuration == duration) + { + return EInconclusive; + } + + if(duration > expectedDuration) + { + aRecUtil->SetPosition(expectedDuration); + + if(iCropToEnd) + { + TRAP(iError, aRecUtil->CropL()); + } + else + { + TRAP(iError, aRecUtil->CropFromBeginningL()); + } + if(iError != KErrNone) + { + ERR_PRINTF2(_L("Crop left with error = %d"),iError); + return EFail; + } + if(iCropToEnd) + { + TTimeIntervalMicroSeconds actualDuration = aRecUtil->Duration(); + if (TimeComparison(I64INT(actualDuration.Int64()), I64INT(expectedDuration.Int64()), KExpectedDurationDeviation)) + { + INFO_PRINTF1(_L("Duration within expected deviation")); + return EPass; + } + else + { + ERR_PRINTF3(_L("Duration cropped file, expected = %f, actual: %f"), + I64REAL(expectedDuration.Int64()), I64REAL(actualDuration.Int64())); + } + } + if(!iCropToEnd) + { + TInt64 theDelta = duration.Int64() - expectedDuration.Int64(); + + TTimeIntervalMicroSeconds actualDuration = aRecUtil->Duration(); + if (TimeComparison(I64INT(actualDuration.Int64()), I64INT(theDelta), KExpectedDurationDeviation)) + { + INFO_PRINTF1(_L("Duration within expected deviation")); + return EPass; + } + else + { + ERR_PRINTF3(_L("Duration cropped file, expected = %f, actual: %f"), + I64REAL(theDelta), + I64REAL(aRecUtil->Duration().Int64())); + } + } + } + return EFail ; + } + + +//------------------------------------------------------------------ + +CTestMmfAclntRecCloseOpen::CTestMmfAclntRecCloseOpen(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + } + +CTestMmfAclntRecCloseOpen* CTestMmfAclntRecCloseOpen::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecCloseOpen* self = new (ELeave) CTestMmfAclntRecCloseOpen(aTestName, aSectName, aNegative); + return self; + } + +TVerdict CTestMmfAclntRecCloseOpen::DoTestL(CMdaAudioRecorderUtility* aRecUtil) +/** + * Open, Close and open a new audio clip. + */ + { + INFO_PRINTF1( _L("TestRecorder : Close/Open")); + + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + iError = KErrTimedOut; + + + aRecUtil->Close(); + aRecUtil->OpenFileL(filename); + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + //wait + CActiveScheduler::Start(); + if(iError == KErrNone) + { + return EPass; + } + + return EFail ; + } + + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecFile::CTestMmfAclntRecFile(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile) + + { + iTestStepName = aTestName; + iHeapSize = 200000; // playback part of test loads whole sound file into buffer, so need large heap + iSectName = aSectName; + iKeyName = aKeyName; + iTestFormat = aFormat; + iCreateFile = aCreateFile; + } + +CTestMmfAclntRecFile* CTestMmfAclntRecFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile) + { + CTestMmfAclntRecFile* self = new (ELeave) CTestMmfAclntRecFile(aTestName,aSectName,aKeyName,aFormat,aCreateFile); + return self; + } + +CTestMmfAclntRecFile* CTestMmfAclntRecFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateFile) + { + CTestMmfAclntRecFile* self = CTestMmfAclntRecFile::NewLC(aTestName,aSectName,aKeyName,aFormat,aCreateFile); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntRecFile::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecFile : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d "), iError); + + if(aCurrentState == CMdaAudioClipUtility::ERecording) + { + User::After(KFiveSeconds); + } + CActiveScheduler::Stop(); + } + +// Audio utility callbacks +void CTestMmfAclntRecFile::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/) + { + iError = aError; + CActiveScheduler::Stop(); + } + +void CTestMmfAclntRecFile::MapcPlayComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + +// Audio output stream callbacks +void CTestMmfAclntRecFile::MaoscOpenComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + +void CTestMmfAclntRecFile::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + iError = aError; + CActiveScheduler::Stop(); + } + +void CTestMmfAclntRecFile::MaoscPlayComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + + +TVerdict CTestMmfAclntRecFile::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + SetupFormatL(iTestFormat); + + if(iCreateFile) + { + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + else if(error==KErrNone) + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + else + { + ret = EInconclusive; + } + fs.Close(); + } + + } + + if((ret == EInconclusive) || (ret == EFail)) + { + return ret; + } + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +/** + * Open a file based clip and record + */ +TVerdict CTestMmfAclntRecFile::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Record File")); + TVerdict ret = EFail; + iError = KErrTimedOut; + + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + { + return EInconclusive; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TMdaFileClipLocation location(filename); + + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + if(!iCreateFile) + { + if(iSectName == _L("SectionOggRec")) // - Added to use OpenFileL only as OpenL parameters are deprected. + { + TPtrC filename2; + + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename2)) + { + return EInconclusive; + } + + CopyFile(filename2, filename); + } + recUtil->OpenFileL(filename); + } + else + { + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + if(iSectName == _L("SectionOggRec")) // - Added to use OpenFileL only as OpenL parameters are deprected. + { + recUtil->OpenFileL(filename); // - Should create the file internally + } + else + { + recUtil->OpenL(&location,iFormat,iCodec,&iAudioSettings); + } + } + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError == KErrNone) + { + iError = KErrTimedOut; + recUtil->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + recUtil->Stop(); + } + + + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + + // Playback the file + if (iError == KErrNone) + { + if (filename.Right(4).Compare(_L(".raw"))==0) + { + // Raw file playback + CMdaAudioOutputStream* outputStream = CMdaAudioOutputStream::NewL(*this); + CleanupStack::PushL(outputStream); + + outputStream->Open(NULL); + CActiveScheduler::Start(); + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error opening output stream for playback = %d"), iError); + CleanupStack::PopAndDestroy(outputStream); + return EFail; + } + + // Connect file session + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error connecting to file session = %d"), err); + return EFail; + } + CleanupClosePushL(fs); + + // Open file + RFile file; + err = file.Open(fs, filename, EFileRead); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error opening file = %d"), err); + CleanupStack::PopAndDestroy(2, outputStream); // fs, outputStream + return EFail; + } + CleanupClosePushL(file); + + // Get size of file + TInt fileSize = 0; + err = file.Size(fileSize); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error getting size of file = %d"), err); + CleanupStack::PopAndDestroy(3, outputStream); // file, fs, outputStream + return EFail; + } + + // Read file + HBufC8* buf = HBufC8::NewLC(fileSize); + TPtr8 ptr(buf->Des()); + err = file.Read(ptr); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error reading file %d"), err); + } + else + { + outputStream->WriteL(ptr); + CActiveScheduler::Start(); + if (iError != KErrNone) + INFO_PRINTF2(_L("Error writing file on audio output stream %d"), iError); + } + + CleanupStack::PopAndDestroy(4, outputStream); // buf, file, fs, outputStream + } + else + { + // Wav file playback + CMdaAudioPlayerUtility* playUtil = CMdaAudioPlayerUtility::NewL(*this); + CleanupStack::PushL(playUtil); + TRAPD(err, playUtil->OpenFileL(filename)); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for playback err = %d"), err); + CleanupStack::PopAndDestroy(playUtil); + return EFail; + } + CActiveScheduler::Start(); + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for playback iError = %d"), iError); + CleanupStack::PopAndDestroy(playUtil); + return EFail; + } + playUtil->Play(); + CActiveScheduler::Start(); + CleanupStack::PopAndDestroy(playUtil); + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error during playback of recorded file iError=%d"), iError); + return EFail; + } + } + } + // DEF127335 + // OggRecordController does not support recording into an already existing file. + // This is due to unavailability of APIs at the level of Ogg Vorbis C libraries. + else if (iTestStepName == _L("MM-MMF-ACLNTOGG-I-0102-CP") && iError == KErrNotSupported) + { + INFO_PRINTF1(_L("Expected Result: OggRecordController returned KErrNotSupported(-5)")); + return EPass; + } + + if( iError == KErrNone ) + { + RFs fs; + RFile file; + TInt size = 0; + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + User::LeaveIfError(file.Size(size)); + + if(size > 0) + { + ret = EPass; + } + + CleanupStack::PopAndDestroy(); //file + } + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + User::After(KOneSecond); + return ret; + } + + + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecFileForceFormat::CTestMmfAclntRecFileForceFormat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iFormat = aFormat; + } + +CTestMmfAclntRecFileForceFormat* CTestMmfAclntRecFileForceFormat::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecFileForceFormat* self = new (ELeave) CTestMmfAclntRecFileForceFormat(aTestName,aSectName,aKeyName,aFormat); + return self; + } + +CTestMmfAclntRecFileForceFormat* CTestMmfAclntRecFileForceFormat::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecFileForceFormat* self = CTestMmfAclntRecFileForceFormat::NewLC(aTestName,aSectName,aKeyName,aFormat); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntRecFileForceFormat::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecFile : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d "), iError); + + //dont stop the playing track + if (aCurrentState != CMdaAudioClipUtility::EPlaying || iError != KErrNone) + { + CActiveScheduler::Stop(); + } + } + + +TVerdict CTestMmfAclntRecFileForceFormat::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + else if(error==KErrNone) + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + else + { + ret = EInconclusive; + } + fs.Close(); + } + + if((ret == EInconclusive) || (ret == EFail)) + { + return ret; + } + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +/** + * Open a file based clip and record + */ + + +TVerdict CTestMmfAclntRecFileForceFormat::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Record File")); + TVerdict ret = EFail; + iError = KErrTimedOut; + + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + { + return EInconclusive; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TMdaFileClipLocation location(filename); + + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + + recUtil->OpenL(&location,&iFormat); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError == KErrNone) + { + iError = KErrTimedOut; + recUtil->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + User::After(KTwoSeconds); + recUtil->Stop(); + + //now try to play the file as a check that it recorded correctly + recUtil->PlayL(); + CActiveScheduler::Start(); + + recUtil->Close(); + + + if(iError == KErrNone) + { + RFs fs; + RFile file; + TInt size = 0; + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + User::LeaveIfError(file.Size(size)); + + if(size > 0) + { + ret = EPass; + } + + CleanupStack::PopAndDestroy(); //file + } + } + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecDes::CTestMmfAclntRecDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateDes): + iAudioPtr(NULL,0,0) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iTestFormat = aFormat; + iCreateDes = aCreateDes; + iSize = 0; + iAudio = NULL; + iHeapSize = 100000; + } + +CTestMmfAclntRecDes* CTestMmfAclntRecDes::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat,const TBool aCreateDes) + { + CTestMmfAclntRecDes* self = new (ELeave) CTestMmfAclntRecDes(aTestName,aSectName,aKeyName,aFormat,aCreateDes); + return self; + } + +CTestMmfAclntRecDes* CTestMmfAclntRecDes::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateDes) + { + CTestMmfAclntRecDes* self = CTestMmfAclntRecDes::NewLC(aTestName,aSectName,aKeyName,aFormat,aCreateDes); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntRecDes::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF4( _L("MMdaObjectStateChangeObserver: previous state: %d current state: %d error: %d"),aPreviousState, aCurrentState, aErrorCode); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecDes::DoTestStepPreambleL() + { + SetupFormatL(iTestFormat); + + switch (iTestFormat) + { + case EPcm16Wav: + case EAlawWav: + case EPcm8: + iHeaderSize = KWavFileUncompressedDataHeaderSize; //(see mmfwavformat.cpp, CreateSinkBufferOfSizeL()) + iFrameSize = 4096; + break; + case EImaAdpcmWav: + case EImasPcmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KImaAdpcmFactChunkSize; + iFrameSize = 4096; + break; + case EMulawRaw: + case EPcmU8: + case EPcmU16: + iHeaderSize = 0; + iFrameSize = 4096; + break; + case EGsmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KGSMFactChunkSize; + iFrameSize = 4095; + break; + default: + /*skip*/ ; + } + + if(!iCreateDes) + { + RFs fs; + RFile file; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + INFO_PRINTF2(_L("File for test - %S"), &filename); + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + + User::LeaveIfError(file.Size(iSize)); + INFO_PRINTF2(_L("size of file = %d\n"),iSize);//Statement Changed under DEF105143 + iAudio = HBufC8::NewMaxL(iSize); + + // Read a file into a descriptor + iAudioPtr.Set(iAudio->Des()); + User::LeaveIfError(file.Read(iAudioPtr)); + + CleanupStack::PopAndDestroy(); //file + } + else + { + INFO_PRINTF1(_L("Recording to New Descriptor for test")); + iSize = KRecSize; // value is not been set yet. + iAudio = HBufC8::NewMaxL(iSize); + iAudioPtr.Set(iAudio->Des()); + iAudioPtr.SetLength(0); + } + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMmfAclntRecDes::DoTestStepPostambleL() + { + delete iAudio; + return CTestMmfAclntCodecTest::DoTestStepPostambleL(); + } + +/** + * Open a descriptor and record + */ +TVerdict CTestMmfAclntRecDes::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder : Record Des")); + TVerdict ret = EFail; + TMdaDesClipLocation* location = NULL; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + if(!iCreateDes) + { + recUtil->OpenDesL(iAudioPtr); + } + else + { + location = new (ELeave) TMdaDesClipLocation(iAudioPtr); + CleanupStack::PushL(location); + recUtil->OpenL(location,iFormat,iCodec,&iAudioSettings); + CleanupStack::PopAndDestroy(location); + } + + iError = KErrTimedOut; + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError == KErrNone) + { + // set the sample rate to 8K, otherwise the default value of 44.1Kh will be used + // resulting in very large buffers (11K) + recUtil->SetDestinationSampleRateL(8000); + + iError = KErrTimedOut; + recUtil->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open->record + if (iError != KErrNone) + { + // DEF127335 + // OggRecordController does not support recording into an already existing descriptor. + // This is due to unavailability of APIs at the level of Ogg Vorbis C libraries. + if (iTestStepName == _L("MM-MMF-ACLNTOGG-I-0103-CP") && iError == KErrNotSupported) + { + INFO_PRINTF1(_L("Expected Result: OggRecordController returned KErrNotSupported(-5)")); + ret = EPass; + } + ERR_PRINTF2( _L("CMdaAudioRecorderUtility failed with error %d"),iError ); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + // wait to run out of space recording + CActiveScheduler::Start(); // record -> open + + if (iError != KErrOverflow) + { + ERR_PRINTF2( _L("CMdaAudioRecorderUtility failed with error %d"),iError ); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + + TInt expectedLength=0; + TInt actualLength = iAudio->Length(); + if(iCreateDes) + { + // Calculuate the frame size which is now dynamic. + // This is more or less a duplicate of the calculation in + // CMMFAudioInput::NegotiateSourceL() + expectedLength = iSize; + TUint sampleRate = recUtil->DestinationSampleRateL(); + TUint bitRate = recUtil->DestinationBitRateL(); + + //xxx work around for GSM which returns zero as the bit rate because internally + // BitsPerSample is zero + if (bitRate==0) + { + bitRate = sampleRate * 8; + } + + TUint numberOfChannels = recUtil->DestinationNumberOfChannelsL(); + iFrameSize = (bitRate * numberOfChannels / 8) / 4; + iFrameSize = (iFrameSize + (KAudioInputDeltaFrameSize-1)) &~ (KAudioInputDeltaFrameSize-1); + if(iFrameSize < KAudioInputMinFrameSize) + { + iFrameSize = KAudioInputMinFrameSize; + } + + else if(iFrameSize > KAudioInputMaxFrameSize) + { + iFrameSize = KAudioInputMaxFrameSize; + } + + // GSM will onlt write out an integral number of GSM frames + // which are 65 bytes long.. + if (iTestFormat == EGsmWav) + { + iFrameSize = (iFrameSize / KGsmEncodedFrameSize) * KGsmEncodedFrameSize; + } + + + expectedLength = ((iSize-iHeaderSize) / iFrameSize)* iFrameSize + iHeaderSize; + + INFO_PRINTF2(_L("sampleRate = %d"), sampleRate); + INFO_PRINTF2(_L("bitRate = %d"), bitRate); + INFO_PRINTF2(_L("numberOfChannels = %d"), numberOfChannels); + INFO_PRINTF2(_L("iFrameSize = %d"), iFrameSize); + INFO_PRINTF2(_L("Duration = %d"), I64LOW(recUtil->Duration().Int64())); + INFO_PRINTF3(_L("Expected length %d, actual length %d"), expectedLength, actualLength); + + +#if defined __WRITE_CONVERSION_TO_FILE + { + _LIT(KFileOut, "\\TEST.WAV"); + RFs fs; + + fs.Connect(); + RFile file; + file.Replace(fs, KFileOut(), EFileWrite); + file.Write(iAudio->Des()); + TInt len = iAudio->Length(); + file.Size(len); + file.Close(); + fs.Close(); + } +#endif + + // a more forgiving test would be : + //if ((actualLength <= expectedLength) && + // (actualLength >= (expectedLength - iFrameSize))) + + // if test is GSM then we expect it to be between + // expected Length and (iSize - iHeaderSize) + if ((iTestFormat == EGsmWav) && + (actualLength <= (iSize - iHeaderSize)) && + (actualLength >= expectedLength) ) + { + ret = EPass; + } + else if (iAudio->Length() == expectedLength) + { + ret = EPass; + } + else + { + INFO_PRINTF3(_L("Expected length %d, actual length %d"), expectedLength, actualLength); + + TInt machineType; + TInt err = HAL::Get(HALData::EMachineUid, machineType); + if (err) + { + ERR_PRINTF1(_L("Error Getting Device information")); + iTestStepResult = EFail; + CActiveScheduler::Stop(); + } + else + { + if ((machineType == 0x102864F7) && (sampleRate == 8000)) + { + // If test is running on a NaviEngine and uses 8K sample rate + // then apply a tollerance when checking duration as we will + // have applied conversion function. + if ((iAudio->Length() >= expectedLength - 1000) && + (iAudio->Length() <= expectedLength + 1000)) + { + ret = EPass; + } + } + } + } + } + else + { + expectedLength = iSize; + + if(iAudio->Length() == expectedLength) + { + ret = EPass; + } + + else + { + INFO_PRINTF3(_L("Expected length %d, actual length %d"), expectedLength, actualLength); + } + + } + } + + + if (ret != EPass) + { + ERR_PRINTF2( _L("CMdaAudioRecorderUtility failed with error %d"),iError ); + } + + + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecUrl::CTestMmfAclntRecUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +CTestMmfAclntRecUrl* CTestMmfAclntRecUrl::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecUrl* self = new (ELeave) CTestMmfAclntRecUrl(aTestName,aSectName,aKeyName); + return self; + } + +CTestMmfAclntRecUrl* CTestMmfAclntRecUrl::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecUrl* self = CTestMmfAclntRecUrl::NewLC(aTestName,aSectName,aKeyName); + CleanupStack::PushL(self); + return self; + }; + +void CTestMmfAclntRecUrl::MoscoStateChangeEvent(CBase* /*aObject*/, + TInt /*aPreviousState*/, + TInt /*aCurrentState*/, + TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecUrl : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d"), iError); + CActiveScheduler::Stop(); + } + +/** + * Open a URL + */ +TVerdict CTestMmfAclntRecUrl::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder : Record URL")); + TPtrC url; + if(!GetStringFromConfig(iSectName, iKeyName, url)) + { + return EInconclusive; + } + + + TVerdict ret = EFail; + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TRAP_IGNORE(recUtil->OpenUrlL(url, KUseDefaultIap, _L8("Audio/Wav"))); + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError == KErrNotSupported) + { + ret = EPass; + } + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + CleanupStack::PopAndDestroy(recUtil); + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecPosition::CTestMmfAclntRecPosition(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative), iPosition(aPosition) + { + } + +CTestMmfAclntRecPosition* CTestMmfAclntRecPosition::NewL(const TDesC& aTestName, const TDesC& aSectName, const TTimeIntervalMicroSeconds& aPosition, TBool aNegative) + { + CTestMmfAclntRecPosition* self = new (ELeave) CTestMmfAclntRecPosition(aTestName, aSectName, aPosition, aNegative); + return self; + } + +TVerdict CTestMmfAclntRecPosition::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : Position")); + TVerdict ret = EFail; + TBool validPosition = EFalse; + + // Set position: middle of clip. + if (I64INT(iPosition.Int64()) == 0) + { + iPosition = I64INT(aRecUtil->Duration().Int64())/2; + } + + // Set position: end of clip. + if (I64INT(iPosition.Int64()) == -1) + { + iPosition = aRecUtil->Duration(); + } + + aRecUtil->PlayL(); //Begin to Play otherwise position can not be set. + // Position is beyond the end of the clips duration. + // so check that the value is clipped. + if(aRecUtil->Duration() < iPosition) + { + aRecUtil->SetPosition(iPosition); + + TInt64 temp = (aRecUtil->Duration().Int64() / KPcm16FrameInterval) - 1; // -1 for DevSound + if(aRecUtil->Position().Int64() == (temp * KPcm16FrameInterval)) + { + validPosition = ETrue; + } + + } + else + { + aRecUtil->SetPosition(iPosition); + //CActiveScheduler::Start(); + + TInt64 temp = (iPosition.Int64() / KPcm16FrameInterval) - 1; // -1 for DevSound + TInt64 thePosActual = aRecUtil->Position().Int64(); + TInt64 thePosExpected = temp * KPcm16FrameInterval; + aRecUtil->Stop(); + + if (TimeComparison(I64INT(thePosActual), I64INT(thePosExpected), KExpectedDeviation)) + { + validPosition = ETrue; + } + } + + if ((iNegative) && (!validPosition)) + { + ret = EPass; + } + + // Postion was set to a valid value. + if(validPosition) + { + ret = EPass; + } + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecDuration::CTestMmfAclntRecDuration(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + } + +CTestMmfAclntRecDuration* CTestMmfAclntRecDuration::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecDuration* self = new (ELeave) CTestMmfAclntRecDuration(aTestName, aSectName, aNegative); + return self; + } + +TVerdict CTestMmfAclntRecDuration::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : Duration")); + TVerdict ret = EFail; + + if(iSectName == _L("SectionOggRec")) + { + if (I64INT(aRecUtil->Duration().Int64()) == KSoundFileLength) + ret = EPass; + } + else if (TimeComparison(I64INT(aRecUtil->Duration().Int64()), KSoundFileLength, KExpectedDeviation)) + { + ret = EPass; + } + + else + INFO_PRINTF3(_L("unexpected duration = %u, expected = %u"), I64INT(aRecUtil->Duration().Int64()), KSoundFileLength); + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecSetMeta::CTestMmfAclntRecSetMeta(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + } + +CTestMmfAclntRecSetMeta* CTestMmfAclntRecSetMeta::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecSetMeta* self = new (ELeave) CTestMmfAclntRecSetMeta(aTestName, aSectName, aNegative); + return self; + } + +_LIT(name,""); +_LIT(data,""); +_LIT(name2,"Artist"); +_LIT(data2,"Test"); +/** + * Set meta-information + */ +TVerdict CTestMmfAclntRecSetMeta::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : Set Metadata")); + TVerdict ret = EFail; + + // build a meta daat object + CMMFMetaDataEntry* metaData[2]; + metaData[0] = CMMFMetaDataEntry::NewL(name,data); + CleanupStack::PushL(metaData[0]); + metaData[1] = CMMFMetaDataEntry::NewL(name2,data2); + CleanupStack::PushL(metaData[1]); + + TInt numEntries; + TInt err = aRecUtil->GetNumberOfMetaDataEntries(numEntries); + if(err != KErrNone) + { + INFO_PRINTF2(_L("GetNumberOfMetaDataEntries() returned error %d"), err); + numEntries = 0; // so we don't try and remove anything + } + + // *** JW adapted test - remove any existing metadata + // this means that a modified test file will not cause inconclusive + if(numEntries != 0) + { + INFO_PRINTF2(_L("Removing %d existing entries..."), numEntries); + for(TInt i = numEntries - 1; i >= 0; i--) + { + err = aRecUtil->RemoveMetaDataEntry(i); + if(err != KErrNone) + { + INFO_PRINTF3(_L("RemoveMetaDataEntry(%d) returned error %d"), i, err); + } + } + aRecUtil->GetNumberOfMetaDataEntries(numEntries); + } + + if(numEntries == 0) + { + TRAPD(err, aRecUtil->AddMetaDataEntryL(*metaData[0])); + if(err != KErrNone) + { + INFO_PRINTF2(_L("AddMetaDataEntryL(*metaData[0]) left with error %d"), err); + } + + + TRAP(err, aRecUtil->AddMetaDataEntryL(*metaData[1])); + if(err != KErrNone) + { + INFO_PRINTF2(_L("AddMetaDataEntryL(*metaData[1]) left with error %d"), err); + } + + CleanupStack::PopAndDestroy(metaData[1]); + CleanupStack::PopAndDestroy(metaData[0]); + + if(err) + { + if(err == KErrNotSupported) // Audio Controller doesn't support - this is ok + { + // + // C-COVER Reports the following methods are not being called + // Remove when metaData is supported + TRAP(err,aRecUtil->GetNumberOfMetaDataEntries(numEntries)); + CMMFMetaDataEntry* testData=NULL; + for(TInt i=0;iGetMetaDataEntryL(0)); + //REPLACE WITH ITSELF?? + TRAP(err,aRecUtil->ReplaceMetaDataEntryL(i,*testData)); + TRAP(err,aRecUtil->RemoveMetaDataEntry(i));//@@@ + } + + // + + INFO_PRINTF1(_L("Note : Audio Controller does not support metadata")); + return EPass; + } + else + { + ERR_PRINTF1(_L("Unexpected error (expected KErrNotSupported)")); + return EFail; + } + } + + aRecUtil->GetNumberOfMetaDataEntries(numEntries); + + if(numEntries == 2) + { + CMMFMetaDataEntry* testData; + + testData = aRecUtil->GetMetaDataEntryL(0); + + if((testData->Name() == name) && (testData->Value() == data)) + { + ret = EPass; + } + + testData = aRecUtil->GetMetaDataEntryL(1); + + if(!((testData->Name() == name2) && (testData->Value() == data2))) + { + ret = EFail; + } + } + return ret; + } + + // Audio file already contains meta data, and we couldn't remove it. + ERR_PRINTF1(_L("Audio file still contains metadata")); + CleanupStack::PopAndDestroy(metaData[1]); + CleanupStack::PopAndDestroy(metaData[0]); + return EInconclusive; + } + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecPriority::CTestMmfAclntRecPriority(const TDesC& aTestName,const TDesC& aSectName) + + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + } + +void CTestMmfAclntRecPriority::MchoComplete(TInt aID, TInt aError) + { + INFO_PRINTF1( _L("CTestMmfAclntRecPriority : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility called")); + if (iError != KErrNone) + { + iError = aError; + } + + INFO_PRINTF3( _L("iError %d ID %d"), iError, aID); + + if(iFirstCallback == -1) + { + iFirstCallback = aID; + } + + + if((--iCallbackCount) == 0) + { + CActiveScheduler::Stop(); + } + } + +//------------------------------------------------------------------ + +/** + * Set Record priority + */ +TVerdict CTestMmfAclntRecPriority::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder : Priority")); + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, _L("playerAudioFile"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + + CMdaAudioRecorderUtility* recUtil[2]; + CStateCallbackHandler* callback[2]; + + for(TInt i=0; i<2; i++) + { + callback[i] = new (ELeave) CStateCallbackHandler(i,this); + CleanupStack::PushL(callback[i]); + } + + recUtil[0] = CMdaAudioRecorderUtility::NewL(*callback[0],NULL,EMdaPriorityNormal,EMdaPriorityPreferenceTimeAndQuality); + CleanupStack::PushL(recUtil[0]); + recUtil[1] = CMdaAudioRecorderUtility::NewL(*callback[1],NULL,EMdaPriorityMin,EMdaPriorityPreferenceNone); + CleanupStack::PushL(recUtil[1]); + + INFO_PRINTF2(_L("CMdaAudioRecorderUtility[0]->OpenFileL(%S)"), &filename); + recUtil[0]->OpenFileL(filename); + // wait for initilisation callback #1 + iCallbackCount = 1; + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility #1")); + CActiveScheduler::Start(); + + INFO_PRINTF2(_L("CMdaAudioRecorderUtility[1]->OpenFileL(%S)"), &filename); + recUtil[1]->OpenFileL(filename); + // wait for initilisation callback #2 + iCallbackCount = 1; + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility #2")); + CActiveScheduler::Start(); + + + if(iError == KErrNone) + { + iError = KErrTimedOut; + + recUtil[0]->PlayL(); + recUtil[1]->PlayL(); + + INFO_PRINTF1( _L("Play CMdaAudioRecorderUtility")); + INFO_PRINTF1( _L("Play CMdaAudioRecorderUtility")); + // wait for play to complete + iCallbackCount = 2; + iFirstCallback = -1; + CActiveScheduler::Start(); + + if((iError == KErrNone) && (iFirstCallback == 0)) + { + CleanupStack::PopAndDestroy(4); // recUtil, callback + return EPass; + } + } + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + + CleanupStack::PopAndDestroy(4); + return EFail; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecBalance::CTestMmfAclntRecBalance(const TDesC& aTestName, const TDesC& aSectName, const TInt aBalance, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative), iBalance(aBalance) + { + } + +CTestMmfAclntRecBalance* CTestMmfAclntRecBalance::NewL(const TDesC& aTestName, const TDesC& aSectName,const TInt aBalance, TBool aNegative) + { + CTestMmfAclntRecBalance* self = new (ELeave) CTestMmfAclntRecBalance(aTestName, aSectName, aBalance, aNegative); + return self; + } + +/** + * Set recorder balance + */ +TVerdict CTestMmfAclntRecBalance::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF2(_L("TestRecorder : Balance - (%d)"), iBalance); + + TInt savedBalance = iBalance; + if (CheckPlaybackBalance(aRecUtil) == EPass) + { + iBalance = savedBalance; + if (CheckRecordBalance(aRecUtil) == EPass) + return EPass; + } + + return EFail; + } + +TVerdict CTestMmfAclntRecBalance::CheckPlaybackBalance(CMdaAudioRecorderUtility* aRecUtil) + { + TInt err = 0; + TUint theNumChanel = 0; + TRAP(err, theNumChanel = aRecUtil->DestinationNumberOfChannelsL()); + if(err != KErrNone) + { + return EFail; + } + + + TInt balance; + + if (iBalance < KMinBalance) + { + err = aRecUtil->SetPlaybackBalance(iBalance); + + if ((err == KErrArgument) && (iNegative)) + { + return EPass; + } + else if ((err == KErrArgument) && (!iNegative)) + { + return EFail; + } + + aRecUtil->GetPlaybackBalance(iBalance); + if(iBalance == KMinBalance) + { + return EPass; + } + } + else if (iBalance > KMaxBalance) + { + err = aRecUtil->SetPlaybackBalance(iBalance); + + if ((err == KErrArgument) && (iNegative)) + { + return EPass; + } + else if ((err == KErrArgument) && (!iNegative)) + { + return EFail; + } + + aRecUtil->GetPlaybackBalance(iBalance); + if(iBalance == KMaxBalance) + { + return EPass; + } + + } + else + { + err = aRecUtil->SetPlaybackBalance(iBalance); + if(theNumChanel <= 1) + { + if(err != KErrNone) // this is now supported + return EFail; + } + if ((err == KErrArgument) && (iNegative)) + { + return EPass; + } + else if ((err == KErrArgument) && (!iNegative)) + { + return EFail; + } + else if(err != KErrNone) + { + return EFail; + } + + + TInt theRes = aRecUtil->GetPlaybackBalance(balance); + if((theRes == KErrNone) && (balance == iBalance)) + { + return EPass; + } + } + + return EFail; + } + +TVerdict CTestMmfAclntRecBalance::CheckRecordBalance(CMdaAudioRecorderUtility* aRecUtil) + { + TInt err = 0; + TUint theNumChanel = 0; + TRAP(err, theNumChanel = aRecUtil->DestinationNumberOfChannelsL()); + if(err != KErrNone) + { + return EFail; + } + + if (iBalance < KMinBalance) + { + err = aRecUtil->SetRecordBalance(iBalance); + + if ((err == KErrArgument) && (iNegative)) + { + return EPass; + } + else if ((err == KErrArgument) && (!iNegative)) + { + return EFail; + } + + aRecUtil->GetRecordBalance(iBalance); + if(iBalance == KMinBalance) + { + return EPass; + } + + } + else if (iBalance > KMaxBalance) + { + err = aRecUtil->SetRecordBalance(iBalance); + + if ((err == KErrArgument) && (iNegative)) + { + return EPass; + } + else if ((err == KErrArgument) && (!iNegative)) + { + return EFail; + } + + aRecUtil->GetRecordBalance(iBalance); + if(iBalance == KMaxBalance) + { + return EPass; + } + + } + else + { + TInt balance; + err = aRecUtil->SetRecordBalance(iBalance); + if(theNumChanel <= 1) + { + if(err != KErrNone) // this is now supported + return EFail; + } + + if ((err == KErrArgument) && (iNegative)) + { + return EPass; + } + else if ((err == KErrArgument) && (!iNegative)) + { + return EFail; + } + + aRecUtil->GetRecordBalance(balance); + if(balance == iBalance) + { + return EPass; + } + } + + return EFail; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecLength::CTestMmfAclntRecLength(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + } + +CTestMmfAclntRecLength* CTestMmfAclntRecLength::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecLength* self = new (ELeave) CTestMmfAclntRecLength(aTestName, aSectName, aNegative); + return self; + } + +/** + *Set maximum length of file in bytes and record + */ +TVerdict CTestMmfAclntRecLength::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : SetMaxWriteLength")); + + TVerdict ret = EFail; + TTimeIntervalMicroSeconds recTime(aRecUtil->RecordTimeAvailable()); + + aRecUtil->SetMaxWriteLength(800); + + if(aRecUtil->RecordTimeAvailable() != recTime) + { + ret = EPass; + } + + return ret; + } + +//------------------------------------------------------------------ + +CTestMmfAclntRecFormats::CTestMmfAclntRecFormats(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + { + } + +CTestMmfAclntRecFormats* CTestMmfAclntRecFormats::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecFormats* self = new (ELeave) CTestMmfAclntRecFormats(aTestName, aSectName, aNegative); + return self; + } + +/** + * Get recordable formats.Test for supported mimetypes. + */ +TVerdict CTestMmfAclntRecFormats::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : Formats")); + + TVerdict ret = EPass; + + TInt recauMatches = 0; + TInt playauMatches = 0; + TInt recwavMatches = 0; + TInt playwavMathces = 0; + + const TInt KControllerAudioRecAuMatches = 4; + const TInt KControllerAudioPlayAuMatches = 4; + const TInt KControllerAudioRecWavMatches = 2; + // there are 2 .wav play plugins - the standard .WAV plugin and + // the test MmfMp3Format plugin with 2 mime types each : + const TInt KControllerAudioPlayWavMatches = 2; + + RArray codecs; + aRecUtil->GetSupportedDestinationDataTypesL(codecs); + TInt numCodecs = codecs.Count(); + + INFO_PRINTF2(_L("GetSupportedDestinationDataTypesL found %d codecs"), numCodecs); + + // enhanced - to use CMMFControllerPluginSelectionParameters + + INFO_PRINTF1(_L("Querying record formats...")); + + CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC(); + CMMFFormatSelectionParameters* recFSelect = CMMFFormatSelectionParameters::NewLC(); + CMMFFormatSelectionParameters* playFSelect = CMMFFormatSelectionParameters::NewLC(); + + RArray mediaIds; + mediaIds.Append(KUidMediaTypeAudio); + cSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOtherMediaIds); + cSelect->SetRequiredRecordFormatSupportL(*recFSelect); + cSelect->SetRequiredPlayFormatSupportL(*playFSelect); + + RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data + CleanupResetAndDestroyPushL(controllers); + cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers + TInt numControllers = controllers.Count(); + if(!numControllers) + { + ERR_PRINTF1(_L("Could not find any controllers")); + } + else + { + INFO_PRINTF2(_L("Found %d controllers"), numControllers); + for(int i = 0; i < numControllers; i++) + { + INFO_PRINTF4(_L("- Controller: %d Uid: 0x%X %S"),i, controllers[i]->Uid(), &controllers[i]->DisplayName()); + const RMMFFormatImplInfoArray& recFormats = controllers[i]->RecordFormats(); + const RMMFFormatImplInfoArray& playFormats = controllers[i]->PlayFormats(); + + const CDesC8Array* fileExtensions = NULL; + const CDesC8Array* mimeTypes = NULL; + + _LIT(KMimeTypeAudioBasic, "audio/basic"); + _LIT(KMimeTypeAudioXAu, "audio/x-au"); + _LIT(KMimeTypeAudioAu, "audio/au"); + _LIT(KMimeTypeAudioXBasic, "audio/x-basic"); + _LIT(KMimeTypeAudioWav, "audio/wav"); + _LIT(KMimeTypeAudioXWav, "audio/x-wav"); + + _LIT(KWavFileExtension, ".wav"); + _LIT(KAuFileExtension, ".au"); + + + for(int recFormat = 0; recFormat < recFormats.Count(); recFormat++) + { + INFO_PRINTF2(_L("Record Format 0x%x"), recFormats[recFormat]->Uid()); + fileExtensions = &recFormats[recFormat]->SupportedFileExtensions(); + INFO_PRINTF2(_L("File Extensions %d"), (fileExtensions ? fileExtensions->MdcaCount() : 0)); + TBuf<24> fileType; + for(int fileExtn = 0; fileExtn < (fileExtensions ? fileExtensions->MdcaCount() : 0); fileExtn++) + { + fileType.Copy(fileExtensions->MdcaPoint(fileExtn)); + INFO_PRINTF2(_L("-- %S"), &fileType); + } + + mimeTypes = &recFormats[recFormat]->SupportedMimeTypes(); + INFO_PRINTF2(_L("Mime Types: %d"), (mimeTypes ? mimeTypes->MdcaCount() : 0)); + for(int mimeType = 0; mimeType < (mimeTypes ? mimeTypes->MdcaCount() : 0); mimeType++) + { + TBuf<24> ext16; + ext16.Copy(mimeTypes->MdcaPoint(mimeType)); + if(fileType.Compare(KAuFileExtension)== KErrNone) + { + switch (mimeType) + { + case 0: + if (ext16 == KMimeTypeAudioBasic) + { + recauMatches++; + } + + else + { + ret = EFail; + } + + break; + case 1: + if (ext16 == KMimeTypeAudioXAu) + { + recauMatches++; + } + + else + { + ret = EFail; + } + + break; + case 2: + if(ext16 == KMimeTypeAudioAu) + { + recauMatches++; + } + + else + { + ret = EFail; + } + break; + + case 3: + if(ext16 == KMimeTypeAudioXBasic) + { + recauMatches++; + } + + else + { + ret = EFail; + } + + break; + default: + break; + } + INFO_PRINTF2(_L("-- %S"), &ext16); + } + if(fileType.Compare(KWavFileExtension) == KErrNone) + { + switch (mimeType) + { + case 0: + if(ext16 == KMimeTypeAudioWav) + { + recwavMatches++; + } + + else + { + ret = EFail; + } + + break; + case 1: + if(ext16 == KMimeTypeAudioXWav) + { + recwavMatches++; + } + + else + { + ret = EFail; + } + + break; + + default: + break; + } + INFO_PRINTF2(_L("-- %S"), &ext16); + } + } //mimetype + } //recFormat + + for(int playFormat = 0; playFormat < playFormats.Count(); playFormat++) + { + INFO_PRINTF2(_L("Play Format 0x%x"), playFormats[playFormat]->Uid()); + fileExtensions = &playFormats[playFormat]->SupportedFileExtensions(); + INFO_PRINTF2(_L("File Extensions %d"), (fileExtensions ? fileExtensions->MdcaCount() : 0)); + TBuf<24> fileType; + for(int fileExtn = 0; fileExtn < (fileExtensions ? fileExtensions->MdcaCount() : 0); fileExtn++) + { + fileType.Copy(fileExtensions->MdcaPoint(fileExtn)); + INFO_PRINTF2(_L("-- %S"), &fileType); + } + mimeTypes = &playFormats[playFormat]->SupportedMimeTypes(); + INFO_PRINTF2(_L("Mime Types: %d"), (mimeTypes ? mimeTypes->MdcaCount() : 0)); + for(int mimeType = 0; mimeType < (mimeTypes ? mimeTypes->MdcaCount() : 0); mimeType++) + { + TBuf<24> ext16; + ext16.Copy(mimeTypes->MdcaPoint(mimeType)); + if(fileType.Compare(KAuFileExtension) == KErrNone) + { + switch (mimeType) + { + case 0: + if (ext16 == KMimeTypeAudioBasic) + { + playauMatches++; + } + + else + { + ret = EFail; + } + + break; + case 1: + if (ext16 == KMimeTypeAudioXAu) + { + playauMatches++; + } + + else + ret = EFail; + break; + case 2: + if(ext16 == KMimeTypeAudioAu) + playauMatches++; + else + ret = EFail; + break; + case 3: + if(ext16 == KMimeTypeAudioXBasic) + { + playauMatches++; + } + else + ret = EFail; + break; + default: + break; + } + INFO_PRINTF2(_L("-- %S"), &ext16); + } + if(fileType.Compare(KWavFileExtension)== KErrNone) + { + switch (mimeType) + { + case 0: + if(ext16 == KMimeTypeAudioWav) + { + playwavMathces++; + } + + else + ret = EFail; + break; + case 1: + if(ext16 == KMimeTypeAudioXWav) + { + playwavMathces++; + } + + else + ret = EFail; + break; + default: + break; + } + INFO_PRINTF2(_L("-- %S"), &ext16); + } + }//mimetype + } //playFormat + } //controllers + }//else condition + + CleanupStack::PopAndDestroy(4);//controllers, recFSelect, playFSelect cSelect + + if((recauMatches != KControllerAudioRecAuMatches || playauMatches != KControllerAudioPlayAuMatches) || + (recwavMatches != KControllerAudioRecWavMatches || playwavMathces != KControllerAudioPlayWavMatches)) + { + ret = EFail; + } + + else + ret = EPass; + + return ret; + } //end of function + + +//------------------------------------------------------------------ + +// Negative tests + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecDelete::CTestMmfAclntRecDelete(const TDesC& aTestName, const TDesC& aSectName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + } + +void CTestMmfAclntRecDelete::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt /*aCurrentState*/, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecDelete : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d "), iError); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecDelete::DoTestStepPreambleL() + { + TVerdict verdict = EPass; + + // Delete the output file (will probably have been used by other tests) + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + verdict = EFail; + } + else + { + TBuf filename; + TPtrC filename1; + if (!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename1)) + { + verdict = EInconclusive; + } + else + { + GetDriveName(filename); + filename.Append(filename1); + err = fs.Delete(filename); + if (!((err == KErrNone) || (err == KErrNotFound))) + { + verdict = EInconclusive; + } + + } + fs.Close(); + } + + if (verdict == EPass) + { + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + } + + + return verdict; + } + +/** + * Record utility - Delete object before record operation has completed. + */ +TVerdict CTestMmfAclntRecDelete::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder : Delete")); + iError = KErrTimedOut; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + __MM_HEAP_MARK; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRec")) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + } + + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + recUtil->OpenFileL(filename); + // wait + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if (iError == KErrNone) + { + TVerdict ret = EPass; + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + recUtil->RecordL(); + INFO_PRINTF1( _L("Destroy CMdaAudioRecorderUtility")); + CleanupStack::PopAndDestroy(recUtil); + + // Check that the file no longer exists + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error connecting to file server %d"), err); + ret = EInconclusive; + } + else + { + TEntry entry; + if ((fs.Entry(filename, entry) == KErrNone) && (entry.iSize > 0)) + { + ERR_PRINTF1(_L("ERROR: File exists and size is greater than ZERO")); + ret = EFail; // file exists - test fails + } + else + { + ret = EPass; + } + fs.Close(); + } + + __MM_HEAP_MARKEND; + User::Heap().Check(); + + return ret; + } + CleanupStack::PopAndDestroy(recUtil); + return EFail; + } + + +//------------------------------------------------------------------ + +CTestMmfAclntAudioRecordVolume::CTestMmfAclntAudioRecordVolume(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative, const TInt aVolume) + : CTestMmfAclntRecord(aTestName, aSectName,aNegative), iVolume(aVolume) + {} + +CTestMmfAclntAudioRecordVolume* CTestMmfAclntAudioRecordVolume::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative, const TInt aVolume) + { + CTestMmfAclntAudioRecordVolume* self = new (ELeave) CTestMmfAclntAudioRecordVolume(aTestName, aSectName,aNegative,aVolume); + return self; + } + + +TVerdict CTestMmfAclntAudioRecordVolume::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecordUtils : Audio Record Volume")); + TVerdict ret = EFail; + + + // Check maxvolume function + if(iVolume == -1) + { + iVolume = aRecUtil->MaxVolume(); + } + // Volume is truncated to maxvolume + if(iVolume > aRecUtil->MaxVolume()) + { + TInt volume; + aRecUtil->SetVolume(iVolume); + aRecUtil->GetVolume(volume); + if(volume == aRecUtil->MaxVolume()) + { + ret = EPass; + } + } + // Volume is truncated to 0 + else if(iVolume < 0) + { + TInt volume; + + aRecUtil->SetVolume(iVolume); + aRecUtil->GetVolume(volume); + if(volume == 0) + { + ret = EPass; + } + } + // Set volume and check + else + { + TInt volume; + aRecUtil->SetVolume(iVolume); + aRecUtil->GetVolume(volume); + if(volume == iVolume) + { + ret = EPass; + } + + else + { + INFO_PRINTF3( _L("Expected volume: %d, received volume : %d"), iVolume, volume); + } + } + + return ret; + } + + +CTestMmfAclntAudioRecordRamp::CTestMmfAclntAudioRecordRamp(const TDesC& aTestName, const TDesC& aSectName,TBool aNegative) + : CTestMmfAclntRecord(aTestName, aSectName,aNegative) + {} + +CTestMmfAclntAudioRecordRamp* CTestMmfAclntAudioRecordRamp::NewL(const TDesC& aTestName, const TDesC& aSectName,TBool aNegative) + { + CTestMmfAclntAudioRecordRamp* self = new (ELeave) CTestMmfAclntAudioRecordRamp(aTestName, aSectName,aNegative); + return self; + } + +TVerdict CTestMmfAclntAudioRecordRamp::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecordUtils : Audio Ramp")); + TVerdict ret = EFail; + TTimeIntervalMicroSeconds ramp(100); + aRecUtil->SetVolumeRamp(ramp); + + aRecUtil->RecordL(); + CActiveScheduler::Start(); // wait for open -> record + if (iError != KErrNone) + { + // DEF127335 + // OggRecordController does not support recording into an already existing file. + // This is due to unavailability of APIs at the level of Ogg Vorbis C libraries. + if (iTestStepName == _L("MM-MMF-ACLNTOGG-I-0123-HP") && iError == KErrNotSupported) + { + INFO_PRINTF1(_L("Expected Result: OggRecordController returned KErrNotSupported(-5)")); + return EPass; + } + else + { + return EFail; + } + } + + iReportedState = aRecUtil->State(); + if(iReportedState == CMdaAudioClipUtility::ERecording ) + { + ret = EPass; + } + + User::After(KOneSecond); + aRecUtil->Stop(); + + return ret; + } + + +//------------------------------------------------------------------ + + +CTestMmfAclntRecordDestChannels::CTestMmfAclntRecordDestChannels(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aNumberOfChannels,const TTestFormat aFormat, const TBool aCreateDes) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iTestFormat = aFormat; + iCreateDes = aCreateDes; + iNumberOfChannels=aNumberOfChannels; + + iSize = 0; + iAudio = NULL; + } + +CTestMmfAclntRecordDestChannels* CTestMmfAclntRecordDestChannels::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aNumberOfChannels, const TTestFormat aFormat,const TBool aCreateDes) + { + CTestMmfAclntRecordDestChannels* self = new (ELeave) CTestMmfAclntRecordDestChannels(aTestName,aSectName,aKeyName,aNumberOfChannels,aFormat,aCreateDes); + return self; + } + +CTestMmfAclntRecordDestChannels* CTestMmfAclntRecordDestChannels::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aNumberOfChannels, const TTestFormat aFormat, const TBool aCreateDes) + { + CTestMmfAclntRecordDestChannels* self = CTestMmfAclntRecordDestChannels::NewLC(aTestName,aSectName,aKeyName,aNumberOfChannels,aFormat,aCreateDes); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntRecordDestChannels::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF4( _L("MMdaObjectStateChangeObserver: previous state: %d current state: %d error: %d"),aPreviousState, aCurrentState, aErrorCode); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecordDestChannels::DoTestStepPreambleL() + { + SetupFormatL(iTestFormat); + + switch (iTestFormat) + { + case EPcm16Wav: + case EAlawWav: + case EPcm8: + iHeaderSize = KWavFileUncompressedDataHeaderSize; //(see mmfwavformat.cpp, CreateSinkBufferOfSizeL()) + iFrameSize = 4096; + break; + case EImaAdpcmWav: + case EImasPcmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KImaAdpcmFactChunkSize; + iFrameSize = 4096; + break; + case EMulawRaw: + case EPcmU8: + case EPcmU16: + iHeaderSize = 0; + iFrameSize = 4096; + break; + case EGsmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KGSMFactChunkSize; + iFrameSize = 4096; + break; + default: + /*skip*/ ; + } + + if(!iCreateDes) + { + RFs fs; + RFile file; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + return EInconclusive; + GetDriveName(filename); + filename.Append(filename1); + INFO_PRINTF2(_L("File for test - %S"), &filename); + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + + User::LeaveIfError(file.Size(iSize)); + INFO_PRINTF2(_L("size of file = %d\n"),iSize);//Statement Changed under DEF105143 + iAudio = HBufC8::NewMaxL(iSize); + + // Read a file into a descriptor + TPtr8 bufferDes(iAudio->Des()); + User::LeaveIfError(file.Read(bufferDes)); + + CleanupStack::PopAndDestroy(); //file + } + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMmfAclntRecordDestChannels::DoTestStepPostambleL() + { + delete iAudio; + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * Open a descriptor and record + */ +TVerdict CTestMmfAclntRecordDestChannels::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder : Record Des")); + TVerdict ret = EFail; + HBufC8* audio = NULL; + TMdaDesClipLocation* location = NULL; + TInt err = KErrNone; + RArray channels; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRec")) + { + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + recUtil->OpenFileL(filename); + } + else if(!iCreateDes) + { + audio=iAudio; + TPtr8 bufferDes(iAudio->Des()); + recUtil->OpenDesL(bufferDes); + } + else + { + iSize = KRecSize; // value is not been set yet. + audio = HBufC8::NewMaxLC(iSize); + TPtr8 bufferDes(audio->Des()); + bufferDes.SetLength(0); + location = new (ELeave) TMdaDesClipLocation(bufferDes); + recUtil->OpenL(location,iFormat,iCodec,&iAudioSettings); + + delete location; + } + + iError = KErrTimedOut; + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + TInt numChannels=-1; + if(iError == KErrNone) + { + TRAP(err,recUtil->GetSupportedNumberOfChannelsL(channels)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::GetSupportedNumberOfChannelsL leave with error %d"),err); + if(iCreateDes) + { + CleanupStack::PopAndDestroy(audio); + } + + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + TRAP(err,recUtil->SetDestinationNumberOfChannelsL(1));//@@@ + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetDestinationNumberOfChannelsL leave with error %d"),err); + if(iCreateDes) + { + CleanupStack::PopAndDestroy(audio); + } + + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + TRAP(err,numChannels = recUtil->DestinationNumberOfChannelsL()); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::DestinationNumberOfChannelsL leave with error %d"),err); + if(iCreateDes) + { + CleanupStack::PopAndDestroy(audio); + } + + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + } + + if(numChannels==iNumberOfChannels) + { + ret = EPass; + } + + + if (ret != EPass) + { + ERR_PRINTF2( _L("CMdaAudioRecorderUtility failed with error %d"),iError ); + } + + if(iCreateDes) + { + CleanupStack::PopAndDestroy(audio); + } + + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + + + +//------------------------------------------------------------------ + +CTestMmfAclntRecordSetPriority::CTestMmfAclntRecordSetPriority(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + : CTestMmfAclntRecord(aTestName, aSectName,aNegative) + {} + +CTestMmfAclntRecordSetPriority* CTestMmfAclntRecordSetPriority::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecordSetPriority* self = new (ELeave) CTestMmfAclntRecordSetPriority(aTestName, aSectName,aNegative); + return self; + } + + +TVerdict CTestMmfAclntRecordSetPriority::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecordUtils : SetPriority")); + TVerdict ret = EPass; + TInt err = KErrNone; + TRAP(err,aRecUtil->SetPriority(EMdaPriorityMin,EMdaPriorityPreferenceNone)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetPriority (1st call) leave with error %d"),err); + ret = EFail; + } + + TRAP(err,aRecUtil->SetPriority(EMdaPriorityNormal,EMdaPriorityPreferenceTime)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetPriority (2nd call) leave with error %d"),err); + ret = EFail; + } + + TRAP(err,aRecUtil->SetPriority(EMdaPriorityMax,EMdaPriorityPreferenceTimeAndQuality)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetPriority (3rd call) leave with error %d"),err); + ret = EFail; + } + return ret; + } + + +//------------------------------------------------------------------ + +CTestMmfAclntRecordDestSampleRate::CTestMmfAclntRecordDestSampleRate(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TTestFormat aFormat, const TBool aCreateDes) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iTestFormat = aFormat; + iCreateDes = aCreateDes; + + iSize = 0; + iAudio = NULL; + } + +CTestMmfAclntRecordDestSampleRate* CTestMmfAclntRecordDestSampleRate::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat,const TBool aCreateDes) + { + CTestMmfAclntRecordDestSampleRate* self = new (ELeave) CTestMmfAclntRecordDestSampleRate(aTestName,aSectName,aKeyName,aFormat,aCreateDes); + return self; + } + +CTestMmfAclntRecordDestSampleRate* CTestMmfAclntRecordDestSampleRate::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateDes) + { + CTestMmfAclntRecordDestSampleRate* self = CTestMmfAclntRecordDestSampleRate::NewLC(aTestName,aSectName,aKeyName,aFormat,aCreateDes); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntRecordDestSampleRate::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF4( _L("MMdaObjectStateChangeObserver: previous state: %d current state: %d error: %d"),aPreviousState, aCurrentState, aErrorCode); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecordDestSampleRate::DoTestStepPreambleL() + { + SetupFormatL(iTestFormat); + + switch (iTestFormat) + { + case EPcm16Wav: + case EAlawWav: + case EPcm8: + iHeaderSize = KWavFileUncompressedDataHeaderSize; //(see mmfwavformat.cpp, CreateSinkBufferOfSizeL()) + iFrameSize = 4096; + break; + case EImaAdpcmWav: + case EImasPcmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KImaAdpcmFactChunkSize; + iFrameSize = 4096; + break; + case EMulawRaw: + case EPcmU8: + case EPcmU16: + iHeaderSize = 0; + iFrameSize = 4096; + break; + case EGsmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KGSMFactChunkSize; + iFrameSize = 4096; + break; + default: + /*skip*/ ; + } + + if(!iCreateDes) + { + RFs fs; + RFile file; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + return EInconclusive; + GetDriveName(filename); + filename.Append(filename1); + INFO_PRINTF2(_L("File for test - %S"), &filename); + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + + User::LeaveIfError(file.Size(iSize)); + INFO_PRINTF2(_L("size of file = %d\n"),iSize);//Statement Changed under DEF105143 + iAudio = HBufC8::NewMaxL(iSize); + + // Read a file into a descriptor + TPtr8 bufferDes(iAudio->Des()); + User::LeaveIfError(file.Read(bufferDes)); + + CleanupStack::PopAndDestroy(); //file + } + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMmfAclntRecordDestSampleRate::DoTestStepPostambleL() + { + delete iAudio; + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * Open a descriptor and record + */ +TVerdict CTestMmfAclntRecordDestSampleRate::DoTestStepL( void ) + { + INFO_PRINTF1( _L("TestRecorder : Destination SampleRate")); + TVerdict ret = EPass; + HBufC8* audio = NULL; + TMdaDesClipLocation* location = NULL; + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRec")) + { + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + return EInconclusive; + GetDriveName(filename); + filename.Append(filename1); + + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + recUtil->OpenFileL(filename); + } + else if(!iCreateDes) + { + audio=iAudio; + TPtr8 bufferDes(iAudio->Des()); + recUtil->OpenDesL(bufferDes); + } + else + { + iSize = KRecSize; // value is not been set yet. + audio = HBufC8::NewMaxLC(iSize); + TPtr8 bufferDes(audio->Des()); + bufferDes.SetLength(0); + location = new (ELeave) TMdaDesClipLocation(bufferDes); + recUtil->OpenL(location,iFormat,iCodec,&iAudioSettings); + + delete location; + } + CActiveScheduler::Start(); + + iError = KErrTimedOut; + TInt err = KErrNone; + RArray rates; + TRAP(err,recUtil->GetSupportedSampleRatesL(rates)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::GetSupportedSampleRatesL leave with error %d"),err); + ret = EFail; + if(iCreateDes) + CleanupStack::PopAndDestroy(audio); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + + TInt numRates = rates.Count(); + for(TInt i=0;iSetDestinationSampleRateL(sr)); + if(err!=KErrNone) + { + INFO_PRINTF3(_L("CMdaAudioRecorderUtility::SetDestinationSampleRateL(%d) leave with error : %d"),sr,err); + ret = EFail; + break; + } + + TUint rate=0; + TRAP(err,rate = recUtil->DestinationSampleRateL()); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::DestinationSampleRateL leave with error %d"),err); + ret = EFail; + } + else + { + if(rate!=rates[i]) + { + ret = EFail; + INFO_PRINTF1(_L("Rate mismatch")); + } + else + { + INFO_PRINTF1(_L("Rates match")); + } + } + + } + if(iCreateDes) + CleanupStack::PopAndDestroy(audio); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } +//------------------------------------------------------------------ + +CTestMmfAclntRecordDestBitRate::CTestMmfAclntRecordDestBitRate(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + : CTestMmfAclntRecord(aTestName, aSectName, aNegative) + {} + +CTestMmfAclntRecordDestBitRate* CTestMmfAclntRecordDestBitRate::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecordDestBitRate* self = new (ELeave) CTestMmfAclntRecordDestBitRate(aTestName, aSectName, aNegative); + return self; + } + + +TVerdict CTestMmfAclntRecordDestBitRate::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecordUtils : Destination Bit Rate")); + TVerdict ret = EPass; + TInt err = KErrNone; + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRec")) + { + TPtrC filename; + if (!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename)) + { + INFO_PRINTF1(_L("Error getting filename from INI file")); + return EInconclusive; + } + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + // Open the file + aRecUtil->OpenFileL(filename); + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + CActiveScheduler::Start(); + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for recording"), iError); + return EInconclusive; + } + } + + RArray rates; + TRAP(err,aRecUtil->GetSupportedBitRatesL(rates)); + // in Typhoon KErrNotSupported is expected + if(err==KErrNotSupported) + { + //test the other bitrate functions for code coverage (and behaviour) + TRAP(err,aRecUtil->SetDestinationBitRateL(100)); // arbitrary value since KErrNotSupported is expected anyway + if (err != KErrNotSupported) + { + return EFail; + } + + TInt rate=0; + TRAP(err, rate=aRecUtil->DestinationBitRateL()); + if (err != KErrNone) + { + return EFail; + } + + INFO_PRINTF3(_L("CMdaAudioRecorderUtility::GetSupportedBitRatesL() leave with error %d bitrate of %d"),err, rate); + ret = EPass; + return ret; + } + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::GetSupportedBitRatesL leave with error %d"),err); + ret = EFail; + return ret; + } + + TInt numRates = rates.Count(); + for(TInt i=0;iSetDestinationBitRateL(rates[i])); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetDestinationBitRateL leave with error %d"),err); + ret = EFail; + } + else// no error, get rate + { + TUint rate=0; + TRAP(err,rate = aRecUtil->DestinationBitRateL()); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::DestinationBitRateL leave with error %d"),err); + ret = EFail; + } + else + { + if(rate!=rates[i]) + { + ret = EFail; + INFO_PRINTF1(_L("Rate mismatch")); + } + else + { + INFO_PRINTF1(_L("Rates match")); + } + } + } + } + return ret; + } + + +//------------------------------------------------------------------ + + + +CTestMmfAclntRecordDestDataType::CTestMmfAclntRecordDestDataType(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateDes) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iTestFormat = aFormat; + iCreateDes = aCreateDes; + iSize = 0; + iAudio = NULL; + } + +CTestMmfAclntRecordDestDataType* CTestMmfAclntRecordDestDataType::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat,const TBool aCreateDes) + { + CTestMmfAclntRecordDestDataType* self = new (ELeave) CTestMmfAclntRecordDestDataType(aTestName,aSectName,aKeyName,aFormat,aCreateDes); + return self; + } + +CTestMmfAclntRecordDestDataType* CTestMmfAclntRecordDestDataType::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat, const TBool aCreateDes) + { + CTestMmfAclntRecordDestDataType* self = CTestMmfAclntRecordDestDataType::NewLC(aTestName,aSectName,aKeyName,aFormat,aCreateDes); + CleanupStack::PushL(self); + return self; + } + +void CTestMmfAclntRecordDestDataType::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF4( _L("MMdaObjectStateChangeObserver: previous state: %d current state: %d error: %d"),aPreviousState, aCurrentState, aErrorCode); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecordDestDataType::DoTestStepPreambleL() + { + SetupFormatL(iTestFormat); + + switch (iTestFormat) + { + case EPcm16Wav: + case EAlawWav: + case EPcm8: + iHeaderSize = KWavFileUncompressedDataHeaderSize; //(see mmfwavformat.cpp, CreateSinkBufferOfSizeL()) + iFrameSize = 4096; + break; + case EImaAdpcmWav: + case EImasPcmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KImaAdpcmFactChunkSize; + iFrameSize = 4096; + break; + case EMulawRaw: + case EPcmU8: + case EPcmU16: + iHeaderSize = 0; + iFrameSize = 4096; + break; + case EGsmWav: + iHeaderSize = KWavFileCompressedDataHeaderSize + KGSMFactChunkSize; + iFrameSize = 4096; + break; + default: + /*skip*/ ; + } + + if(!iCreateDes) + { + RFs fs; + RFile file; + + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + INFO_PRINTF2(_L("File for test - %S"), &filename); + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + + User::LeaveIfError(file.Size(iSize)); + INFO_PRINTF2(_L("size of file = %d\n"),iSize);//Statement Changed under DEF105143 + iAudio = HBufC8::NewMaxL(iSize); + + // Read a file into a descriptor + TPtr8 bufferDes(iAudio->Des()); + User::LeaveIfError(file.Read(bufferDes)); + + CleanupStack::PopAndDestroy(); //file + } + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +TVerdict CTestMmfAclntRecordDestDataType::DoTestStepPostambleL() + { + delete iAudio; + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * Open a descriptor and record + */ +TVerdict CTestMmfAclntRecordDestDataType::DoTestStepL( void ) + { + HBufC8* audio = NULL; + TMdaDesClipLocation* location = NULL; + TInt err = KErrNone; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRec")) + { + TBuf filename; + TPtrC filename1; + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + recUtil->OpenFileL(filename); + } + else if(!iCreateDes) + { + audio=iAudio; + TPtr8 bufferDes(iAudio->Des()); + recUtil->OpenDesL(bufferDes); + } + else + { + iSize = KRecSize; // value is not been set yet. + audio = HBufC8::NewMaxLC(iSize); + TPtr8 bufferDes(audio->Des()); + bufferDes.SetLength(0); + location = new (ELeave) TMdaDesClipLocation(bufferDes); + recUtil->OpenL(location,iFormat,iCodec,&iAudioSettings); + + delete location; + } + CActiveScheduler::Start(); + + iError = KErrTimedOut; + INFO_PRINTF1( _L("TestRecordUtils : Destination data type")); + + RArray codecs; + recUtil->GetSupportedDestinationDataTypesL(codecs); + TInt numCodecs = codecs.Count(); + TVerdict ret = EPass; + for(TInt i=0;iSetDestinationDataTypeL(codecs[i])); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetDestinationDataTypeL leave with error %d"),err); + if(iCreateDes) + CleanupStack::PopAndDestroy(audio); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + TFourCC dataType; + TRAP(err,dataType = recUtil->DestinationDataTypeL()); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::DestinationDataTypeL leave with error %d"),err); + if(iCreateDes) + CleanupStack::PopAndDestroy(audio); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + if(dataType!=codecs[i]) + { + ret = EFail; + } + else + { + INFO_PRINTF1(_L("CMdaAudioRecorderUtility::DestinationDataType set-get OK")); + } + } + if(iCreateDes) + { + CleanupStack::PopAndDestroy(audio); + } + + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + + + + +//------------------------------------------------------------------ + +CTestMmfAclntRecordDestFormat::CTestMmfAclntRecordDestFormat(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative, const TUid aFormat) + : CTestMmfAclntRecord(aTestName, aSectName, aNegative), iFormat(aFormat) + {} + +CTestMmfAclntRecordDestFormat* CTestMmfAclntRecordDestFormat::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative, const TUid aFormat) + { + CTestMmfAclntRecordDestFormat* self = new (ELeave) CTestMmfAclntRecordDestFormat(aTestName, aSectName, aNegative, aFormat); + return self; + } + + +TVerdict CTestMmfAclntRecordDestFormat::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + // GET --> SET --> GET + INFO_PRINTF1( _L("TestRecordUtils : Destination format")); + TVerdict ret = EFail; + TInt err = KErrNone; + TRAP(err,iFormat = aRecUtil->DestinationFormatL()); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::DestinationFormatL leave with error %d"),err); + return ret; + } + TRAP(err,aRecUtil->SetDestinationFormatL(iFormat)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::SetDestinationFormatL leave with error %d"),err); + return ret; + } + TUid format; + TRAP(err,format = aRecUtil->DestinationFormatL()); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("CMdaAudioRecorderUtility::DestinationFormatL leave with error %d"),err); + return ret; + } + if(format==iFormat) + { + ret = EPass; + } + + return ret; + } + + +//------------------------------------------------------------------ + +CTestMmfAclntRecordAudioDeviceMode::CTestMmfAclntRecordAudioDeviceMode(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + : CTestMmfAclntRecord(aTestName, aSectName, aNegative) + {} + +CTestMmfAclntRecordAudioDeviceMode* CTestMmfAclntRecordAudioDeviceMode::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecordAudioDeviceMode* self = new (ELeave) CTestMmfAclntRecordAudioDeviceMode(aTestName, aSectName, aNegative); + return self; + } + + +TVerdict CTestMmfAclntRecordAudioDeviceMode::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecordUtils : SetAudioDeviceMode")); + INFO_PRINTF1( _L("This function is provided for binary compatibility, but does not have any effect from 7.0s")); + + // Set the audio device mode. This function is provided for binary compatibility, but + // does not have any effect from 7.0s + aRecUtil->SetAudioDeviceMode(CMdaAudioRecorderUtility::EDefault); + aRecUtil->SetAudioDeviceMode(CMdaAudioRecorderUtility::ETelephonyOrLocal); + aRecUtil->SetAudioDeviceMode(CMdaAudioRecorderUtility::ETelephonyMixed); + aRecUtil->SetAudioDeviceMode(CMdaAudioRecorderUtility::ETelephonyNonMixed); + aRecUtil->SetAudioDeviceMode(CMdaAudioRecorderUtility::ELocal); + TVerdict ret = EPass; + return ret; + } + + + + + + + + +// +// +// CMdaAudioInputStream Integration Tests // +// +// + +/** + * Standard static NewL() taking a callback function + */ +CCallBackTimer* CCallBackTimer::NewL(TCallBack aCallBack, TPriority aPriority) + { + CCallBackTimer* self = new(ELeave) CCallBackTimer(aCallBack, aPriority); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); // self + return self; + } + +/** + * Private c'tor + */ +CCallBackTimer::CCallBackTimer(TCallBack aCallBack, TPriority aPriority) +: CTimer(aPriority), +iCallBack(aCallBack) + { + CActiveScheduler::Add(this); + } + +/* + * Callback on timer complete + */ +void CCallBackTimer::RunL() + { + iCallBack.CallBack(); + } + + +_LIT(KStreamRawFile,"c:\\AclntITestData\\test.raw"); +_LIT(KRecordStreamRawFile,"c:\\AclntITestData\\streamrecorded.raw"); +CTestStepAudInStream* CTestStepAudInStream::NewL() + { + CTestStepAudInStream* s = new(ELeave) CTestStepAudInStream(); + CleanupStack::PushL(s); + s->ConstructL(); + CleanupStack::Pop(); + return s; + } + +CTestStepAudInStream::CTestStepAudInStream() : iError(KErrNone), iState(EStopped) + { + + } + +void CTestStepAudInStream::ConstructL() + { + // reset the buffer + for(TInt i=0; iCancel(); + TInt filePosition=0; + iFile.Seek(ESeekStart, filePosition); + iFile.Close(); + CActiveScheduler::Stop(); + } + +void CTestStepAudInStream::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + iError = aError; + if(aError != KErrNone) + { + return; + } + // Assume aBuffer == iBufferList[iEndBuf] + + // Increment iEndBuf + if(iEndBuf==KRecNumBuffer-1) + { + iEndBuf = 0; + } + + else + iEndBuf++; + + // Starting writing out the buffers if we're not already + if(!iWriteBufferActive->IsActive()) + { + iWriteBufferActive->Write(iBufferList[iStartBuf]); + } + } + +void CTestStepAudInStream::StartReadL() + { + // Issue reads on all available buffers + for (TInt ii=0; iiReadL(iBufferList[ii]); + } + } + +void CTestStepAudInStream::Read1BufL() + { + // Issue reads on 1 available buffer + iAudInStream->ReadL(iBufferList[0]); + } + + +CTestStepAudInStream::CWriteBufferActive::CWriteBufferActive() : CActive(0) + { + CActiveScheduler::Add(this); + } + +CTestStepAudInStream::CWriteBufferActive::~CWriteBufferActive() + { + Cancel(); + } + +void CTestStepAudInStream::CWriteBufferActive::RunL() + { + //ASSERT it wrote OK + iParent->ProcessDataL(); + } + +TInt CTestStepAudInStream::CWriteBufferActive::RunError(TInt aError) + { + iParent->iError = aError; + CActiveScheduler::Stop(); + + return KErrNone; + } + + +void CTestStepAudInStream::CWriteBufferActive::DoCancel() + { + // do nothing + } + +void CTestStepAudInStream::CWriteBufferActive::Write(const TDesC8& aBuffer) + { + iParent->iFile.Write(aBuffer, iStatus); // read the 1st data trunk + SetActive(); + } + + +void CTestStepAudInStream::ProcessDataL() + { + // Set the next buffer to handle + iBufferList[iStartBuf] = KNullDesC8; // done with that one + // Issue another read to input stream + iAudInStream->ReadL(iBufferList[iStartBuf]); + + // Increment iStartBuf + if(iStartBuf==KRecNumBuffer-1) + { + iStartBuf=0; + } + + else + iStartBuf++; + + if (iBufferList[iStartBuf] != KNullDesC8) + { + // Still more to write + iWriteBufferActive->Write(iBufferList[iStartBuf]); + } + else + CActiveScheduler::Stop(); + + // else just wait for more recorded data to come through + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ + enum TVerdict CTestStepAudInStream::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + + // reset the buffer [in case new test reuses previous object] + for(TInt i=0; iiParent = this; + iFs.Connect(); + + TRAPD(err, iAudInStream = CMdaAudioInputStream::NewL(*this) ); + + if (err != KErrNone || + iAudInStream == NULL ) + { + return EInconclusive; + } + + + return verdict; + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepAudInStream::DoTestStepPostambleL(void) + { + iFs.Close(); + + delete iAudInStream; + iAudInStream = NULL; + delete iWriteBufferActive; + iWriteBufferActive = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepAudInStream::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + if (iError != KErrNone ) + return EFail; + + err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ; + if (err != KErrNone) + return EFail; + + StartReadL(); + CActiveScheduler::Start(); + + iFile.Close(); + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + +CTestStepAudInStreamNoUECap* CTestStepAudInStreamNoUECap::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamNoUECap* self = new(ELeave) CTestStepAudInStreamNoUECap(aTestName); + return self; + } + + +CTestStepAudInStreamNoUECap::CTestStepAudInStreamNoUECap(const TDesC& aTestName) + { + iTestStepResult = EFail; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + + + +CTestStepAudInStreamNoUECap::~CTestStepAudInStreamNoUECap() + { + } + + +void CTestStepAudInStreamNoUECap::MaiscOpenComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + +void CTestStepAudInStreamNoUECap::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) + { + INFO_PRINTF1(_L("MMdaAudioInputStreamCallback::MaiscBufferCopied was not supposed to be called")); + iTestStepResult = EFail; + CActiveScheduler::Stop(); + } +void CTestStepAudInStreamNoUECap::MaiscRecordComplete(TInt aError) + { + INFO_PRINTF2(_L("MMdaAudioInputStreamCallback::MaiscRecordComplete was called with aError = %d"),aError); + iMaiscRecordCompleteError = aError; + CActiveScheduler::Stop(); + } + +TVerdict CTestStepAudInStreamNoUECap::DoTestStepL() + { + TInt err = KErrNone; + iTestStepResult = EFail; + + // Printing to the console and log file + INFO_PRINTF1(_L("this test calls MediaAudioClientInputStream::ReadL func with NO UserEnvironment capability")); + + iAudInStream->Open(NULL); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 1: error = %d"),iError); + return EInconclusive; + } + + iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ; + if (err != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 2: error = %d"),err); + return EInconclusive; + } + + iState=ERecording; + + // start feeding the input stream + TRAP(err, Read1BufL()); + CActiveScheduler::Start(); + if ( (err == KErrNone && iMaiscRecordCompleteError == KErrPermissionDenied) || err == KErrPermissionDenied ) + { + INFO_PRINTF2(_L("Feeding input stream without UserEnvironent cap left with expected error = %d"),err); + iTestStepResult = EPass; + } + else + { + INFO_PRINTF1(_L("Failed this test step with error %d")); + INFO_PRINTF2(_L("Expected error = %d"),KErrPermissionDenied); + INFO_PRINTF1(_L("The requesting client should not have the UserEnvironment cap in this test")); + iTestStepResult = EFail; + } + // test steps return a result + + return iTestStepResult; + } + +CTestStepAudInStreamWithUECap* CTestStepAudInStreamWithUECap::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamWithUECap* self = new(ELeave) CTestStepAudInStreamWithUECap(aTestName); + return self; + } + + +CTestStepAudInStreamWithUECap::CTestStepAudInStreamWithUECap(const TDesC& aTestName) + { + iTestStepResult = EFail; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + + + +CTestStepAudInStreamWithUECap::~CTestStepAudInStreamWithUECap() + { + } + + +void CTestStepAudInStreamWithUECap::MaiscOpenComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + + +void CTestStepAudInStreamWithUECap::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + //if weve stopped recording, each unused buffer will be returned with KErrAbort + if(iState == EStopped && aError == KErrAbort) + { + return; + } + + iError = aError; + } + +void CTestStepAudInStreamWithUECap::MaiscRecordComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } + +TVerdict CTestStepAudInStreamWithUECap::DoTestStepL() + { + // Printing to the console and log file + INFO_PRINTF1(_L("This test calls MediaAudioClientInputStream::ReadL func with at list the UserEnvironment capability")); + + iAudInStream->Open(NULL); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 1: error = %d"),iError); + return EInconclusive; + } + + TInt err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ; + if (err != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 2: error = %d"),err); + return EInconclusive; + } + + + iState=ERecording; + + // start feeding the input stream + TRAP(err, Read1BufL()); + CActiveScheduler::Start(); + + if (err != KErrNone) + { + INFO_PRINTF2(_L("Test Failed with: error = %d"),iError); + return EFail; + } + + return EPass; + } + + +CTestStepAudInStreamSetGain* CTestStepAudInStreamSetGain::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamSetGain* self = new(ELeave) CTestStepAudInStreamSetGain(aTestName); + return self; + } + +CTestStepAudInStreamSetGain::CTestStepAudInStreamSetGain(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudInStreamSetGain::~CTestStepAudInStreamSetGain() + { + } + +void CTestStepAudInStreamSetGain::MaiscOpenComplete(TInt /*aError*/) + { + } +void CTestStepAudInStreamSetGain::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) + { + } +void CTestStepAudInStreamSetGain::MaiscRecordComplete(TInt /*aError*/) + { + } + +enum TVerdict CTestStepAudInStreamSetGain::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + INFO_PRINTF2(_L("Test step %S DoTestStepPreambleL"),&iTestStepName); + TInt err = KErrNone; + TRAP(err, iAudInStream = CMdaAudioInputStream::NewL(*this)); + if (err != KErrNone || iAudInStream == NULL ) + { + return EInconclusive; + } + + return verdict; + } + +enum TVerdict CTestStepAudInStreamSetGain::DoTestStepPostambleL(void) + { + delete iAudInStream; + iAudInStream = NULL; + //[ Destroy the scheduler ] + INFO_PRINTF2(_L("Test step %S DoTestStepPostambleL"),&iTestStepName); + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudInStreamSetGain::DoTestStepL() + { + INFO_PRINTF1( _L("TestAudioInputStream : Gain")); + INFO_PRINTF2( _L("TestAudioInputStream : MaxGain()(%d)"),iAudInStream->MaxGain()); + TInt gain = iAudInStream->MaxGain()/2; + if (gain < 0) + { + return EFail; + } + + //set the volume + INFO_PRINTF2( _L("TestAudioInputStream : SetGain(%d)"),gain); + iAudInStream->SetGain(gain); + + //get the volume + TInt rgain = iAudInStream->Gain(); + if (gain != rgain ) + { + return EFail; + } + + INFO_PRINTF2( _L("TestAudioInputStream : Gain() returned %d"),rgain); + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + +// +// +// +CTestStepAudInStreamSetPriority* CTestStepAudInStreamSetPriority::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamSetPriority* self = new(ELeave) CTestStepAudInStreamSetPriority(aTestName); + return self; + } + +CTestStepAudInStreamSetPriority::CTestStepAudInStreamSetPriority(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudInStreamSetPriority::~CTestStepAudInStreamSetPriority() + { + } + +void CTestStepAudInStreamSetPriority::MaiscOpenComplete(TInt aError) + { + iError = aError; + } +void CTestStepAudInStreamSetPriority::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + iError = aError; + } +void CTestStepAudInStreamSetPriority::MaiscRecordComplete(TInt aError) + { + iError = aError; + } + +enum TVerdict CTestStepAudInStreamSetPriority::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + + TInt err = KErrNone; + TRAP(err, iAudInStream = CMdaAudioInputStream::NewL(*this)); + if (err != KErrNone || iAudInStream == NULL ) + { + return EInconclusive; + } + + return verdict; + } + +enum TVerdict CTestStepAudInStreamSetPriority::DoTestStepPostambleL(void) + { + delete iAudInStream; + iAudInStream = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudInStreamSetPriority::DoTestStepL() + { + INFO_PRINTF1( _L("TestAudioInputStream : Priority")); + iAudInStream->SetPriority(EMdaPriorityMin, EMdaPriorityPreferenceTime); + iAudInStream->SetPriority(EMdaPriorityMax, EMdaPriorityPreferenceQuality); + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + +// +// +// +CTestStepAudInStreamSetBalance* CTestStepAudInStreamSetBalance::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamSetBalance* self = new(ELeave) CTestStepAudInStreamSetBalance(aTestName); + return self; + } + +CTestStepAudInStreamSetBalance::CTestStepAudInStreamSetBalance(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudInStreamSetBalance::~CTestStepAudInStreamSetBalance() + { + } + +void CTestStepAudInStreamSetBalance::MaiscOpenComplete(TInt /*aError*/) + { + } +void CTestStepAudInStreamSetBalance::MaiscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) + { + } +void CTestStepAudInStreamSetBalance::MaiscRecordComplete(TInt /*aError*/) + { + } + +enum TVerdict CTestStepAudInStreamSetBalance::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + + TInt err = KErrNone; + TRAP(err, iAudInStream = CMdaAudioInputStream::NewL(*this)); + if (err != KErrNone || iAudInStream == NULL ) + { + return EInconclusive; + } + + return verdict; + } + +enum TVerdict CTestStepAudInStreamSetBalance::DoTestStepPostambleL(void) + { + delete iAudInStream; + iAudInStream = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudInStreamSetBalance::DoTestStepL() + { + TInt bal=0; + + TRAPD(err, iAudInStream->SetBalanceL()); // default KMMFBalanceCenter + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + //get the balance + TRAP(err, bal = iAudInStream->GetBalanceL()); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + if (bal != KMMFBalanceCenter ) + { + return EFail; + } + + TRAP(err, iAudInStream->SetBalanceL(KMMFBalanceMaxRight)); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + //get the balance + TRAP(err, bal = iAudInStream->GetBalanceL()); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + + if (bal != KMMFBalanceMaxRight) + { + return EFail; + } + + TRAP(err, iAudInStream->SetBalanceL(KMMFBalanceMaxLeft)); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + //get the balance + TRAP(err, bal = iAudInStream->GetBalanceL()); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + if (bal != KMMFBalanceMaxLeft ) + { + return EFail; + } + + // In of bounds + /* + iAudInStream->SetBalance(KMMFBalanceMaxLeft+10); + //check condition + */ + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + +// +// +// + +LOCAL_C TInt stopActiveScheduler(TAny*) + { + CActiveScheduler::Stop(); + return FALSE; + } + +CTestStepAudInStreamGetBytes* CTestStepAudInStreamGetBytes::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamGetBytes* self = new(ELeave) CTestStepAudInStreamGetBytes(aTestName); + return self; + } + +CTestStepAudInStreamGetBytes::CTestStepAudInStreamGetBytes(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudInStreamGetBytes::~CTestStepAudInStreamGetBytes() + { + } + +void CTestStepAudInStreamGetBytes::MaiscOpenComplete(TInt aError) + { + iError = aError; + CActiveScheduler::Stop(); + } +void CTestStepAudInStreamGetBytes::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + //if weve stopped recording, each unused buffer will be returned with KErrAbort + if(iState == EStopped && aError == KErrAbort) + { + return; + } + + iError = aError; + ++iBuffersUsed; + } + +void CTestStepAudInStreamGetBytes::MaiscRecordComplete(TInt aError) + { + + if(aError != KErrNone) + { + iError = aError; + CActiveScheduler::Stop(); + return; + } + // Assume aBuffer == iBufferList[iEndBuf] + + // Increment iEndBuf + if(iEndBuf==KRecNumBuffer-1) + { + iEndBuf = 0; + } + + else + iEndBuf++; + + // Starting writing out the buffers if we're not already + if(!iWriteBufferActive->IsActive()) + iWriteBufferActive->Write(iBufferList[iStartBuf]); + } + +enum TVerdict CTestStepAudInStreamGetBytes::DoTestStepPreambleL(void) + { + iTestStepResult = EPass; + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestStepAudInStream::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF1(_L("this test gets the bytes rendered by the H/W until this moment: GetBytes()")); + + iAudInStream->Open(NULL); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 1: error = %d"),iError); + return EInconclusive; + } + + TInt err = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ; + if (err != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 2: error = %d"),err); + return EInconclusive; + } + + + iState=ERecording; + + // start feeding the input stream + StartReadL(); + CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard); + idleStopper->Start(TCallBack(stopActiveScheduler)); + CActiveScheduler::Start(); + delete idleStopper; + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 3: error = %d"),iError); + return EInconclusive; + } + + return verdict; + } + +enum TVerdict CTestStepAudInStreamGetBytes::DoTestStepPostambleL(void) + { + iFile.Close(); + delete iAudInStream; + iAudInStream = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudInStreamGetBytes::DoTestStepL() + { + TInt bytes1 = iAudInStream->GetBytes(); + INFO_PRINTF2(_L("bytes1 = %d"), bytes1); + + CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler)); + callBackTimer->After(1000000); + CActiveScheduler::Start(); + callBackTimer->Cancel(); // in case something else stopped the AS + + if (iError != KErrNone) + { + ERR_PRINTF2(_L("First call to GetBytes() returned error %d"), iError); + delete callBackTimer; + return EFail; + } + + TInt bytes2 = iAudInStream->GetBytes(); + INFO_PRINTF2(_L("bytes2 = %d"), bytes2); + + callBackTimer->After(1000000); + CActiveScheduler::Start(); + callBackTimer->Cancel(); + + if (iError != KErrNone) + { + ERR_PRINTF2(_L("Second call to GetBytes() returned error %d"), iError); + delete callBackTimer; + return EFail; + } + + delete callBackTimer; + + //Stop will kick off the write of the data to file through CWriteBufferActive, which will stop + //ActiveSheduler when written + iState=EStopped; //required so that acceptable KErrAbort in MaiscBufferCopied are handled properly + iAudInStream->Stop(); + + // Starting writing out the buffers if we're not already + if(!iWriteBufferActive->IsActive()) + { + iWriteBufferActive->Write(iBufferList[iStartBuf]); + } + + CActiveScheduler::Start(); + + TInt bytes3 = iAudInStream->GetBytes(); + INFO_PRINTF2(_L("bytes3 = %d"), bytes3); + if (iError != KErrNone) + { + ERR_PRINTF2(_L("Third call to GetBytes() returned error %d"), iError); + return EFail; + } + + TInt fileSize; + User::LeaveIfError(iFile.Size(fileSize)); + ERR_PRINTF2(_L("filesize %d"), fileSize); + INFO_PRINTF4(_L("GetBytes returned sizes %d, %d, %d"), bytes1, bytes2, bytes3); + + INFO_PRINTF3(_L("Recording Complete used %d of the %d buffers available"),iBuffersUsed,KRecNumBuffer); + + if (bytes1 > bytes2 || bytes2 > bytes3) + { + return EFail; + } + + + if (bytes3 != fileSize) + { + ERR_PRINTF3(_L("Error : bytes3 %d != filesize %d"), bytes3, fileSize); + return EFail; + } + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + +// +// +// + +CTestStepAudInStreamSglBuf* CTestStepAudInStreamSglBuf::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamSglBuf* self = new(ELeave) CTestStepAudInStreamSglBuf(aTestName); + return self; + } + +CTestStepAudInStreamSglBuf::CTestStepAudInStreamSglBuf(const TDesC& aTestName) + : CTestStepAudInStreamGetBytes(aTestName), + iBufferPtr(NULL, 0) + { + iTestStepResult = EFail; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudInStreamSglBuf::~CTestStepAudInStreamSglBuf() + { + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepAudInStreamSglBuf::DoTestStepPreambleL(void) + { + iTestStepResult = EPass; + + // this installs the scheduler + iTestStepResult = CTestStepAudInStream::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF1(_L("this test gets the bytes rendered by the H/W until this moment: GetBytes()")); + + iAudInStream->SetSingleBufferMode(ETrue); + iAudInStream->Open(NULL); + CActiveScheduler::Start(); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 1: error = %d"),iError); + return EInconclusive; + } + + iError = iFile.Replace( iFs, KRecordStreamRawFile, EFileWrite ) ; + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 2: error = %d"),iError); + return EInconclusive; + } + + iState=ERecording; + + // start feeding the input stream + Read1BufL(); // single buffer + CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard); + idleStopper->Start(TCallBack(stopActiveScheduler)); + CActiveScheduler::Start(); + delete idleStopper; + if (iError != KErrNone) + { + INFO_PRINTF2(_L("DEBUG LEAVE 3: error = %d"),iError); + return EInconclusive; + } + + return iTestStepResult; + } + + +void CTestStepAudInStreamSglBuf::Read1BufL() + { + // Issue reads on 1 available buffer + iBufferPtr.Set(const_cast(iSingleBuffer.Ptr()), 0, iSingleBuffer.MaxLength()); + iAudInStream->ReadL(iBufferPtr); + } + + +void CTestStepAudInStreamSglBuf::MaiscBufferCopied(TInt aError, const TDesC8& aBuffer) + { + CTestStepAudInStreamGetBytes::MaiscBufferCopied(aError, aBuffer); + + TInt lengthRecorded = iSingleBuffer.Length()+aBuffer.Length(); + iSingleBuffer.SetLength(lengthRecorded); + } + + +void CTestStepAudInStreamSglBuf::MaiscRecordComplete(TInt aError) + { + // Starting writing out the buffer if we're not already + if(!iWriteBufferActive->IsActive()) + { + iWriteBufferActive->Write(iSingleBuffer); + } + + CTestStepAudInStreamGetBytes::MaiscRecordComplete(aError); + } + + +TVerdict CTestStepAudInStreamSglBuf::DoTestStepL() + { + TInt bytes1 = iAudInStream->GetBytes(); + INFO_PRINTF2(_L("bytes1 = %d"), bytes1); + + CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler)); + callBackTimer->After(1000000); + CActiveScheduler::Start(); + callBackTimer->Cancel(); // in case something else stopped the AS + + if (iError != KErrNone) + { + ERR_PRINTF2(_L("First call to GetBytes() returned error %d"), iError); + delete callBackTimer; + return EFail; + } + + TInt bytes2 = iAudInStream->GetBytes(); + INFO_PRINTF2(_L("bytes2 = %d"), bytes2); + + callBackTimer->After(1000000); + CActiveScheduler::Start(); + callBackTimer->Cancel(); + + if (iError != KErrNone) + { + ERR_PRINTF2(_L("Second call to GetBytes() returned error %d"), iError); + delete callBackTimer; + return EFail; + } + + delete callBackTimer; + + //Stop will kick off the write of the data to file through CWriteBufferActive, which will stop + //ActiveSheduler when written + iState=EStopped; //required so that acceptable KErrAbort in MaiscBufferCopied are handled properly + iAudInStream->Stop(); + + // Starting writing out the buffers if we're not already + if(!iWriteBufferActive->IsActive()) + { + iWriteBufferActive->Write(iSingleBuffer); + } + + CActiveScheduler::Start(); + + TInt bytes3 = iAudInStream->GetBytes(); + INFO_PRINTF2(_L("bytes3 = %d"), bytes3); + if (iError != KErrNone) + { + ERR_PRINTF2(_L("Third call to GetBytes() returned error %d"), iError); + return EFail; + } + + TInt fileSize; + User::LeaveIfError(iFile.Size(fileSize)); + ERR_PRINTF2(_L("filesize %d"), fileSize); + INFO_PRINTF4(_L("GetBytes returned sizes %d, %d, %d"), bytes1, bytes2, bytes3); + + INFO_PRINTF2(_L("Recording Complete using a single buffer of size %d bytes"), KRecBufferSglBufSize); + + if (bytes1 > bytes2 || bytes2 > bytes3) + { + return EFail; + } + + if (bytes3 != fileSize) + { + ERR_PRINTF3(_L("Error : bytes3 %d != filesize %d"), bytes3, fileSize); + return EFail; + } + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + +void CTestStepAudInStreamSglBuf::ProcessDataL() + { + // wait for more recorded data to come through + CActiveScheduler::Stop(); + } + +// +// +// + +CTestStepAudInStreamSetProp* CTestStepAudInStreamSetProp::NewL(const TDesC& aTestName) + { + CTestStepAudInStreamSetProp* self = new(ELeave) CTestStepAudInStreamSetProp(aTestName); + return self; + } + +CTestStepAudInStreamSetProp::CTestStepAudInStreamSetProp(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudInStreamSetProp::~CTestStepAudInStreamSetProp() + { + } + +void CTestStepAudInStreamSetProp::MaiscOpenComplete(TInt aError) + { + iError = aError; + } +void CTestStepAudInStreamSetProp::MaiscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + iError = aError; + } +void CTestStepAudInStreamSetProp::MaiscRecordComplete(TInt aError) + { + iError = aError; + } + +enum TVerdict CTestStepAudInStreamSetProp::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + + TInt err = KErrNone; + TRAP(err, iAudInStream = CMdaAudioInputStream::NewL(*this)); + if (err != KErrNone || iAudInStream == NULL ) + { + return EInconclusive; + } + + return verdict; + } + +enum TVerdict CTestStepAudInStreamSetProp::DoTestStepPostambleL(void) + { + delete iAudInStream; + iAudInStream = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudInStreamSetProp::DoTestStepL() + { + INFO_PRINTF1( _L("TestAudioInputStream : SetAudioProperties")); + iTestStepResult = EPass; + TInt err = KErrNone; + + // test 1 + TRAP(err, iAudInStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate8000Hz,TMdaAudioDataSettings::EChannelsMono) ); + + if (!(err == KErrNone || + err == KErrNotSupported) ) + { + return EFail; + } + + + // test2 + TRAP(err, iAudInStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate44100Hz,TMdaAudioDataSettings::EChannelsStereo) ); + + if (!(err == KErrNone || + err == KErrNotSupported) ) + { + return EFail; + } + + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + +// +// +// CMdaAudioOutputStream Integration Tests // +// +// + +// base class for some audio Ouput stream tests +CTestStepAudOutStream* CTestStepAudOutStream::NewL() + { + CTestStepAudOutStream* s = new(ELeave) CTestStepAudOutStream(); + CleanupStack::PushL(s); + s->ConstructL(); + CleanupStack::Pop(); + return s; + } + +CTestStepAudOutStream::CTestStepAudOutStream() : iError(KErrNone) + { + iIsAllDataRead = EFalse; + iIsAllDataWritten = EFalse; + } + +void CTestStepAudOutStream::ConstructL() + { + // reset the buffer + for(TInt i=0; iCancel(); + TInt filePosition=0; + iFile.Seek(ESeekStart, filePosition); + iFile.Close(); + CActiveScheduler::Stop(); + } + +void CTestStepAudOutStream::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/) + { + iError = aError; + if(aError) + { + //need add for deal with exception + return; + } + + + // adjust the buffer + iBufferList[iStartBuf] = KNullDesC8; + if(iStartBuf==KNumBuffer-1) + iStartBuf = 0; + else + iStartBuf++; + + if (iIsAllDataRead && iStartBuf == iEndBuf) + { + iIsAllDataWritten = ETrue; + } + else if(!iReadBufferActive->IsActive()) + iReadBufferActive->Read(); + } + + +CTestStepAudOutStream::CReadBufferActive::CReadBufferActive() : CActive(0) + { + CActiveScheduler::Add(this); + } + +CTestStepAudOutStream::CReadBufferActive::~CReadBufferActive() + { + Cancel(); + } + +void CTestStepAudOutStream::CReadBufferActive::RunL() + { + iParent->ProcessDataL(iBuffer); + } + +TInt CTestStepAudOutStream::CReadBufferActive::RunError(TInt aError) + { + iParent->iError = aError; + CActiveScheduler::Stop(); + + return KErrNone; + } + +void CTestStepAudOutStream::CReadBufferActive::DoCancel() + { + // do nothing + } + +void CTestStepAudOutStream::CReadBufferActive::Read() + { + iParent->iFile.Read(iBuffer, iStatus); // read the 1st data trunk + SetActive(); + } + + +void CTestStepAudOutStream::ProcessDataL(TBuf8& aData) + { + if(aData.Length()) + { + if(iBufferList[iEndBuf]==KNullDesC8) + { + iBufferList[iEndBuf] = aData; + iAudOutStream->WriteL(iBufferList[iEndBuf]); + + // adjust the buffer + if(iEndBuf==KNumBuffer-1) + { + iEndBuf=0; + } + + else + { + iEndBuf++; + } + } + + if(iBufferList[iEndBuf]==KNullDesC8) + { + iReadBufferActive->Read(); + } + // else all our buffers are full + } + else + iIsAllDataRead = ETrue; + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ + enum TVerdict CTestStepAudOutStream::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + + // reset the buffer [incase new test reuses previous object] + for(TInt i=0; iiParent = this; + iFs.Connect(); + + TRAPD(err, iAudOutStream = CMdaAudioOutputStream::NewL(*this) ); + + if (err != KErrNone || + iAudOutStream == NULL ) + { + return EInconclusive; + } + + return verdict; + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepAudOutStream::DoTestStepPostambleL(void) + { + iFs.Close(); + + delete iAudOutStream; + iAudOutStream = NULL; + delete iReadBufferActive; + iReadBufferActive = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepAudOutStream::DoTestStepL() + { + iTestStepResult = EPass; + //TInt err = KErrNone; + + iAudOutStream->Open(NULL); + CActiveScheduler::Start(); + iAudOutStream->SetVolume(iAudOutStream->MaxVolume()>>1); // half volume + + if (iError != KErrNone ) + { + return EFail; + } + + + TInt err = KErrNone; + err = iFile.Open(iFs, KStreamRawFile, EFileRead); + if (err != KErrNone) + { + return EFail; + } + + iReadBufferActive->Read(); + CActiveScheduler::Start(); + + // wait sometime to finish and then close the file + User::After(1200000); + iFile.Close(); + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + + + + +CTestStepAudOutStreamSetProp* CTestStepAudOutStreamSetProp::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamSetProp* self = new(ELeave) CTestStepAudOutStreamSetProp(aTestName); + return self; + } + +CTestStepAudOutStreamSetProp::CTestStepAudOutStreamSetProp(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudOutStreamSetProp::~CTestStepAudOutStreamSetProp() + { + } + +enum TVerdict CTestStepAudOutStreamSetProp::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestStepAudOutStream::DoTestStepPreambleL(); + + // if the parent preamble fails, we must fail too + if (verdict != EPass) + { + return verdict; + } + + // Printing to the console and log file + INFO_PRINTF1(_L("this test is setting the audio properties of an Audio Output Stream Utility Class")); + + iAudOutStream->Open(NULL); + CActiveScheduler::Start(); + + return verdict; + } + +TVerdict CTestStepAudOutStreamSetProp::DoTestStepL() + { + TInt err = KErrNone; + + // test 1 + TRAP(err, iAudOutStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate8000Hz,TMdaAudioDataSettings::EChannelsMono) ); + if (!(err == KErrNone || + err == KErrNotSupported) ) + { + return EFail; + } + + + // test2 + // fails with the enum values, correct? + TRAP(err, iAudOutStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate44100Hz,TMdaAudioDataSettings::EChannelsStereo) ); + + if (!(err == KErrNone || + err == KErrNotSupported) ) + { + return EFail; + } + + else + return EPass; + } + + + + + + + +CTestStepAudOutStreamOpen* CTestStepAudOutStreamOpen::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamOpen* self = new(ELeave) CTestStepAudOutStreamOpen(aTestName); + return self; + } + +CTestStepAudOutStreamOpen::CTestStepAudOutStreamOpen(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +enum TVerdict CTestStepAudOutStreamOpen::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler and initialises the iAudOutStream + verdict = CTestStepAudOutStream::DoTestStepPreambleL(); + INFO_PRINTF1(_L("this test is openning an Audio Output Stream Utility Class")); + return verdict; + } + +TVerdict CTestStepAudOutStreamOpen::DoTestStepL() + { + TInt err = KErrNone; + + TMdaAudioDataSettings settings; + settings.Query(); + settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz; // ESampleRateAnyInRange + settings.iChannels = TMdaAudioDataSettings::EChannelsStereo; + settings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting; + settings.iVolume = 0; + + iAudOutStream->Open(&settings); + CActiveScheduler::Start(); + + if (iAudOutStream == NULL) + { + err = KErrNotReady; + } + + if (iError != KErrNone || + err != KErrNone) + { + return EFail; + } + + else + { + return EPass; + } + } + + + +CTestStepAudOutStreamSetVol* CTestStepAudOutStreamSetVol::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamSetVol* self = new(ELeave) CTestStepAudOutStreamSetVol(aTestName); + return self; + } + +CTestStepAudOutStreamSetVol::CTestStepAudOutStreamSetVol(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudOutStreamSetVol::~CTestStepAudOutStreamSetVol() + { + } + +/** + * Implementation of the MMdaAudioOuputStreamCallback interface functions + **/ +void CTestStepAudOutStreamSetVol::MaoscOpenComplete(TInt /*aError*/) + { + } +void CTestStepAudOutStreamSetVol::MaoscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) + { + } +void CTestStepAudOutStreamSetVol::MaoscPlayComplete(TInt /*aError*/) + { + } + +enum TVerdict CTestStepAudOutStreamSetVol::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + // Printing to the console and log file + INFO_PRINTF1(_L("this test is setting the volume of an Audio Output Stream Utility Class")); + + TRAPD(err, iAudOutStream = CMdaAudioOutputStream::NewL(*this) ); + + if (err != KErrNone || + iAudOutStream == NULL) + { + return EInconclusive; + } + + return verdict; + } + +enum TVerdict CTestStepAudOutStreamSetVol::DoTestStepPostambleL(void) + { + delete iAudOutStream; + iAudOutStream = NULL; + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + + +TVerdict CTestStepAudOutStreamSetVol::DoTestStepL() + { + TInt vol = iAudOutStream->MaxVolume()/2; + if (vol < 0) + { + return EFail; + } + + //set the volume + iAudOutStream->SetVolume(vol); + + //get the volume + TInt rvol = iAudOutStream->Volume(); + if (vol != rvol ) + { + return EFail; + } + + else + { + iTestStepResult = EPass; + } + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + + +CTestStepAudOutStreamSetBalance* CTestStepAudOutStreamSetBalance::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamSetBalance* self = new(ELeave) CTestStepAudOutStreamSetBalance(aTestName); + return self; + } + +CTestStepAudOutStreamSetBalance::CTestStepAudOutStreamSetBalance(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + + +CTestStepAudOutStreamSetBalance::~CTestStepAudOutStreamSetBalance() + { + } + +void CTestStepAudOutStreamSetBalance::MaoscOpenComplete(TInt /*aError*/) + { + } +void CTestStepAudOutStreamSetBalance::MaoscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) + { + } +void CTestStepAudOutStreamSetBalance::MaoscPlayComplete(TInt /*aError*/) + { + } + +enum TVerdict CTestStepAudOutStreamSetBalance::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestMmfAclntStep::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF1(_L("this test is setting and getting the balance of an Audio Output Stream Utility Class")); + + TRAPD(err, iAudOutStream = CMdaAudioOutputStream::NewL(*this) ); + + if (err != KErrNone || + iAudOutStream == NULL ) + { + return EInconclusive; + } + + + return verdict; + } + +enum TVerdict CTestStepAudOutStreamSetBalance::DoTestStepPostambleL(void) + { + delete iAudOutStream; + iAudOutStream = NULL; + + //[ Destroy the scheduler ] + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + + +TVerdict CTestStepAudOutStreamSetBalance::DoTestStepL() + { + TInt bal = 0; + + TRAPD(err, iAudOutStream->SetBalanceL()); // default KMMFBalanceCenter + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + //get the balance + TRAP(err, bal = iAudOutStream->GetBalanceL()); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + if (bal != KMMFBalanceCenter) + { + return EFail; + } + + TRAP(err, iAudOutStream->SetBalanceL(KMMFBalanceMaxRight)); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + //get the balance + TRAP(err, bal = iAudOutStream->GetBalanceL()); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + if (bal != KMMFBalanceMaxRight) + { + return EFail; + } + + TRAP(err, iAudOutStream->SetBalanceL(KMMFBalanceMaxLeft)); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + //get the balance + TRAP(err, bal = iAudOutStream->GetBalanceL()); + if (err != KErrNone) + { + return EFail; // we expect this _will_ be supported for Typhoon + } + + if (bal != KMMFBalanceMaxLeft) + { + return EFail; + } + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + + + + +CTestStepAudOutStreamSetPrior* CTestStepAudOutStreamSetPrior::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamSetPrior* self = new(ELeave) CTestStepAudOutStreamSetPrior(aTestName); + return self; + } + +CTestStepAudOutStreamSetPrior::CTestStepAudOutStreamSetPrior(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudOutStreamSetPrior::~CTestStepAudOutStreamSetPrior() + { + } + +enum TVerdict CTestStepAudOutStreamSetPrior::DoTestStepPreambleL(void) + { + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestStepAudOutStream::DoTestStepPreambleL(); + // Printing to the console and log file + INFO_PRINTF1(_L("this test is setting the audio priorities of an Audio Output Stream Utility Class")); + + // if the parent preamble fails, we must fail too + if (verdict != EPass) + { + return verdict; + } + + iAudOutStream->Open(NULL); + CActiveScheduler::Start(); + + TInt err = KErrNone; + if(iAudOutStream==NULL) + { + err = KErrNotReady; + } + + if (iError != KErrNone || + err != KErrNone) + { + return EInconclusive; + } + + + return verdict; + } + +enum TVerdict CTestStepAudOutStreamSetPrior::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepAudOutStream::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudOutStreamSetPrior::DoTestStepL() + { + // test 1 + iAudOutStream->SetPriority(EMdaPriorityMin, EMdaPriorityPreferenceTime); + + // test2 + iAudOutStream->SetPriority(EMdaPriorityMax, EMdaPriorityPreferenceQuality); + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + + + +CTestStepAudOutStreamStop* CTestStepAudOutStreamStop::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamStop* self = new(ELeave) CTestStepAudOutStreamStop(aTestName); + return self; + } + +CTestStepAudOutStreamStop::CTestStepAudOutStreamStop(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudOutStreamStop::~CTestStepAudOutStreamStop() + { + } + +enum TVerdict CTestStepAudOutStreamStop::DoTestStepPreambleL(void) + { + iTestStepResult = EPass; + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestStepAudOutStream::DoTestStepPreambleL(); + + // if the parent preamble fails, we must fail too + if (verdict != EPass) + { + return verdict; + } + + // Printing to the console and log file + INFO_PRINTF1(_L("this test is stopping a playing Audio Output Stream Utility Class: Stop()")); + + iAudOutStream->Open(NULL); + CActiveScheduler::Start(); + iAudOutStream->SetVolume(iAudOutStream->MaxVolume()>>1); // half volume + + + TInt err = KErrNone; + if(iAudOutStream==NULL) + { + err=KErrNotReady; + } + + if (iError != KErrNone || + err != KErrNone) + { + return EInconclusive; + } + + err = iFile.Open(iFs, KStreamRawFile, EFileRead); + if (err != KErrNone) + { + return EInconclusive; + } + + // start feeding the outputStream + iReadBufferActive->Read(); // finally calls CMdaAudioOutputStream::WriteL(...) + CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard); + idleStopper->Start(TCallBack(stopActiveScheduler)); + CActiveScheduler::Start(); + delete idleStopper; + + if(iAudOutStream==NULL) + { + err = KErrNotReady; + } + + if (err != KErrNone) + { + return EInconclusive; + } + + return verdict; +} + +enum TVerdict CTestStepAudOutStreamStop::DoTestStepPostambleL(void) + { + iFile.Close(); + + //[ Destroy the scheduler, delete the iAudOutStream, close the file system + return CTestStepAudOutStream::DoTestStepPostambleL(); + } + +TInt StopAudOutStream(TAny* aAudOutStream) + { + REINTERPRET_CAST(CMdaAudioOutputStream*, aAudOutStream)->Stop(); + return FALSE; + } + + +TVerdict CTestStepAudOutStreamStop::DoTestStepL() + { + TInt err = KErrNone; + // stream is playing now from preamble + // wait a fraction of the stream duration before stopping + CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(StopAudOutStream, iAudOutStream)); + callBackTimer->After(1000000); + CActiveScheduler::Start(); + + if(iAudOutStream==NULL) + { + err=KErrNotReady; + } + + if (iError != KErrCancel || // KErrAbort(?KErrCancel seems to be what is returned) is supposed to be returned ny the MaoscBufferCopied + err != KErrNone) + { + INFO_PRINTF2(_L("Test failed with error %d"), iError); + return EFail; + } + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + + + +CTestStepAudOutStreamPosition* CTestStepAudOutStreamPosition::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamPosition* self = new(ELeave) CTestStepAudOutStreamPosition(aTestName); + return self; + } + +CTestStepAudOutStreamPosition::CTestStepAudOutStreamPosition(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudOutStreamPosition::~CTestStepAudOutStreamPosition() + { + } + +enum TVerdict CTestStepAudOutStreamPosition::DoTestStepPreambleL(void) +{ + iTestStepResult = EPass; + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestStepAudOutStream::DoTestStepPreambleL(); + + // if the parent preamble fails, we must fail too + if (verdict != EPass) + { + return verdict; + } + + + // Printing to the console and log file + INFO_PRINTF1(_L("this test is getting the position of a playing Audio Output Stream Utility Class: Position()")); + + iAudOutStream->Open(NULL); + CActiveScheduler::Start(); + iAudOutStream->SetVolume(iAudOutStream->MaxVolume()>>1); // half volume + TInt err = KErrNone; + if(iAudOutStream==NULL) + { + err = KErrNotReady; + } + + if (iError != KErrNone || + err != KErrNone ) + { + return EInconclusive; + } + + err = iFile.Open(iFs, KStreamRawFile, EFileRead); + if (err != KErrNone) + { + return EInconclusive; + } + + // start feeding the outputStream + iReadBufferActive->Read(); // finally calls CMdaAudioOutputStream::WriteL(...) + CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard); + idleStopper->Start(TCallBack(stopActiveScheduler)); + CActiveScheduler::Start(); + delete idleStopper; + + if(iAudOutStream==NULL) + { + err = KErrNotReady; + } + + if (err != KErrNone) + { + return EInconclusive; + } + + return verdict; +} + + +enum TVerdict CTestStepAudOutStreamPosition::DoTestStepPostambleL(void) + { + iFile.Close(); + + //[ Destroy the scheduler, delete the iAudOutStream, close the file system + return CTestStepAudOutStream::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudOutStreamPosition::DoTestStepL() + { + if(iAudOutStream==NULL) + { + return EFail; + } + + // Get the position before and after a 5s play; + // We are asking for a two seconds play window, but due to scheduling issues etc, + // we may not get exactly what we want. However we can more accurately find out + // what we got by asking for the elapsed clock ticks during that time. + // This test fails if waittime < 5 seconds, needs more wait time to calculate accuractely + const TInt KWaitTime = 5000000; // 5s + CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler), CActive::EPriorityStandard); + callBackTimer->After(KWaitTime); + const TTimeIntervalMicroSeconds pos1 = iAudOutStream->Position(); + const TInt tick1 = User::TickCount(); + CActiveScheduler::Start(); + delete callBackTimer; + const TTimeIntervalMicroSeconds pos2 = iAudOutStream->Position(); + const TInt tick2 = User::TickCount(); + + // How much did the postion move by, and in how much time? + TInt tickPeriod = 0; + if (HAL::Get(HALData::ESystemTickPeriod, tickPeriod) != KErrNone) + { + return EInconclusive; + } + + const TInt64 KDiffPosition = pos2.Int64() - pos1.Int64(); + const TInt KElapsedTime = (tick2 - tick1) * tickPeriod; + + // Is the position diff inside an acceptable range? + const TReal KTolerance = 0.2; // 20% + const TInt KDelta = static_cast(static_cast(KElapsedTime) * KTolerance); // yuk + const TInt KMin = KElapsedTime - KDelta; + const TInt KMax = KElapsedTime + KDelta; + INFO_PRINTF5 (_L("Step One:\tActual: %ld, Expected: %d, Min: %d, Max: %d"), KDiffPosition, KElapsedTime, KMin, KMax); + if ((KDiffPosition < KMin) || (KDiffPosition > KMax)) + { + return EFail; + } + + + CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard); + idleStopper->Start(TCallBack(StopAudOutStream, iAudOutStream)); + CActiveScheduler::Start(); + delete idleStopper; + + if (iError != KErrCancel) + { + // KErrCancel (KErrAbort is supposed to be returned ny the MaoscBufferCopied??) + INFO_PRINTF2(_L("Test failed with error %d"), iError); + return EFail; + } + + + // Get the position. For a stopped stream, this should always be zero. + TTimeIntervalMicroSeconds pos = iAudOutStream->Position(); + INFO_PRINTF2(_L("Step Two:\tActual: %ld, Expected: 0"), pos.Int64()); + if (pos.Int64() != 0) + { + return EFail; + } + + + //xxx try cotinuing playing and get positions while playing if there is more time. + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return EPass; + } + + + +CTestStepAudOutStreamGetBytes* CTestStepAudOutStreamGetBytes::NewL(const TDesC& aTestName) + { + CTestStepAudOutStreamGetBytes* self = new(ELeave) CTestStepAudOutStreamGetBytes(aTestName); + return self; + } + +CTestStepAudOutStreamGetBytes::CTestStepAudOutStreamGetBytes(const TDesC& aTestName) + { + iTestStepResult = EPass; + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = aTestName; + } + +CTestStepAudOutStreamGetBytes::~CTestStepAudOutStreamGetBytes() + { + } + +enum TVerdict CTestStepAudOutStreamGetBytes::DoTestStepPreambleL(void) + { + iTestStepResult = EPass; + enum TVerdict verdict; + // this installs the scheduler + verdict = CTestStepAudOutStream::DoTestStepPreambleL(); + + // if the parent preamble fails, we must fail too + if (verdict != EPass) + { + return verdict; + } + + + // Printing to the console and log file + INFO_PRINTF1(_L("this test gets the bytes rendered by the H/W until this moment: GetBytes()")); + + iAudOutStream->Open(NULL); + CActiveScheduler::Start(); + iAudOutStream->SetVolume(iAudOutStream->MaxVolume()>>1); // half volume + + TInt err = KErrNone; + if(iAudOutStream==NULL) + { + err = KErrNotReady; + } + + if (iError != KErrNone || + err != KErrNone) + { + return EInconclusive; + } + + err = iFile.Open(iFs, KStreamRawFile, EFileRead); + if (err != KErrNone) + { + return EInconclusive; + } + + + // start feeding the outputStream + iReadBufferActive->Read(); // finally calls CMdaAudioOutputStream::WriteL(...) + CIdle* idleStopper = CIdle::NewL(CActive::EPriorityStandard); + idleStopper->Start(TCallBack(stopActiveScheduler)); + CActiveScheduler::Start(); + delete idleStopper; + + if(iAudOutStream==NULL) + { + err = KErrNotReady; + } + + if (err != KErrNone) + { + return EInconclusive; + } + + return verdict; +} + +enum TVerdict CTestStepAudOutStreamGetBytes::DoTestStepPostambleL(void) + { + iFile.Close(); + + //[ Destroy the scheduler, delete the iAudOutStream, close the file system + return CTestStepAudOutStream::DoTestStepPostambleL(); + } + +TVerdict CTestStepAudOutStreamGetBytes::DoTestStepL() + { + TInt bytes1 = iAudOutStream->GetBytes(); + CCallBackTimer* callBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler)); + callBackTimer->After(2000000); + CActiveScheduler::Start(); + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Test failed with error %d"), iError); + return EFail; + } + callBackTimer->Cancel(); // in case something else stopped the AS + TInt bytes2 = iAudOutStream->GetBytes(); + callBackTimer->After(2000000); + CActiveScheduler::Start(); + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Test failed with error %d"), iError); + return EFail; + } + delete callBackTimer; + TInt bytes3 = iAudOutStream->GetBytes(); + + TInt fileSize; + User::LeaveIfError(iFile.Size(fileSize)); + CActiveScheduler::Start(); // wait for sample to finish + TInt bytes4 = iAudOutStream->GetBytes(); + if (bytes1 >= bytes2 || bytes2 >= bytes3 || bytes3 >= bytes4) + { + return EFail; + } + + if (bytes4 != fileSize) + { + return EFail; + } + + + INFO_PRINTF1(_L("finished with this test step")); + // test steps return a result + return iTestStepResult; + } + + + + + +//------------------------------------------------------------------ + +/** + * Constructor baseclass + */ +CTestMmfAclntRecNoPlayback::CTestMmfAclntRecNoPlayback(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +void CTestMmfAclntRecNoPlayback::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecNoPlayback : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d "), iError); + + //dont stop the playing track + if (aCurrentState != CMdaAudioClipUtility::EPlaying || iError != KErrNone) + { + CActiveScheduler::Stop(); + } + + } + + +TVerdict CTestMmfAclntRecNoPlayback::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + else if(error==KErrNone) + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + else + { + ret = EInconclusive; + } + fs.Close(); + } + + if((ret == EInconclusive) || (ret == EFail)) + { + return ret; + } + + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + + +TVerdict CTestMmfAclntRecNoPlayback::DoTestStepPostambleL() + { + if(IsFileTest()) + { + // Cleanup after the test + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error != KErrNone) + { + INFO_PRINTF2(_L("Failed to delete %S"), &fullFileName.FullName()); + } + } + } + + return CTestMmfAclntStep::DoTestStepPostambleL(); + } + + + + +TVerdict CTestMmfAclntRecNoPlayback::DoTestStepL() + { + TVerdict testStatus = EPass; + TInt trapRet = KErrNone; + TInt ret = KErrNone; + + const TInt durError = 2000000; //2 second + const TInt posnError = 250000; //1/4 second + const TInt cropError = 250000; //1/4 second + + iRecorder = CMdaAudioRecorderUtilityLC(); + + if(!iRecorder) + { + testStatus = EFail; + } + + //Should always work, must be done before play or record to ensure in EPrimed state + if(testStatus == EPass) + { + TRAP(trapRet,iRecorder->SetPriority(EMdaPriorityMin,EMdaPriorityPreferenceNone)); + if(trapRet != KErrNone) + { + INFO_PRINTF2(_L("SetPriority leave with error %d"),trapRet); + testStatus = EFail; + } + } + + + + if(testStatus == EPass) + { + iError = KErrTimedOut; + iRecorder->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + User::After(KTenSeconds); + iRecorder->Stop(); + + testStatus = RecordSuccessfull(); + } + + + //Can't detect difference in these interfaces with no play controller + //void ClearPlayWindow(); + //void SetRepeats(....); + //void Pause(); + //void SetMaxWriteLength(TInt aMaxWriteLength /*= KMdaClipLocationMaxWriteLengthNone*/); + //void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration); + //void SetPlayWindow(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd); + + + + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + //These interfaces should always WORK if there is a record or playback controller + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds setPosn(KTwoSeconds); + + iRecorder->SetPosition(setPosn); + TTimeIntervalMicroSeconds getPosn = iRecorder->Position(); + INFO_PRINTF3(_L("got position %d should be %d"),I64LOW(getPosn.Int64()), KTwoSeconds); + + if((getPosn.Int64() < setPosn.Int64()-posnError) && + (getPosn.Int64() > setPosn.Int64()+posnError)) + { + INFO_PRINTF1(_L("Position fail")); + testStatus = EFail; + } + } + + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds duration = iRecorder->Duration(); + INFO_PRINTF3(_L("got duration %d should be %d"),I64LOW(duration.Int64()), KTenSeconds); + + if((duration.Int64() > KTenSeconds+durError) || + (duration.Int64() < KTenSeconds-durError)) + { + INFO_PRINTF1(_L("Duration fail")); + } + } + + + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + //These interfaces should WORK if there is a record controller but no playback controller + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + if(testStatus == EPass) + { + TInt gain; + iRecorder->SetGain(2); + + ret = iRecorder->GetGain(gain); + if((ret != KErrNone) || (gain != 2)) + { + INFO_PRINTF1(_L("Gain fail")); + testStatus = EFail; + } + } + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds croppedDuration; + TTimeIntervalMicroSeconds originalDuration; + TTimeIntervalMicroSeconds setPosn(KTwoSeconds); + iRecorder->SetPosition(setPosn); + + originalDuration = iRecorder->Duration(); + + if((originalDuration.Int64() > KTenSeconds+durError) || + (originalDuration.Int64() < KTenSeconds-durError)) + { + INFO_PRINTF1(_L("getting Duration for CropL fail")); + testStatus = EFail; + } + else + { + TRAP(trapRet, iRecorder->CropFromBeginningL()); + if(trapRet == KErrNone) + { + croppedDuration = iRecorder->Duration(); + INFO_PRINTF3(_L("got duration %d should be %d"),I64LOW(croppedDuration.Int64()), originalDuration.Int64()-KTwoSeconds); + } + if((trapRet != KErrNone) || + ((croppedDuration.Int64() > originalDuration.Int64()-KTwoSeconds+cropError) || + (croppedDuration.Int64() < originalDuration.Int64()-KTwoSeconds-cropError))) + { + INFO_PRINTF1(_L("Crop fail")); + testStatus = EFail; + } + } + } + + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds zero(0); + + TTimeIntervalMicroSeconds recTimeAvail = iRecorder->RecordTimeAvailable(); + if(recTimeAvail == zero) + { + INFO_PRINTF1(_L("RecordTimeAvailable fail")); + testStatus = EFail; + } + } + + + if(testStatus == EPass) + { + TInt bal = KMMFBalanceMaxRight; + ret = iRecorder->SetRecordBalance(KMMFBalanceMaxLeft); + if(ret == KErrNone) + { + bal = KMMFBalanceMaxRight; + ret = iRecorder->GetRecordBalance(bal); + } + if((bal != KMMFBalanceMaxLeft) || (ret != KErrNone)) + { + INFO_PRINTF1(_L("Balance tests fail")); + testStatus = EFail; + } + } + + //Haven't got a format that supports these - trace into code. + /* + if(testStatus == EPass) + { + TInt metaEntries; + CMMFMetaDataEntry* metaEntry = NULL; + CMMFMetaDataEntry* newMetaEntry = CMMFMetaDataEntry::NewL(_L("dummy meta"), _L("dummy val")); + + iRecorder->GetNumberOfMetaDataEntries(metaEntries); + TRAP(trapRet, metaEntry = iRecorder->GetMetaDataEntryL(1)); + TRAP(trapRet, iRecorder->AddMetaDataEntryL(*newMetaEntry)); + TRAP(trapRet, iRecorder->ReplaceMetaDataEntryL(1, *newMetaEntry)); + iRecorder->RemoveMetaDataEntry(1); + } + */ + + + if(testStatus == EPass) + { + RArray codecs; + TRAP(trapRet, iRecorder->GetSupportedDestinationDataTypesL(codecs)); + if((trapRet == KErrNone) && (codecs.Count() > 0) && IsFileTest()) + { + TRAP(trapRet, iRecorder->SetDestinationDataTypeL(codecs[0])); + } + + if((trapRet == KErrNone) && (codecs.Count() > 0)) + { + TFourCC dataType; + TRAP(trapRet, dataType = iRecorder->DestinationDataTypeL()); + if((trapRet != KErrNone) || (IsFileTest() && (dataType != codecs[0]))) + testStatus = EFail; + } + + if((trapRet != KErrNone) || (testStatus == EFail)) + { + INFO_PRINTF1(_L("DestinationDataTypes fail")); + testStatus = EFail; + } + } + + + //These methods are not available for our formats and will therefore always fail - trace into code + /* + if(testStatus == EPass) + { + RArray bitRates; + TUint bitRate = 0; + + TRAP(trapRet, iRecorder->GetSupportedBitRatesL(bitRates)); + if((trapRet == KErrNone) && (bitRates.Count() >0)) + TRAP(trapRet, iRecorder->SetDestinationBitRateL(bitRates[0])); + if((trapRet == KErrNone) && (bitRates.Count() >0)) + TRAP(trapRet, bitRate = iRecorder->DestinationBitRateL()); + + if((trapRet != KErrNone) || (bitRate != bitRates[0])) + { + INFO_PRINTF1(_L("BitRates fail")); + testStatus = EFail; + } + } + */ + + if(testStatus == EPass) + { + RArray sampleRates; + TUint sampleRate = 0; + + TRAP(trapRet, iRecorder->GetSupportedSampleRatesL(sampleRates)); + if((trapRet == KErrNone) && (sampleRates.Count() >0)) + { + TRAP(trapRet, iRecorder->SetDestinationSampleRateL(sampleRates[0])); + } + + if((trapRet == KErrNone) && (sampleRates.Count() >0)) + { + TRAP(trapRet, sampleRate = iRecorder->DestinationSampleRateL()); + } + + if((trapRet != KErrNone) || (sampleRate != sampleRates[0])) + { + INFO_PRINTF1(_L("SampleRates fail")); + testStatus = EFail; + } + } + + + + if(testStatus == EPass) + { + RArray channels; + TUint channel = 0; + + TRAP(trapRet, iRecorder->GetSupportedNumberOfChannelsL(channels)); + if((trapRet == KErrNone) && (channels.Count() >0)) + { + TRAP(trapRet, iRecorder->SetDestinationNumberOfChannelsL(channels[0])); + } + + if((trapRet == KErrNone) && (channels.Count() >0)) + { + TRAP(trapRet, channel = iRecorder->DestinationNumberOfChannelsL()); + } + + if((trapRet != KErrNone) || (channel != channels[0])) + { + INFO_PRINTF1(_L("channels fail")); + testStatus = EFail; + } + } + + + if(testStatus == EPass) + { + TUid currentFormat = KNullUid; + + TRAP(trapRet, currentFormat = iRecorder->DestinationFormatL()); + + /*can't do this, causes segmentation violation - trace into code + TUid newFormat = {KMmfUidFormatRAWWrite}; + if(trapRet == KErrNone) + TRAP(trapRet, iRecorder->SetDestinationFormatL(newFormat)); + if(trapRet == KErrNone) + TRAP(trapRet, iRecorder->SetDestinationFormatL(currentFormat)); + */ + + if(trapRet != KErrNone) + { + INFO_PRINTF1(_L("format fail")); + testStatus = EFail; + } + } + + +// These would pass when a record controller is present, also need test controller - trace into code +// TInt RecordControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom); +// TInt RecordControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2); +// void RecordControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus); +// void RecordControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus); + + + + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + //These interfaces should FAIL if there is a record controller but no playback controller + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + if(testStatus == EPass) + { + TRAP(trapRet, iRecorder->PlayL()) + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("Play fail")); + testStatus = EFail; + } + } + + + if(testStatus == EPass) + { + TInt maxVol = iRecorder->MaxVolume(); + if(maxVol != 0) + { + INFO_PRINTF1(_L("MaxVolume fail")); + testStatus = EFail; + } + } + + + if(testStatus == EPass) + { + iRecorder->SetVolume(1); + + TInt vol; + ret = iRecorder->GetVolume(vol); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("GetVolume fail")); + testStatus = EFail; + } + } + + if(testStatus == EPass) + { + TInt bal; + TInt ret = iRecorder->SetPlaybackBalance(KMMFBalanceMaxRight); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("SetPlaybackBalance fail")); + testStatus = EFail; + } + + ret = iRecorder->GetPlaybackBalance(bal); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("GetPlaybackBalance fail")); + testStatus = EFail; + } + } + + + + if(testStatus == EPass) + { + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = 100; + TBuf8<8> dummyBuff; + + ret = iRecorder->PlayControllerCustomCommandSync(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("PlayControllerCustomCommandSync - 1 fail")); + testStatus = EFail; + } + + ret = iRecorder->PlayControllerCustomCommandSync(dummyPckg, dummyFunc, dummyBuff, dummyBuff); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("PlayControllerCustomCommandSync -2 fail")); + testStatus = EFail; + } + + CTestMmfAclntAOCallback* aoCallback = new CTestMmfAclntAOCallback(this); + CleanupStack::PushL(aoCallback); + aoCallback->PublicSetActive(); + + + iRecorder->PlayControllerCustomCommandAsync(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff, aoCallback->iStatus); + CActiveScheduler::Start(); + + if(iError != KErrNotSupported) + { + INFO_PRINTF1(_L("PlayControllerCustomCommandAsync -1 fail")); + testStatus = EFail; + } + + aoCallback->PublicSetActive(); + iRecorder->PlayControllerCustomCommandAsync(dummyPckg, dummyFunc, dummyBuff, dummyBuff, aoCallback->iStatus); + CActiveScheduler::Start(); + + if(iError != KErrNotSupported) + { + INFO_PRINTF1(_L("PlayControllerCustomCommandAsync -2 fail")); + testStatus = EFail; + } + + CleanupStack::Pop(aoCallback); + } + + + + + CleanupStack::PopAndDestroy(iRecorder); + User::After(KOneSecond); + return testStatus; + } + + + + + + + + + + + + + + + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecNoPlaybackForceFormat::CTestMmfAclntRecNoPlaybackForceFormat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) +: CTestMmfAclntRecNoPlayback(aTestName, aSectName, aKeyName) + { + iFormat = aFormat; + } + +CTestMmfAclntRecNoPlaybackForceFormat* CTestMmfAclntRecNoPlaybackForceFormat::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoPlaybackForceFormat* self = new (ELeave) CTestMmfAclntRecNoPlaybackForceFormat(aTestName,aSectName,aKeyName,aFormat); + return self; + } + +CTestMmfAclntRecNoPlaybackForceFormat* CTestMmfAclntRecNoPlaybackForceFormat::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoPlaybackForceFormat* self = CTestMmfAclntRecNoPlaybackForceFormat::NewLC(aTestName,aSectName,aKeyName,aFormat); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoPlaybackForceFormat::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a file and forcing format")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + return NULL; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TMdaFileClipLocation location(iFilename); + + recUtil->OpenL(&location,&iFormat); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + return recUtil; + } + +TVerdict CTestMmfAclntRecNoPlaybackForceFormat::RecordSuccessfull() + { + TVerdict testStatus = EPass; + + if(iError == KErrNone) + { + RFs fs; + RFile file; + TInt size = 0; + + iError = fs.Connect(); + if (iError == KErrNone) + { + iError = file.Open(fs,iFilename,EFileRead); + + if (iError == KErrNone) + { + iError = file.Size(size); + + if (iError != KErrNone) + { + INFO_PRINTF1(_L("Unable to get size of file!")); + } + } + else + { + INFO_PRINTF1(_L("Unable to open file.")); + return EInconclusive; + } + + } + else + { + INFO_PRINTF1(_L("Unable to connect to file system.")); + return EInconclusive; + } + + if(size == 0) + { + testStatus = EFail; + } + + + file.Close(); + fs.Close(); + CleanupStack::PopAndDestroy(); //file + } + else + testStatus = EFail; + + return testStatus; + } + + + +CTestMmfAclntRecNoPlaybackForceFormatDesc* CTestMmfAclntRecNoPlaybackForceFormatDesc::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoPlaybackForceFormatDesc* self = new (ELeave) CTestMmfAclntRecNoPlaybackForceFormatDesc(aTestName,aSectName,aKeyName,aFormat); + return self; + } + +CTestMmfAclntRecNoPlaybackForceFormatDesc* CTestMmfAclntRecNoPlaybackForceFormatDesc::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoPlaybackForceFormatDesc* self = CTestMmfAclntRecNoPlaybackForceFormatDesc::NewLC(aTestName,aSectName,aKeyName,aFormat); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoPlaybackForceFormatDesc::CMdaAudioRecorderUtilityLC() + { + const TInt KMaxFileSize = 200000; + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a descriptor and forcing format")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + User::Leave(KErrNotFound); + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + + HBufC8* iBuf = HBufC8::NewL( KMaxFileSize ); + CleanupStack::PushL(iBuf); + + iFileDesc = new (ELeave) TPtr8( NULL, 0 ); + CleanupStack::PushL(iFileDesc); + + iFileDesc->Set( iBuf->Des()); + + + TMdaDesClipLocation location(*iFileDesc); + + recUtil->OpenL(&location,&iFormat); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + User::Leave(KErrNotFound); + } + + CleanupStack::Pop(iFileDesc); + CleanupStack::Pop(iBuf); + return recUtil; + } + +TVerdict CTestMmfAclntRecNoPlaybackForceFormatDesc::RecordSuccessfull() + { + TVerdict testStatus = EPass; + + TInt len = iFileDesc->Length(); + + if(len == 0) + { + testStatus = EFail; + } + + return testStatus; + } + + + + +//------------------------------------------------------------------ + + +CTestMmfAclntRecNoPlaybackFile* CTestMmfAclntRecNoPlaybackFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoPlaybackFile* self = new (ELeave) CTestMmfAclntRecNoPlaybackFile(aTestName,aSectName,aKeyName); + return self; + } + +CTestMmfAclntRecNoPlaybackFile* CTestMmfAclntRecNoPlaybackFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoPlaybackFile* self = CTestMmfAclntRecNoPlaybackFile::NewLC(aTestName,aSectName,aKeyName); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoPlaybackFile::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a file")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + return NULL; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + recUtil->OpenFileL(iFilename); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + return recUtil; + } + +TVerdict CTestMmfAclntRecNoPlaybackFile::RecordSuccessfull() + { + TVerdict testStatus = EPass; + + if(iError == KErrNone) + { + RFs fs; + RFile file; + TInt size = 0; + + iError = fs.Connect(); + if (iError == KErrNone) + { + iError = file.Open(fs,iFilename,EFileRead); + + if (iError == KErrNone) + { + iError = file.Size(size); + + if (iError != KErrNone) + { + INFO_PRINTF1(_L("Unable to get size of file!")); + } + } + else + { + INFO_PRINTF1(_L("Unable to open file.")); + return EInconclusive; + } + + } + else + { + INFO_PRINTF1(_L("Unable to connect to file system.")); + return EInconclusive; + } + + if(size == 0) + { + testStatus = EFail; + } + + + file.Close(); + fs.Close(); + CleanupStack::PopAndDestroy(); //file + } + + else + testStatus = EFail; + + return testStatus; + } + + + + +CTestMmfAclntRecNoPlaybackDesc* CTestMmfAclntRecNoPlaybackDesc::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoPlaybackDesc* self = new (ELeave) CTestMmfAclntRecNoPlaybackDesc(aTestName,aSectName,aKeyName); + return self; + } + +CTestMmfAclntRecNoPlaybackDesc* CTestMmfAclntRecNoPlaybackDesc::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoPlaybackDesc* self = CTestMmfAclntRecNoPlaybackDesc::NewLC(aTestName,aSectName,aKeyName); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoPlaybackDesc::CMdaAudioRecorderUtilityLC() + { + const TInt KMaxFileSize = 200000; + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a descriptor")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + User::Leave(KErrNotFound); + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + + HBufC8* iBuf = HBufC8::NewL( KMaxFileSize ); + CleanupStack::PushL(iBuf); + + iFileDesc = new (ELeave) TPtr8( NULL, 0 ); + CleanupStack::PushL(iFileDesc); + + iFileDesc->Set( iBuf->Des()); + + //Put some contents (one sample wav file) into the descriptor + TPtrC oneSampleFileName; + if(!GetStringFromConfig(iSectName, _L("OneSampleFile"), oneSampleFileName)) + { + User::Leave(KErrNotFound); + } + + RFs fs; + RFile file; + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,oneSampleFileName,EFileRead)); + CleanupClosePushL(file); + if(file.Read(*iFileDesc) != KErrNone) + { + User::Leave(KErrNotFound); + } + CleanupStack::PopAndDestroy(&file); + + + recUtil->OpenDesL(*iFileDesc); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + User::Leave(KErrNotFound); + } + + CleanupStack::Pop(iFileDesc); + CleanupStack::Pop(iBuf); + return recUtil; + } + +TVerdict CTestMmfAclntRecNoPlaybackDesc::RecordSuccessfull() + { + TVerdict testStatus = EPass; + + TInt len = iFileDesc->Length(); + + if(len == 0) + { + testStatus = EFail; + } + + return testStatus; + } + + + + +CTestMmfAclntRecNoPlaybackFileForceController* CTestMmfAclntRecNoPlaybackFileForceController::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoPlaybackFileForceController* self = new (ELeave) CTestMmfAclntRecNoPlaybackFileForceController(aTestName,aSectName,aKeyName, aController); + return self; + } + +CTestMmfAclntRecNoPlaybackFileForceController* CTestMmfAclntRecNoPlaybackFileForceController::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoPlaybackFileForceController* self = CTestMmfAclntRecNoPlaybackFileForceController::NewLC(aTestName,aSectName,aKeyName,aController); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoPlaybackFileForceController::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a file, forcing record controller")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + return NULL; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + recUtil->OpenFileL(iFilename,iController); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + return recUtil; + } + +TVerdict CTestMmfAclntRecNoPlaybackFileForceController::RecordSuccessfull() + { + TVerdict testStatus = EPass; + + if(iError == KErrNone) + { + RFs fs; + RFile file; + TInt size = 0; + + iError = fs.Connect(); + if (iError == KErrNone) + { + iError = file.Open(fs,iFilename,EFileRead); + + if (iError == KErrNone) + { + iError = file.Size(size); + + if (iError != KErrNone) + { + INFO_PRINTF1(_L("Unable to get size of file!")); + } + } + else + { + INFO_PRINTF1(_L("Unable to open file.")); + return EInconclusive; + } + + } + else + { + INFO_PRINTF1(_L("Unable to connect to file system.")); + return EInconclusive; + } + + if(size == 0) + { + testStatus = EFail; + } + + file.Close(); + fs.Close(); + CleanupStack::PopAndDestroy(); //file + } + else + testStatus = EFail; + + return testStatus; + } + + + + +CTestMmfAclntRecNoPlaybackDescForceController* CTestMmfAclntRecNoPlaybackDescForceController::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoPlaybackDescForceController* self = new (ELeave) CTestMmfAclntRecNoPlaybackDescForceController(aTestName,aSectName,aKeyName,aController); + return self; + } + +CTestMmfAclntRecNoPlaybackDescForceController* CTestMmfAclntRecNoPlaybackDescForceController::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoPlaybackDescForceController* self = CTestMmfAclntRecNoPlaybackDescForceController::NewLC(aTestName,aSectName,aKeyName,aController); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoPlaybackDescForceController::CMdaAudioRecorderUtilityLC() + { + const TInt KMaxFileSize = 200000; + + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a descriptor, forcing record controller")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + User::Leave(KErrNotFound); + } + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + + HBufC8* iBuf = HBufC8::NewL( KMaxFileSize ); + CleanupStack::PushL(iBuf); + + iFileDesc = new (ELeave) TPtr8( NULL, 0 ); + CleanupStack::PushL(iFileDesc); + + iFileDesc->Set( iBuf->Des()); + + + //Put some contents (one sample wav file) into the descriptor + TPtrC oneSampleFileName; + if(!GetStringFromConfig(iSectName, _L("OneSampleFile"), oneSampleFileName)) + { + User::Leave(KErrNotFound); + } + + RFs fs; + RFile file; + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,oneSampleFileName,EFileRead)); + CleanupClosePushL(file); + if(file.Read(*iFileDesc) != KErrNone) + { + User::Leave(KErrNotFound); + } + CleanupStack::PopAndDestroy(&file); + + + recUtil->OpenDesL(*iFileDesc, iController); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + User::Leave(KErrNotFound); + } + + CleanupStack::Pop(iFileDesc); + CleanupStack::Pop(iBuf); + return recUtil; + } + +TVerdict CTestMmfAclntRecNoPlaybackDescForceController::RecordSuccessfull() + { + TVerdict testStatus = EPass; + + TInt len = iFileDesc->Length(); + + if(len == 0) + { + testStatus = EFail; + } + + return testStatus; + } + + + + + + + + +//------------------------------------------------------------------ +/** + * Constructor baseclass + */ +CTestMmfAclntRecNoRecord::CTestMmfAclntRecNoRecord(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + } + +void CTestMmfAclntRecNoRecord::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecNoRecord : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d "), iError); + + //dont stop the playing track + if (aCurrentState != CMdaAudioClipUtility::EPlaying || iError != KErrNone) + { + CActiveScheduler::Stop(); + } + } + +TVerdict CTestMmfAclntRecNoRecord::DoTestStepPreambleL() + { + // Make sure file exists + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Open(fs,filename1,EFileRead)); + file.Close(); + fs.Close(); + } + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + + + + +TVerdict CTestMmfAclntRecNoRecord::DoTestStepL() + { + TVerdict testStatus = EPass; + TInt trapRet = KErrNone; + TInt ret = KErrNone; + + const TInt durError = 2500; //As best as could be read from Goldwave + const TInt posError = 250; + const TInt MainTst_KDur = 8359100; //MainTst.wav = 8.3591 sec from GoldWave + + iRecorder = CMdaAudioRecorderUtilityLC(); + + if(!iRecorder) + { + testStatus = EFail; + } + + + //Should always work, must be done before play or record to ensure in EPrimed state + if(testStatus == EPass) + { + TRAP(trapRet,iRecorder->SetPriority(EMdaPriorityMin,EMdaPriorityPreferenceNone)); + if(trapRet != KErrNone) + { + INFO_PRINTF2(_L("SetPriority leave with error %d"),trapRet); + testStatus = EFail; + } + } + + + + if(testStatus == EPass) + { + iError = KErrTimedOut; + iRecorder->PlayL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + testStatus = PlaySuccessfull(); + } + + + //Can't detect difference in these interfaces + //void ClearPlayWindow(); + //void SetRepeats(....); + //void Pause(); + //void SetMaxWriteLength(TInt aMaxWriteLength /*= KMdaClipLocationMaxWriteLengthNone*/); + //void SetVolume(TInt aVolume); + //void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration); + + + + + + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + //These interfaces should always WORK if there is a record or playback controller + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + //if no rec controller, report playback duration. + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds duration = iRecorder->Duration(); + + if((duration.Int64() > MainTst_KDur + durError) || + (duration.Int64() < MainTst_KDur - durError)) + { + INFO_PRINTF1(_L("Duration fail")); + testStatus = EFail; + } + } + + + //returns rec values if rec controller, else playback values + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds setPosn(KTwoSeconds); + + iRecorder->SetPosition(setPosn); + TTimeIntervalMicroSeconds getPosn = iRecorder->Position(); + INFO_PRINTF3(_L("got position %d should be %d"),I64LOW(getPosn.Int64()), KTwoSeconds); + + if((getPosn.Int64() > KTwoSeconds+posError) || + (getPosn.Int64() < KTwoSeconds-posError)) + { + INFO_PRINTF1(_L("Position fail")); + testStatus = EFail; + } + } + + + + + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + //These interfaces should FAIL if there is a playback controller, but no record controller + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + if(testStatus == EPass) + { + TInt gain; + iRecorder->SetGain(1); + + ret = iRecorder->GetGain(gain); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("Gain fail")); + testStatus = EFail; + } + } + + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds setPosn(KTwoSeconds); + iRecorder->SetPosition(setPosn); + + TRAP(trapRet, iRecorder->CropFromBeginningL()); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("Crop fail")); + testStatus = EFail; + } + } + + if(testStatus == EPass) + { + TTimeIntervalMicroSeconds zero(0); + + TTimeIntervalMicroSeconds recTimeAvail = iRecorder->RecordTimeAvailable(); + if(recTimeAvail != zero) + { + INFO_PRINTF1(_L("RecordTimeAvailable fail")); + testStatus = EFail; + } + } + + + if(testStatus == EPass) + { + TInt bal = KMMFBalanceMaxRight; + ret = iRecorder->SetRecordBalance(KMMFBalanceMaxLeft); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("SetRecordBalance test failed")); + testStatus = EFail; + } + + ret = iRecorder->GetRecordBalance(bal); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("GetRecordBalance test failed")); + testStatus = EFail; + } + } + + + //Haven't got a format that supports these - trace into code. + /* + if(testStatus == EPass) + { + TInt metaEntries; + CMMFMetaDataEntry* metaEntry = NULL; + CMMFMetaDataEntry* newMetaEntry = CMMFMetaDataEntry::NewL(_L("dummy meta"), _L("dummy val")); + + iRecorder->GetNumberOfMetaDataEntries(metaEntries); + TRAP(trapRet, metaEntry = iRecorder->GetMetaDataEntryL(1)); + TRAP(trapRet, iRecorder->AddMetaDataEntryL(*newMetaEntry)); + TRAP(trapRet, iRecorder->ReplaceMetaDataEntryL(1, *newMetaEntry)); + iRecorder->RemoveMetaDataEntry(1); + } + */ + + + if(testStatus == EPass) + { + RArray codecs; + TRAP(trapRet, iRecorder->GetSupportedDestinationDataTypesL(codecs)); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("GetSupportedDestinationDataTypesL test failed")); + testStatus = EFail; + } + + TFourCC dataType; + TRAP(trapRet, iRecorder->SetDestinationDataTypeL(dataType)); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("SetDestinationDataTypeL test failed")); + testStatus = EFail; + } + + TRAP(trapRet, dataType = iRecorder->DestinationDataTypeL()); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("DestinationDataTypeL test failed")); + testStatus = EFail; + } + } + + + //These methods are not available for our formats and will therefore always fail - trace into code. + /* + if(testStatus == EPass) + { + RArray bitRates; + TUint bitRate = 0; + + TRAP(trapRet, iRecorder->GetSupportedBitRatesL(bitRates)); + if((trapRet == KErrNone) && (bitRates.Count() >0)) + TRAP(trapRet, iRecorder->SetDestinationBitRateL(bitRates[0])); + if((trapRet == KErrNone) && (bitRates.Count() >0)) + TRAP(trapRet, bitRate = iRecorder->DestinationBitRateL()); + + if((trapRet != KErrNone) || (bitRate != bitRates[0])) + { + INFO_PRINTF1(_L("BitRates fail")); + testStatus = EFail; + } + } + */ + + if(testStatus == EPass) + { + RArray sampleRates; + TUint sampleRate = 0; + + TRAP(trapRet, iRecorder->GetSupportedSampleRatesL(sampleRates)); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("GetSupportedSampleRatesL test failed")); + testStatus = EFail; + } + + sampleRate = 8000; + TRAP(trapRet, iRecorder->SetDestinationSampleRateL(sampleRate)); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("SetDestinationSampleRateL test failed")); + testStatus = EFail; + } + + TRAP(trapRet, sampleRate = iRecorder->DestinationSampleRateL()); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("DestinationSampleRateL test failed")); + testStatus = EFail; + } + } + + + + if(testStatus == EPass) + { + RArray channels; + TUint channel = 0; + + TRAP(trapRet, iRecorder->GetSupportedNumberOfChannelsL(channels)); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("GetSupportedNumberOfChannelsL test failed")); + testStatus = EFail; + } + + + TRAP(trapRet, iRecorder->SetDestinationNumberOfChannelsL(1)); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("SetDestinationNumberOfChannelsL test failed")); + testStatus = EFail; + } + + TRAP(trapRet, channel=iRecorder->DestinationNumberOfChannelsL()); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF2(_L("DestinationNumberOfChannelsL test failed with channel %d"), channel); + testStatus = EFail; + } + } + + + if(testStatus == EPass) + { + TUid currentFormat = KNullUid; + + TRAP(trapRet, currentFormat = iRecorder->DestinationFormatL()); + if(trapRet != KErrNotSupported) + { + INFO_PRINTF1(_L("DestinationFormatL test failed")); + testStatus = EFail; + } + + //NB: Can't do this test here, as it causes seg violation - trace into code + /* + TUid newFormat = {KMmfUidFormatRAWWrite}; + if(trapRet == KErrNone) + TRAP(trapRet, iRecorder->SetDestinationFormatL(newFormat)); + if(trapRet == KErrNone) + TRAP(trapRet, iRecorder->SetDestinationFormatL(currentFormat)); + */ + } + + + + if(testStatus == EPass) + { + TMMFMessageDestinationPckg dummyPckg; + TInt dummyFunc = 100; + TBuf8<8> dummyBuff; + + ret = iRecorder->RecordControllerCustomCommandSync(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("RecordControllerCustomCommandSync - 1 fail")); + testStatus = EFail; + } + + ret = iRecorder->RecordControllerCustomCommandSync(dummyPckg, dummyFunc, dummyBuff, dummyBuff); + if(ret != KErrNotSupported) + { + INFO_PRINTF1(_L("RecordControllerCustomCommandSync -2 fail")); + testStatus = EFail; + } + + CTestMmfAclntAOCallback* aoCallback = new CTestMmfAclntAOCallback(this); + CleanupStack::PushL(aoCallback); + + aoCallback->PublicSetActive(); + iRecorder->RecordControllerCustomCommandAsync(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff, aoCallback->iStatus); + CActiveScheduler::Start(); + + if(iError != KErrNotSupported) + { + INFO_PRINTF1(_L("RecordControllerCustomCommandAsync -1 fail")); + testStatus = EFail; + } + + aoCallback->PublicSetActive(); + iRecorder->RecordControllerCustomCommandAsync(dummyPckg, dummyFunc, dummyBuff, dummyBuff, aoCallback->iStatus); + CActiveScheduler::Start(); + + if(iError != KErrNotSupported) + { + INFO_PRINTF1(_L("RecordControllerCustomCommandAsync -2 fail")); + testStatus = EFail; + } + + CleanupStack::Pop(aoCallback); + } + + + + + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + //These interfaces should PASS if there is a playback controller, but no record controller + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + if(testStatus == EPass) + { + const TUint KPlayError = 500000; //1/2 second in play duration + + TTimeIntervalMicroSeconds duration = iRecorder->Duration(); + + iRecorder->SetPlayWindow(duration.Int64()/2, duration); + + iError = KErrTimedOut; + iRecorder->PlayL(); + + TTime startTime; startTime.UniversalTime(); + + CActiveScheduler::Start(); + + TTime endTime; endTime.UniversalTime(); + + TInt64 playTime = endTime.Int64() - startTime.Int64(); + + INFO_PRINTF3(_L("Expected to play for %d Usec, played for %d Usec"), I64LOW(duration.Int64()/2), I64LOW(playTime)); + + if((I64LOW(playTime) > I64LOW(duration.Int64()/2 + KPlayError)) || + (I64LOW(playTime) < I64LOW(duration.Int64()/2 - KPlayError))) + { + INFO_PRINTF1(_L("SetPlayWindow fail")); + testStatus = EFail; + } + else + { + testStatus = PlaySuccessfull(); + } + } + + if(testStatus == EPass) + { + TInt maxVol = iRecorder->MaxVolume(); + if(maxVol > 0) + { + iRecorder->SetVolume(maxVol/2); + TInt vol; + ret = iRecorder->GetVolume(vol); + if((ret != KErrNone) || (vol != maxVol/2)) + { + INFO_PRINTF1(_L("GetVolume fail")); + testStatus = EFail; + } + } + else + { + INFO_PRINTF1(_L("MaxVolume fail")); + testStatus = EFail; + } + + } + + if(testStatus == EPass) + { + TInt bal; + TInt ret = iRecorder->SetPlaybackBalance(KMMFBalanceMaxRight); + if(ret == KErrNone) + { + ret = iRecorder->GetPlaybackBalance(bal); + if((ret != KErrNone) || (bal != KMMFBalanceMaxRight)) + { + INFO_PRINTF1(_L("GetPlaybackBalance fail")); + testStatus = EFail; + } + } + else + { + INFO_PRINTF1(_L("SetPlaybackBalance fail")); + testStatus = EFail; + } + } + + + +// These would pass when a playback controller is present, also need test controller +// TInt PlayControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom); +// TInt PlayControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2); +// void PlayControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus); +// void PlayControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus); + + CleanupStack::PopAndDestroy(iRecorder); + User::After(KOneSecond); + return testStatus; + } + + + + + + + + + + + + + + +//------------------------------------------------------------------ + +/** + * Constructor + */ + +CTestMmfAclntRecNoRecordForceFormat::CTestMmfAclntRecNoRecordForceFormat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) +: CTestMmfAclntRecNoRecord(aTestName, aSectName, aKeyName) + { + iFormat = aFormat; + } + +CTestMmfAclntRecNoRecordForceFormat* CTestMmfAclntRecNoRecordForceFormat::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoRecordForceFormat* self = new (ELeave) CTestMmfAclntRecNoRecordForceFormat(aTestName,aSectName,aKeyName,aFormat); + return self; + } + +CTestMmfAclntRecNoRecordForceFormat* CTestMmfAclntRecNoRecordForceFormat::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoRecordForceFormat* self = CTestMmfAclntRecNoRecordForceFormat::NewLC(aTestName,aSectName,aKeyName,aFormat); + CleanupStack::PushL(self); + return self; + } + + + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoRecordForceFormat::CMdaAudioRecorderUtilityLC() + { + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + return NULL; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TMdaFileClipLocation location(iFilename); + + recUtil->OpenL(&location,&iFormat); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + return recUtil; + } + +TVerdict CTestMmfAclntRecNoRecordForceFormat::PlaySuccessfull() + { + TVerdict testStatus = EPass; + + if(iError != KErrNone) + { + testStatus = EFail; + } + + return testStatus; + } + + + + +CTestMmfAclntRecNoRecordForceFormatDesc* CTestMmfAclntRecNoRecordForceFormatDesc::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoRecordForceFormatDesc* self = new (ELeave) CTestMmfAclntRecNoRecordForceFormatDesc(aTestName,aSectName,aKeyName,aFormat); + return self; + } + +CTestMmfAclntRecNoRecordForceFormatDesc* CTestMmfAclntRecNoRecordForceFormatDesc::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TMdaClipFormat& aFormat) + { + CTestMmfAclntRecNoRecordForceFormatDesc* self = CTestMmfAclntRecNoRecordForceFormatDesc::NewLC(aTestName,aSectName,aKeyName,aFormat); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoRecordForceFormatDesc::CMdaAudioRecorderUtilityLC() + { + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + User::Leave(KErrNotFound); + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + + RFs fs; + RFile file; + TInt size = 0; + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,iFilename,EFileRead)); + CleanupClosePushL(file); + User::LeaveIfError(file.Size(size)); + + if(size == 0) + { + User::Leave(KErrNotFound); + } + + HBufC8* iBuf = HBufC8::NewL( size ); + CleanupStack::PushL(iBuf); + + iFileDesc = new (ELeave) TPtr8( NULL, 0 ); + CleanupStack::PushL(iFileDesc); + + iFileDesc->Set( iBuf->Des()); + + if(file.Read(*iFileDesc) != KErrNone) + { + User::Leave(KErrNotFound); + } + + TMdaDesClipLocation location(*iFileDesc); + + recUtil->OpenL(&location,&iFormat); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + User::Leave(KErrNotFound); + } + + CleanupStack::Pop(iFileDesc); + CleanupStack::Pop(iBuf); + CleanupStack::PopAndDestroy(&file); + return recUtil; + } + + +TVerdict CTestMmfAclntRecNoRecordForceFormatDesc::PlaySuccessfull() + { + TVerdict testStatus = EPass; + + if(iError != KErrNone) + { + testStatus = EFail; + } + + return testStatus; + } + + +//------------------------------------------------------------------ + + +CTestMmfAclntRecNoRecordFile* CTestMmfAclntRecNoRecordFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoRecordFile* self = new (ELeave) CTestMmfAclntRecNoRecordFile(aTestName,aSectName,aKeyName); + return self; + } + +CTestMmfAclntRecNoRecordFile* CTestMmfAclntRecNoRecordFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoRecordFile* self = CTestMmfAclntRecNoRecordFile::NewLC(aTestName,aSectName,aKeyName); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoRecordFile::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a file")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + return NULL; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + recUtil->OpenFileL(iFilename); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + return recUtil; + } + +TVerdict CTestMmfAclntRecNoRecordFile::PlaySuccessfull() + { + TVerdict testStatus = EPass; + + if(iError != KErrNone) + { + testStatus = EFail; + } + + return testStatus; + } + + + + +CTestMmfAclntRecNoRecordDesc* CTestMmfAclntRecNoRecordDesc::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoRecordDesc* self = new (ELeave) CTestMmfAclntRecNoRecordDesc(aTestName,aSectName,aKeyName); + return self; + } + +CTestMmfAclntRecNoRecordDesc* CTestMmfAclntRecNoRecordDesc::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName) + { + CTestMmfAclntRecNoRecordDesc* self = CTestMmfAclntRecNoRecordDesc::NewLC(aTestName,aSectName,aKeyName); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoRecordDesc::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a descriptor")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + User::Leave(KErrNotFound); + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + + RFs fs; + RFile file; + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,iFilename,EFileRead)); + CleanupClosePushL(file); + + TInt size; + User::LeaveIfError(file.Size(size)); + + if(size == 0) + { + User::Leave(KErrNotFound); + } + + + HBufC8* iBuf = HBufC8::NewL( size ); + CleanupStack::PushL(iBuf); + + iFileDesc = new (ELeave) TPtr8( NULL, 0 ); + CleanupStack::PushL(iFileDesc); + + iFileDesc->Set( iBuf->Des()); + + if(file.Read(*iFileDesc) != KErrNone) + { + User::Leave(KErrNotFound); + } + + + recUtil->OpenDesL(*iFileDesc); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + User::Leave(KErrNotFound); + } + + CleanupStack::Pop(iFileDesc); + CleanupStack::Pop(iBuf); + CleanupStack::PopAndDestroy(&file); + return recUtil; + } + +TVerdict CTestMmfAclntRecNoRecordDesc::PlaySuccessfull() + { + TVerdict testStatus = EPass; + + if(iError != KErrNone) + { + testStatus = EFail; + } + + return testStatus; + } + + + + +CTestMmfAclntRecNoRecordFileForceController* CTestMmfAclntRecNoRecordFileForceController::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoRecordFileForceController* self = new (ELeave) CTestMmfAclntRecNoRecordFileForceController(aTestName,aSectName,aKeyName, aController); + return self; + } + +CTestMmfAclntRecNoRecordFileForceController* CTestMmfAclntRecNoRecordFileForceController::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoRecordFileForceController* self = CTestMmfAclntRecNoRecordFileForceController::NewLC(aTestName,aSectName,aKeyName,aController); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoRecordFileForceController::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a file, forcing record controller")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + return NULL; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + recUtil->OpenFileL(iFilename, KNullUid, iController); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + return recUtil; + } + +TVerdict CTestMmfAclntRecNoRecordFileForceController::PlaySuccessfull() + { + TVerdict testStatus = EPass; + + if(iError != KErrNone) + { + testStatus = EFail; + } + + + return testStatus; + } + + +CTestMmfAclntRecNoRecordDescForceController* CTestMmfAclntRecNoRecordDescForceController::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoRecordDescForceController* self = new (ELeave) CTestMmfAclntRecNoRecordDescForceController(aTestName,aSectName,aKeyName,aController); + return self; + } + +CTestMmfAclntRecNoRecordDescForceController* CTestMmfAclntRecNoRecordDescForceController::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TUid aController) + { + CTestMmfAclntRecNoRecordDescForceController* self = CTestMmfAclntRecNoRecordDescForceController::NewLC(aTestName,aSectName,aKeyName,aController); + CleanupStack::PushL(self); + return self; + } + + +CMdaAudioRecorderUtility* CTestMmfAclntRecNoRecordDescForceController::CMdaAudioRecorderUtilityLC() + { + INFO_PRINTF1( _L("Create CMdaAudioRecorderUtility with a descriptor, forcing record controller")); + + if(!GetStringFromConfig(iSectName, iKeyName, iFilename)) + { + User::Leave(KErrNotFound); + } + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + + RFs fs; + RFile file; + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,iFilename,EFileRead)); + CleanupClosePushL(file); + + TInt size; + User::LeaveIfError(file.Size(size)); + + if(size == 0) + { + User::Leave(KErrNotFound); + } + + + + HBufC8* iBuf = HBufC8::NewL( size ); + CleanupStack::PushL(iBuf); + + iFileDesc = new (ELeave) TPtr8( NULL, 0 ); + CleanupStack::PushL(iFileDesc); + + iFileDesc->Set( iBuf->Des()); + + if(file.Read(*iFileDesc) != KErrNone) + { + User::Leave(KErrNotFound); + } + + + recUtil->OpenDesL(*iFileDesc, KNullUid, iController); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError != KErrNone) + { + User::Leave(KErrNotFound); + } + + CleanupStack::Pop(iFileDesc); + CleanupStack::Pop(iBuf); + CleanupStack::PopAndDestroy(&file); + return recUtil; + } + +TVerdict CTestMmfAclntRecNoRecordDescForceController::PlaySuccessfull() + { + TVerdict testStatus = EPass; + + if(iError != KErrNone) + { + testStatus = EFail; + } + + return testStatus; + } + + + +//------------------------------------------------------------------ + +/** + * Constructor + */ +CTestMmfAclntRecFileAppend::CTestMmfAclntRecFileAppend(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TFormatType aFormatType, TCodecType aCodecType, TBool aDiffSampleRate) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iFormatType = aFormatType; + iCodecType = aCodecType; + iDiffSampleRate = aDiffSampleRate; + } + +CTestMmfAclntRecFileAppend* CTestMmfAclntRecFileAppend::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TFormatType aFormatType, TCodecType aCodecType, TBool aDiffSampleRate) + { + CTestMmfAclntRecFileAppend* self = new (ELeave) CTestMmfAclntRecFileAppend(aTestName, aSectName, aKeyName, aFormatType, aCodecType, aDiffSampleRate); + return self; + } + +void CTestMmfAclntRecFileAppend::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + iCurrentState = aCurrentState; + INFO_PRINTF3( _L("MoscoStateChangeEvent: aCurrentState = %d, iError %d "), iCurrentState, iError); + + CActiveScheduler::Stop(); + } + + +TVerdict CTestMmfAclntRecFileAppend::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + else if(error==KErrNone) + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + else + { + ret = EInconclusive; + } + fs.Close(); + } + + if((ret == EInconclusive) || (ret == EFail)) + return ret; + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + + +const TInt KSeventyFive = 75; +const TInt KTwentyFive = 25; +const TInt KOneHundred = 100; + +/** + * Open a file based clip and record, stop & then record again + */ + + +TVerdict CTestMmfAclntRecFileAppend::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Record File")); + TVerdict ret = EPass; + iError = KErrGeneral; // set error to ensure callback takes place + + TInt size1 = 0; // size of file after first record + TInt size2 = 0; // size of file after append + + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + return EInconclusive; + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TMdaFileClipLocation location(filename); + + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + + for (TInt index=0; index<2; index++) + { + if (index == 0) + INFO_PRINTF1(_L("Recording to file...")); + else + INFO_PRINTF1(_L("Appending to file...")); + + TMdaWavClipFormat mdaWavFormat; + TMdaAuClipFormat mdaAuFormat; + TMdaClipFormat* format = NULL; + + TMdaImaAdpcmWavCodec wavImadCodec; + TMdaPcmWavCodec wav8PcmCodec; + TMdaPcm8BitAuCodec au8PcmCodec; + + TMdaPackage* codec = NULL; + + switch (iFormatType) + { + case EWavFormat: + format = &mdaWavFormat; + switch (iCodecType) + { + case EAdpcmCodec: + codec = &wavImadCodec; + break; + case EPcmCodec: + codec = &wav8PcmCodec; + break; + } + break; + case EAuFormat: + format = &mdaAuFormat; + switch (iCodecType) + { + case EPcmCodec: + codec = &au8PcmCodec; + break; + default: + break; + } + break; + } + + if (format == NULL || codec == NULL) + { + ret = EInconclusive; + break; + } + + TMdaAudioDataSettings audioSettings; + audioSettings.iCaps = + TMdaAudioDataSettings::ESampleRateFixed | + TMdaAudioDataSettings::EChannelsMono | + TMdaAudioDataSettings::ESampleRate8000Hz | + TMdaAudioDataSettings::ESampleRate11025Hz; + + audioSettings.iSampleRate = KSampleRate8K; + audioSettings.iChannels = 1; + audioSettings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting; + if (index == 1 && iDiffSampleRate) + { + audioSettings.iSampleRate = KSampleRate11K; + } + + + recUtil->OpenL(&location, format, codec, &audioSettings); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // idle -> open + + if(iError != KErrNone) + { + break; + } + + iError = KErrTimedOut; + recUtil->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + User::After(KTwoSeconds); + + if (iCurrentState != CMdaAudioClipUtility::ERecording) + { + INFO_PRINTF1( _L("CMdaAudioRecorderUtility is not recording")); + ret = EFail; + break; + } + + recUtil->Stop(); + + + if (index == 1) + { + TTimeIntervalMicroSeconds actualDuration; + TTimeIntervalMicroSeconds expectedDuration(KFourSeconds); + actualDuration = recUtil->Duration(); + INFO_PRINTF3(_L("Duration recorded file, expected = %f, actual: %f"), + I64REAL(expectedDuration.Int64()), I64REAL(actualDuration.Int64())); + // allow a deviation of 25% + if (actualDuration.Int64() < expectedDuration.Int64() * KSeventyFive / KOneHundred) + { + ERR_PRINTF1(_L("Appended duration is too short")); + ret = EFail; + } + else if (actualDuration.Int64() > expectedDuration.Int64() * (KOneHundred+KTwentyFive) / KOneHundred) + { + ERR_PRINTF1(_L("Appended duration is too long")); + ret = EFail; + } + } + + + + recUtil->Close(); + + if(iError == KErrNone) + { + RFs fs; + RFile file; + TInt size = 0; + + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(file.Open(fs,filename,EFileRead)); + CleanupClosePushL(file); + User::LeaveIfError(file.Size(size)); + INFO_PRINTF2(_L("File size = %d"), size); + + if(size <= 0) + { + ret = EFail; + } + + CleanupStack::PopAndDestroy(&file); + + if (index == 0) + { + size1 = size; + } + + else + { + size2 = size; + } + + } + } + + if (iError != KErrNone) + { + ret = EFail; + } + + + // the appended size should be double the original size + // but to allow a little deviation, ensure it's at least 1.5 times bigger + if (ret == EPass) + { + if (size2 < (size1*(KOneHundred+KSeventyFive)/KOneHundred)) + { + ERR_PRINTF1(_L("Appended file size is too short")); + ret = EFail; + } + else if (size2 > (size1*(KOneHundred+KOneHundred+KTwentyFive)/KOneHundred)) + { + ERR_PRINTF1(_L("Appended file size is too long")); + ret = EFail; + } + } + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + CleanupStack::PopAndDestroy(recUtil); + User::After(KOneSecond); + return ret; + } + + +/** + * Constructor + */ +CTestMmfAclntRecFilePlay::CTestMmfAclntRecFilePlay(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TFormatType aFormatType, TCodecType aCodecType) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iFormatType = aFormatType; + iCodecType = aCodecType; + } + +CTestMmfAclntRecFilePlay* CTestMmfAclntRecFilePlay::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TFormatType aFormatType, TCodecType aCodecType) + { + CTestMmfAclntRecFilePlay* self = new (ELeave) CTestMmfAclntRecFilePlay(aTestName, aSectName, aKeyName, aFormatType, aCodecType); + return self; + } + +void CTestMmfAclntRecFilePlay::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + iCurrentState = aCurrentState; + INFO_PRINTF3( _L("MoscoStateChangeEvent: aCurrentState = %d, iError %d "), iCurrentState, iError); + + CActiveScheduler::Stop(); + } + + +TVerdict CTestMmfAclntRecFilePlay::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + return EInconclusive; + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + else if(error==KErrNone) + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + else + { + ret = EInconclusive; + } + fs.Close(); + } + + if((ret == EInconclusive) || (ret == EFail)) + return ret; + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +/** + * Open a file based clip and record, stop & then play + * specifying a different sample rate / number of channels + */ + + +TVerdict CTestMmfAclntRecFilePlay::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Record File & play with diff sample rate/num of channels")); + TVerdict ret = EPass; + iError = KErrGeneral; // set error to ensure callback takes place + + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + return EInconclusive; + + CMdaAudioRecorderUtility* recUtil = NULL; + + TMdaFileClipLocation location(filename); + + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + + for (TInt index=0; index<2; index++) + { + if (recUtil) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + if (index == 0) + INFO_PRINTF1(_L("Recording to file...")); + else + INFO_PRINTF1(_L("Playing recorded file")); + + TMdaWavClipFormat mdaWavFormat; + TMdaAuClipFormat mdaAuFormat; + TMdaClipFormat* format = NULL; + + TMdaImaAdpcmWavCodec wavImadCodec; + TMdaPcmWavCodec wav8PcmCodec; + TMdaPcm8BitAuCodec au8PcmCodec; + + TMdaPackage* codec = NULL; + + switch (iFormatType) + { + case EWavFormat: + format = &mdaWavFormat; + switch (iCodecType) + { + case EAdpcmCodec: + codec = &wavImadCodec; + break; + case EPcmCodec: + codec = &wav8PcmCodec; + break; + } + break; + case EAuFormat: + format = &mdaAuFormat; + switch (iCodecType) + { + case EPcmCodec: + codec = &au8PcmCodec; + break; + default: + break; + } + break; + } + + if (format == NULL || codec == NULL) + { + ret = EInconclusive; + break; + } + + TMdaAudioDataSettings audioSettings; + audioSettings.iCaps = + TMdaAudioDataSettings::ESampleRateFixed | + TMdaAudioDataSettings::EChannelsMono | + TMdaAudioDataSettings::EChannelsStereo | + TMdaAudioDataSettings::ESampleRate8000Hz | + TMdaAudioDataSettings::ESampleRate11025Hz; + + audioSettings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting; + + // record in stereo at 8KHz, playback in mono at 11KHz + if (index == 0) // record + { + audioSettings.iSampleRate = KSampleRate8K; + audioSettings.iChannels = 2; + } + else // play + { + audioSettings.iSampleRate = KSampleRate11K; + audioSettings.iChannels = 1; + } + + + recUtil->OpenL(&location, format, codec, &audioSettings); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // idle -> open + + if(iError != KErrNone) + break; + + iError = KErrTimedOut; + + if (index == 0) // record + { + recUtil->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + User::After(KTwoSeconds); + + if (iCurrentState != CMdaAudioClipUtility::ERecording) + { + INFO_PRINTF1( _L("CMdaAudioRecorderUtility is not recording")); + ret = EFail; + break; + } + + recUtil->Stop(); + + } + else // play + { + recUtil->PlayL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> play + CActiveScheduler::Start(); // play -> open + } + + recUtil->Close(); + + + } + + if (iError != KErrNone) + ret = EFail; + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + if (recUtil) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + User::After(KOneSecond); + return ret; + } + + +/** + * DEF039893 + * Gets balance prior to setting balance + * @class CTestMmfAclntRecord + */ +CTestMmfAclntRecordGetBalance::CTestMmfAclntRecordGetBalance(const TDesC& aTestName) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + } + +CTestMmfAclntRecordGetBalance* CTestMmfAclntRecordGetBalance::NewL(const TDesC& aTestName) + { + CTestMmfAclntRecordGetBalance* self = new (ELeave) CTestMmfAclntRecordGetBalance(aTestName); + return self; + } + +void CTestMmfAclntRecordGetBalance::MoscoStateChangeEvent(CBase* aObject,TInt aPreviousState,TInt aCurrentState, TInt aErrorCode) + { + iObject = aObject; + iPreviousState = aPreviousState; + iCurrentState = aCurrentState; + iError = aErrorCode; + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecordGetBalance::DoTestStepL() + { + // Set up a file to record to + TVerdict verdict = EPass; + + TPtrC filename; + if (!GetStringFromConfig(_L("SectionThree"), _L("outputAudioFile"), filename)) + { + INFO_PRINTF1(_L("Error getting filename from INI file")); + return EInconclusive; + } + + RFs fs; + TInt err = fs.Connect(); + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error connecting file session"), err); + return EInconclusive; + } + + err = fs.Delete(filename); + if (!((err == KErrNone) || (err == KErrNotFound))) + { + INFO_PRINTF2(_L("Error deleting output file"), err); + return EInconclusive; + } + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + + TInt balance; + err = recUtil->GetPlaybackBalance(balance); + + if (err != KErrNotSupported) + {//would have thought KErrNotReady would be a more logical error + verdict = EFail; + } + + TRAP(err,recUtil->OpenFileL(filename)); + CActiveScheduler::Start(); + + if (err) + { + INFO_PRINTF2(_L("Error opening output file"), err); + verdict = EInconclusive; + } + else + { + err = recUtil->GetPlaybackBalance(balance); + + if ((err)||(balance)) + {//there should be no errors and balance should be 0 + verdict = EFail; + } + + recUtil->Close(); + + err = recUtil->GetPlaybackBalance(balance); + if (err != KErrNotSupported) + { + verdict = EFail; + } + } + + delete recUtil; + + return verdict; + } +/* +DEF039308 - No integration test to test playback of recorded raw file +The tmfad record test option b + 4 to record an alaw raw file and then play it back: this uncovered a defect that was not picked up by the integration tests suggesting there are no integration tests to record and playback a recorded raw file. +Not clear whether this applies to just recording raw alaw or recorded raw in general- this needs checking as part of the 'under investigation' phase. +*/ + +/** + * Constructor + */ +CTestMmfAclntRecRawFilePlay::CTestMmfAclntRecRawFilePlay(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TFormatType aFormatType, TCodecType aCodecType) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyName = aKeyName; + iFormatType = aFormatType; + iCodecType = aCodecType; + } + +CTestMmfAclntRecRawFilePlay* CTestMmfAclntRecRawFilePlay::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TFormatType aFormatType, TCodecType aCodecType) + { + CTestMmfAclntRecRawFilePlay* self = new (ELeave) CTestMmfAclntRecRawFilePlay(aTestName, aSectName, aKeyName, aFormatType, aCodecType); + return self; + } + +void CTestMmfAclntRecRawFilePlay::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode) + { + iError = aErrorCode; + iCurrentState = aCurrentState; + INFO_PRINTF3( _L("MoscoStateChangeEvent: aCurrentState = %d, iError %d "), iCurrentState, iError); + + CActiveScheduler::Stop(); + } + + +TVerdict CTestMmfAclntRecRawFilePlay::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + return EInconclusive; + + GetDriveName(filename); + filename.Append(filename1); + + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + else if(error==KErrNone) + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + else + { + ret = EInconclusive; + } + fs.Close(); + } + + if((ret == EInconclusive) || (ret == EFail)) + return ret; + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + +/** + * Open a file based clip and record, stop & then play + * specifying a different sample rate / number of channels + */ + + +TVerdict CTestMmfAclntRecRawFilePlay::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Record RAW File & play with diff sample rate/num of channels")); + TVerdict ret = EPass; + iError = KErrGeneral; // set error to ensure callback takes place + + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + return EInconclusive; + + CMdaAudioRecorderUtility* recUtil = NULL; + + TMdaFileClipLocation location(filename); + + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + + for (TInt index=0; index<2; index++) + { + if (recUtil) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + if (index == 0) + INFO_PRINTF1(_L("Recording to file...")); + else + INFO_PRINTF1(_L("Playing recorded file")); + + TMdaRawAudioClipFormat mdaRawFormat; + TMdaClipFormat* format = NULL; + + TMdaAlawRawAudioCodec rawAlawCodec; + + TMdaPackage* codec = NULL; + + switch (iFormatType) + { + case ERawFormat: + format = &mdaRawFormat; + switch (iCodecType) + { + case EAlawCodec: + codec = &rawAlawCodec; + break; + default: + break; + } + break; + } + + if (format == NULL || codec == NULL) + { + ret = EInconclusive; + break; + } + + TMdaAudioDataSettings audioSettings; + audioSettings.iCaps = + TMdaAudioDataSettings::ESampleRateFixed | + TMdaAudioDataSettings::EChannelsMono | + TMdaAudioDataSettings::EChannelsStereo | + TMdaAudioDataSettings::ESampleRate8000Hz | + TMdaAudioDataSettings::ESampleRate11025Hz; + + audioSettings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting; + + // record in stereo at 8KHz, playback in mono at 11KHz + if (index == 0) // record + { + audioSettings.iSampleRate = KSampleRate8K; + audioSettings.iChannels = 2; + } + else // play + { + audioSettings.iSampleRate = KSampleRate11K; + audioSettings.iChannels = 1; + } + + + recUtil->OpenL(&location, format, codec, &audioSettings); + + INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // idle -> open + + if(iError != KErrNone) + break; + + iError = KErrTimedOut; + + if (index == 0) // record + { + recUtil->RecordL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> record + + User::After(KTwoSeconds); + + if (iCurrentState != CMdaAudioClipUtility::ERecording) + { + INFO_PRINTF1( _L("CMdaAudioRecorderUtility is not recording")); + ret = EFail; + break; + } + + recUtil->Stop(); + + } + else // play + { + recUtil->PlayL(); + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); // open -> play + CActiveScheduler::Start(); // play -> open + } + + recUtil->Close(); + + + } + + if (iError != KErrNone) + ret = EFail; + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + if (recUtil) + { + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + } + + User::After(KOneSecond); + return ret; + } + + +/** + * REQ2870 + * Sierra: AudioRecorderUtility to get AudioBitrare + * @class CTestMmfAclntRecSrcAuBitrate + */ +CTestMmfAclntRecSrcAuBitrate::CTestMmfAclntRecSrcAuBitrate(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName1, const TDesC& aKeyName2) + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iSectName = aSectName; + iKeyFileName = aKeyName1; + iKeyBitRateName = aKeyName2; + } + +CTestMmfAclntRecSrcAuBitrate* CTestMmfAclntRecSrcAuBitrate::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName1, + const TDesC& aKeyName2) + { + CTestMmfAclntRecSrcAuBitrate* self = new (ELeave) CTestMmfAclntRecSrcAuBitrate(aTestName, + aSectName, + aKeyName1, + aKeyName2); + return self; + } + +void CTestMmfAclntRecSrcAuBitrate::MoscoStateChangeEvent(CBase* aObject, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + iError = aErrorCode; + iObject = aObject; + iPreviousState = aPreviousState; + iCurrentState = aCurrentState; + INFO_PRINTF1( _L("CTestMmfAclntRecSrcAuBitrate : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState); + CActiveScheduler::Stop(); + } + +TVerdict CTestMmfAclntRecSrcAuBitrate::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Audio Bit Rate")); + TVerdict verdict = EPass; + + TPtrC filename; + TInt bitRate = 0; + TInt err = 0; + + if(!GetStringFromConfig(iSectName,iKeyFileName,filename)) + { + INFO_PRINTF1(_L("Error getting filename from INI file")); + return EInconclusive; + } + if(!GetIntFromConfig(iSectName, iKeyBitRateName, iExpectedBitRate)) + { + INFO_PRINTF1(_L("Error getting bitrate from INI file")); + return EInconclusive; + } + + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + if (recUtil == NULL || + iError != KErrNone) + { + INFO_PRINTF1(_L("Error to create a recUtil object")); + return EFail; + } + CleanupStack::PushL(recUtil); + + + INFO_PRINTF2(_L("Opening file = %S"), &filename); + TRAP(err, recUtil->OpenFileL(filename)); + CActiveScheduler::Start(); + + if (err != KErrNone || + iError != KErrNone) + { + INFO_PRINTF2(_L("Opening file error: %d"), err); + CleanupStack::PopAndDestroy(recUtil); + verdict = EFail; + } + else + { + recUtil->PlayL(); + CActiveScheduler::Start(); // wait for open -> play + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error to play the file: %d"), iError); + verdict = EFail; + } + + TRAP(err, bitRate = recUtil->SourceBitRateL()); + if (err != KErrNone || + iError != KErrNone) + { + INFO_PRINTF2(_L("Error to query the bitrate: %d"), err); + verdict = EFail; + } + + if (bitRate != iExpectedBitRate) + { + verdict = EFail; + } + INFO_PRINTF2(_L("Expected bit rate: %d"), iExpectedBitRate); + INFO_PRINTF2(_L("Queried Bitrate: %d"), bitRate); + recUtil->Close(); + CleanupStack::PopAndDestroy(recUtil); + } + + return verdict; +} + + +/** + * REQ2870 + * Sierra: AudioRecorderUtility to get AudioBitrare from a recorded file + * @class CTestMmfAclntRecBitrateRecordedFile + */ +CTestMmfAclntRecBitrateRecordedFile::CTestMmfAclntRecBitrateRecordedFile(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + const TTestFormat aFormat, + const TBool aCreateFile) + + { + // store the name of this test case + // this is the name that is used by the script file + // Each test step initialises it's own name + iTestStepName = aTestName; + iHeapSize = 200000; // playback part of test loads whole sound file into buffer, so need large heap + iSectName = aSectName; + iKeyName = aKeyName; + iTestFormat = aFormat; + iCreateFile = aCreateFile; + } + +CTestMmfAclntRecBitrateRecordedFile* CTestMmfAclntRecBitrateRecordedFile::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + const TTestFormat aFormat, + const TBool aCreateFile) + { + CTestMmfAclntRecBitrateRecordedFile* self = new (ELeave) CTestMmfAclntRecBitrateRecordedFile(aTestName, + aSectName, + aKeyName, + aFormat, + aCreateFile); + return self; + } + +void CTestMmfAclntRecBitrateRecordedFile::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt /*aCurrentState*/, TInt aErrorCode) + { + iError = aErrorCode; + INFO_PRINTF1( _L("CTestMmfAclntRecBitrateRecordedFile : MMdaObjectStateChangeObserver Callback for CMdaAudioRecorderUtility complete")); + INFO_PRINTF2( _L("iError %d "), iError); + + CActiveScheduler::Stop(); + } + + +TVerdict CTestMmfAclntRecBitrateRecordedFile::DoTestStepPreambleL() + { + TVerdict ret = EPass; + + //Setup codec and format to test (CTestMmfAclntCodecTest) + SetupFormatL(iTestFormat); + + if(iCreateFile) + { + // Make sure file doesn't exist (maybe from a previous test) + TParse fullFileName; + TBuf filename; + TPtrC filename1; + + if(!GetStringFromConfig(iSectName, iKeyName, filename1)) + { + return EInconclusive; + } + GetDriveName(filename); + filename.Append(filename1); + + // parse the filenames + if(!fullFileName.Set(filename, &KDefault, NULL)) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + fs.SetAtt(fullFileName.FullName(), 0, KEntryAttReadOnly); + TInt error = fs.Delete(fullFileName.FullName()); + + if(error == KErrPathNotFound) + { + error = fs.MkDirAll(fullFileName.DriveAndPath()); + INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName()); + } + else if(error == KErrNotFound) + { + INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName()); + } + else if(error==KErrNone) + { + INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName()); + } + else + { + ret = EInconclusive; + } + fs.Close(); + } + } + + if(ret == EInconclusive) + { + return ret; + } + + return CTestMmfAclntStep::DoTestStepPreambleL(); + } + + +TVerdict CTestMmfAclntRecBitrateRecordedFile::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Query bitrate from a recorded file")); + TVerdict verdict = EPass; + iError = KErrTimedOut; + + TPtrC filename; + if(!GetStringFromConfig(iSectName, iKeyName, filename)) + { + return EInconclusive; + } + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + TMdaFileClipLocation location(filename); + + recUtil->OpenL(&location,iFormat,iCodec,&iAudioSettings); + CActiveScheduler::Start(); + INFO_PRINTF1( _L("Open a new file for recording")); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for recording iError = %d"), iError); + CleanupStack::PopAndDestroy(recUtil); + return EFail; + } + + iError = KErrTimedOut; + recUtil->RecordL(); + CActiveScheduler::Start(); // open -> record + INFO_PRINTF1( _L("Recording")); + User::After(KFiveSeconds); + + if(iError != KErrNone) + { + INFO_PRINTF2( _L("Fail to do recording with error: %d"), iError); + verdict = EFail; + } + + recUtil->Stop(); + User::After(KOneSecond); + + + TRAPD(err, recUtil->OpenFileL(filename)); + CActiveScheduler::Start(); + INFO_PRINTF1( _L("Open the recorded file")); + + if (err != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for playback err = %d"), err); + CleanupStack::PopAndDestroy(recUtil); + return EFail; + } + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error opening file for playback iError = %d"), iError); + CleanupStack::PopAndDestroy(recUtil); + return EFail; + } + + recUtil->PlayL(); + CActiveScheduler::Start(); + INFO_PRINTF1( _L("Play the recorded file")); + + if (iError != KErrNone) + { + INFO_PRINTF2(_L("Error during playback of recorded file iError=%d"), iError); + verdict = EFail; + } + User::After(KFiveSeconds); + + TInt bitRate = 0; + + TRAP(err, bitRate = recUtil->SourceBitRateL()); + INFO_PRINTF1( _L("Query bitrate from the recorded file")); + + if (err != KErrNone || + iError != KErrNone) + { + INFO_PRINTF2(_L("Error to query the bitrate: %d"), err); + verdict = EFail; + } + + INFO_PRINTF2(_L("Queried Bitrate: %d"), bitRate); + + recUtil->Close(); + + CleanupStack::PopAndDestroy(recUtil); + recUtil = NULL; + + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + User::After(KOneSecond); + return verdict; + } + +//Record-Stop-Record test. Added for CR1566 + +CTestMmfAclntRecStopRec::CTestMmfAclntRecStopRec(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + :CTestMmfAclntRecord(aTestName, aSectName, aNegative) + {} + +CTestMmfAclntRecStopRec* CTestMmfAclntRecStopRec::NewL(const TDesC& aTestName, const TDesC& aSectName, TBool aNegative) + { + CTestMmfAclntRecStopRec* self = new (ELeave) CTestMmfAclntRecStopRec(aTestName, aSectName, aNegative); + return self; + } + +TVerdict CTestMmfAclntRecStopRec::DoTestStepL() + { + INFO_PRINTF1( _L("TestRecorder : Record-Stop-Record")); + TVerdict ret = EFail; + + iError = KErrTimedOut; + + TPtrC filename; + + + if(!GetStringFromConfig(iSectName, _L("outputAudioFile"), filename)) + { + return EInconclusive; + } + + RFs fs; + fs.Connect(); + fs.Delete(filename); + fs.Close(); + + CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(recUtil); + + // Add create file for Ogg-tests + if(iSectName == _L("SectionOggRecState")) + { + RFs fs; + User::LeaveIfError(fs.Connect()); + RFile file; + User::LeaveIfError(file.Replace(fs,filename,EFileWrite)); + file.Close(); + fs.Close(); + } + + INFO_PRINTF2(_L("CMdaAudioRecorderUtility->OpenFileL(%S)"), &filename); + recUtil->OpenFileL(filename); + // wait + INFO_PRINTF1(_L("Initialise CMdaAudioRecorderUtility")); + CActiveScheduler::Start(); + + if(iError == KErrNone) + { + ret = DoTestL(recUtil); + } + + + CleanupStack::PopAndDestroy(recUtil); + User::After(KTwoSeconds); + ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError ); + return ret; + } + +/** + * Enquire state at each state transition. + */ +TVerdict CTestMmfAclntRecStopRec::DoTestL(CMdaAudioRecorderUtility* aRecUtil) + { + INFO_PRINTF1( _L("TestRecorder : State Transition")); + + TVerdict ret= EFail; + + iReportedState = aRecUtil->State(); + if( iReportedState == CMdaAudioClipUtility::EOpen ) + { + INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility")); + aRecUtil->RecordL(); + CActiveScheduler::Start(); // wait for open -> record + if (iError != KErrNone) + { + return EFail; + } + + iReportedState = aRecUtil->State(); + if(iReportedState == CMdaAudioClipUtility::ERecording ) + { + ret = EPass; + } + + User::After(KTwoSeconds); + aRecUtil->Stop(); + + iReportedState = aRecUtil->State(); + if(iReportedState != CMdaAudioClipUtility::EOpen ) //Check that record returns to open + { + return EFail; + } + + aRecUtil->RecordL(); + CActiveScheduler::Start(); // wait for open -> record again + if (iError != KErrNone) + { + return EFail; + } + + iReportedState = aRecUtil->State(); + if( iReportedState == CMdaAudioClipUtility::ERecording ) + { + aRecUtil->Close(); + ret = EPass; + } + } + return ret; + } +