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

#include "MmfBtPolicyClientServer.h"

#include "MmfBtAudioPolicyServer.h"

#include "MmfBtDevSoundInfo.h"

CMMFAudioPolicySession* CMMFAudioPolicySession::NewL()

	{

	CMMFAudioPolicySession* self = new(ELeave) CMMFAudioPolicySession();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CMMFAudioPolicySession::ConstructL()

	{

	iAudioPolicyRequest = new (ELeave) CMMFAudioPolicyRequest();

	}

CMMFAudioPolicySession::CMMFAudioPolicySession() : iEventsQue(_FOFF(TMMFAudioPolicyEventHolder,iLink))

	{

	}

void CMMFAudioPolicySession::CreateL(const CMmfIpcServer& aServer)

	{

	iServer = STATIC_CAST(CMMFAudioPolicyServer*, (CONST_CAST(CMmfIpcServer*, &aServer)));

	iServer->IncrementSessionCount();

	CMmfIpcSession::CreateL(aServer);

	iServer->IncrementSessionId();

	iPolicySessionId = iServer->PolicySessionId();

	// Get ptr to AudioPolicy from the server

	iAudioPolicy = iServer->AudioPolicy();

	(iAudioPolicy->AudioPolicyRequestArray())->SetReserveL(iServer->PolicySessionCount());

	}

CMMFAudioPolicyServer* CMMFAudioPolicySession::Server()

	{

	return STATIC_CAST(CMMFAudioPolicyServer*, iServer);

	}

CMMFAudioPolicySession::~CMMFAudioPolicySession()

	{

	delete iEventReceiver;

	delete iAudioPolicyRequest;

	iEventReceiver=NULL;

	if (!iEventsQue.IsEmpty())

		{

		TMMFAudioPolicyEventHolder* heldEvent = iEventsQue.First();

		iEventsQue.Remove(*heldEvent);

		delete heldEvent;

		}

	iAudioPolicyPrioritySettings.iState = EMMFStateClosed;

	// Have session's CMMFAudioPolicyRequest object removed from list

	iAudioPolicy->RemoveFromList(iPolicySessionId);

	iServer->DecrementSessionCount();

	iServer->StopNotificationTimer();

	}

void CMMFAudioPolicySession::ServiceL(const RMmfIpcMessage& aMessage)

	{

	TBool complete = EFalse;

	switch(aMessage.Function())

		{

	case EMMFPolicyMakeRequest:

		MakeRequestL(aMessage);

		aMessage.Complete(KErrNone);

		break;

	case EMMFPolicySetDevSoundInfo:

		complete = SetDevSoundInfoL(aMessage);

		break;

	case EMMFPolicyUpdateState:

		complete = UpdateStateL(aMessage);

		break;

	case EMMFPolicyReceiveEvents:

		complete = ReceiveEventsL(aMessage);

		break;

	case EMMFPolicyCancelReceiveEvents:

		complete = CancelReceiveEvents();

		break;

	case EMMFPolicyGetPlayFormatsSupported:

		complete = GetPlayFormatsSupportedL(aMessage);

		break;

	case EMMFPolicyGetRecordFormatsSupported:

		complete = GetRecordFormatsSupportedL(aMessage);

		break;

	case EMMFPolicyGetPlayFormat:

		complete = GetPlayFormatL(aMessage);

		break;

	case EMMFPolicyGetRecordFormat:

		complete = GetRecordFormatL(aMessage);

		break;

	case EMMFPolicyLaunchRequests:

		complete = LaunchRequest();

		break;

	case EMMFPolicyRequestResourceNotification:

		complete = RequestResourceNotificationL(aMessage);

		break;

	case EMMFPolicyCancelRequestResourceNotification:

		complete = CancelRequestResourceNotificationL(aMessage);

		break;

	case EMMFPolicyStopNotification:

		complete = StopNotificationL(aMessage);

		break;

	case EMMFPolicyGetResourceNotificationEvent:

		complete = GetResourceNotificationEventL(aMessage);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	if(complete)

		{

		aMessage.Complete(KErrNone);

		}

	}

void CMMFAudioPolicySession::MakeRequestL(const RMmfIpcMessage& aMessage)

	{

	TMMFAudioPolicyPrioritySettingsPckg settingsPckg;

	MmfMessageUtil::ReadL(aMessage, 0, settingsPckg);

	iAudioPolicyRequest->SetPriority(settingsPckg().iPriority);

	iAudioPolicyRequest->SetPref(settingsPckg().iPref);

	iAudioPolicyRequest->SetState(settingsPckg().iState);

	iAudioPolicyRequest->SetCapabilities(settingsPckg().iCapabilities);

	// Set session Id in Request

	iAudioPolicyRequest->SetPolicySessionId(iPolicySessionId);

	iAudioPolicy->MakeRequest(iAudioPolicyRequest);

	}

TBool CMMFAudioPolicySession::UpdateStateL(const RMmfIpcMessage& aMessage)

	{

	TMMFAudioPolicyPrioritySettingsPckg settingsPckg;

	MmfMessageUtil::ReadL(aMessage, 0, settingsPckg);

	iAudioPolicyRequest->SetState(settingsPckg().iState);

	iAudioPolicy->ModifyEntry(iPolicySessionId, iAudioPolicyRequest); 

	return ETrue;

	}

void CMMFAudioPolicySession::SendEventToClient(TMMFAudioPolicyEvent& aEvent)

	{

	if (iEventReceiver)

		{

		iEventReceiver->SendEvent(aEvent);

		delete iEventReceiver;

		iEventReceiver=NULL;

		}

	else 

		{

		TMMFAudioPolicyEventHolder* heldEvent = new TMMFAudioPolicyEventHolder(aEvent);

		iEventsQue.AddLast(*heldEvent);

		}

	}

TBool CMMFAudioPolicySession::SetDevSoundInfoL(const RMmfIpcMessage& aMessage)

	{

	TMMFDevSoundInfoPckg devSoundInfoPckg;

	MmfMessageUtil::ReadL(aMessage, 0, devSoundInfoPckg);

	iDevSoundId = devSoundInfoPckg().iDevSoundId;

	return ETrue;

	}

TBool CMMFAudioPolicySession::ReceiveEventsL(const RMmfIpcMessage& aMessage)

	{

	if (iEventReceiver)

		User::Leave(KErrAlreadyExists);

	iEventReceiver = CMMFAudioPolicyEventReceiver::NewL(aMessage);

	//send the next cached event (if any) to the client

	if (!iEventsQue.IsEmpty())

		{

		TMMFAudioPolicyEventHolder* heldEvent = iEventsQue.First();

		iEventReceiver->SendEvent(heldEvent->iEvent);

		iEventsQue.Remove(*heldEvent);

		delete iEventReceiver;

		iEventReceiver=NULL;

		}

	return EFalse;

	}

TBool CMMFAudioPolicySession::CancelReceiveEvents()

	{

	delete iEventReceiver;

	iEventReceiver = NULL;

	return ETrue;

	}

TBool CMMFAudioPolicySession::GetPlayFormatsSupportedL(const RMmfIpcMessage& aMessage)

	{

	RMdaDevSound::TSoundFormatsSupportedBuf aPlayFormatsSupported;

	aPlayFormatsSupported = iAudioPolicy->MdaHwInfo()->GetPlayFormatsSupported();

	MmfMessageUtil::WriteL(aMessage, 0, aPlayFormatsSupported);

	return ETrue;

	}

TBool CMMFAudioPolicySession::GetRecordFormatsSupportedL(const RMmfIpcMessage& aMessage)

	{

	RMdaDevSound::TSoundFormatsSupportedBuf aRecordFormatsSupported;

	aRecordFormatsSupported = iAudioPolicy->MdaHwInfo()->GetRecordFormatsSupported();

	MmfMessageUtil::WriteL(aMessage, 0, aRecordFormatsSupported);

	return ETrue;

	}

TBool CMMFAudioPolicySession::GetPlayFormatL(const RMmfIpcMessage& aMessage)

	{

	RMdaDevSound::TCurrentSoundFormatBuf aPlayFormat;

	aPlayFormat = iAudioPolicy->MdaHwInfo()->GetPlayFormat();

	MmfMessageUtil::WriteL(aMessage, 0, aPlayFormat);

	return ETrue;

	}

TBool CMMFAudioPolicySession::GetRecordFormatL(const RMmfIpcMessage& aMessage)

	{

	RMdaDevSound::TCurrentSoundFormatBuf aRecordFormat;

	aRecordFormat = iAudioPolicy->MdaHwInfo()->GetRecordFormat();

	MmfMessageUtil::WriteL(aMessage, 0, aRecordFormat);

	return ETrue;

	}

TBool CMMFAudioPolicySession::LaunchRequest()

	{

	iAudioPolicy->LaunchRequest();

	return ETrue;

	}

TBool CMMFAudioPolicySession::RequestResourceNotificationL(const RMmfIpcMessage& aMessage)

	{

	TMMFAudioPolicyResourceNotificationSettingsPckg notificationPckg;

	MmfMessageUtil::ReadL(aMessage, 0, notificationPckg);

	iAudioPolicyRequest->SetNotificationEvent(notificationPckg().iNotificationUid);

	iAudioPolicy->SetNotification(iPolicySessionId,notificationPckg().iNotificationUid);

	return ETrue;

	}

TBool CMMFAudioPolicySession::CancelRequestResourceNotificationL(const RMmfIpcMessage& aMessage)

	{

	if(iServer->IsTimerActive() == EFalse)

		{

		iServer->StartNotificationTimer();

		}

	TMMFAudioPolicyResourceNotificationSettingsPckg notificationPckg;

	MmfMessageUtil::ReadL(aMessage, 0, notificationPckg);

	iAudioPolicyRequest->ResetNotificationEvent(notificationPckg().iNotificationUid);

	iAudioPolicy->SetNotification(iPolicySessionId,KNullUid);

	return ETrue;

	}

TBool CMMFAudioPolicySession::StopNotificationL(const RMmfIpcMessage& /*aMessage*/)

	{

	iServer->StopNotificationTimer();

	return ETrue;

	}

TBool CMMFAudioPolicySession::GetResourceNotificationEventL(const RMmfIpcMessage& aMessage)

	{

	TMMFAudioPolicyResourceNotificationSettingsPckg notificationPckg;

	notificationPckg().iNotificationUid = iAudioPolicyRequest->NotificationEvent();

	MmfMessageUtil::WriteL(aMessage, 0, notificationPckg);

	return ETrue;

	}

CMMFAudioPolicyEventReceiver* CMMFAudioPolicyEventReceiver::NewL(const RMmfIpcMessage& aMessage)

	{

	return new(ELeave) CMMFAudioPolicyEventReceiver(aMessage);

	}

CMMFAudioPolicyEventReceiver::~CMMFAudioPolicyEventReceiver()

	{

	if (iNeedToCompleteMessage)

		iMessage.Complete(KErrDied);

	}

void CMMFAudioPolicyEventReceiver::SendEvent(const TMMFAudioPolicyEvent& aEvent)

	{

	TMMFAudioPolicyEventPckg eventpckg(aEvent);

	TInt err = MmfMessageUtil::Write(iMessage, 0, eventpckg);

	iMessage.Complete(err);

	iNeedToCompleteMessage = EFalse;			

	}

void CMMFAudioPolicyEventReceiver::SendEvent(const TMMFEvent& aEvent)

	{

	TMMFEventPckg eventpckg(aEvent);

	TInt err = MmfMessageUtil::Write(iMessage, 0, eventpckg);

	iMessage.Complete(err);

	iNeedToCompleteMessage = EFalse;

	}

CMMFAudioPolicyEventReceiver::CMMFAudioPolicyEventReceiver(const RMmfIpcMessage& aMessage) : 

	iMessage(aMessage), iNeedToCompleteMessage(ETrue)

	{

	}