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

#include <mmf/common/mmfcontroller.h>
#include <mmf/server/mmffile.h>
#include <mmf/common/mmfdrmcustomcommands.h>
#include <mmf/common/mmfstandardcustomcommands.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <mmf/common/mmfcontrollerextendeddata.h>
#include <mmf/common/mmfcustomcommandparsermanager.h>
#endif

inline void ExtendedDataTlsCleanup(TAny* /*aPtr*/)
	{
	delete static_cast<CMMFControllerExtendedData*>(Dll::Tls());
	Dll::SetTls(NULL);
	}

CMMFController* CMMFController::NewL(TUid aControllerUid, MAsyncEventHandler& aEventHandler, TThreadId aClientTid)
	{
	Dll::SetTls(CMMFController::CreateExtendedDataL(aClientTid));
	CleanupStack::PushL(TCleanupItem(&ExtendedDataTlsCleanup, NULL));
	CMMFController* s = REINTERPRET_CAST(CMMFController*,REComSession::CreateImplementationL(aControllerUid,_FOFF(CMMFController,iDtor_ID_Key)));
	CleanupStack::PushL(s);
	s->ConstructL(aEventHandler, aClientTid);
	CleanupStack::Pop(s);
	CleanupStack::PopAndDestroy();	// TCleanupItem(ExtendedDataTlsCleanup)
	return s;
	}

void CMMFController::ConstructL(MAsyncEventHandler& aEventHandler, TThreadId aClientTid)
	{
	iAsyncEventHandler = &aEventHandler;
	
	// If extended data hasn't been initialized, GetExtendedDataL will initialize it and
	// add it into iMMFObjectContainer
#ifdef _DEBUG
	CMMFControllerExtendedData* extendData =
#endif
		GetExtendedDataL();
#ifdef _DEBUG
	ASSERT(extendData->ClientThreadId() == aClientTid);
#else
	(void)aClientTid;	// remove compilation error
#endif
	}

EXPORT_C CMMFController::~CMMFController()
	{
	delete iCustomCommandParserManager;
	delete iMMFObjectContainer;
	delete iMetaDataBuffer;
	REComSession::DestroyedImplementation(iDtor_ID_Key);
	}

EXPORT_C TInt CMMFController::DoSendEventToClient(const TMMFEvent& aEvent)
	{
	return iAsyncEventHandler->SendEventToClient(aEvent);
	}

EXPORT_C CMMFObjectContainer& CMMFController::MMFObjectContainerL()
	{
	// Construct iMMFObjectContainer if we haven't already.
	if (!iMMFObjectContainer)
		iMMFObjectContainer = new(ELeave) CMMFObjectContainer;
	return *iMMFObjectContainer;
	}

EXPORT_C void CMMFController::AddCustomCommandParserL(CMMFCustomCommandParserBase& aParser)
	{
	// Construct iCustomCommandParserManager if we haven't already
	if (!iCustomCommandParserManager)
		iCustomCommandParserManager = CMMFCustomCommandParserManager::NewL();
	iCustomCommandParserManager->AddCustomCommandParserL(aParser);
	}


