// 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 Multiple Audio Clients.

// 

//

/**

 @file TestMultiClientARN.cpp

*/

#include "TestAudioClientUtilitiesARN.h"

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

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

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

//

//CTestMdaAudioMultiClientCallbackSupport

//

/**

 * NewL

 */

CTestMdaAudioMultiClientCallbackSupport* CTestMdaAudioMultiClientCallbackSupport::NewL(MTestAudioResourceNotificationCallback& aCallback)

	{

	return new(ELeave) CTestMdaAudioMultiClientCallbackSupport(aCallback);

	}

/**

 * MarncResourceAvailable

 */

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

	{

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

	}

/**

 * Constructor

 */

CTestMdaAudioMultiClientCallbackSupport::CTestMdaAudioMultiClientCallbackSupport(MTestAudioResourceNotificationCallback& aCallback):iCallback(aCallback)

	{

	}

//

//CTestMmfAclntMultiClientARN

//

/**

 * Constructor

 */

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

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName=aTestName;

	iHeapSize = 800000;

	iSectName = aSectName;

	}

/**

 * MarncResourceAvailableTest

 */

void CTestMmfAclntMultiClientARN::MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioMultiClientCallbackSupport& aMdaAudioMultiClientCallbackSupport)

	{

	if (aNotificationEventId == KMMFEventCategoryAudioResourceAvailable)

		{

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

		//Convert TDesc8 to TInt64

		TMMFTimeIntervalMicroSecondsPckg timeIntvbuf;

		timeIntvbuf.Copy(aNotificationData);

		TTimeIntervalMicroSeconds intPos = timeIntvbuf();

		iPosition = intPos;

		if (&aMdaAudioMultiClientCallbackSupport == iMdaAudioPlayerCallbackSupport)

			{

			INFO_PRINTF1(_L("iAudioPlayer -> MMMFAudioResourceNotificationCallback NotificationReceived"));

			TRAP(iError, FsmL(EMarncResourceAvailablePlayer));

			}

		else if (&aMdaAudioMultiClientCallbackSupport == iMdaAudioRecorderCallbackSupport)

			{

			INFO_PRINTF1(_L("iAudioRecorder -> MMMFAudioResourceNotificationCallback NotificationReceived"));

			TRAP(iError, FsmL(EMarncResourceAvailableRecorder));

			}

		else if (&aMdaAudioMultiClientCallbackSupport == iMdaAudioOutputStreamCallbackSupport)

			{

			INFO_PRINTF1(_L("iAudioOutputStream -> MMMFAudioResourceNotificationCallback NotificationReceived"));

			TRAP(iError, FsmL(EMarncResourceAvailableOS));

			}

		}

	else

		{

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

		}

	}

/**

 * MapcInitCompleteTest

 */

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

	{

	iDuration = aDuration;

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

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

	}

/**

 * MapcPlayCompleteTest

 */

void CTestMmfAclntMultiClientARN::MapcPlayComplete(TInt aError)

	{

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

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

	}

/**

 * MoscoStateChangeEventTest

 */

void CTestMmfAclntMultiClientARN::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	INFO_PRINTF1(_L("iAudioRecorder -> MMdaObjectStateChangeObserver StateChanged"));

	INFO_PRINTF4(_L("iTestAudioRecorder -> aErrorCode : %d, aPreviousState : %d, aCurrentState : %d"), aErrorCode, aPreviousState, aCurrentState);

	TRAP(iError, FsmL(EMoscoStateChangeEvent, aErrorCode, iTestAudioRecorder->State()));

	}

/**

 * MMdaAudioOutputStreamCallback->MaoscOpenComplete

 */

void CTestMmfAclntMultiClientARN::MaoscOpenComplete(TInt aError)

	{

	INFO_PRINTF2(_L("iAudioOutputStream -> MMdaAudioOutputStreamCallback : MaoscOpenComplete (%d)"),aError);

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

	}

