// Copyright (c) 2001-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 "MmfAudioPolicy.h"

#include "MmfAudioPolicySession.h"	

#include "MmfAudioPolicyServer.h"

#include "MdaHwInfo.h"	

#include "MmfAudioPolicyRequest.h"

/**

*@internalTechnology

*@return if a client owns or wish to own audio resource

*/

inline TBool IsActiveState(TMMFAudioPolicyState aState)

	{

	return (aState < EMMFStateStopped || aState==EMMFStateNotified || aState==EMMFStatePlayDualTone);

	}

CAudioPolicy::~CAudioPolicy()

	{

	delete iMdaHwInfo;

	delete iAudioPolicyRequestArray;

	}

void CAudioPolicy::ConstructL()

	{

	// Create dynamic array for sessions list

	iAudioPolicyRequestArray = new(ELeave) CPolicyReqPtrArray(CAudioPolicy::EGranularity);

	iMdaHwInfo = CMdaHwInfo::NewL();

	}

EXPORT_C CAudioPolicy* CAudioPolicy::NewL(CMMFAudioPolicyServer* aAudioPolicyServer)

	{	

	CAudioPolicy* self = new(ELeave)CAudioPolicy(aAudioPolicyServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return(self);

	}

CAudioPolicy::CAudioPolicy(CMMFAudioPolicyServer* aAudioPolicyServer) :

	iAudioPolicyServer(aAudioPolicyServer),

	iNotifiedSessionId(KErrNotFound),

	iSessionIdAwaitingForDevsound(KErrNotFound),

	iStopHandledFromSessId(KErrNotFound)

	{

	}

void CAudioPolicy::MakeRequest(CMMFAudioPolicyRequest* aAudioPolicyRequest)

	{

// since we have a FIFO q, then remove request and re-add it.

	RemoveFromList(aAudioPolicyRequest->PolicySessionId(), EFalse); 

	if (iStopHandledFromSessId==aAudioPolicyRequest->PolicySessionId())

		{

		iStopHandledFromSessId=KErrNotFound;

		}

// Process Request by looking at priorities, preferences, special states...

	TPolicyResponse responseValue = ProcessRequest(aAudioPolicyRequest);

#if defined(ALLOW_POLICY_DEBUG)

	RDebug::Print(_L("Sess ID=%d, Priority=%d"),aAudioPolicyRequest->PolicySessionId(),aAudioPolicyRequest->Priority());

#endif	

	switch (responseValue)

		{

		case EDenied:

			{

			TMMFAudioPolicyEvent responseEvent(TMMFAudioPolicyEvent::EMMFAudioPolicyPriorityTooLow, KErrInUse,EMMFStateWaitingForResource);

			// the client won't be notified until he has request so, so we can set its state anyway

			aAudioPolicyRequest->SetState( EMMFStateWaitingForResource ); 

			iAudioPolicyServer->SendEventToClient(aAudioPolicyRequest->PolicySessionId(), responseEvent);

			}

			break;

		case EProceed:

			{

			iAudioPolicyServer->StopNotificationTimer();

			TMMFAudioPolicyEvent responseEvent(TMMFAudioPolicyEvent::EMMFAudioPolicyNoEvent, KErrNone, aAudioPolicyRequest->State());

			iAudioPolicyServer->SendEventToClient(aAudioPolicyRequest->PolicySessionId(), responseEvent);

			}

			break;

		case EStopThenProceed:

			{

			iAudioPolicyServer->StopNotificationTimer(); 

			iSessionIdAwaitingForDevsound=aAudioPolicyRequest->PolicySessionId();

			// we have to wait for devsound to stop client(s), then notify that one

			}

			break;

		case EResume:

		case EMix:

		default:

			ASSERT(EFalse);

		}

	TRAPD(err, iAudioPolicyRequestArray->AppendL(aAudioPolicyRequest) );

	__ASSERT_ALWAYS(err==KErrNone, Panic(EMMFAudioPolicyRequestArrayOverflow) ); // we reserved space, so shouldn't hit this

	}

TPolicyResponse CAudioPolicy::ProcessRequest(CMMFAudioPolicyRequest* aAudioPolicyRequest)

	{

	// If there is no other item on list, return with proceed

	if (iAudioPolicyRequestArray->Count()==0)

		{

		return EProceed;

		}

	TPolicyResponse responseValue(EProceed);

	TInt requestPriority = aAudioPolicyRequest->Priority();

	TBool requestCaps = aAudioPolicyRequest->Capabilities();

	// Iterate through list and compare priorities:

	// QUEST: state checking shall be done as well?

	for (TInt index = 0; index < iAudioPolicyRequestArray->Count(); index++)

		{

		CMMFAudioPolicyRequest& currentReq=*(*iAudioPolicyRequestArray)[index];

		if (!IsActiveState(currentReq.State()) ) // this request is inactive

			{

			continue;

			}

			// If there's even one on the list w/ a higher priority deny request and leave:

		if (currentReq.Capabilities() > requestCaps)

			{

			responseValue = EDenied;

			break;

			}

		else if(currentReq.Capabilities() == requestCaps) 

			{

			if(currentReq.Priority() >= requestPriority)

				{

				responseValue = EDenied;

				break;

				}

			}

		if (currentReq.State()==EMMFStateWaitingForResource || currentReq.State()==EMMFStatePreempted)

			{

			continue;

			}

		// we need to stop active client since new request is of higher priority

		TMMFAudioPolicyEvent freezeEvent(TMMFAudioPolicyEvent::EMMFAudioPolicyPriorityTooLow, KErrInUse, EMMFStatePaused);

#if defined(ALLOW_POLICY_DEBUG)	

		RDebug::Print(_L("Sess ID=%d, State=%d Has been preempted"),currentReq.PolicySessionId(),currentReq.State());

#endif			

		currentReq.SetState( EMMFStatePreempted );

		currentReq.SetEventFlag(EFalse);

		iAudioPolicyServer->SendEventToClient(currentReq.PolicySessionId(), freezeEvent);

		responseValue = EStopThenProceed;

		}

	return responseValue;

	}

void CAudioPolicy::ModifyEntry(TInt aPolicySessionId,const TMMFAudioPolicyState aNewState)

	{

	CMMFAudioPolicyRequest* sessionEntry=FindPolicyRequestById(aPolicySessionId);

#if defined(ALLOW_POLICY_DEBUG)	

	RDebug::Print(_L("Sess ID=%d, Old State=%d New State=%d"),aPolicySessionId,sessionEntry?sessionEntry->State():-1, aNewState);

#endif	

	// some client took over resource, so update its state and cancel timer

	if (IsActiveState(aNewState))

		{

		if (sessionEntry)

			{

			sessionEntry->SetState(aNewState);	

			sessionEntry->SetEventFlag(EFalse);

			}

		iAudioPolicyServer->StopNotificationTimer();

		iNotifiedSessionId	=KErrNotFound;

		ASSERT(iSessionIdAwaitingForDevsound==KErrNotFound); // we shouldn't have a client waiting to be notified

		if (iStopHandledFromSessId==aPolicySessionId)

			{

			iStopHandledFromSessId=KErrNotFound;

			}

		return;

		}

	if (iNotifiedSessionId==aPolicySessionId) // if client that was notified, then stop timer.

		{

		iAudioPolicyServer->StopNotificationTimer();

		}

	if (sessionEntry==NULL) // to cope with erroneous behaviour of devsound

		{

		return;

		}

	// we have update from the client, if we have other clients waiting we should notify them

	if ( (aNewState == EMMFStatePaused || (aNewState == EMMFStateStopped && iStopHandledFromSessId!=aPolicySessionId) )

			&& sessionEntry->State()!=EMMFStateStopped && sessionEntry->State()!=EMMFStateWaitingForResource)

		{

		if (aNewState == EMMFStateStopped) // to eliminate duplicate stop events

			{

			iStopHandledFromSessId=aPolicySessionId;

			}

		if (sessionEntry->State()==EMMFStatePreempted)

			{

			sessionEntry->SetState(EMMFStateWaitingForResource);

			}

		if (iSessionIdAwaitingForDevsound==aPolicySessionId)

			{

			iSessionIdAwaitingForDevsound=KErrNotFound;

			}

		if (aNewState == EMMFStatePaused || aNewState == EMMFStateStopped) // devsound should free, so notify waiting client

			{

			if (iSessionIdAwaitingForDevsound!=KErrNotFound) // we have a client waiting for Devsound, so notify it

				{

				NotifySessionWithTimeout(iSessionIdAwaitingForDevsound, TMMFAudioPolicyEvent::EMMFAudioPolicyNoEvent);

				iSessionIdAwaitingForDevsound=KErrNotFound;

				}

			else if (!iAudioPolicyServer->IsTimerActive()) // do not try to notify if we're still waiting for response

				{

				const TInt sessionIdToNotify = CheckSessionToNotify();

				if(sessionIdToNotify != KErrNotFound)

					{

					// set the state as notified

					NotifySessionWithTimeout(sessionIdToNotify, TMMFAudioPolicyEvent::EMMFAudioPolicyResourceNotification);

					}				

				}

			}

		}

	// we update state to passive only if the client hasn't been stopped by us, so as not loose its waiting indication

	if (sessionEntry->State()!=EMMFStateWaitingForResource)

		{

		sessionEntry->SetState(aNewState);

		}

	}

void CAudioPolicy::NotifySessionWithTimeout(TInt aPolicySessionId, TMMFAudioPolicyEvent::TAudioPolicyEventType aEvent)

	{

	CMMFAudioPolicyRequest* sessionEntry=FindPolicyRequestById(aPolicySessionId);

	ASSERT(sessionEntry);

#if defined(ALLOW_POLICY_DEBUG)	

	RDebug::Print(_L("Sending timed not. ID=%d, State=%d Event=%d"),aPolicySessionId,sessionEntry->State(), aEvent);

#endif

	const TMMFAudioPolicyEvent eventToSend(aEvent, KErrNone, sessionEntry->State());

	sessionEntry->SetEventFlag(ETrue);

	iAudioPolicyServer->StartNotificationTimer();

	iNotifiedSessionId 	= aPolicySessionId;

	iAudioPolicyServer->SendEventToClient(aPolicySessionId, eventToSend);

	}

void CAudioPolicy::RemoveFromList(TInt aPolicySessionId, TBool aAllowTimerRestart)

	{

	if (aPolicySessionId==KErrNotFound)

		{

		return;

		}

	for (TInt index = iAudioPolicyRequestArray->Count(); index-- ;)

		{

		// Find correct entry to remove	

		if ( (*iAudioPolicyRequestArray)[index]->PolicySessionId() == aPolicySessionId)

			{

			if (iSessionIdAwaitingForDevsound==aPolicySessionId)

				{

				iSessionIdAwaitingForDevsound=KErrNotFound;

				}			

			if (iNotifiedSessionId==aPolicySessionId && iAudioPolicyServer->IsTimerActive()) 

				{

				iNotifiedSessionId=KErrNotFound;

				// the session we were waiting for disconnected so try to immediately notify another one

				iAudioPolicyServer->StopNotificationTimer();

				if (iAudioPolicyRequestArray->Count() > 1 && aAllowTimerRestart)

					{

					iAudioPolicyServer->StartNotificationTimer(ETrue);

					}

				}			

			else if(!iAudioPolicyServer->IsTimerActive())

				{

				if (iAudioPolicyRequestArray->Count() > 1 && aAllowTimerRestart)

					{

					iAudioPolicyServer->StartNotificationTimer(ETrue);

					}

				}

			iAudioPolicyRequestArray->Delete(index);

			return;

			}

		}

	}

void CAudioPolicy::HandlePreferences(CMMFAudioPolicyRequest* /*aAudioPolicyRequest*/, TInt /*aPref*/, TPolicyResponse& /*aResponse*/)

	{

	}

// this is weird, but devsound 

// does Stop() if a client is denied access to resource

// then calls this routine to indicate that resource became available

void CAudioPolicy::LaunchRequest(TInt aSessionId)

	{

	ASSERT(iSessionIdAwaitingForDevsound!=aSessionId);

	ModifyEntry(aSessionId, EMMFStateStopped);

	}

void CAudioPolicy::ReserveClientNumL(TInt aNum)

	{

	iAudioPolicyRequestArray->SetReserveL(aNum);

	}

/**

@internalTechnology

This function raises a panic

@param	aError

		one of the several panics codes that may be raised by this dll

@panic	EMMFAudioPolicyRequestArrayOverflow is raised when policyrequest array is full

*/

GLDEF_C void Panic(TMMFAudioPolicyPanicCodes aPanicCode)

	{

	User::Panic(KMMFAudioPolicyPanicCategory, aPanicCode);

	}

// checks based on the session ,Is the session is registered for Notification 

TBool CAudioPolicy::IsRegisteredNotification(TInt aSessionId) const

	{

	TUid event;

 	for (TInt index = 0; index < iAudioPolicyRequestArray->Count(); index++)

 		{

 		if((*iAudioPolicyRequestArray)[index]->PolicySessionId() == aSessionId)

 			{

 			event = (*iAudioPolicyRequestArray)[index]->NotificationEvent();

 			if (event  == KMMFEventCategoryAudioResourceAvailable)

 				{

 				// only when the client is registered for KMMFEventCategoryAudioResourceAvailable event

 				return ETrue; 

 				}

 			break;	

 			} 

 		} 

 	return EFalse;

	}

// get the next highest priority of the client to notify 	

TInt CAudioPolicy::CheckSessionToNotify()

	{

	TInt nextHighestPriority= -100;

	TInt sessionToNotify = KErrNotFound;

	// get the max priority and set the Index

	for (TInt attempt=2; attempt-- && sessionToNotify==KErrNotFound;)

		{

		for (TInt index = 0; index < iAudioPolicyRequestArray->Count(); ++index)

	 		{

	 		CMMFAudioPolicyRequest& currentReq=*(*iAudioPolicyRequestArray)[index];

	 		if((nextHighestPriority <= currentReq.Priority())

	 					&& (currentReq.NotificationEvent() == KMMFEventCategoryAudioResourceAvailable) 

	 					&& (!currentReq.IsEventNotified())

	 					&& currentReq.State()==EMMFStateWaitingForResource)

	 			{

	 			nextHighestPriority = currentReq.Priority();

	 			sessionToNotify = currentReq.PolicySessionId();

	 			}

	 		}

	 	// we tried to notify every session once, so reset flag and try again.

	 	if (sessionToNotify==KErrNotFound)

	 		{

	 		for (TInt i=iAudioPolicyRequestArray->Count(); i--;)

	 			{

	 			(*iAudioPolicyRequestArray)[i]->SetEventFlag(EFalse);

	 			}

	 		}

 		}

  	return sessionToNotify;	

	}

// send the message to the server 

void CAudioPolicy::NotifyNextClient()

	{

	const TInt sessionIdToNotify = CheckSessionToNotify();

#if defined(ALLOW_POLICY_DEBUG)	

	RDebug::Print(_L("Sess ID %d didn't continue within timeout, Next ID=%d"), iNotifiedSessionId, sessionIdToNotify);

#endif	

	iNotifiedSessionId = KErrNotFound;

	if(sessionIdToNotify != KErrNotFound)

		{

		NotifySessionWithTimeout(sessionIdToNotify, TMMFAudioPolicyEvent::EMMFAudioPolicyResourceNotification);

		}	

	}

// Set in the AudiopolicyRequestArray the uid registered

TInt CAudioPolicy::SetNotification(TInt aSessionId, TUid aEventType)

	{

	if (KMMFEventCategoryAudioResourceAvailable!=aEventType)

		{

		return EFalse;

		}

	for (TInt index = iAudioPolicyRequestArray->Count(); index-- ; )

 		{

 		CMMFAudioPolicyRequest& currentReq=*(*iAudioPolicyRequestArray)[index];

 		if(currentReq.PolicySessionId() == aSessionId)

 			{

 			currentReq.SetNotificationEvent(aEventType);

#if defined(ALLOW_POLICY_DEBUG)

			RDebug::Print(_L("Sess ID %d state=%d requested resource notification"), aSessionId, currentReq.State());

#endif			 			 			

 			if (!IsActiveState(currentReq.State()))

 				{

 				currentReq.SetState(EMMFStateWaitingForResource);

 				}

 			return ETrue;	

 			}

 		}

 	return EFalse;

	}

CMMFAudioPolicyRequest* CAudioPolicy::FindPolicyRequestById(TInt aSessionId) const

	{

	for (TInt index = iAudioPolicyRequestArray->Count(); index-- ; )

 		{

 		if((*iAudioPolicyRequestArray)[index]->PolicySessionId() == aSessionId)

 			{

 			return (*iAudioPolicyRequestArray)[index];

 			}

 		}

	return NULL;

	}