EXPORT_C void CMMFController::HandleRequestL(TMMFMessage& aMessage)
	{
	// If the message has the constant controller destination handle, pass the message to
	// the controller plugin to handle.
	// Otherwise, the message must be for one of the MMFObjects.
	if (aMessage.Destination().DestinationHandle() == KMMFObjectHandleController)
		{
		// If the message has an interface ID for this controller, handle it here.
		// Otherwise, pass it to the controller plugin to handle as a custom command.
		if (aMessage.Destination().InterfaceId() == KUidInterfaceMMFController)
			{
			TBool complete = ETrue;
			switch (aMessage.Function())
				{
			case EMMFControllerAddDataSource:
				complete = DoAddDataSourceL(aMessage);
				break;
			case EMMFControllerAddDataSink:
				complete = DoAddDataSinkL(aMessage);
				break;
			case EMMFControllerRemoveDataSource:
				complete = DoRemoveDataSourceL(aMessage);
				break;
			case EMMFControllerRemoveDataSink:
				complete = DoRemoveDataSinkL(aMessage);
				break;
			case EMMFControllerReset:
				complete = DoResetL(aMessage);
				break;
			case EMMFControllerPrime:
				complete = DoPrimeL(aMessage);
				break;
			case EMMFControllerPlay:
				complete = DoPlayL(aMessage);
				break;
			case EMMFControllerPause:
				complete = DoPauseL(aMessage);
				break;
			case EMMFControllerStop:
				complete = DoStopL(aMessage);
				break;
			case EMMFControllerGetPosition:
				complete = DoGetPositionL(aMessage);
				break;
			case EMMFControllerSetPosition:
				complete = DoSetPositionL(aMessage);
				break;
			case EMMFControllerGetDuration:
				complete = DoGetDurationL(aMessage);
				break;
			case EMMFControllerGetNumberOfMetaDataEntries:
				complete = DoGetNumberOfMetaDataEntriesL(aMessage);
				break;
			case EMMFControllerGetSizeOfMetaDataEntry:
				complete = DoGetSizeOfMetaDataEntryL(aMessage);
				break;
			case EMMFControllerGetMetaDataEntry:
				complete = DoGetMetaDataEntryL(aMessage);
				break;
			case EMMFControllerSetPrioritySettings:
				complete = DoSetPrioritySettingsL(aMessage);
				break;
			case EMMFControllerCancelAddDataSource:
				complete = ETrue;//Nothing to cancel since AddDataSource is synchronous server-side
				break;
			case EMMFControllerCancelAddDataSink:
				complete = ETrue;//Nothing to cancel since AddDataSink is synchronous server-side
				break;
			case EMMFControllerAddFileHandleDataSource:
				complete = DoAddFileHandleDataSourceL(aMessage);
				break;
			case EMMFControllerAddFileHandleDataSink:
				complete = DoAddFileHandleDataSinkL(aMessage);
				break;
			case EMMFControllerSourceSinkInitDataPreload:
				complete = DoPreloadSourceSinkInitDataL(aMessage);
				break;
			case EMMFControllerAddFileHandleDataSourceWithInitData:
				complete = DoAddFileHandleDataSourceWithInitDataL(aMessage);
				break;
			case EMMFControllerAddFileHandleDataSinkWithInitData:
				complete = DoAddFileHandleDataSinkWithInitDataL(aMessage);
				break;
			default:
				User::Leave(KErrNotSupported);
				break;
				}
			if (complete)
				aMessage.Complete(KErrNone);
			}
		else
			{
			// Must be a custom command
			DoCustomCommand(aMessage);
			}
		}
	else
		{
		// Message for one of the MMF Objects
		CMMFObject* object = NULL;
		User::LeaveIfError(MMFObjectContainerL().FindMMFObject(aMessage.Destination(), object));
		object->HandleRequest(aMessage);
		}

	}

TBool CMMFController::DoAddDataSourceL(TMMFMessage& aMessage)
	{
	// Get the UID of the source from the client
	TMMFUidPckg uidPckg;
	aMessage.ReadData1FromClientL(uidPckg);

	// Get the size of the init data and create a buffer to hold it
	TInt desLength = aMessage.SizeOfData2FromClient();
	// Leaving here in order to prevent a panic in the NewLC if the value is negative
	User::LeaveIfError(desLength); 
	HBufC8* buf = HBufC8::NewLC(desLength);
	TPtr8 ptr = buf->Des();
	aMessage.ReadData2FromClientL(ptr);

	// Create the source
	MDataSource* source = MDataSource::NewSourceL(uidPckg(), *buf);
	CleanupStack::PopAndDestroy(buf);//buf
	AddMDataSourceAndRepondClientL(source, aMessage);
	
	return ETrue;
	}
	
	
TBool CMMFController::DoAddDataSinkL(TMMFMessage& aMessage)
	{
	// Get the UID of the sink from the client
	TMMFUidPckg uidPckg;
	aMessage.ReadData1FromClientL(uidPckg);

	// Get the size of the init data and create a buffer to hold it
	TInt desLength = aMessage.SizeOfData2FromClient();
	// Leaving here in order to prevent a panic in the NewLC if the value is negative
	User::LeaveIfError(desLength);
	HBufC8* buf = HBufC8::NewLC(desLength);
	TPtr8 ptr = buf->Des();
	aMessage.ReadData2FromClientL(ptr);

	// Create the sink
	MDataSink* sink = MDataSink::NewSinkL(uidPckg(), *buf);
	CleanupStack::PopAndDestroy(buf);//buf
	AddMDataSinkAndRepondClientL(sink, aMessage);
	
	return ETrue;
	}
	
