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

// TSIMmfCtlfrmStep.cpp

// 

//

// EPOC includes

#include <e32base.h>

// Test system includes

#include <testframework.h>

#include "TSI_MmfCtlfrmStep.h"

#include "TSI_MmfCtlfrmSuite.h"

#include "TSI_MmfCodes.h"

#include "TSI_MmfEventIds.h"

#include "ActrlTestUids.h"

#include <mmf/common/mmfcontroller.h>

#include <mmf/plugin/mmfcontrollerimplementationuids.hrh>

const TUid KTestControllerUid = {KTSIMmfControllerUid};

const TUid KTestController2Uid = {KTSIMmfController2Uid};

//const TUid KTestDataSourceUid = {KTSIMmfDataSourceUid};	

//const TUid KTestDataSinkUid   = {KTSIMmfDataSinkUid};		

// audio controller, from mmfControllerImplementationUIDs.hrh

//const TUid KTestAudioControllerUid = {KMmfUidControllerAudio};	

// event values for audio controller testing

const TInt KDelay            = 1000000;

const TInt KMaxRetries       = 12;

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

// RTestStepMmfCtlfrm

// base class

RTestStepMmfCtlfrm::RTestStepMmfCtlfrm() 

	{

	}

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

// RTestStepMmfCtlfrmTest1

// base class with preamble / postamble to open and close the test controller

