/*

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

#include <sipdialog.h>

#include <sipcontactheader.h>

#include <sipprofile.h>

#include "mceserver.pan"

#include "mcecssubsession.h"

#include "mcesipmanager.h"

#include "mcecssessionimplementation.h"

#include "mcecssession.h"

#include "mceservercore.h"

#include "mcesipconnection.h"

#include "mcecssubsessionreceiver.h"

#include "mcecsserveritc.h"

#include "mcecomsession.h"

#include "mcecommediastream.h"

#include "mcecommediastream.h"

#include "mcecomaudiocodec.h"

#include "mcecommediasink.h"

#include "mcecommediasource.h"

#include "mceserial.h"

#include "mcesrvlogs.h"

#include "mcemessagedispatcher.h"

const TInt KMaxAddressLength = 256;    

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

// CMceCsSubSession::CMceCsSubSession

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

//

CMceCsSubSession::CMceCsSubSession ( TMceCsSessionType aType,

                                     CMceCsSession& aClientSession,

                                     CMceSipConnection& aSIPConnection )

: iType( EUnknown ),

  iClientType( aType ),

  iDialogId( KMceNotAssigned ),

  iClientExists( EFalse ),

  iCurrentDialog( NULL ),

  iClientSession (NULL ),

  iSIPConnection( aSIPConnection ),

  iServerCore( aClientSession.ServerCore() ),

  iProfile( NULL )

  	{

	}

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

// CMceCsSubSession::CMceCsSubSession

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

//

CMceCsSubSession::CMceCsSubSession ( TMceCsSessionType aType,

                                     CMceCsSession& aClientSession,

                                     CMceSipConnection& aSIPConnection,

                                     CSIPProfile& aProfile )

: iType( EUnknown ),

  iClientType( aType ),

  iDialogId( KMceNotAssigned ),

  iClientExists( EFalse ),

  iCurrentDialog( NULL ),

  iClientSession (NULL ),

  iSIPConnection( aSIPConnection ),

  iServerCore( aClientSession.ServerCore() ),

  iProfile( &aProfile )

  	{

	}

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

// CMceCsSubSession::ConstructL

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

//

void CMceCsSubSession::ConstructL ( CMceCsSession& aClientSession )

	{

    MCESRV_DEBUG("CMceCsSubSession::ConstructL, Entry")

    SetSessionReceiver( aClientSession.CreateSubSessionReceiverL() );

    SetClient( aClientSession.Implementation() );

    MCESRV_DEBUG("CMceCsSubSession::ConstructL, Exit")

	}

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

// CMceCsSubSession::~CMceCsSubSession

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

//

CMceCsSubSession::~CMceCsSubSession()

	{

    MCESRV_DEBUG("CMceCsSubSession::~CMceCsSubSession, Entry")

    TInt index = iPendingTransactions.Find( iInitialInvite );

    if ( index != KErrNotFound )

        {

        iPendingTransactions.Remove( index );

        }

    index = iPendingTransactions.Find( iResponse );

    if ( index != KErrNotFound )

        {

        iPendingTransactions.Remove( index );

        }

    iPendingTransactions.ResetAndDestroy();

    iPendingTransactions.Close();

    iPendingReceivedRequests.ResetAndDestroy();

    if ( iInitialInvite != iResponse )

        {

        delete iInitialInvite;

        }

    iInitialInvite = NULL;

    delete iReceiver;

    delete iDialog;

    delete iResponse;

    delete iClientContent;

    Manager().UnRegisterSubSession( *this );

    delete iAutoEventMsg;

    delete iAutoEventIds;

    delete iAutoEvent;

    MCESRV_DEBUG("CMceCsSubSession::~CMceCsSubSession, Exit")

	}

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

// CMceCsSubSession::Type

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

//

CMceCsSubSession::TType CMceCsSubSession::Type() const

    {

    return iType;

    }

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

// CMceCsSubSession::ClientType

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

//

TMceCsSessionType CMceCsSubSession::ClientType() const

    {

    return iClientType;

    }

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

// CMceCsSubSession::ClientSession

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

//

CMceCsSessionImplementation& CMceCsSubSession::Client() const

    {

    return *iClientSession;

    }

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

// CMceCsSubSession::SetClient

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

//

void CMceCsSubSession::SetClient( CMceCsSessionImplementation& aClient )

    {

    iClientSession = &aClient;

    }

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

// CMceCsSubSession::SetClient

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

//

void CMceCsSubSession::SetSessionReceiver( 

                                  CMceCsSubSessionReceiver* aSessionReceiver )

    {

    delete iReceiver;

    iReceiver = aSessionReceiver;

    }

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

// CMceCsSubSession::IsOrphan

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

//

TBool CMceCsSubSession::IsOrphan()   

    {

    return !iReceiver;

    }

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

// CMceCsSubSession::HasInitialInviteTransactionBeenCompleted()

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

//

TBool CMceCsSubSession::HasInitialInviteTransactionBeenCompleted() const

    {

    TBool completed( ETrue );

    if ( iInitialInvite )

        {

        CSIPTransactionBase::TState state( CSIPTransactionBase::ETerminated  );

        TRAP_IGNORE( ( state = iInitialInvite->StateL() ) )

        completed = ( state == CSIPTransactionBase::ECompleted || 

                      state == CSIPTransactionBase::ETerminated );

        }

    return completed; 

    }

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

// CMceCsSubSession::SIPConnection

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

//

CMceSipConnection& CMceCsSubSession::SIPConnection() const

    {

    return iSIPConnection;

    }

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

// CMceCsSubSession::DialogId

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

//

TUint32 CMceCsSubSession::DialogId() const

    {

    return iDialogId;

    }

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

// CMceCsSubSession::Manager

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

//

CMceSipManager& CMceCsSubSession::Manager() const

    {

    return ServerCore().Manager();

    }

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

// CMceCsSubSession::ServerCore

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

//

CMceServerCore& CMceCsSubSession::ServerCore() const

    {

    return iServerCore;

    }

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

// CMceCsSubSession::FCSession

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

//

const CFCSession* CMceCsSubSession::FCSession() const

	{

	return iFCSession;

	}

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

// CMceCsSubSession::Request

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

//

CSIPServerTransaction& CMceCsSubSession::Request() const

    {

    if ( iAutoEventEnabled && iAutoEventAssociatedRequest )

        {

        TInt index = iPendingReceivedRequests.Find( iAutoEventAssociatedRequest );

        if ( index != KErrNotFound )

            {

            return *iAutoEventAssociatedRequest;

            }

        }

    return *CURRENT_REQUEST();

    }

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

// CMceCsSubSession::InitialRequest

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

//

CSIPServerTransaction& CMceCsSubSession::InitialRequest() const

    {

    return *FIRST_REQUEST();

    }

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

// CMceCsSubSession::PopRequest

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

//

CSIPServerTransaction* CMceCsSubSession::PopRequest()

    {

    CSIPServerTransaction* request = NULL;

    request = CURRENT_REQUEST();

    if ( request )

        {

        iPendingReceivedRequests.Remove( CURRENT_REQUEST_IND );

        }

    return request;

    }

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

// CMceCsSubSession::Response

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

//

CSIPClientTransaction& CMceCsSubSession::Response() const

    {

    return *iResponse;

    }

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

// CMceCsSubSession::PopResponse

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

//

CSIPClientTransaction* CMceCsSubSession::PopResponse()

    {

    CSIPClientTransaction* response = iResponse;

    if ( response && MceSip::TrxCompleted( *response ) )

        {

        iResponse = NULL;

        }

    else

        {

        response = NULL;

        }

    return response;

    }

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

// CMceCsSubSession::SetDialog

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

//

void CMceCsSubSession::SetDialog( CMceCsSubSession::TType aType, 

                                  CSIPDialogAssocBase* aDialog, 

                                  TUint32 aDialogId )

    {

    __ASSERT_ALWAYS( !iDialog, User::Panic( KMceServerPanic, KErrArgument ) );

    iType = aType;

    iDialogId = aDialogId;

    iDialog = aDialog;

    }

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

// CMceCsSubSession::SetPendingTransactionL

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

//

void CMceCsSubSession::SetPendingTransactionL( 

                                    CSIPClientTransaction* aTransaction )

    {

    __ASSERT_ALWAYS( aTransaction, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( iPendingTransactions.Find( aTransaction ) == KErrNotFound, 

        User::Leave( KErrArgument ) );

    iPendingTransactions.AppendL( aTransaction );

    if ( Type() == EOutSession && 

         aTransaction->Type() == SIPStrings::StringF( SipStrConsts::EInvite ) )

        {

        iType = EOutSIPSession;

        iInitialInvite = aTransaction;

        }

    }

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

// CMceCsSubSession::Consumes

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

//

TBool CMceCsSubSession::Consumes( CSIPTransactionBase& aTransaction )

    {

    TBool isPending = EFalse;

    if ( aTransaction.IsSIPClientTransaction() )

        {

        CSIPClientTransaction& transaction = 

            static_cast<CSIPClientTransaction&>( aTransaction );

        isPending = iPendingTransactions.Find( &transaction ) >= 0;

        }

    else

        {

        CSIPServerTransaction& transaction = 

            static_cast<CSIPServerTransaction&>( aTransaction );

        isPending = iPendingReceivedRequests.Find( &transaction ) >= 0; 

        }

    return isPending;    

    }

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

// CMceCsSubSession::AcceptDialogTransaction

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

//

TBool CMceCsSubSession::AcceptDialogTransaction( 

                                    CSIPServerTransaction& /*aTransaction*/ )

    {        

    return ETrue;    

    }

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

