/*

* Copyright (c) 2002 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:  AudioroutingControl test module

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "AudioRoutingTestClass.h"

#include "debug.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

// ============================ MEMBER FUNCTIONS ===============================

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

// CAudioAudioRoutingTest::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

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

//

TInt CAudioRoutingTestClass::Delete()

{

	TInt error= KErrNone;

    FTRACE(FPrint(_L("CAudioRoutingTestClass::Delete")));

    iExpectedEvents.Close();

    iOcurredEvents.Close();

    iLog->Log(_L("Deleting test class..."));

	iLog->Log(_L(""));

	iLog->Log(_L(""));

	if (iAudioInput)

		{

		delete iAudioInput;

		}

	if (iAudioOutput)

		{

		delete iAudioOutput;

		}

	if (iAudioTone)

		{

		delete iAudioTone;

		}

	if (iAudioInputStream)

		{

		delete iAudioInputStream;

		}

	if (iAudioOutputStream)

		{

		delete iAudioOutputStream;

		}

	if (iCustomCommandUtility)

		{

		delete iCustomCommandUtility;

		}

	if (iMidiClientUtility)

		{

		iMidiClientUtility->Close();

		delete iMidiClientUtility;

		}

	if (iRecorder)

		{

		delete iRecorder;

		}

	if (iUtil)

		{

		delete iUtil;

		}

	if (iDrmPlayerUtility)

		{

		delete iDrmPlayerUtility;

		}

	if (iVideoPlayerUtility)

		{

		delete iVideoPlayerUtility;

		DeleteVideoWindow();

		}

	if (iDevSound)

		{

		delete iDevSound;

		}

	REComSession::FinalClose();

	return error;

}

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

// CAudioAudioRoutingTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CAudioRoutingTestClass::RunMethodL( CStifItemParser& aItem )

    {

    static TStifFunctionInfo const KFunctions[] =

        {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

		ENTRY( "AudioInput", CAudioRoutingTestClass::CreateAudioInput),

		ENTRY( "CreateObject", CAudioRoutingTestClass::CreateObject),

		ENTRY( "AudioInputs", CAudioRoutingTestClass::AudioInput),

		ENTRY( "SetAudioInput", CAudioRoutingTestClass::SetAudioInputL),

		ENTRY( "AudioOutput", CAudioRoutingTestClass::AudioOutput),

		ENTRY( "DefaultAudioOutput", CAudioRoutingTestClass::DefaultAudioOutput),

		ENTRY( "RegisterObserver", CAudioRoutingTestClass::RegisterObserverL),

		ENTRY( "SecureOutput", CAudioRoutingTestClass::SecureOutput),

		ENTRY( "SetAudioOutput", CAudioRoutingTestClass::SetAudioOutputL),

		ENTRY( "SetSecureOutput", CAudioRoutingTestClass::SetSecureOutputL),

		ENTRY( "UnregisterObserver", CAudioRoutingTestClass::UnregisterObserver),

        };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CAudioAudioRoutingTest::EventName

// Return descriptor with the notification description

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

TPtrC CAudioRoutingTestClass::EventName( TInt aKey )

{

	static TText* const badKeyword = (TText*)L"BadKeyword";

	static TText* const keywords[] =

		{

		(TText*)L"EInitializeComplete",

		};

	if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) )

		{

		iLog->Log(_L("Keyword out of bounds"));

		TPtrC keyword( badKeyword );

		return keyword;

		}

	else

		{

		TPtrC keyword( keywords[aKey] );

		return keyword;

		}

}

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

// CAudioAudioRoutingTest::AddExpectedEvent

// Add an event to the expected events' list

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

void CAudioRoutingTestClass::AddExpectedEvent(TG711ExpectedEvent event, TInt ms)

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::AddExpectedEvent")));

	iExpectedEvents.Append(event);

	TPtrC eventName = EventName(event);

	iLog->Log(_L("Adding expected event:(0x%02x)%S Total=%d"), event, &eventName, iExpectedEvents.Count() );

	if ( iTimeoutController && !iTimeoutController->IsActive() )

		{

		if (ms > 0)

			{

			iTimeoutController->Start( TTimeIntervalMicroSeconds(ms * 1000) );

			}

		else

			{

			iLog->Log(_L("Timeout with default value (1s)"));

			iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );

			}

		}

}

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

// CAudioAudioRoutingTest::RemoveExpectedEvent

// Remove the indicated event from the expected events' list

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

TBool CAudioRoutingTestClass::RemoveExpectedEvent(TG711ExpectedEvent aEvent)

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::RemoveExpectedEvent")));

	TBool match = EFalse;

	for (TUint i=0; i < iExpectedEvents.Count() ; i++)

		{

		if (iExpectedEvents[i] == aEvent)

			{

			iExpectedEvents.Remove(i);

			match = ETrue;

			break;

			}

		}

	return match;

}

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

// CAudioAudioRoutingTest::RemoveAllExpectedEvents

// Remove the indicated event from the expected events' list

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

void CAudioRoutingTestClass::RemoveAllExpectedEvents()

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::RemoveAllExpectedEvents")));

	iLog->Log(_L("Removing all expected events"));

	iExpectedEvents.Reset();

	iOcurredEvents.Reset();

}

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

// CAudioAudioRoutingTest::ProcessEvent

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

void CAudioRoutingTestClass::ProcessEvent(TG711ExpectedEvent aEvent, TInt aError)

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::ProcessEvent")));

	TPtrC nameEvent = EventName(aEvent);

	// Check for error

	if (aError == KErrNone)

		{

		// Remove the event

		if (RemoveExpectedEvent(aEvent))

			{

			iLog->Log(_L("Expected Event: (0x%02x)%S has ocurred Total=%d"), aEvent, &nameEvent,iExpectedEvents.Count());

			}

		else

			{

			iLog->Log(_L("Event: (0x%02x)%S has ocurred"), aEvent, &nameEvent);

			return;

			}

		// All expected events have ocurred

		if (iExpectedEvents.Count() == 0 )

			{

			Signal();

			iTimeoutController->Cancel();

			}

		}

	else

		{

		iLog->Log(_L("[Error] Event: (0x%02x)%S return with error code=%d"), aEvent, &nameEvent, aError);

		if (iExpectedEvents.Count() != 0 )

			{

			RemoveExpectedEvent(aEvent);

			}

		iTimeoutController->Cancel();

		Signal(KErrCallbackErrorCode);

		}

}

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

// CAudioAudioRoutingTest::HandleTimeout

// Review if all the expected events have ocurred once the time is over

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

void CAudioRoutingTestClass::HandleTimeout(TInt aError)

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::HandleTimeout")));

	// All expected events have ocurred

	if (aError != KErrNone)

		{

		if (iExpectedEvents.Count() == 0 )

			{

			iLog->Log(_L("Timing out but events have ocurred"));

			Signal();

			}

		else

			{

			RemoveAllExpectedEvents();

			iLog->Log(_L("Timing out and events still pending"));

			Signal(KErrEventPending);

			}

		}

	else

		{

		iLog->Log(_L("Timing out return a error %d"), aError);

		Signal(aError);

		}

}

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

// CAudioAudioRoutingTest::SetTimeout

// Create a timer and set a timeout

// When the timeout is reached the test case is marked as failed

// It's used rather than the "timeout" keyword in the configuration file

// because in this way the log continues

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

TInt CAudioRoutingTestClass::SetTimeout( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::SetTimeout")));

	TInt timeout=0;

	TInt error = aItem.GetNextInt(timeout) ;

	if ( iTimeoutController )

		{

		if ( timeout > 0 )

			{

			iTimeoutController->Start( TTimeIntervalMicroSeconds(timeout*1000) );

			}

		else

			{

			iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );

			}

		}

	else

		{

		iLog->Log(_L("Timeout Controller doesn't exist"));

		error = KErrTimeoutController;

		}

	return error;

}

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

// Uses the TestModuleBase API to allow a panic as exit reason for a test case

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

TInt CAudioRoutingTestClass::SetAllowedPanic( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::SetAllowedPanic")));

	TInt error = KErrNone;

	TInt panicCode;

	TPtrC panicType;

	if (  ( KErrNone == aItem.GetNextString(panicType) ) &&

	( KErrNone == aItem.GetNextInt(panicCode) )  )

		{

		iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode);

		iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode );

		iNormalExitReason = EFalse;

		}

	else

		{

		iLog->Log(KMsgBadTestParameters);

		error = KErrBadTestParameter;

		}

	return error;

}

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

// CAudioAudioRoutingTest::SetExpectedEvents()

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

TInt CAudioRoutingTestClass::SetExpectedEvents( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CAudioRoutingTestClass::SetExpectedEvents")));

	TInt error = KErrNone;

	TInt event=0;

	while ( KErrNone == aItem.GetNextInt(event))

		{

		AddExpectedEvent(static_cast<TG711ExpectedEvent>(event), 0); // Default timeout value

		}

	return error;

}

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

// CAudioAudioRoutingTest::ExampleL

// Example test method function.

// (other items were commented in a header).

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

//

TInt CAudioRoutingTestClass::ExampleL( CStifItemParser& aItem )

    {

    _LIT( KAudioRoutingTestClass, "AudioRoutingTestClass" );

    _LIT( KExample, "In Example" );

    TestModuleIf().Printf( 0, KAudioRoutingTestClass, KExample );

    iLog->Log( KExample );

    TInt i = 0;

    TPtrC string;

    _LIT( KParam, "Param[%i]: %S" );

    while ( aItem.GetNextString ( string ) == KErrNone )

        {

        TestModuleIf().Printf( i, KAudioRoutingTestClass, KParam, i, &string );

        i++;

        }

    return KErrNone;

    }

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

// CG711DecoderIntfcTestClass::CreateObject

// Create Factory

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

//

TInt CAudioRoutingTestClass::CreateObject( CStifItemParser& aItem )

	{

	FTRACE(FPrint(_L("CAudioAudioRoutingTest::CreateObject")));

	iLog->Log(_L("CAudioAudioRoutingTest::CreateObject"));

	TInt error = KErrNone;

	TPtrC object;

	aItem.GetNextString ( object );

	iObject.Set(object);

	iLog->Log(_L("the object to create is [%S]"),&object);

	if (object == KTagDevSound)

		{

	    TRAP(error, iDevSound = CMMFDevSound::NewL());

		if (error == KErrNone)

		    {

		    TRAP(error,iDevSound->InitializeL(*this,KMMFFourCCCodeAMR,EMMFStatePlaying));

		    }

		}

	else if (object == KTagRecorder)

		{

		iInputOutput = ETrue;

		CreateInput();

		}

	else if (object== KTagCustomCommand)

		{

		TPtrC type;

		aItem.GetNextString ( type );

		if (type == KTagAudioPlayer)

			{

			TRAP(error,iCustomCommandUtility = CCustomCommandUtility::NewL(*iUtil));

			}

		else

			{

			TRAP(error,iCustomCommandUtility = CCustomCommandUtility::NewL(*iRecorder,ETrue));

			}

		}

	else if (object == KTagCustomInterface)

		{

		TPtrC type;

		aItem.GetNextString ( type );

		if (type == KTagAudioPlayer)

			{

			TRAP(error,iCustomInterfaceUtility = CCustomInterfaceUtility::NewL(*iUtil));

			}

		else if (type == KTagCustomCommand)

			{

			TRAP(error,iCustomInterfaceUtility = CCustomInterfaceUtility::NewL(*iCustomCommandUtility));

			}

		else if (type == KTagRecorder)

			{

			TRAP(error,iCustomInterfaceUtility = CCustomInterfaceUtility::NewL(*iRecorder,ETrue));

			}

		}

	else if (object == KTagInputStream)

		{

		TRAP(error,iAudioInputStream = CMdaAudioInputStream::NewL(*this));

		}

	else if (object == KTagAudioPlayer)

		{

		CreateOutput();

		}

	else if (object == KTagOuputRecord)

		{

		iInputOutput = EFalse;

		CreateInput();

		}