// 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 "MmfAudioPolicySession.h"
#include "MmfPolicyClientServer.h"
#include "MmfAudioPolicyServer.h"
#include "MmfDevSoundInfo.h"


const TInt KEventQLimit=16; // maximum number of pending events per session

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)),
			iNoMemoryEventHolder(TMMFAudioPolicyEvent(TMMFAudioPolicyEvent::EMMFAudioPolicyResourceNotification, KErrNoMemory, EMMFStateCompleted), EFalse)
	{
	}

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->ReserveClientNumL(iServer->PolicySessionCount());
	}

CMMFAudioPolicyServer* CMMFAudioPolicySession::Server()
	{
	return STATIC_CAST(CMMFAudioPolicyServer*, iServer);
	}

CMMFAudioPolicySession::~CMMFAudioPolicySession()
	{
	delete iEventReceiver;
	iEventReceiver=NULL;
	ClearEventQ();
	iAudioPolicyPrioritySettings.iState = EMMFStateClosed;
	// Have session's CMMFAudioPolicyRequest object removed from list
	if (iAudioPolicy != NULL)
		{
		iAudioPolicy->RemoveFromList(iPolicySessionId);
		}
	delete iAudioPolicyRequest;
	if (iServer != NULL)
		{
		iServer->DecrementSessionCount();
		iServer->StopNotificationTimer();
		}
	}
	
void CMMFAudioPolicySession::ClearEventQ()
	{
	while (!iEventsQue.IsEmpty())
		{
		TMMFAudioPolicyEventHolder* heldEvent = iEventsQue.First();
		iEventsQue.Remove(*heldEvent);
		if (heldEvent == &iNoMemoryEventHolder)
			{
			iNoMemoryEventUsed = EFalse;
			}		
		if (heldEvent->iShallBeDeleted)
			{
			delete heldEvent;
			}
		--iEventQSize;
		}	
	}

void CMMFAudioPolicySession::ServiceL(const RMmfIpcMessage& aMessage)
	{
	if (iEventQSize > KEventQLimit)
		{
		aMessage.Panic(KMMFAudioPolicyPanicCategory, EMMFAudioPolicySessionEventQueueOverflow);
		return;
		}
		
	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);

	iAudioPolicy->ModifyEntry(iPolicySessionId, settingsPckg().iState); 
	return ETrue;
	}

void CMMFAudioPolicySession::SendEventToClient(const TMMFAudioPolicyEvent& aEvent)
	{
	if (iEventReceiver)
		{
		iEventReceiver->SendEvent(aEvent);
		delete iEventReceiver;
		iEventReceiver=NULL;
		}
	else 
		{
		if (++iEventQSize > KEventQLimit) // check if Q is not full
			{
			return; // we'll panic that bad client later
			}
		TMMFAudioPolicyEventHolder* heldEvent = new TMMFAudioPolicyEventHolder(aEvent, ETrue);

		if (heldEvent==NULL && !iNoMemoryEventUsed)
			{
			heldEvent=&iNoMemoryEventHolder;
			iNoMemoryEventUsed = ETrue;
			}
		if (heldEvent)
			{
			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);
#if defined(ALLOW_POLICY_DEBUG)	
	RDebug::Print(_L("Sess. ID=%d listen to events"),iPolicySessionId);
#endif	
	//send the next cached event (if any) to the client
	if (!iEventsQue.IsEmpty())
		{
		TMMFAudioPolicyEventHolder* heldEvent = iEventsQue.First();
		iEventReceiver->SendEvent(heldEvent->iEvent);
		iEventsQue.Remove(*heldEvent);
		if (heldEvent == &iNoMemoryEventHolder)
			{
			iNoMemoryEventUsed = EFalse;
			}
		--iEventQSize;
		if (heldEvent->iShallBeDeleted)
			{
			delete 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( iAudioPolicyRequest->PolicySessionId() );
	return ETrue;
	}
	
TBool CMMFAudioPolicySession::RequestResourceNotificationL(const RMmfIpcMessage& aMessage)
	{
	TMMFAudioPolicyResourceNotificationSettingsPckg notificationPckg;
	MmfMessageUtil::ReadL(aMessage, 0, notificationPckg);
	iAudioPolicyRequest->SetNotificationEvent(notificationPckg().iNotificationUid);
	iAudioPolicyRequest->SetRequestDataL(notificationPckg().iNotificationDelay);
	iAudioPolicy->SetNotification(iPolicySessionId,notificationPckg().iNotificationUid);
	return ETrue;
	}

TBool CMMFAudioPolicySession::CancelRequestResourceNotificationL(const RMmfIpcMessage& aMessage)
	{
	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) const
	{
	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)
	{
	}

CMMFAudioPolicyRequest::CMMFAudioPolicyRequest():
									iPolicySessionId(KErrNotFound),
									iReqDataPtr(KNullDesC8)
	{
	iNotificationEventUid = KNullUid;
	}

CMMFAudioPolicyRequest::~CMMFAudioPolicyRequest() 
	{
	delete iRequestData;
	}

void CMMFAudioPolicyRequest::SetRequestDataL(const TDesC8& aRequestData)
	{
	iReqDataPtr.Set(KNullDesC8);
	if (aRequestData.Length() == 0)
		{
		return;
		}
	if (iRequestData==NULL || (iRequestData && iRequestData->Des().MaxLength()<aRequestData.Length()))
		{
		delete iRequestData;
		iRequestData = NULL;
		iRequestData = aRequestData.AllocL();
		}
	else
		{
		iRequestData->Des().Copy(aRequestData);
		}
	iReqDataPtr.Set(*iRequestData);
	}