// 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 "mmrcservercontroller.h"

#include "mmrcerrorcodes.h"

#include "mmrcserversession.h"

#include "mmrcserverinfo.h"

#include "mmrcserverrulemanager.h"

#include "mmrcadaptationproxy.h"

#include "mlogicalchain.h"

#include <a3f/audioprocessingunittypeuids.h>

/**

@internalComponent

This class implements a timer. 

*/	

class CARNNotificationObject : public CActive

	{

public:

	static CARNNotificationObject* NewL(const TInt aPriority, CMMRCServerInfo& aMMRCServerInfo);

	~CARNNotificationObject();

	void After(TTimeIntervalMicroSeconds32 aInterval);

	void Initialize();

protected:

	void RunL();

	void DoCancel();

private:

	CARNNotificationObject(const TInt aPriority);

	void ConstructL(CMMRCServerInfo& aMMRCServerInfo);

public:

	TInt iIndex;

protected:

	RTimer	iTimer;

	CMMRCServerInfo*  iMMRCServerInfo;

	};

//------------------------------------------------------------------------------------

//

//------------------------------------------------------------------------------------

/**

 * Constructor

 */

CMMRCServerController::CMMRCServerController()

	{

	TRACE_CREATE();

	DP_CONTEXT(----> CMMRCServerController::CMMRCServerController *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	}

/**

 * Destructor

 */

CMMRCServerController::~CMMRCServerController()

	{

	DP_CONTEXT(----> CMMRCServerController::~CMMRCServerController *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	delete iMMRCServerInfo;

	delete iMMRCServerRuleManager;

	delete iARNNotificationObject;

	DP_OUT();

	}

/**

 * Constructs, and returns a pointer to, a new CMMRCServerController object.

 * Leaves on failure.

 * @return CMMRCServerController* A pointer to newly created utlitly object.

 */		

CMMRCServerController* CMMRCServerController::NewL()

	{

	DP_STATIC_CONTEXT(----> CMMRCServerController::NewL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CMMRCServerController* self = NewLC();

	CleanupStack::Pop(self);

	DP0_RET(self, "self = 0x%x");

	}

/**

 * Constructs, leaves object on the cleanup stack, and returns a pointer

 * to, a new CMMRCServerController object.

 * Leaves on failure.

 * @return CMMRCServerController* A pointer to newly created utlitly object.

 */	

CMMRCServerController* CMMRCServerController::NewLC()

	{

	DP_STATIC_CONTEXT(----> CMMRCServerController::NewLC *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CMMRCServerController* self = new(ELeave) CMMRCServerController();

	CleanupStack::PushL(self);

	self->ConstructL();

	DP0_RET(self, "self = 0x%x");

	}

/**

 * CMMRCServerController::ConstructL

 * Symbian 2nd phase constructor can leave.

 */

void CMMRCServerController::ConstructL()

	{

	DP_CONTEXT(----> CMMRCServerController::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iMMRCServerInfo = CMMRCServerInfo::NewL(*this);

	iMMRCServerRuleManager = CMMRCServerRuleManager::NewL(*this);

	iARNNotificationObject = CARNNotificationObject::NewL(0, *iMMRCServerInfo); //Check the value

	DP_OUT();

	}

/**

* Process the request pointer by a specific session

* @param CMMRCServerSession& aServerSession

* @return KerrNone in case of success of the process

*/

TInt CMMRCServerController::EnqueueRequestL(CMMRCServerSession& aServerSession)

	{

	DP_CONTEXT(----> CMMRCServerController::ProcessRequestL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	//add the request to the queue

	iMMRCServerInfo->PushRequestL(aServerSession);

	TInt err = ProcessNextRequestL();

	DP0_RET(err, "err=%d");

	}

/**

 * Process the first request with the highest priority from the FIFO queue

 * @return KerrNone in case of success of the process

 */

 TInt CMMRCServerController::ProcessNextRequestL()

	{

	DP_CONTEXT(--------> CMMRCServerController::ProcessNextRequestL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	TUint64 contextId;

	TMMRCServerState serverState;

	iMMRCServerInfo->ServerState(serverState, contextId);

#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING

		RDebug::Print(_L("serverState    = %d"),  serverState);

		RDebug::Print(_L("size of message queue    = %d"),  iMMRCServerInfo->RequestsCount());

		RDebug::Print(_L("size of inprocess queue = %d"),  iMMRCServerInfo->AllocatedResourceContextsCount());

		RDebug::Print(_L("size of paused queue = %d"),  iMMRCServerInfo->AllocatedPausedContextsCount());

#endif

	if(EMMRCServerStateIdle != serverState)

		{

		DP0_RET(KErrNone, "%d");

		}

	CMMRCServerSession* serverSession = iMMRCServerInfo->PopAndRemoveFirstRequest(); //PopAndRemoveRequestFirstHighestPriority();

	//Pop the next next commited message with the highest priority

	if( NULL == serverSession )

		{

		DP0_RET(KErrNone, "%d");

		}

	if (!serverSession->HasUserEnvironmentCapability())

		{

		/* Check to see if it's a record use case and in IDLE, Active, or PRIME.

		// in which case you should refuse the request for reasons 

		KErrPermissionDenied

		*/

		MLogicalChain* requestedChange = serverSession->LogicalChainRequestedStack();

		if ((requestedChange!=NULL) && (requestedChange->StreamState() > EInitialized)) // trying to play

			{

			TInt count = requestedChange->AudioProcessingUnitsCount();

			for (TInt i=0; i<count; ++i)

				{

				if (KUidAudioDeviceSource == requestedChange->AudioProcessingUnitUid(i))

					{		

					serverSession->NotifyClientOfError(KErrPermissionDenied);

					// The following return value, doesn't actually make it back to the client

					// We do however Notify the client above using NotifyClientOfError()

					DP0_RET(KErrPermissionDenied, "%d");

					}

				}			

			}

		}

	//Pop the last commited message in process = the current resource in use

	CMMRCServerSession* serverSessionAllocatedResource = iMMRCServerInfo->PopFirstAllocatedResourceContext();

	//If no resource locked...

	if( NULL == serverSessionAllocatedResource )

		{

		err = SendResourceRequest ( *serverSession );

		}

	else //If a resource has been allocated or is used, possibly preemption

		{

		TAudioContextId contextId = serverSession->ContextId( );

		TAudioContextId contextIdAllocatedResource = serverSessionAllocatedResource->ContextId( );

	#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

			RDebug::Print(_L("contextId          = %d"),  contextId.Id());

			RDebug::Print(_L("contextIdAllocatedResource = %d"),  contextIdAllocatedResource.Id());

	#endif

		//in case of processing the same context, remove the last committed request from the queue

		// of in-process request to avoid preemption within the same context.

		if(contextId == contextIdAllocatedResource)

			{

			err = SendResourceRequest ( *serverSession );

			}

		else // maybe preemption

			{

			//Pop the rule

			MLogicalChain* logicalChainUsingResource = serverSessionAllocatedResource->LogicalChainLastCommited();

			MLogicalChain* logicalChainNew = serverSession->LogicalChainRequestedStack();

			//Should not/cannot be null! 

			if( NULL==logicalChainUsingResource || NULL==logicalChainNew )

				{

			#ifdef _DEBUG	

					RDebug::Print(_L("!!!!CMMRCServerController::ProcessNextRequestL - logicalChainUsingResource or logicalChainNew NULL"));

					ASSERT(0);

			#endif

				User::Leave(EMMRCErrorLogicalChainNull);

				}

			TAudioState audioStateAllocatedResource = logicalChainUsingResource->StreamState();

			TAudioState audioStateNew = logicalChainNew->StreamState ( );

			TMMRCRule rule = DecisionRule(audioStateAllocatedResource, audioStateNew);

			//Process according to the rule

			if( rule == EAlwaysProcess )

				{

				err = SendResourceRequest( *serverSession );

				}

			else // process only in case of higher priority

				{

				TInt currentClientPriority = logicalChainUsingResource->Priority();

				TInt newClientPriority = logicalChainNew->Priority();

				TBool currentClient_HasMMDD = serverSessionAllocatedResource->HasMultimediaCapability();

				TBool newClient_HasMMDD = serverSession->HasMultimediaCapability();

				// If new client has multimedia capability and current doesn't have, 

				// priorities don't matter preempt the current client

				// But if both are equal competitors (both has MMDD capability or both hasn't)

				// and the newcomer has higher priority preempt too

				if ( (!currentClient_HasMMDD && newClient_HasMMDD)  || 

					( (currentClient_HasMMDD == newClient_HasMMDD) && 

					  (newClientPriority > currentClientPriority) ) )

					{

					//The process is delayed. First we have to preempt the current inprocess resource

					// so puch back the request (its session)

					iMMRCServerInfo->PushRequestL(*serverSession);

					//

					//send a premption message to the last commited message session

					err = SendPreemptionRequest ( *serverSessionAllocatedResource );

					}

				else 

					{

					// Deny the resource

					TAudioContextId iId = serverSession->ContextId( );

					TBool iIsOnPauseList = iMMRCServerInfo->IsOnPauseList(iId);

					if(!iIsOnPauseList)

						{

						iMMRCServerInfo->PushPausedContextL(*serverSession);

						}

// nothing pending, deny resources, and notify client.						

					serverSession->AdaptationRequestAcknowledgment(EMMRCAdaptationToServerResourceIncomplete, KErrInUse);

// Server is back to idle.

					iMMRCServerInfo->SwitchServerState(EMMRCServerStateIdle, 0);

					}

				}

			}

		}

#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

	if(err != KErrNone)

		{

		RDebug::Print(_L("!!!!CMMRCServerController::ProcessNextRequestL - error = %d"), err);

		}

#endif

	DP0_RET(err, "err=%d");

	}

/**

 * Pop the decision rule on the base of the current in-process request and a new committed request

 * @param TAudioState aAudioStateAllocatedResource

 * @param TAudioState aAudioStateRequiringProcess

 * @return TMMRCRule

 */

TMMRCRule CMMRCServerController::DecisionRule(TAudioState aAudioStateAllocatedResource, TAudioState aAudioStateRequiringProcess)

	{

	DP_CONTEXT(----> CMMRCServerController::DecisionRule *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TMMRCRule rule = iMMRCServerRuleManager->DecisionRule(aAudioStateAllocatedResource, aAudioStateRequiringProcess);

	DP0_RET(rule, "rule=%d");

	}

/**

 * Pop the action reason on the base of the last committed request and the current one

 * @param TAudioState aAudioStateLastCommitted

 * @param TAudioState aAudioStateRequested

 * @return TReason

 */

TReason CMMRCServerController::ActionReason(TAudioState aAudioStateLastCommitted, TAudioState aAudioStateRequested)

	{

	DP_CONTEXT(----> CMMRCServerController::ActionReason *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TReason reason = iMMRCServerRuleManager->ActionReason(aAudioStateLastCommitted, aAudioStateRequested);

	DP0_RET(reason, "reason=%d");

	}

/**

 * Send a resource request to the adaptation

 * @param MLogicalChain* aOldChain

 * @param MLogicalChain* aNewChain

 * @return KerrNone in case of success of the process

 */

TInt CMMRCServerController::SendResourceRequest( CMMRCServerSession& aServerSession )

	{

	DP_CONTEXT(----> CMMRCServerController::SendResourceRequest *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iMMRCServerInfo->SwitchServerState( EMMRCServerStateWaitResourceResponseFromAdaptation, aServerSession.ContextId() );

// if entering APR state, remove from Paused list.

	TRAPD(err, aServerSession.StartProcessL());

	{

	MLogicalChain* logicalChainNew = aServerSession.LogicalChainRequested();

	if (logicalChainNew)

		{

		TAudioState audioStateNew = logicalChainNew->StreamState();

		if ( 

			(audioStateNew == EActive ) || 

			(audioStateNew == EPrimed) || 

			(audioStateNew == EIdle) 

			)

			{

			TInt contextId = aServerSession.ContextId( );

			iMMRCServerInfo->PopAndRemovePausedContext(contextId);

			}

		}

	}

	if(err == KErrNone)

		{

		//Send request

		if (!aServerSession.SendRequestToAdaptation(ENormalRequest))

			{

// TBD fail at current task.

// return server shutting down			

			}

		}

#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

	if(err != KErrNone)

		{

		RDebug::Print(_L("!!!!CMMRCServerController::SendResourceRequest - error = %d"), err);

		}

#endif

	DP0_RET(err, "err=%d");

	}

/** 

 * Send a preemption request to the adaptation

 * @param MLogicalChain* aOldChain

 * @param MLogicalChain* aNewChain

 * @return KerrNone in case of success of the process

 */

TInt CMMRCServerController::SendPreemptionRequest( CMMRCServerSession& aServerSession )

	{

	DP_CONTEXT(----> CMMRCServerController::SendPreemptionRequest *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iMMRCServerInfo->SwitchServerState( EMMRCServerStateWaitPreemptionResponse, aServerSession.ContextId() );

	//Update logical chains

	TRAPD(err, aServerSession.StartPreemptionL());

	if(err == KErrNone)

		{

	//Send request

		if (!aServerSession.SendRequestToAdaptation(EPreemptionRequest))

			{

	// TBD fail at current task.

	// return server shutting down/low memory where necessary			

			}

		}

#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

	if(err != KErrNone)

		{

		RDebug::Print(_L("!!!!CMMRCServerController::SendPreemptionRequest - error = %d"), err);

		}

#endif

	DP0_RET(err, "err=%d");

	}

/** 

 * Callback from the adaptation

 * @param MLogicalChain* aOldChain

 * @param MLogicalChain* aNewChain

 * @param TMMRCAdaptationToServerRequestResults aResult

 */

void CMMRCServerController::AdaptationRequestAcknowledgment(CMMRCServerSession& aServerSession, TMMRCAdaptationToServerRequestResults aResult, TInt /*aError*/)

	{

	DP_CONTEXT(--------> CMMRCServerController::AdaptationRequestAcknowledgment *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

		RDebug::Print(_L("size of message queue    = %d"),  iMMRCServerInfo->RequestsCount());

		RDebug::Print(_L("size of inprocess queue = %d"),  iMMRCServerInfo->AllocatedResourceContextsCount());

		RDebug::Print(_L("size of paused queue = %d"),  iMMRCServerInfo->AllocatedPausedContextsCount());

#endif

	TUint64 contextId;

	TMMRCServerState serverState;

	TInt err = KErrNone;

	iMMRCServerInfo->ServerState(serverState, contextId);

	switch(serverState)

		{

		case EMMRCServerStateWaitPreemptionResponse: // here we process the response

			{

			switch(aResult)

				{

				case EMMRCAdaptationToServerResourceComplete:

					{

					//we remove the request in process from the queue

					CMMRCServerSession* serverSession = iMMRCServerInfo->PopAndRemoveFirstAllocatedResourceContext();

					if(serverSession)

						{

						TRAP(err, iMMRCServerInfo->PushPausedContextL(*serverSession));

						DP1(DLERR,"EPushPauseContextLeft %d", err);

						__ASSERT_DEBUG(err == KErrNone, Panic(EPushPauseContextLeft));

						}

					//Do not wait for a client acknowledgment

					iMMRCServerInfo->SwitchServerState(EMMRCServerStateIdle, 0);

					}

				break;

				case EMMRCAdaptationToServerResourceTimeout:

				default:

					{

					//jjpy TODO: What if the preemption request failed?!

					// That will be specified/implemented during the integration with the resource manager

					//we remove the request in process from the queue

					iMMRCServerInfo->PopAndRemoveFirstAllocatedResourceContext();

					}

				} // end switch(aResult)

			} //end case EMMRCServerStateWaitPreemptionResponse

		break;

		case EMMRCServerStateWaitResourceResponseFromAdaptation: // here we process the response

			{

			switch(aResult)

				{

				case EMMRCAdaptationToServerResourceComplete:

					{

					CMMRCServerSession* serverSessionAllocatedResource = iMMRCServerInfo->PopFirstAllocatedResourceContext();

					if( serverSessionAllocatedResource ) //If some previously some context has allocated a resource

						{

					 	//check if same context, if not it might be an error

					 	TAudioContextId contextId = aServerSession.ContextId( );

					 	TAudioContextId contextIdAllocatedResource = serverSessionAllocatedResource->ContextId( );

					#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

							RDebug::Print(_L("contextId          = %d"),  contextId.Id());

							RDebug::Print(_L("contextIdAllocatedResource = %d"),  contextIdAllocatedResource.Id());

					#endif

						MLogicalChain* logicalChainNew = aServerSession.LogicalChainRequested();

						MLogicalChain* logicalChainOld = aServerSession.LogicalChainLastCommited();

						TAudioState audioStateNew = logicalChainNew->StreamState ( );

					 	if(contextId != contextIdAllocatedResource)

					 		{

					 		//it is ok if the rule said process always

							MLogicalChain* logicalChainUsingResource = serverSessionAllocatedResource->LogicalChainLastCommited();

							TAudioState audioStateAllocatedResource = logicalChainUsingResource->StreamState();

							TAudioState audioStateNew = logicalChainNew->StreamState ( );

							TMMRCRule rule = DecisionRule(audioStateAllocatedResource, audioStateNew);

					 		if( rule != EAlwaysProcess )

					 			{

					 			//not possible in theory... this is an error

							#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

									RDebug::Print(_L("!!!!CMMRCServerController::AdaptationRequestAcknowledgment - contextId allocating a resource and new request different. Should be the same!"),  iMMRCServerInfo->AllocatedResourceContextsCount());

							#endif				 		

					 			}

					 		}

					 	else //same context here, so check if the resource has been deallocated

					 		{

						 	// in case of stop etc. remove from in process request

						 	//now check the reason

							TAudioState audioStateOld = EUninitialized;

							if(logicalChainOld)

								{

								audioStateOld = logicalChainOld->StreamState();

								}

							TReason reason = ActionReason(audioStateOld, audioStateNew);

							if (reason == ELoad)

								{

								iARNNotificationObject->Cancel();

								iMMRCServerInfo->PopAndRemovePausedContext(contextId);

								}

							else if (reason == EUnload)

								{

								iARNNotificationObject->Initialize();

								iMMRCServerInfo->PopAndRemoveFirstAllocatedResourceContextByContextId(contextId);			

								}

					 		}

					 	}

					else //no in process request locking a resource

						{

						MLogicalChain* logicalChainNew = aServerSession.LogicalChainRequested();

						MLogicalChain* logicalChainOld = aServerSession.LogicalChainLastCommited();

						TAudioState audioStateNew = logicalChainNew->StreamState ( );

						TAudioState audioStateOld = EUninitialized;

						if(logicalChainOld)

							{

							audioStateOld = logicalChainOld->StreamState();

							}

						TReason reason = ActionReason(audioStateOld, audioStateNew);

						if( reason == ELoad ||

			 					reason == EPrimeReason ||

			 					reason == EActivate )

			 					{

			 					TRAP(err, iMMRCServerInfo->PushAllocatedResourceContextL( aServerSession ));

			 					DP1(DLERR,"EPushAllocatedResourceContextFailed %d", err);

								__ASSERT_DEBUG(err == KErrNone, Panic(EPushAllocatedResourceContextFailed));

			 					}					

						}

					iMMRCServerInfo->SwitchServerState(EMMRCServerStateIdle, 0);

					}

				break;

	 			case EMMRCAdaptationToServerResourceTimeout:

	 			default:

	 				{

					//Just switch the state

					iMMRCServerInfo->SwitchServerState(EMMRCServerStateIdle, 0);

					}

	 			break;

	 			} //end switch switch(aResult)

	 		} // end case EMMRCServerStateWaitResourceResponseFromAdaptation

	 	break;

		case EMMRCServerStateIdle: //not possible....

	 	default:

 	 	break;

	 	}

	TRAP(err, ProcessNextRequestL());

	DP1(DLERR,"EProcessNextRequestLeft %d", err);

	__ASSERT_DEBUG(err == KErrNone, Panic(EProcessNextRequestLeft));

	DP_OUT();

	}

/*

 * 

 */

void CMMRCServerController::NotifyPausedClientsResourceUnallocated()

	{

 	DP_CONTEXT(----> CMMRCServerController::NotifyClientsResourceUnallocated *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CMMRCServerSession* serverSession  = iMMRCServerInfo->PopAndRemoveFirstPausedContext( );

	while( serverSession )

		{

		serverSession->NotifyClientResourceUnallocated();

		serverSession  = iMMRCServerInfo->PopAndRemoveFirstPausedContext( );

		}

	DP_OUT();

	}

/*

 * 

 */

void CMMRCServerController::CloseSessionByContextId(TInt32 aContextId)

	{

 	DP_CONTEXT(----> CMMRCServerController::CloseSessionByContextId *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	while( iMMRCServerInfo->PopAndRemoveFirstAllocatedResourceContextByContextId( aContextId ) ){}

	while( iMMRCServerInfo->PopAndRemoveFirstRequestByContextId( aContextId ) ){}

	while( iMMRCServerInfo->PopAndRemovePausedContext( aContextId ) ){}

	while( iMMRCServerInfo->PopAndRemoveFirstAPRContextByContextId( aContextId ) ){}

	TUint64 contextId;

	TMMRCServerState serverState;

	iMMRCServerInfo->ServerState(serverState, contextId);

	if( contextId == aContextId)

		{

		iMMRCServerInfo->SwitchServerState(EMMRCServerStateIdle, 0);

		}

#ifdef SYMBIAN_MULTIMEDIA_ENABLE_LOGGING	

	RDebug::Print(_L("size of message queue    = %d"),  iMMRCServerInfo->RequestsCount());

	RDebug::Print(_L("size of inprocess queue = %d"),  iMMRCServerInfo->AllocatedResourceContextsCount());

	RDebug::Print(_L("size of paused queue = %d"),  iMMRCServerInfo->AllocatedPausedContextsCount());

	RDebug::Print(_L("size of APR queue  = %d"),  iMMRCServerInfo->AllocatedAPRContextsCount());

#endif

	DP_OUT();

	}

/*

 *

 */

void CMMRCServerController::ServerState(TMMRCServerState& aServerState, TUint64& aContextId) const

	{

	iMMRCServerInfo->ServerState(aServerState, aContextId);

	}

/**

*/

TInt CMMRCServerController::EnqueueRequestForAPRL(CMMRCServerSession& aServerSession)

	{

	DP_CONTEXT(----> CMMRCServerController::EnqueueRequestForAPRL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	//add the request to the queue

	TInt err = KErrNone;

	//if already there, should return KErrAlreadyExists

	if (iMMRCServerInfo->IsOnAPRList(aServerSession.ContextId()))

		{

		err = KErrAlreadyExists;

		}

	else

		{

		iMMRCServerInfo->PushAPRContextL(aServerSession);

		}	

	DP0_RET(err, "err=%d");

	}

/**

*/

TInt CMMRCServerController::RemoveRequestForAPR(CMMRCServerSession& aServerSession)

	{

	DP_CONTEXT(----> CMMRCServerController::RemoveRequestForAPR *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	TInt32 iContextId = aServerSession.ContextId();

	TBool iIsOnAPRList = iMMRCServerInfo->IsOnAPRList(iContextId);

	if(iIsOnAPRList)

		{

		// Its possible that the remove request has occured whilst clients are being notified that the resource is available

		// Check if a notification sequence is currently under way

		if ( iARNNotificationObject->IsActive() )

			{

			// Iterate through each paused client 

			for ( TInt index = 0 ; index < iMMRCServerInfo->AllocatedPausedContextsCount() ; index++ )

				{

				// Find the client that has requested removal in the list

				TAudioContextId id = iMMRCServerInfo->PausedContextByIndex(index)->ContextId();

				if ( aServerSession.ContextId() == id )

					{

					// Object has already received a notification

					if ( index < iARNNotificationObject->iIndex )

						{

						// decrement the notification objects list index to account for the item that will be removed from the queue

						--iARNNotificationObject->iIndex;

						}

					// no action needs to be taken if 

					// index >= iMMRCServerInfo.iIndex

					break;

					}

				}

			}

		iMMRCServerInfo->PopAndRemoveFirstAPRContextByContextId(iContextId);

		iMMRCServerInfo->PopAndRemovePausedContext(iContextId); //removing this session from the list of paused too.

		}

	else

		{

		err = KErrCancel;

		}

	DP0_RET(err, "err=%d");

	}

/**

*/

TInt CMMRCServerController::WillResumePlay()

	{

	DP_CONTEXT(----> CMMRCServerController::WillResumePlay *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	iARNNotificationObject->Cancel();

	DP0_RET(err, "err=%d");

	}

//From CActive

/**

 * Constructor.

 */

CARNNotificationObject::CARNNotificationObject(const TInt aPriority)

:CActive(aPriority)

	{

	TRACE_CREATE();

	DP_CONTEXT(----> CARNNotificationObject::CARNNotificationObject *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	}

/**

 * Destructor.

 */

CARNNotificationObject::~CARNNotificationObject()

	{

	DP_CONTEXT(----> CARNNotificationObject::~CARNNotificationObject *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	Cancel();

	iTimer.Close();

	delete iMMRCServerInfo;

	DP_OUT();

	}

/**

 	CARNNotificationObject::ConstructL

 	Symbian 2nd phase constructor can leave.

 */

void CARNNotificationObject::ConstructL(CMMRCServerInfo& aMMRCServerInfo)

	{

	DP_CONTEXT(----> CARNNotificationObject::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iMMRCServerInfo = &aMMRCServerInfo; 

	CActiveScheduler::Add(this);

	User::LeaveIfError(iTimer.CreateLocal());

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CARNNotificationObject::NewL

// ---------------------------------------------------------------------------

CARNNotificationObject* CARNNotificationObject::NewL(const TInt aPriority, CMMRCServerInfo& aMMRCServerInfo)

	{

	DP_STATIC_CONTEXT(----> CARNNotificationObject::NewL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CARNNotificationObject* self = new(ELeave)CARNNotificationObject(aPriority);

	CleanupStack::PushL(self);

	self->ConstructL(aMMRCServerInfo);

	CleanupStack::Pop(self);

	DP0_RET(self, "0x%x");

	} 

// ---------------------------------------------------------------------------

// CARNNotificationObject::RunL

// ---------------------------------------------------------------------------

void CARNNotificationObject::RunL()

	{

	DP_CONTEXT(CARNNotificationObject::RunL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	#if defined(_DEBUG) && defined(__WINS__) 

	const TTimeIntervalMicroSeconds32 KTimer = 1.8*1000000; // 1.8 seconds

	#else

	const TTimeIntervalMicroSeconds32 KTimer = 800000; // 0.8 seconds

	#endif

	TInt numPausedContext = iMMRCServerInfo->AllocatedPausedContextsCount();

	// The list may have been modified whilst the AO was asleep, need to check that:

	// 1) iIndex is still in range

	// 2) the object at that location should still receive a notification

	if ( (iIndex > -1) && (iIndex < numPausedContext) )

		{

		CMMRCServerSession* mmrcSession = iMMRCServerInfo->PausedContextByIndex(iIndex);

		TAudioContextId id = mmrcSession->ContextId( );

		TBool isOnAPRList = iMMRCServerInfo->IsOnAPRList(id);

		if(isOnAPRList)

			{

			mmrcSession->NotifyClientResourceUnallocated();

			}

		for(TInt aux = iIndex + 1; aux < numPausedContext ; aux++)

			{

			mmrcSession = iMMRCServerInfo->PausedContextByIndex(aux);

			id = mmrcSession->ContextId( );

			isOnAPRList = iMMRCServerInfo->IsOnAPRList(id);

			if(isOnAPRList)

				{

				iIndex = aux;		

				After(KTimer);

				break;

				}

			}

		}

	else

		{

		iIndex = 0;

		}

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CARNNotificationObject::After

// ---------------------------------------------------------------------------

void CARNNotificationObject::After(TTimeIntervalMicroSeconds32 aInterval)

	{

	DP_CONTEXT(CARNNotificationObject::After *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	Cancel();

	iTimer.After(iStatus,aInterval);

	SetActive();

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CARNNotificationObject::Initialize

// ---------------------------------------------------------------------------

void CARNNotificationObject::Initialize()

	{

	DP_CONTEXT(CARNNotificationObject::Initialize *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	#if defined(_DEBUG) && defined(__WINS__)

	const TTimeIntervalMicroSeconds32 KTimer = 1.8*1000000; // 1.8 seconds

	#else

	const TTimeIntervalMicroSeconds32 KTimer = 800000; // 0.8 seconds

	#endif

	TInt numPausedContext = iMMRCServerInfo->AllocatedPausedContextsCount();

	iIndex = 0;

	CMMRCServerSession* mmrcSession = NULL;

	if(numPausedContext) // don't bother if zero.

		{

		for(TInt i(0); i<numPausedContext ; ++i)

			{

			mmrcSession = iMMRCServerInfo->PausedContextByIndex(i);

			TAudioContextId id = mmrcSession->ContextId( );

			TBool isOnAPRList = iMMRCServerInfo->IsOnAPRList(id);

			if(isOnAPRList)

				{

				iIndex = i;

				After(KTimer);

				break;

				}

			}

		}

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CMMRCServer::DoCancel

// ---------------------------------------------------------------------------

void CARNNotificationObject::DoCancel()

	{

	DP_CONTEXT(CARNNotificationObject::DoCancel *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iTimer.Cancel();

	DP_OUT();

	}

void CMMRCServerController::Panic(TMMRCServerControllerPanicCodes aCode)

	{

	User::Panic(KMMRCServerControllerPanicCategory, aCode);

	}	

//EOF