/*

* Copyright (c) 2004-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:  

*

*/

#include <pv_plugin_interfaces.h>

#include <pv_2way_symbian_interface.h>

#include <pv_2way_h324m_interface.h>

#include <pv_mp4_h263_enc_extension_interface_symbian.h>

#include <pv_audio_output_control_interface.h>

#include <pv_2way_factory.h>

#include "mvtprotocolhandler.h"

#include "cdatasinkproxy.h"

#include "cdatasourceproxy.h"

#include "csessionhandler.h"

#include "ccommserver.h"

#include "ch324confighandler.h"

#include "cvideoconfighandler.h"

#include "caudioconfighandler.h"

#define DEBUG_CFG_BB_LOOPBACK 0

#define DEBUG_CFG_PV_LOOPBACK 0

#ifdef _DEBUG

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

#else

#    define __IF_DEBUG(t)

#endif

const TInt KVtProtoMultiplexingDelay = 150;

const TInt EVtGet324CtrlInterface = 15;

const TInt EVtGetH263EncInterface = 24;

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

// TSessionHandler::TSessionHandler

// Constructor.

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

//

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

    {

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

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

    }

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

// TSessionHandler::CommandCompletedL

// Handle an event that has been generated.

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

//

void TSessionHandler::CommandCompletedL(const CPVCmdResponse& aResponse)

    {

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

    TVtCommandType cmdType = (TVtCommandType)aResponse.GetCmdType();

    TInt cmdId = (TInt)aResponse.GetCmdId();

    TInt cmdResponse = aResponse.GetCmdStatus();

    TVtCommandResponse commandRsp(cmdType, cmdId, cmdResponse);

    iProtocolHandler->HandleSessionCommandEventL(commandRsp);

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

    }

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

// TSessionHandler::HandleInformationalEventL

// Handle an informational event that has been generated.

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

//

void TSessionHandler::HandleInformationalEventL(const CPVAsyncInformationalEvent& aEvent)

    {

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

    const TUint8* buffer = aEvent.GetLocalBuffer();

    TInt eventType = aEvent.GetEventType();

    TVtIndicationEvent vtEvent(eventType, buffer);

    iProtocolHandler->HandleSessionInformationalEventL(vtEvent);

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

    }

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

// TSessionHandler::HandleErrorEventL

// Handle an error event that has been generated.

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

//

void TSessionHandler::HandleErrorEventL(const CPVAsyncErrorEvent& aEvent)

    {

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

    TVtErrorEvent event(aEvent.GetEventType());

    iProtocolHandler->HandleSessionErrorEventL(event);

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

    }

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

// CSessionCommand::CSessionCommand

// Constructor.

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

//

CSessionCommand::CSessionCommand(TSessionHandler* aSessionHandler, MPV2WaySymbianInterface* aPv2Way) 

  : iPv2Way(aPv2Way), 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")));		

    TPVConnectOptions connectOptions;

    connectOptions.iLoopbackMode = PV_LOOPBACK_NONE;

#ifdef _DEBUG

    if ( DEBUG_CFG_BB_LOOPBACK )

        {

        connectOptions.iLoopbackMode = PV_LOOPBACK_COMM;

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

        }

    else if ( DEBUG_CFG_PV_LOOPBACK )

        {

        connectOptions.iLoopbackMode = PV_LOOPBACK_MUX;        

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

        }

    else

        {        

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

        }

#endif

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

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

    return iPv2Way->ConnectL(connectOptions, commServer->iComm);    

    }

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

// 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 iPv2Way->DisconnectL();

    }

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

// CSessionCommand::ResetProtocolL

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

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

//

TInt CSessionCommand::ResetProtocolL()

    {

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

    return iPv2Way->ResetL();

    }

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

// CSessionCommand::InitProtocolL

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

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

//

