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

//

// Custom interface definitions

#include <mmf/server/devsoundstandardcustominterfaces.h>

#include <mmf/plugin/mmfdevsoundcustominterface.hrh>

// Test system includes

#include "tsu_mmf_devsound_ciu_step.h"

#include "tsu_mmf_devsound_ciu_suite.h"

/**

CTestStepCustominterfaceUnificationUnit constructor

*/

CTestStepCustominterfaceUnificationUnit::CTestStepCustominterfaceUnificationUnit() : 

iScheduler(NULL)

	{

	iRes = &iSourceFileName;

	}

CTestStepCustominterfaceUnificationUnit::CTestStepCustominterfaceUnificationUnit(const TDesC& aTestName) : 

iScheduler(NULL)

	{

	iRes = &iSourceFileName;

	iTestStepName = aTestName;

	}

/**

CTestStepCustominterfaceUnificationUnit destructor

*/

CTestStepCustominterfaceUnificationUnit::~CTestStepCustominterfaceUnificationUnit()

	{

	if (iMMFDevSound)

		{

		delete iMMFDevSound;

		}

	if (iActiveListener)

		{

		delete iActiveListener;

		}

	if (iScheduler)

		{

		delete iScheduler;

		}

	}

/**

CTestStepCustominterfaceUnificationUnit accessor : set suite

 @param CTestSuiteCustominterfaceUnificationUnit*

		The test suite.

 */

void CTestStepCustominterfaceUnificationUnit::SetSuite(CTestSuiteCustomInterfaceUnificationUnit* aSuite)

	{ 

	iTestSuite = aSuite;

	}

/**

CTestStepCustominterfaceUnificationUnit accessor : get suite

 *

 * @return "CTestSuiteCustominterfaceUnificationUnit*"

 *		    The test suite.

 */

CTestSuiteCustomInterfaceUnificationUnit* CTestStepCustominterfaceUnificationUnit::TestSuite() const

	{

	return iTestSuite;

	}

/**

DoTestStepPreambleL is the preamble function for test steps

It creates an active scheduler and installs it. This is necessary

since we are multithreading and each test step runs in a separate thread.

@return TVerdict which is either EPass or Efail

The function can leave if there is insufficient memeory

*/

enum TVerdict CTestStepCustominterfaceUnificationUnit::DoTestStepPreambleL(void)

	{

	iScheduler = new(ELeave)CActiveScheduler;

	CleanupStack::PushL( iScheduler );

	CActiveScheduler::Install( iScheduler );

	CleanupStack::Pop();

	iActiveListener= new(ELeave)CActiveListener;

	INFO_PRINTF1(_L("Creating DevSound Object"));

	TRAPD(err, iMMFDevSound = CMMFDevSound::NewL());

	if (err)

		{

		return EInconclusive;

		}

	else

		{

		return EPass;

		}

	}

/**

The post amble step cleans up the allocated memory in the preamble

@return TVerdict EPass or EFail

@leave can leave due to insufficient memory

*/

enum TVerdict CTestStepCustominterfaceUnificationUnit::DoTestStepPostambleL(void)

	{

	INFO_PRINTF1(_L("Deleting DevSound Object"));

	if (iMMFDevSound)

		{

		delete iMMFDevSound;

		iMMFDevSound = NULL;

		}

	if (iActiveListener)

		{

		delete iActiveListener;

		iActiveListener = NULL;

		}

	if (iScheduler)

		{

		delete iScheduler;

		iScheduler = NULL;

		}

	return EPass;

	}

//

//		start Callback methods from MDevSoundObserver mixin

//

/**

InitializeComplete

@param aError

*/

void CTestStepCustominterfaceUnificationUnit::InitializeComplete (TInt aError)

	{

	INFO_PRINTF2(_L("DevSound called InitializeComplete with aError = %d"), aError);

	TRequestStatus* stat = &(iActiveListener->iStatus);

	User::RequestComplete(stat, aError);

	iCallbackArray[EInitComplete] ++;

	iCallbackError = aError;

	}

/**

ToneFinished

@param aError

*/

void CTestStepCustominterfaceUnificationUnit::ToneFinished (TInt aError)

	{

	INFO_PRINTF2(_L("DevSound called ToneFinished with aError = %d"), aError);

	TRequestStatus* stat = &(iActiveListener->iStatus);

	User::RequestComplete(stat, aError);

	iCallbackArray[EToneFinished] ++;

	iCallbackError = aError;

	}

