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

// TSIMmfCtlfrm.cpp

// 

//

// EPOC includes

#include <e32base.h>

// Test system includes

#include <testframework.h>

#include "TSI_MmfCtlfrm.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/common/mmfstandardcustomcommands.h>

#include <mmf/plugin/mmfcontrollerimplementationuids.hrh>

const TUid KTestControllerUid = {KTSIMmfControllerUid};

const TUid KTestDataSourceUid = {KTSIMmfDataSourceUid};

const TUid KTestDataSinkUid   = {KTSIMmfDataSinkUid};

// audio controllers, from mmfControllerImplementationUIDs.hrh

const TUid KTestAudioControllerUid = {KMmfUidControllerAudio};

// pause length for repeat calls to GetPosition

// NB this can't be a const - global uninitialised data in ARM

#define KGetPositionIntervalLength 500000

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

// RTestMmfCtlfrmI0001

//

// Load each controller plugin into its own thread

//

// REQ172.3.1

RTestMmfCtlfrmI0001* RTestMmfCtlfrmI0001::NewL()

	{

	RTestMmfCtlfrmI0001* self = new(ELeave) RTestMmfCtlfrmI0001;

	return self;

	}

RTestMmfCtlfrmI0001::RTestMmfCtlfrmI0001()

	{

	iTestStepName = _L("MM-MMF-CTLFRM-I-0001");

	}