TVerdict RTestStepMmfCtlfrmTest1::OpenL() 

	{

	TInt error = KErrNone;

	iSettings.iPriority = ETSIMmfPriorityLow;

	iSettings.iPref = EMdaPriorityPreferenceTime;

	iSettings.iState = EMMFStateIdle;

	// Open a controller

	error = iController.Open(KTestControllerUid, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	return iTestStepResult = EPass;

	}

void RTestStepMmfCtlfrmTest1::Close() 

	{

	iController.Close();

	// close controller delay - ensure it has time to finish

	// (so we don't get access violation from something trying to dequeue it before it's closed)

	const TTimeIntervalMicroSeconds32 KCloseControllerDelay = 500000L;

	User::After(KCloseControllerDelay);

	}

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

// RTestStepMmfCtlfrmTest2

// base class with preamble / postamble to open and close the test controller 2

TVerdict RTestStepMmfCtlfrmTest2::OpenL() 

	{

	TInt error = KErrNone;

	iSettings.iPriority = ETSIMmfPriorityLow;

	iSettings.iPref = EMdaPriorityPreferenceTime;

	iSettings.iState = EMMFStateIdle;

	// Open a controller

	error = iController.Open(KTestController2Uid, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	return iTestStepResult = EPass;

	}

void RTestStepMmfCtlfrmTest2::Close() 

	{

	iController.Close();

	// close controller delay - ensure it has time to finish

	// (so we don't get access violation from something trying to dequeue it before it's closed)

	const TTimeIntervalMicroSeconds32 KCloseControllerDelay = 500000L;

	User::After(KCloseControllerDelay);

	}

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

// RTestStepMmfCtlfrmAudio

// base class with preamble / postamble to open and close the audio controller

TVerdict RTestStepMmfCtlfrmAudio::OpenL() 

	{

	TInt error = KErrNone;

	iSettings.iPriority = ETSIMmfPriorityHigh;

	iSettings.iPref = EMdaPriorityPreferenceQuality;

	iSettings.iState = EMMFStateIdle;

	// Open a controller

	error = iController.Open(KUidCustomTestAudioPlugin, iSettings);

//	error = iController.Open(KTestAudioControllerUid, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	INFO_PRINTF2(_L("Opened Custom Audio Controller, UID 0x%8x"), KUidCustomTestAudioPlugin);

	// Add a source and sink

	_LIT(KTestWavFile, "c:\\TsiMmfCtlfrmData\\test.wav");

	iFileConfig().iPath = KTestWavFile;

	error = iController.AddDataSource(KUidMmfFileSource, iFileConfig);

	if (error)

		{

		ERR_PRINTF2(_L("failed to add a data source, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	error = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8);

	if (error)

		{

		ERR_PRINTF2(_L("failed to add a data sink, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	return iTestStepResult = EPass;

	}

void RTestStepMmfCtlfrmAudio::Close() 

	{

	iController.Stop();

	iController.Reset();

	iController.Close();

	// close controller delay - ensure it has time to finish

	// (so we don't get access violation from something trying to dequeue it before it's closed)

	const TTimeIntervalMicroSeconds32 KCloseControllerDelay = 500000L;

	User::After(KCloseControllerDelay);

	}

// Searches for an event

TVerdict RTestStepMmfCtlfrmAudio::SearchForEvent( TMMFEvent& aEvent )

	{

#ifdef EVENT_SEARCH_DISABLED

	WARN_PRINTF1(_L("Warning : SearchForEvent disabled"));

    TMMFEvent dummyEvent; // JS

	aEvent = dummyEvent;	// to get rid of compiler warning

	return EPass;

#else

	TVerdict result = EFail;

	// status of events

	TRequestStatus timerStatus;

	TRequestStatus eventStatus;

	// due to problems with the timer as a member variable 

	// added a local timer here

	RTimer  myTimer ;

	myTimer.CreateLocal();

    // create an event and initialise with unknown marker

    TMMFEventPckg receivedEvent;

	// for KMaxRetries attempt to find the event

	for( TInt retries = 0; retries < KMaxRetries; retries++ )

		{

		// post receive event to controller

		iController.ReceiveEvents( receivedEvent, eventStatus );

		// start breakout timer to escape

		myTimer.After(timerStatus, KDelay);

		// wait for an event to mature

		User::WaitForRequest( eventStatus, timerStatus );

		// check if the command is the event 

		// and that a timeout did not occur

        if( IsTimeOut( eventStatus ))

			{

			// cancel the receive events

			CancelReceivedEvents();

			}

		else if( IsSoughtEvent( aEvent, receivedEvent ) )

			{

			// cancel the outstanding timer

			User::Check();

			myTimer.Cancel();

			// set status to pass since we have found the event

			result = EPass;

			break;

			}

		else

			{

			// We rx'd an event other than expected

			myTimer.Cancel();

			}

		}

	return result;

#endif // EVENT_SEARCH_DISABLED

	}

TBool RTestStepMmfCtlfrmAudio::IsTimeOut( TRequestStatus& aEventStatus )

	{

    return ( aEventStatus == KRequestPending);

	}

TBool RTestStepMmfCtlfrmAudio::IsSoughtEvent( TMMFEvent& aExpectedEvent, TMMFEventPckg& aReceivedEvent )

	{

	TInt expectedUid = aExpectedEvent.iEventType.iUid;

	TInt receivedUid = aReceivedEvent().iEventType.iUid;

	// display any events we get

	INFO_PRINTF3(_L("Event received : 0x%08x %d"), 

					 aReceivedEvent().iEventType.iUid, aReceivedEvent().iErrorCode);

	return ((expectedUid == receivedUid) &&

	 	    (aExpectedEvent.iErrorCode == aReceivedEvent().iErrorCode));

	}

void RTestStepMmfCtlfrmAudio::CancelReceivedEvents()

	{

	iController.CancelReceiveEvents();

	}

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

// RTestStepMmfCtlfrmAudioPrimed

// as above, with source / sink handles, primed in preamble

TVerdict RTestStepMmfCtlfrmAudioPrimed::OpenL()

	{

	// initialise the controller, including adding source and sink; prime it.

	// retain handles to the source and sink so we can verify them after reset

	TInt error = KErrNone;

	TVerdict result = EPass;

	iSourceHandlePtr = NULL;

	iSinkHandlePtr = NULL;

	iSettings.iPriority = ETSIMmfPriorityHigh;

	iSettings.iPref = EMdaPriorityPreferenceQuality;

	iSettings.iState = EMMFStateIdle;

	// Open a controller

	error = iController.Open(KUidCustomTestAudioPlugin, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	INFO_PRINTF2(_L("Opened Custom Audio Controller, UID 0x%8x"), KUidCustomTestAudioPlugin);

	// Add a source and sink

	_LIT(KTestWavFile, "c:\\TsiMmfCtlfrmData\\test.wav");

	iFileConfig().iPath = KTestWavFile;

	// add a data source with a handle

	iSourceHandlePtr = new (ELeave) TMMFMessageDestination();

	TMMFMessageDestination& sourceHandle = *iSourceHandlePtr;

	error = iController.AddDataSource(KUidMmfFileSource, iFileConfig, sourceHandle);

	if (error)

		{

		ERR_PRINTF2(_L("AddDataSource failed, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	// add a data sink with a handle

	iSinkHandlePtr = new (ELeave) TMMFMessageDestination();

	TMMFMessageDestination& sinkHandle = *iSinkHandlePtr;

	error = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8, sinkHandle);

	if (error)

		{

		ERR_PRINTF2(_L("AddDataSink failed, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	// prime it

	error = iController.Prime();

	if(error)

		{

		ERR_PRINTF2(_L("Prime failed, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	// wait for and process the return event from the custom audio controller

	TMMFEvent primeEvent( KPrimeTestId, KErrNone);

	result = SearchForEvent( primeEvent );

	if( result == EFail )

		{

		ERR_PRINTF1(_L("Custom audio controller did not return a prime event"));

		Close();

		return iTestStepResult = EInconclusive;

		}

	return iTestStepResult = EPass;

	}

void RTestStepMmfCtlfrmAudioPrimed::Close() 

	{

	iController.Stop();

	iController.Reset();

	delete iSinkHandlePtr;

	delete iSourceHandlePtr;

	iController.Close();

	// close controller delay - ensure it has time to finish

	// (so we don't get access violation from something trying to dequeue it before it's closed)

	const TTimeIntervalMicroSeconds32 KCloseControllerDelay = 500000L;

	User::After(KCloseControllerDelay);

	}

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

// RTestStepMmfCtlfrmAudioNoSource

// same as RTestStepMmfCtlfrmAudio, but has no source or sink loaded yet

TVerdict RTestStepMmfCtlfrmAudioNoSource::OpenL()

	{

	// preamble - load a controller but give it no data source

	TInt error = KErrNone;

	iSettings.iPriority = ETSIMmfPriorityHigh;

	iSettings.iPref = EMdaPriorityPreferenceQuality;

	iSettings.iState = EMMFStateIdle;

	// Open a controller

	error = iController.Open(KUidCustomTestAudioPlugin, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	INFO_PRINTF2(_L("Opened Custom Audio Controller, UID 0x%8x"), KUidCustomTestAudioPlugin);

	return iTestStepResult = EPass;

	}

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

// RTestStepMmfCtlfrmDualAudio

// same as RTestStepMmfCtlfrmAudio, with 2 identical controllers

TVerdict RTestStepMmfCtlfrmDualAudio::OpenL() 

	{

	TInt error = KErrNone;

	iSettings.iPriority = ETSIMmfPriorityHigh;

	iSettings.iPref = EMdaPriorityPreferenceTime;

	iSettings.iState = EMMFStateIdle;

	// Open both controllers

	error = iController1.Open(KUidCustomTestAudioPlugin, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("iController1 failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	INFO_PRINTF2(_L("Controller 1 : Opened Custom Audio Controller, UID 0x%8x"), KUidCustomTestAudioPlugin);

	error = iController2.Open(KUidCustomTestAudioPlugin, iSettings);

	if (error)

		{

		ERR_PRINTF2(_L("iController2 failed to open, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	INFO_PRINTF2(_L("Controller 2 : Opened Custom Audio Controller, UID 0x%8x"), KUidCustomTestAudioPlugin);

	// Add source and sink

	// Use two different files to avoid conflict

	_LIT(KTestWavFile1, "c:\\TsiMmfCtlfrmData\\test.wav");

	_LIT(KTestWavFile2, "c:\\TsiMmfCtlfrmData\\test2.wav");

	iFileConfig1().iPath = KTestWavFile1;

	iFileConfig2().iPath = KTestWavFile2;

	error = iController1.AddDataSource(KUidMmfFileSource, iFileConfig1);

	if (error)

		{

		ERR_PRINTF2(_L("iController1 failed to add a data source, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	error = iController1.AddDataSink(KUidMmfAudioOutput, KNullDesC8);

	if (error)

		{

		ERR_PRINTF2(_L("iController1 failed to add a data sink, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	error = iController2.AddDataSource(KUidMmfFileSource, iFileConfig2);

	if (error)

		{

		ERR_PRINTF2(_L("iController2 failed to add a data source, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	error = iController2.AddDataSink(KUidMmfAudioOutput, KNullDesC8);

	if (error)

		{

		ERR_PRINTF2(_L("iController2 failed to add a data sink, error %d"), error);

		Close();

		return iTestStepResult = EInconclusive;

		}

	return iTestStepResult = EPass;

	}

void RTestStepMmfCtlfrmDualAudio::Close() 

	{

	iController1.Stop();

	iController1.Reset();

	iController1.Close();

	iController2.Stop();

	iController2.Reset();

	iController2.Close();

	// close controller delay - ensure it has time to finish

	// (so we don't get access violation from something trying to dequeue it before it's closed)

	const TTimeIntervalMicroSeconds32 KCloseControllerDelay = 500000L;

	User::After(KCloseControllerDelay);

	}

// Searches for an event

TVerdict RTestStepMmfCtlfrmDualAudio::SearchForEvent( TMMFEvent& aEvent, TInt aWhichController )

	{

	// NB don't worry about EVENT_SEARCH_DISABLED here,

	// as generally we'll be looking for events from the Controller Framework here,

	// not from the custom Audio Controller

	TVerdict result = EFail;

	// status of events

	TRequestStatus timerStatus    ;

	TRequestStatus eventStatus    ;

	RMMFController* theController;

	// which controller are we searching on?

	if(aWhichController == 1)

		theController = &iController1;

	else if(aWhichController == 2)

		theController = &iController2;

	else 

		{

		ERR_PRINTF1(_L("SearchForEvent error : controller must be 1 or 2"));

		return result = EFail;

		}

	// due to problems with the timer as a member variable 

	// added a local timer here

	RTimer  myTimer ;

	myTimer.CreateLocal();

    // create an event and initialise with unknown marker

    TMMFEventPckg receivedEvent;

	// for KMaxRetries attempt to find the event

	for( TInt retries = 0; retries < KMaxRetries; retries++ )

		{

		// post receive event to controller

		(*theController).ReceiveEvents( receivedEvent, eventStatus );

		// start breakout timer to escape

		myTimer.After( timerStatus, KDelay );

		// wait for an event to mature

		User::WaitForRequest( eventStatus, timerStatus );

		// check if the command is the event 

		// and that a timeout did not occur

        if( IsTimeOut( eventStatus ))

			{

			// cancel the receive events

			CancelReceivedEvents(aWhichController);

			}

		else if( IsSoughtEvent( aEvent, receivedEvent ) )

			{

			// cancel the outstanding timer

			User::Check();

			myTimer.Cancel();

			// set status to pass since we have found the event

			result = EPass;

			break;

			}

		else

			{

			// We rx'd an event other than expected

			myTimer.Cancel();

			}

		}

    return result;

	}

TBool RTestStepMmfCtlfrmDualAudio::IsTimeOut( TRequestStatus& aEventStatus )

	{

    return (aEventStatus == KRequestPending);

	}