/**

BufferToBeFilled

@param aBuffer

*/

void CTestStepCustominterfaceUnificationUnit::BufferToBeFilled (CMMFBuffer* aBuffer)

	{

	iBuffer = aBuffer;

	TRequestStatus* stat = &(iActiveListener->iStatus);

	if (aBuffer != NULL) 

		{

		User::RequestComplete(stat, KErrNone);

		iCallbackError = KErrNone;

		}

	else 

		{

		User::RequestComplete(stat, KErrNotFound);

		iCallbackError = KErrNotFound;

		}

	iCallbackArray[EBuffToFill] ++;

	}

/**

PlayError

@param aError

*/

void CTestStepCustominterfaceUnificationUnit::PlayError (TInt aError)

	{

	INFO_PRINTF2(_L("DevSound called PlayError with aError = %d"), aError);

	TRequestStatus* stat = &(iActiveListener->iStatus);

	User::RequestComplete (stat, aError);

	iCallbackError = aError;

	iCallbackArray[EPlayError] ++;

	}

/**

BufferToBeEmptied

@param aBuffer

*/

void CTestStepCustominterfaceUnificationUnit::BufferToBeEmptied (CMMFBuffer* aBuffer)

	{

	INFO_PRINTF1(_L("DevSound called BufferToBeEmptied"));

	iBuffer = aBuffer;

	TRequestStatus* stat = &(iActiveListener->iStatus);

	if (aBuffer != NULL)

		{

		User::RequestComplete(stat, KErrNone);

		iCallbackError = KErrNone;

		}

	else

		{

		User::RequestComplete(stat, KErrNotFound);

		iCallbackError = KErrNotFound;

		}

	iCallbackArray[EBuffToEmpty] ++;

	}

/**

RecordError

@param aError

*/

void CTestStepCustominterfaceUnificationUnit::RecordError (TInt aError)

	{

	INFO_PRINTF2(_L("DevSound called RecordError with aError = %d"), aError);

	TRequestStatus* stat = &(iActiveListener->iStatus);

	User::RequestComplete (stat, aError);

	iCallbackError = aError;

	iCallbackArray[ERecError] ++;

	}

/**

ConvertError

*/

void CTestStepCustominterfaceUnificationUnit::ConvertError (TInt /*aError*/)

	{

	}

/**

DeviceMessage

*/

void CTestStepCustominterfaceUnificationUnit::DeviceMessage(TUid, const TDesC8& /*aMsg*/)

	{

	}

//

//		start Test methods (called by test cases)

//

/**

TestInitialize

@param aMode

@return TVerdict

*/

TVerdict CTestStepCustominterfaceUnificationUnit::TestInitialize(TMMFState aMode)

	{

	iCallbackError = KErrNone;

	iExpectedValue = KErrNone;

	INFO_PRINTF1(_L("Initializing DevSound"));

	ResetCallbacks();

	iActiveListener->InitialiseActiveListener();

	// Initialize

	TRAPD(err, iMMFDevSound->InitializeL(*this, aMode));

	if (err)

		{

		WARN_PRINTF2 (_L("DevSound InitializeL left with error = %d"), err);

		return EInconclusive;

		}

	else

		{

		CActiveScheduler::Start();

		if (iCallbackError != iExpectedValue)

			{

			ERR_PRINTF3 (_L("DevSound InitializeComplete returned %d, expected %d"), iCallbackError, iExpectedValue);

			return EFail;

			}

		if (iCallbackArray[EInitComplete] != 1)

			{

			ERR_PRINTF2 (_L("DevSound InitializeComplete was called %d times, expected 1"), iCallbackArray[EInitComplete]);

			return EFail;

			}

		}

	return EPass;

	}

/**

TestInitialize

@param aHwDeviceUid

@param aMode

@return TVerdict

*/

TVerdict CTestStepCustominterfaceUnificationUnit::TestInitialize(TUid aHwDeviceUid, TMMFState aMode)

	{

	iCallbackError = KErrNone;

	iExpectedValue = KErrNone;

	INFO_PRINTF1(_L("Initializing DevSound"));

	ResetCallbacks();

	iActiveListener->InitialiseActiveListener();

	// Initialize

	TRAPD(err, iMMFDevSound->InitializeL(*this, aHwDeviceUid, aMode));

	if (err)

		{

		WARN_PRINTF2 (_L("DevSound InitializeL left with error = %d"), err);

		return EInconclusive;

		}

	else

		{

		CActiveScheduler::Start();

		if (iCallbackError != iExpectedValue)

			{

			ERR_PRINTF3 (_L("DevSound InitializeComplete returned %d, expected %d"), iCallbackError, iExpectedValue);

			return EFail;

			}

		if (iCallbackArray[EInitComplete] != 1)

			{

			ERR_PRINTF2 (_L("DevSound InitializeComplete was called %d times, expected 1"), iCallbackArray[EInitComplete]);

			return EFail;

			}

		}

	return EPass;

	}

