// 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 Output Stream.

// 

//

/**

 @file TestOutputStreamARN.cpp

*/

#include "TestAudioClientUtilitiesARN.h"

const TInt KSampleRate = 8000;

const TInt KBytesPerSample = 2; 

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

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

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

//

//CTestMdaAudioOutputStreamCallbackSupport

//

/**

 * NewL

 */

CTestMdaAudioOutputStreamCallbackSupport* CTestMdaAudioOutputStreamCallbackSupport::NewL(MTestAudioOutputStreamCallback& aCallback)

	{

	return new(ELeave) CTestMdaAudioOutputStreamCallbackSupport(aCallback);

	}

/**

 * MaoscOpenComplete

 */

void CTestMdaAudioOutputStreamCallbackSupport::MaoscOpenComplete(TInt aError)

	{

	iCallback.MaoscOpenCompleteTest(aError, *this);

	}

/**

 * MaoscBufferCopied

 */

void CTestMdaAudioOutputStreamCallbackSupport::MaoscBufferCopied(TInt aError, const TDesC8& aBuffer)

	{

	iCallback.MaoscBufferCopiedTest(aError, aBuffer, *this);

	}

/**

 * MaoscPlayComplete

 */

void CTestMdaAudioOutputStreamCallbackSupport::MaoscPlayComplete(TInt aError)

	{

	iCallback.MaoscPlayCompleteTest(aError, *this);

	}

/**

 * MarncResourceAvailable

 */

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

	{

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

	}

/**

 * Constructor

 */

CTestMdaAudioOutputStreamCallbackSupport::CTestMdaAudioOutputStreamCallbackSupport(MTestAudioOutputStreamCallback& aCallback):iCallback(aCallback)

	{

	}

//

//CTestStepAudioOutputStreamARN

//

/**

 * Constructor

 */

CTestStepAudioOutputStreamARN::CTestStepAudioOutputStreamARN(const TDesC& aTestName)

	{

	iTestStepName = aTestName;

	iFileSize1 = 0;

	iFileSize2 = 0;

	iHeapSize = 3600000;

	}

/**

 * MMdaAudioOutputStreamCallback->MaoscOpenComplete

 */

void CTestStepAudioOutputStreamARN::MaoscOpenCompleteTest(TInt aError, CTestMdaAudioOutputStreamCallbackSupport& aMdaAudioOutputStreamCallbackSupport)

	{

	if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport1)

		{

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

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

		}

	else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport2)

		{

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

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

		}

	else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport3)

		{

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

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

		}

	}

/**

 * MMdaAudioOutputStreamCallback->MaoscBufferCopied

 */

void CTestStepAudioOutputStreamARN::MaoscBufferCopiedTest(TInt aError, const TDesC8& /*aBuffer*/, CTestMdaAudioOutputStreamCallbackSupport& aMdaAudioOutputStreamCallbackSupport)

	{

	if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport1)

		{

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

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

		}

	else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport2)

		{

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

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

		}

	else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport3)

		{

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

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

		}

	}

/**

 * MMdaAudioOutputStreamCallback->MaoscPlayComplete

 */

void CTestStepAudioOutputStreamARN::MaoscPlayCompleteTest(TInt aError, CTestMdaAudioOutputStreamCallbackSupport& aMdaAudioOutputStreamCallbackSupport)

	{

	if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport1)

		{

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

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

		}

	else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport2)

		{

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

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

		}

	else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport3)

		{

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

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

		}

	}

/**

 * MMMFAudioResourceNotificationCallback->MarncResourceAvailable

 */

void CTestStepAudioOutputStreamARN::MarncResourceAvailableTest(TUid aNotificationEventId, const TDesC8& aNotificationData, CTestMdaAudioOutputStreamCallbackSupport& aMdaAudioOutputStreamCallbackSupport)

	{

	if (aNotificationEventId == KMMFEventCategoryAudioResourceAvailable)

		{

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

		//Convert TDesc8 to TInt64

		TMMFTimeIntervalMicroSecondsPckg timeIntvbuf;

		timeIntvbuf.Copy(aNotificationData);

		TTimeIntervalMicroSeconds intPos = timeIntvbuf();

		iPosition = intPos;

		if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport1)

			{

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

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

			}

		else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport2)

			{

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

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

			}

		else if (&aMdaAudioOutputStreamCallbackSupport == iMdaAudioOutputStreamCallbackSupport3)

			{

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

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

			}

		}

	else

		{

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

		}

	}

