/*

* 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:   Server-side session implementation

*

*/

#include <e32std.h>

#include <e32svr.h>

#include <s32mem.h>  // for stream classes

#include "TelephonyAudioRoutingServerSession.h"

const TInt KMaxNumberOfOutputs = 100; 

// ============================ MEMBER FUNCTIONS ===============================

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

// CTelephonyAudioRoutingServerSession::CTelephonyAudioRoutingServerSession

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CTelephonyAudioRoutingServerSession::CTelephonyAudioRoutingServerSession(

	TInt aSessionId)

    :iSessionId(aSessionId), 

    iMessageArray()

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::CTelephonyAudioRoutingServerSession "),this);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());	

	}

// Destructor

CTelephonyAudioRoutingServerSession::~CTelephonyAudioRoutingServerSession()

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::~CTelephonyAudioRoutingServerSession "),this);

    if	(&Server() != NULL)

		{

		Server().RemoveSession(iSessionId);

		}

	iSessionAvailableOutputs.Close();

	iMessageArray.Close();

	}

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

// CTelephonyAudioRoutingServerSession::Server

// Creates the server.

// (other items were commented in a header).

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

//

CTelephonyAudioRoutingServer& CTelephonyAudioRoutingServerSession::Server()

	{

	return *static_cast<CTelephonyAudioRoutingServer*>(const_cast<CServer2*>(CSession2::Server()));

	}

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

// CTelephonyAudioRoutingServerSession::ServiceError

// Handle an error from ServiceL

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::ServiceError(

	const RMessage2& aMessage,

	TInt aError)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::ServiceError - %d "), aError);

	PanicClient (aMessage, EPanicIllegalFunction); 

	}

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

// CTelephonyAudioRoutingServerSession::ServiceL

// Handles the servicing of a client request that has been passed to the server.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::ServiceL (

	const RMessage2& aMessage)

	{

    switch (aMessage.Function())

		{

		case ETelAudRtngServDoSetOutput:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServDoSetOutput "),this);

			DoSetOutputL(aMessage);

			break;

		case ETelAudRtngServNotifyIfOutputChanged:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServNotifyIfOutputChanged "),this);

			NotifyIfOutputChangedL(aMessage);

			break;

		case ETelAudRtngServNotifyIfAvailOutputsChanged:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServNotifyIfAvailOutputsChanged "),this);

			NotifyIfAvailOutputsChangedL(aMessage);

			break;

		case ETelAudRtngServGetNoOutputs:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServGetNoOutputs "),this);

			GetNoOfAvailableOutputs(aMessage);

			break;

		case ETelAudRtngServGetAvailableOutputs:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServGetAvailableOutputs "),this);

			GetAvailableOutputsL(aMessage);

			break;

		case ETelAudRtngServMonitorOutputChange:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServMonitorOutputChange "),this);

			MonitorOutputChangeL(aMessage);

			break;

		case ETelAudRtngServSetPolicySessionId:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServSetPolicySessionId "),this);

			SetPolicySessionId(aMessage);

			break;

		case ETelAudRtngServOutputChangeComplete:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServOutputChangeComplete "),this);

			OutputChangeCompleteL(aMessage);

			break;

		case ETelAudRtngDoAvailableOutputsChanged:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngDoAvailableOutputsChanged "),this);

			DoAvailableOutputsChangedL(aMessage);

			break;

		case ETelAudRtngServCancelRequest:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServCancelRequest "),this);

			CancelRequestL(aMessage);

			break;

		case ETelAudRtngServInitialize:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServInitialize "),this);

			InitializeL(aMessage);

			break;

		case ETelAudRtngServOutputChangedByPolicy:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServOutputChangedByPolicy "),this);

			OutputChangedL(aMessage);

			break;

		case ETelAudRtngServGetDefaultValues:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - ETelAudRtngServGetDefaultValues "),this);

			GetDefaultValuesL(aMessage);

			break;

		default:

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL - default !! "),this);

			PanicClient (aMessage, EPanicIllegalFunction);

		}

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::ServiceL EXIT"), this);		

	}

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

// CTelephonyAudioRoutingServerSession::InitializeL

// Session initialization.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::InitializeL(

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::IntitializeL enter"),this);	

	iConnected = ETrue;

	Server().AddSession();

	aMessage.Complete(KErrNone);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::IntitializeL exit"),this);

	}

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

// CTelephonyAudioRoutingServerSession::CancelRequestL

// Cancel the outstanding request.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::CancelRequestL(

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::CancelRequestL"),this);	

	TTelAudRtngServRqst req;

	req = (TTelAudRtngServRqst) aMessage.Int1();

	TPckgBuf<TInt> count;

	aMessage.ReadL( 0, count);

	req = (TTelAudRtngServRqst)count();

	aMessage.Complete(KErrNone);

	TInt messageCount = iMessageArray.Count();

	TInt messageIndex = 0;

	if(messageCount > 0)

		{

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

			{

			if(iMessageArray[i].Function()== req)

				{

				messageIndex=i;

				break;

				}

			}

		iMessageArray[messageIndex].Complete(KErrCancel);

		iMessageArray.Remove(messageIndex);

		}

	}

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

