// 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 AudioToneUtility
//
//
/**
@file ToneTruePause.cpp
*/
#include "tonetruepause.h"
#include "toneTest.h"
/*
*
* RMdaToneUtilityTestBase - Test step constructor
*
*/
RMdaToneUtilityTestBase::RMdaToneUtilityTestBase(const TDesC& aTestName, const TDesC& aSectName)
: iToneUtilityState(EStateInitial),
iToneUtility(NULL),
iTimer(NULL),
iWait(EFalse),
iStop(EFalse),
iConfig(EFalse),
iPrepare(EFalse),
iNegative(EFalse),
iCount(0),
iVolume(0),
iBalance(0),
iDuration(0),
iPause(0),
iExpected(0),
iFilename(KNullDesC)
{
iTestStepName = aTestName;
iSectName = aSectName;
}
/*
*
* ~RMdaToneUtilityTestBase - Test step destructor
*
*/
RMdaToneUtilityTestBase::~RMdaToneUtilityTestBase()
{
if (iToneUtility)
{
delete iToneUtility;
}
if(iTimer)
{
delete iTimer;
}
iFile.Close();
iFs.Close();
}
/*
*
* KickoffTestL - Starts the test
*
*/
void RMdaToneUtilityTestBase::KickoffTestL()
{
User::LeaveIfError(iFs.Connect());
INFO_PRINTF1(_L("__________ Creating Tone Utility object ___________"));
TRAPD(err, iToneUtility = CMdaAudioToneUtility::NewL(*this));
if (err != KErrNone)
{
ERR_PRINTF2(_L("Could not create Tone Utility object. Error = %d"), err);
StopTest(err);
return;
}
INFO_PRINTF1(_L("Tone Utility State: EStateCreated"));
iToneUtilityState = EStateCreated;
DoKickoffTestL();
INFO_PRINTF1(_L("Tone Utility Event: EEventInitialize"));
Fsm(EEventInitialize, KErrNone);
}
/*
*
* CloseTest
*
*/
void RMdaToneUtilityTestBase::CloseTest()
{
INFO_PRINTF1(_L("Deleting Tone Utility object"));
delete iToneUtility;
delete iTimer;
}
/*
*
* StartTimer - Starts timer and timer callback
*
*/
void RMdaToneUtilityTestBase::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 RMdaToneUtilityTestBase::TimerCallback(TAny* aPtr)
{
static_cast<RMdaToneUtilityTestBase*>(aPtr)->DoTimerCallback();
return KErrNone;
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaToneUtilityTestBase::Fsm(TMdaAudioUtilityEvent aMdaAudioUtilityEvent, TInt aError)
{
TInt error = 0;
switch (iToneUtilityState)
{
case EStateCreated:
{
if (aMdaAudioUtilityEvent == EEventInitialize)
{
if(!iNegative)
{
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::PrepareToPlayFileSequence"));
iToneUtility->PrepareToPlayFileSequence(iFile);
}
else
{
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::PrepareToPlayDTMFString"));
iToneUtility->PrepareToPlayDTMFString(KDTMFString);
}
INFO_PRINTF1(_L("MdaAudioUtility State: EStateInitializing"));
iToneUtilityState = EStateInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioUtility EEventInitialize not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStateInitializing:
{
if (aMdaAudioUtilityEvent == EEventPrepareComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iToneUtility->SetVolume(iToneUtility->MaxVolume()/2);
INFO_PRINTF1(_L("Starting playback"));
iToneUtility->Play();
iStartTime.HomeTime();
iToneUtilityState = EStatePlaying;
StartTimer(iPause*KOneSecond); //wait to pause
}
else if (aMdaAudioUtilityEvent == EEventPrepareComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MatoPrepareComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioUtility EEventPrepareComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStatePlaying:
{
if(aMdaAudioUtilityEvent == EEventTimerComplete)
{
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::Pause"));
error = iToneUtility->Pause();
if(!iNegative)
{
INFO_PRINTF1(_L("MdaAudioUtility State: EStatePause"));
iToneUtilityState = EStatePause;
iWait = EFalse;
}
else
{
if(error == KErrNotSupported)
{
INFO_PRINTF1(_L("Pause while in a mode different than prepare to play file sequence returned with KErrNotSupported as expected"));
}
else
{
ERR_PRINTF2(_L("Pause while in a mode different than prepare to play file sequence returned with %d instead of KErrNotSupported as expected"),error);
StopTest(error);
}
}
}
else
{
ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStatePause:
{
if (aMdaAudioUtilityEvent == EEventTimerComplete)
{
if(!iWait && !iConfig && !iPrepare)
{
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioToneUtility::Resume"));
error = iToneUtility->Resume();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iToneUtilityState = EStatePlaying;
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
}
else if(!iWait && iConfig)
{
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);
iToneUtility->SetVolume(iVolume);
iToneUtility->SetBalanceL(iBalance);
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioToneUtility::Resume"));
error = iToneUtility->Resume();
if(error == KErrNone)
{
INFO_PRINTF1(_L("Resume returned with KErrNone as expected"));
iToneUtilityState = EStatePlaying;
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNone as expected"),error);
StopTest(error);
}
iConfig = EFalse;
}
else if(!iWait && iPrepare)
{
INFO_PRINTF2(_L("Playback paused for %d seconds"),iPause);
INFO_PRINTF1(_L("Calling PrepareToPlayFileSequence while in Pause"));
iToneUtility->PrepareToPlayFileSequence(iFile);
iToneUtilityState = EStatePlaying;
}
}
else
{
ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStateStopped:
{
if (aMdaAudioUtilityEvent == EEventTimerComplete)
{
if(iWait)
{
INFO_PRINTF1(_L("Playback stopped for 2 seconds"));
iWait = EFalse;
}
else
{
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::Resume while stopped"));
error = iToneUtility->Resume();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Resume returned with KErrNotReady as expected"));
iToneUtilityState = EStatePlaying;
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioToneUtility::Play"));
iToneUtility->Play();
}
}
else
{
ERR_PRINTF2(_L("EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioUtility state received: %d"), iToneUtilityState);
StopTest(KErrGeneral);
}
}
}
/*
*
* MatoPrepareComplete - From MMdaAudioToneObserver
*
*/
void RMdaToneUtilityTestBase::MatoPrepareComplete(TInt aError)
{
INFO_PRINTF1(_L("========== Tone Utility MatoPrepareComplete() callback =========="));
if(iToneUtilityState == EStateInitializing)
{
INFO_PRINTF1(_L("Tone Utility MatoPrepareComplete"));
Fsm(EEventPrepareComplete, aError);
}
}
/*
*
* MatoPlayComplete - From MMdaAudioToneObserver
*
*/
void RMdaToneUtilityTestBase::MatoPlayComplete(TInt aError)
{
INFO_PRINTF1(_L("========== Tone Utility MatoPlayComplete() callback =========="));
if (aError == KErrNone)
{
INFO_PRINTF2(_L("Tone Utility called MatoPlayComplete with error = %d as expected"), aError);
iEndTime.HomeTime();
TTimeIntervalMicroSeconds playduration = iEndTime.MicroSecondsFrom(iStartTime);
if(playduration > iExpected - KVariation && playduration < iExpected + KVariation)
{
INFO_PRINTF2(_L("Tone played for %ld. Value is between acceptable threshold"),playduration.Int64());
StopTest(aError,EPass);
}
else
{
ERR_PRINTF2(_L("Tone played for %ld. Value is not between acceptable threshold"),playduration.Int64());
StopTest(KErrGeneral);
}
}
else
{
ERR_PRINTF2(_L("Tone Utility called MatoPlayComplete with error = %d"), aError);
ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow);
StopTest(aError);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0168-HP
*========================================================================================================
*/
RMdaToneUtilityResumeTest::RMdaToneUtilityResumeTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityResumeTest* RMdaToneUtilityResumeTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityResumeTest * self = new(ELeave)RMdaToneUtilityResumeTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityResumeTest::DoKickoffTestL()
{
TPtrC filename;
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// 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, KSequence, 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();
User::Leave(err);
}
iWait = ETrue;
iExpected = iDuration + iPause*KOneSecond;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityResumeTest::DoTimerCallback()
{
if(!iWait)
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
}
Fsm (EEventTimerComplete, KErrNone);
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0169-HP
*========================================================================================================
*/
RMdaToneUtilityResumeThreeTest::RMdaToneUtilityResumeThreeTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityResumeThreeTest* RMdaToneUtilityResumeThreeTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityResumeThreeTest * self = new(ELeave)RMdaToneUtilityResumeThreeTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityResumeThreeTest::DoKickoffTestL()
{
TPtrC filename;
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// 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, KSequence, 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();
User::Leave(err);
}
iWait = ETrue;
iExpected = iDuration + 3*(iPause*KOneSecond);
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
iCount = 0;
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityResumeThreeTest::DoTimerCallback()
{
iCount++;
if(!iWait && iCount == 6) //Repeating Pause-Resume cycle three times
{
iTimer->Cancel();
Fsm (EEventTimerComplete, KErrNone);
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventTimerComplete, KErrNone);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0170-HP
*========================================================================================================
*/
RMdaToneUtilityPlayPauseStopPlayTest::RMdaToneUtilityPlayPauseStopPlayTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityPlayPauseStopPlayTest* RMdaToneUtilityPlayPauseStopPlayTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityPlayPauseStopPlayTest * self = new(ELeave)RMdaToneUtilityPlayPauseStopPlayTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityPlayPauseStopPlayTest::DoKickoffTestL()
{
TPtrC filename;
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// 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, KSequence, 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();
User::Leave(err);
return;
}
iWait = ETrue;
iStop = ETrue;
iExpected = iDuration + 3*(iPause*KOneSecond);
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
iCount = 0;
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityPlayPauseStopPlayTest::DoTimerCallback()
{
if(!iWait && iStop)
{
INFO_PRINTF1(_L("Stopping playback"));
iToneUtility->CancelPlay();
iStop = EFalse;
iToneUtilityState = EStateStopped;
iWait = ETrue;
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventTimerComplete, KErrNone);
}
else if(!iWait && !iStop)
{
iTimer->Cancel();
Fsm (EEventTimerComplete, KErrNone);
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventTimerComplete, KErrNone);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0171-HP
*========================================================================================================
*/
RMdaToneUtilityConfigResumeTest::RMdaToneUtilityConfigResumeTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityConfigResumeTest* RMdaToneUtilityConfigResumeTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityConfigResumeTest * self = new(ELeave)RMdaToneUtilityConfigResumeTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityConfigResumeTest::DoKickoffTestL()
{
TPtrC filename;
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// 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, KSequence, 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();
User::Leave(err);
return;
}
iWait = ETrue;
iConfig = ETrue;
iExpected = iDuration + iPause*KOneSecond;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityConfigResumeTest::DoTimerCallback()
{
if(!iWait && !iConfig)
{
iTimer->Cancel();
INFO_PRINTF1(_L("Comparing Volume and Balance with values set"));
if (iVolume == iToneUtility->Volume() && Abs(iBalance - iToneUtility->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"),iToneUtility->Volume(),iToneUtility->GetBalanceL(),iVolume,iBalance);
StopTest(KErrGeneral);
}
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventTimerComplete, KErrNone);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0172-HP
*========================================================================================================
*/
RMdaToneUtilityPrepareInPauseTest::RMdaToneUtilityPrepareInPauseTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityPrepareInPauseTest* RMdaToneUtilityPrepareInPauseTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityPrepareInPauseTest * self = new(ELeave)RMdaToneUtilityPrepareInPauseTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityPrepareInPauseTest::DoKickoffTestL()
{
TPtrC filename;
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// 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, KSequence, 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();
User::Leave(err);
return;
}
iWait = ETrue;
iPrepare = ETrue;
iExpected = iDuration;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityPrepareInPauseTest::DoTimerCallback()
{
if(!iWait)
{
iTimer->Cancel();
Fsm (EEventTimerComplete, KErrNone);
}
else
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventTimerComplete, KErrNone);
}
}
/*
*
* MatoPrepareComplete - From MMdaAudioToneObserver
*
*/
void RMdaToneUtilityPrepareInPauseTest::MatoPrepareComplete(TInt aError)
{
INFO_PRINTF1(_L("========== Tone Utility MatoPrepareComplete() callback =========="));
if(iToneUtilityState == EStateInitializing)
{
INFO_PRINTF1(_L("Tone Utility MatoPrepareComplete"));
Fsm(EEventPrepareComplete, aError);
}
else if(iToneUtilityState == EStatePlaying)
{
if(aError == KErrNone)
{
INFO_PRINTF2(_L("Tone Utility returned with expected error %d"),aError);
INFO_PRINTF1(_L("Resuming playback. Calling CMdaAudioToneUtility::Play"));
iStartTime.HomeTime(); //Register start time here. Tone should restart
iToneUtility->Play();
}
else
{
ERR_PRINTF1(_L("Preparing tone playback was not successful while paused. This is unexpected"));
StopTest(aError);
}
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0173-HP
*========================================================================================================
*/
RMdaToneUtilityPauseBeforePlayTest::RMdaToneUtilityPauseBeforePlayTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityPauseBeforePlayTest* RMdaToneUtilityPauseBeforePlayTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityPauseBeforePlayTest * self = new(ELeave)RMdaToneUtilityPauseBeforePlayTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityPauseBeforePlayTest::DoKickoffTestL()
{
TPtrC filename;
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
StopTest(KErrNotFound);
return;
}
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KSequence, 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();
User::Leave(err);
return;
}
iExpected = iDuration;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* MatoPrepareComplete - From MMdaAudioToneObserver
*
*/
void RMdaToneUtilityPauseBeforePlayTest::MatoPrepareComplete(TInt aError)
{
INFO_PRINTF1(_L("========== Tone Utility MatoPrepareComplete() callback =========="));
if(iToneUtilityState == EStateInitializing)
{
INFO_PRINTF1(_L("Tone Utility MatoPrepareComplete"));
Fsm(EEventPrepareComplete, aError);
}
}
/*
*
* Fsm - Executes playing events of AudioPlayerUtility in sequence
*
*/
void RMdaToneUtilityPauseBeforePlayTest::Fsm(TMdaAudioUtilityEvent aMdaAudioUtilityEvent, TInt aError)
{
TInt error = 0;
switch (iToneUtilityState)
{
case EStateCreated:
{
if (aMdaAudioUtilityEvent == EEventInitialize)
{
StartTimer(20*KOneSecond); //wait twenty seconds. If timer callback occurrs then Pause worked while not in play
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::Pause before preparing to play"));
error = iToneUtility->Pause();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Pause before preparing to play returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Pause before preparing to play returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::PrepareToPlayFileSequence"));
iToneUtility->PrepareToPlayFileSequence(iFile);
INFO_PRINTF1(_L("MdaAudioUtility State: EStateInitializing"));
iToneUtilityState = EStateInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioUtility EEventInitialize not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStateInitializing:
{
if (aMdaAudioUtilityEvent == EEventPrepareComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iToneUtility->SetVolume(iToneUtility->MaxVolume()/2);
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::Pause before playing"));
error = iToneUtility->Pause();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Pause before preparing to play returned with KErrNotReady as expected"));
}
else
{
ERR_PRINTF2(_L("Pause before preparing to play returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Starting playback"));
iToneUtility->Play();
iStartTime.HomeTime();
}
else if (aMdaAudioUtilityEvent == EEventPrepareComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MatoPrepareComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioUtility EEventPrepareComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioUtility state received: %d"), iToneUtilityState);
StopTest(KErrGeneral);
}
}
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityPauseBeforePlayTest::DoTimerCallback()
{
ERR_PRINTF1(_L("Timer callback received. This is unexpected"));
StopTest(KErrGeneral);
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0174-HP Negative
*========================================================================================================
*/
RMdaToneUtilityNegPauseResumeTest::RMdaToneUtilityNegPauseResumeTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityNegPauseResumeTest* RMdaToneUtilityNegPauseResumeTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityNegPauseResumeTest * self = new(ELeave)RMdaToneUtilityNegPauseResumeTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityNegPauseResumeTest::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, KSequence, 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();
User::Leave(err);
return;
}
iWait = ETrue;
iNegative = ETrue;
iCount = 0;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityNegPauseResumeTest::DoTimerCallback()
{
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
Fsm (EEventTimerComplete, KErrNone);
}
/*
*
* MatoPlayComplete - From MMdaAudioToneObserver
*
*/
void RMdaToneUtilityNegPauseResumeTest::MatoPlayComplete(TInt aError)
{
INFO_PRINTF1(_L("========== Tone Utility MatoPlayComplete() callback =========="));
iCount++;
if (aError == KErrNone)
{
INFO_PRINTF2(_L("Tone Utility called MatoPlayComplete with error = %d as expected"), aError);
switch(iCount)
{
//NOTE:"PlayFixedSequence is not supported on A3F"
case 1:
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::PrepareToPlayTone"));
iToneUtility->PrepareToPlayTone(KToneFrequency, KFiveSeconds);
INFO_PRINTF1(_L("MdaAudioUtility State: EStateInitializing"));
iToneUtilityState = EStateInitializing;
break;
case 2:
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::PrepareToPlayDualTone"));
iToneUtility->PrepareToPlayDualTone(KToneFrequency, KToneFrequencyTwo, KFiveSeconds);
INFO_PRINTF1(_L("MdaAudioUtility State: EStateInitializing"));
iToneUtilityState = EStateInitializing;
break;
case 3:
INFO_PRINTF1(_L("All tone variations have been tested"));
StopTest(aError);
break;
}
}
else
{
ERR_PRINTF2(_L("Tone Utility called MatoPlayComplete with error = %d"), aError);
ERR_PRINTF2(_L("Expected error = %d"), KErrUnderflow);
StopTest(aError);
}
}
/*
*========================================================================================================
* MM-MMF-ACLNT-I-0183-HP
*========================================================================================================
*/
RMdaToneUtilityPauseNonA3fTest::RMdaToneUtilityPauseNonA3fTest(const TDesC& aTestName, const TDesC& aSectName)
: RMdaToneUtilityTestBase(aTestName,aSectName)
{
}
/*
*
* NewL
*
*/
RMdaToneUtilityPauseNonA3fTest* RMdaToneUtilityPauseNonA3fTest::NewL(const TDesC& aTestName, const TDesC& aSectName)
{
RMdaToneUtilityPauseNonA3fTest * self = new(ELeave)RMdaToneUtilityPauseNonA3fTest(aTestName,aSectName);
return self;
}
/*
*
* DoKickoffTestL
*
*/
void RMdaToneUtilityPauseNonA3fTest::DoKickoffTestL()
{
TPtrC filename;
// Get the filename of the audio file to play
if (!GetStringFromConfig(iSectName, KSequence, 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();
User::Leave(err);
return;
}
// Get the duration of the audio file to play
if (!GetIntFromConfig(iSectName, KDuration, iDuration))
{
ERR_PRINTF1(_L("Duration could not be retrieved from ini file"));
User::Leave(KErrNotFound);
return;
}
// Get the pause time
if (!GetIntFromConfig(iSectName, KPause, iPause))
{
ERR_PRINTF1(_L("Pause time could not be retrieved from ini file"));
User::Leave(KErrNotFound);
return;
}
iExpected = iDuration;
INFO_PRINTF2(_L("File under test -> %S"), &iFilename);
iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
}
/*
*
* MatoPrepareComplete - From MMdaAudioToneObserver
*
*/
void RMdaToneUtilityPauseNonA3fTest::MatoPrepareComplete(TInt aError)
{
INFO_PRINTF1(_L("========== Tone Utility MatoPrepareComplete() callback =========="));
if(iToneUtilityState == EStateInitializing)
{
INFO_PRINTF1(_L("Tone Utility MatoPrepareComplete"));
Fsm(EEventPrepareComplete, aError);
}
}
/*
*
* Fsm - Executes playing events of AudioToneUtility in sequence
*
*/
void RMdaToneUtilityPauseNonA3fTest::Fsm(TMdaAudioUtilityEvent aMdaAudioUtilityEvent, TInt aError)
{
TInt error = 0;
switch (iToneUtilityState)
{
case EStateCreated:
{
if (aMdaAudioUtilityEvent == EEventInitialize)
{
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::PrepareToPlayFileSequence"));
iToneUtility->PrepareToPlayFileSequence(iFile);
INFO_PRINTF1(_L("MdaAudioUtility State: EStateInitializing"));
iToneUtilityState = EStateInitializing;
}
else
{
ERR_PRINTF2(_L("MdaAudioUtility EEventInitialize not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStateInitializing:
{
if (aMdaAudioUtilityEvent == EEventPrepareComplete && aError == KErrNone)
{
INFO_PRINTF1(_L("Calling SetVolume using MaxVolume/2"));
iToneUtility->SetVolume(iToneUtility->MaxVolume()/2);
INFO_PRINTF1(_L("Starting playback"));
iToneUtility->Play();
iStartTime.HomeTime();
iToneUtilityState = EStatePlaying;
StartTimer(iPause*KOneSecond); //wait to pause
}
else if (aMdaAudioUtilityEvent == EEventPrepareComplete && aError != KErrNone)
{
ERR_PRINTF2(_L("MatoPrepareComplete returned with error = %d"), aError);
StopTest(aError);
}
else
{
ERR_PRINTF2(_L("MdaAudioUtility EEventPrepareComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
case EStatePlaying:
{
if(aMdaAudioUtilityEvent == EEventTimerComplete)
{
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::Pause in non-a3f configuration"));
error = iToneUtility->Pause();
if(error == KErrNotSupported)
{
INFO_PRINTF1(_L("Pause in ToneUtility returned with KErrNotSupported as expected"));
}
else
{
ERR_PRINTF2(_L("Pause in ToneUtility returned with %d instead of KErrNotSupported as expected"),error);
StopTest(error);
}
INFO_PRINTF1(_L("Calling CMdaAudioToneUtility::Resume in non-a3f configuration"));
error = iToneUtility->Resume();
if(error == KErrNotReady)
{
INFO_PRINTF1(_L("Resume returned with KErrNotReady as expected"));
iToneUtilityState = EStatePlaying;
}
else
{
ERR_PRINTF2(_L("Resume returned with %d instead of KErrNotReady as expected"),error);
StopTest(error);
}
}
else
{
ERR_PRINTF2(_L("DevSound EEventTimerComplete not received as expected. Received event: %d"), aMdaAudioUtilityEvent);
StopTest(aError, EFail);
}
break;
}
default:
{
ERR_PRINTF2(_L("Invalid MdaAudioUtility state received: %d"), iToneUtilityState);
StopTest(KErrGeneral);
}
}
}
/*
*
* DoTimerCallback
*
*/
void RMdaToneUtilityPauseNonA3fTest::DoTimerCallback()
{
INFO_PRINTF1(_L("MdaToneUtility Event: EEventTimerComplete"));
INFO_PRINTF1(_L("Cancelling timer"));
iTimer->Cancel();
Fsm (EEventTimerComplete, KErrNone);
}