// Copyright (c) 2005-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:

// CPP file: Audio Resource Notification tests for Audio Player.

// 

//

/**

 @file TestPlayerUtilsARN.cpp

*/

#include "TestAudioClientUtilitiesARN.h"

//------------------------------------------------------------------------------

//********************PREQ 797 - Audio Resource Notification********************

//------------------------------------------------------------------------------

//

//CTestMdaAudioPlayerCallbackSupport

//

/**

 * NewL

 */

CTestMdaAudioPlayerCallbackSupport* CTestMdaAudioPlayerCallbackSupport::NewL(MTestAudioPlayerCallback& aCallback)

	{

	return new(ELeave) CTestMdaAudioPlayerCallbackSupport(aCallback);

	}

/**

 * MapcInitComplete

 */

void CTestMdaAudioPlayerCallbackSupport::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration)

	{

	iCallback.MapcInitCompleteTest(aError, aDuration, *this);

	}

/**

 * MapcPlayComplete

 */

void CTestMdaAudioPlayerCallbackSupport::MapcPlayComplete(TInt aError)

	{

	iCallback.MapcPlayCompleteTest(aError, *this);

	}

/**

 * MarncResourceAvailable

 */

void CTestMdaAudioPlayerCallbackSupport::MarncResourceAvailable(TUid aNotificationEventId, const TDesC8& aNotificationData)

	{

	iCallback.MarncResourceAvailableTest(aNotificationEventId, aNotificationData, *this);

	}

/**

 * Constructor

 */

CTestMdaAudioPlayerCallbackSupport::CTestMdaAudioPlayerCallbackSupport(MTestAudioPlayerCallback& aCallback):iCallback(aCallback)

	{

	}

//

//CTestMmfAclntAudioPlayerARN

//

/**

 * Constructor

 */

CTestMmfAclntAudioPlayerARN::CTestMmfAclntAudioPlayerARN(const TDesC& aTestName, const TDesC& aSectName)

	{

	// store the name of this test case

	iTestStepName=aTestName;

	iHeapSize = 3600000;

	iSectName = aSectName;

	}

/**

 * MapcInitCompleteTest

 */

void CTestMmfAclntAudioPlayerARN::MapcInitCompleteTest(TInt aError, const TTimeIntervalMicroSeconds& aDuration, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)

	{

	iDuration = aDuration;

	if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)

		{

		INFO_PRINTF2(_L("iAudioPlayer1 -> MMdaAudioPlayerCallback InitComplete (%d)"),aError);

		TRAP(iError, FsmL(EMapcInitComplete1, aError));

		}

	else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)

		{

		INFO_PRINTF2(_L("iAudioPlayer2 -> MMdaAudioPlayerCallback InitComplete (%d)"),aError);

		TRAP(iError, FsmL(EMapcInitComplete2, aError));

		}	

	else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)

		{

		INFO_PRINTF2(_L("iAudioPlayer3 -> MMdaAudioPlayerCallback InitComplete (%d)"),aError);

		TRAP(iError, FsmL(EMapcInitComplete3, aError));

		}

	}

/**

 * MapcPlayCompleteTest

 */

void CTestMmfAclntAudioPlayerARN::MapcPlayCompleteTest(TInt aError, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)

	{

	if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)

		{

		INFO_PRINTF2(_L("iAudioPlayer1 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);

		TRAP(iError, FsmL(EMapcPlayComplete1, aError));

		}

	else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)

		{

		INFO_PRINTF2(_L("iAudioPlayer2 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);

		TRAP(iError, FsmL(EMapcPlayComplete2, aError));

		}

	else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)

		{

		INFO_PRINTF2(_L("iAudioPlayer3 -> MMdaAudioPlayerCallback PlayComplete (%d)"), aError);

		TRAP(iError, FsmL(EMapcPlayComplete3, aError));

		}

	}

/**

 * MarncResourceAvailableTest

 */

void CTestMmfAclntAudioPlayerARN::MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioPlayerCallbackSupport& aMdaAudioPlayerCallbackSupport)

	{

	if (aNotificationEventId == KMMFEventCategoryAudioResourceAvailable)

		{

		INFO_PRINTF1(_L("iAudioPlayer::MMMFAudioResourceNotificationCallback -> KMMFEventCategoryAudioResourceAvailable"));

		//Convert TDesc8 to TInt64

		TMMFTimeIntervalMicroSecondsPckg timeIntvbuf;

		timeIntvbuf.Copy(aNotificationData);

		TTimeIntervalMicroSeconds intPos = timeIntvbuf();

		iPosition = intPos;

		if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport1)

			{

			INFO_PRINTF1(_L("iAudioPlayer1 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable..waiting for playcomplete"));

			TRAP(iError, FsmL(EMarncResourceAvailable1, KErrNone));

			}

		else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport2)

			{

			INFO_PRINTF1(_L("iAudioPlayer2 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable"));

			TRAP(iError, FsmL(EMarncResourceAvailable2, KErrNone));

			}

		else if (&aMdaAudioPlayerCallbackSupport == iMdaAudioPlayerCallbackSupport3)

			{

			INFO_PRINTF1(_L("iAudioPlayer3 -> MMMFAudioResourceNotificationCallback : AudioResourceAvailable"));

			TRAP(iError, FsmL(EMarncResourceAvailable3, KErrNone));

			}

		}

	else

		{

		INFO_PRINTF1(_L("MMMFAudioResourceNotificationCallback, but NOT KMMFEventCategoryAudioResourceAvailable"));

		}

	}