/**

 * MMdaAudioOutputStreamCallback->MaoscBufferCopied

 */

void CTestMmfAclntMultiClientARN::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)

	{

	INFO_PRINTF2(_L("iAudioOutputStream -> MMdaAudioOutputStreamCallback : MaoscBufferCopied  (%d)"), aError);

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

	}

/**

 * MMdaAudioOutputStreamCallback->MaoscPlayComplete

 */

void CTestMmfAclntMultiClientARN::MaoscPlayComplete(TInt aError)

	{

	INFO_PRINTF2(_L("iAudioOutputStream -> MMdaAudioOutputStreamCallback : MaoscPlayComplete  (%d)"), aError);

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

	}

/**

 * DoTestStepPreambleL

 */

TVerdict CTestMmfAclntMultiClientARN::DoTestStepPreambleL()

	{

	iError = KErrTimedOut;

	TPtrC filename;

	TVerdict verdict;

	// Install the scheduler - Call base DoTestStepPreambleL()

	verdict = CTestMmfAclntStep::DoTestStepPreambleL();

	if (verdict == EFail)

		{

		return verdict;

		}

	iEventChecker = CMultiEventChecker::NewL();

	//************** Initialise CMdaAudioPlayerUtility***************

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

	// Get file name

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

		{

		return EInconclusive;

		}

	GetDriveName(iFilenamePlayer);

	iFilenamePlayer.Append(filename);

	// Callback Handler

	iMdaAudioPlayerCallbackSupport = CTestMdaAudioMultiClientCallbackSupport::NewL(*this);

	// Initialise Audio Player

	iTestAudioPlayer = CMdaAudioPlayerUtility::NewL(*this, EMdaPriorityNormal);

	//************** Initialise CMdaAudioRecorderUtility*************

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

	// Get file name

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

		{

		return EInconclusive;

		}

	GetDriveName(iFilenameRecorder);

	iFilenameRecorder.Append(filename);

	// Callback Handler

	iMdaAudioRecorderCallbackSupport = CTestMdaAudioMultiClientCallbackSupport::NewL(*this);

	// Initialise Audio Recorder

	iTestAudioRecorder = CMdaAudioRecorderUtility::NewL(*this, NULL, EMdaPriorityMax);

	//************** Initialise CMdaAudioOutputStream****************

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

	// Connect RFs session

	TInt err = iFs.Connect();

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Error connecting to File session (RFs) = %d"), err);

		return EFail;

		}

	// Callback Handler

	iMdaAudioOutputStreamCallbackSupport = CTestMdaAudioMultiClientCallbackSupport::NewL(*this);

	// Initialise iTestAudioOutputStream

	TRAP(err, iTestAudioOutputStream = CMdaAudioOutputStream::NewL(*this, EMdaPriorityMin, EMdaPriorityPreferenceTimeAndQuality));

	if (err != KErrNone || iTestAudioOutputStream == NULL )

		{

		INFO_PRINTF2(_L("Error Creating iTestAudioOutputStream = %d"), err);

		return EInconclusive;

		}

	// Open RFile

	err = iFile.Open(iFs, KStreamRawFile1, EFileRead);

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Error opening iFile = %d"), err);

		return EFail;

		}

	// Get size of iFile

	err = iFile.Size(iFileSize);

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Error getting size of iFile = %d"), err);

		return EFail;

		}

	// Initialise iBuf

	iBuf.CreateMaxL(iFileSize);

	// Initialise the CCallBackTimer.

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

	return verdict;

	}

/**

 * DoTestStepPostambleL

 */