/**

 * DoTestStepPreambleL

 */

TVerdict CTestStepAudioOutputStreamARN::DoTestStepPreambleL()

	{

	// Local Variable to hold verdict

	TVerdict verdict;

	// Install the scheduler

	verdict = CTestMmfAclntStep::DoTestStepPreambleL();

	if (verdict == EFail)

		{

		return verdict;

		}

	// Connect RFs session

	TInt err = iFs.Connect();

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Initialise iTestAudioOutputStream1

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

	iMdaAudioOutputStreamCallbackSupport1 = CTestMdaAudioOutputStreamCallbackSupport::NewL(*this);

	TRAP(err, iTestAudioOutputStream1 = CMdaAudioOutputStream::NewL(*iMdaAudioOutputStreamCallbackSupport1, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality));

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

		{

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

		return EInconclusive;

		}

	// Open RFile#1

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

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Get size of iFile1

	err = iFile1.Size(iFileSize1);

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Initialise iBuf1

	iBuf1.CreateMaxL(iFileSize1);

	// Initialise iTestAudioOutputStream2

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

	iMdaAudioOutputStreamCallbackSupport2 = CTestMdaAudioOutputStreamCallbackSupport::NewL(*this);

	TRAP(err, iTestAudioOutputStream2 = CMdaAudioOutputStream::NewL(*iMdaAudioOutputStreamCallbackSupport2, EMdaPriorityMax, EMdaPriorityPreferenceTimeAndQuality));

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

		{

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

		return EInconclusive;

		}

	// Open RFile#2

	err = iFile2.Open(iFs, KStreamRawFile2, EFileRead);

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Get size of iFile2

	err = iFile2.Size(iFileSize2);

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Initialise iBuf2

	iBuf2.CreateMaxL(iFileSize2);

	// Initialise iTestAudioOutputStream3

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

	iMdaAudioOutputStreamCallbackSupport3 = CTestMdaAudioOutputStreamCallbackSupport::NewL(*this);

	TRAP(err, iTestAudioOutputStream3 = CMdaAudioOutputStream::NewL(*iMdaAudioOutputStreamCallbackSupport3, EMdaPriorityMin, EMdaPriorityPreferenceTimeAndQuality));

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

		{

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

		return EInconclusive;

		}

	// Open RFile#3

	err = iFile3.Open(iFs, KStreamRawFile3, EFileRead);

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Get size of iFile3

	err = iFile3.Size(iFileSize3);

	if (err != KErrNone)

		{

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

		return EFail;

		}

	// Initialise iBuf3

	iBuf3.CreateMaxL(iFileSize3);

	// Initialise the CCallBackTimer.

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

	return verdict;

	}

/**

 * DoTestStepPostambleL

 */

TVerdict CTestStepAudioOutputStreamARN::DoTestStepPostambleL()

	{

	// Delete all the iTestAudioOutputStream utilities.

	delete iTestAudioOutputStream1;

	iTestAudioOutputStream1=NULL;

	delete iTestAudioOutputStream2;

	iTestAudioOutputStream2=NULL;

	delete iTestAudioOutputStream3;

	iTestAudioOutputStream3=NULL;

	// Destroy File Handles

	iFile1.Close();

	iFile2.Close();

	iFile3.Close();

	iFs.Close();

	// Delete RBuf8

	iBuf1.Close();

	iBuf2.Close();

	iBuf3.Close();

	// Delete CTestMdaAudioOutputStreamCallbackSupport

	delete iMdaAudioOutputStreamCallbackSupport1;

	delete iMdaAudioOutputStreamCallbackSupport2;

	delete iMdaAudioOutputStreamCallbackSupport3;

	// Delete the CCallBackTimer.

	delete iCallBackTimer;

	iCallBackTimer=NULL;

	// Destroy the scheduler

	return CTestMmfAclntStep::DoTestStepPostambleL();

	}

/**

 * DoTestStepL

 */

TVerdict CTestStepAudioOutputStreamARN::DoTestStepL()

	{

	return( DoTestL() );

	}

/**

 * StateInit

 */

void CTestStepAudioOutputStreamARN::StateInit()

	{

	iExpectedEvent=EIdleOutputStream;

	iExpectedError=KErrNone;

	iState=0;

	}

