/*

* Copyright (c) 2008 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:  Session command implementation

*

*/

#include "mvtprotocolhandler.h"

#include "cdatasinkproxy.h"

#include "cdatasourceproxy.h"

#include "csessionhandler.h"

#include "ccommserver.h"

#include "ch324confighandler.h"

#include "cvideoconfighandler.h"

#include "caudioconfighandler.h"

#ifdef _DEBUG

#    define __IF_DEBUG(t) {RDebug::t;}

#else

#    define __IF_DEBUG(t)

#endif

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

// TSessionHandler::TSessionHandler

// Constructor.

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

//

TSessionHandler::TSessionHandler(MVtProtocolHandler* aProtocolHandler) : iProtocolHandler(aProtocolHandler)

    {

    __IF_DEBUG(Print(_L("VTProto: TSessionHandler::TSessionHandler<")));	

    __IF_DEBUG(Print(_L("VTProto: TSessionHandler::TSessionHandler>")));	

    }

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

// CSessionCommand::CSessionCommand

// Constructor.

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

//

CSessionCommand::CSessionCommand(TSessionHandler* aSessionHandler) 

  : iSessionHandler(aSessionHandler) 

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::CSessionCommand<")));

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::CSessionCommand>")));

    }

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

// CSessionCommand::~CSessionComman

// Destructor.

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

//

CSessionCommand::~CSessionCommand()

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::~CSessionCommand<")));	

    delete iVideoSource;

    delete iDisplaySink;

    delete iSessionHandler;

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::~CSessionCommand>")));

    }

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

// CSessionCommand::ConnectToProtocolL

// This function can be invoked only in the ESetup state.

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

//

TInt CSessionCommand::ConnectToProtocolL(MCommServer* aComm)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::ConnectToProtocolL")));		

    CCommServer* commServer = static_cast<CCommServer*>(aComm);

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::ConnectToProtocolL commServer %d"), commServer));

    return KErrNone;    

    }

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

// CSessionCommand::DisconnectFromProtocolL

// The Disconnect call is valid only when invoked in the EConnecting, and

// EConnected states.

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

//

TInt CSessionCommand::DisconnectFromProtocolL()

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::DisconnectFromProtocolL")));			

    return KErrNone;

    }

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

// CSessionCommand::ResetProtocolL

// This function is valid only in the ESetup and EInitializing state.

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

//

TInt CSessionCommand::ResetProtocolL()

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::ResetProtocolL")));	

    return KErrNone;

    }

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

// CSessionCommand::InitProtocolL

// This function is valid only in the EIdle state.

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

//

TInt CSessionCommand::InitProtocolL(TVtInitInfo& aInitInfo)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::InitProtocolL")));	

    return KErrNone;

    }

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

// CSessionCommand::AddVideoSinkL

// Allows an application to provide a media sink for rendering an incoming media bitstream in a

// logical channel of communication with the peer.

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

//

TInt CSessionCommand::AddVideoSinkL(const TUint aChannelId, MVTVideoSink& aDataSink)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddVideoSinkL")));	

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddVideoSinkL aChannelId %d"), aChannelId));

    iDisplaySink =CDisplaySinkProxy::NewL(&aDataSink);

    return KErrNone;        

    }

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

// CSessionCommand::AddVideoSourceL

// Allows an application to provide a media source to be associated with a logical channel

// of communication with the peer.

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

//

TInt CSessionCommand::AddVideoSourceL(const TUint aChannelId, MVTVideoSource& aDataSource)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddVideoSourceL")));	

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddVideoSourceL aChannelId %d"), aChannelId));

    iVideoSource = CVideoSourceProxy::NewL(&aDataSource);

    return KErrNone;        

    }

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

// CSessionCommand::AddAudioSourceL

// Allows an application to provide a media source to be associated with a logical channel

// of communication with the peer.

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

//

TInt CSessionCommand::AddAudioSourceL(const TUint aChannelId, MVTAudioSource &aDataSource)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddAudioSourceL")));	

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddAudioSourceL aChannelId %d"), aChannelId));	

    CAudioSourceProxy* audioSourceProxy = static_cast<CAudioSourceProxy*>(&aDataSource);

    return KErrNone;

    }

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

// CSessionCommand::AddAudioSinkL

// Allows an application to provide a media sink for rendering an incoming media bitstream in a

// logical channel of communication with the peer.

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

//