// CTelephonyAudioRoutingServerSession::DoSetOutputL 

// Send a request to audio policy to set audio output.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::DoSetOutputL (

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::DoSetOutputL "),this);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());	

	iMessageArray.AppendL(aMessage);

	Server().DoSetOutputL(iSessionId,aMessage);

    }

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

// CTelephonyAudioRoutingServerSession::NotifyIfOutputChangedL 

// Add a message to message queue. Complete the message when output changes

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::NotifyIfOutputChangedL (

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::NotifyIfOutputChangedL "),this);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());		

    iMessageArray.AppendL(aMessage);

	}

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

// CTelephonyAudioRoutingServerSession::NotifyIfAvailOutputsChangedL

// Add a message to message queue. Complete the message when available audio 

// outputs change

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::NotifyIfAvailOutputsChangedL (

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::NotifyIfAvailOutputsChangedL "),this);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());			

    iMessageArray.AppendL(aMessage);

	}

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

// CTelephonyAudioRoutingServerSession::SetPolicySessionId

// Set the policy session Id.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::SetPolicySessionId(

	const RMessage2& aMessage)

	{

	if(!iPolicyFlag)

		{

		Server().SetPolicySessionId(iSessionId);

		iPolicyFlag = ETrue;

		}

	aMessage.Complete(KErrNone);

	}

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

// CTelephonyAudioRoutingServerSession::OutputChangeCompleteL

// Used by policy session to indicate that the SetOutput request is complete.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::OutputChangeCompleteL(

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::OutputChangeCompleteL "),this);

	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

	aMessage.ReadL( 0, xPackage);		

   	CTelephonyAudioRouting::TAudioOutput audioOutput = xPackage();

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeComplete: AudioOutput = %d"), audioOutput);      	

 	TPckgBuf<TInt> errPkg;

  	aMessage.ReadL(1, errPkg);

   	TInt err = errPkg();	

  	if (Server().CurrentAudioOutput() != CTelephonyAudioRouting::ENone)

	{

		Server().PreviousAudioOutput() = Server().CurrentAudioOutput();

		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeComplete: iPreviousAudioOutput set to: %d"), Server().PreviousAudioOutput());	

	}

	Server().CurrentAudioOutput() = audioOutput; 	

   	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeCompleteL: Server will be sent audioOutput = %d"), audioOutput);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::OutputChangeCompleteL: previousAudioOutput = %d"), Server().PreviousAudioOutput());   	

	aMessage.Complete(KErrNone);

	Server().SetOutputCompleteL(audioOutput, err); 		

	}

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

// CTelephonyAudioRoutingServerSession::MonitorOutputChangeL

// Used by policy session to listen to any SetOutput request from other sessions.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::MonitorOutputChangeL (

	const RMessage2& aMessage)

	{

		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::MonitorOutputChangeL "),this);

		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Appending aMessage to iMessageArray. Current count = %d "),iMessageArray.Count());

		TRAPD(err, iMessageArray.AppendL(aMessage));

		if (err != KErrNone)

		{

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t MonitorOutputChangeL ERROR: %d "),err);	

			PanicClient (aMessage, EPanicIllegalFunction); 	

		}	

	}

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

// CTelephonyAudioRoutingServerSession::GetNoOfAvailableOutputs

// Returns the number of available outputs to client-side session.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::GetNoOfAvailableOutputs (

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::GetNoOfAvailableOutputs"),this);

	TPckgBuf<TInt> xPackage;

	xPackage() = (Server().AvailableOutputs()).Count();

	TInt res = aMessage.Write(0, xPackage);	

    if (res != KErrNone)

    	{

		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t GetNoOfAvailableOutputs WRITE ERROR: %d"),res);

    	PanicClient(aMessage, EPanicIllegalFunction);

    	}

    else   

 		aMessage.Complete(KErrNone);

	}

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

// CTelephonyAudioRoutingServerSession::GetAvailableOutputsL

// Returns the available audio outputs to client-side session.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::GetAvailableOutputsL (

	const RMessage2& aMessage)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::GetAvailableOutputsL "),this);

	TInt KBufExpandSize8 = 8;//two TInts

	CBufFlat* dataCopyBuffer = CBufFlat::NewL(KBufExpandSize8);

	CleanupStack::PushL(dataCopyBuffer);

	RBufWriteStream stream;

	stream.Open(*dataCopyBuffer);

	CleanupClosePushL(stream);

	// Write out server's available outputs to caller:

	CTelephonyAudioRouting::TAudioOutput output;

	TInt count = (Server().AvailableOutputs()).Count();

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

		{

		output = ( Server().AvailableOutputs() )[i];

		stream.WriteInt32L(output);

		}

	aMessage.WriteL(0, dataCopyBuffer->Ptr(0));

	stream.Close();

	CleanupStack::PopAndDestroy(2); // dataCopyBuffer, stream

	aMessage.Complete(KErrNone);

	}

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

