/*

* 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 FILES

#include <e32base.h>

#include <e32std.h>

#include <e32def.h>

#include <stringpool.h>

#include <sdpdocument.h>

#include <sdpcodecstringconstants.h>

#include <sdpcodecstringpool.h>

#include <sdpmediafield.h>

#include <sdpattributefield.h>

#include <sdprtpmapvalue.h>

#include <sdpfmtattributefield.h>

#include <sdporiginfield.h>

#include <e32err.h>

#include <uricommon.h>

#include <uri8.h>

#include <uriutils.h>

#include <SdpConnectionField.h>

#include "mcemediadefs.h"

#include "mcemessagesdpcodec.h"

#include "mcecommessagestream.h"

#include "mcemessagestream.h"

#include "mcecommessagecodec.h"

#include "mcemediadefs.h"

#include "mcecomfactory.h"

#include "mcemmlogs.h"

#include "mcecommsrpsource.h"

#include "mcecomexternalsink.h"

#include "mcecomexternalsource.h"

#include "mcecommsrpsink.h"

#include "mcecommediasource.h"

#include "mcedefs.h"

#include "mcecomendpoint.h"

#include <mcemsrpsink.h>

#include <mcemsrpsource.h>

#include <mcemessagesink.h>

#include <mcemessagesource.h>

#include "mcecommessagesink.h"

#include "mcecommessagesource.h"

#include "mcemsrpsink.h"

#include "mceexternalsource.h"

#include "mceexternalsink.h"

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

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

// CMceMessageSdpCodec::NewL

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

//

CMceMessageSdpCodec* CMceMessageSdpCodec::NewL()

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::CMceMessageSdpCodec::NewL, Entry" )

    RStringF message = MCE_SDP_STRING_MESSAGEL();

    /*

    RStringPool sPool;

    RStringF message =sPool.OpenFStringL(KMceMediaMessage);

    */    

    CMceMessageSdpCodec* self = new (ELeave) CMceMessageSdpCodec( message );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    MCEMM_DEBUG( "CMceMessageSdpCodec::CMceMessageSdpCodec::NewL, Exit" )

    return self;

    }

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

// CMceMessageSdpCodec::CMceMessageSdpCodec

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

//

CMceMessageSdpCodec::CMceMessageSdpCodec( RStringF aMedia )

    : CMceMediaSdpCodec( aMedia )

    {

    }

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

// CMceMessageSdpCodec::~CMceMessageSdpCodec

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

//

CMceMessageSdpCodec::~CMceMessageSdpCodec()

    { 

    MCEMM_DEBUG( "CMceMessageSdpCodec::~CMceMessageSdpCodec, Entry" )

    iNetType.Close();

    iAddressType.Close();

    iAcceptTypesStr.Close();

    iPathStr.Close();

    iAcceptWrappedTypesStr.Close();

    iFileSelectorStr.Close();

    iFileTransferidStr.Close();  

    iFileDispositionStr.Close();

    iConnectionStr.Close();

    MCEMM_DEBUG( "CMceMessageSdpCodec::~CMceMessageSdpCodec, Exit" )

    }

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

// CMceMessageSdpCodec::Encodes

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

//

TBool CMceMessageSdpCodec::Encodes( const CMceComMediaStream& aStream ) const

    {

    return aStream.iStreamType != CMceComMediaStream::ELocalStream &&

           aStream.iType == KMceMessage;

    }

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

// CMceMessageSdpCodec::EncodeRtpmapAttributeLC

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

//

CSdpFmtAttributeField* CMceMessageSdpCodec::EncodeRtpmapAttributeLC( CMceComCodec& /*aCodec*/ ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::EncodeRtpmapAttributeLC(), Entry" )

    CSdpFmtAttributeField* rtpmapAttribute = NULL;

    CleanupStack::PushL( rtpmapAttribute );

    MCEMM_DEBUG( "CMceMessageSdpCodec::EncodeRtpmapAttributeLC(), Exit" )

    return rtpmapAttribute;

    }

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

// CMceMessageSdpCodec::EncodeMessageMediaAttributesL

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

//