TInt CSessionCommand::AddAudioSinkL(const TUint aChannelId, MVTAudioSink &aDataSink)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddAudioSinkL")));	

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::AddAudioSinkL aChannelId %d"), aChannelId));	

    CAudioSinkProxy* audioSinkProxy = static_cast<CAudioSinkProxy*>(&aDataSink);

    return KErrNone;

    }

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

// CSessionCommand::PauseVideoL

// For an incoming track (MVTVideoSink) this function  pauses sending

// media to the sink (output device) and stops the sink.

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

//

TInt CSessionCommand::PauseVideoL(MVTVideoSource& aTrack)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::PauseVideoL")));		

    return KErrNone;    

    }

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

// CSessionCommand::PauseVideoL

// For an incoming track (MVtVideoSink) this function  pauses sending

// media to the sink (output device) and stops the sink.

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

//

TInt CSessionCommand::PauseVideoL(MVTVideoSink& aTrack) 

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::PauseVideoL")));		

    return KErrNone;     

    }        

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

// CSessionCommand::PauseAudioL

// For an incoming track (MVTAudioSource) this function  pauses sending

// media to the sink (output device) and stops the sink.

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

//

TInt CSessionCommand::PauseAudioL(MVTAudioSource& aTrack)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::PauseAudioL")));		

    CAudioSourceProxy* audioSourceProxy = static_cast<CAudioSourceProxy*>(&aTrack);

    return KErrNone;

    }

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

// CSessionCommand::ResumeVideoL

// Resume a previously paused incoming or outgoing track.

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

//

TInt CSessionCommand::ResumeVideoL(MVTVideoSource& aTrack)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::ResumeVideoL")));		

    return KErrNone;    

    }

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

// CSessionCommand::ResumeVideoL

// Resume a previously paused incoming or outgoing track.

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

//

TInt CSessionCommand::ResumeVideoL(MVTVideoSink& aTrack) 

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::ResumeVideoL")));		

    return KErrNone;     

    } 

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

// CSessionCommand::ResumeAudioL

// Resume a previously paused incoming or outgoing track.

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

//

TInt CSessionCommand::ResumeAudioL(MVTAudioSource& aTrack)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::ResumeAudioL")));		

    CAudioSourceProxy* audioSourceProxy = static_cast<CAudioSourceProxy*>(&aTrack);

    return KErrNone;

    }

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

// CSessionCommand::CancelAllCommandsL

// This API is to allow the user to cancel all pending requests.

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

//

TInt CSessionCommand::CancelAllCommandsL( )

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::CancelAllCommandsL")));	

    return KErrNone;

    }

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

// CSessionCommand::GetProtocolInterfaceL

// This API is to allow for extensibility of the protocol interface.

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

//

TInt CSessionCommand::GetProtocolInterfaceL(TVtConfigType aType, MVtProtocolCommand*& aProtocolCommand)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::GetProtocolInterfaceL<")));		

    TInt commandId = 0;

    if (aType == EVtH324Config)

        {

        CH324ConfigCommand* H324ConfigCommand = new (ELeave)CH324ConfigCommand();

        aProtocolCommand = H324ConfigCommand;

        }

    else if (aType == EVtVideoEncoderConfig)

        {

        CVideoConfigCommand* videoConfigCommand = new (ELeave)CVideoConfigCommand();

        aProtocolCommand = videoConfigCommand;

        }

    else

        {

        ;

        }

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::GetProtocolInterfaceL aType %d, aProtocolCommand %d>"), aType, aProtocolCommand));    

    return commandId;

    }

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

// CSessionCommand::DeleteProtocolInterfaceL

// This APIis to be used to release an interface that was previously obtained using

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

//

TInt CSessionCommand::DeleteProtocolInterfaceL(TVtConfigType aType, MVtProtocolCommand* aProtocolCommand)

    {

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::DeleteProtocolInterfaceL<")));

    TInt commandId = 0;

    if (aType == EVtH324Config)

            {

            CH324ConfigCommand* H324ConfigCommand = static_cast<CH324ConfigCommand*>(aProtocolCommand);

            delete H324ConfigCommand;

            }

        else if (aType == EVtVideoEncoderConfig)

            {

            CVideoConfigCommand* videoConfigCommand = static_cast<CVideoConfigCommand*>(aProtocolCommand);

            delete videoConfigCommand;

            }

        else

            {

            ;

            }

    __IF_DEBUG(Print(_L("VTProto: CSessionCommand::DeleteProtocolInterfaceL aType, aProtocolCommand %d>"), aType, aProtocolCommand));        

    return commandId;

    }

// end of file