TBool CMMFController::DoRemoveDataSourceL(TMMFMessage& aMessage)
	{
	TMMFMessageDestinationPckg handleInfo;
	aMessage.ReadData1FromClientL(handleInfo);
	
	// Find the correct source
	CMMFObject* object = NULL;
	CMMFDataSourceHolder* holder = NULL;
	User::LeaveIfError(MMFObjectContainerL().FindMMFObject(handleInfo(), object));
	// Cast the object found if possible..
	if (object->Handle().InterfaceId() == KUidInterfaceMMFDataSourceHolder)
		holder = STATIC_CAST(CMMFDataSourceHolder*, object);
	else
		User::Leave(KErrBadHandle);

	// Try to remove the data source from the plugin
	RemoveDataSourceL(holder->DataSource());

	// If we're here, the removal worked so remove the source from the object array and delete it
	MMFObjectContainerL().RemoveAndDestroyMMFObject(*holder);
	return ETrue;
	}

TBool CMMFController::DoRemoveDataSinkL(TMMFMessage& aMessage)
	{
	TMMFMessageDestinationPckg handleInfo;
	aMessage.ReadData1FromClientL(handleInfo);
	
	// Find the correct source
	CMMFObject* object = NULL;
	CMMFDataSinkHolder* holder = NULL;
	User::LeaveIfError(MMFObjectContainerL().FindMMFObject(handleInfo(), object));
	// Cast the object found if possible..
	if (object->Handle().InterfaceId() == KUidInterfaceMMFDataSinkHolder)
		holder = STATIC_CAST(CMMFDataSinkHolder*, object);
	else
		User::Leave(KErrBadHandle);

	// Try to remove the data sink from the plugin
	RemoveDataSinkL(holder->DataSink());

	// If we're here, the removal worked so remove the source from the object array and delete it
	MMFObjectContainerL().RemoveAndDestroyMMFObject(*holder);
	return ETrue;
	}

TBool CMMFController::DoResetL(TMMFMessage& /*aMessage*/)
	{
	ResetL();
	// Controller extended data must be kept until the death of controller
	const RPointerArray<CMMFObject>& objects = iMMFObjectContainer->MMFObjects();
	for (TInt i = objects.Count()-1; i >= 0; i--)
		{
		CMMFObject* object = objects[i];
		if (object->Handle().InterfaceId() != KUidMMFControllerExtendedDataHolder)
			{
			iMMFObjectContainer->RemoveAndDestroyMMFObject(*object);
			}
		}
	return ETrue;
	}

TBool CMMFController::DoPrimeL(TMMFMessage& aMessage)
	{
	PrimeL(aMessage);
	return EFalse;
	}


EXPORT_C void CMMFController::PrimeL(TMMFMessage& aMessage)
	{
	PrimeL();
	aMessage.Complete(KErrNone);
	}


TBool CMMFController::DoPlayL(TMMFMessage& aMessage)
	{
	PlayL(aMessage);
	return EFalse;
	}

EXPORT_C void CMMFController::PlayL(TMMFMessage& aMessage)
	{
	PlayL();
	aMessage.Complete(KErrNone);
	}



TBool CMMFController::DoPauseL(TMMFMessage& aMessage)
	{
	PauseL(aMessage);
	return EFalse;
	}

EXPORT_C void CMMFController::PauseL(TMMFMessage& aMessage)
	{
	PauseL();
	aMessage.Complete(KErrNone);
	}


TBool CMMFController::DoStopL(TMMFMessage& aMessage)
	{
	StopL(aMessage);
	return EFalse;
	}

EXPORT_C void CMMFController::StopL(TMMFMessage& aMessage)
	{
	StopL();
	aMessage.Complete(KErrNone);
	}



