/*

* Copyright (c) 2005 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 <badesca.h>

#include "mceservercore.h"

#include "mcecssessionimplementation.h"

#include "mcecsserver.h"

#include "mcecssession.h"

#include "mcecomaudiocodec.h"

#include "mcecomvideocodec.h"

#include "mcecssessionreceiver.h"

#include "mcecssubsessionreceiver.h"

#include "mcecssubsession.h"

#include "mcecsserveritc.h"

#include "mcesipmanager.h"

#include "mcemediamanager.h"

#include "mcesrvlogs.h"

#include "mceserial.h"

#include "mcemessagedispatcher.h"

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

// CMceCsSession::NewL

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

//

CMceCsSession* CMceCsSession::NewL( CMceServerCore& aServerCore )

	{

    CMceCsSession* self = CMceCsSession::NewLC( aServerCore );

    CleanupStack::Pop(self);

    return self;

	}

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

// CMceCsSession::NewLC

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

//

CMceCsSession* CMceCsSession::NewLC( CMceServerCore& aServerCore )

	{

    CMceCsSession* self = new (ELeave) CMceCsSession( aServerCore );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

	}

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

// CMceCsSession::CMceCsSession

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

//

CMceCsSession::CMceCsSession (CMceServerCore& aServerCore)

: iServerCore (aServerCore)

	{

    iServerCore.IncrementSessions();

	}

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

// CMceCsSession::ConstructL

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

//

void CMceCsSession::ConstructL ()

	{

    MCESRV_DEBUG("CMceCsSession::ConstructL, Entry");

	iITC = CMceCsServerITC::NewL();

    iImpl = CMceCsSessionImplementation::NewL( iServerCore.Manager(), this );

    MCESRV_DEBUG("CMceCsSession::ConstructL, Exit");

	}

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

// CMceCsSession::CreateSubSessionReceiverL

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

//

CMceCsSubSessionReceiver* CMceCsSession::CreateSubSessionReceiverL ()

	{

    return CMceCsSubSessionReceiver::NewL( ITC() );

	}

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

// CMceCsSession::Implementation

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

//

CMceCsSessionImplementation& CMceCsSession::Implementation()

    {

    return *iImpl;

    }

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

// CMceCsSession::~CMceCsSession

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

//

CMceCsSession::~CMceCsSession()

	{

    MCESRV_DEBUG("CMceCsSession::~CMceCsSession, Entry");

    iServerCore.DecrementSessions();

    iServerCore.Manager().UnRegisterClient( *this );

    if ( iImpl )

        {

        iImpl->RemoveAllSubSessions();

        delete iImpl;

        iImpl = NULL;

        }

    iReceivers.ResetAndDestroy();

    iReceivers.Close();

    delete iITC;

    MCESRV_DEBUG("MCE Server session deleted");

    MCESRV_DEBUG("CMceCsSession::~CMceCsSession, Exit");

	}

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

// CMceCsSession::ServerCore

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

//

CMceServerCore& CMceCsSession::ServerCore ()

    {

    return iServerCore;

    }

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

// CMceCsSession::ServiceL

// From CSession

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

//

void CMceCsSession::ServiceL( const RMessage2& aMessage )

	{

	TInt error = KErrNone;

    MCESRV_DEBUG("CMceCsSession::ServiceL, Entry");

#ifdef PLAT_SEC_TEST  

	iITC->Complete(aMessage, KErrNone);

	return;

#endif

	TInt function = iITC->Function( aMessage );

	TMceIds ids = iITC->ReadMCEIdsL( aMessage );

    TRAP( error, DoServiceL( function, aMessage ) );

    if ( error != KErrNone )

	    {

        MCESRV_DEBUG_DVALUE("ServiceL: Error occured in session/subsession. ERROR", error );

	    iITC->WriteL(aMessage, ids);

	    if ( function == EMceItcClientReadyToReceive ||

	         function == EMceItcClientCancelReceive )

		    {

            MCESRV_DEBUG("ServiceL: Error occured in ClientReadyToReceiveL -> Stop receive" );

		   	error = KErrCompletion;

		    }

	    }

    MCESRV_DEBUG("CMceCsSession::ServiceL, Exit");

	User::LeaveIfError( error );

	}

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

// CMceCsSession::DoServiceL

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

//

void CMceCsSession::DoServiceL( TInt aFunction, const RMessage2& aMessage )

    {

    MCESRV_DEBUG("CMceCsSession::ServiceL, Entry");

    MCESRV_DEBUG_EVENT("ITC", aFunction);

    TMceIds ids = iITC->ReadMCEIdsL( aMessage );

    MCESRV_DEBUG_IDS("IDS", ids );

    if ( ids.IsAppUIDId() )

    	{

   	 	MCESRV_DEBUG("passing to manager receiver");

   	 	switch (aFunction)

			{

        	case EMceItcSetAppUid:

        		{

            	SetClientUidL(ids, aMessage);

            	break; 

        		}

        	case EMceItcCreateSession:

        		{

            	CreateSubSessionL(ids, aMessage);

            	break; 

        		}

			case EMceItcDeleteSession:

        		{

            	DeleteSubSessionL(ids, aMessage);

            	break; 

        		}

        	case EMceItcClientCancelReceive:

        		{

            	CancelClientReceiveL( ids );

        		break;

        		}

        	case EMceItcClientReadyToReceive: // Asynchronous. Do not complete yet.

        		{

            	ClientReadyToReceiveL(ids, aMessage);

            	return; 

        		}

        	case EMceItcGetSupportedAudioCodecs:

        	case EMceItcGetSupportedVideoCodecs:

        		{

        		SupportedCodecsL(aFunction, aMessage);

        		break;

        		}

			case EMceItcDisplaysAvailable:

			case EMceItcCameraInfo:

			case EMceItcCamerasAvailable:

            case EMceItcTranscode:

            case EMceItcTranscodeWithSession:

            case EMceItcCancelTranscode:

            case EMceItcFileInfo:

			case EMceItcMaxVolume:

			case EMceItcMaxGain:

			    {

			    MediaServiceL( ids, (TMceItcFunctions)aFunction, aMessage );

			    break;

			    }

	        case EMceItcReceive:

	        	{

	            ReceiveL (ids, aMessage);

	            break;		    

	        	} 

			case EMceItcSetDefaultHeaders:

                {

                StoreDefaultHeadersL( aMessage );

                break;

                }

			case EMceItcGetDefaultHeaders:

			    {

			    DefaultHeadersL( aMessage );

			    break;

			    }

            default:

            	{

            	#ifndef ALLOW_NOT_SUPPORTED_ITC

            	User::Leave(KErrNotSupported);

            	#endif

            	}

			}

			iITC->WriteL(aMessage, ids);

	        iITC->Complete(aMessage, KErrNone);

	    }

	else

    	{

   	 	MCESRV_DEBUG("passing to session receiver");

        CallSubSessionL(ids, aFunction, aMessage);

    	}

    MCESRV_DEBUG("CMceCsSession::ServiceL, Exit");

    }

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

// CMceCsSession::Uid

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

//

TUid CMceCsSession::Uid()

	{

	return iClientUid;

	}

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

// CMceCsSession::SetClientUidL

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

//

void CMceCsSession::SetClientUidL (TMceIds& aIds, const RMessage2& /*aMessage*/)

	{

    MCESRV_DEBUG("CMceCsSession::SetClientUidL, Entry");

	TInt id = (TInt) aIds.iAppUID;

	iClientUid = TUid::Uid(id);

	ServerCore().Manager().RegisterClientL( *this );

    MCESRV_DEBUG("CMceCsSession::SetClientUidL, Exit");

	}

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