// CMceCsSubSession::AcceptStandAloneTransaction

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

//

TBool CMceCsSubSession::AcceptStandAloneTransaction( 

                                    CSIPServerTransaction& /*aTransaction*/ )

    {        

    return ETrue;    

    }

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

// CMceCsSubSession::Consumes

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

//

TBool CMceCsSubSession::Consumes( CSIPDialog& aDialog, 

                                  CSIPServerTransaction& aTransaction,

                                  TBool& aAssociatesWithDialog )

    {

    aAssociatesWithDialog = ( Dialog()->Dialog() == aDialog );

    return aAssociatesWithDialog && ( Consumes( aTransaction ) ||

           AcceptMethod( MceSip::Method( aTransaction ) ) );

    }

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

// CMceCsSubSession::DoServiceL

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

//

HBufC8* CMceCsSubSession::DoServiceL( TMceIds& /*aIds*/, 

                                      TMceItcFunctions /*aFunction*/ )

    {

    MCESRV_DEBUG("CMceCsSubSession::DoServiceL( no message ), NOT SUPPORTED")

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CMceCsSubSession::DoServiceL

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

//

void CMceCsSubSession::DoServiceL( TMceIds& /*aIds*/, 

                                 TMceItcFunctions /*aFunction*/, 

                                 const TDesC8& /*aMessage*/ )

    {

    MCESRV_DEBUG("CMceCsSubSession::DoServiceL( data ), NOT SUPPORTED")

    User::Leave( KErrNotSupported );

    }

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

// CMceCsSubSession::DoServiceL

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

//

void CMceCsSubSession::DoServiceL( TMceIds& /*aIds*/, 

                                 TMceItcFunctions /*aFunction*/, 

                                 TPtr8& /*aMessage*/ )

    {

    MCESRV_DEBUG("CMceCsSubSession::DoServiceL( data ), NOT SUPPORTED")

    User::Leave( KErrNotSupported );

    }

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

// CMceCsSubSession::DoServiceL

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

//

void CMceCsSubSession::DoServiceL( TMceIds& /*aIds*/, 

                                 TMceItcFunctions /*aFunction*/, 

                                 CMceMsgBase& /*aMessage*/ )

    {

    MCESRV_DEBUG("CMceCsSubSession::DoServiceL( message ), NOT SUPPORTED")

    User::Leave( KErrNotSupported );

    }

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

// CMceCsSubSession::PendingTransactions

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

//

const RPointerArray<CSIPClientTransaction>& 

    CMceCsSubSession::PendingTransactions()

    {

    return iPendingTransactions;

    }

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

// CMceCsSubSession::PendingReceivedRequests 

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

//

const RPointerArray<CSIPServerTransaction>&

    CMceCsSubSession::PendingReceivedRequests()

    {

    return iPendingReceivedRequests;

    }

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

// CMceCsSubSession::PendingTransaction

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

//

CSIPClientTransaction* CMceCsSubSession::PendingTransaction( RStringF aType )

    {

    CSIPClientTransaction* trx = NULL;

    TInt index = PendingTransactions().Count()-1;

    while( !trx && index >= 0 )

        {

        trx = PendingTransactions()[ index-- ];

        TBool isMatch = trx->Type() == aType;

        trx = isMatch ? trx : NULL;

        }

    return trx;

    }

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

// CMceCsSubSession::RegisterDialogAssoc

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

//

void CMceCsSubSession::RegisterDialogAssoc( CSIPDialogAssocBase& aDialogAssoc )

    {

    iCurrentDialog = &aDialogAssoc;

    }

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

// CMceCsSubSession::ResponseReceivedWithinDialog