// Copyright (c) 2005-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 "MmfDevSoundCIDeMuxUtility.h"

 #include "MmfDevSoundCIMuxUtility.h" // included for command definitions

 #include <mmf/plugin/mmfdevsoundcustominterface.hrh>

 #include <ecom/ecom.h>

 #include <mm/mmpluginutils.h>

 CMMFDevSoundCIDeMuxUtility* CMMFDevSoundCIDeMuxUtility::NewL(MMMFDevSoundCustomInterfaceDeMuxInterface* aInterface)

 	{

 	CMMFDevSoundCIDeMuxUtility* self = new (ELeave) CMMFDevSoundCIDeMuxUtility(aInterface);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CMMFDevSoundCIDeMuxUtility::ConstructL()

 	{

 	// nothing to do in this plugin

 	}

 CMMFDevSoundCIDeMuxUtility::~CMMFDevSoundCIDeMuxUtility()

 	{

 	}

 const TInt KDeMuxTempBufferSize = 20;

 // create a custom interface Mux implementation

 MMMFDevSoundCustomInterfaceDeMuxPlugin* CMMFDevSoundCIDeMuxUtility::CreateCustomInterfaceDeMuxL(TUid aInterfaceId)

 	{

 	// The Uid of the plugin will be the match string

 	TInt uidAsInteger = aInterfaceId.iUid;

 	TBuf8<KDeMuxTempBufferSize> tempBuffer;

 	tempBuffer.Num(uidAsInteger, EHex); // has value

 	TUid interfaceUid = {KUidDevSoundCustomInterfaceDeMux};

 	TUid destructorKey;

 	MMMFDevSoundCustomInterfaceDeMuxPlugin* self = 

 		static_cast<MMMFDevSoundCustomInterfaceDeMuxPlugin*>

 		(MmPluginUtils::CreateImplementationL(interfaceUid, destructorKey, tempBuffer, KRomOnlyResolverUid));

 	// pass the destructor key so class can destroy itself

 	self->PassDestructorKey(destructorKey);

 	CleanupReleasePushL(*self);

 	// attempt to construct the plugin

 	self->CompleteConstructL(this);

 	CleanupStack::Pop();	// self

 	return self;

 	}

 // this will leave if the command is not a supported custom interface command

 // the integer being returned is not an error code per-se it is the return code

 // from the message being handled and so it makes sense here to have the function

 // returning an integer but also able to leave if there is a problem

 TInt CMMFDevSoundCIDeMuxUtility::ProcessCustomInterfaceCommandL(const RMmfIpcMessage& aMessage)

 	{

 	TPckgBuf<TA3FCustomInterfaceCommand> commandBuf;

 	MmfMessageUtil::ReadL(aMessage, 1, commandBuf);

 	CMMFDevSoundCIMuxUtility::TMMFDevSoundCustomCommand commandType = commandBuf().iType;

 	TInt handle = commandBuf().iHandle;

 	TInt retVal = KErrNotFound;

 	switch (commandType)

 		{

 		case CMMFDevSoundCIMuxUtility::EMMFDevSoundCustomCommandCIOpenSlave:

 			{

 			// get a local copy of descriptor

 			RBuf8 tempBuf;

 			tempBuf.CleanupClosePushL();

 			TInt len = InputDesLength(aMessage);

 			if (len < 0)

 				{

 				User::Leave(KErrBadDescriptor);

 				}

 			else

 				{

 				tempBuf.CreateL(len);

 				}

 			ReadFromInputDesL(aMessage, &tempBuf);

 			TUid interfaceUid(KNullUid);

 			interfaceUid.iUid = handle;

 			TPckgBuf<TUid> idBuffer(interfaceUid);

 			retVal = iInterface->DoOpenSlaveL(idBuffer(), tempBuf);		

 			CleanupStack::PopAndDestroy(&tempBuf);

 			break;

 			}

 		case CMMFDevSoundCIMuxUtility::EMMFDevSoundCustomCommandCICloseSlave:

 			{

 			TPckgBuf<TInt> handleBuffer(handle);

 			iInterface->DoCloseSlaveL(handleBuffer());

 			retVal = KErrNone; // no return from CloseSlave

 			break;

 			}

 		case CMMFDevSoundCIMuxUtility::EMMFDevSoundCustomCommandCISendSlaveSyncCommand:

 			{

 			retVal = iInterface->DoSendSlaveSyncCommandL(aMessage);

 			break;

 			}

 		case CMMFDevSoundCIMuxUtility::EMMFDevSoundCustomCommandCISendSlaveSyncCommandResult:

 			{

 			retVal = iInterface->DoSendSlaveSyncCommandResultL(aMessage);

 			break;

 			}

 		case CMMFDevSoundCIMuxUtility::EMMFDevSoundCustomCommandCISendSlaveAsyncCommand:

 			{

 			iInterface->DoSendSlaveAsyncCommandL(aMessage);

 			retVal = KErrNone; // no return from async

 			break;

 			}

 		case CMMFDevSoundCIMuxUtility::EMMFDevSoundCustomCommandCISendSlaveAsyncCommandResult:

 			{

 			iInterface->DoSendSlaveAsyncCommandResultL(aMessage);

 			retVal = KErrNone;	// no return from async

 			break;

 			}

 		default:

 			User::Leave(retVal);

 		}

 	return retVal;

 	}

 // at the moment these two functions are the same but this may change on different platforms

 // so separate sync and async message data functions have been defined

 void CMMFDevSoundCIDeMuxUtility::GetSyncMessageDataL(const RMmfIpcMessage& aMessage, TMMFDevSoundCIMessageData& aData)

 	{

 	// data is stored as destination, custom command info, inbuf, outbuf

 	TPckgBuf<TA3FCustomInterfaceCommand> comBuffer;

 	aMessage.ReadL(1, comBuffer);

 	// get command and handle

 	aData.iCommand = comBuffer().iCommand;

 	aData.iHandle = comBuffer().iHandle;

 	}

 void CMMFDevSoundCIDeMuxUtility::GetAsyncMessageDataL(const RMmfIpcMessage& aMessage, TMMFDevSoundCIMessageData& aData)

 	{

 	// data is stored as destination, custom command info, inbuf, outbuf,status 

 	TPckgBuf<TA3FCustomInterfaceCommand> comBuffer;

 	aMessage.ReadL(1, comBuffer);

 	// get command and handle

 	aData.iCommand = comBuffer().iCommand;

 	aData.iHandle = comBuffer().iHandle;

 	}

 TInt CMMFDevSoundCIDeMuxUtility::InputDesLength(const RMmfIpcMessage& aMessage)

 	{

 	// input descriptor is at offset 2

 	TInt len = aMessage.GetDesLength(2);	

 	return len;

 	}

 void CMMFDevSoundCIDeMuxUtility::ReadFromInputDesL(const RMmfIpcMessage& aMessage, TDes8* aBufToFill)

 	{

 	// check if the descriptor is large enough

 	TInt len = InputDesLength(aMessage);

 	if (len > aBufToFill->MaxLength())

 		{

 		User::Leave(KErrArgument);

 		}

 	// input descriptor is at offset 2

 	aMessage.ReadL(2, *aBufToFill);

 	}

 void CMMFDevSoundCIDeMuxUtility::WriteToOutputDesL(const RMmfIpcMessage& aMessage, TDesC8& aBufToWrite)

 	{

 	// output descriptor is at offset 3

 	aMessage.WriteL(3, aBufToWrite);

 	}

 void CMMFDevSoundCIDeMuxUtility::CompleteMessage(const RMmfIpcMessage& aMessage, TInt aError)

 	{

 	aMessage.Complete(aError);

 	}

 CMMFDevSoundCIDeMuxUtility::CMMFDevSoundCIDeMuxUtility(MMMFDevSoundCustomInterfaceDeMuxInterface* aInterface)

 : iInterface(aInterface)

 	{

 	}