TVerdict RTestMmfCtlfrmI0001::DoTestStepL()

	{

	TMMFPrioritySettings settings;

	TInt error = KErrNone;

	RMMFController controller, controller2;

	settings.iPriority = ETSIMmfPriorityLow;

	settings.iPref = EMdaPriorityPreferenceTime;

	settings.iState = EMMFStateIdle;

	// Open a controller

	error = controller.Open(KTestControllerUid, settings);

	if (error)

		{

		ERR_PRINTF2(_L("controller1 failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	// Open another controller 

	// (it is valid for this test to open two instances of the same controller)

	error = controller2.Open(KTestControllerUid, settings);

		if (error)

		{

		ERR_PRINTF2(_L("controller2 failed to open, error %d"), error);

		controller.Close();

		return iTestStepResult = EInconclusive;

		}

	TBuf8<KTextBufLen> memFunctionText;

	TUid uid = {KTSIMmfControllerUid};

	TMMFMessageDestination handleInfo(uid);

	TMMFMessageDestinationPckg messageDest(handleInfo);

	TBuf<KTextBufLen> memFunctionText16;

	TBuf<KTextBufLen> memFunction2Text16;

	// get thread addresses

	error = controller.CustomCommandSync(messageDest, KThreadIdFunction, KNullDesC8, KNullDesC8, memFunctionText);

	if (error)

		{

		ERR_PRINTF2(_L("controller1 CustomCommandSync failed with error %d"), error);

		controller2.Close();

		controller.Close();

		return iTestStepResult = EInconclusive;

		}

	// memFunctionText comes back as hex string

	memFunctionText16.SetMax();

	memFunctionText16.Fill(0x0);

	memFunctionText16.Copy(memFunctionText);

	INFO_PRINTF2(_L("Controller1 thread ID : 0x%S"), &memFunctionText16);

	error = controller2.CustomCommandSync(messageDest, KThreadIdFunction, KNullDesC8, KNullDesC8, memFunctionText);

	if (error)

		{

		ERR_PRINTF2(_L("controller2 CustomCommandSync failed with error %d"), error);

		controller2.Close();

		controller.Close();

		return iTestStepResult = EInconclusive;

		}

	// memFunctionText comes back as hex string

	memFunction2Text16.SetMax();

	memFunction2Text16.Fill(0x0);

	memFunction2Text16.Copy(memFunctionText);

	INFO_PRINTF2(_L("Controller2 thread ID : 0x%S"), &memFunction2Text16);

	// compare thread addresses; they must not match

	if(!memFunctionText16.Compare(memFunction2Text16))

		{

		ERR_PRINTF1(_L("Error - thread IDs match"));

		controller2.Close();

		controller.Close();

		return iTestStepResult = EFail;

		}

	controller2.Close();

	controller.Close();

	return iTestStepResult = EPass;

	}

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

// RTestMmfCtlfrmI0002

//

// Give each controller thread its own heap

//

// REQ172.3.2

RTestMmfCtlfrmI0002* RTestMmfCtlfrmI0002::NewL()

	{

	RTestMmfCtlfrmI0002* self = new(ELeave) RTestMmfCtlfrmI0002;

	return self;

	}

RTestMmfCtlfrmI0002::RTestMmfCtlfrmI0002()

	{

	iTestStepName = _L("MM-MMF-CTLFRM-I-0002");

	}

TVerdict RTestMmfCtlfrmI0002::DoTestStepL()

	{

	TMMFPrioritySettings settings;

	TInt error = KErrNone;

	RMMFController controller, controller2;

	settings.iPriority = ETSIMmfPriorityLow;

	settings.iPref = EMdaPriorityPreferenceTime;

	settings.iState = EMMFStateIdle;

	// Open a controller

	error = controller.Open(KTestControllerUid, settings);

	if (error)

		{

		ERR_PRINTF2(_L("controller1 failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	// Open another controller 

	// (it is valid for this test to open two instances of the same controller)

	error = controller2.Open(KTestControllerUid, settings);

		if (error)

		{

		ERR_PRINTF2(_L("controller2 failed to open, error %d"), error);

		controller.Close();

		return iTestStepResult = EInconclusive;

		}

	TBuf8<KTextBufLen> memFunctionText;

	TUid uid = {KTSIMmfControllerUid};

	TMMFMessageDestination handleInfo(uid);

	TMMFMessageDestinationPckg messageDest(handleInfo);

	TBuf<KTextBufLen> memFunctionText16;

	TBuf<KTextBufLen> memFunction2Text16;

	// get heap addresses

	error = controller.CustomCommandSync(messageDest, KHeapAddressFunction, KNullDesC8, KNullDesC8, memFunctionText);

	if (error)

		{

		ERR_PRINTF2(_L("controller1 CustomCommandSync failed with error %d"), error);

		controller2.Close();

		controller.Close();

		return iTestStepResult = EInconclusive;

		}

	// memFunctionText comes back as hex string

	memFunctionText16.SetMax();

	memFunctionText16.Fill(0x0);

	memFunctionText16.Copy(memFunctionText);

	INFO_PRINTF2(_L("Controller1 heap address : 0x%S"), &memFunctionText16);

	error = controller2.CustomCommandSync(messageDest, KHeapAddressFunction, KNullDesC8, KNullDesC8, memFunctionText);

	if (error)

		{

		ERR_PRINTF2(_L("controller2 CustomCommandSync failed with error %d"), error);

		controller2.Close();

		controller.Close();

		return iTestStepResult = EInconclusive;

		}

	// memFunctionText comes back as hex string

	memFunction2Text16.SetMax();

	memFunction2Text16.Fill(0x0);

	memFunction2Text16.Copy(memFunctionText);

	INFO_PRINTF2(_L("Controller2 heap address : 0x%S"), &memFunction2Text16);

	// compare heap addresses; they must not match

	if(!memFunctionText16.Compare(memFunction2Text16))

		{

		ERR_PRINTF1(_L("Error - heap addresses match"));

		controller2.Close();

		controller.Close();

		return iTestStepResult = EFail;

		}

	// cleanup

	controller2.Close();

	controller.Close();

	return iTestStepResult = EPass;

	}

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

// RTestMmfCtlfrmI0003

//

// Provide inter-thread access from client to controller plugin

//

// REQ172.3.3

RTestMmfCtlfrmI0003* RTestMmfCtlfrmI0003::NewL()

	{

	RTestMmfCtlfrmI0003* self = new(ELeave) RTestMmfCtlfrmI0003;

	return self;

	}

RTestMmfCtlfrmI0003::RTestMmfCtlfrmI0003()

	{

	iTestStepName = _L("MM-MMF-CTLFRM-I-0003");

	}

TVerdict RTestMmfCtlfrmI0003::DoTestStepL()

	{

	TMMFPrioritySettings settings;

	TInt error = KErrNone;

	RMMFController controller;

	settings.iPriority = ETSIMmfPriorityLow;

	settings.iPref = EMdaPriorityPreferenceTime;

	settings.iState = EMMFStateIdle;

	// Open a controller

	error = controller.Open(KTestControllerUid, settings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	TUid uid = {KTSIMmfControllerUid};

	TMMFMessageDestination handleInfo(uid);

	TMMFMessageDestinationPckg messageDest(handleInfo);

	// send dummy messages, to verify that return values are correct

	error = controller.CustomCommandSync(messageDest, KDummyFunc1, KNullDesC8, KNullDesC8);

	if(error == KDummyFunc1Return)

		error = KErrNone;

	else

		{

		ERR_PRINTF2(_L("CustomCommandSync KDummyFunc1 returned unexpected value %d"), error);

		controller.Close();

		return iTestStepResult = EFail;

		}

	error = controller.CustomCommandSync(messageDest, KDummyFunc2, KNullDesC8, KNullDesC8);

	if(error == KDummyFunc2Return)

		error = KErrNone;

	else

		{

		ERR_PRINTF2(_L("CustomCommandSync KDummyFunc2 returned unexpected value %d"), error);

		controller.Close();

		return iTestStepResult = EFail;

		}

	INFO_PRINTF1(_L("CustomCommandSync returned expected values"));

	// cleanup

	controller.Close();

	return iTestStepResult = EPass;

	}

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

// RTestMmfCtlfrmI0102

//

// Load a controller plugin by UID

//

// REQ172.5.1

RTestMmfCtlfrmI0102* RTestMmfCtlfrmI0102::NewL()

	{

	RTestMmfCtlfrmI0102* self = new(ELeave) RTestMmfCtlfrmI0102;

	return self;

	}

RTestMmfCtlfrmI0102::RTestMmfCtlfrmI0102()

	{

	iTestStepName = _L("MM-MMF-CTLFRM-I-0102");

	}

TVerdict RTestMmfCtlfrmI0102::DoTestStepL()

	{

	TMMFPrioritySettings settings;

	TInt error = KErrNone;

	RMMFController controller;

	settings.iPriority = ETSIMmfPriorityLow;

	settings.iPref = EMdaPriorityPreferenceTime;

	settings.iState = EMMFStateIdle;

	// Open a controller

	error = controller.Open(KTestControllerUid, settings);

	if (error)

		{

		ERR_PRINTF2(_L("controller failed to open, error %d"), error);

		return iTestStepResult = EInconclusive;

		}

	TUid uid = {KTSIMmfControllerUid};

	TMMFMessageDestination handleInfo(uid);

	TMMFMessageDestinationPckg messageDest(handleInfo);

	TBuf8<KTextBufLen> memFunctionText;

	TBuf<KTextBufLen> memFunctionText16;

	// verify that we've loaded the plugin requested

	// the return we expect to be the string KPluginUIDSubstitute

	// we'd like to use the UID itself, but it's private in CMMFController, so this will have to do

	error = controller.CustomCommandSync(messageDest, KPluginUidFunction, KNullDesC8, KNullDesC8, memFunctionText);

	if(error)

		{

		// could be we haven't got this function in the loaded plugin 

		ERR_PRINTF2(_L("CustomCommandSync KPluginUidFunction failed, error code %d"), error);

		controller.Close();

		return iTestStepResult = EFail;

		}

	// this string must match that specified in TSIMmfController.cpp

	_LIT8(KPluginUIDSubstitute, "TSI_MMFController");

	// memFunctionText comes back as hex string

	memFunctionText16.SetMax();

	memFunctionText16.Fill(0x0);

	memFunctionText16.Copy(memFunctionText);

	INFO_PRINTF2(_L("Controller returned : %S"), &memFunctionText16);

	// check return string is expected value

	if(memFunctionText.Compare(KPluginUIDSubstitute))	// returns 0 if equal

		{

		ERR_PRINTF1(_L("Error - string does not match expected value"));

		controller.Close();

		return iTestStepResult = EFail;

		}

	// cleanup

	controller.Close();

	return iTestStepResult = EPass;

	}

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

// RTestMmfCtlfrmI0105

//

// Load a controller plugin by filename / extension

//

// REQ172.5.3, REQ172.5.4

RTestMmfCtlfrmI0105* RTestMmfCtlfrmI0105::NewL()

	{

	RTestMmfCtlfrmI0105* self = new(ELeave) RTestMmfCtlfrmI0105;

	return self;

	}

RTestMmfCtlfrmI0105::RTestMmfCtlfrmI0105()

	{

	iTestStepName = _L("MM-MMF-CTLFRM-I-0105");

	}

TVerdict RTestMmfCtlfrmI0105::DoTestStepL()

	{

	// open controller by filename / extension

	INFO_PRINTF1(_L("open controller by filename / extension"));

	TMMFPrioritySettings settings;

	TInt error = KErrNone;

	RMMFController controller;

	settings.iPriority = ETSIMmfPriorityLow;

	settings.iPref = EMdaPriorityPreferenceTime;

	settings.iState = EMMFStateIdle;

	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

	// Set the format match data

	fSelect->SetMatchToFileNameL(_L("test.wav"));

	// Set the controller plugin play format match data

	cSelect->SetRequiredPlayFormatSupportL(*fSelect); 

	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

	CleanupResetAndDestroyPushL(controllers);

	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

	TInt numControllers = controllers.Count();

	if(!numControllers)

		{

		ERR_PRINTF1(_L("Could not find any controllers"));

		CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

		return iTestStepResult = EFail;

		}

	INFO_PRINTF2(_L("Found %d controllers"), numControllers);

	CMMFControllerImplementationInformation* implInfo = controllers[0];

	TUid theControllerImplUid = implInfo->Uid();

	error = controller.Open(theControllerImplUid, settings); // instantiate the controller

	if(error)

		{

		ERR_PRINTF2(_L("Could not open controller, error %d"), error);

		CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

		return iTestStepResult = EFail;

		}

	INFO_PRINTF2(_L("Opened controller with UID 0x%8x"), theControllerImplUid);

	if(theControllerImplUid != KTestAudioControllerUid)	// check it's the right one

		{

		ERR_PRINTF1(_L("Error: this is not the Audio Controller"));

		return iTestStepResult = EFail;

		}

	INFO_PRINTF1(_L("This is the Audio Controller"));

	controller.Close();

	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

	return iTestStepResult = EPass;

	}

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

// RTestMmfCtlfrmI0106

//

// Load a controller plugin from a preferred supplier by filename / extension

//

// REQ172.5.3, REQ172.5.4

RTestMmfCtlfrmI0106* RTestMmfCtlfrmI0106::NewL()

	{

	RTestMmfCtlfrmI0106* self = new(ELeave) RTestMmfCtlfrmI0106;

	return self;

	}

RTestMmfCtlfrmI0106::RTestMmfCtlfrmI0106()

	{

	iTestStepName = _L("MM-MMF-CTLFRM-I-0106");

	}

TVerdict RTestMmfCtlfrmI0106::DoTestStepL()

	{

	// open controller by filename / extension and preferred supplier

	INFO_PRINTF1(_L("open controller by filename / extension and preferred supplier"));

	TMMFPrioritySettings settings;

	TInt error = KErrNone;

	RMMFController controller;

	settings.iPriority = ETSIMmfPriorityLow;

	settings.iPref = EMdaPriorityPreferenceTime;

	settings.iState = EMMFStateIdle;

	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

	// Set the format match data

	fSelect->SetMatchToFileNameL(_L("test.wav"));

	// Set the controller plugin play format match data

	cSelect->SetRequiredPlayFormatSupportL(*fSelect); 

	// Set for only those plugins supplied by "Symbian"

	_LIT(KPrefSupplierSymbian, "Symbian");

	cSelect->SetPreferredSupplierL(KPrefSupplierSymbian, CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

	CleanupResetAndDestroyPushL(controllers);

	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

	TInt numControllers = controllers.Count();

	if(!numControllers)

		{

		ERR_PRINTF1(_L("Could not find any controllers"));

		CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

		return iTestStepResult = EFail;

		}

	INFO_PRINTF2(_L("Found %d controllers"), numControllers);

	CMMFControllerImplementationInformation* implInfo = controllers[0];

	TUid theControllerImplUid = implInfo->Uid();

	error = controller.Open(theControllerImplUid, settings); // instantiate the controller

	if(error)

		{

		ERR_PRINTF2(_L("Could not open controller, error %d"), error);

		CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

		return iTestStepResult = EFail;