/*
* Copyright (c) 2006 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:   TelephonyAudioRoutingServer implementation
*
*/

 

#include <e32svr.h>
#include <e32math.h>
#include <data_caging_path_literals.hrh>
#include <barsc.h>
#include <barsread.h>
#include "TelephonyAudioRoutingServer.h"
#include "TelephonyAudioRoutingServerSession.h"
#include "TelephonyAudioRoutingClientServer.h"


void PanicClient(
	const RMessage2& aMessage,
	TTelephonyAudioRoutingPanic aPanic)
	{
	_LIT(KPanic,"TelephonyAudioRoutingServer");
	aMessage.Panic(KPanic,aPanic);
	}
	
// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// StartThreadL
// Start the TelephonyAudioRoutingServer thread.
// Returns: TInt: error code
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CTelephonyAudioRoutingServer::StartThreadL(
	TAny* /*aParms*/)  
/**
Thread entry-point function.
The TServerStart objects is passed as the thread parameter
**/
	{
		
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::StartThreadL "));
	
	TInt err = KErrNone;
	__UHEAP_MARK;
	
	CTrapCleanup* cleanup = CTrapCleanup::New();

	if (!cleanup)
	err = KErrNoMemory;
	
	if (!err)
		{
		CActiveScheduler* sched=NULL;
		sched=new(ELeave) CActiveScheduler;
		CActiveScheduler::Install(sched);
		CTelephonyAudioRoutingServer* server = NULL;
		TRAPD(err,server = CTelephonyAudioRoutingServer::NewL()); 		
	
		if(!err)
		{
		// Sync with the client and enter the active scheduler
			RThread::Rendezvous(KErrNone);
			sched->Start();
		}
	
		delete server;
		delete sched;	
		}
	
	delete cleanup;

	__UHEAP_MARKEND;
	return err;
	}
	
	
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::CTelephonyAudioRoutingServer
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CTelephonyAudioRoutingServer::CTelephonyAudioRoutingServer()
	:CServer2(0,EUnsharableSessions),
	iSessionIdsInUse()
	{
	iSessionCount = 0;
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::ConstructL()
	{
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::ConstructL "));
	TName name(RThread().Name());
	StartL(name);
	
	// Set default values
   	iCurrentAudioOutput = CTelephonyAudioRouting::ENotActive;
   	iPreviousAudioOutput = CTelephonyAudioRouting::ENotActive;
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CTelephonyAudioRoutingServer* CTelephonyAudioRoutingServer::NewL()
	{
	CTelephonyAudioRoutingServer* self=new(ELeave) CTelephonyAudioRoutingServer();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

// Destructor
CTelephonyAudioRoutingServer::~CTelephonyAudioRoutingServer()
    {
 	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::~CTelephonyAudioRoutingServer "));   
	iSessionIdsInUse.Close();
	iSetOutputRequests.Close();
	iAvailableOutputs.Close();
	}
	

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::NewSessionL
// Create a new client session
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSession2* CTelephonyAudioRoutingServer::NewSessionL(
	const TVersion&,
	const RMessage2& /*aMessage*/) const
	{
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::NewSessionL "));	
		 
	CTelephonyAudioRoutingServer& nonConstThis = *const_cast<CTelephonyAudioRoutingServer*>(this);
	const TInt sessionId = nonConstThis.IdentifyAndAllocateNextFreeSessionIdL();
	return new (ELeave) CTelephonyAudioRoutingServerSession(sessionId);
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::DoSetOutputL 
// Notify the policy session about a request to change output.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::DoSetOutputL (
	TInt aSessionId, 
	const RMessage2& aMessage)
	{
		
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::DoSetOutputL "));
	
	//Check for multimedia capability:
	RThread clientThread;
	aMessage.ClientL(clientThread);
	RProcess clientProcess;
	User::LeaveIfError(clientThread.Process(clientProcess));

	TProcessId clientProcessID(clientProcess.Id());

	
	TBool clientHasCapabilities = clientProcess.HasCapability(ECapabilityMultimediaDD, KSuppressPlatSecDiagnostic);

	if (!clientHasCapabilities)
		{
		TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::DoSetOutputL ERROR: Client failed Capability Check"));			
		aMessage.Complete(KErrPermissionDenied);
		return;
		}
	
	clientThread.Close();
	clientProcess.Close();
	
	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;
	aMessage.ReadL( 0, xPackage);
	
    CTelephonyAudioRouting::TAudioOutput response = xPackage();
	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::DoSetOutputL Audio Output Value to set on the sessions: %d"), response); 	
	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> yPackage; // space for previous output
	aMessage.ReadL( 1, yPackage);
	
	TPckgBuf<TInt> zPackage; // space for err
	aMessage.ReadL( 2, zPackage);		

	TPckgBuf<TBool> showNotePkg;
  	aMessage.ReadL(3, showNotePkg);
   	iShowNoteMode = showNotePkg();	
	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::DoSetOutputL ShowNoteMode Value Sent to server = %d"), iShowNoteMode);    	
   	
	iSetOutputRequests.AppendL(aSessionId);
	
	// Verify requested audio change exists in available outputs (unless is ENone or ENotActive)	
	if ( (response != CTelephonyAudioRouting::ENone) && (response != CTelephonyAudioRouting::ENotActive))
	{
		TBool found = IsAvailableOutput(response);
		if (!found)
		{
			TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::DoSetOutputL: ERROR, Requested output not in availableOutputs!"));	
			SetOutputCompleteL(response, KErrPermissionDenied);
			return;  
		}	
	}

    iSessionIter.SetToFirst();

	CTelephonyAudioRoutingServerSession* serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);

	while (serverSession != NULL)
		{
		if(serverSession->SessionId() == iPolicySessionId)
			{
			serverSession->OutputChangeRequested(response);
			break;
			}
		serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
		}
    
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::IdentifyAndAllocateNextFreeSessionIdL
// Assign a unique session Id to a new session
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTelephonyAudioRoutingServer::IdentifyAndAllocateNextFreeSessionIdL()
	{
	
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::IdentifyAndAllocateNextFreeSessionIdL "));

	// The aim of this method is to locate a session identifier which is not already
	// in use....
	TInt sessionId = 0;
	TInt errorOrIndex;
	
	// Only 256 (KMaxNumberOfSessions) are allowed
	const TInt numberOfUsedSessionIds = iSessionIdsInUse.Count();
	if (numberOfUsedSessionIds > KMaxNumberOfSessions)
		{
		User::LeaveIfError(KErrDied);
		}

	// Session Id's indexing begins at 1, not 0
	for (TInt count = 1; count < KMaxNumberOfSessions+1; count++)
	{
		sessionId = count;
		errorOrIndex = iSessionIdsInUse.FindInOrder(sessionId);

		// If sessionId=count not currently being used, assign it.
		// Save the session in the array of allocated ids. We use InsertInOrder
		// since it effectively allows a binary search when trying to find
		// free ids:
		if (errorOrIndex == KErrNotFound)
			{
			errorOrIndex = iSessionIdsInUse.InsertInOrder(sessionId);
			if (errorOrIndex < 0)  // Handle error 
				{
				User::LeaveIfError(KErrDied);
				}
			break;
			}

		// Prevent value returned by RArray<T>::FindInOrder from being propagated
		// to the client side in response to a RSessionBase::Connect() request.
		if ((errorOrIndex != KErrNotFound) && (errorOrIndex < 0))
		{
			User::LeaveIfError(KErrDied);
		}

	} // End for

	return sessionId;

	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::AddSession
// Add a new Session.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::AddSession()
	{
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::AddSession "));
	iSessionCount++;
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::RemoveSession
// Remove an existing session.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::RemoveSession(
	TInt aSessionId)
	{
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::RemoveSession"));
	FreeSessionId(aSessionId);
	iSessionCount--;
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::FreeSessionId
// Free the session Id or a delated session for re-use.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::FreeSessionId(
	TInt aSessionId)
	{
		
	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::FreeSessionId: ID: %d"), aSessionId);

	const TInt indexOrError = iSessionIdsInUse.FindInOrder(aSessionId);

	if	(indexOrError >= 0)
		{
		// This session id can now be reused...
		iSessionIdsInUse.Remove(indexOrError);
		}
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::SetPolicySessionId
// Set the Id of the policy session.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::SetPolicySessionId(
	TInt aSessionId)
	{
		iPolicySessionId = aSessionId;
	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::AvailableOutputsChangedL
// Used by policy session to indicated to all other sessions that available outputs have changed.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::AvailableOutputsChangedL(
	const TArray<CTelephonyAudioRouting::TAudioOutput>& aOutputs)
	{
		
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::AvailableOutputsChangedL "));
	
	iAvailableOutputs.Reset();
	TInt count = aOutputs.Count();
	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t AvailableOutputsChangedL: Count = %d "),count);
	for(TInt i = 0; i < count; i++)
	{
		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t AvailableOutputsChangedL: aOutputs[i] = %d "),aOutputs[i]);
		iAvailableOutputs.AppendL(aOutputs[i]);		
	}
			
	iSessionIter.SetToFirst();

	CTelephonyAudioRoutingServerSession* serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
	while (serverSession != NULL)
		{
		if(serverSession->SessionId() != iPolicySessionId)
			serverSession->AvailableOutputsChanged(aOutputs);
		serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
		}

	}

// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::SetOutputComplete
// Used by policy session to indicate the session that requested a SetOutput() that
// the request is complete, all the other session get OutputChanged() notification
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::SetOutputCompleteL( 
	CTelephonyAudioRouting::TAudioOutput aOutput,
	TInt aError)
	{
	
	CTelephonyAudioRouting::TAudioOutput output = aOutput;	
	
	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::SetOutputComplete called with: = %d"), output);
	
	TInt requestCount = iSetOutputRequests.Count();

	if(requestCount>0)
		{
	
		TInt sessionToAlert = iSetOutputRequests[0];
		iSessionIter.SetToFirst();
	
		CTelephonyAudioRoutingServerSession* serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
		while (serverSession != NULL)
			{
			if(serverSession->SessionId() != iPolicySessionId)
				{
									
				if (serverSession->SessionId() == sessionToAlert )
					{
					TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::SetOutputComplete: Calling serverSession::SetOutputComplete with showNote: %d"), iShowNoteMode);					
					serverSession->SetOutputComplete(output, aError, iShowNoteMode);					
					}
				else
					{
					if (aError == KErrNone)  
						{
						serverSession->OutputChanged(output, iShowNoteMode);	
						}
					
					}
				}
				
			serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
			}
		
		for(TInt i=0;i<iSetOutputRequests.Count()-1;i++)
			{
			iSetOutputRequests[i] = iSetOutputRequests[i+1];
			}
		iSetOutputRequests.Remove(iSetOutputRequests.Count()-1);
		}
	}
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::OutputChanged
// Used by policy session to notify all sessions that the output has changed (from the policy side)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingServer::OutputChanged( 
	CTelephonyAudioRouting::TAudioOutput aOutput)
	{
	
	CTelephonyAudioRouting::TAudioOutput output = aOutput;	
	
	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::OutputChanged called with: = %d"), output);

	iSessionIter.SetToFirst();
	
	CTelephonyAudioRoutingServerSession* serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
	while (serverSession != NULL)
		{
		if(serverSession->SessionId() != iPolicySessionId)
			{
				// Always send ETrue if outputChanged initiated by Policy:
				iShowNoteMode = ETrue;
				serverSession->OutputChanged(output, iShowNoteMode);	
				
			}				
			serverSession = static_cast<CTelephonyAudioRoutingServerSession*>(iSessionIter++);
		}	
	}
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::IsAvailableOutput
// Method used to determine if requested audio output is one of the
// audio outputs in the available output array.
// -----------------------------------------------------------------------------
//
TBool CTelephonyAudioRoutingServer::IsAvailableOutput( 
	CTelephonyAudioRouting::TAudioOutput aOutput)
	{
	TELAUDRTNG_RDEBUG(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::IsAvailableOutput "));
	
	TBool found = EFalse;
	CTelephonyAudioRouting::TAudioOutput arrayElement;
    TInt count = iAvailableOutputs.Count();

    for(TInt i=0;i<count;i++)
    {
    	arrayElement = iAvailableOutputs[i];
    	if (aOutput == arrayElement)
    	{
     		found = ETrue;
    		break;   		
    	}

    }

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServer::IsAvailableOutput: Found? = %d "), found);
	return found;
		
	}
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::CurrentAudioOutput
// Accessor method returns iCurrentAudioOutput to caller.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
CTelephonyAudioRouting::TAudioOutput& CTelephonyAudioRoutingServer::CurrentAudioOutput()
	{
		return iCurrentAudioOutput;
	}
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::ShowNoteMode
// Accessor method returns iShowNoteMode to caller.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
TBool& CTelephonyAudioRoutingServer::ShowNoteMode()
	{
		return iShowNoteMode;
	}
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::SetShowNoteMode
// Accessor method allows caller to set iShowNoteMode.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
void CTelephonyAudioRoutingServer::SetShowNoteMode(TBool aShowNoteMode)
	{
		iShowNoteMode = aShowNoteMode;
	}
	
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::PreviousAudioOutput
// Accessor method returns iPreviousAudioOutput to caller.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
CTelephonyAudioRouting::TAudioOutput& CTelephonyAudioRoutingServer::PreviousAudioOutput()
	{
		return iPreviousAudioOutput;
	}	
	
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingServer::AvailableOutputs
// Accessor method returns iAvailableOutputs to caller.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//	
RArray<CTelephonyAudioRouting::TAudioOutput>& CTelephonyAudioRoutingServer::AvailableOutputs()
	{
		return iAvailableOutputs;
	}					
			
	
//End of File