/*

* Copyright (c) 2007 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 "mcecomsession.h"

#include "mceserial.h"

#include "mceevents.h"

#include "cleanupresetanddestroy.h"

#ifdef MCE_COMMON_SERVER_SIDE

#include "mcesrvstream.h"

#include "mcemediaidle.h"

#include "mcemedianegotiated.h"

#include "mcemediamanager.h"

#include "mcesrvstreamiterator.h"

#include "mceadoptedsrvstream.h"

#include "mcesdpsession.h"

#else

#define KMceNegotiationAnswerTypeNotDefined 0

#define KMceCodecSelectionOff 0

#endif//MCE_COMMON_SERVER_SIDE

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

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

// CMceComSession::NewL

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

//

CMceComSession* CMceComSession::NewL()

    {

    return NewL( EInSession );

    }

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

// CMceComSession::NewL

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

//

CMceComSession* CMceComSession::NewL( CMceComSession::TType aType )

    {

    CMceComSession* self = NewLC( aType );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceComSession::NewLC

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

//

CMceComSession* CMceComSession::NewLC( CMceComSession::TType aType )

    {

    CMceComSession* self = new (ELeave) CMceComSession( aType );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMceComSession::NewL

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

//

CMceComSession* CMceComSession::NewL( MMceComSerializationContext& aSerCtx )

    {

    CMceComSession* self = NewLC( aSerCtx );

    CleanupStack::Pop( self );

    return self;

    } 

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

// CMceComSession::NewLC

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

//

CMceComSession* CMceComSession::NewLC( MMceComSerializationContext& aSerCtx )

    {

    CMceComSession* self = new (ELeave) CMceComSession();

    CleanupStack::PushL( self );

    self->InternalizeL( aSerCtx );

    self->InitializeL();

    return self;

    } 

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

// CMceComSession::~CMceComSession

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

//

CMceComSession::~CMceComSession()

    {    

    delete iRecipient;

    delete iOriginator;

    delete iSIPHeaders;

    delete iSIPContentType;

    delete iSIPContentHeaders;

    delete iLocalSessionSDPLines;

    delete iRemoteSessionSDPLines;

    delete iSIPContent;

    iMediaStreams.ResetAndDestroy();

    iBundles.ResetAndDestroy();

    iClientCryptoSuites.Close();	

#ifdef MCE_COMMON_SERVER_SIDE

    DeleteSecureSession();

    if ( iSdpSession )

        {

        if( iSdpSession->DetachMedia( *this ) )

        	{

            iSdpSession = NULL;

        	}

        }

    iMccStreams.ResetAndDestroy();

    iMccAdoptedStreams.ResetAndDestroy();

    delete iNegotiationState;

#endif // MCE_COMMON_SERVER_SIDE

    }

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

// CMceComSession::BaseFactory

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

//

TMceComFactory CMceComSession::BaseFactory()

    {

    return TMceComFactory();

    }

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

// CMceComSession::Factory

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

//

TMceComFactory CMceComSession::Factory()

    {

    return TMceComFactory();

    }

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

// CMceComSession::ConstructL

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

//

void CMceComSession::ConstructL()

    {

    iRecipient = KNullDesC8().AllocL();

    iOriginator = KNullDesC8().AllocL();

    iSIPHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iSIPContentType = KNullDesC8().AllocL();

    iSIPContentHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iLocalSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iRemoteSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iIsSecureSession = EFalse;

    }

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

// CMceComSession::ConstructL

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

//

void CMceComSession::ConstructL( CMceComSession& aSession, TBool aPullModeUpdate )

    {

    iID = aSession.iID;

    iRecipient = aSession.iRecipient ? 

        aSession.iRecipient->AllocL() : KNullDesC8().AllocL();

    iOriginator = aSession.iOriginator ? 

        aSession.iOriginator->AllocL() : KNullDesC8().AllocL();

    iSIPContentType = aSession.iSIPContentType ? 

        aSession.iSIPContentType->AllocL() : KNullDesC8().AllocL();

    iState = aSession.iState;

    iIsConnectionActive = aSession.iIsConnectionActive;

    iDialogId = aSession.iDialogId;

    iIapId = aSession.iIapId;

    iLocalIpAddress = aSession.iLocalIpAddress;

    iRemoteIpAddress = aSession.iRemoteIpAddress;

    iMediaObserver = aSession.iMediaObserver;

    iTimeout = aSession.iTimeout;

    iMinSE = aSession.iMinSE;

    iRefresh = aSession.iRefresh;

    iIsSecureSession = aSession.iIsSecureSession;

    iAnswerType = aSession.iAnswerType;

    iPullModeUpdate = aPullModeUpdate;

    iClientCryptoSuites.Reset();

    for (TInt i=0; i<aSession.iClientCryptoSuites.Count(); i++)

    	{

    	iClientCryptoSuites.InsertL( aSession.iClientCryptoSuites[i], i);

    	}

    iSIPHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    for( TInt i = 0;i<aSession.iSIPHeaders->MdcaCount();i++ )

        {

        iSIPHeaders->AppendL( aSession.iSIPHeaders->MdcaPoint( i ) );

        }

    iSIPContentHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    for( TInt i = 0;i<aSession.iSIPContentHeaders->MdcaCount();i++ )

        {

        iSIPContentHeaders->AppendL( aSession.iSIPContentHeaders->MdcaPoint( i ) );

        }

    iLocalSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    for( TInt i = 0; i < aSession.iLocalSessionSDPLines->MdcaCount(); i++ )

        {

        iLocalSessionSDPLines->AppendL( aSession.iLocalSessionSDPLines->MdcaPoint( i ) );

        }

    iRemoteSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    for( TInt i = 0; i < aSession.iRemoteSessionSDPLines->MdcaCount(); i++ )

        {

        iRemoteSessionSDPLines->AppendL( aSession.iRemoteSessionSDPLines->MdcaPoint( i ) );

        }

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

        {

        iSessionModifiers[ i ] = aSession.iSessionModifiers[ i ];

        }

    if ( !aPullModeUpdate )

        {

        CloneStreamsL( aSession );

        CloneBudlesL( aSession );     

        } 

    iServiceType = aSession.iServiceType;

    iSipContactAddrSecure = aSession.iSipContactAddrSecure;

#ifdef MCE_COMMON_SERVER_SIDE

    iSdpSession = aSession.iSdpSession;

	if (iClientCryptoSuites.Count())

		{

		CloneSecureSessionL(aSession);

		}

#endif//MCE_COMMON_SERVER_SIDE    

    }

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

// CMceComSession::CloneStreamsL

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

//

void CMceComSession::CloneStreamsL( CMceComSession& aSession )

    {

    for( TInt i = 0; i<aSession.Streams().Count(); i++ )

        {

        CMceComMediaStream* stream = aSession.Streams()[i]->CloneL();

        CleanupStack::PushL( stream );

        AddStreamL( stream );

        CleanupStack::Pop( stream );

        }

    }

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

// CMceComSession::CloneBudlesL

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

//

void CMceComSession::CloneBudlesL( CMceComSession& aSession )

    {

    for( TInt i = 0; i<aSession.Bundles().Count(); i++ )

        {

        CMceComStreamBundle* bundle = aSession.Bundles()[i]->CloneL( Streams() );

        CleanupStack::PushL( bundle );

        AddBundleL( bundle );

        CleanupStack::Pop( bundle );

        }

    }

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

// CMceComSession::CloneL

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

//

CMceComSession* CMceComSession::CloneL( TBool aPullModeUpdate )

    {

    CMceComSession* copy = new (ELeave) CMceComSession( iType );

    CleanupStack::PushL( copy );

    copy->ConstructL( *this, aPullModeUpdate );

    copy->InitializeL();

    CleanupStack::Pop( copy );

    copy->iCloneOrigin = this;

    return copy;

    }

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

// CMceComSession::AddStreamL

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

//

void CMceComSession::AddStreamL( CMceComMediaStream* aMediaStream )

    {

    iMediaStreams.AppendL( aMediaStream );

    }

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

// CMceComSession::Streams

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

//

RPointerArray<CMceComMediaStream>& CMceComSession::Streams()

    {

    return iMediaStreams;

    }

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

// CMceComSession::AddBundleL

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

//

void CMceComSession::AddBundleL( CMceComStreamBundle* aBundle )

    {

    aBundle->AddedL();

    iBundles.AppendL( aBundle );

    }

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

// CMceComSession::RemoveBundleL

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

//

void CMceComSession::RemoveBundleL( CMceComStreamBundle& aBundle )

    {

    TInt index = iBundles.Find( &aBundle );

    User::LeaveIfError( index );

    iBundles.Remove( index );

    }

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

// CMceComSession::Bundles

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

//

const RPointerArray< CMceComStreamBundle >& CMceComSession::Bundles() const

    {

    return iBundles;

    }

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

// CMceComSession::SetObserver

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

//

void CMceComSession::SetObserver( MMceMediaSessionObserver& aMediaObserver )

    {

    iMediaObserver = &aMediaObserver;

    }

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

// CMceComSession::SetObserver

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

//

MMceMediaSessionObserver& CMceComSession::MediaObserver()

    {

    return *iMediaObserver;

    }

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

// CMceComSession::SetOriginatorL

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

//

void CMceComSession::SetOriginatorL( const TDesC8& aOriginator )

    {

    delete iOriginator;

    iOriginator = NULL;

    iOriginator = aOriginator.AllocL();

    }

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

// CMceComSession::SetRecipientL

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

//

void CMceComSession::SetRecipientL( const TDesC8& aRecipient )

    {

    delete iRecipient;

    iRecipient = NULL;

    iRecipient = aRecipient.AllocL();

    }

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

// CMceComSession::SerializationId

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

//

TUint64 CMceComSession::SerializationId() const

    {

    return _MAKE_TUINT64_ZX( iID );

    }

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

// CMceComSession::InternalizeFlatL

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

//

void CMceComSession::InternalizeFlatL( RReadStream& aReadStream )

    {

    //iType

    iType = static_cast<TType>( aReadStream.ReadUint8L() );

    //iID

    iID = aReadStream.ReadUint32L();

    //iState

    iState = static_cast<CMceSession::TState>( aReadStream.ReadUint8L() );

    //iRecipient

    MceSerial::DecodeL( iRecipient, aReadStream ); 

    //iOriginator

    MceSerial::DecodeL( iOriginator, aReadStream ); 

    //iIsConnectionActive

    iIsConnectionActive = static_cast<TBool>( aReadStream.ReadUint8L() );

    //iDialogId

    iDialogId = aReadStream.ReadUint32L();

    //iTimeout

    iTimeout = aReadStream.ReadUint32L();

    // iMinSE

    iMinSE = aReadStream.ReadUint32L();

    //iSIPHeaders

    MceSerial::DecodeL( iSIPHeaders, aReadStream ); 

    //iSIPContentType

    MceSerial::DecodeL( iSIPContentType, aReadStream ); 

    //iSIPContentHeaders

    MceSerial::DecodeL( iSIPContentHeaders, aReadStream ); 

    //iLocalSessionSDPLines

    MceSerial::DecodeL( iLocalSessionSDPLines, aReadStream ); 

    //iRemoteSessionSDPLines

    MceSerial::DecodeL( iRemoteSessionSDPLines, aReadStream ); 

    //iSessionModifiers

    TPckgBuf<TMceComSessionModifiers> modifiers;

    MceSerial::DecodeL( modifiers, aReadStream );

    iSessionModifiers = modifiers();

    //check RArray

    MceSerial::DecodeL(iClientCryptoSuites, aReadStream);

   	iServiceType = aReadStream.ReadUint32L();

   	iSipContactAddrSecure = 

   		static_cast<CMceSession::TControlPathSecurityLevel>( aReadStream.ReadUint8L() );

    }

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

// CMceComSession::ExternalizeFlatL

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

//

void CMceComSession::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

    aWriteStream.WriteUint8L( iType );

    aWriteStream.WriteUint32L( iID );

    aWriteStream.WriteUint8L( iState );

    MceSerial::EncodeL( iRecipient, aWriteStream );

    MceSerial::EncodeL( iOriginator, aWriteStream );

	aWriteStream.WriteUint8L( iIsConnectionActive );

    aWriteStream.WriteUint32L( iDialogId );

    aWriteStream.WriteUint32L( iTimeout );

    aWriteStream.WriteUint32L( iMinSE );

    MceSerial::EncodeL( iSIPHeaders, aWriteStream );

    MceSerial::EncodeL( iSIPContentType, aWriteStream );

    MceSerial::EncodeL( iSIPContentHeaders, aWriteStream );

    MceSerial::EncodeL( iLocalSessionSDPLines, aWriteStream );

    MceSerial::EncodeL( iRemoteSessionSDPLines, aWriteStream );

    TPckgBuf<TMceComSessionModifiers> modifiers( iSessionModifiers );

    MceSerial::EncodeL( modifiers, aWriteStream );

    MceSerial::EncodeL(iClientCryptoSuites, aWriteStream);

    aWriteStream.WriteUint32L( iServiceType );

    aWriteStream.WriteUint8L( iSipContactAddrSecure );

    }

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

// CMceComSession::InternalizeL

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

//

void CMceComSession::InternalizeL( MMceComSerializationContext& aSerCtx )

    {

    TMceSessionSerializer<CMceComSession> serial( *this );

    serial.InternalizeL( aSerCtx );

    }

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

// CMceComSession::InternalizeL

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

//

void CMceComSession::ExternalizeL( MMceComSerializationContext& aSerCtx )

    {

    TMceSessionSerializer<CMceComSession> serial( *this );

    serial.ExternalizeL( aSerCtx );

    }

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

// CMceComSession::CMceComSession

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

//

CMceComSession::CMceComSession()

 : iID( KMceNotAssigned ),

   iType( EInSession ),

   iState( CMceSession::EIncoming ),