TBool CMMFController::DoGetPositionL(TMMFMessage& aMessage)
	{
	TMMFTimeIntervalMicroSecondsPckg pckg(PositionL());
	aMessage.WriteDataToClientL(pckg);
	return ETrue;
	}

TBool CMMFController::DoSetPositionL(TMMFMessage& aMessage)
	{
	TMMFTimeIntervalMicroSecondsPckg pckg;
	aMessage.ReadData1FromClientL(pckg);
	SetPositionL(pckg());
	return ETrue;
	}

TBool CMMFController::DoGetDurationL(TMMFMessage& aMessage)
	{
	TMMFTimeIntervalMicroSecondsPckg pckg(DurationL());
	aMessage.WriteDataToClientL(pckg);
	return ETrue;
	}

TBool CMMFController::DoSetPrioritySettingsL(TMMFMessage& aMessage)
	{
	TMMFPrioritySettingsPckg pckg;
	aMessage.ReadData1FromClientL(pckg);
	SetPrioritySettings(pckg());
	return ETrue;
	}

void CMMFController::DoCustomCommand(TMMFMessage& aMessage)
	{
	// First, try giving the message to the custom command parser manager...
	TBool handled = EFalse;
	if (iCustomCommandParserManager)
		{
		if (aMessage.Destination().InterfaceId() == KUidInterfaceMMFDRMControl ||
			aMessage.Destination().InterfaceId() == KUidInterfaceMMFVideoDRMExt)
			{
			TBool secureDrmMode = EFalse;
			TRAPD(err, secureDrmMode = GetExtendedDataL()->SecureDrmMode());
			if (err)
				{
				aMessage.Complete(err);
				handled = ETrue;
				}
			else if (secureDrmMode)
				{
				aMessage.Complete(KErrPermissionDenied);
				handled = ETrue;
				}
			}
		
		if (!handled)
			{
			handled = iCustomCommandParserManager->HandleRequest(aMessage);
			}
		}
		
	// If the ccp manager couldn't handle the message, pass directly to the 
	// controller plugin as a custom command.
	if (!handled)
		CustomCommand(aMessage);
	}

TBool CMMFController::DoGetNumberOfMetaDataEntriesL(TMMFMessage& aMessage)
	{
	TInt numberOfEntries;
	GetNumberOfMetaDataEntriesL(numberOfEntries);
	TPckgBuf<TInt> pckg(numberOfEntries);
	aMessage.WriteDataToClientL(pckg);
	return ETrue;
	}

TBool CMMFController::DoGetSizeOfMetaDataEntryL(TMMFMessage& aMessage)
	{
	// Get the index of the required entry
	TPckgBuf<TInt> pckg;
	aMessage.ReadData1FromClientL(pckg);
	// Get the entry
	CMMFMetaDataEntry* entry = GetMetaDataEntryL(pckg());
	CleanupStack::PushL(entry);
	// Delete any existing buffer
	delete iMetaDataBuffer;
	iMetaDataBuffer = NULL;
	// Create a buffer to hold the externalised entry
	iMetaDataBuffer = CBufFlat::NewL(32);
	RBufWriteStream s;
	s.Open(*iMetaDataBuffer);
	CleanupClosePushL(s);
	entry->ExternalizeL(s);
	CleanupStack::PopAndDestroy(2);//s, entry
	// Write the size of the externalised data back to the client
	pckg() = iMetaDataBuffer->Ptr(0).Length();
	aMessage.WriteDataToClientL(pckg);
	return ETrue;
	}

TBool CMMFController::DoGetMetaDataEntryL(TMMFMessage& aMessage)
	{
	// We should have already prepared the buffer
	if (!iMetaDataBuffer)
		User::Leave(KErrNotReady);
	aMessage.WriteDataToClientL(iMetaDataBuffer->Ptr(0));
	return ETrue;
	}

TBool CMMFController::DoPreloadSourceSinkInitDataL(TMMFMessage& aMessage)
	{
	GetExtendedDataL()->ResetSourceSinkInitData();
	
	// Get the size of the init data and create a buffer to hold it
	TInt desLength = aMessage.SizeOfData1FromClient();
	HBufC8* sourceSinkInitData = HBufC8::NewLC(desLength);
	TPtr8 ptr = sourceSinkInitData->Des();
	aMessage.ReadData1FromClientL(ptr);
	
	GetExtendedDataL()->SetSourceSinkInitData(sourceSinkInitData);
	CleanupStack::Pop(sourceSinkInitData);
	return ETrue;
	}