/**

 * DoTestStepPreambleL

 */

TVerdict CTestMmfAclntAudioPlayerARN::DoTestStepPreambleL()

	{

	TPtrC filename;

	TVerdict ret = EPass;

	// Call base DoTestStepPreambleL()

	ret = CTestMmfAclntStep::DoTestStepPreambleL();

	if (ret == EFail)

		{

		return ret;

		}

	// Get 1st file name

	if(!GetStringFromConfig(iSectName, _L("playerAudioFile1"), filename))

		{

		return EInconclusive;

		}

	GetDriveName(iFilename1);

	iFilename1.Append(filename);

	iEventChecker = CMultiEventChecker::NewL();

	// Initialise 1st Audio Player

	INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility1 : EMdaPriorityNormal"));

	iMdaAudioPlayerCallbackSupport1 = CTestMdaAudioPlayerCallbackSupport::NewL(*this);

	iTestAudioPlayer1 = CMdaAudioPlayerUtility::NewL(*iMdaAudioPlayerCallbackSupport1, EMdaPriorityNormal);

	// Get 2nd file name

	if(!GetStringFromConfig(iSectName, _L("playerAudioFile2"), filename))

		{

		return EInconclusive;

		}

	GetDriveName(iFilename2);

	iFilename2.Append(filename);

	// Initialise 2nd Audio Player

	INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility2 : EMdaPriorityMax"));

	iMdaAudioPlayerCallbackSupport2 = CTestMdaAudioPlayerCallbackSupport::NewL(*this);

	iTestAudioPlayer2 = CMdaAudioPlayerUtility::NewL(*iMdaAudioPlayerCallbackSupport2, EMdaPriorityMax);

	// Get 3rd file name

	if(!GetStringFromConfig(iSectName, _L("playerAudioFile3"), filename))

		{

		return EInconclusive;

		}

	GetDriveName(iFilename3);

	iFilename3.Append(filename);

	// Initialise 3rd Audio Player

	INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility3 : EMdaPriorityMin"));

	iMdaAudioPlayerCallbackSupport3 = CTestMdaAudioPlayerCallbackSupport::NewL(*this);

	iTestAudioPlayer3 = CMdaAudioPlayerUtility::NewL(*iMdaAudioPlayerCallbackSupport3, EMdaPriorityMin);

	// Initialise the CCallBackTimer.

	iCallBackTimer = CCallBackTimer::NewL(TCallBack(stopActiveScheduler));

	return ret;

	}

/**

 * DoTestStepPostambleL

 */

TVerdict CTestMmfAclntAudioPlayerARN::DoTestStepPostambleL()

	{

	// Delete all the iTestAudioPlayer utilities.

	iTestAudioPlayer1->Close();

	delete iTestAudioPlayer1;

	iTestAudioPlayer1=NULL;

	iTestAudioPlayer2->Close();

	delete iTestAudioPlayer2;

	iTestAudioPlayer2=NULL;

	iTestAudioPlayer3->Close();

	delete iTestAudioPlayer3;

	iTestAudioPlayer3=NULL;

	// Delete CTestMdaAudioPlayerCallbackSupport

	delete iMdaAudioPlayerCallbackSupport1;

	delete iMdaAudioPlayerCallbackSupport2;

	delete iMdaAudioPlayerCallbackSupport3;

	// Delete the CCallBackTimer.

	delete iCallBackTimer;

	iCallBackTimer=NULL;

	delete iEventChecker;

	// Base Postamble.

	return CTestMmfAclntStep::DoTestStepPostambleL();

	}