TVerdict CTestMmfAclntMultiClientARN::DoTestStepPostambleL()

	{

	// Delete all the Audio Client utilities.

	if (iTestAudioPlayer)

		iTestAudioPlayer->Close();

	delete iTestAudioPlayer;

	iTestAudioPlayer = NULL;

	iTestAudioRecorder->Close();

	delete iTestAudioRecorder;

	iTestAudioRecorder = NULL;

	delete iTestAudioOutputStream;

	iTestAudioOutputStream = NULL;

	// Delete CTestMdaAudioRecorderCallbackSupport

	delete iMdaAudioPlayerCallbackSupport;

	delete iMdaAudioRecorderCallbackSupport;

	delete iMdaAudioOutputStreamCallbackSupport;

	// Close RBuf8

	iBuf.Close();

	// Delete the CCallBackTimer.

	delete iCallBackTimer;

	iCallBackTimer=NULL;

	// Close the File Handles

	iFile.Close();

	iFs.Close();

	delete iEventChecker;

	return CTestMmfAclntStep::DoTestStepPostambleL();

	}

/**

 * DoTestStepL

 */

TVerdict CTestMmfAclntMultiClientARN::DoTestStepL()

	{

	return( DoTestL() );

	}

/**

 * StateInit

 */

void CTestMmfAclntMultiClientARN::StateInit()

	{

	iExpectedEvent=EIdleMulti;

	iExpectedRecorderState=CMdaAudioClipUtility::ENotReady;

	iExpectedError=KErrNone;

	iState=0;

	}

/**

 * StateChange

 */

void CTestMmfAclntMultiClientARN::StateChange(TMmfAudioMultiClientEvents aExpectedEvent, TInt aExpectedError, CMdaAudioClipUtility::TState aExpectedRecorderState)

	{

	iExpectedEvent=aExpectedEvent;

	iExpectedRecorderState=aExpectedRecorderState;

	iExpectedError=aExpectedError;

	iState++;

	}

/**

 * FsmCheck

 */

