// 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