/**

 * DoTestStepL

 */

TVerdict CTestMmfAclntAudioPlayerARN::DoTestStepL()

	{

	return( DoTestL() );

	}

/**

 * StateInit

 */

void CTestMmfAclntAudioPlayerARN::StateInit()

	{

	iExpectedEvent=EIdlePlayer;

	iExpectedError=KErrNone;

	iState=EStateBegin;

	}

/**

 * StateChange

 */

void CTestMmfAclntAudioPlayerARN::StateChange(TMmfAudioPlayerState aState, TMmfAudioPlayerEvents aExpectedEvent, TInt aExpectedError)

	{

	iExpectedEvent=aExpectedEvent;

	iExpectedError=aExpectedError;

	iState=aState;

	}

/**

 * FsmCheck

 */

TBool CTestMmfAclntAudioPlayerARN::FsmCheck(TMmfAudioPlayerEvents aEventCode, TInt aError)

	{

	TBool retFsmCheck = EFalse;

	if (((aEventCode == EMapcPlayComplete1) || (aEventCode == EMapcPlayComplete2)) && (aError == KErrUnderflow))

		{

		INFO_PRINTF1(_L("Underflow !"));

		}

	else if (iExpectedEvent != aEventCode)

		{

		ERR_PRINTF3(_L("ExpectedEvent : %d, ActualEvent : %d"), iExpectedEvent, aEventCode);

		iTestStepResult = EFail;

		CActiveScheduler::Stop();

		}

	else if (iExpectedError != aError)

		{

		ERR_PRINTF3(_L("ExpectedError : %d, ActualError : %d"), iExpectedError, aError);

		iTestStepResult = EFail;

		CActiveScheduler::Stop();

		}

	else

		{

		retFsmCheck = ETrue;

		}

	return retFsmCheck;

	}

//

//POSITIVE TESTS//

//

//

//CTestMmfAclntARN8101

//

/**

 * Constructor

 */

CTestMmfAclntARN8101::CTestMmfAclntARN8101(const TDesC& aTestName, const TDesC& aSectName)

	: CTestMmfAclntAudioPlayerARN(aTestName, aSectName)

	{}

/**

 * NewL

 */

CTestMmfAclntARN8101* CTestMmfAclntARN8101::NewL(const TDesC& aTestName, const TDesC& aSectName)

	{

	CTestMmfAclntARN8101* self = new (ELeave) CTestMmfAclntARN8101(aTestName, aSectName);

	return self;

	}

/**

 * DoTestL

 */

TVerdict CTestMmfAclntARN8101::DoTestL()

	{

	return( PerformTestL() );

	}

/**

 * FsmL

 */

void CTestMmfAclntARN8101::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)

	{

	if (FsmCheck(aEventCode, aError))

		{

		TInt retErr = KErrNone;

		switch (iState)

			{

			case EStateBegin:

				// Open iTestAudioPlayer#1

				iTestAudioPlayer1->OpenFileL(iFilename1);

				INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));

				// Set ExpectedEvent and change the State

				StateChange(EStateOpenPlayer2, EMapcInitComplete1);

				break;

			case EStateOpenPlayer2:

				// Register iTestAudioPlayer#1 for Notification

				retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);

				INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));

				if( retErr != KErrNone )

					{

					ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);

					iTestStepResult = EFail;

					CActiveScheduler::Stop();

					break;

					}

				// Open iTestAudioPlayer#2

				iTestAudioPlayer2->OpenFileL(iFilename2);

				INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));

				// Set ExpectedEvent and change the State

				StateChange(EStatePlaying2, EMapcInitComplete2);

				break;

			case EStatePlaying2:

				// Play iTestAudioPlayer#2

				iTestAudioPlayer2->Play();

				INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));

				// Set ExpectedEvent and change the State

				StateChange(EStateEndPlay2, EMapcPlayComplete2);

				break;

			case EStateEndPlay2:

				// Timer to check if Notification Event Occurs.

				iCallBackTimer->After(2000000);

				iTestStepResult = EPass;

				// Set ExpectedEvent and change the State

				StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);

				break;

			case EStateNotifiedPlayer1:

				iCallBackTimer->Cancel(); // in case something else stopped the AS

				INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));

				iTestStepResult = EFail;

				CActiveScheduler::Stop();

				break;

			}

		}

	}

/**

 * PerformTestL

 */