TBool CTestMmfAclntMultiClientARN::FsmCheck(TMmfAudioMultiClientEvents aEventCode, TInt aError, CMdaAudioClipUtility::TState aRecorderState)

	{

	TBool retFsmCheck = EFalse;

	if ((iExpectedError !=KErrUnderflow) && (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 if (iExpectedRecorderState != aRecorderState)

		{

		ERR_PRINTF3(_L("ExpectedRecorderState : %d, ActualRecorderState : %d"), iExpectedRecorderState, aRecorderState);

		iTestStepResult = EFail;

		CActiveScheduler::Stop();

		}

	else

		{

		retFsmCheck = ETrue;

		}

	return retFsmCheck;

	}

//

//CTestMmfAclntARN9001

//

/**

 * Constructor

 */

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

	: CTestMmfAclntMultiClientARN(aTestName, aSectName)

	{}

/**

 * NewL

 */

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

	{

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

	return self;

	}

/**

 * DoTestL

 */

TVerdict CTestMmfAclntARN9001::DoTestL()

	{

	return( PerformTestL() );

	}

/**

 * FsmCheck

 */

TBool CTestMmfAclntARN9001::FsmCheck(TMmfAudioMultiClientEvents aEventCode, TInt aError, CMdaAudioClipUtility::TState aRecorderState)

	{

	TBool retFsmCheck = EFalse;

	if ((iExpectedError !=KErrUnderflow) && (aError == KErrUnderflow))

		{

		INFO_PRINTF1(_L("Underflow !"));

		}

	else if (iExpectedEvent != aEventCode)

		{

        if ((aEventCode == EMoscoStateChangeEvent))

	        {

	        retFsmCheck = ETrue;

	        if (iEventOccured == EMarncResourceAvailableOS)

	            {

	            return retFsmCheck;

	            }

            else

                {

                iEventOccured = EMoscoStateChangeEvent;

                }

	        }

        else if (aEventCode == EMarncResourceAvailableOS)

            {

            retFsmCheck = ETrue;

            if (iEventOccured == EMoscoStateChangeEvent)

                {

                return retFsmCheck;

                }

            else

                {

                iEventOccured = EMarncResourceAvailableOS;

                }

            }

        else

            {

    		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 if (iExpectedRecorderState != aRecorderState)

		{

		ERR_PRINTF3(_L("ExpectedRecorderState : %d, ActualRecorderState : %d"), iExpectedRecorderState, aRecorderState);

		iTestStepResult = EFail;

		CActiveScheduler::Stop();

		}

	else

		{

		retFsmCheck = ETrue;

		}

	return retFsmCheck;

	}

/**

 * FsmL

 */

void CTestMmfAclntARN9001::FsmL(TMmfAudioMultiClientEvents aEventCode, TInt aError, CMdaAudioClipUtility::TState aRecorderState)

	{

	if (FsmCheck(aEventCode, aError, aRecorderState))

		{

		TInt err = KErrNone;

		switch (iState)

			{

			case 0:

				// Open iTestAudioPlayer

				iTestAudioPlayer->OpenFileL(iFilenamePlayer);

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

				// Set ExpectedEvent, ExpectedError, ExpectedRecorderState and change the State

				StateChange(EMapcInitComplete);

				break;

			case 1:

				// Play iTestAudioPlayer

				iTestAudioPlayer->Play();

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

				// Open iTestAudioRecorder

				iTestAudioRecorder->OpenFileL(iFilenameRecorder);

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

				// Set ExpectedEvent, ExpectedError, ExpectedRecorderState and change the State

				StateChange(EMoscoStateChangeEvent, KErrNone, CMdaAudioClipUtility::EOpen);

				break;

			case 2:

				// Play iTestAudioRecorder

				iTestAudioRecorder->PlayL();

				INFO_PRINTF1(_L("iTestAudioRecorder->PlayL()"));

				// Set ExpectedEvent and change the State

				StateChange(EMoscoStateChangeEvent, KErrNone, CMdaAudioClipUtility::EPlaying);

				break;

			case 3:

				// iTestAudioPlayer gets PlayError.

				StateChange(EMapcPlayComplete, KErrInUse);

				break;

			case 4:

				// Register iTestAudioPlayer for Notification

				err = iTestAudioPlayer->RegisterAudioResourceNotification(*iMdaAudioPlayerCallbackSupport, KMMFEventCategoryAudioResourceAvailable);

				INFO_PRINTF2(_L("iTestAudioPlayer->RegisterAudioResourceNotification : Status - %d "), err);

				if( err != KErrNone )

					{

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

					iTestStepResult = EFail;

					CActiveScheduler::Stop();

					break;

					}

				// Register iTestAudioOutputStream for Notification

				err = iTestAudioOutputStream->RegisterAudioResourceNotification(*iMdaAudioOutputStreamCallbackSupport, KMMFEventCategoryAudioResourceAvailable);

				INFO_PRINTF2(_L("iTestAudioOutputStream->RegisterAudioResourceNotification : Status - %d "), err);

				if( err != KErrNone )

					{

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

					iTestStepResult = EFail;

					CActiveScheduler::Stop();

					break;

					}

				// Open iTestAudioOutputStream

				iTestAudioOutputStream->Open(NULL);

				INFO_PRINTF1(_L("iTestAudioOutputStream->Open()"));

				// Set ExpectedEvent, ExpectedError, ExpectedRecorderState and change the State

				StateChange(EMaoscOpenComplete);

				break;

			case 5:

				// iFile->Read()

				err = iFile.Read(iBuf); //-synchronous

				if (err != KErrNone)

					{

					INFO_PRINTF2(_L("Error reading iFile %d"), err);

					User::Leave(err);

					}

				// iTestAudioOutputStream->WriteL()

				INFO_PRINTF1(_L("iTestAudioOutputStream->WriteL()"));

				iTestAudioOutputStream->WriteL(iBuf); //-Should get Play Error.

				// Set ExpectedEvent & ExpectedError and change the State

				StateChange(EMaoscBufferCopied, KErrInUse);

				break;

			case 6:

				// Set ExpectedEvent & ExpectedError and change the State

				StateChange(EMaoscPlayComplete, KErrInUse);

				break;

			case 7:

				// Delete the instance iTestAudioPlayer