void CMceMessageSdpCodec::EncodeMessageMediaAttributesL( CMceComMessageStream& aStream, 

                                                            CSdpMediaField& aMediaLine)                                             

     {

     // Message stream level attributes will be set through client SDP attributes.

    MCEMM_DEBUG( "CMceMessageSdpCodec::EncodeMessageMediaAttributesL, Entry" )

     CMceComMsrpSource* msrpSource = NULL;

     CMceComMsrpSink* msrpSink = NULL;

     if ( (aStream.iStreamType == CMceComMediaStream::ESendOnlyStream) ||

             (aStream.iStreamType == CMceComMediaStream::ESendStream))

         {

         for(TInt i=0; i<aStream.Sinks().Count(); i++)

             {

             if ( (aStream.Sinks())[i]->iType == KMceMSRPSink)

                 {

                 msrpSink = dynamic_cast<CMceComMsrpSink*>( aStream.Sinks()[i]);

                 break;

                 }

             }

         }

        else  //it meamsn it is sendrecv stream so the parameters are expected to be set to msrpSink

         {

         __ASSERT_ALWAYS(aStream.Source()->iType == KMceMSRPSource, User::Leave(KErrArgument));

         msrpSource = dynamic_cast<CMceComMsrpSource*>( aStream.Source());

         }

     __ASSERT_ALWAYS(msrpSource!=NULL || msrpSink!= NULL, User::Leave(KErrNotFound));

     RPointerArray<CMceComMediaSink> &sinks = aStream.Sinks(); //== KMceMessageSink

     if( (aStream.iSource->iType == KMceMSRPSource && sinks[0]->iType == KMceMessageSink) || aStream.iSource->iType == KMceMessageSource) // down link

         {

         if(aStream.iLocalMsrpPath.Length() && ( aStream.Session()->Streams().Count() != 2 || aStream.iStreamType != CMceComMediaStream::ESendOnlyStream) )

             {

             if (iPathStr.DesC().Length() == 0 )

                 {

                 iPathStr = SdpCodecStringPool::StringPoolL().OpenFStringL(KMceSDPNamePath);

                 CleanupClosePushL( iPathStr );

                 }

             HBufC16* localPath = HBufC16::NewLC(256);

             localPath->Des().Copy(aStream.iLocalMsrpPath);

             CUri8* uri = UriUtils::CreateUriL(*localPath);

             // if the realy is supported then the last entry will always indicates its own MSRP URI

             SetHostAddrFromPathAttrL(uri->Uri(), aMediaLine); 

             // Set local port number from the msrp path

             //SetPortFromPathAttrL((TUriC8&)uri->Uri(), aStream);            

             // Create the path SDP attr and append this to media line

             CSdpAttributeField* pathAttr = CSdpAttributeField::NewLC( iPathStr, aStream.iLocalMsrpPath);                     

             MCEMM_DEBUG_SVALUE( "path Attribute value from MSRP stack:", aStream.iLocalMsrpPath )         

             aMediaLine.AttributeFields().AppendL( pathAttr );

             CleanupStack::Pop(pathAttr);

             CleanupStack::PopAndDestroy(localPath);

             if (iPathStr.DesC().Length() != 0 )

                 CleanupStack::PopAndDestroy(&iPathStr);

             delete uri;

             }

         }

     else if(aStream.iSource->iType == KMceMessageSource && msrpSink->iType == KMceMSRPSink) // message uplink

         {

         //NOP

         }

     else

         {

         SetPathAttributeL(aStream, msrpSource, msrpSink, aMediaLine);

         }

    // EncodeFileAttributeL( aStream, aMediaLine );

     SetAcceptTypesAttributeL(msrpSource, msrpSink, aMediaLine);

     SetAcceptWrappedAttributeL(msrpSource, msrpSink, aMediaLine);

     SetFileShareAttributeL(msrpSource, msrpSink, aMediaLine);

     // Set Information attribute

     HBufC8* infoPtr = msrpSource!=NULL ? msrpSource->iSessInfo : msrpSink->iSessInfo;

     if (infoPtr != NULL)

         aMediaLine.SetInfoL(infoPtr->Des());

     // set msrp conneciton attribute

     SetConnectionAttributeL(aStream, aMediaLine);

     MCEMM_DEBUG( "CMceMessageSdpCodec::EncodeMessageMediaAttributesL, Exit" )

     }

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

// CMceMessageSdpCodec::EncodeMediaAttributesL

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

//

void CMceMessageSdpCodec::EncodeMediaAttributesL( CMceComCodec& /*aCodec*/, 

                                                CSdpMediaField& /*aMediaLine*/, 

                                                CSdpFmtAttributeField& /*aRtpmap*/ ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::EncodeMediaAttributesL(), Entry" )

    MCEMM_DEBUG( "CMceMessageSdpCodec::EncodeMediaAttributesL(), Exit" )

    }

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

// CMceMessageSdpCodec::DecodeMediaAttributesL 

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

//

void CMceMessageSdpCodec::DecodeMediaAttributesL(

    CSdpMediaField& /*aMediaLine*/, 

    CMceComCodec& /*aCodec*/,

    CSdpFmtAttributeField& /*aRtpmap*/ ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::DecodeMediaAttributesL(), Entry ")

    MCEMM_DEBUG("CMceMessageSdpCodec::DecodeMediaAttributesL(), Exit ")

    }

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