/**

 * StateChange

 */

void CTestStepAudioOutputStreamARN::StateChange(TMmfAudioOutputStreamEvents aExpectedEvent, TInt aExpectedError)

	{

	iExpectedEvent=aExpectedEvent;

	iExpectedError=aExpectedError;

	iState++;

	}

/**

 * FsmCheck

 */

TBool CTestStepAudioOutputStreamARN::FsmCheck(TMmfAudioOutputStreamEvents aEventCode, TInt aError)

	{

	TBool retFsmCheck = EFalse;

	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;	

	}

CTestStepAudioOutputStreamARN2::CTestStepAudioOutputStreamARN2(const TDesC& aTestName)

	{

	iTestStepName = aTestName;

	iHeapSize = 3600000;

	}

/**

 * DoTestStepPreambleL

 */

TVerdict CTestStepAudioOutputStreamARN2::DoTestStepPreambleL()

	{

	TVerdict verdict;

	verdict = CTestMmfAclntStep::DoTestStepPreambleL();

	if (verdict == EFail)

		{

		return verdict;

		}

	iClientList[1] = CFsmAudioOutputStreamClient::NewL(1, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality, this);

	iClientList[2] = CFsmAudioOutputStreamClient::NewL(2, EMdaPriorityMax, EMdaPriorityPreferenceTimeAndQuality, this);

	iClientList[3] = CFsmAudioOutputStreamClient::NewL(3, EMdaPriorityMin, EMdaPriorityPreferenceTimeAndQuality, this);

	// Connect RFs session

	TInt err = iFs.Connect();

	if (err != KErrNone)

		{

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

		return EFail;

		}

	err = iFileHandle[1].Open(iFs, KStreamRawFile1, EFileRead);

	if (err != KErrNone)

		{

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

		return EFail;

		}

	err = iFileHandle[2].Open(iFs, KStreamRawFile2, EFileRead);

	if (err != KErrNone)

		{

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

		return EFail;

		}	

	err = iFileHandle[3].Open(iFs, KStreamRawFile3, EFileRead);

	if (err != KErrNone)

		{

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

		return EFail;

		}	

	for(TInt fileNumber=1; fileNumber<=3; fileNumber++)

		{

		err = iFileHandle[fileNumber].Size(iFileSize[fileNumber]);

		if(err != KErrNone)

			{

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

			return EFail;

			}

		iBuf[fileNumber].CreateMaxL(iFileSize[fileNumber]);

		}

	// Initialise the CCallBackTimer.

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

	return verdict;

	}

/**

 * DoTestStepPostambleL

 */

TVerdict CTestStepAudioOutputStreamARN2::DoTestStepPostambleL()

	{

	iClientList.DeleteAll();

	for(TInt fileNumber=1; fileNumber <=3; fileNumber++)

		{

		iFileHandle[fileNumber].Close();

		}

	for(TInt bufNumber=1 ; bufNumber <=3; bufNumber++)

		{

		iBuf[bufNumber].Close();

		}

	delete iCallBackTimer;

	return CTestMmfAclntStep::DoTestStepPostambleL();

	}

/**

 * DoTestStepL

 */

TVerdict CTestStepAudioOutputStreamARN2::DoTestStepL()

	{

	return( DoTestL() );

	}

/**

 * StateChange

 */

void CTestStepAudioOutputStreamARN2::StateChange(TFsmAosState aState)

	{

	iState = aState;

	}

void CTestStepAudioOutputStreamARN2::StopTest()

	{

	//We can add other cleanup things here 

	CActiveScheduler::Stop();

	}

void CTestStepAudioOutputStreamARN2::SetExpectedEvent(TInt aClientNumber, TInt aExpectedEvent, TInt aExpectedError)

	{

	iClientEventsToMonitor[aClientNumber]= aExpectedEvent;

	iClientError[aClientNumber] = aExpectedError;

	}

/**

 * FsmCheck

 */

TBool CTestStepAudioOutputStreamARN2::FsmCheck(TInt aClientNumber, TInt aEventCode, TInt aError)

	{

	TBool retFsmCheck = ETrue;

	if (iState == EStateMonitoringEvents) /*special state to make decisions depending on clients events */

		{

		if(iClientEventsToMonitor[aClientNumber] == aEventCode && iClientError[aClientNumber] == aError )