TVerdict CTestMmfAclntARN8101::PerformTestL()

	{

	INFO_PRINTF1(_L("Register for notification, but make no request to play audio"));

	iTestStepResult = EFail;

	// Initialise the state variables

	StateInit();

	// Begin the process

	FsmL(EIdlePlayer, KErrNone);

	// Start the scheduler - Done only once !

	CActiveScheduler::Start();

	return iTestStepResult;

	}

//

//CTestMmfAclntARN8102

//

/**

 * Constructor

 */

CTestMmfAclntARN8102::CTestMmfAclntARN8102(const TDesC& aTestName, const TDesC& aSectName)

	: CTestMmfAclntAudioPlayerARN(aTestName, aSectName)

	{}

/**

 * NewL

 */

CTestMmfAclntARN8102* CTestMmfAclntARN8102::NewL(const TDesC& aTestName, const TDesC& aSectName)

	{

	CTestMmfAclntARN8102* self = new (ELeave) CTestMmfAclntARN8102(aTestName, aSectName);

	return self;

	}

/**

 * DoTestL

 */

TVerdict CTestMmfAclntARN8102::DoTestL()

	{

	return( PerformTestL() );

	}

/**

 * FsmL

 */

void CTestMmfAclntARN8102::FsmL(TMmfAudioPlayerEvents aEventCode, TInt aError)

	{

	if (FsmCheck(aEventCode, aError))

		{

		TInt retErr = KErrNone;

		switch (iState)

			{

			case EStateBegin:

				// Open iTestAudioPlayer#1

				iTestAudioPlayer1->OpenFileL(iFilename1);

				INFO_PRINTF1(_L("iTestAudioPlayer1->OpenFileL()"));

				// Set ExpectedEvent and change the State

				StateChange(EStateOpenPlayer2, EMapcInitComplete1);

				break;

			case EStateOpenPlayer2:

				// Register iTestAudioPlayer#1 for Notification

				retErr = iTestAudioPlayer1->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport1, KMMFEventCategoryAudioResourceAvailable);

				INFO_PRINTF1(_L("iTestAudioPlayer1->RegisterAudioResourceNotification()"));

				if( retErr != KErrNone )

					{

					ERR_PRINTF2(_L("iTestAudioPlayer1->RegisterAudioResourceNotification - Failed with Error : %d"), retErr);

					iTestStepResult = EFail;

					CActiveScheduler::Stop();

					break;

					}

				// Open iTestAudioPlayer#2

				iTestAudioPlayer2->OpenFileL(iFilename2);

				INFO_PRINTF1(_L("iTestAudioPlayer2->OpenFileL()"));

				// Set ExpectedEvent and change the State

				StateChange(EStatePlaying2, EMapcInitComplete2);

				break;

			case EStatePlaying2:

				// Play iTestAudioPlayer#2

				iTestAudioPlayer2->Play();

				INFO_PRINTF1(_L("iTestAudioPlayer2->Play()"));

				// Play iTestAudioPlayer#1

				iTestAudioPlayer1->Play();

				INFO_PRINTF1(_L("iTestAudioPlayer1->Play()"));

				// Set ExpectedEvent and change the State

				StateChange(EStateErrInUsePlayer1, EMapcPlayComplete1, KErrInUse);

				break;

			case EStateErrInUsePlayer1:

				// Close iTestAudioPlayer#2

				WaitWithTimeout(iRequestStatus,1000000);

				iTestAudioPlayer2->Stop();

				INFO_PRINTF1(_L("iTestAudioPlayer2->Stop()"));

				iTestAudioPlayer2->Close();

				INFO_PRINTF1(_L("iTestAudioPlayer2->Close()"));

				// Timer to check if Notification Event Occurs.

				iCallBackTimer->After(2000000);

				// Set ExpectedEvent and change the State

				StateChange(EStateNotifiedPlayer1, EMarncResourceAvailable1);

				break;

			case EStateNotifiedPlayer1:

				iCallBackTimer->Cancel(); // in case something else stopped the AS

				INFO_PRINTF1(_L("iTestAudioPlayer1->NotificationReceived"));

				iTestStepResult = EPass;

				CActiveScheduler::Stop();

				break;

			}

		}

	}

/**

 * PerformTestL

 */

TVerdict CTestMmfAclntARN8102::PerformTestL()

	{

	INFO_PRINTF1(_L("Register (b4 play, after Open) and Receive Notification of a Resource Available Event."));

	INFO_PRINTF1(_L("(when audio resource is currently unavailable and then available)"));

	iTestStepResult = EFail;