// CMceMessageSdpCodec::CreateStreamLC

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

//

CMceComMediaStream* CMceMessageSdpCodec::CreateStreamLC( TInt aType ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateStreamLC(), Entry" )

   CMceComMessageStream* messagestream = NULL;

    if( aType == SdpCodecStringConstants::EAttributeSendonly )

        {

        // downlink

        MCEMM_DEBUG( "create downlink" )

        messagestream = CreateDownlinkStreamL();

        }

    else if( aType == SdpCodecStringConstants::EAttributeRecvonly )        

        {

        // uplink 

        MCEMM_DEBUG( "create uplink" )

        messagestream = CreateUplinkStreamL();

        }

    else

        {

        // sendrcv 

        // create two way stream

        // create downlink

        MCEMM_DEBUG( "create two-way stream" )

        messagestream = CreateDownlinkStreamL();

        CleanupStack::PushL( messagestream );

        // create bounded uplink

       CMceComMessageStream *boundUplink = CreateUplinkStreamL();

        CleanupStack::PushL( boundUplink );

        messagestream->BindL( boundUplink );

        CleanupStack::Pop( boundUplink ); 

        CleanupStack::Pop( messagestream );

        }

    CleanupStack::PushL( messagestream );

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateStreamLC(), Exit" )

    return messagestream;

    }

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

// CMceMessageSdpCodec::UpdateStreamL

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

//

void CMceMessageSdpCodec::UpdateStreamL( CMceComMediaStream& aStream, TInt aDirection ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::UpdateStreamL(), Entry ")

    MCE_DEFINE_AUDIO( stream, aStream );

   CMceComMessageStream* messagestream = NULL;

   CMceComMessageStream& amessagestream = (CMceComMessageStream&)( aStream );

    TInt streamType = stream.SdpStreamType();

    if ( aDirection != SdpCodecStringConstants::EAttributeInactive )

        {

        switch( streamType )

            {

            case SdpCodecStringConstants::EAttributeRecvonly:

                {

                //if direction is changed

                if ( aDirection != SdpCodecStringConstants::EAttributeSendonly )

                    {

                    MCEMM_DEBUG( "update from recvonly to send" )

                    MCEMM_DEBUG( "create uplink" )

                    messagestream = CreateUplinkStreamL();

                    }

                break;

                }

            case SdpCodecStringConstants::EAttributeSendonly:

                {

                //if direction is changed

                if ( aDirection != SdpCodecStringConstants::EAttributeRecvonly )

                    {

                    MCEMM_DEBUG( "update from sendonly to recv" )

                    MCEMM_DEBUG( "create downlink" )

                    messagestream = CreateDownlinkStreamL();

                    }

                break;

                }

            case SdpCodecStringConstants::EAttributeSendrecv:

            default:

                {

                break;

                }

            }

        }

    if ( messagestream )

        {

        CleanupStack::PushL( messagestream );

        MCEMM_DEBUG( "cloning codecs" )

        for( TInt index = 0; index < amessagestream.CodecCount(); ++index )

            {

            // No ceodecs for message stream presently

            CMceComMessageCodec* codec = static_cast<CMceComMessageCodec*>( amessagestream.CodecL( index )->CloneL() );

            CleanupStack::PushL( codec );

            MCEMM_DEBUG_SVALUE( "cloned codec", codec->iSdpName )

            messagestream->AddCodecL( codec );

            CleanupStack::Pop( codec );

            }

        amessagestream.BindL( messagestream );

        messagestream->InitializeL( *amessagestream.Session() );

        MCEMM_DEBUG( "binded stream created" )

        CleanupStack::Pop( messagestream ); 

        }

    MCEMM_DEBUG( "CMceMessageSdpCodec::UpdateStreamL(), Exit" )

    }

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

// CMceMessageSdpCodec::CreateCodecLC

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

//

CMceComCodec* CMceMessageSdpCodec::CreateCodecLC( CSdpFmtAttributeField& /*aRtpmap*/ ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateCodecLC(), Entry" )

    CMceComCodec* codec = NULL;

    TPtrC8 codecName(KMceSDPNameMsrp);

    TMceComMessageCodecFactory factory;

    codec =  factory.CreateLC( codecName );

    //Junk Value for dummy msrp codec

    codec->iPayloadType = 90;  // dummy payload type + using unassigned value

    MCEMM_DEBUG_SVALUE( "created codec", codecName )

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateCodecLC(), Exit" )

    return codec;

    }

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

// CMceMessageSdpCodec::CreateCodecLC

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

//