TBool CMMFController::DoAddFileHandleDataSourceWithInitDataL(TMMFMessage& aMessage)
	{
	if (GetExtendedDataL()->SourceSinkInitData() == NULL)
		{
		User::Leave(KErrNotReady);
		}
	HBufC8* initData = GetExtendedDataL()->SourceSinkInitData()->AllocLC();
	
	// Get the client file handle and replace 
	RFile file;
	aMessage.AdoptFileHandleFromClientL(1,2, file);
	CleanupClosePushL(file);
	TPtr8 initDataPtr(initData->Des());
	ReplaceFileHandleInInitDataL(&file, initDataPtr);
	
	// Create the source
	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, *initData);
	CleanupStack::PopAndDestroy(2, initData);	//file, initData
	AddMDataSourceAndRepondClientL(source, aMessage);
	
	GetExtendedDataL()->ResetSourceSinkInitData();
	return ETrue;
	}

TBool CMMFController::DoAddFileHandleDataSinkWithInitDataL(TMMFMessage& aMessage)
	{
	if (GetExtendedDataL()->SourceSinkInitData() == NULL)
		{
		User::Leave(KErrNotReady);
		}
	HBufC8* initData = GetExtendedDataL()->SourceSinkInitData()->AllocLC();
	
	// Get the client file handle and replace
	RFile file;
	aMessage.AdoptFileHandleFromClientL(1,2, file);
	CleanupClosePushL(file);
	TPtr8 initDataPtr(initData->Des());
	ReplaceFileHandleInInitDataL(&file, initDataPtr);
	
	// Create the sink
	MDataSink* sink = MDataSink::NewSinkL(KUidMmfFileSink, *initData);
	CleanupStack::PopAndDestroy(2, initData);	//file, initData
	AddMDataSinkAndRepondClientL(sink, aMessage);
	
	GetExtendedDataL()->ResetSourceSinkInitData();
	return ETrue;
	}
	
void CMMFController::ReplaceFileHandleInInitDataL(RFile* aFile, TDes8& aInitData)
	{
	// aInitData should have the second 4bytes data (first 4bytes represent TUid) containing 
	// a client RFile pointer.
	// This RFile pointer may be invalid due to the fact that client and server threads
	// may reside in different processes, and therefore, different memory space.
	// In this context, we would rather trust the file handle retrieve from the call
	// AdoptFileHandleFromClientL, and replace the RFile pointer with a more reliable one
	TPtr8 filePtrStart = aInitData.MidTPtr(sizeof(TUid));
	RDesWriteStream writeStream;
	writeStream.Open(filePtrStart);
	CleanupClosePushL(writeStream);
	TPckgBuf<RFile*> filePtr(aFile);
	writeStream.WriteL(filePtr);
	writeStream.CommitL();
	CleanupStack::PopAndDestroy(&writeStream);
	}

void CMMFController::AddMDataSourceAndRepondClientL(MDataSource* aSource, TMMFMessage& aMessage)
	{
	CleanupDeletePushL(aSource);	
	CMMFDataSourceHolder* holder = new(ELeave) CMMFDataSourceHolder(*aSource);
	CleanupStack::Pop(aSource);	//aSource (since now owned by holder)
	
	CleanupStack::PushL(holder);
	// Append holder to array of MMFObjects
	User::LeaveIfError(MMFObjectContainerL().AddMMFObject(*holder));
	CleanupStack::Pop(holder);//holder

	// Write source handle info back to client
	TMMFMessageDestination handleInfo(holder->Handle());
	TMMFMessageDestinationPckg handlePckg(handleInfo);
	TInt error = aMessage.WriteDataToClient(handlePckg);

	// Add source to plugin
	if (!error)
		TRAP(error, AddDataSourceL(*aSource));

	if (error)
		{
		// Source not accepted by plugin or we couldn't write handle info back to client, 
		// so delete it and return error to client
		MMFObjectContainerL().RemoveAndDestroyMMFObject(*holder);
		User::Leave(error);
		}	
	}