TInt CSessionCommand::InitProtocolL(TVtInitInfo& aInitInfo)

    {

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

    CPV2WayInitInfo initInfo;

    initInfo.iMultiplexingDelayMs = KVtProtoMultiplexingDelay;

    if (aInitInfo.iAMRWBOn)

        {

        initInfo.iIncomingAudioFormats.

        Append((TDesC8 *)&KVtAudioMIMETypeAMRWBIF2);

        initInfo.iOutgoingAudioFormats.

        Append((TDesC8 *)&KVtAudioMIMETypeAMRWBIF2);

        }

    initInfo.iIncomingAudioFormats.

    Append((TDesC8 *)&KVtAudioMIMETypeAMRIF2);

    initInfo.iOutgoingAudioFormats.

    Append((TDesC8 *)&KVtAudioMIMETypeAMRIF2);

    initInfo.iIncomingVideoFormats.

    Append( (TDesC8 *) &KVtVideoMIMETypeH264 );

    initInfo.iOutgoingVideoFormats.

    Append( (TDesC8 *) &KVtVideoMIMETypeH264 );

    if (!aInitInfo.iDisableMpeg4)

        {

        initInfo.iIncomingVideoFormats.

        Append((TDesC8 *)&KVtVideoMIMETypeM4V);

        initInfo.iOutgoingVideoFormats.

        Append((TDesC8 *)&KVtVideoMIMETypeM4V);

        }

    initInfo.iIncomingVideoFormats.

    Append((TDesC8 *)&KVtVideoMIMETypeH263);

    initInfo.iOutgoingVideoFormats.

    Append((TDesC8 *)&KVtVideoMIMETypeH263);

    return iPv2Way->InitL(initInfo);

    }

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

// 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 iPv2Way->AddDataSinkL(aChannelId, *iDisplaySink);        

    }

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

// 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 iPv2Way->AddDataSourceL(aChannelId, *iVideoSource);        

    }

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

// 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 iPv2Way->AddDataSourceL(aChannelId, *(audioSourceProxy->iAudioSource));

    }

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

// 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 iPv2Way->AddDataSinkL(aChannelId, *(audioSinkProxy->iAudioSink));

    }

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

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

    if (&aTrack == iVideoSource->VideoSource())

        {

        return iPv2Way->PauseL(*iVideoSource);        

        }

    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")));		

    if (&aTrack == iDisplaySink->DisplaySink())

        {

        return iPv2Way->PauseL(*iDisplaySink);        

        }

    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 iPv2Way->PauseL(*(audioSourceProxy->iAudioSource));

    }

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

// CSessionCommand::ResumeVideoL

// Resume a previously paused incoming or outgoing track.

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

//

TInt CSessionCommand::ResumeVideoL(MVTVideoSource& aTrack)

    {

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

    if (&aTrack == iVideoSource->VideoSource())

        {

        return iPv2Way->ResumeL(*iVideoSource);        

        }

    return KErrNone;    

    }

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

// CSessionCommand::ResumeVideoL

// Resume a previously paused incoming or outgoing track.

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

//

TInt CSessionCommand::ResumeVideoL(MVTVideoSink& aTrack) 

    {

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

    if (&aTrack == iDisplaySink->DisplaySink())

        {

        return iPv2Way->ResumeL(*iDisplaySink);        

        }

    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 iPv2Way->ResumeL(*(audioSourceProxy->iAudioSource));

    }

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

// 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 iPv2Way->CancelAllCommandsL();

    }

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

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

        commandId = iPv2Way->QueryInterfaceL(

                     KPVUidH324ConfigInterface,

                     ( MPVInterface*& ) H324ConfigCommand->PVH324ConfigInterface(),

                     ( void* ) EVtGet324CtrlInterface );

        aProtocolCommand = H324ConfigCommand;

        }

    else if (aType == EVtVideoEncoderConfig)

        {

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

        commandId = iPv2Way->QueryInterfaceL(

                        KPVUidVidEncConfigInterface,

                        ( MPVInterface*& ) videoConfigCommand->PVVideoEncoderInterface(),

                        ( void* ) EVtGetH263EncInterface  );

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

            commandId = iPv2Way->ReleaseInterfaceL(H324ConfigCommand->PVH324ConfigInterface());

            delete H324ConfigCommand;

            }

        else if (aType == EVtVideoEncoderConfig)

            {

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

            commandId = iPv2Way->ReleaseInterfaceL(videoConfigCommand->PVVideoEncoderInterface());

            delete videoConfigCommand;

            }

        else

            {

            ;

            }

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

    return commandId;

    }

// end of file