CMceComCodec* CMceMessageSdpCodec::CreateCodecLC( TUint /*aPayload*/, 

                                                CSdpMediaField& /*aMediaLine*/ ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateCodecLC( payload ), Entry" )

    TMceComMessageCodecFactory factory;  

    CMceComMessageCodec* codec = NULL;

    TUint aPayload = 90;  // dummy payload type + using unassigned value

    codec = factory.CreateCodecLC( aPayload );

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateCodecLC( payload ), Exit" )

    return codec;

    }

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

// CMceMessageSdpCodec::DecodeSessionMediaAttributesL

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

//

void CMceMessageSdpCodec::DecodeSessionMediaAttributesL( CMceComMediaStream& /*aStream*/, 

                                                       CSdpDocument& /*aSdpDocument*/ ) const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::DecodeSessionMediaAttributesL(), Entry" )

    MCEMM_DEBUG( "CMceMessageSdpCodec::DecodeSessionMediaAttributesL(), Exit" )

    }

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

// CMceMessageSdpCodec::CreateUplinkStreamL

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

//

CMceComMessageStream* CMceMessageSdpCodec::CreateUplinkStreamL() const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateUplinkStreamL(), Entry" )

   CMceComMessageStream *messagestream =CMceComMessageStream::NewL();

    CleanupStack::PushL( messagestream );

    // uplink           

    CMceComMessageSource* messageSource = CMceComMessageSource::NewL();

    CleanupStack::PushL( messageSource );

    //messageSource->InitializeL( static_cast<CMceComMessageStream&> ( *messagestream ) );

    messageSource->InitializeL( *messagestream);

    messagestream->SetSourceL( messageSource );

    CleanupStack::Pop( messageSource );

    CMceComMsrpSink* msrpSink = CMceComMsrpSink::NewL();

    CleanupStack::PushL( msrpSink );

    msrpSink->InitializeL( *messagestream);

    messagestream->AddSinkL( msrpSink );

    CleanupStack::Pop( msrpSink ); 

    CleanupStack::Pop( messagestream );

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateUplinkStreamL(), Exit" )

    return messagestream;

    }

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

// CMceMessageSdpCodec::CodecsL

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

//

const RPointerArray<CMceComCodec>& CMceMessageSdpCodec::CodecsL( CMceComMediaStream& aStream ) const

    {

    __ASSERT_ALWAYS( aStream.iType == KMceMessage, User::Leave( KErrArgument ) );

    MCE_DEFINE_MESSAGE( stream, aStream );

    return reinterpret_cast< const RPointerArray< CMceComCodec >& >( stream.Codecs() );

    }

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

// CMceMessageSdpCodec::CreateDownlinkStreamL

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

//

CMceComMessageStream* CMceMessageSdpCodec::CreateDownlinkStreamL() const

    {

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateDownlinkStreamL(), Entry" )

   CMceComMessageStream *messagestream =CMceComMessageStream::NewL();

    CleanupStack::PushL( messagestream ); 

    // downlink         

    CMceComMsrpSource* msrpSource = CMceComMsrpSource::NewL();

    CleanupStack::PushL( msrpSource );

    //msrpSource->InitializeL( static_cast<CMceComMessageStream&> ( *messagestream ) );

    msrpSource->InitializeL( ( *messagestream ) );

    messagestream->SetSourceL( msrpSource );

    CleanupStack::Pop( msrpSource );

    CMceComMessageSink* sink = CMceComMessageSink::NewL();

    CleanupStack::PushL( sink );

    sink->InitializeL( ( *messagestream ) );

    messagestream->AddSinkL( sink );

    CleanupStack::Pop( sink ); 

    CleanupStack::Pop( messagestream );

    MCEMM_DEBUG( "CMceMessageSdpCodec::CreateDownlinkStreamL(), Exit" )

    return messagestream;

    }

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

// CMceMessageSdpCodec::SetHostAddrFromPathAttrL

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

//

void CMceMessageSdpCodec::SetHostAddrFromPathAttrL(const TUriC8& aMsrpUri, 

        CSdpMediaField& aMediaLine)

    {

    MCEMM_DEBUG("\n CMceMessageSdpCodec::SetHostAddrPortFromPathAttr : Entry");

    TUriParser8 parser;

    TInt parseValue = parser.Parse(aMsrpUri.UriDes()); 

    MCEMM_DEBUG_DVALUE("\n CMceMessageSdpCodec::SetHostAddrPortFromPathAttr: Parsed return value for MSRP URI: ", 

            parseValue);

    User::LeaveIfError(parseValue);

    TBuf8<50> host = parser.Extract(EUriHost);

    // check the type of the host and create the conneciton filed and insert it into the media field