void CMMFController::AddMDataSinkAndRepondClientL(MDataSink* aSink, TMMFMessage& aMessage)
	{
	CleanupDeletePushL(aSink);
	CMMFDataSinkHolder* holder = new(ELeave) CMMFDataSinkHolder(*aSink);
	CleanupStack::Pop(aSink);	//aSink (since now owned by holder)
	
	CleanupStack::PushL(holder);
	// Append sink to array
	User::LeaveIfError(MMFObjectContainerL().AddMMFObject(*holder));
	CleanupStack::Pop(holder);//holder

	// Write sink handle info back to client
	TMMFMessageDestination handleInfo(holder->Handle());
	TMMFMessageDestinationPckg handlePckg(handleInfo);
	TInt error = aMessage.WriteDataToClient(handlePckg);

	// Add sink to plugin
	if (!error)
		TRAP(error, AddDataSinkL(*aSink));

	if (error)
		{
		// Sink not accepted by plugin or we couldn't write handle info back to client, 
		// so delete it and return error to client
		MMFObjectContainerL().RemoveAndDestroyMMFObject(*holder);
		User::Leave(error);
		}
	}

CMMFControllerExtendedData* CMMFController::GetExtendedDataL()
	{
	CMMFControllerExtendedData* data = NULL;
	
	// iMMFObjectContainer and CMMFControllerExtendedData must be constructed 
	// in CMMFController constructor. Only 1 CMMFControllerExtendedData object can
	// be found in iMMFObjectContainer.		
	const RPointerArray<CMMFObject>& objects = MMFObjectContainerL().MMFObjects();
	for (TInt i = 0; i < objects.Count(); i++)
		{
		if (objects[i]->Handle().InterfaceId() == KUidMMFControllerExtendedDataHolder)
			{
			data = static_cast<CMMFControllerExtendedData*>(objects[i]);
			break;
			}
		}
	if (data == NULL)
		{
		// In this case, extended data has not been constructed and added into iMMFObjectContainer.
		// This is a situation where GetExtendedDataL is being indirectly called in the controller
		// initialization process (i.e. CMMFController::NewL() or constructor of licensee's controller).
		// Extended data should have a copy stored in Dll::Tls already at this point.
		const CMMFControllerExtendedData* dataCopy = static_cast<CMMFControllerExtendedData*>(Dll::Tls());
		data = CreateExtendedDataL(dataCopy->ClientThreadId());
		CleanupStack::PushL(data);
		User::LeaveIfError(MMFObjectContainerL().AddMMFObject(*data));
		CleanupStack::Pop(data);
		}
	return data;
	}

CMMFControllerExtendedData* CMMFController::CreateExtendedDataL(TThreadId aClientTid)
	{
	// In secureDRMMode, SecureDRM server and user are running in
	// different processes.
	TProcessId clientProcessId;
	RThread clientThread;
	CleanupClosePushL(clientThread);
	User::LeaveIfError(clientThread.Open(aClientTid));
	
	RProcess clientProcess;
	CleanupClosePushL(clientProcess);
	User::LeaveIfError(clientThread.Process(clientProcess));
	clientProcessId = clientProcess.Id();
	CleanupStack::PopAndDestroy(2, &clientThread);	// clientProcess, clientThread
	
	RProcess thisProcess;
	TBool secureDrmMode = clientProcessId != thisProcess.Id();
	thisProcess.Close();
	
	CMMFControllerExtendedData* dataSet = new(ELeave) CMMFControllerExtendedData();
	CleanupStack::PushL(dataSet);
	dataSet->SetClientThreadId(aClientTid);
	dataSet->SetSecureDrmMode(secureDrmMode);
	CleanupStack::Pop(dataSet);
	
	return dataSet;
	}


EXPORT_C CMMFCustomCommandParserManager* CMMFCustomCommandParserManager::NewL()
	{
	return new(ELeave) CMMFCustomCommandParserManager;
	}

CMMFCustomCommandParserManager::CMMFCustomCommandParserManager()
	{
	}

