--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/devsound/devsoundrefplugin/src/server/Policy/MmfAudioPolicySession.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,396 @@
+// 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);
+	}
+
+
+