/*

* 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 <sipinvitedialogassoc.h>

#include <sipprofile.h>

#include <sdpdocument.h>

#include <siptoheader.h>

#include <sipdialog.h>

#include <sipcontactheader.h>

#include "mcesipsession.h"

#include "mcecssession.h"

#include "mceservercore.h"

#include "fcpluginengine.h"

#include "mcesipconnection.h"

#include "mcesipstatemachine.h"

#include "mcestate.h"

#include "mceactionset.h"

#include "mcefcactionset.h"

#include "mceclient.pan"

#include "mcesrvlogs.h"

#include "mcecomsession.h"

#include "mcecomaudiocodec.h"

#include "mcesipextensions.h"

#include "mcereliablesender.h" 

#include "mcemediamanager.h"

#include "mcesdpsession.h"

#include "mcetimermanager.h"

#include "mcemediastate.h"

#define MCE_IGNORE_MEDIA_ERROR ( ( defined __WINSCW__ ) || ( defined __WINS__ ) )\

                            && ( !defined MCESRV_UNIT_TESTING ) 

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

// CMceSipSession::NewL

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

//

CMceSipSession* CMceSipSession::NewL( CMceCsSession& aClientSession, 

                                      CMceSipConnection& aSIPConnection,

								      CMceSipStateMachine& aStateMachine,

								      CSIPProfile& aProfile )

	{

    CMceSipSession* self = CMceSipSession::NewLC( aClientSession, 

                                                  aSIPConnection, 

                                                  aStateMachine,

                                                  aProfile );

    CleanupStack::Pop(self);

    return self;

	}

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

// CMceSipSession::NewLC

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

//

CMceSipSession* CMceSipSession::NewLC ( CMceCsSession& aClientSession, 

                                        CMceSipConnection& aSIPConnection,

 								        CMceSipStateMachine& aStateMachine,

 								        CSIPProfile& aProfile )

	{

    CMceSipSession* self = new (ELeave) CMceSipSession( aClientSession, 

                                                        aSIPConnection, 

                                                        aStateMachine,

                                                        aProfile );

    CleanupStack::PushL(self);

    self->ConstructL( aClientSession );

    return self;

	}

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

// CMceSipSession::NewLC

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

//

CMceSipSession* CMceSipSession::NewLC ( CMceCsSession& aClientSession, 

                                        CMceSipConnection& aSIPConnection,

 								        CMceSipStateMachine& aStateMachine )

	{

    CMceSipSession* self = new (ELeave) CMceSipSession( aClientSession, 

                                                        aSIPConnection, 

                                                        aStateMachine );

    CleanupStack::PushL(self);

    self->ConstructL( aClientSession );

    return self;

	}

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

// CMceSipSession::CMceSipSession

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

//

CMceSipSession::CMceSipSession ( CMceCsSession& aClientSession, 

								 CMceSipConnection& aSIPConnection,

								 CMceSipStateMachine& aStateMachine,

								 CSIPProfile& aProfile )

: CMceCsSubSession( KMceCSSIPSession, aClientSession, aSIPConnection, \

					aProfile ),

  iStateMachine( &aStateMachine ),

  iSubState( ENone ),

  iUseFC( EFalse )

	{

	}

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

// CMceSipSession::CMceSipSession

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

//

CMceSipSession::CMceSipSession ( CMceCsSession& aClientSession, 

								 CMceSipConnection& aSIPConnection,

								 CMceSipStateMachine& aStateMachine )

: CMceCsSubSession( KMceCSSIPSession, aClientSession, aSIPConnection ),

  iStateMachine( &aStateMachine ),

  iSubState( ENone ),

  iUseFC( EFalse )

	{

	}

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

// CMceSipSession::ConstructL

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

//

void CMceSipSession::ConstructL ( CMceCsSession& aClientSession )

	{

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

	CMceCsSubSession::ConstructL( aClientSession );

	iTimer = CMceTimerManager::KNoSuchTimer;

	iPendingTimer = CMceTimerManager::KNoSuchTimer;

	iCurrentState = &iStateMachine->State( KMceStateIdle );

    iExtensions= CMceSipExtensions::NewL();

    iReliableSender = CMceReliableSender::NewL( *this );

    iRSeq = KErrNone;

    iPreviousState = KMceStateIdle;

    iForceSDPSending = EFalse;

    iNatSession = EFalse;

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

	}

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

// CMceSipSession::~CMceSipSession

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

//

CMceSipSession::~CMceSipSession()

	{

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

    CloseMedia( ETrue );

    CMceComSession::Delete( iNewBodyCandidate, Manager().MediaManager() );

    PrevOfferSafeDelete();	

	delete iOffer;

    Manager().TimerManager().Stop( iTimer );

	if ( iFCSession )

		{

		ServerCore().DeregisterFCSession( *this, *iFCSession );	 

		ServerCore().FCPluginEngine().ReleaseSession( *iFCSession); 

		}

	iForkedDialogs.ResetAndDestroy(); 

	delete iMediaAuthorizationToken;

	delete iExtensions;

	delete iReliableSender;

	iRemoteUri.ResetAndDestroy();

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

  	}

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

// CMceSipSession::CloseMedia         

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

//

void CMceSipSession::CloseMedia( TBool aDelete )

	{

    MCESRV_DEBUG("CMceSipSession::CloseMedia, Entry");

    if ( aDelete )

        {

        CMceComSession::Delete( iBody, Manager().MediaManager() );

        }

    else

        {

        Manager().MediaManager().CloseSession( *iBody );

        }

    CloseBodyBucket();

    MCESRV_DEBUG("CMceSipSession::CloseMedia, Exit");

	}

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

// CMceSipSession::CloseBodyBucket         

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

//

void CMceSipSession::CloseBodyBucket()

	{

    MCESRV_DEBUG("CMceSipSession::CloseBodyBucket, Entry");

    while( iBodyBucket.Count() > 0 )

        {

        CMceComSession* body = iBodyBucket[ 0 ];

        if ( &body->SdpSession() )

            {

            body->SdpSession().AttachContext( NULL );

            }

        CMceComSession::Delete( body, Manager().MediaManager() );

        iBodyBucket.Remove( 0 );

        }

    iBodyBucket.ResetAndDestroy();

    MCESRV_DEBUG("CMceSipSession::CloseBodyBucket, Exit");

	}

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

// CMceSipSession::ReliableSender         

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

//

CMceReliableSender& CMceSipSession::ReliableSender()

    {

    return *iReliableSender;

    }

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

// CMceSipSession::DoInitializeIncomingDialogL

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

//

void CMceSipSession::DoInitializeIncomingDialogL( 

    CSIPServerTransaction& /*aTransaction*/ )

    {

    MCESRV_DEBUG("CMceSipSession::DoInitializeIncomingDialogL, Entry");

    FCActions().InitializeFCL();

    SetBodyL();

    MCESRV_DEBUG("DoInitializeIncomingDialogL: new session body:");

    MCESRV_DEBUG_COMSESSION( iBody );

    MCESRV_DEBUG("CMceSipSession::DoInitializeIncomingDialogL, Exit");    

    }

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

