/*

* Copyright (c) 2005-2006 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:   CustomInterface Builder

*

*/

#include <CustomInterfaceBuilder.h>

#include <sounddevice.h>

#include <MessageHandlerFactory.h>

#include "AdaptationCustomInterfaceBuilder.h"

#include "CustomInterfaceBuilderTypes.h"

#include "RestrictedAudioOutputMessageHandler.h"

#include "AudioOutputMessageTypes.h"

const TUid KUidCustomInterfaceBuilderImpl = {0x10207A8E};

EXPORT_C CCustomInterfaceBuilder* CCustomInterfaceBuilder::NewL(CMMFObjectContainer& aObjectContainer,

                                                                CMMFDevSound&        aDevSound)

	{

	CCustomInterfaceBuilder* self = new(ELeave) CCustomInterfaceBuilder(aObjectContainer,

	                                                                    aDevSound);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CCustomInterfaceBuilder* CCustomInterfaceBuilder::NewL(CMMFObjectContainer& aObjectContainer,

                                                                MCustomInterface& aCustomInterface)

	{

	CCustomInterfaceBuilder* self = new(ELeave) CCustomInterfaceBuilder(aObjectContainer,

	                                                                    aCustomInterface);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CCustomInterfaceBuilder::CCustomInterfaceBuilder(CMMFObjectContainer& aObjectContainer,

                                                 CMMFDevSound&        aDevSound) :

    CMMFObject(KUidCustomInterfaceBuilderImpl),

    iDevSound(&aDevSound),

	iObjectContainer(aObjectContainer),

	iSecureCustomInterfaces(EFalse)

	{

	}

CCustomInterfaceBuilder::CCustomInterfaceBuilder(CMMFObjectContainer& aObjectContainer,

                                                 MCustomInterface& aCustomInterface) :

    CMMFObject(KUidCustomInterfaceBuilderImpl),

	iCustomInterface(&aCustomInterface),

	iObjectContainer(aObjectContainer),

	iSecureCustomInterfaces(EFalse)

	{

	}

void CCustomInterfaceBuilder::ConstructL()

	{

	}

CCustomInterfaceBuilder::~CCustomInterfaceBuilder()

	{

	}

void CCustomInterfaceBuilder::HandleRequest(TMMFMessage& aMessage)

	{

	ASSERT(aMessage.Destination().InterfaceId() == KUidCustomInterfaceBuilderImpl);

	TRAPD(error,DoHandleRequestL(aMessage));

	if(error)

		{

		aMessage.Complete(error);

		}

	}

void CCustomInterfaceBuilder::DoHandleRequestL(TMMFMessage& aMessage)

	{

	switch( aMessage.Function() )

		{

		case ECibBuild:

			DoBuildL(aMessage);

			break;

		case ECibRemove:

			DoRemoveL(aMessage);

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	}

void CCustomInterfaceBuilder::DoBuildL(TMMFMessage& aMessage)

	{

	TPckgBuf<TUid> uidPckg;

	aMessage.ReadData1FromClientL(uidPckg);

	TUid interfaceId = uidPckg();

	//only KUidRestrictedAudioOutput is blocked here. 

    //KUidAudioOutput will be blocked in messageHandler for specific commands.

	if( iSecureCustomInterfaces && interfaceId==KUidRestrictedAudioOutput )

	    {

	    User::Leave( KErrNotSupported );

	    }

	TMMFMessageDestination handle;

	TAny* customInterface = GetCustomInterfaceL(interfaceId);

	if(customInterface)

		{

		CMMFObject* messageHandler = CMessageHandlerFactory::Create(interfaceId, customInterface,iObjectContainer);

		if(messageHandler)

			{

			iObjectContainer.AddMMFObject(*messageHandler);

			handle = messageHandler->Handle();

			}

		}

	TMMFMessageDestinationPckg handlePckg(handle);

	aMessage.WriteDataToClient(handlePckg);

	aMessage.Complete(KErrNone);

	}

void CCustomInterfaceBuilder::DoRemoveL(TMMFMessage& aMessage)

	{

	TMMFMessageDestinationPckg handlePckg;

	aMessage.ReadData1FromClientL(handlePckg);

	CMMFObject* messageHandler = NULL;

	if ( iObjectContainer.FindMMFObject(handlePckg(), messageHandler) == KErrNone )

		{

		iObjectContainer.RemoveAndDestroyMMFObject(*messageHandler);

		}

	aMessage.Complete(KErrNone);

	}

TAny* CCustomInterfaceBuilder::GetCustomInterfaceL(TUid aInterfaceId)

	{

	TAny* customInterface = NULL;

    if (iDevSound)

        {

        customInterface = iDevSound->CustomInterface(aInterfaceId);

        }

    else if (iCustomInterface)

        {

        customInterface = iCustomInterface->CustomInterface(aInterfaceId);

        }

	return customInterface;

	}

EXPORT_C void CCustomInterfaceBuilder::SetSecureCustomInterfaces( const TBool aSecure )

    {

    iSecureCustomInterfaces = aSecure;

    }