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

 *

 */