// CMceSipSession::CanDispose

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

//

TBool CMceSipSession::CanDispose()

    {

    return ( CurrentState().Id() == KMceStateTerminated &&

             HasInitialInviteTransactionBeenCompleted() ); 

    }

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

// CMceSipSession::Actions

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

//

TMceActionSet CMceSipSession::Actions()

    {

    return TMceActionSet( *this );

    }

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

// CMceSipSession::FCActions

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

//

TMceFCActionSet CMceSipSession::FCActions()

    {

    return TMceFCActionSet( *this );

    }

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

// CMceSipSession::CurrentState

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

//

CMceState& CMceSipSession::CurrentState( TBool aMarkExit )

    {

    if ( aMarkExit )

        {

        iExitState = iCurrentState;

        }

    return *iCurrentState;

    }

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

// CMceSipSession::Body

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

//

CMceComSession* CMceSipSession::Body()

    {

    CMceComSession* body = iBody;

    if ( iBodyBucket.Count() > 0 )

        {

        body = &iBody->SdpSession() && iBody->SdpSession().Context() == Dialog() ? 

               iBody : NULL;

        TInt index = 0;

        while( !body && index < iBodyBucket.Count() )

            {

            body = iBodyBucket[ index++ ];

            body = &body->SdpSession() && body->SdpSession().Context() == Dialog() ? body : NULL;

            }

        body = !body ? iBody : body;

        }

    return body;    

    }

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

// CMceSipSession::BodyCandidate

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

//

CMceComSession* CMceSipSession::BodyCandidate()

    {

    return iNewBodyCandidate;

    }

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

// CMceSipSession::SetOffer

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

//

