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