/**

TestInitialize

@param aDataType

@param aMode

@return TVerdict

*/

TVerdict CTestStepCustominterfaceUnificationUnit::TestInitialize(TFourCC& aDataType, TMMFState aMode)

	{

	iCallbackError = KErrNone;

	iExpectedValue = KErrNone;

	INFO_PRINTF1(_L("Initializing DevSound"));

	ResetCallbacks();

	iActiveListener->InitialiseActiveListener();

	// Initialize

	TRAPD(err, iMMFDevSound->InitializeL(*this, aDataType, aMode));

	if (err)

		{

		WARN_PRINTF2 (_L("DevSound InitializeL left with error = %d"), err);

		return EInconclusive;

		}

	else

		{

		CActiveScheduler::Start();

		if (iCallbackError != iExpectedValue)

			{

			ERR_PRINTF3 (_L("DevSound InitializeComplete returned %d, expected %d"), iCallbackError, iExpectedValue);

			return EFail;

			}

		if (iCallbackArray[EInitComplete] != 1)

			{

			ERR_PRINTF2 (_L("DevSound InitializeComplete was called %d times, expected 1"), iCallbackArray[EInitComplete]);

			return EFail;

			}

		}

	return EPass;

	}

/**

 * Initialises dev sound for the given HwDevice uid and tries to instantiate the given interface.

 */

TAny* CTestStepCustominterfaceUnificationUnit::InitializeAndInstantiateInterfaceL(const TUid aHwDeviceUid, const TUid aInterfaceUid)

	{

	TAny* interface = NULL;

	iTestStepResult = TestInitialize(aHwDeviceUid, EMMFStatePlaying);

	if (iTestStepResult == EPass)

		{

		INFO_PRINTF1(_L("Successfully initialized DevSound"));

		interface = iMMFDevSound->CustomInterface(aInterfaceUid);

		}

	else

		{

		ERR_PRINTF1(_L("Failed to initialize DevSound"));

		}

	return interface;

	}

/**

 * Initialises dev sound for the given FourCC and tries to instantiate the given interface.

 */

TAny* CTestStepCustominterfaceUnificationUnit::InitializeAndInstantiateInterfaceL(TFourCC& aDataType, const TUid aInterfaceUid)

	{

	TAny* interface = NULL;

	iTestStepResult = TestInitialize(aDataType, EMMFStatePlaying);

	if (iTestStepResult == EPass)

		{

		INFO_PRINTF1(_L("Successfully initialized DevSound"));

		interface = iMMFDevSound->CustomInterface(aInterfaceUid);

		}

	else

		{

		ERR_PRINTF1(_L("Failed to initialize DevSound"));

		}

	return interface;

	}

/**

ReadFileL

@param aName

@param aData

*/

void CTestStepCustominterfaceUnificationUnit::ReadFileL(const TDesC &aName, TInt& aData)

	{

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iFile.Open(iFs, aName, EFileRead));

	TBuf8<4> data;

	User::LeaveIfError(iFile.Read(data));

	iFile.Close();

	iFs.Delete(aName);

	iFs.Close();

	TLex8 lex(data);

	lex.Val(aData);

	}

/**

WriteFileL

@param aName

@param aData

*/

void CTestStepCustominterfaceUnificationUnit::WriteFileL(const TDesC &aName, TInt aData)

	{

	User::LeaveIfError(iFs.Connect());

	iFs.MkDirAll(aName);

	User::LeaveIfError(iFile.Replace(iFs, aName, EFileWrite));

	TBuf8<4> data;

	data.Format(_L8("%d"), aData);

	User::LeaveIfError(iFile.Write(data));

	iFile.Close();

	iFs.Close();

	}

/**

ResetCallbacks

*/

void CTestStepCustominterfaceUnificationUnit::ResetCallbacks()

	{

	//Initialize callback array

	iCallbackArray.Reset();

	}