void CMceSipSession::SetOffer( CSdpDocument* aSdpDocument )

    {

    if ( aSdpDocument != iOffer )

        {

        delete iOffer;

        iOffer = aSdpDocument;

        }

    }

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

// CMceSipSession::Offer

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

//

CSdpDocument* CMceSipSession::Offer()

    {

    return iOffer;

    }

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

// CMceSipSession::SetPrevOffer

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

//

void CMceSipSession::SetPrevOffer( CSdpDocument* aSdpDocument )

    {

    if ( aSdpDocument != iPrevOffer )

        {

        PrevOfferSafeDelete();

        iPrevOffer = aSdpDocument;

        }

    }

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

// CMceSipSession::PrevOffer

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

//

CSdpDocument* CMceSipSession::PrevOffer()

    {

    return iPrevOffer;

    }

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

// CMceSipSession::StorePrevOffer

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

//

void CMceSipSession::StorePrevOffer()

    {

    MCESRV_DEBUG( "*** CMceSipSession::StorePrevOfferL, Entry" );

    // If refreshing, existing prev offer is going to be taken in use and

    // we don't want to override it with offer.

    if ( iOffer && SubState() != ERefreshing )

        {

        MCESRV_DEBUG( "*** CMceSipSession::StorePrevOfferL, Copy" );

        CSdpDocument* clonedOffer = NULL;

        TRAP_IGNORE( ( clonedOffer = iOffer->CloneL() ) );

        SetPrevOffer( clonedOffer );

        }

    MCESRV_DEBUG( "*** CMceSipSession::StorePrevOfferL, Exit" ); 

    }

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

// CMceSipSession::IncrementSentSdpCount

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

//

void CMceSipSession::IncrementSentSdpCount()

    {

    iSentSdpCount++;

    }

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

// CMceSipSession::IncrementReceivedSdpCount

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

//   

void CMceSipSession::IncrementReceivedSdpCount()

    {

    iReceivedSdpCount++;

    }

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

// CMceSipSession::ResetSdpCounts

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

//

void CMceSipSession::ResetSdpCounts()

    {

    iSentSdpCount = 0;

    iReceivedSdpCount = 0; 

    }

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

// CMceSipSession::DoesMediaManagerNeedToNegotiate

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

//

TBool CMceSipSession::DoesMediaManagerNeedToNegotiate( 

    CSdpDocument* aSdpDocument )

    {

    CMceMediaManager& mediaManager = Manager().MediaManager();

    return mediaManager.NeedToNegotiate( ActiveBody(), aSdpDocument );

    }

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

// CMceSipSession::NatSession

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

//

TBool CMceSipSession::NatSession() const

    {

    return EFalse;

    }

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

// CMceSipSession::NatState

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

//

TInt CMceSipSession::NatState() const

    {

    return KErrNotFound;

    }

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

// CMceSipSession::IsNatDisabled

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

//

TBool CMceSipSession::IsNatDisabled() const

	{

	return EFalse;

	}

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

// CMceSipSession::StartSessionTimerL

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

//

void CMceSipSession::StartSessionTimerL()

    {

    MCESRV_DEBUG("CMceSipSession::StartSessionTimerL, Entry");

    const TUint KTwo = 2;

    CMceTimerManager& timerManager = Manager().TimerManager();

    if( iBody->iTimeout > 0 )

    	{

    	TUint32 interval;

	    if( iBody->iRefresh )

	    	{

	    	// if this end should perform refreshes then the reccommended

	    	// time is half the session interval

	    	interval = ( iBody->iTimeout * KMceSecToMillisec ) / KTwo;

	    	}

	    else

	    	{

	    	// the other end is performing refreshes, so set the timeout

	    	// to full session interval and send bye in case of no refresh

	    	interval = iBody->iTimeout * KMceSecToMillisec;

	    	}

        if ( timerManager.IsRunning( iTimer ) )

            {

    		timerManager.Stop( iTimer );

            }

        iTimer = timerManager.StartL( this, interval );

        }

    MCESRV_DEBUG("CMceSipSession::StartSessionTimerL, Exit");

    }

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

// CMceSipSession::StartPendingTimerL

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

//

void CMceSipSession::StartPendingTimerL( TUint aInterval )

    {

    MCESRV_DEBUG("CMceSipSession::StartPendingTimerL, Entry");

    CMceTimerManager& timerManager = Manager().TimerManager();

    iPendingTimer = timerManager.StartL( this, aInterval );

    MCESRV_DEBUG("CMceSipSession::StartPendingTimerL, Exit");

    }

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