EXPORT_C CMMFCustomCommandParserManager::~CMMFCustomCommandParserManager()
	{
	iParsers.ResetAndDestroy();
	iParsers.Close();
	}

EXPORT_C TBool CMMFCustomCommandParserManager::HandleRequest(TMMFMessage& aMessage)
	{
	TBool handledRequest = EFalse;
	for (TInt i=0; i<iParsers.Count(); i++)
		{
		CMMFCustomCommandParserBase* c = iParsers[i];
		if (c->InterfaceId() == aMessage.Destination().InterfaceId())
			{
			c->HandleRequest(aMessage);
			handledRequest = ETrue;
			break;
			}
		}
	return handledRequest;
	}

EXPORT_C void CMMFCustomCommandParserManager::AddCustomCommandParserL(CMMFCustomCommandParserBase& aParser)
	{
	User::LeaveIfError(iParsers.Append(&aParser));
	}


TBool CMMFController::DoAddFileHandleDataSourceL(TMMFMessage& aMessage)
	{
	RFile file;
	aMessage.AdoptFileHandleFromClientL(1,2, file);
	CleanupClosePushL(file);
	TMMFFileHandleConfig fileConfig;
	fileConfig().iFile = &file;
	// Create the source
	MDataSource* source = MDataSource::NewSourceL(KUidMmfFileSource, fileConfig);
	CleanupStack::PopAndDestroy(&file);
	CleanupDeletePushL(source);	
	CMMFDataSourceHolder* holder = new(ELeave) CMMFDataSourceHolder(*source);
	CleanupStack::Pop(source);//source (since now owned by holder)

	CleanupStack::PushL(holder);
	// Append holder to array of MMFObjects
	User::LeaveIfError(MMFObjectContainerL().AddMMFObject(*holder));
	CleanupStack::Pop(holder);//holder

	// Write source handle info back to client
	TMMFMessageDestination handleInfo(holder->Handle());
	TMMFMessageDestinationPckg handlePckg(handleInfo);
	TInt error = aMessage.WriteDataToClient(handlePckg);

	// Add source to plugin
	if (!error)
		TRAP(error, AddDataSourceL(*source));

	if (error)
		{
		// Source not accepted by plugin or we couldn't write handle info back to client, 
		// so delete it and return error to client
		MMFObjectContainerL().RemoveAndDestroyMMFObject(*holder);
		User::Leave(error);
		}
	
	return ETrue;
	}


TBool CMMFController::DoAddFileHandleDataSinkL(TMMFMessage& aMessage)
	{
	RFile file;
	aMessage.AdoptFileHandleFromClientL(1,2, file);
	CleanupClosePushL(file);
	TMMFFileHandleConfig fileConfig;
	fileConfig().iFile = &file;
	// Create the sink
	MDataSink* sink = MDataSink::NewSinkL(KUidMmfFileSink, fileConfig);
	CleanupStack::PopAndDestroy(&file); // close our handle to the file
	CleanupDeletePushL(sink);
	CMMFDataSinkHolder* holder = new(ELeave) CMMFDataSinkHolder(*sink);
	CleanupStack::Pop(sink);//sink (since now owned by holder)

	CleanupStack::PushL(holder);
	// Append sink to array
	User::LeaveIfError(MMFObjectContainerL().AddMMFObject(*holder));
	CleanupStack::Pop(holder);//holder


	// Write sink handle info back to client
	TMMFMessageDestination handleInfo(holder->Handle());
	TMMFMessageDestinationPckg handlePckg(handleInfo);
	TInt error = aMessage.WriteDataToClient(handlePckg);

	// Add sink to plugin
	if (!error)
		TRAP(error, AddDataSinkL(*sink));

	if (error)
		{
		// Sink not accepted by plugin or we couldn't write handle info back to client, 
		// so delete it and return error to client
		MMFObjectContainerL().RemoveAndDestroyMMFObject(*holder);
		User::Leave(error);
		}
	
	return ETrue;
	}

EXPORT_C TThreadId CMMFController::ClientThreadIdL()
	{
	return GetExtendedDataL()->ClientThreadId();
	}

EXPORT_C TBool CMMFController::IsSecureDrmModeL()
	{
	return GetExtendedDataL()->SecureDrmMode();
	}