// CTelephonyAudioRoutingServerSession::DoAvailableOutputsChangedL

// Notify the client-side session that available outputs have changed.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::DoAvailableOutputsChangedL (

	const RMessage2& aMessage)

{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::DoAvailableOutputsChangedL"),this);

	TInt err(KErrNone);

	TBool validData(ETrue);

	TPckgBuf<TInt> count;

	TRAP(err,aMessage.ReadL( 0, count));

	if (err != KErrNone)

	{

		TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(1) ERROR: %d "),err);	

		PanicClient (aMessage, EPanicIllegalFunction); 

		return;		

	}

	if ((count() <0) || (count() > KMaxNumberOfOutputs))

	{	

		validData = EFalse;	

		iSessionAvailableOutputs.Reset();		

	}

	if (validData)

	{

		HBufC8* buf = HBufC8::NewLC(count()*sizeof(CTelephonyAudioRouting::TAudioOutput));	

		TPtr8 ptr = buf->Des();

		TRAP(err,aMessage.ReadL(1, ptr ));

		if (err != KErrNone)

		{

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(2) ERROR: %d "),err);	

			PanicClient (aMessage, EPanicIllegalFunction); 

			return;		

		}

		RDesReadStream stream(ptr);

		CleanupClosePushL(stream);

		iSessionAvailableOutputs.Reset();

		TInt element(0);

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

		{

	   		TRAP(err, element = stream.ReadInt16L());

			if (err != KErrNone)

			{

				TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(3) ERROR: %d "),err);	

				PanicClient (aMessage, EPanicIllegalFunction); 

				return;	

			}	   	

			err = iSessionAvailableOutputs.Append((CTelephonyAudioRouting::TAudioOutput)element);

			if (err)

			{

				TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChangedL(4) ERROR: %d "),err);			

				iSessionAvailableOutputs.Reset();

				PanicClient (aMessage, EPanicIllegalFunction); 

				return;

			}

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t DoAvailableOutputsChanged: Avail Outputs to be sent to server: iSessionAvailableOutputs[i] = %d "),iSessionAvailableOutputs[i]);			

		} // end For

		stream.Close();

		CleanupStack::PopAndDestroy(2); // buf, stream

	} // end if

	aMessage.Complete(KErrNone);

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t [%x]DoAvailableOutputsChangedL: calling Server::AvailableOutputsChanged"),this);	

	Server().AvailableOutputsChangedL(iSessionAvailableOutputs.Array());	

}

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

// CTelephonyAudioRoutingServerSession::SetOutputComplete

// Notifies the client-side session that the SetOutput request is complete.

// (other items were commented in a header).

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

//

void CTelephonyAudioRoutingServerSession::SetOutputComplete(

	CTelephonyAudioRouting::TAudioOutput aOutput,

	TInt aError,

	TBool aShowNote)

	{

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession[%x]::SetOutputComplete "),this);

	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> xPackage;

	xPackage() = aOutput;

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::SetOutputComplete: iPreviousAudioOutput Write out: %d"), Server().PreviousAudioOutput());		

	TPckgBuf<CTelephonyAudioRouting::TAudioOutput> yPackage;

	yPackage() = Server().PreviousAudioOutput();	

	TPckgBuf<TInt> errorPackage;

	errorPackage() = aError;

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingServerSession::SetOutputComplete: ShowNote Val to pass to client: %d"), aShowNote);	

	TPckgBuf<TBool> showNotePackage;

	showNotePackage() = aShowNote;	

	TInt messageCount = iMessageArray.Count();

	TInt messageIndex = -1;

	TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t iMessageArrayCount = %d "),iMessageArray.Count());	

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

		{

		if(iMessageArray[i].Function()== ETelAudRtngServDoSetOutput)

			{

				messageIndex = i;

				break;

			}

		}		

	if (messageIndex != -1)

		{

			TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t Current Index = %d "), messageIndex);	

			TInt res = iMessageArray[messageIndex].Write(0, xPackage);

			TInt res2 = iMessageArray[messageIndex].Write(1, yPackage);

			TInt res3 = iMessageArray[messageIndex].Write(2, errorPackage);	

			TInt res4 = iMessageArray[messageIndex].Write(3, showNotePackage);								

			if ( (res != KErrNone) || (res2 != KErrNone) || (res3 != KErrNone) || (res4 != KErrNone))

    			{	

    				PanicClient(iMessageArray[messageIndex], EPanicIllegalFunction);

    			}