diff -r 000000000000 -r b8ed18f6c07b mmlibs/mmfw/tsrc/mmfunittest/aclnt/TSU_MMF_ACLNT_01/TestStepRecorderSimultaneousPlay.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfunittest/aclnt/TSU_MMF_ACLNT_01/TestStepRecorderSimultaneousPlay.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,2154 @@ +// Copyright (c) 2003-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 file contains an example Test step implementation +// This demonstrates the various functions provided +// by the CTestStep base class which are available within +// a test step +// +// + +// EPOC includes +#include +#include +#include +#include +#include +#include +#include +#include + +//#include +#include +#include + +// Test system includes +#include + +// Specific includes for this test suite +#include "TestStepUnitMMFAudClient.h" +#include "TestSuiteUnitMMFAudClient.h" + +// Specific includes for these test steps +#include "TestStepRecorder.h" + + +#include "MmfAudioController.h" +#include "mmfclientaudiorecorder.h" +// -------------------------------------------- +// -------------------------------------------- + +/** + * + * Static constructor for CTestStepRecorderSimultaneousPlay1. + * + * + * @return "CTestStepRecorderSimultaneousPlay1*" + * The constructed CTestStepRecorderSimultaneousPlay1 + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay1* CTestStepRecorderSimultaneousPlay1::NewL() + { + CTestStepRecorderSimultaneousPlay1* self = new(ELeave) CTestStepRecorderSimultaneousPlay1; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay1::CTestStepRecorderSimultaneousPlay1() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0810-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay1::~CTestStepRecorderSimultaneousPlay1() + { + } + +/** + * + * Test step Close + * handles all deletion + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay1::Close() + { + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay1::DoTestStepPreambleL(void) + { + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of calling CMdaAudioRecorderUtility::PlayL() while a tone is playing")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file + { + return EInconclusive; + } + + return verdict; + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay1::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay1::MoscoStateChangeEvent(CBase* aObject, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + INFO_PRINTF5(_L("MoscoStateChangeEvent(object=0x%08x, ps=%d, cs=%d, error = %d)"), + aObject, + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + iCurrentState = aCurrentState; + CActiveScheduler::Stop(); + } + + +void CTestStepRecorderSimultaneousPlay1::MatoPrepareComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPrepareComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + +void CTestStepRecorderSimultaneousPlay1::MatoPlayComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPlayComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderSimultaneousPlay1::DoTestStepL() + { + iTestStepResult = EFail; + + iToneUtility = CMdaAudioToneUtility::NewL(*this); + CleanupStack::PushL(iToneUtility); + + iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this); + CleanupStack::PushL(iRecorderUtility); + + do + { + // open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility")); + iRecorderUtility->OpenFileL(iFileName); + CActiveScheduler::Start(); + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + { + break; + } + + // prepare the tone + INFO_PRINTF1( _L("Initialize CMdaAudioToneUtility")); + iToneUtility->PrepareToPlayTone(KToneFrequency, TTimeIntervalMicroSeconds(KTwoSeconds)); + // Wait for prepare + iErrorTone = KErrGeneral; // set so we know callback has occurred + CActiveScheduler::Start(); + if (iErrorTone != KErrNone) + { + break; + } + + // start playing the tone & wait 0.25 secs to make sure it gets started + INFO_PRINTF1( _L("Playing tone...")); + iToneUtility->Play(); + User::After(KQuarterScond); + + // start playing the file + INFO_PRINTF1( _L("Playing sound file...")); + iRecorderUtility->PlayL(); + // wait once for start of play + // NB this "EPlaying" callback does not occur in 6.1 ! + CActiveScheduler::Start(); + if ((iError != KErrNone) || (iCurrentState != CMdaAudioRecorderUtility::EPlaying)) + { + break; + } + + // wait once for end of play - this should produce KErrInUse + INFO_PRINTF1( _L("Waiting for end of play...")); + CActiveScheduler::Start(); + if ((iError != KErrInUse) || (iCurrentState != CMdaAudioRecorderUtility::EOpen)) + { + break; + } + // wait once tone to finsh playing + CActiveScheduler::Start(); + + // now that the tone player has finished, try playing + // the sound file again (this should work now) + + INFO_PRINTF1( _L("Calling iRecorderUtility->PlayL...")); + iRecorderUtility->PlayL(); + // wait once for start of play + CActiveScheduler::Start(); + if ((iError != KErrNone) || (iCurrentState != CMdaAudioRecorderUtility::EPlaying)) + { + break; + } + + // wait once for end of play - this should produce KErrNone + CActiveScheduler::Start(); + if ((iError != KErrNone) || (iCurrentState != CMdaAudioRecorderUtility::EOpen)) + { + break; + } + + iTestStepResult = EPass; + } + while (EFalse); + + CleanupStack::PopAndDestroy(iRecorderUtility); + CleanupStack::PopAndDestroy(iToneUtility); + iRecorderUtility = NULL; + iToneUtility = NULL; + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + +// + + +/** + * + * Static constructor for CTestStepRecorderSimultaneousPlay2. + * + * + * @return "CTestStepRecorderSimultaneousPlay2*" + * The constructed CTestStepRecorderSimultaneousPlay2 + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay2* CTestStepRecorderSimultaneousPlay2::NewL() + { + CTestStepRecorderSimultaneousPlay2* self = new(ELeave) CTestStepRecorderSimultaneousPlay2; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay2::CTestStepRecorderSimultaneousPlay2() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0811-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay2::~CTestStepRecorderSimultaneousPlay2() + { + } + +/** + * + * Test step Close + * handles all deletion + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay2::Close() + { + delete iToneUtility; + delete iRecorderUtility; + } + + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay2::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of playing a high priority tone over a low priority .wav file")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file + { + return EInconclusive; + } + + // create a record utility + TRAP(err, iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin)); + if (err != KErrNone) + return EInconclusive; + // create a tone utility + TRAP(err, iToneUtility = CMdaAudioToneUtility::NewL(*this, NULL, EMdaPriorityMax)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay2::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay2::MoscoStateChangeEvent(CBase* /*aObject*/, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"), + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + iCurrentState = aCurrentState; + CActiveScheduler::Stop(); + } + + +void CTestStepRecorderSimultaneousPlay2::MatoPrepareComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPrepareComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + +void CTestStepRecorderSimultaneousPlay2::MatoPlayComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPlayComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderSimultaneousPlay2::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + // open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility")); + TRAP(err, iRecorderUtility->OpenFileL(iFileName)); + if (err != KErrNone) + return EInconclusive; + + // wait for open to complete + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // prepare the tone + INFO_PRINTF1( _L("Initialize CMdaAudioToneUtility")); + iToneUtility->PrepareToPlayTone(KToneFrequency,TTimeIntervalMicroSeconds(KTwoSeconds)); + // Wait for prepare + iErrorTone = KErrGeneral; // set so we know tone callback has occurred + CActiveScheduler::Start(); + if (iErrorTone != KErrNone) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // start playing the file and give it time to start + INFO_PRINTF1( _L("Playing sound file (1)...low priority")); + TRAP(err, iRecorderUtility->PlayL()); + if (err != KErrNone) + return EInconclusive; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + User::After(KQuarterScond); + + + // start playing the tone and wait for completion + // Two observer callbacks to catch here: + // One is high priority tone starting playing, and the other is the low + // priority recorder being kicked off. We are ignoring the order of these. + INFO_PRINTF1( _L("Playing tone...high priority")); + iToneUtility->Play(); + iErrorTone = KErrGeneral; // set so we know tone callback has occurred + CActiveScheduler::Start(); + if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) && + !(iErrorTone == KErrNone)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + iErrorTone = KErrGeneral; // set so we know tone callback has occurred + CActiveScheduler::Start(); + if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) && + !(iErrorTone == KErrNone)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + + // start playing the file again and wait for completion + INFO_PRINTF1( _L("Playing sound file (2)...low priority")); + TRAP(err, iRecorderUtility->PlayL()); + if (err != KErrNone) + return EInconclusive; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // Wait for end of play + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + + +// + + +/** + * + * Static constructor for CTestStepRecorderSimultaneousPlay3. + * + * + * @return "CTestStepRecorderSimultaneousPlay3*" + * The constructed CTestStepRecorderSimultaneousPlay3 + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay3* CTestStepRecorderSimultaneousPlay3::NewL() + { + CTestStepRecorderSimultaneousPlay3* self = new(ELeave) CTestStepRecorderSimultaneousPlay3; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay3::CTestStepRecorderSimultaneousPlay3() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0812-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay3::~CTestStepRecorderSimultaneousPlay3() + { + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay3::Close() + { + delete iRecorderUtility1; + delete iRecorderUtility2; + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay3::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of playing a high priority .wav file over a low priority .wav file")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName1)) // long wav file + { + return EInconclusive; + } + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName1"), iFileName2)) // short wav file + { + return EInconclusive; + } + + // create record utilities. A low priority and a high priority + TRAP(err, iRecorderUtility1 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin)); + if (err != KErrNone) + return EInconclusive; + + TRAP(err, iRecorderUtility2 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay3::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay3::MoscoStateChangeEvent(CBase* /*aObject*/, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"), + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + iCurrentState = aCurrentState; + CActiveScheduler::Stop(); + } + + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderSimultaneousPlay3::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + // open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility1")); + TRAP(err, iRecorderUtility1->OpenFileL(iFileName1)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + + // open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility2")); + TRAP(err, iRecorderUtility2->OpenFileL(iFileName2)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + + // start playing the first file and give it time to start + INFO_PRINTF1( _L("Playing sound file (1)...low priority")); + TRAP(err, iRecorderUtility1->PlayL()); + if (err != KErrNone) + return EInconclusive; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + User::After(KQuarterScond); + + // start playing the second file and wait for completion + // Two observer callbacks to catch here: + // One is high priority recorder starting playing, and the other is the low + // priority recorder being kicked off. We are ignoring the order of these. + INFO_PRINTF1( _L("Playing sound file (2)...high priority")); + TRAP(err, iRecorderUtility2->PlayL()); + if (err != KErrNone) + return EFail; + CActiveScheduler::Start(); + if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) && + !(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + CActiveScheduler::Start(); + if (!(iError == KErrInUse && iCurrentState == CMdaAudioRecorderUtility::EOpen) && + !(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // Wait for end of play for file 2 + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // start playing the first file again and wait for completion + INFO_PRINTF1( _L("Playing sound file (3)...low priority")); + TRAP(err, iRecorderUtility1->PlayL()); + if (err != KErrNone) + return EFail; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + User::After(KQuarterScond); + + // Wait for end of play + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState == CMdaAudioRecorderUtility::EOpen)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + + +// + + +/** + * + * Static constructor for CTestStepRecorderSimultaneousPlay4. + * + * + * @return "CTestStepRecorderSimultaneousPlay4*" + * The constructed CTestStepRecorderSimultaneousPlay4 + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay4* CTestStepRecorderSimultaneousPlay4::NewL() + { + CTestStepRecorderSimultaneousPlay4* self = new(ELeave) CTestStepRecorderSimultaneousPlay4; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay4::CTestStepRecorderSimultaneousPlay4() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0813-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay4::~CTestStepRecorderSimultaneousPlay4() + { + } + +/** + * + * Test step Close + * handles all deletion + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay4::Close() + { + delete iRecorderUtility1; + delete iRecorderUtility2; + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay4::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of playing a high priority .wav file over the same low priority .wav file")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName1)) // long wav file + { + return EInconclusive; + } + + // create record utilities. A low priority and a high priority + TRAP(err, iRecorderUtility1 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin)); + if (err != KErrNone) + return EInconclusive; + + TRAP(err, iRecorderUtility2 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay4::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay4::MoscoStateChangeEvent(CBase* aObject, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + _LIT(KRecordUtility1, "RecorderUtility1"); + _LIT(KRecordUtility2, "RecorderUtility2"); + INFO_PRINTF5(_L("MoscoStateChangeEvent(): %S : Previous state = %d, current state = %d, error = %d"), + (aObject == iRecorderUtility1)?&KRecordUtility1:&KRecordUtility2, + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + + if (aObject == iRecorderUtility1) + iCurrentState1 = aCurrentState; + else if (aObject == iRecorderUtility2) + iCurrentState2 = aCurrentState; + + + CActiveScheduler::Stop(); + } + + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderSimultaneousPlay4::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + INFO_PRINTF2(_L("File to play = %S"), &iFileName1); + + // Get the first recorder utility to open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility1")); + TRAP(err, iRecorderUtility1->OpenFileL(iFileName1)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState1 != CMdaAudioRecorderUtility::EOpen) + return EFail; + + // start playing the first file and give it time to start + INFO_PRINTF1( _L("Playing sound file (Utililty #1)...low priority")); + TRAP(err, iRecorderUtility1->PlayL()); + if (err != KErrNone) + return EInconclusive; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + User::After(KQuarterScond); + + // Get the second recorder utility to open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility2")); + TRAP(err, iRecorderUtility2->OpenFileL(iFileName1)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState2 != CMdaAudioRecorderUtility::EOpen) + return EFail; + + // start playing the second file and wait for completion + // Two observer callbacks to catch here: + // One is high priority recorder starting playing, and the other is the low + // priority recorder being kicked off. We are ignoring the order of these. + INFO_PRINTF1( _L("Playing sound file (Utililty #2)...high priority")); + TRAP(err, iRecorderUtility2->PlayL()); + if (err != KErrNone) + return EFail; + CActiveScheduler::Start(); + if (!(iError == KErrInUse && iCurrentState1 == CMdaAudioRecorderUtility::EOpen) && + !(iError == KErrNone && iCurrentState2 == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + CActiveScheduler::Start(); + if (!(iError == KErrInUse && iCurrentState1 == CMdaAudioRecorderUtility::EOpen) && + !(iError == KErrNone && iCurrentState2 == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // Wait for end of play for second recorder utility + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState2 == CMdaAudioRecorderUtility::EOpen)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // start playing the first file again and wait for completion + INFO_PRINTF1( _L("Playing sound file (Utililty #1 again)...low priority")); + TRAP(err, iRecorderUtility1->PlayL()); + if (err != KErrNone) + return EFail; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + // Wait for end of play + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EOpen)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + + +// + + +/** + * + * Static constructor for CTestStepRecorderSimultaneousPlay5 + * + * + * @return "CTestStepRecorderSimultaneousPlay5*" + * The constructed CTestStepRecorderSimultaneousPlay5 + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay5* CTestStepRecorderSimultaneousPlay5::NewL() + { + CTestStepRecorderSimultaneousPlay5* self = new(ELeave) CTestStepRecorderSimultaneousPlay5; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay5::CTestStepRecorderSimultaneousPlay5() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0814-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderSimultaneousPlay5::~CTestStepRecorderSimultaneousPlay5() + { + } + +/** + * + * Test step Close + * handles all deletion + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay5::Close() + { + delete iRecorderUtility1; + delete iRecorderUtility2; + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay5::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of Open a low priority recorder and a higher priority recorder with the same file & get the duration in each case")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName1)) // long wav file + { + return EInconclusive; + } + + // create record utilities. A low priority and a high priority + TRAP(err, iRecorderUtility1 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMin)); + if (err != KErrNone) + return EInconclusive; + + TRAP(err, iRecorderUtility2 = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSimultaneousPlay5::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderSimultaneousPlay5::MoscoStateChangeEvent(CBase* aObject, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"), + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + + if (aObject == iRecorderUtility1) + iCurrentState1 = aCurrentState; + else if (aObject == iRecorderUtility2) + iCurrentState2 = aCurrentState; + + + CActiveScheduler::Stop(); + } + + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderSimultaneousPlay5::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + INFO_PRINTF2(_L("File to play = %S"), &iFileName1); + + // Get the first recorder utility to open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility1")); + TRAP(err, iRecorderUtility1->OpenFileL(iFileName1)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState1 != CMdaAudioRecorderUtility::EOpen) + return EFail; + + // start playing the first file and give it time to start + INFO_PRINTF1( _L("Playing sound file (Utililty #1)...low priority")); + TRAP(err, iRecorderUtility1->PlayL()); + if (err != KErrNone) + return EInconclusive; + CActiveScheduler::Start(); + if (!(iError == KErrNone && iCurrentState1 == CMdaAudioRecorderUtility::EPlaying)) + { + iTestStepResult = EFail; + return iTestStepResult; + } + User::After(KQuarterScond); + + // Get the second recorder utility to open the sound file + INFO_PRINTF1( _L("Initialize CMdaAudioRecorderUtility2")); + TRAP(err, iRecorderUtility2->OpenFileL(iFileName1)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState2 != CMdaAudioRecorderUtility::EOpen) + return EFail; + + + // get the duration of each utility + TTimeIntervalMicroSeconds duration1, duration2; + + duration1 = iRecorderUtility1->Duration(); + duration2 = iRecorderUtility2->Duration(); + + INFO_PRINTF2( _L("CMdaAudioRecorderUtility1: reported duration = %d"), I64INT(duration1.Int64())); + INFO_PRINTF2( _L("CMdaAudioRecorderUtility1: reported duration = %d"), I64INT(duration2.Int64())); + + if (duration1 != duration2) + iTestStepResult = EFail; + + // stop playing + iRecorderUtility1->Stop(); + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + + +// + + +/** + * + * Static constructor for CTestStepRecorderPlayTwice. + * + * + * @return "CTestStepRecorderPlayTwice*" + * The constructed CTestStepRecorderPlayTwice + * + * @xxxx + * + */ +CTestStepRecorderPlayTwice* CTestStepRecorderPlayTwice::NewL() + { + CTestStepRecorderPlayTwice* self = new(ELeave) CTestStepRecorderPlayTwice; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderPlayTwice::CTestStepRecorderPlayTwice() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0820-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderPlayTwice::~CTestStepRecorderPlayTwice() + { + } + +/** + * + * Test step Close + * handles all deletion + * @xxxx + * + */ +void CTestStepRecorderPlayTwice::Close() + { + delete iRecorderUtility; + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderPlayTwice::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of calling CMdaAudioRecorderUtility::PlayL() twice")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file + { + return EInconclusive; + } + + // create a record utility + TRAP(err, iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderPlayTwice::DoTestStepPostambleL(void) + { + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderPlayTwice::MoscoStateChangeEvent(CBase* /*aObject*/, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"), + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + iCurrentState = aCurrentState; + CActiveScheduler::Stop(); + } + + +void CTestStepRecorderPlayTwice::MatoPrepareComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPrepareComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + +void CTestStepRecorderPlayTwice::MatoPlayComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPlayComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderPlayTwice::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + + // open the sound file + TRAP(err, iRecorderUtility->OpenFileL(iFileName)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + + TTime timeStart; + TTime timeEnd; + TTimeIntervalMicroSeconds playDuration1; + TTimeIntervalMicroSeconds playDuration2; + TTimeIntervalMicroSeconds position; + const TInt KQuarterSecond = 250000; + const TInt KHalfSecond = 500000; + const TInt KTwoSeconds = 2000000; + + // Start playing the file and after two seconds get the position + INFO_PRINTF1( _L("Playing file for the first time...")); + timeStart.UniversalTime(); // start the timer + TRAP(err, iRecorderUtility->PlayL()); + if (err != KErrNone) + return EInconclusive; + // wait once for start of play + CActiveScheduler::Start(); + if (iError != KErrNone) + iTestStepResult = EFail; + if (iCurrentState != CMdaAudioRecorderUtility::EPlaying) + return EFail; + + // check the position is close to the start of the file + position = iRecorderUtility->Position(); + INFO_PRINTF2(_L("Start position = %d microseconds"), I64INT(position.Int64())); + if (position.Int64() > KHalfSecond) + { + INFO_PRINTF1(_L("Start position is too high")); + return EFail; + } + + User::After(KTwoSeconds); + // make sure we're still playing + if (iCurrentState != CMdaAudioRecorderUtility::EPlaying) + return EInconclusive; + position = iRecorderUtility->Position(); + + // wait once for end of play - this should produce KErrNone + CActiveScheduler::Start(); + if (iError != KErrNone) + iTestStepResult = EFail; + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + timeEnd.UniversalTime(); // stop the timer + + // save the first play's duration + playDuration1 = timeEnd.MicroSecondsFrom(timeStart); + + + // Play the file again + INFO_PRINTF1( _L("Playing file for the second time...")); + timeStart.UniversalTime(); // start the timer + TRAP(err, iRecorderUtility->PlayL()); + if (err != KErrNone) + return EInconclusive; + // wait once for start of play + CActiveScheduler::Start(); + if (iError != KErrNone) + iTestStepResult = EFail; + if (iCurrentState != CMdaAudioRecorderUtility::EPlaying) + return EFail; + + // check the position is close to the start of the file + // and much less than 2 seconds + position = iRecorderUtility->Position(); + INFO_PRINTF2(_L("Start position = %d microseconds"), I64INT(position.Int64())); + if (position.Int64() > KHalfSecond) + { + INFO_PRINTF1(_L("Start position is too high")); + return EFail; + } + + // wait once for end of play - this should produce KErrNone + CActiveScheduler::Start(); + if (iError != KErrNone) + iTestStepResult = EFail; + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + timeEnd.UniversalTime(); // stop the timer + + // save the second play's durarion + playDuration2 = timeEnd.MicroSecondsFrom(timeStart); + + // Now compare how long it took to play the file in both cases + // calculate the difference (hopefully pretty small) + TInt64 playDurationDiff = playDuration2.Int64() - playDuration1.Int64(); + // make sure it's a positive number + if (playDurationDiff < 0) + playDurationDiff = -playDurationDiff; + + INFO_PRINTF2(_L("Duration #1 = %d microseconds"), playDuration1.Int64()); + INFO_PRINTF2(_L("Duration #2 = %d microseconds"), playDuration2.Int64()); + INFO_PRINTF2(_L("Difference = %d microseconds"), playDurationDiff); + if (playDurationDiff > KQuarterSecond) + { + INFO_PRINTF1(_L("Difference is too high")); + iTestStepResult = EFail; + } + + + + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + + + +// + + +/** + * + * Static constructor for CTestStepPlayerPlayAndClearWindow. + * + * + * @return "CTestStepPlayerPlayAndClearWindow*" + * The constructed CTestStepPlayerPlayAndClearWindow + * + * @xxxx + * + */ +CTestStepPlayerPlayAndClearWindow* CTestStepPlayerPlayAndClearWindow::NewL() + { + CTestStepPlayerPlayAndClearWindow* self = new(ELeave) CTestStepPlayerPlayAndClearWindow; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepPlayerPlayAndClearWindow::CTestStepPlayerPlayAndClearWindow() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0824-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepPlayerPlayAndClearWindow::~CTestStepPlayerPlayAndClearWindow() + { + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepPlayerPlayAndClearWindow::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this is a test of calling Play, clearing the play window")); + INFO_PRINTF1(_L("and then playing again & verifying the whole clip is played")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file + { + return EInconclusive; + } + + // create a play utility + TRAP(err, iPlayerUtility = CMdaAudioPlayerUtility::NewL(*this)); + if (err != KErrNone) + return EInconclusive; + + // create a recorder utility + TRAP(err, iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepPlayerPlayAndClearWindow::DoTestStepPostambleL(void) + { + delete iPlayerUtility; + iPlayerUtility = NULL; + delete iRecorderUtility; + iRecorderUtility = NULL; + + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepPlayerPlayAndClearWindow::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/) + { + INFO_PRINTF2(_L("MapcInitComplete(): error = %d"), aError); + iError = aError; + CActiveScheduler::Stop(); + } + +void CTestStepPlayerPlayAndClearWindow::MapcPlayComplete(TInt aError) + { + INFO_PRINTF2(_L("MapcPlayComplete(): error = %d"), aError); + iError = aError; + CActiveScheduler::Stop(); + } + + +void CTestStepPlayerPlayAndClearWindow::MoscoStateChangeEvent(CBase* /*aObject*/, + TInt aPreviousState, + TInt aCurrentState, + TInt aErrorCode) + { + INFO_PRINTF4(_L("MoscoStateChangeEvent(): Previous state = %d, current state = %d, error = %d"), + aPreviousState, + aCurrentState, + aErrorCode); + iError = aErrorCode; + iCurrentState = aCurrentState; + CActiveScheduler::Stop(); + } + + +TVerdict CTestStepPlayerPlayAndClearWindow::DoTestStepPlayerL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + const TInt KHalfSecond = 500000; + + INFO_PRINTF1(_L("Opening file using player utility...")); + + // open the sound file + TRAP(err, iPlayerUtility->OpenFileL(iFileName)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + + TTimeIntervalMicroSeconds duration = iPlayerUtility->Duration(); + TTimeIntervalMicroSeconds position; + TTimeIntervalMicroSeconds playStart = duration.Int64()/2; + TTimeIntervalMicroSeconds playEnd = duration; + + // sequence #1A + // SetPlayWindow, Play & verify we play from start of window,stop + INFO_PRINTF1(_L("Sequence #1A...")); + INFO_PRINTF1(_L("calling SetPlayWindow...")); + iPlayerUtility->SetPlayWindow(playStart, playEnd); + INFO_PRINTF1(_L("calling play...")); + iPlayerUtility->Play(); + + INFO_PRINTF1(_L("calling GetPosition...")); + iPlayerUtility->GetPosition(position); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() < playStart.Int64()) + { + INFO_PRINTF2(_L("play position is not at start of play window - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + INFO_PRINTF1(_L("calling stop...")); + iPlayerUtility->Stop(); + + // sequence #1B + // Play & verify we play from start of window,stop + INFO_PRINTF1(_L("Sequence #1B...")); + INFO_PRINTF1(_L("calling play...")); + iPlayerUtility->Play(); + iPlayerUtility->GetPosition(position); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() < playStart.Int64()) + { + INFO_PRINTF2(_L("play position is not at start of play window - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + + // sequence #1C + // ClearPlayWindow, Stop, play & verify we play from start of clip,stop + INFO_PRINTF1(_L("Sequence #1C...")); + INFO_PRINTF1(_L("calling ClearPlayWindow...")); + iPlayerUtility->ClearPlayWindow(); + INFO_PRINTF1(_L("calling stop...")); + iPlayerUtility->Stop(); + INFO_PRINTF1(_L("calling play...")); + iPlayerUtility->Play(); + INFO_PRINTF1(_L("calling GetPosition...")); + iPlayerUtility->GetPosition(position); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() > KHalfSecond) + { + INFO_PRINTF2(_L("play position is not at start of clip - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + INFO_PRINTF1(_L("calling stop...")); + iPlayerUtility->Stop(); + + // sequence #2 + // play, SetPlayWindow,stop,ClearPlayWindow,Play & verify we play from + // start of clip + INFO_PRINTF1(_L("Sequence #2...")); + INFO_PRINTF1(_L("calling play...")); + iPlayerUtility->Play(); + INFO_PRINTF1(_L("calling SetPlayWindow...")); + iPlayerUtility->SetPlayWindow(playStart, playEnd); + INFO_PRINTF1(_L("calling stop...")); + iPlayerUtility->Stop(); + INFO_PRINTF1(_L("calling ClearPlayWindow...")); + iPlayerUtility->ClearPlayWindow(); + INFO_PRINTF1(_L("calling play...")); + iPlayerUtility->Play(); + INFO_PRINTF1(_L("calling GetPosition...")); + iPlayerUtility->GetPosition(position); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() > KHalfSecond) + { + INFO_PRINTF2(_L("play position is not at start of clip - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + INFO_PRINTF1(_L("calling stop...")); + iPlayerUtility->Stop(); + + + INFO_PRINTF1(_L("finished with this test step")); + + return iTestStepResult; + } + +TVerdict CTestStepPlayerPlayAndClearWindow::DoTestStepRecorderL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + const TInt KHalfSecond = 500000; + + INFO_PRINTF1(_L("Opening file using recorder utility...")); + + // open the sound file + TRAP(err, iRecorderUtility->OpenFileL(iFileName)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + + TTimeIntervalMicroSeconds duration = iRecorderUtility->Duration(); + TTimeIntervalMicroSeconds position; + TTimeIntervalMicroSeconds playStart = duration.Int64()/2; + TTimeIntervalMicroSeconds playEnd = duration; + + // sequence #1A + // SetPlayWindow, Play & verify we play from start of window,stop + INFO_PRINTF1(_L("Sequence #1A...")); + INFO_PRINTF1(_L("calling SetPlayWindow...")); + iRecorderUtility->SetPlayWindow(playStart, playEnd); + INFO_PRINTF1(_L("calling play...")); + iRecorderUtility->PlayL(); + // wait for play to start + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + + INFO_PRINTF1(_L("calling GetPosition...")); + position = iRecorderUtility->Position(); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() < playStart.Int64()) + { + INFO_PRINTF2(_L("play position is not at start of play window - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + INFO_PRINTF1(_L("calling stop...")); + iRecorderUtility->Stop(); + + // sequence #1B + // Play & verify we play from start of window,stop + INFO_PRINTF1(_L("Sequence #1B...")); + INFO_PRINTF1(_L("calling play...")); + iRecorderUtility->PlayL(); + // wait for play to start + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + position = iRecorderUtility->Position(); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() < playStart.Int64()) + { + INFO_PRINTF2(_L("play position is not at start of play window - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + + // sequence #1C + // ClearPlayWindow, Stop, play & verify we play from start of clip,stop + INFO_PRINTF1(_L("Sequence #1C...")); + INFO_PRINTF1(_L("calling ClearPlayWindow...")); + iRecorderUtility->ClearPlayWindow(); + INFO_PRINTF1(_L("calling stop...")); + iRecorderUtility->Stop(); + INFO_PRINTF1(_L("calling play...")); + iRecorderUtility->PlayL(); + // wait for play to start + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + INFO_PRINTF1(_L("calling GetPosition...")); + position = iRecorderUtility->Position(); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() > KHalfSecond) + { + INFO_PRINTF2(_L("play position is not at start of clip - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + INFO_PRINTF1(_L("calling stop...")); + iRecorderUtility->Stop(); + + // sequence #2 + // play, SetPlayWindow,stop,ClearPlayWindow,Play & verify we play from + // start of clip + INFO_PRINTF1(_L("Sequence #2...")); + INFO_PRINTF1(_L("calling play...")); + iRecorderUtility->PlayL(); + // wait for play to start + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + INFO_PRINTF1(_L("calling SetPlayWindow...")); + iRecorderUtility->SetPlayWindow(playStart, playEnd); + INFO_PRINTF1(_L("calling stop...")); + iRecorderUtility->Stop(); + INFO_PRINTF1(_L("calling ClearPlayWindow...")); + iRecorderUtility->ClearPlayWindow(); + INFO_PRINTF1(_L("calling play...")); + iRecorderUtility->PlayL(); + // wait for play to start + CActiveScheduler::Start(); + if (iError != KErrNone) + return EFail; + INFO_PRINTF1(_L("calling GetPosition...")); + position = iRecorderUtility->Position(); + INFO_PRINTF2(_L("play position = %d"), position.Int64()); + if (position.Int64() > KHalfSecond) + { + INFO_PRINTF2(_L("play position is not at start of clip - %d"), position.Int64()); + iTestStepResult = EFail; + return iTestStepResult; + } + INFO_PRINTF1(_L("calling stop...")); + iRecorderUtility->Stop(); + + + INFO_PRINTF1(_L("finished with this test step")); + + return iTestStepResult; + } + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepPlayerPlayAndClearWindow::DoTestStepL() + { + + // run the same test with the player utility & then the recorded utility + iTestStepResult = DoTestStepPlayerL(); + + if (iTestStepResult == EPass) + iTestStepResult = DoTestStepRecorderL(); + + return iTestStepResult; + } + + + +// + + +/** + * + * Static constructor for CTestStepRecorderSetPosition. + * + * + * @return "CTestStepRecorderSetPosition*" + * The constructed CTestStepRecorderSetPosition + * + * @xxxx + * + */ +CTestStepRecorderSetPosition* CTestStepRecorderSetPosition::NewL() + { + CTestStepRecorderSetPosition* self = new(ELeave) CTestStepRecorderSetPosition; + return self; + } + +/** + * + * Test step constructor. + * Each test step initialises its own name. + * + * @xxxx + * + */ +CTestStepRecorderSetPosition::CTestStepRecorderSetPosition() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACLNT-U-0825-HP"); + } + +/** + * + * Test step destructor. + * + * @xxxx + * + */ +CTestStepRecorderSetPosition::~CTestStepRecorderSetPosition() + { + } + +/** + * + * Test step Preamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSetPosition::DoTestStepPreambleL(void) + { + TInt err; + + TVerdict verdict; + // this installs the scheduler + verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL(); + + // Printing to the console and log file + INFO_PRINTF2(_L("%S"), &iTestStepName); + INFO_PRINTF1(_L("this tests the responsiveness of CMdaAudioRecorderUtility Setposition()")); + + if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName2"), iFileName)) // wav file + { + return EInconclusive; + } + + // create a record utility + TRAP(err, iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this)); + if (err != KErrNone) + return EInconclusive; + + return verdict; + + } + +/** + * + * Test step Postamble. + * + * @xxxx + * + */ +enum TVerdict CTestStepRecorderSetPosition::DoTestStepPostambleL(void) + { + delete iRecorderUtility; + iRecorderUtility = NULL; + //[ Destroy the scheduler ] + return CTestStepUnitMMFAudClient::DoTestStepPostambleL(); + } + +/** + * + * Callback Handle. + * + * @xxxx + * + */ +void CTestStepRecorderSetPosition::MoscoStateChangeEvent(CBase* /*aObject*/, + TInt /*aPreviousState*/, + TInt aCurrentState, + TInt aErrorCode) + { + iError = aErrorCode; + iCurrentState = aCurrentState; + CActiveScheduler::Stop(); + } + + +void CTestStepRecorderSetPosition::MatoPrepareComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPrepareComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + +void CTestStepRecorderSetPosition::MatoPlayComplete(TInt aError) + { + INFO_PRINTF2(_L("MatoPlayComplete(): error = %d"), aError); + iErrorTone = aError; + CActiveScheduler::Stop(); + } + + +/** + * + * Do the test step. + * Each test step must supply an implementation for DoTestStepL. + * + * @return "TVerdict" + * The result of the test step + * + * @xxxx + * + */ +TVerdict CTestStepRecorderSetPosition::DoTestStepL() + { + iTestStepResult = EPass; + TInt err = KErrNone; + + const TInt KFiveSeconds = 5000000; + const TInt KTwoSeconds = 2000000; + const TInt KReplayedTime = KFiveSeconds - KTwoSeconds; + + INFO_PRINTF2( _L("Playing file for %d microseconds..."), KFiveSeconds); + INFO_PRINTF2( _L("and then resetting position to %d microseconds from start of file..."), KTwoSeconds); + + // open the sound file + TRAP(err, iRecorderUtility->OpenFileL(iFileName)); + if (err != KErrNone) + return EInconclusive; + // wait for open to complete + CActiveScheduler::Start(); + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + + TTime timeStart; + TTime timeEnd; + TTimeIntervalMicroSeconds playDuration; + TTimeIntervalMicroSeconds position; +// usually the WINS emulator responds within 300 ms, but about 30% +// of the time it takes significantly longer. Have chosen to allow this +// for emulator only (presumably it's down to other processes on the +// PC slowing things down...) +#ifdef __WINS__ + const TInt KAllowedDeviation = 750000; +#else + const TInt KAllowedDeviation = 350000; +#endif + + // Start playing the file and after a while change the position + TRAP(err, iRecorderUtility->PlayL()); + if (err != KErrNone) + return EInconclusive; + // wait once for start of play + CActiveScheduler::Start(); + if (iError != KErrNone) + iTestStepResult = EFail; + if (iCurrentState != CMdaAudioRecorderUtility::EPlaying) + return EFail; + timeStart.UniversalTime(); // start the timer + User::After(KFiveSeconds); + // make sure we're still playing + if (iCurrentState != CMdaAudioRecorderUtility::EPlaying) + return EInconclusive; + position = iRecorderUtility->Position(); + iRecorderUtility->SetPosition(TTimeIntervalMicroSeconds(KTwoSeconds)); + + // wait once for end of play - this should produce KErrNone + CActiveScheduler::Start(); + if (iError != KErrNone) + iTestStepResult = EFail; + if (iCurrentState != CMdaAudioRecorderUtility::EOpen) + return EFail; + timeEnd.UniversalTime(); // stop the timer + + // save the first play's duration + playDuration = timeEnd.MicroSecondsFrom(timeStart); + + + TTimeIntervalMicroSeconds clipDuration = iRecorderUtility->Duration(); + TTimeIntervalMicroSeconds expectedDuration = + TTimeIntervalMicroSeconds(clipDuration.Int64() + KReplayedTime); + + // Now compare how long it took to play the file + TInt64 playDurationDiff = expectedDuration.Int64() - playDuration.Int64(); + // make sure it's a positive number + if (playDurationDiff < 0) + playDurationDiff = -playDurationDiff; + + INFO_PRINTF2(_L("Clip duration = %d microseconds"), I64LOW(clipDuration.Int64())); + INFO_PRINTF2(_L("Expected play duration = %d microseconds"), I64LOW(expectedDuration.Int64())); + INFO_PRINTF2(_L("Time to play = %d microseconds"), playDuration.Int64()); + + INFO_PRINTF2(_L("Difference = %d microseconds"), playDurationDiff); + if (playDurationDiff > KAllowedDeviation) + { + INFO_PRINTF1(_L("Difference is too high")); + iTestStepResult = EFail; + } + + INFO_PRINTF1(_L("finished with this test step")); + + // test steps return a result + return iTestStepResult; + } + + +