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