--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmresourcemgmt/mmresctrl/src/mmrcserver/mmrcserversession.cpp Fri Oct 08 19:40:43 2010 +0100
@@ -0,0 +1,953 @@
+// Copyright (c) 2007-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 "mmrcserversession.h"
+#include "mmrcerrorcodes.h"
+#include "mmrcservercontroller.h"
+#include "mmrcadaptationproxy.h"
+
+#include <a3f/maudiocontext.h>
+
+#include "mlogicalchain.h"
+#include "logicalaudiostream.h"
+#include "audiocontext.h"
+
+#include <a3f/a3ffourcclookup.h>
+
+
+//------------------------------------------------------------------------------------
+//
+//------------------------------------------------------------------------------------
+/**
+ * By default Symbian 2nd phase constructor is private.
+ * @param CMMRCServerController& A reference on the MMRC Server controller
+ */
+CMMRCServerSession::CMMRCServerSession(CMMRCServerController& aServerController,
+ const CFourCCConvertor& aFourCCConvertor)
+: iMMRCServerController(aServerController),
+ iShutdown(0),
+ iLogicalChainRequested(NULL),
+ iLogicalChainLastCommited(NULL),
+ iLogicalChainRequestResponse(NULL),
+ iLogicalChainPreemptionNotification(NULL)
+ {
+ TRACE_CREATE();
+ DP_CONTEXT(----> CMMRCServerSession::CMMRCServerSession *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+ iFourCCConvertor = &aFourCCConvertor;
+ DP_OUT();
+ }
+
+/**
+ * Destructor
+ */
+CMMRCServerSession::~CMMRCServerSession()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::~CMMRCServerSession *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+ //remove any request associated to this session from the controller
+ iMMRCServerController.CloseSessionByContextId(iContextId);
+
+ if (iMMRCServerSideAdaptationResponseAO)
+ {
+ delete iMMRCServerSideAdaptationResponseAO;
+ iMMRCServerSideAdaptationResponseAO=0;
+ };
+
+ if( iLogicalChainLastCommited )
+ {
+ iLogicalChainLastCommited->Release();
+ iLogicalChainLastCommited = NULL;
+ };
+
+ if( iLogicalChainRequested )
+ {
+ iLogicalChainRequested->Release();
+ iLogicalChainRequested = NULL;
+ }
+ if( iLogicalChainRequestResponse )
+ {
+ iLogicalChainRequestResponse->Release();
+ iLogicalChainRequestResponse = NULL;
+ };
+
+ if( iLogicalChainPreemptionNotification )
+ {
+ iLogicalChainPreemptionNotification->Release();
+ iLogicalChainPreemptionNotification = NULL;
+ };
+
+ iMsgQueue.Close();
+
+ DP_OUT();
+ }
+
+/**
+ * Constructs, and returns a pointer to, a new CMMRCServerSession object.
+ * Leaves on failure.
+ * @param CMMRCServerController& A reference on the MMRC Server controller
+ * @param CFourCCConvertor& A reference to the Fourcc to format converter
+ * @return CMMRCServerSession* A pointer to newly created utlitly object.
+ */
+CMMRCServerSession* CMMRCServerSession::NewL(CMMRCServerController& aServerController,
+ const CFourCCConvertor& aFourCCConvertor)
+ {
+ DP_STATIC_CONTEXT(----> CMMRCServerSession::NewL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ CMMRCServerSession* self = NewLC(aServerController, aFourCCConvertor);
+ CleanupStack::Pop(self);
+
+ DP0_RET(self, "self=0x%x");
+ }
+
+/**
+ * Constructs, leaves object on the cleanup stack, and returns a pointer
+ * to, a new CMMRCServerSession object.
+ * Leaves on failure.
+ * @param CMMRCServerController& A reference on the MMRC Server controller
+ * @param CFourCCConvertor& A reference to the Fourcc to format converter
+ * @return CMMRCServerSession* A pointer to newly created utlitly object.
+ */
+CMMRCServerSession* CMMRCServerSession::NewLC(CMMRCServerController& aServerController,
+ const CFourCCConvertor& aFourCCConvertor)
+ {
+ DP_STATIC_CONTEXT(----> CMMRCServerSession::NewLC *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ CMMRCServerSession* self = new(ELeave) CMMRCServerSession(aServerController, aFourCCConvertor);
+ CleanupStack::PushL( self );
+ self->ConstructL();
+
+ DP0_RET(self, "self=0x%x");
+ }
+
+/**
+ CMMRCServerSession::ConstructL
+ Symbian 2nd phase constructor can leave.
+ */
+void CMMRCServerSession::ConstructL()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::ConstructL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ iContextId = reinterpret_cast<TUint32>(this);
+ iMMRCServerSideAdaptationResponseAO = CMMRCServerSideAdaptationResponseAO::NewL();
+ iMMRCServerSideAdaptationResponseAO->Initialize(this, &iServerThread);
+
+ DP_OUT();
+ }
+
+/**
+ * from CSession2
+ * @param aMessage - Function and data for the session
+ */
+void CMMRCServerSession::ServiceL(const RMessage2& aMessage)
+ {
+ DP_CONTEXT(----> CMMRCServerSession::ServiceL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ TRAPD( errL, DispatchMessageL(aMessage) );
+
+ if( errL != KErrNone )
+ {
+ #ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING
+ RDebug::Print(_L("CMMRCServerSession::ServiceL - err %d"), errL);
+ #endif
+ }
+
+ DP_OUT();
+ }
+
+/**
+ * Dispatch the message received from ServeL
+ * EMMRCClientToServerSetMsgQueueHandle - Initialise the queue handler
+ * EMMRCClientToServerMessage - Process a message from the client
+ * EMMRCClientToServerMessageUpdate - Process a message update from the client
+ * EMMRCClientToServerMessageAcknowledgement - Process the acknowldgement from the client
+ * @param aMessage - Function and data for the session
+ * @return error code
+ * @leave in case of writeL leave or request leave
+ */
+TInt CMMRCServerSession::DispatchMessageL(const RMessage2& aMessage)
+ {
+ DP_CONTEXT(----> CMMRCServerSession::DispatchMessageL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ TInt error(KErrNone);
+
+ TMMRCClientToServerMessages messageFunction = static_cast<TMMRCClientToServerMessages>(aMessage.Function());
+ switch(messageFunction)
+ {
+
+ case EMMRCClientToServerSetClientThreadId:
+ {
+ TThreadId* id = static_cast<TThreadId*>(const_cast<TAny *>(aMessage.Ptr0()));
+ iClientThread.Open(*id);
+ RThread me;
+ iServerThread.Open(me.Id());
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerSetAdaptationProxy:
+ {
+ iMMRCClientSideServerRequestToAdaptationAO = static_cast<CMMRCClientSideServerRequestToAdaptationAO*>(const_cast<TAny *>(aMessage.Ptr0()));
+
+ if(iMMRCClientSideServerRequestToAdaptationAO)
+ {
+ iMMRCClientSideServerRequestToAdaptationAO->Initialize(this,
+ iMMRCServerSideAdaptationResponseAO,
+ &iClientThread,
+ *iFourCCConvertor);
+ }
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerSetMsgQueueHandle:
+ {
+ error = iMsgQueue.Open( aMessage, 0 );
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerCloseSession:
+ {
+ //set a flag so that any subsequent acknowledgment will be ignored...
+ iShutdown=ETrue;
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerRequestResource:
+ {
+ error = EnqueueRequestL(aMessage);
+ // AM this is needed since the request is not asynchronous.
+ // It is processed asynchronously which is different
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerRequestContextId:
+ {
+ // CDS This code does not appear to be handling PlatSec functionality well
+
+ TProcessId PID;
+ TPckg<TProcessId> processIdPckg(PID);
+ TPckgBuf<TUint64> contextIdPckg;
+
+ aMessage.ReadL( 0, processIdPckg );
+
+ RProcess client;
+ TInt err = client.Open(PID);
+ if(err == KErrNone)
+ {
+ iClientHasMMCapability = client.HasCapability(ECapabilityMultimediaDD, KSuppressPlatSecDiagnostic);
+ iClientHasUECapability = client.HasCapability(ECapabilityUserEnvironment, KSuppressPlatSecDiagnostic);
+ client.Close();
+ }
+ aMessage.WriteL( 1, contextIdPckg );
+ aMessage.Complete(error);
+ }
+ break;
+
+
+ case EMMRCClientToServerRegisterAsClient:
+ {
+ // ignoring arguments
+ error = iMMRCServerController.EnqueueRequestForAPRL(*this);
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerCancelRegisterAsClient:
+ {
+ // ignoring arguments
+ error = iMMRCServerController.RemoveRequestForAPR(*this);
+ aMessage.Complete(error);
+ }
+ break;
+
+ case EMMRCClientToServerWillResumePlay:
+ {
+ error = iMMRCServerController.WillResumePlay();
+ aMessage.Complete(error);
+ }
+ break;
+
+ default:
+ {
+ #ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING
+ RDebug::Print(_L("!!!!CMMRCServerSession::DispatchMessageL - unknown message"));
+ #endif
+ // Unknown Message
+ error = KErrNotSupported;
+ }
+ break;
+ }
+
+ DP0_RET(error, "err=%d");
+ }
+
+/**
+ * Process a message that can be
+ * EMMRCMessageStateAffecting a state-effecting message
+ * EMMRCMessageCommit a resource request
+ * @param const RMessage2& aMessage
+ */
+void CMMRCServerSession::PreProcessRequestL(const RMessage2& aMessage)
+ {
+ DP_CONTEXT(----> CMMRCServerSession::PreprocessMessageL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ MLogicalChain* logicalChainRequested = static_cast<MLogicalChain*>(const_cast<TAny *>(aMessage.Ptr1()));
+ if( logicalChainRequested == NULL )
+ {
+ #ifdef _DEBUG
+ RDebug::Print(_L("!!!!CMMRCServerSession::PreProcessRequestL - logicalChainRequested NULL"));
+ ASSERT(0);
+ #endif
+ User::Leave(KErrArgument);
+ }
+
+ TInt err1 = KErrNone, err2 = KErrNone;
+ iAudioContext = static_cast<CAudioContext*>(const_cast<TAny *>(aMessage.Ptr2()));
+ MLogicalChain* logicalChainLastCommited = static_cast<MLogicalChain*>(const_cast<TAny *>(aMessage.Ptr0()));
+
+ if(iLogicalChainLastCommitedStack)
+ {
+ iLogicalChainLastCommitedStack->Release();
+ iLogicalChainLastCommitedStack = NULL;
+ }
+ if(iLogicalChainRequestedStack)
+ {
+ iLogicalChainRequestedStack->Release();
+ iLogicalChainRequestedStack = NULL;
+ }
+
+ iAudioContext->CriticalSection().Wait();
+ TInt msgVersion = iAudioContext->MsgVersion();
+ if(msgVersion == aMessage.Int3())
+ {
+ if(logicalChainLastCommited)
+ {
+ TRAP(err1, iLogicalChainLastCommitedStack = logicalChainLastCommited->CloneL());
+ }
+
+ if(logicalChainRequested)
+ {
+ TRAP(err2, iLogicalChainRequestedStack = logicalChainRequested->CloneL());
+ }
+ }
+ iAudioContext->CriticalSection().Signal();
+
+ if(msgVersion != aMessage.Int3())
+ {
+ User::Leave(KErrCompletion);
+ }
+
+ if(err1!=KErrNone)
+ {
+ #ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING
+ RDebug::Print(_L("!!!!CMMRCServerSession::PreProcessRequestL - logicalChainLastCommited->CloneL - error = %d"), err1);
+ #endif
+ ASSERT(0);
+ User::Leave(err1);
+ }
+
+ if(err2!=KErrNone)
+ {
+ #ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING
+ RDebug::Print(_L("!!!!CMMRCServerSession::PreProcessRequestL - logicalChainRequested->CloneL - error = %d"), err2);
+ #endif
+ if(iLogicalChainLastCommitedStack)
+ {
+ iLogicalChainRequestedStack->Release();
+ iLogicalChainRequestedStack = NULL;
+ }
+ ASSERT(0);
+ User::Leave(err2);
+ }
+
+ DP_OUT();
+ }
+
+/**
+ * Process a message that can be
+ * EMMRCMessageStateAffecting a state-effecting message
+ * EMMRCMessageCommit a resource request
+ * @param const RMessage2& aMessage
+ */
+TInt CMMRCServerSession::EnqueueRequestL(const RMessage2& aMessage)
+ {
+ DP_CONTEXT(----####> CMMRCServerSession::ProcessRequestL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ TInt err = KErrNone;
+ TRAP(err, PreProcessRequestL(aMessage));
+ if( err == KErrNone )
+ {
+ err = iMMRCServerController.EnqueueRequestL(*this);
+ }
+
+ DP0_RET(err, "err = %d");
+ }
+
+/*
+ *
+ */
+void CMMRCServerSession::StartProcessL()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::StartProcessL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ if( iLogicalChainLastCommited )
+ {
+ //jjpy TODO should compare with iLogicalChainRequestedStack
+ iLogicalChainLastCommited->Release();
+ }
+
+ if(iLogicalChainRequested)
+ {
+ #ifdef _DEBUG
+ RDebug::Print(_L("!!!!CMMRCServerSession::StartProcessL - iLogicalChainRequested not NULL"));
+ ASSERT(0);
+ #endif
+ iLogicalChainRequested->Release();
+ }
+
+ iLogicalChainLastCommited = iLogicalChainLastCommitedStack;
+ iLogicalChainRequested = iLogicalChainRequestedStack;
+
+ iLogicalChainLastCommitedStack = 0;
+ iLogicalChainRequestedStack = 0;
+
+ //Send the CommitUpdate to the client
+ TMMRCQueueItem messageItem;
+ messageItem.iRequestType = EMMRCRequestCommitUpdate;
+ messageItem.iResult = EMMRCServerToClientCommitUpdate;
+ messageItem.iErrorCode = KErrNone;
+ TInt errSend = iMsgQueue.Send(messageItem);
+ #ifdef _DEBUG
+ if(errSend!=KErrNone)
+ {
+ RDebug::Print(_L("!!!!CMMRCServerSession::PreProcessRequestL - error = %d"), errSend);
+ ASSERT(0);
+ }
+ #endif
+ User::LeaveIfError(errSend);
+
+ DP_OUT();
+ }
+
+/*
+ *
+ */
+void CMMRCServerSession::StartPreemptionL()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::StartPreemptionL *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ //Should be NULL
+ if(iLogicalChainRequested)
+ {
+ #ifdef _DEBUG
+ RDebug::Print(_L("!!!!CMMRCServerSession::StartPreemptionL - iLogicalChainRequested not NULL"));
+ ASSERT(0);
+ #endif
+ iLogicalChainRequested->Release();
+ }
+
+ //Should NOT be NULL.
+ if( iLogicalChainLastCommited )
+ {
+ iLogicalChainRequested = iLogicalChainLastCommited->CloneL();
+ CLogicalAudioStream* audiostream = static_cast<CLogicalAudioStream*>(iLogicalChainRequested);
+ TAudioState state = audiostream->StreamState();
+
+ // MMRC wont't support demote to EIdle anymore
+ // All stream are demote to EInitialised
+ switch(state)
+ {
+ case EIdle:
+ {
+ audiostream->Unload();
+ }
+ break;
+
+ case EPrimed:
+ case EActive:
+ {
+ User::LeaveIfError(audiostream->Stop());
+ audiostream->Unload();
+ }
+ break;
+ default:
+ #ifdef _DEBUG
+ RDebug::Print(_L("!!!!CMMRCServerSession::StartPreemptionL - wrong state "));
+ ASSERT(0);
+ #endif
+ break;
+ }
+ }
+
+ DP_OUT();
+ }
+
+/**
+ * Callback on a resource request
+ * @param TMMRCServerToClientMessageResults aResult the result on the request
+ * @leave
+ */
+void CMMRCServerSession::AdaptationRequestAcknowledgment(TMMRCAdaptationToServerRequestResults aResult, TInt aError)
+ {
+ DP_CONTEXT(----@@@@> CMMRCServerSession::AdaptationRequestAcknowledgment *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ TMMRCQueueItem messageItem;
+ messageItem.iRequestType = EMMRCRequestCommitResponse;
+
+ switch(aResult)
+ {
+ case EMMRCAdaptationToServerResourceComplete:
+ {
+ TUint64 contextId;
+ TMMRCServerState serverState;
+ iMMRCServerController.ServerState(serverState, contextId);
+ switch(serverState)
+ {
+ case EMMRCServerStateWaitResourceResponseFromAdaptation: // here we process the response
+ {
+ messageItem.iResult = EMMRCServerToClientResourceAgreed;
+ messageItem.iErrorCode = aError;
+ iMMRCServerController.AdaptationRequestAcknowledgment(*this, aResult, aError);
+ SendRequestResponseToClient(messageItem);
+ } //end case EMMRCServerStateWaitResourceResponseFromAdaptation
+ break;
+ case EMMRCServerStateWaitPreemptionResponse: // here we process the response
+ {
+ messageItem.iResult = EMMRCServerToClientResourcePreempt;
+ messageItem.iErrorCode = KErrCompletion;
+ iMMRCServerController.AdaptationRequestAcknowledgment(*this, aResult, KErrCompletion);
+ SendPreemptionNotificationToClient(messageItem);
+ }
+ break;
+ default:
+ {
+ #ifdef _DEBUG
+ RDebug::Print(_L("!!!!CMMRCServerSession::AdaptationRequestAcknowledgment - Unknown message"));
+ ASSERT(0);
+ #endif
+ }
+ break;
+ } //end case EMMRCServerStateWaitPreemptionRespons
+ }
+ break;
+
+ case EMMRCAdaptationToServerResourceIncomplete:
+ {
+ messageItem.iResult = EMMRCServerToClientResourceDenied;
+ messageItem.iErrorCode = aError;
+ iMMRCServerController.AdaptationRequestAcknowledgment(*this, aResult, aError);
+ SendRequestResponseToClient(messageItem);
+ }
+ break;
+
+ case EMMRCAdaptationToServerResourceTimeout:
+ {
+ messageItem.iResult = EMMRCServerToClientRequestError;
+ messageItem.iErrorCode = KErrCompletion;
+ iMMRCServerController.AdaptationRequestAcknowledgment(*this, EMMRCAdaptationToServerResourceTimeout, KErrCompletion);
+ SendRequestResponseToClient(messageItem);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ DP_OUT();
+ }
+
+/**
+ *
+ *
+ */
+void CMMRCServerSession::SendRequestResponseToClient(TMMRCQueueItem& messageItem)
+ {
+ DP_CONTEXT(----====> CMMRCServerSession::SendRequestResponseToClient *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+ if(messageItem.iErrorCode == KErrNone)
+ {
+ //1) Set the iLogicalChainRequestResponse
+ if(iLogicalChainRequestResponse)
+ {
+ iLogicalChainRequestResponse->Release();
+ iLogicalChainRequestResponse = NULL;
+ }
+ if(iLogicalChainRequested)
+ {
+ TInt errT;
+ TRAP(errT, iLogicalChainRequestResponse = iLogicalChainRequested->CloneL());
+ DP1(DLERR,"ECloneLeftWhenSendingResponseToClient %d", errT);
+ __ASSERT_DEBUG(errT == KErrNone, Panic(ECloneLeftWhenSendingResponseToClient));
+ }
+ //2) Set the last commited chain et set the desired one to NULL
+ if( iLogicalChainLastCommited )
+ {
+ iLogicalChainLastCommited->Release();
+ iLogicalChainLastCommited = NULL;
+ }
+ iLogicalChainLastCommited = iLogicalChainRequested;
+ iLogicalChainRequested = NULL;
+ }
+ else //In case of ERROR
+ {
+ //1) Set the iLogicalChainRequestResponse
+ if(iLogicalChainRequestResponse)
+ {
+ iLogicalChainRequestResponse->Release();
+ iLogicalChainRequestResponse = NULL;
+ }
+ if(iLogicalChainRequested)
+ {
+ TInt errT;
+ TRAP(errT, iLogicalChainRequestResponse = iLogicalChainLastCommited->CloneL());
+ DP1(DLERR,"ECloneLeftWhenSendingResponseToClient %d", errT);
+ __ASSERT_DEBUG(errT == KErrNone, Panic(ECloneLeftWhenSendingResponseToClient));
+ }
+ //2) Set the last commited chain et set the desired one to NULL
+ if( iLogicalChainRequested )
+ {
+ iLogicalChainRequested->Release();
+ iLogicalChainRequested = NULL;
+ }
+
+ if(iLogicalChainRequestedStack)
+ {
+ CLogicalAudioStream* lChain = static_cast <CLogicalAudioStream*>(iLogicalChainLastCommited);
+ TAudioTypeSettings settings;
+ settings.iPriority = iLogicalChainRequestedStack->Priority();
+ settings.iPref = 0;
+ lChain->SetAudioType(settings);
+ }
+ }
+ // Set the data for the client
+ messageItem.iData = iLogicalChainRequestResponse;
+
+ //send the response to the client
+ TInt errSend = iMsgQueue.Send(messageItem);
+ DP1(DLERR,"EMsgQueueFailedToSendMsg %d", errSend);
+ __ASSERT_DEBUG(errSend == KErrNone, Panic(EMsgQueueFailedToSendMsg));
+
+ DP_OUT();
+ }
+
+/**
+ *
+ *
+ */
+void CMMRCServerSession::SendPreemptionNotificationToClient(TMMRCQueueItem& messageItem)
+ {
+ DP_CONTEXT(----~~~~> CMMRCServerSession::SendRequestResponseToClient *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+ //1) Set the iLogicalChainPreemptionNotification
+ if(iLogicalChainPreemptionNotification)
+ {
+ iLogicalChainPreemptionNotification->Release();
+ iLogicalChainPreemptionNotification = NULL;
+ }
+ if(iLogicalChainRequested)
+ {
+ TInt errT;
+ TRAP(errT, iLogicalChainPreemptionNotification = iLogicalChainRequested->CloneL());
+ DP1(DLERR,"ECloneLeftWhenSendingResponseToClient %d", errT);
+ __ASSERT_DEBUG(errT == KErrNone, Panic(ECloneLeftWhenSendingResponseToClient));
+
+ iLogicalChainRequested->Release();
+ iLogicalChainRequested = NULL;
+ }
+
+ messageItem.iData = iLogicalChainPreemptionNotification;
+
+ //send the response to the client
+ TInt errSend = iMsgQueue.Send(messageItem);
+ DP1(DLERR,"EMsgQueueFailedToSendMsg %d", errSend);
+ __ASSERT_DEBUG(errSend == KErrNone, Panic(EMsgQueueFailedToSendMsg));
+
+ DP_OUT();
+ }
+
+/**
+ * Notify all the paused client that a resource has been unallocated
+ */
+void CMMRCServerSession::NotifyClientResourceUnallocated()
+ {
+ DP_CONTEXT(----****> CMMRCServerSession::NotifyClientsResourceUnallocated *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ TMMRCQueueItem messageItem;
+ messageItem.iRequestType = EMMRCRequestResourceUnallocated;
+ TInt errSend = iMsgQueue.Send(messageItem);
+ DP1(DLERR,"EMsgQueueFailedToSendMsg %d", errSend);
+ __ASSERT_DEBUG(errSend == KErrNone, Panic(EMsgQueueFailedToSendMsg));
+
+ DP_OUT();
+ }
+
+
+/**
+ * return the current committed chain (const)
+ * @return the current committed chain
+ */
+const MLogicalChain* CMMRCServerSession::LogicalChainRequested() const
+ {
+ DP_CONTEXT(----> CMMRCServerSession::LogicalChainRequested const *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iLogicalChainRequested, "iLogicalChainRequested=0x%x");
+ }
+
+/**
+ * return the current committed chain (const)
+ * @return the current committed chain
+ */
+const MLogicalChain* CMMRCServerSession::LogicalChainRequestedStack() const
+ {
+ DP_CONTEXT(----> CMMRCServerSession::LogicalChainRequestedStack const *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iLogicalChainRequestedStack, "iLogicalChainRequestedStack=0x%x");
+ }
+
+
+/**
+ * return the last committed chain (const)
+ * @return the last committed chain
+ */
+const MLogicalChain* CMMRCServerSession::LogicalChainLastCommited() const
+ {
+ DP_CONTEXT(----> CMMRCServerSession::LogicalChainLastCommited const *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iLogicalChainLastCommited, "iLogicalChainLastCommited=0x%x");
+ }
+
+/**
+ * return the Audio Context (const)
+ * @return the Audio Context
+ */
+const MAudioContext* CMMRCServerSession::AudioContext() const
+ {
+ DP_CONTEXT(----> CMMRCServerSession::AudioContext *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iAudioContext, "iAudioContext=0x%x");
+ }
+
+/**
+ * return the current committed chain
+ * @return the current committed chain
+ */
+MLogicalChain* CMMRCServerSession::LogicalChainRequested()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::LogicalChainRequested *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iLogicalChainRequested, "iLogicalChainRequested=0x%x");
+ }
+
+/**
+ * return the current committed chain
+ * @return the current committed chain
+ */
+MLogicalChain* CMMRCServerSession::LogicalChainRequestedStack()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::LogicalChainRequestedStack *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iLogicalChainRequestedStack, "iLogicalChainRequestedStack=0x%x");
+ }
+
+/**
+ * return the last committed chain
+ * @return the last committed chain
+ */
+MLogicalChain* CMMRCServerSession::LogicalChainLastCommited()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::LogicalChainLastCommited *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iLogicalChainLastCommited, "iLogicalChainLastCommited=0x%x");
+ }
+
+/**
+ *
+ * @param
+ * @return
+ */
+CMMRCClientSideServerRequestToAdaptationAO* CMMRCServerSession::AdaptationProxy()
+{
+ DP_CONTEXT(----> CMMRCServerSession::AdaptationProxy *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iMMRCClientSideServerRequestToAdaptationAO, "iMMRCServerAdaptationProxy=0x%x");
+}
+
+/**
+ *
+ * @param
+ * @return
+ */
+TUint64 CMMRCServerSession::ContextId()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::ContextId *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iContextId, "iContextId=%d");
+ }
+
+/**
+ *
+ */
+TBool CMMRCServerSession::HasMultimediaCapability() const
+ {
+ return iClientHasMMCapability;
+ }
+
+
+/**
+ *
+ */
+void CMMRCServerSession::Clean()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::Clean *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+ DP_OUT();
+ }
+
+/**
+ *
+ * @param
+ */
+void CMMRCServerSession::Disconnect(const RMessage2& aMessage)
+ {
+ DP_CONTEXT(----> CMMRCServerSession::Disconnect *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ CSession2::Disconnect(aMessage);
+
+ DP_OUT();
+ }
+
+/**
+ *
+ * @return
+ */
+TBool CMMRCServerSession::IsServerShuttingDown()
+ {
+ DP_CONTEXT(----> CMMRCServerSession::IsServerShuttingDown *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+
+ DP0_RET(iShutdown, "state(bool) = %d");
+ }
+
+TInt CMMRCServerSession::RequestsSent()
+ {
+ return iRequestsSent;
+ };
+
+void CMMRCServerSession::IncrementRequestsSent()
+ {
+ iRequestsSent++;
+ };
+
+CMMRCServerSideAdaptationResponseAO* CMMRCServerSession::ServerProxy()
+ {
+ return iMMRCServerSideAdaptationResponseAO;
+ };
+
+TInt CMMRCServerSession::SendRequestToAdaptation(TMMRCServerSessionRequestType aRequestType)
+ {
+ TInt err=KErrNone;
+ if (!IsServerShuttingDown())
+ {
+ IncrementRequestsSent();
+ ServerProxy()->StartAdaptationListening();
+ AdaptationProxy()->Service(aRequestType);
+ }
+ else
+ {
+// send some server shutting down error code.
+ }
+ return err;
+ };
+
+TInt CMMRCServerSession::GetPriority() const
+ {
+ DP_CONTEXT(----> CMMRCServerSession::GetPriority *CD1*, CtxDevSound, DPLOCAL);
+ DP_IN();
+ TInt priority = 0;
+ if(LogicalChainLastCommited() != NULL)
+ {
+ priority = const_cast<MLogicalChain*>( LogicalChainLastCommited() )->Priority();
+ }
+ DP0_RET(priority, "priority = %d");
+ }
+
+void CMMRCServerSession::Panic(TMMRCServerSessionPanicCodes aCode)
+ {
+ User::Panic(KMMRCServerSessionPanicCategory, aCode);
+ }
+
+/**
+ * @ return Boolean value specifying whether Client has UserEnvironment Capability.
+ */
+TBool CMMRCServerSession::HasUserEnvironmentCapability()
+ {
+ return iClientHasUECapability;
+ }
+
+/**
+ * @ param Error Value to send
+ * @ return Error Value specifying any error in adding the message to the message queue.
+ */
+
+TInt CMMRCServerSession::NotifyClientOfError(TInt aError)
+ {
+ // Create message and send to Client
+ TMMRCQueueItem messageItem;
+ messageItem.iRequestType = EMMRCRequestCommitUpdate;
+ messageItem.iResult = EMMRCServerToClientCommitUpdate;
+ messageItem.iErrorCode = KErrNone;
+ TInt errSend = iMsgQueue.Send(messageItem);
+
+ // Create a message with the Error and send to Client
+ messageItem.iRequestType = EMMRCRequestCommitResponse;
+ messageItem.iResult = EMMRCServerToClientResourceAgreed;
+ messageItem.iErrorCode = aError;
+ TInt errSend2 = iMsgQueue.Send(messageItem);
+ if (errSend!=KErrNone)
+ {
+ return errSend;
+ }
+ else
+ {
+ return errSend2;
+ }
+ }
+//EOF