// 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

 *

 */