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