// 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:
// This program is designed the test of the TSU_MMFMIDICLNT.cpp.
// 
//

/**
 @file TSU_MMFMIDICLNT.cpp
*/

#include "TSU_MMFMIDICLNT.h"


/**
 * Timeout function
 */
void CTestMmfMidiClntStep::WaitWithTimeout(TRequestStatus& aStatus, TInt aNumberOfMicroSeconds)
	{
	TRequestStatus timerStatus;
	RTimer timer;
	timer.CreateLocal() ;
	timer.After(timerStatus,aNumberOfMicroSeconds);

	User::WaitForRequest(aStatus, timerStatus);
	if (timerStatus == KRequestPending)
		{
		timer.Cancel();
		User::WaitForRequest(timerStatus);
		}
	else
		{
		INFO_PRINTF1(_L("CTestMmfMidiClntStep wait timed out")) ;
		}
	timer.Close() ;
	}

/**
 * Time comparison utility function
 *
 * @param	"const TUint aActual"
 *			The actual timer value produced
 * @param	"const TUint aExpected"
 *			Expected timer value
 * @param	"const TUint aDeviation"
 *			Allowed deviation of the expected value
 *			from the actual value.
 * @return	"TBool"
 *			Did actual timed value fall within deviation limits
 */ 
TBool CTestMmfMidiClntStep::TimeComparison(const TUint aActual, const TUint aExpected, const TUint aDeviation)
	{
	// save unnessary conditions
	if(aActual == aExpected)
		return ETrue;	

	// Prevent unsigned wrapping errors 
	TUint difference;
	if(aActual > aExpected)
		difference = aActual - aExpected;
	else
		difference = aExpected - aActual;

	// compare
	if(difference < aDeviation)
		return ETrue;
	return EFalse;
	}

/**
 * Test Preamble routines.
 *
 * Creates our own Active Scheduler.
 *
 * @return	"TVerdict"
 *			Did Preamble complete.
 */
TVerdict CTestMmfMidiClntStep::DoTestStepPreambleL()
	{
	iActiveScheduler = new(ELeave) CActiveScheduler;
    //[ push the scheduler on the stack ]
	CleanupStack::PushL( iActiveScheduler );
	
	//[install the active scheduler ]
	CActiveScheduler::Install(iActiveScheduler);

	// Pop the element from the stack
	CleanupStack::Pop();

	return EPass;
	}

/**
 * Test Postamble routines.
 *
 * Destroys our Active Scheduler.
 *
 * @return	"TVerdict"
 *			Did Postamble complete.
 */
TVerdict CTestMmfMidiClntStep::DoTestStepPostambleL()
	{
	delete iActiveScheduler;
	iActiveScheduler = NULL;
	
	delete iScreen;
	delete iWindow;
	iWs.Close();
	

	return EPass;
	}

/**
 * CTestMMFVCLNTStep Implementation
 */
CTestMmfMidiClntStep::CTestMmfMidiClntStep(const TDesC& aTestName, const TTestStepType aTestType)
	:CTestStep(),
	 iActiveScheduler( NULL )
	{
	// store the name of this test step
	// this is the name that is used by the script file
	// Each test step initialises it's own name
	iTestStepName = aTestName;
	iTestType = aTestType;
	}

CTestMmfMidiClntStep::CTestMmfMidiClntStep()
	:iActiveScheduler( NULL )
	// for test step that sets its own name
	{
	iTestType = ETestValid;
	}

CTestMmfMidiClntStep::~CTestMmfMidiClntStep()
	{
	}

/*void CTestMmfMidiClntStep::Close()
	{
	delete iScreen;
	delete iWindow;
	iWs.Close();
	}*/

/**
 * DoTestStepL : same as CTestMidiClientOpenFile::DoTestStepL() but with no file opening
 * routines.
 *
 * Generally, test steps should NOT override this, but put their processing in DoTestL()
 *
 */