// CMceCsSession::ClientReadyToReceiveL

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

//

void CMceCsSession::ClientReadyToReceiveL (TMceIds& aIds, const RMessage2& aMessage)

	{

    MCESRV_DEBUG("CMceCsSession::ClientReadyToReceiveL, Entry");

    ReceiverL( aIds )->ClientReadyToReceiveL (aMessage);

    MCESRV_DEBUG("CMceCsSession::ClientReadyToReceiveL, Exit");

	}

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

// CMceCsSession::CancelClientReceiveL

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

//

void CMceCsSession::CancelClientReceiveL ( TMceIds& aIds )

	{

    MCESRV_DEBUG("CMceCsSession::CancelClientReceiveL, Entry");

    ReceiverL( aIds )->CancelClientReceiveL();

    MCESRV_DEBUG("CMceCsSession::CancelClientReceiveL, Exit");

	}

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

// CMceCsSession::SupportedCodecsL

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

//

void CMceCsSession::SupportedCodecsL( TInt aFunction, const RMessage2& aMessage )

	{

    MCESRV_DEBUG("CMceCsSession::SupportedCodecsL, Entry");

    HBufC8* codecs = NULL;

	if ( aFunction == EMceItcGetSupportedAudioCodecs )

	    {

        codecs = iImpl->SupportedAudioCodecsL();

	    }

    else

        {

        codecs = iImpl->SupportedVideoCodecsL();

        }

    CleanupStack::PushL( codecs );

    iITC->WriteL( aMessage, *codecs, EMceItcArgContext);

    CleanupStack::PopAndDestroy( codecs );

    MCESRV_DEBUG("CMceCsSession::SupportedCodecsL, Exit");

	}

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

// CMceCsSession::MediaServiceL

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

//

