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

 #include "MmfBtAudioPolicySession.h"	

 #include "MmfBtAudioPolicyServer.h"

 #include "MdaBtHwInfo.h"	

 #include "MmfBtAudioPolicyRequest.h"

 CAudioPolicy::~CAudioPolicy()

 	{

 	delete iMdaHwInfo;

 	delete iAudioPolicyRequestArray; 		

 	}

 void CAudioPolicy::ConstructL()

 	{

 	// Create dynamic array for sessions list

 	iAudioPolicyRequestArray = new(ELeave)CArrayFixFlat<CMMFAudioPolicyRequest>(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)

 	{

 	}

 void CAudioPolicy::MakeRequest(CMMFAudioPolicyRequest* aAudioPolicyRequest)

 	{

 	//Make sure there is sufficient space in the array to avoid expansion in AppendL() 

 	__ASSERT_ALWAYS(iAudioPolicyRequestArray->Count() < iAudioPolicyServer->PolicySessionCount(), Panic(EMMFAudioPolicyRequestArrayOverflow));

 	TPolicyResponse responseValue; 

 	iSessionToAlert = NULL; // Reset

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

 	responseValue = ProcessRequest(aAudioPolicyRequest);

 		// Finally, check current profile settings (only if not denied thus far):

 		//	CheckAgainstProfiles(aAudioPolicyRequest, responseValue);

 		if (responseValue == EDenied)

 			{

 			SetSessionToAlert(aAudioPolicyRequest->PolicySessionId(),

 							  NULL, TMMFAudioPolicyEvent::EMMFAudioPolicyPriorityTooLow,

 							  aAudioPolicyRequest->State());

 			if(IsRegisteredNotification(aAudioPolicyRequest->PolicySessionId()))

 				{

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

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

 				}

 			}

 	// If a client needs to be notified (either a previous session that was booted off or a new

 	// one that was denied) then send event for that session to the client:

 	// NB KErrInUse, KErrDied OR KErrAccessDenied may be used to indicate this.

 	if (iSessionToAlert != NULL)

 		{

 			//check the session is registered for notification of resource available

 			if(!IsRegisteredNotification(iSessionToAlert))

 				{

 				RemoveFromList(iSessionToAlert);  				

 				}

 			iAudioPolicyEvent.iErrorCode = KErrInUse;

 			iAudioPolicyEvent.iState = aAudioPolicyRequest->State();

 			iAudioPolicyServer->SendEventToClient(iSessionToAlert, iSessionToBeLaunched, iAudioPolicyEvent);

 		}

 		//Resume of a Audio of the notified client ,since it is already in the list 

 		//no need to append and send response back to DevSound for request accepted.

 		if(responseValue == EResume)

 			{

 			iAudioPolicyServer->StopNotificationTimer();

 			iAudioPolicyEvent.iErrorCode = KErrNone;

 			iAudioPolicyEvent.iEventType = TMMFAudioPolicyEvent::EMMFAudioPolicyNoEvent;

 			iAudioPolicyEvent.iState = aAudioPolicyRequest->State();

 			iAudioPolicyServer->SendEventToClient(aAudioPolicyRequest->PolicySessionId(), NULL, iAudioPolicyEvent);	

 			}

 		// Add new policy to list, and send response back to DevSound for request accepted

 	if (responseValue == EProceed)

 		{

 		//no possibility of expansion here as sufficient space for the array is reserved in advance during the creation of the policysession

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

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

 		iAudioPolicyEvent.iErrorCode = KErrNone;

 		iAudioPolicyEvent.iEventType = TMMFAudioPolicyEvent::EMMFAudioPolicyNoEvent;

 		iAudioPolicyEvent.iState = aAudioPolicyRequest->State();

 		iAudioPolicyServer->SendEventToClient(aAudioPolicyRequest->PolicySessionId(), NULL, iAudioPolicyEvent);

 		}

 	if (responseValue == EStopThenProceed)  // place on list, but dev Sound will launch request

 		{

 		//no possibility of expansion here as sufficient space for the array is reserved in advance during the creation of the policysession

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

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

 		}

 	}

 TPolicyResponse CAudioPolicy::ProcessRequest(CMMFAudioPolicyRequest* aAudioPolicyRequest)

 	{

 	TPolicyResponse responseValue(EProceed); 

 	iSessionToAlert = NULL; // Reset

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

 	if (!iAudioPolicyRequestArray->Count()) 

 		return EProceed;

 	// Handle Preferences, if any, otherwise just compare priorities:

 	//	HandlePreferences(aAudioPolicyRequest, preference, responseValue);

 	if(IsNotified())

 		{

 		return EResume;

 		}

 	responseValue = ComparePriorities(aAudioPolicyRequest);

 	return responseValue;

 	}

 void CAudioPolicy::ModifyEntry(TInt aPolicySessionId, CMMFAudioPolicyRequest* aAudioPolicyRequest)

 	{

 	TMMFAudioPolicyState requestState = aAudioPolicyRequest->State();

 	// If state is stopped or paused, remove item from list

 	if ((aAudioPolicyRequest->State() == EMMFStatePaused) || (aAudioPolicyRequest->State() == EMMFStateStopped) || (aAudioPolicyRequest->State() == EMMFStateCompleted))

 		{

 		if(iSessionToBeLaunched == aPolicySessionId)

 			{

 			iSessionToBeLaunched = 0;

 			}

 		if((aAudioPolicyRequest->State() == EMMFStateStopped) && (!iSessionToBeLaunched))

 			{	

 			TInt sessionToNotify = CheckSessionToNotify();

 			if(sessionToNotify)

 				{

 				iAudioPolicyServer->StartNotificationTimer();

 				iAudioPolicyEvent.iErrorCode = KErrNone;

 				iAudioPolicyEvent.iEventType = TMMFAudioPolicyEvent::EMMFAudioPolicyResourceNotification;

 				iAudioPolicyServer->SendEventToClient(sessionToNotify, NULL, iAudioPolicyEvent);

 				}	

 			}

 			if(aAudioPolicyRequest->NotificationEvent() != KMMFEventCategoryAudioResourceAvailable)

 				{

 				RemoveFromList(aPolicySessionId);	

 				return;

 				}

 		}

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

 		{

 			// Find correct entry to replace state	

 			if ( ((*iAudioPolicyRequestArray)[index].PolicySessionId()) == aPolicySessionId)

 				{

 					(*iAudioPolicyRequestArray)[index].SetState(requestState);

 					break;

 				}

 		}  

 	}

 void CAudioPolicy::RemoveFromList(TInt aPolicySessionId)

 	{

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

 		{

 			// Find correct entry to remove	

 			if ( (*iAudioPolicyRequestArray)[index].PolicySessionId() == aPolicySessionId)

 				{

 					iAudioPolicyRequestArray->Delete(index);

 					break;

 				}

 		}  

 	}

 TPolicyResponse CAudioPolicy::ComparePriorities(CMMFAudioPolicyRequest* aAudioPolicyRequest/*, TMMFAudioPolicyEvent& aEvent*/)

 	{

 	TPolicyResponse responseValue(EProceed);

 	TInt requestPriority = aAudioPolicyRequest->Priority();

 	TBool requestCaps = aAudioPolicyRequest->Capabilities();

 	// Iterate through list and compare priorities:

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

 		{

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

 			if ((*iAudioPolicyRequestArray)[index].Capabilities() > requestCaps)

 				{

 				responseValue = EDenied;

 				break;

 				}

 			else if((*iAudioPolicyRequestArray)[index].Capabilities() == requestCaps) 

 				{

 					if((*iAudioPolicyRequestArray)[index].Priority() >= requestPriority)

 					{

 						responseValue = EDenied;

 						break;

 					}

 				}

 			// Otherwise have the one on the list removed:

 				SetSessionToAlert((*iAudioPolicyRequestArray)[index].PolicySessionId(), 

 					aAudioPolicyRequest->PolicySessionId(), TMMFAudioPolicyEvent::EMMFAudioPolicyPriorityTooLow, aAudioPolicyRequest->State());

 				responseValue = EStopThenProceed;

 		}    

 	return responseValue;

 	}

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

 	{

 	}

 void CAudioPolicy::LaunchRequest()

 	{

 	if (iAudioPolicyEventToLaunch.iEventType == TMMFAudioPolicyEvent::EMMFAudioPolicySwitchToIdle)

 		iAudioPolicyServer->LaunchRequest(iSessionToBeLaunched, iAudioPolicyEventToLaunch);

 	}

 // Sets up session information for sending an event on a denied (or killed) request

 void CAudioPolicy::SetSessionToAlert(TInt aSessionToAlert, TInt aSessionToBeLaunched, TMMFAudioPolicyEvent::TAudioPolicyEventType aEventType, TMMFAudioPolicyState aState )

 	{

 	iSessionToAlert = aSessionToAlert;

 	iSessionToBeLaunched = aSessionToBeLaunched;

 	iAudioPolicyEvent.iEventType = aEventType;

 	if (iSessionToBeLaunched != 0)  // When currently playing item needs to be stopped

 		{

 		iAudioPolicyEventToLaunch.iEventType = TMMFAudioPolicyEvent::EMMFAudioPolicySwitchToIdle;

 		iAudioPolicyEventToLaunch.iState = aState;

 		}

 	}

 CArrayFixFlat<CMMFAudioPolicyRequest>* CAudioPolicy::AudioPolicyRequestArray()

 	{

 	return iAudioPolicyRequestArray;

 	}

 /**

 @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)

 	{

 	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;

 	}

 // checks the state,whether any client is already send notification

 TBool CAudioPolicy::IsNotified()

 	{

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

  		{

 		if((*iAudioPolicyRequestArray)[index].State() == EMMFStateNotified)

 			{

 			// In a instance only one client should have the state as EMMFStateNotified

 			return ETrue;

 			}

  		}

  	return EFalse;

 	}

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

 TInt CAudioPolicy::CheckSessionToNotify()

 	{

 	TInt nextHighestPriority= -100;

 	TInt sessionToNotify = 0;

 	TInt notificationIdx = -1;

 	if(IsNotified())

 		{

 		return sessionToNotify;

 		}

 	// get the max priority and set the Index 		

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

  		{

  		if((nextHighestPriority <= (*iAudioPolicyRequestArray)[index].Priority()) && ((*iAudioPolicyRequestArray)[index].NotificationEvent() != KNullUid) && (!(*iAudioPolicyRequestArray)[index].IsEventNotified()))

  			{

  			nextHighestPriority = (*iAudioPolicyRequestArray)[index].Priority();

  			sessionToNotify = (*iAudioPolicyRequestArray)[index].PolicySessionId();

  			notificationIdx = index;

  			}

  		}

  	// set the state as notified	

  	if(notificationIdx != -1)

  		{

  		(*iAudioPolicyRequestArray)[notificationIdx].SetEventFlag(ETrue);	

  		(*iAudioPolicyRequestArray)[notificationIdx].SetState(EMMFStateNotified);	

  		}

   	return sessionToNotify;	

 	}

 // send the message to the server 

 void CAudioPolicy::DoSendNotification()

 	{

 	ResetNotification();

 	TInt sessionToNotify = CheckSessionToNotify();

 	if(sessionToNotify)

 		{

 		iAudioPolicyEvent.iErrorCode = KErrNone;

 		iAudioPolicyEvent.iEventType = TMMFAudioPolicyEvent::EMMFAudioPolicyResourceNotification;

 		iAudioPolicyServer->SendEventToClient(sessionToNotify, NULL, iAudioPolicyEvent);

 		}

 	}

 // Set in the AudiopolicyRequestArray the uid registered

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

 	{

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

  		{

  		if((*iAudioPolicyRequestArray)[index].PolicySessionId() == aSessionId)

  			{

  			(*iAudioPolicyRequestArray)[index].SetNotificationEvent(aEventType);

  			return ETrue;	

  			}

  		}

  	return EFalse;

 	}

 // cancel the state of the message notification to closed 

 void 	CAudioPolicy::ResetNotification()

 	{

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

  		{

 		if((*iAudioPolicyRequestArray)[index].State() == EMMFStateNotified)

 			{

 			(*iAudioPolicyRequestArray)[index].SetState(EMMFStateClosed);

 			}

  		}

  	}