TVerdict CTestMmfMidiClntStep::DoTestStepL()
	{
	__MM_HEAP_MARK;
	CMidiClientUtility* player = CMidiClientUtility::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
	if (!player)
		{
		ERR_PRINTF1(_L("Could not create a CMidiClientUtility"));
		return EInconclusive;
		}
	
	CleanupStack::PushL(player);
 
	TMMFMessageDestinationPckg dummyPckg;
	TInt dummyFunc = 0;		//EDevMidiOff;
	TBuf8<8> dummyBuff;
	player->CustomCommandSyncL(dummyPckg, dummyFunc, dummyBuff, dummyBuff, dummyBuff);

	TVerdict ret = DoTestL(player);
		
	INFO_PRINTF1(_L("CMidiClientUtility: Destroying"));
	CleanupStack::PopAndDestroy(player);

	if(iError != KErrNone)
		ERR_PRINTF2( _L("CMidiClientUtility failed with error %d"),iError );
	
	__MM_HEAP_MARKEND;
	return	ret;
	}

TVerdict CTestMmfMidiClntStep::DoTestL(CMidiClientUtility* /*aMidi*/)
	{
	return EPass;
	}

void CTestMmfMidiClntStep::InitWservL()
	{
	TInt err = iWs.Connect();
	if (err != KErrNone)
		{
		// Access violation if ws is null
		INFO_PRINTF1(_L("Cannot test, no window server available"));
		User::Leave(err);
		}

	iScreen = new (ELeave) CWsScreenDevice(iWs); // make device for this session
	User::LeaveIfError(iScreen->Construct()); // and complete its construction

	RWindowGroup rootWindow = RWindowGroup(iWs);
	User::LeaveIfError(rootWindow.Construct((TUint32)this, ETrue));

	iWindow = new(ELeave) RWindow(iWs);
	User::LeaveIfError(((RWindow*)iWindow)->Construct(rootWindow,((TUint32)(this)) + 1));
	iWindow->SetExtent(TPoint(0,0), TSize(100,100));
	iWindow->SetVisible(ETrue);
	iWindow->Activate();
	iWs.Flush();
	}

// MMidiClientUtilityObserver

void CTestMmfMidiClntStep::MmcuoStateChanged(TMidiState aOldState, TMidiState aNewState, 
											  const TTimeIntervalMicroSeconds& /* aTime */, TInt aError)
	{
	INFO_PRINTF3(_L("MmcuoStateChanged callback, oldState = %d, newState = %d"), aOldState, aNewState);

	iError = aError;
	iCurrentState = aNewState;
	CActiveScheduler::Stop(); // check if asynchronous
	}

void CTestMmfMidiClntStep::MmcuoTempoChanged(TInt /* aMicroBeatsPerMinute */)
	{
	INFO_PRINTF1(_L("MmcuoTempoChanged callback"));
	}

void CTestMmfMidiClntStep::MmcuoVolumeChanged(TInt /*aChannel*/,TReal32 /*aVolumeInDecibels*/)
	{
	INFO_PRINTF1(_L("MmcuoVolumeChanged callback"));
	}

void CTestMmfMidiClntStep::MmcuoMuteChanged(TInt /* aChannel */, TBool /* aMuted */)
	{
	INFO_PRINTF1(_L("MmcuoMuteChanged callback"));
	}

void CTestMmfMidiClntStep::MmcuoSyncUpdate(const TTimeIntervalMicroSeconds& /* aMicroSeconds */, TInt64 /* aMicroBeats */)
	{
	INFO_PRINTF1(_L("MmcuoSyncUpdate callback"));
	}

void CTestMmfMidiClntStep::MmcuoMetaDataEntryFound(const TInt /*aMetaDataEntryId*/,const TTimeIntervalMicroSeconds& /*aPosition*/)
	{
	INFO_PRINTF1(_L("MmcuoSmfMetaDataEntryFound callback"));
	}

void CTestMmfMidiClntStep::MmcuoMipMessageReceived(const RArray<TMipMessageEntry>& /* aEntry */)
	{
	INFO_PRINTF1(_L("MmcuoMipMessageReceived callback"));
	}

void CTestMmfMidiClntStep::MmcuoPolyphonyChanged(TInt /* aNewPolyphony */)
	{
	INFO_PRINTF1(_L("MmcuoPolyphonyChanged callback"));
	}

void CTestMmfMidiClntStep::MmcuoInstrumentChanged(TInt /* aChannel */, TInt /* aBankId */, TInt /* aInstrumentId */)
	{
	INFO_PRINTF1(_L("MmcuoInstrumentChanged callback"));
	}