void CMceCsSession::MediaServiceL( TMceIds& aIds, TMceItcFunctions aFunction, 

                                const RMessage2& aMessage )

    {

    MCESRV_DEBUG("CMceCsSession::MediaServiceL, Entry");

    TMceMessageDispatcher<CMceCsSessionImplementation> dispatcher( *iImpl, *iITC );

    dispatcher.DispatchL( aIds, aFunction, aMessage );

    MCESRV_DEBUG("CMceCsSubSession::MediaServiceL, Exit");

    }

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

// CMceCsSession::CallSubSessionL

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

//

void CMceCsSession::CallSubSessionL (TMceIds& aIds, TInt aFunction,

                                     const RMessage2& aMessage)

    {

	CMceCsSubSession* subSession = iImpl->SubSessionL( aIds.iSessionID );

    subSession->ServiceL( aIds, (TMceItcFunctions)aFunction, aMessage);

    }

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

// CMceCsSession::CreateSubSessionL

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

//

void CMceCsSession::CreateSubSessionL( TMceIds& aIds, const RMessage2& aMessage )

    {

    MCESRV_DEBUG("CMceCsSession::CreateSubSessionL, Entry");

    HBufC8* encodedMessage = NULL;

    encodedMessage = ITC().ReadLC( aMessage, EMceItcArgContext );

    CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray();

    CleanupStack::PushL( msgParams );

    msgParams->DecodeL( *encodedMessage );

    CDesC8Array* params = msgParams->iArray;

    CleanupStack::PushL( params );

    iImpl->CreateSubSessionL( aIds, *params );

    CleanupStack::PopAndDestroy( params );

    CleanupStack::PopAndDestroy( msgParams );

    CleanupStack::PopAndDestroy( encodedMessage );

    iITC->WriteL(aMessage, aIds);

    MCESRV_DEBUG("CMceCsSession::CreateSubSessionL, Exit");

    }

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

// CMceCsSession::DeleteSubSessionL

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

//

void CMceCsSession::DeleteSubSessionL( TMceIds& /*aIds*/, const RMessage2& aMessage )

    {

    MCESRV_DEBUG("CMceCsSession::DeleteSubSessionL, Entry");

    TUint32 sessionId = iITC->ReadTUint32L(aMessage, EMceItcArgId );

    iImpl->RemoveSubSessionL( sessionId );

    MCESRV_DEBUG("CMceCsSession::DeleteSubSessionL, Exit");

    }

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

// CMceCsSession::Receiver

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

//

CMceCsSessionReceiver* CMceCsSession::ReceiverL( TMceIds& aIds )

    {

	TMceManagerType type = aIds.iManagerType;

    CMceCsSessionReceiver* receiver = NULL;

    TInt index = 0;

    while( !receiver && index < iReceivers.Count() )

        {

        if ( iReceivers[ index ]->Type() == type )

            {

            receiver = iReceivers[ index ];

            }

        index++;            

        }

    if (!receiver )

        {

        receiver = CMceCsSessionReceiver::NewLC( type, *iITC );

        iReceivers.AppendL( receiver );

        CleanupStack::Pop( receiver );

        }

    return receiver;

    }

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

// CMceCsSession::ITC

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

//

CMceCsServerITC& CMceCsSession::ITC()

    {

    return *iITC;

    }

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

// CMceCsSession::ReceiveL

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

//

void CMceCsSession::ReceiveL( TMceIds& aIds, const RMessage2& aMessage )

	{

    MCESRV_DEBUG("CMceCsSession::ReceiveL, Entry");

    ReceiverL( aIds )->ReceiveL( aMessage );

    MCESRV_DEBUG("CMceCsSession::ReceiveL, Exit");

    }

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

// CMceCsSession::StoreDefaultHeadersL

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

//

void CMceCsSession::StoreDefaultHeadersL( const RMessage2& aMessage )

    {

    HBufC8* encodedMsg = ITC().ReadLC( aMessage, EMceItcArgContext );

    User::LeaveIfNull( encodedMsg );

    TMceComFactory factory;

    CMceMsgArray<TMceComFactory>* msgArray = 

        new (ELeave) CMceMsgArray<TMceComFactory>( factory );

    CleanupStack::PushL( msgArray );

    msgArray->DecodeL( *encodedMsg );

    CDesC8Array* methods = static_cast< CMceMsgTextArray* >

        ( msgArray->iArray[0] )->iArray;

    CleanupStack::PushL( methods );

    CDesC8Array* headers = static_cast< CMceMsgTextArray* >

        ( msgArray->iArray[1] )->iArray;

    CleanupStack::PushL( headers );

    iImpl->StoreDefaultHeadersL( *methods, headers );

    CleanupStack::Pop( headers );

    CleanupStack::PopAndDestroy( methods );

    CleanupStack::PopAndDestroy( msgArray );

    CleanupStack::PopAndDestroy( encodedMsg );