Bug 3673 - Seeking via grabbing the Music Player progress bar does not work.
// Copyright (c) 2008-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:
// Part of the TSI_MMFACLNT suite that tests CR1566 (TruePause) on AudioOutputStream
//
//
/**
@file TestOutputStreamTruePause.cpp
*/
#include "testoutputstreamtruepause.h"
/*
*
* RMdaOutputStreamTestBase - Test step constructor
*
*/
RMdaOutputStreamTestBase::RMdaOutputStreamTestBase(const TDesC& aTestName, const TDesC& aSectName)
: iAudioOutputStreamState(EStateAOSInitial),
iAudioOutputStream(NULL),
iTimer(NULL),
iWait(EFalse),
iConfig(EFalse),
iInvalidConfig(EFalse),
iGetBytes(EFalse),
iCount(0),
iVolume(0),
iBalance(0),
iDuration(0),
iPause(0),
iBytes(0),
iPosition(0),
iFilename(KNullDesC)
{
iTestStepName = aTestName;
iSectName = aSectName;
}
/*
*
* ~RMdaOutputStreamTestBase - Test step destructor
*
*/
RMdaOutputStreamTestBase::~RMdaOutputStreamTestBase()
{
if (iAudioOutputStream)
{
delete iAudioOutputStream;
}
if(iTimer)
{
delete iTimer;
}
iFile.Close();
iFs.Close();
iBuffer.Close();
}
/*
*
* KickoffTestL - Starts the test
*
*/
void RMdaOutputStreamTestBase::KickoffTestL()
{
User::LeaveIfError(iFs.Connect());
INFO_PRINTF1(_L("__________ Creating AudioOutputStream object ___________"));
TRAPD(err, iAudioOutputStream = CMdaAudioOutputStream::NewL(*this));
if (err != KErrNone)
{
ERR_PRINTF2(_L("Could not create Tone Utility object. Error = %d"), err);
StopTest(err);
return;
}
INFO_PRINTF1(_L("AudioOutputStream State: EStateCreated"));
iAudioOutputStreamState = EStateAOSCreated;
DoKickoffTestL();
INFO_PRINTF1(_L("AudioOutputStream: EEventInitialize"));
Fsm(EEventAOSInitialize, KErrNone);
}
/*
*
* CloseTest
*
*/
void RMdaOutputStreamTestBase::CloseTest()
{
INFO_PRINTF1(_L("Deleting AudioOutputStream object"));
delete iAudioOutputStream;
delete iTimer;
}
/*
*
* StartTimer - Starts timer and timer callback
*
*/
void RMdaOutputStreamTestBase::StartTimer(TTimeIntervalMicroSeconds32 aWaitTime)
{
TTimeIntervalMicroSeconds32 timeInterval;
if(aWaitTime <= TTimeIntervalMicroSeconds32(0))
{
timeInterval = KOneSecond;
}
else
{
timeInterval = aWaitTime;
}
TCallBack callback (TimerCallback, this);
iTimer->Start(timeInterval, timeInterval, callback);
INFO_PRINTF1(_L("Timer has been started"));
}
/*
*
* TimerCallback
*
*/
TInt RMdaOutputStreamTestBase::TimerCallback(TAny* aPtr)
{
static_cast<RMdaOutputStreamTestBase*>(aPtr)->DoTimerCallback();
return KErrNone;
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaOutputStreamTestBase::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError)
{
TInt error = 0;
TTimeIntervalMicroSeconds resumeposition;
switch (iAudioOutputStreamState)
{
case EStateAOSCreated:
{
if (aMdaAudioOutputStreamEvent == EEventAOSInitialize)
{
TMdaAudioDataSettings settings;
//Default settings
settings.Query();
settings.iChannels = TMdaAudioDataSettings::EChannelsMono;
settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open"));
iAudioOutputStream->Open(&settings);
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing"));
iAudioOutputStreamState = EStateAOSInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSInitializing:
{
if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2);
INFO_PRINTF1(_L("Starting playback"));
iAudioOutputStream->WriteL(iBuffer);
iAudioOutputStreamState = EStateAOSPlaying;
StartTimer(iPause*KOneSecond);
}
else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSPlaying:
{
if(aMdaAudioOutputStreamEvent == EEventAOSTimerComplete)
{
if(!iGetBytes)
{
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause"));
error = iAudioOutputStream->Pause();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Pause returned with KErrNone as expected"));
}
else
{
ERR_PRINTF2(_L("Pause returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
iPosition = iAudioOutputStream->Position();
INFO_PRINTF2(_L("Stream was paused at %Ld"),iPosition.Int64());
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause"));
iAudioOutputStreamState = EStateAOSPause;
iWait = EFalse;
}
if(iGetBytes)
{
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause"));
error = iAudioOutputStream->Pause();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Pause returned with KErrNone as expected"));
}
else
{
ERR_PRINTF2(_L("Pause returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause"));
iPosition = iAudioOutputStream->Position();
INFO_PRINTF2(_L("Stream was paused at %Ld"),iPosition.Int64());
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause"));
iAudioOutputStreamState = EStateAOSPause;
iWait = EFalse;
INFO_PRINTF1(_L("Calling GetBytes"));
iBytes = iAudioOutputStream->GetBytes();
}
}
else
{
ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSPause:
{
if (aMdaAudioOutputStreamEvent == EEventAOSTimerComplete)
{
if(!iWait && !iConfig && !iInvalidConfig && !iGetBytes)
{
if(iPosition == iAudioOutputStream->Position())
{
INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64());
StopTest(KErrGeneral);
}
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume"));
error = iAudioOutputStream->Resume();
resumeposition = iAudioOutputStream->Position();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iAudioOutputStreamState = EStateAOSPlaying;
if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2)
{
INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64());
StopTest(KErrGeneral);
}
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
}
else if(!iWait && iConfig)
{
if(iPosition == iAudioOutputStream->Position())
{
INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64());
StopTest(KErrGeneral);
}
INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause);
INFO_PRINTF3(_L("Changing Volume and Balance while paused to Volume = %d and Balance = %d"),iVolume,iBalance);
iAudioOutputStream->SetVolume(iVolume);
iAudioOutputStream->SetBalanceL(iBalance);
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume"));
error = iAudioOutputStream->Resume();
resumeposition = iAudioOutputStream->Position();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iAudioOutputStreamState = EStateAOSPlaying;
if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2)
{
INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64());
StopTest(KErrGeneral);
}
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
iConfig = EFalse;
}
else if(!iWait && iInvalidConfig)
{
if(iPosition == iAudioOutputStream->Position())
{
INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64());
StopTest(KErrGeneral);
}
INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause);
INFO_PRINTF1(_L("Changing AudioProperties while paused"));
TRAPD(err,iAudioOutputStream->SetAudioPropertiesL(TMdaAudioDataSettings::ESampleRate48000Hz, TMdaAudioDataSettings::EChannelsStereo));
if(err == KErrNotReady)
{
INFO_PRINTF1(_L("SetAudioPropertiesL returned with KErrNotReady as expected"));
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume"));
error = iAudioOutputStream->Resume();
resumeposition = iAudioOutputStream->Position();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iAudioOutputStreamState = EStateAOSPlaying;
if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2)
{
INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64());
StopTest(KErrGeneral);
}
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),err);
StopTest(err);
}
iInvalidConfig = EFalse;
}
else
{
ERR_PRINTF2(_L("SetAudioPropertiesL did not return with KErrNotSupported as expected, returned with %d instead"), err);
StopTest(KErrGeneral);
}
}
else if(!iWait && iGetBytes)
{
if(iPosition == iAudioOutputStream->Position())
{
INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64());
StopTest(KErrGeneral);
}
INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause);
INFO_PRINTF1(_L("Calling GetBytes to verify the value hasn't changed"));
TInt myBytes = iAudioOutputStream->GetBytes();
if(myBytes == iBytes)
{
INFO_PRINTF1(_L("GetBytes value did not change while in pause, this is expected."));
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume"));
error = iAudioOutputStream->Resume();
resumeposition = iAudioOutputStream->Position();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iAudioOutputStreamState = EStateAOSPlaying;
if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2)
{
INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64());
StopTest(KErrGeneral);
}
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
iGetBytes = EFalse;
}
else
{
ERR_PRINTF3(_L("GetBytes value changed while in pause, this is unexpected. Expected = %d Retrieved = %d"),iBytes,myBytes);
StopTest(KErrGeneral);
}
}
}
else
{
ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState);
StopTest(KErrGeneral);
}
}
}
/*
*
* MaoscOpenComplete - From MMdaAudioOutputStreamObserver
*
*/
void RMdaOutputStreamTestBase::MaoscOpenComplete(TInt aError)
{
INFO_PRINTF1(_L("========== AudioOutputStream MaoscOpenComplete() callback =========="));
if(iAudioOutputStreamState == EStateAOSInitializing)
{
INFO_PRINTF1(_L("AudioOutputStream MaoscOpenComplete"));
Fsm(EEventAOSOpenComplete, aError);
}
}
/*
*
* MaoscBufferCopied - From MMdaAudioOutputStreamObserver
*
*/
void RMdaOutputStreamTestBase::MaoscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/)
{
INFO_PRINTF1(_L("========== AudioOutputStream MaoscBufferCopied() callback =========="));
INFO_PRINTF1(_L("Reading file"));
TInt err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
if (iBuffer != KNullDesC8 && iAudioOutputStreamState != EStateAOSStopped)
{
INFO_PRINTF1(_L("Writing to stream"));
iAudioOutputStream->WriteL(iBuffer);
}
if(iAudioOutputStreamState == EStateAOSPlaying)
{
INFO_PRINTF1(_L("AudioOutputStream MaoscBufferCopied"));
}
else if(iAudioOutputStreamState == EStateAOSPause)
{
ERR_PRINTF1(_L("AudioOutputStream MaoscBufferCopied in Paused. This is unexpected"));
StopTest(KErrGeneral);
}
}
/*
*
* MaoscPlayComplete - From MMdaAudioOutputStreamObserver
*
*/
void RMdaOutputStreamTestBase::MaoscPlayComplete(TInt aError)
{
INFO_PRINTF1(_L("========== AudioOutputStream MaoscPlayComplete() callback =========="));
if (aError == KErrUnderflow)
{
INFO_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d as expected"), aError);
StopTest(EPass);
}
else
{
ERR_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d"), aError);
ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow);
StopTest(aError);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0175-HP
*========================================================================================================
*/
RMdaOutputStreamPauseResumeBeforeWriteTest::RMdaOutputStreamPauseResumeBeforeWriteTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamPauseResumeBeforeWriteTest* RMdaOutputStreamPauseResumeBeforeWriteTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamPauseResumeBeforeWriteTest * self = new(ELeave)RMdaOutputStreamPauseResumeBeforeWriteTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamPauseResumeBeforeWriteTest::DoKickoffTestL()
{
TPtrC filename;
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
iPause = KTimeout; //Set timeout to stop test if playback was paused
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaOutputStreamPauseResumeBeforeWriteTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError)
{
TInt error = 0;
TTimeIntervalMicroSeconds resumeposition;
switch (iAudioOutputStreamState)
{
case EStateAOSCreated:
{
if (aMdaAudioOutputStreamEvent == EEventAOSInitialize)
{
TMdaAudioDataSettings settings;
//Default settings
settings.Query();
settings.iChannels = TMdaAudioDataSettings::EChannelsMono;
settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause before Open"));
error = iAudioOutputStream->Pause();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Pause before open returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Pause before open returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open"));
iAudioOutputStream->Open(&settings);
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing"));
iAudioOutputStreamState = EStateAOSInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSInitializing:
{
if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2);
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause before first WriteL"));
error = iAudioOutputStream->Pause();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Pause before first WriteL returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Pause before first WriteL returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Resume before first WriteL"));
error = iAudioOutputStream->Resume();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Resume before first WriteL returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Resume before first WriteL returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Starting playback"));
iAudioOutputStream->WriteL(iBuffer);
iAudioOutputStreamState = EStateAOSPlaying;
StartTimer(iPause*KOneSecond);
}
else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState);
StopTest(KErrGeneral);
}
}
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamPauseResumeBeforeWriteTest::DoTimerCallback()
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
ERR_PRINTF1(_L("Playback was paused when it shouldn't"));
StopTest(KErrGeneral);
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0176-HP
*========================================================================================================
*/
RMdaOutputStreamResumeTest::RMdaOutputStreamResumeTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamResumeTest* RMdaOutputStreamResumeTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamResumeTest * self = new(ELeave)RMdaOutputStreamResumeTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamResumeTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamResumeTest::DoTimerCallback()
{
if(!iWait)
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
}
else
{
INFO_PRINTF1(_L("MdaAudioOutputStream Event: EEventTimerComplete"));
}
Fsm (EEventAOSTimerComplete, KErrNone);
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0177-HP
*========================================================================================================
*/
RMdaOutputStreamResumeThriceTest::RMdaOutputStreamResumeThriceTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamResumeThriceTest* RMdaOutputStreamResumeThriceTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamResumeThriceTest * self = new(ELeave)RMdaOutputStreamResumeThriceTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamResumeThriceTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamResumeThriceTest::DoTimerCallback()
{
iCount++;
if(!iWait && iCount == 2*KRepeatThrice) //Repeating Pause-Resume cycle three times. Timer should be called 6 times
{
iTimer->Cancel();
Fsm (EEventAOSTimerComplete, KErrNone);
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventAOSTimerComplete, KErrNone);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0178-HP
*========================================================================================================
*/
RMdaOutputStreamConfigInPauseTest::RMdaOutputStreamConfigInPauseTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamConfigInPauseTest* RMdaOutputStreamConfigInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamConfigInPauseTest * self = new(ELeave)RMdaOutputStreamConfigInPauseTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamConfigInPauseTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the volume
if (!GetIntFromConfig(iSectName, KVolume, iVolume))
{
ERR_PRINTF1(_L("Volume could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the balance
if (!GetIntFromConfig(iSectName, KBalance, iBalance))
{
ERR_PRINTF1(_L("Balance could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
iConfig = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamConfigInPauseTest::DoTimerCallback()
{
if(!iWait && !iConfig)
{
iTimer->Cancel();
INFO_PRINTF1(_L("Comparing Volume and Balance with values set"));
if (iVolume == iAudioOutputStream->Volume() && Abs(iBalance - iAudioOutputStream->GetBalanceL())<KBalanceTolerance)
{
INFO_PRINTF3(_L("Volume = %d and Balance = %d as expected"),iVolume,iBalance);
}
else
{
ERR_PRINTF1(_L("Retrieved values are different than expected"));
ERR_PRINTF5(_L("Retrieved Volume = %d and Balance = %d. Expected Volume = %d and Balance = %d"),iAudioOutputStream->Volume(),iAudioOutputStream->GetBalanceL(),iVolume,iBalance);
StopTest(KErrGeneral);
}
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventAOSTimerComplete, KErrNone);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0179-HP
*========================================================================================================
*/
RMdaOutputStreamInvalidConfigInPauseTest::RMdaOutputStreamInvalidConfigInPauseTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamInvalidConfigInPauseTest* RMdaOutputStreamInvalidConfigInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamInvalidConfigInPauseTest * self = new(ELeave)RMdaOutputStreamInvalidConfigInPauseTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamInvalidConfigInPauseTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
iInvalidConfig = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamInvalidConfigInPauseTest::DoTimerCallback()
{
if(!iWait)
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
}
else
{
INFO_PRINTF1(_L("MdaAudioOutputStream Event: EEventTimerComplete"));
}
Fsm (EEventAOSTimerComplete, KErrNone);
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0180-HP
*========================================================================================================
*/
RMdaOutputStreamGetBytesInPauseTest::RMdaOutputStreamGetBytesInPauseTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamGetBytesInPauseTest* RMdaOutputStreamGetBytesInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamGetBytesInPauseTest * self = new(ELeave)RMdaOutputStreamGetBytesInPauseTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamGetBytesInPauseTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
iGetBytes = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamGetBytesInPauseTest::DoTimerCallback()
{
if(!iWait)
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
}
else
{
INFO_PRINTF1(_L("MdaAudioOutputStream Event: EEventTimerComplete"));
}
Fsm (EEventAOSTimerComplete, KErrNone);
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0181-HP
*========================================================================================================
*/
RMdaOutputStreamPlayPauseStopPlayTest::RMdaOutputStreamPlayPauseStopPlayTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamPlayPauseStopPlayTest* RMdaOutputStreamPlayPauseStopPlayTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamPlayPauseStopPlayTest * self = new(ELeave)RMdaOutputStreamPlayPauseStopPlayTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamPlayPauseStopPlayTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
iStop = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamPlayPauseStopPlayTest::DoTimerCallback()
{
if(!iWait && iStop)
{
iAudioOutputStreamState = EStateAOSStopped;
iStop = EFalse;
iWait = ETrue;
INFO_PRINTF1(_L("MAudioOutputStream Event: EEventTimerComplete"));
Fsm (EEventAOSTimerComplete, KErrNone);
}
else if(!iWait && !iStop)
{
iTimer->Cancel();
Fsm (EEventAOSTimerComplete, KErrNone);
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventAOSTimerComplete, KErrNone);
}
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaOutputStreamPlayPauseStopPlayTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError)
{
TInt error = 0;
TTimeIntervalMicroSeconds resumeposition;
switch (iAudioOutputStreamState)
{
case EStateAOSCreated:
{
if (aMdaAudioOutputStreamEvent == EEventAOSInitialize)
{
TMdaAudioDataSettings settings;
//Default settings
settings.Query();
settings.iChannels = TMdaAudioDataSettings::EChannelsMono;
settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open"));
iAudioOutputStream->Open(&settings);
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing"));
iAudioOutputStreamState = EStateAOSInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSInitializing:
{
if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2);
INFO_PRINTF1(_L("Starting playback"));
iAudioOutputStream->WriteL(iBuffer);
iAudioOutputStreamState = EStateAOSPlaying;
StartTimer(iPause*KOneSecond);
}
else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSPlaying:
{
if(aMdaAudioOutputStreamEvent == EEventAOSTimerComplete)
{
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause"));
error = iAudioOutputStream->Pause();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Pause returned with KErrNone as expected"));
}
else
{
ERR_PRINTF2(_L("Pause returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
iPosition = iAudioOutputStream->Position();
INFO_PRINTF2(_L("Stream was paused at %Ld"),iPosition.Int64());
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStatePause"));
iAudioOutputStreamState = EStateAOSPause;
iWait = EFalse;
}
else
{
ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSPause:
{
if (aMdaAudioOutputStreamEvent == EEventAOSTimerComplete)
{
if(iPosition == iAudioOutputStream->Position())
{
INFO_PRINTF2(_L("Paused position was maintained at %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Position was not maintained during pause. Expected %Ld Retrieved %Ld"),iPosition.Int64(),iAudioOutputStream->Position().Int64());
StopTest(KErrGeneral);
}
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioOutputStream::Resume"));
error = iAudioOutputStream->Resume();
resumeposition = iAudioOutputStream->Position();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iAudioOutputStreamState = EStateAOSPlaying;
if(Abs(resumeposition.Int64() - iPosition.Int64()) <= KOneSecond/2)
{
INFO_PRINTF2(_L("Playback resumed from expected position %Ld"),iPosition.Int64());
}
else
{
ERR_PRINTF3(_L("Playback did not resume from expected position. Expected %Ld Retrieved %Ld"),iPosition.Int64(),resumeposition.Int64());
StopTest(KErrGeneral);
}
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
}
else
{
ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSStopped:
{
if (aMdaAudioOutputStreamEvent == EEventAOSTimerComplete)
{
if(iWait)
{
INFO_PRINTF1(_L("Stopping playback for 2 seconds"));
iAudioOutputStream->Stop();
iWait = EFalse;
}
else
{
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Resume while in Stop"));
error = iAudioOutputStream->Resume();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Resume returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
TInt filepos = 0;
INFO_PRINTF1(_L("Restarting file to start position"));
error = iFile.Seek(ESeekStart, filepos);
if (error != KErrNone)
{
INFO_PRINTF2(_L("Error restarting iFile %d"), error);
StopTest(error);
}
error = iFile.Read(iBuffer);
if (error != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), error);
StopTest(error);
}
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::WriteL while in Stop to restart playback"));
iAudioOutputStream->WriteL(iBuffer);
iAudioOutputStreamState = EStateAOSPlaying;
}
}
else
{
ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState);
StopTest(KErrGeneral);
}
}
}
/*
*
* MaoscPlayComplete - From MMdaAudioOutputStreamObserver
*
*/
void RMdaOutputStreamPlayPauseStopPlayTest::MaoscPlayComplete(TInt aError)
{
INFO_PRINTF1(_L("========== AudioOutputStream MaoscPlayComplete() callback =========="));
if(iAudioOutputStreamState == EStateAOSStopped)
{
if (aError == KErrCancel)
{
INFO_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d as expected"), aError);
}
else
{
ERR_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d"), aError);
ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow);
StopTest(aError);
}
}
else if(iAudioOutputStreamState == EStateAOSPlaying)
{
if(aError == KErrUnderflow)
{
INFO_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d as expected"), aError);
StopTest(EPass);
}
else
{
ERR_PRINTF2(_L("AudioOutputStream called MaoscPlayComplete with error = %d"), aError);
ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow);
StopTest(aError);
}
}
else
{
ERR_PRINTF1(_L("AudioOutputStream called MaoscPlayComplete at invalid state"));
StopTest(KErrGeneral);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0182-HP
*========================================================================================================
*/
RMdaOutputStreamInvalidFormatsTest::RMdaOutputStreamInvalidFormatsTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamInvalidFormatsTest* RMdaOutputStreamInvalidFormatsTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamInvalidFormatsTest * self = new(ELeave)RMdaOutputStreamInvalidFormatsTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamInvalidFormatsTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KOggFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iWait = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamInvalidFormatsTest::DoTimerCallback()
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
Fsm (EEventAOSTimerComplete, KErrNone);
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaOutputStreamInvalidFormatsTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError)
{
TInt error = 0;
TTimeIntervalMicroSeconds resumeposition;
switch (iAudioOutputStreamState)
{
case EStateAOSCreated:
{
if (aMdaAudioOutputStreamEvent == EEventAOSInitialize)
{
TMdaAudioDataSettings settings;
//setting for OGG file
settings.Query();
settings.iChannels = TMdaAudioDataSettings::EChannelsStereo;
settings.iSampleRate = TMdaAudioDataSettings::ESampleRate44100Hz;
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open"));
iAudioOutputStream->Open(&settings);
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing"));
iAudioOutputStreamState = EStateAOSInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSInitializing:
{
if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone)
{
TFourCC KVORBDataType('V', 'O', 'R', 'B');
TRAPD(err,iAudioOutputStream->SetDataTypeL(KVORBDataType));
if(err != KErrNone)
{
INFO_PRINTF1(_L("Failed to set non-PCM Format"));
StopTest(err);
}
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2);
INFO_PRINTF1(_L("Starting playback"));
iAudioOutputStream->WriteL(iBuffer);
iAudioOutputStreamState = EStateAOSPlaying;
StartTimer(iPause*KOneSecond);
}
else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSPlaying:
{
if(aMdaAudioOutputStreamEvent == EEventAOSTimerComplete)
{
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause while playing non-PCM format"));
error = iAudioOutputStream->Pause();
if(error == KErrNotSupported)
{
INFO_PRINTF1(_L("Pause while playing non-PCM format returned with KErrNotSupported as expected"));
}
else
{
ERR_PRINTF2(_L("Pause while playing non-PCM format returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
}
else
{
ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState);
StopTest(KErrGeneral);
}
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0184-HP
*========================================================================================================
*/
RMdaOutputStreamPauseNonA3FTest::RMdaOutputStreamPauseNonA3FTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaOutputStreamTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaOutputStreamPauseNonA3FTest* RMdaOutputStreamPauseNonA3FTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaOutputStreamPauseNonA3FTest * self = new(ELeave)RMdaOutputStreamPauseNonA3FTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaOutputStreamPauseNonA3FTest::DoKickoffTestL()
{
TPtrC filename;
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KRawFile, filename))
{
ERR_PRINTF1(_L("Filename could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// open using RFile for playback
iFilename.Copy(filename);
TInt err = iFile.Open(iFs, iFilename, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF3(_L("Could not open input file %S. Error = %d"), &iFilename, err);
iFs.Close();
StopTest(err);
return;
}
// Get size of iFile
TInt filesize = 0;
err = iFile.Size(filesize);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);
StopTest(err);
return;
}
// Initialise iBuf
iBuffer.CreateMaxL(filesize/KFileDivision);
//Read first half of the file
err = iFile.Read(iBuffer);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error reading iFile %d"), err);
StopTest(err);
}
iPause = KTimeout; //Set timeout to stop test if playback was paused
iWait = ETrue;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaOutputStreamPauseNonA3FTest::DoTimerCallback()
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
ERR_PRINTF1(_L("Playback was paused when it shouldn't"));
StopTest(KErrGeneral);
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaOutputStreamPauseNonA3FTest::Fsm(TMdaAOSEvent aMdaAudioOutputStreamEvent, TInt aError)
{
switch (iAudioOutputStreamState)
{
case EStateAOSCreated:
{
if (aMdaAudioOutputStreamEvent == EEventAOSInitialize)
{
TMdaAudioDataSettings settings;
//Default settings
settings.Query();
settings.iChannels = TMdaAudioDataSettings::EChannelsMono;
settings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Open"));
iAudioOutputStream->Open(&settings);
INFO_PRINTF1(_L("MdaAudioOutputStream State: EStateInitializing"));
iAudioOutputStreamState = EStateAOSInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventInitialize not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
case EStateAOSInitializing:
{
if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iAudioOutputStream->SetVolume(iAudioOutputStream->MaxVolume()/2);
INFO_PRINTF1(_L("Starting playback"));
iAudioOutputStream->WriteL(iBuffer);
StartTimer(iPause*KOneSecond);
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Pause in non-a3f configuration"));
TInt err = iAudioOutputStream->Pause();
if(err == KErrNotSupported)
{
INFO_PRINTF1(_L("Pause in CMdaAudioOutputStream returned with KErrNotSupported as expected"));
}
else
{
ERR_PRINTF2(_L("Pause in CMdaAudioOutputStream returned with %d instead of KErrNotSupported as expected"),err);
StopTest(err);
}
INFO_PRINTF1(_L("Calling CMdaAudioOutputStream::Resume in non-a3f configuration"));
err = iAudioOutputStream->Resume();
if(err == KErrNotReady)
{
INFO_PRINTF1(_L("Resume in CMdaAudioOutputStream returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Resume in CMdaAudioOutputStream returned with %d instead of KErrNotReady as expected"),err);
StopTest(err);
}
}
else if (aMdaAudioOutputStreamEvent == EEventAOSOpenComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MaoscOpenComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioOutputStream EEventOpenComplete not received as expected. Received event: %d"), aMdaAudioOutputStreamEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioOutputStream state received: %d"), iAudioOutputStreamState);
StopTest(KErrGeneral);
}
}
}