// 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);
	}

TBool RTestStepMmfCtlfrmDualAudio::IsSoughtEvent( TMMFEvent& aExpectedEvent, TMMFEventPckg& aReceivedEvent )
	{
	
	TInt expectedUid = aExpectedEvent.iEventType.iUid;
	TInt receivedUid = aReceivedEvent().iEventType.iUid;

	// display any events we get
	INFO_PRINTF3(_L("Event expected : 0x%08x %d"), 
				 expectedUid, aExpectedEvent.iErrorCode);
	INFO_PRINTF3(_L("Event received : 0x%08x %d"), 
				 aReceivedEvent().iEventType.iUid, aReceivedEvent().iErrorCode);

	return ((expectedUid == receivedUid) &&
	 	    (aExpectedEvent.iErrorCode == aReceivedEvent().iErrorCode));
	}

void RTestStepMmfCtlfrmDualAudio::CancelReceivedEvents(TInt aWhichController)
	{
	RMMFController* theController;
	// which controller are we searching on?
	if(aWhichController == 1)
		theController = &iController1;
	else if(aWhichController == 2)
		theController = &iController2;
	else 
		{
		ERR_PRINTF1(_L("CancelReceivedEvents error : controller must be 1 or 2"));
		return;
		}
	(*theController).CancelReceiveEvents();
	}

// ---------------------------
// RTestStepMmfCtlfrmVideo
// base class with preamble / postamble to open and close the video controller
// NB we're only actually using this to test custom commands

TVerdict RTestStepMmfCtlfrmVideo::OpenL() 
	{
	TInt error = KErrNone;

	iSettings.iPriority = ETSIMmfPriorityHigh;
	iSettings.iPref = EMdaPriorityPreferenceQuality;
	iSettings.iState = EMMFStateIdle;

	// Open a controller
	error = iController.Open(KMmfVideoTestControllerUid, iSettings);
	if (error)
		{
		ERR_PRINTF2(_L("controller failed to open, error %d"), error);
		return iTestStepResult = EInconclusive;
		}

	INFO_PRINTF2(_L("Opened Custom Video Controller, UID 0x%8x"), KMmfVideoTestControllerUid);
	// Add a source and sink
	_LIT(KTestAviFile, "c:\\VclntITestData\\LongVideo.avi");
	iFileConfig().iPath = KTestAviFile;
	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 RTestStepMmfCtlfrmVideo::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);
	}