/*

* 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:  EMC - Test App

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <DRMConfigIntfc.h>

#include <DataBufferSource.h>

#include <CommDbConnPref.h>

#include <commdb.h>

#include "EnhanMediaTestClass.h"

#include "debug.h"

using namespace multimedia;

// 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 ===============================

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

// CEnhanMediaTestClass::Delete

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

// Called from destructor.

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

//

void CEnhanMediaTestClass::Delete()

	{

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

    iExpectedEvents.Reset();

    iExpectedEvents.Close();

    iFs.Close();

    //iOcurredEvents.Close();

	//iSupportedBitrates.Close();

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

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

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

}

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

// CEnhanMediaTestClass::RunMethodL

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

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

//

TInt CEnhanMediaTestClass::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( "CreateFactory", CEnhanMediaTestClass::CreateFactory ),

		ENTRY( "DeleteFactory", CEnhanMediaTestClass::DeleteFactory ),

		ENTRY( "AddObserver", CEnhanMediaTestClass::AddObserver ),

		ENTRY( "RemoveObserver", CEnhanMediaTestClass::RemoveObserver ),

        ENTRY( "CreateSource", CEnhanMediaTestClass::CreateSourceControl ),

        ENTRY( "StreamRemoveSource", CEnhanMediaTestClass::StreamRemoveSource ),

        ENTRY( "CloseSource", CEnhanMediaTestClass::CloseSource ),

        ENTRY( "DeleteSource", CEnhanMediaTestClass::DeleteSource ),

        ENTRY( "StreamAddSource", CEnhanMediaTestClass::StreamAddSource ),

        ENTRY( "CreateSink", CEnhanMediaTestClass::CreateSink),

        ENTRY( "DeleteSink", CEnhanMediaTestClass::DeleteSink),

        ENTRY( "StreamAddSink", CEnhanMediaTestClass::StreamAddSink),

        ENTRY( "StreamRemoveSink", CEnhanMediaTestClass::StreamRemoveSink),

        ENTRY( "CreateEffect", CEnhanMediaTestClass::CreateEffect ),

        ENTRY( "DeleteEffect", CEnhanMediaTestClass::DeleteEffect ),

        ENTRY( "RemoveEffect", CEnhanMediaTestClass::RemoveEffect ),

        ENTRY( "StreamAddEffect", CEnhanMediaTestClass::StreamAddEffect ),

        ENTRY( "CreateStream", CEnhanMediaTestClass::CreateStream ),

        ENTRY( "DeleteStream", CEnhanMediaTestClass::DeleteStream ),

        ENTRY( "FileSOpen", CEnhanMediaTestClass::FileSOpen ),

        ENTRY( "FileGenOpen", CEnhanMediaTestClass::FileGenOpen ),

        ENTRY( "DescSOpen", CEnhanMediaTestClass::DescSOpen ),

        ENTRY( "DBSOpen", CEnhanMediaTestClass::DBSOpen ),

        ENTRY( "DBSClose", CEnhanMediaTestClass::DBSClose ),

        ENTRY( "StreamOpen", CEnhanMediaTestClass::StreamOpen ),

        ENTRY( "StreamClose", CEnhanMediaTestClass::StreamClose ),

        ENTRY( "StreamPrime", CEnhanMediaTestClass::StreamPrime ),

        ENTRY( "EqualizerBandLevel", CEnhanMediaTestClass::EqualizerBandLevel ),

        ENTRY( "EqualizerNumBands", CEnhanMediaTestClass::EqualizerNumBands ),

        ENTRY( "EqualizerBandWidth", CEnhanMediaTestClass::EqualizerBandWidth ),

        ENTRY( "EqualizerCenterFrequency", CEnhanMediaTestClass::EqualizerCenterFrequency ),

        ENTRY( "EqualizerCrossoverFrequency", CEnhanMediaTestClass::EqualizerCrossoverFrequency ),

        ENTRY( "EqualizerDbLevelLimits", CEnhanMediaTestClass::EqualizerDbLevelLimits ),

        ENTRY( "EqualizerSetBandLevel", CEnhanMediaTestClass::EqualizerSetBandLevel ),

        ENTRY( "StreamStart", CEnhanMediaTestClass::StreamStart ),

        ENTRY( "StreamPause", CEnhanMediaTestClass::StreamPause ),

        ENTRY( "StreamStop", CEnhanMediaTestClass::StreamStop ),

        ENTRY( "StreamCustomInterface", CEnhanMediaTestClass::StreamCustomInterface ),

        ENTRY( "DescSGetBitRate", CEnhanMediaTestClass::DescSGetBitRate ),

        ENTRY( "CreateDataBuffer", CEnhanMediaTestClass::CreateDataBuffer ),

        ENTRY( "DBSSetSize", CEnhanMediaTestClass::DBSSetSize ),

        ENTRY( "DBSGetSize", CEnhanMediaTestClass::DBSGetSize ),

        ENTRY( "DBSMinBufSize", CEnhanMediaTestClass::DBSMinBufSize ),

        ENTRY( "WriteLoop", CEnhanMediaTestClass::WriteLoop ),

        ENTRY( "GetBuffConfig", CEnhanMediaTestClass::GetBuffConfig ),

        ENTRY( "DBSSetBuffConfig", CEnhanMediaTestClass::DBSSetBuffConfig ),

        ENTRY( "DBSGetBuffType", CEnhanMediaTestClass::DBSGetBuffType ),

        ENTRY( "DBSGetInterface", CEnhanMediaTestClass::DBSGetInterface ),

        ENTRY( "DBSGetBitRate", CEnhanMediaTestClass::DBSGetBitRate ),

        ENTRY( "DeleteDataBuffer", CEnhanMediaTestClass::DeleteDataBuffer ),

        ENTRY( "VolGetMinVolume", CEnhanMediaTestClass::VolGetMinVolume ),

        ENTRY( "VolGetMaxVolume", CEnhanMediaTestClass::VolGetMaxVolume ),

        ENTRY( "VolSetVolume", CEnhanMediaTestClass::VolSetVolume ),

        ENTRY( "VolGetVolume", CEnhanMediaTestClass::VolGetVolume ),

        ENTRY( "VolGetDefaultVolume", CEnhanMediaTestClass::VolGetDefaultVolume ),

        ENTRY( "BalGetBalance", CEnhanMediaTestClass::BalGetBalance ),

        ENTRY( "BalSetBalance", CEnhanMediaTestClass::BalSetBalance ),

        ENTRY( "EffectApply", CEnhanMediaTestClass::EffectApply ),

        ENTRY( "VolSetVolumeRamp", CEnhanMediaTestClass::VolSetVolumeRamp ),

        ENTRY( "FileSGetBitRate", CEnhanMediaTestClass::FileSGetBitRate ),

        ENTRY( "FileSGetSize", CEnhanMediaTestClass::FileSGetSize ),

        ENTRY( "Source_GetMimeType", CEnhanMediaTestClass::Source_GetMimeType ),

        ENTRY( "Source_GetSize", CEnhanMediaTestClass::Source_GetSize ),

        ENTRY( "Stream_GetDuration", CEnhanMediaTestClass::Stream_GetDuration ),

        ENTRY( "Stream_SetPriority", CEnhanMediaTestClass::Stream_SetPriority ),

        ENTRY( "StreamGetSSL", CEnhanMediaTestClass::StreamGetSSL ),

        ENTRY( "StreamGetRSSL", CEnhanMediaTestClass::StreamGetRSSL ),

        ENTRY( "StreamGetStateL", CEnhanMediaTestClass::StreamGetStateL ),

        ENTRY( "StreamGetCIL", CEnhanMediaTestClass::StreamGetCIL ),

        ENTRY( "StreamGetPositionL", CEnhanMediaTestClass::StreamGetPositionL ),

        ENTRY( "StreamSetPositionL", CEnhanMediaTestClass::StreamSetPositionL ),

        ENTRY( "ControlTypeL", CEnhanMediaTestClass::ControlTypeL ),

        ENTRY( "ControlControlTypeL", CEnhanMediaTestClass::ControlControlTypeL ),

        ENTRY( "DRMSetType", CEnhanMediaTestClass::DRMSetType ),

        ENTRY( "DRMGetType", CEnhanMediaTestClass::DRMGetType ),

        ENTRY( "DRMCommit", CEnhanMediaTestClass::DRMCommit ),

        ENTRY( "DRMGetAllowedODCount", CEnhanMediaTestClass::DRMGetAllowedOutputDeviceCount ),

        ENTRY( "DRMGetAllowedOutputDevice", CEnhanMediaTestClass::DRMGetAllowedOutputDevice ),

        ENTRY( "DRMAppendAllowedOutputDevice", CEnhanMediaTestClass::DRMAppendAllowedOutputDevice ),

        ENTRY( "DRMRemoveAllowedOutputDevice", CEnhanMediaTestClass::DRMRemoveAllowedOutputDevice ),

        ENTRY( "DRMReset", CEnhanMediaTestClass::DRMReset ),

        ENTRY( "DSGetSize", CEnhanMediaTestClass::DSGetSize ),

        ENTRY( "DSGetSize", CEnhanMediaTestClass::GeneralGen_StartProgDLL ),

        ENTRY( "Gen_StartProgDL",CEnhanMediaTestClass::GeneralGen_StartProgDLL ),

        ENTRY( "PDLSOpenL",CEnhanMediaTestClass::PDLSOpenL ),

        ENTRY( "PDLSGetCurFileSizeL",CEnhanMediaTestClass::PDLSGetCurFileSizeL ),

        ENTRY( "PDLSGetExpFileSizeL",CEnhanMediaTestClass::PDLSGetExpFileSizeL ),

        ENTRY( "PDLSGetDLStatusL",CEnhanMediaTestClass::PDLSGetDLStatusL ),

        ENTRY( "PDLSIsDLCompleteL",CEnhanMediaTestClass::PDLSIsDLCompleteL ),

        ENTRY( "PDLSGetPerDownloadedL",CEnhanMediaTestClass::PDLSGetPerDownloadedL ),

        ENTRY( "PDLSGetPerBufferedL",CEnhanMediaTestClass::PDLSGetPerBufferedL ),

        ENTRY( "PDLSGetDLRateL",CEnhanMediaTestClass::PDLSGetDLRateL ),

        ENTRY( "PDLSGetBitRateL",CEnhanMediaTestClass::PDLSGetBitRateL ),

        ENTRY( "PDLSResumeDownloadL",CEnhanMediaTestClass::PDLSResumeDownloadL ),

        ENTRY( "PDLSMoveFileL",CEnhanMediaTestClass::PDLSMoveFileL ),

        ENTRY( "PDLSCancelDownloadL",CEnhanMediaTestClass::PDLSCancelDownloadL ),

        ENTRY( "PDLSGetSize",CEnhanMediaTestClass::PDLSGetSize ),

        ENTRY( "AudioEffect_IsEnabled",CEnhanMediaTestClass::AudioEffectIsEnabled ),

        ENTRY( "AudioEffect_IsEnforced",CEnhanMediaTestClass::AudioEffectIsEnforced ),

        ENTRY( "AudioEffect_Uid",CEnhanMediaTestClass::AudioEffectUid ),

        ENTRY( "AudioEffect_HaveUpdateRights",CEnhanMediaTestClass::AudioEffectHaveUpdateRights ),

        ENTRY( "AudioEffect_Enforce",CEnhanMediaTestClass::AudioEffectEnforce ),

        ENTRY( "AudioEffect_Enable",CEnhanMediaTestClass::HandleAudioEffectEnableL ),

        ENTRY( "AudioEffect_Disable",CEnhanMediaTestClass::HandleAudioEffectDisableL ),

        ENTRY( "ER_DecayHFRatio",CEnhanMediaTestClass::HandleReverbDecayHFRatioL ),

        ENTRY( "ER_DecayHFRatioRange",CEnhanMediaTestClass::HandleReverbDecayHFRatioRangeL ),

        ENTRY( "ER_DecayTime",CEnhanMediaTestClass::HandleReverbDecayTimeL ),

        ENTRY( "ER_DecayTimeRange",CEnhanMediaTestClass::HandleReverbDecayTimeRangeL ),

        ENTRY( "ER_Density",CEnhanMediaTestClass::HandleReverbDensityL ),

        ENTRY( "ER_Diffusion",CEnhanMediaTestClass::HandleReverbDiffusionL ),

        ENTRY( "ER_ReflectionsDelay",CEnhanMediaTestClass::HandleReverbReflectionsDelayL ),

        ENTRY( "ER_ReflectionsDelayMax",CEnhanMediaTestClass::HandleReverbReflectionsDelayMaxL ),

        ENTRY( "ER_ReflectionsLevel",CEnhanMediaTestClass::HandleReverbReflectionsLevelL ),

        ENTRY( "ER_ReflectionLevelRange",CEnhanMediaTestClass::HandleReverbReflectionLevelRangeL ),

        ENTRY( "ER_ReverbDelay",CEnhanMediaTestClass::HandleReverbReverbDelayL ),

        ENTRY( "ER_ReverbDelayMax",CEnhanMediaTestClass::HandleReverbReverbDelayMaxL ),

        ENTRY( "ER_ReverbLevel",CEnhanMediaTestClass::HandleReverbReverbLevelL),

        ENTRY( "ER_ReverbLevelRange",CEnhanMediaTestClass::HandleReverbReverbLevelRangeL ),

        ENTRY( "ER_RoomHFLevel",CEnhanMediaTestClass::HandleReverbRoomHFLevelL ),

        ENTRY( "ER_RoomHFLevelRange",CEnhanMediaTestClass::HandleReverbRoomHFLevelRangeL ),

        ENTRY( "ER_RoomLevel",CEnhanMediaTestClass::HandleReverbRoomLevelL ),

        ENTRY( "ER_RoomLevelRange",CEnhanMediaTestClass::HandleReverbRoomLevelRangeL ),

        ENTRY( "ER_SetDecayHFRatio",CEnhanMediaTestClass::HandleReverbSetDecayHFRatioL ),

        ENTRY( "ER_SetDecayTime",CEnhanMediaTestClass::HandleReverbSetDecayTimeL ),

        ENTRY( "ER_SetDensity",CEnhanMediaTestClass::HandleReverbSetDensityL ),

        ENTRY( "ER_SetDiffusion",CEnhanMediaTestClass::HandleReverbSetDiffusionL ),

        ENTRY( "ER_SetReflectionsDelay",CEnhanMediaTestClass::HandleReverbSetReflectionsDelayL ),

        ENTRY( "ER_SetReflectionsLevel",CEnhanMediaTestClass::HandleReverbSetReflectionsLevelL ),

        ENTRY( "ER_SetReverbDelay",CEnhanMediaTestClass::HandleReverbSetReverbDelayL ),

        ENTRY( "ER_SetReverbLevel",CEnhanMediaTestClass::HandleReverbSetReverbLevelL ),

        ENTRY( "ER_SetRoomHFLevel",CEnhanMediaTestClass::HandleReverbSetRoomHFLevelL ),

        ENTRY( "ER_SetRoomLevel",CEnhanMediaTestClass::HandleReverbSetRoomLevelL ),

        ENTRY( "ER_DelayMax",CEnhanMediaTestClass::HandleReverbDelayMaxL ),

        ENTRY( "SW_IsContinuousLevelSupportedL",CEnhanMediaTestClass::HandleSWIsContinuousLevelSupportedL ),

        ENTRY( "SW_SetStereoWideningLevelL",CEnhanMediaTestClass::HandleSWSetStereoWideningLevelL ),

        ENTRY( "SW_StereoWideningLevelL",CEnhanMediaTestClass::HandleSWStereoWideningLevelL ),

        ENTRY( "RL_LevelRangeL",CEnhanMediaTestClass::HandleRLLevelRangeL ),

        ENTRY( "RL_SetRoomLevelL",CEnhanMediaTestClass::HandleRLSetRoomLevelL ),

        ENTRY( "RL_LevelL",CEnhanMediaTestClass::HandleRLLevelL ),

        ENTRY( "DA_DistanceAttenuationL",CEnhanMediaTestClass::HandleDADistanceAttenuationL ),

        ENTRY( "DA_RollOffFactorMaxL",CEnhanMediaTestClass::HandleDARollOffFactorMaxL ),

        ENTRY( "DA_RoomRollOffFactorMaxL",CEnhanMediaTestClass::HandleDARoomRollOffFactorMaxL ),

        ENTRY( "SL_LocationCartesianL",CEnhanMediaTestClass::HandleSLLocationCartesianL ),

        ENTRY( "SL_LocationSphericalL",CEnhanMediaTestClass::HandleSLLocationSphericalL ),

        ENTRY( "SL_SetLocationCartesianL",CEnhanMediaTestClass::HandleSLSetLocationCartesianL ),

        ENTRY( "SL_SetLocationSphericalL",CEnhanMediaTestClass::HandleSLSetLocationSphericalL ),

        ENTRY( "LO_OrientationL",CEnhanMediaTestClass::LO_OrientationL ),

        ENTRY( "LO_OrientationVectorsL",CEnhanMediaTestClass::LO_OrientationVectorsL ),

        ENTRY( "Control_Type",CEnhanMediaTestClass::HandleControlTypeL ),

        ENTRY( "Control_ControlType",CEnhanMediaTestClass::HandleControlControlTypeL ),

        ENTRY( "SD_SetFactorL",CEnhanMediaTestClass::HandleSDSetFactorL ),

        ENTRY( "SD_SetSphericalVelocityL",CEnhanMediaTestClass::HandleSDSetSphericalVelocityL ),

        ENTRY( "SD_SphericalVelocityL",CEnhanMediaTestClass::HandleSDSphericalVelocityL ),

        ENTRY( "SD_CartesianVelocityL",CEnhanMediaTestClass::HandleSDCartesianVelocityL ),

        ENTRY( "SD_FactorL",CEnhanMediaTestClass::HandleSDFactorL ),

        ENTRY( "SD_FactorMaxL",CEnhanMediaTestClass::HandleSDFactorMaxL ),

        ENTRY( "SD_SetCartesianVelocityL",CEnhanMediaTestClass::HandleSDSetCartesianVelocityL ),

		ENTRY( "AttachReverb",CEnhanMediaTestClass::AttachReverb ),

		ENTRY( "DetachReverb",CEnhanMediaTestClass::DetachReverb ),

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CEnhanMediaTestClass::EventName

// Return descriptor with the notification description

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

TPtrC CEnhanMediaTestClass::EventName( TInt aKey )

{

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

	static TText* const keywords[] =

		{

		(TText*)L"EEDBSOpen",

		(TText*)L"EEStreamPause",

		(TText*)L"EEDeleteBuffer",

		(TText*)L"EEWriteToStream",

		(TText*)L"EEDataBuffer",

		(TText*)L"EEStreamClose",

		(TText*)L"EEStreamAddEffect",

		(TText*)L"EEStreamOpen",

		(TText*)L"EEStreamPrime",

		(TText*)L"EEStreamStart",

		(TText*)L"EEPDLSOpen",

	};

	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;

		}

}

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

// CEnhanMediaTestClass::AddExpectedEvent

// Add an event to the expected events' list

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

void CEnhanMediaTestClass::AddExpectedEvent(TAEnhsExpectedEvent event, TInt ms)

{

	FTRACE(FPrint(_L("CEnhanMediaTestClass::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) );

			}

		}

}

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

// CEnhanMediaTestClass::RemoveExpectedEvent

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

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

TBool CEnhanMediaTestClass::RemoveExpectedEvent(TAEnhsExpectedEvent aEvent)

{

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

	TBool match = EFalse;

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

		{

		if (iExpectedEvents[i] == aEvent)

			{

			iExpectedEvents.Remove(i);

			match = ETrue;

			break;

			}

		}

	return match;

}

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

// CEnhanMediaTestClass::RemoveAllExpectedEvents

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

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

void CEnhanMediaTestClass::RemoveAllExpectedEvents()

{

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

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

	iExpectedEvents.Reset();

	//iOcurredEvents.Reset();

}

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

// CEnhanMediaTestClass::ProcessEvent

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

void CEnhanMediaTestClass::ProcessEvent(TAEnhsExpectedEvent aEvent, TInt aError)

{

	FTRACE(FPrint(_L("CEnhanMediaTestClass::ProcessExpectedEvent")));

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

		}

}

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

// CEnhanMediaTestClass::HandleTimeout

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

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

void CEnhanMediaTestClass::HandleTimeout(TInt aError)

{

	FTRACE(FPrint(_L("CEnhanMediaTestClass::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);

		}

}

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

// CEnhanMediaTestClass::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 CEnhanMediaTestClass::SetTimeout( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CEnhanMediaTestClass::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 CEnhanMediaTestClass::SetAllowedPanic( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CEnhanMediaTestClass::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;