/*

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

#include "mceoutsession.h"

#include "mcemanager.h"

#include "mceevent.h"

#include "mcecomsession.h"

#include "mceitcsender.h"

#include "mceserial.h"

#include "mceclilogs.h"

#define _FLAT_DATA static_cast<CMceComSession*>( iFlatData )

#define FLAT_DATA( data ) _FLAT_DATA->data

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

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

// CMceOutSession::NewL

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

//

EXPORT_C CMceOutSession* CMceOutSession::NewL(

                        CMceManager& aManager,

                        CSIPProfile& aProfile,

                        const TDesC8& aRecipient,

						HBufC8* aOriginator )

    {

    MCECLI_DEBUG("CMceOutSession::NewL, Entry");

    TUint32 profileId(0);

    if ( aProfile.GetParameter( KSIPProfileId, profileId ) != KErrNone )

        {

        User::Leave(KErrNotFound);

        }

    CMceOutSession* self = new (ELeave) CMceOutSession( &aManager, profileId );

    CleanupStack::PushL( self );

    self->ConstructL( aRecipient, aOriginator );

    CleanupStack::Pop( self );

    MCECLI_DEBUG("CMceOutSession::NewL, Exit");

    return self;

    }

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

// CMceOutSession::NewL

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

//

EXPORT_C CMceOutSession* CMceOutSession::NewL( CMceManager& aManager,

				  TUint32 aIAPId,

				  const TDesC8& aOriginator,

				  const TDesC8& aRecipient,

				  CDesC8Array* aContactParameters )

	{

    CMceOutSession* self = new (ELeave) CMceOutSession( &aManager, 0 );

    CleanupStack::PushL( self );

    self->ConstructL( aRecipient, aOriginator, aIAPId, aContactParameters );

    CleanupStack::Pop( self );

    return self;	

	}

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

// CMceOutSession::NewL

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

//

EXPORT_C CMceOutSession* CMceOutSession::NewL( CMceEvent& aEvent )

    {

    MCECLI_DEBUG("CMceOutSession::NewL(event), Entry");

    CMceOutSession* self = new (ELeave) CMceOutSession( &aEvent.Manager(),

                                                        aEvent.ProfileId() );

    CleanupStack::PushL( self );

    self->ConstructL( aEvent.Recipient(), 

                      aEvent.Originator(), 

                      aEvent.DialogId() );

    CleanupStack::Pop( self );

    MCECLI_DEBUG("CMceOutSession::NewL(event), Exit");

    return self;

    }

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

// CMceOutSession::NewL

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

//

EXPORT_C CMceOutSession* CMceOutSession::NewL( CMceRefer& aRefer )

    {

    MCECLI_DEBUG("CMceOutSession::NewL(refer), Entry");

    CMceOutSession* self = new (ELeave) CMceOutSession( &aRefer.Manager(),

                                                        aRefer.ProfileId() );

    CleanupStack::PushL( self );

    self->ConstructL( aRefer.Recipient(), 

                      aRefer.Originator(),

                      aRefer.DialogId() );

    CleanupStack::Pop( self );

    MCECLI_DEBUG("CMceOutSession::NewL(refer), Exit");

    return self;

    }

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

// CMceOutSession::~CMceOutSession

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

//

EXPORT_C CMceOutSession::~CMceOutSession()

    {

    }

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

// CMceOutSession::EstablishL

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

//

EXPORT_C void CMceOutSession::EstablishL(

                        TUint32 aTimeout,

                        CDesC8Array* aHeaders, 

                        HBufC8* aContentType,

                        HBufC8* aContent,

                        CDesC8Array* aContentHeaders ) 

    {

    MCECLI_DEBUG("CMceOutSession::EstablishL, Entry");

    TState state = State();

    MCECLI_DEBUG_CLISTATE( "state", state );

    User::LeaveIfError( State() == EIdle ? KErrNone : KErrNotReady );

    User::LeaveIfError( 

        ( aContentType && aContent ) || 

       !( aContentType || aContent || aContentHeaders ) ? 

        KErrNone : KErrArgument );

    //set sip params

    SetSIPParams( aHeaders, aContentType, aContentHeaders );

    TCleanupItem sipParamsCleanup( SIPParamsCleanup, this );

    CleanupStack::PushL( sipParamsCleanup );

    FLAT_DATA( iTimeout ) = aTimeout;

    //create com session of this

	CMceMsgObject<CMceSession>* msg = 

	    new (ELeave) CMceMsgObject<CMceSession>( *this, EMceItcMsgTypeSession );

    CleanupStack::PushL( msg );

    //initialize streams, discard unused codecs

    InitializeL( EFalse, ETrue );

    //start establishing the session

	TMceIds ids;

	PrepareForITC( ids );

	iSender->SendL( ids, EMceItcEstablishSession , *msg, aContent );

    //update the state

	FLAT_DATA( iState ) = static_cast<CMceSession::TState>( ids.iState );

	state = State();

    MCECLI_DEBUG_CLISTATE( "CMceSession::EstablishL, after ITC, state", state );

    //cleanup

    CleanupStack::PopAndDestroy( msg );

    CleanupStack::Pop(); // sipParamsCleanup

    SetSIPParams( NULL, NULL, NULL );

    MCECLI_DEBUG("CMceOutSession::EstablishL, Exit");

    }

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

// CMceOutSession::AddStreamL

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

//

void CMceOutSession::AddStreamL( CMceMediaStream* aMediaStream )

    {

    __ASSERT_ALWAYS( aMediaStream != NULL, User::Leave( KErrArgument ) );

    // Just call the base class implementation.

    // Don't remove CMceOutSession::AddStreamL keep BC.

    CMceSession::AddStreamL( aMediaStream );

    }

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

// CMceOutSession::StreamInitializeCondition

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

//

TBool CMceOutSession::StreamInitializeCondition(

	CMceMediaStream& /*aMediaStream*/ ) const

	{

	return ETrue;

	}

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

// CMceOutSession::CancelL

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

//

EXPORT_C void CMceOutSession::CancelL()

    {

    MCECLI_DEBUG("CMceOutSession::CancelL, Entry");

    TState state = State();

    MCECLI_DEBUG_CLISTATE( "state", state );

    User::LeaveIfError( IsZombie() ? KErrArgument : KErrNone  );

    User::LeaveIfError( State() != EIdle ? KErrNone : KErrNotReady );

    //send cancel

	TMceIds ids;

	PrepareForITC( ids );

	ids.iState = State();

    iSender->SendL( ids, EMceItcCancel );

    //update the state

	FLAT_DATA( iState ) = static_cast<TState>( ids.iState );

	state = State();

    MCECLI_DEBUG_CLISTATE( "CMceSession::CancelL, after ITC, state", state );

    MCECLI_DEBUG("CMceOutSession::CancelL, Exit");

    }

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

// CMceOutSession::NewL

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

//

CMceOutSession* CMceOutSession::NewL()

    {

    MCECLI_DEBUG("CMceOutSession::NewL(empty), Entry");

    CMceOutSession* self = new (ELeave) CMceOutSession( NULL, NULL );

    CleanupStack::PushL( self );

    self->ConstructL( KNullDesC8, NULL );

    CleanupStack::Pop( self );

    MCECLI_DEBUG("CMceOutSession::NewL(empty), Exit");

    return self;

    }

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

// CMceOutSession::CMceOutSession

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

//

CMceOutSession::CMceOutSession( CMceManager* aManager, TUint32 aProfileId ) 

    : CMceSession( aManager, aProfileId )

    {

    //NOP

    }

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

// CMceOutSession::ConstructL

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

//

void CMceOutSession::ConstructL( const TDesC8& aRecipient, HBufC8* aOriginator )

    {

    iFlatData = CMceComSession::NewL( CMceComSession::EOutSession );

    delete FLAT_DATA( iRecipient );

    FLAT_DATA( iRecipient ) = 0;

    FLAT_DATA( iRecipient ) = aRecipient.AllocL();

    if ( aOriginator )

        {

        delete FLAT_DATA( iOriginator );

        FLAT_DATA( iOriginator ) = 0;

        FLAT_DATA( iOriginator ) = (*aOriginator).AllocL();

        }

    CMceSession::ConstructL();

    delete aOriginator;    

    }

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

// CMceOutSession::ConstructL

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

//

void CMceOutSession::ConstructL( const TDesC8& aRecipient, 

                                 const TDesC8& aOriginator,

                                 TUint32 aDialogId )

    {

    User::LeaveIfError(

        aDialogId != KMceNotAssigned ? KErrNone : KErrArgument );

    iFlatData = CMceComSession::NewL( CMceComSession::EOutSession );

    FLAT_DATA( iDialogId ) = aDialogId;

    delete FLAT_DATA( iRecipient );

    FLAT_DATA( iRecipient ) = 0;

    FLAT_DATA( iRecipient ) = aRecipient.AllocL();

    delete FLAT_DATA( iOriginator );

    FLAT_DATA( iOriginator ) = 0;

    FLAT_DATA( iOriginator ) = aOriginator.AllocL();

    CMceSession::ConstructL();

    }

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

// CMceOutSession::ConstructL

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

//

void CMceOutSession::ConstructL( const TDesC8& aRecipient, 

                                 const TDesC8& aOriginator,

                                 TUint32 aIAPId,

                                 CDesC8Array* aContactParameters )

    {    

    iFlatData = CMceComSession::NewL( CMceComSession::EOutSession );

    delete FLAT_DATA( iRecipient );

    FLAT_DATA( iRecipient ) = 0;

    FLAT_DATA( iRecipient ) = aRecipient.AllocL();

    delete FLAT_DATA( iOriginator );

    FLAT_DATA( iOriginator ) = 0;

    FLAT_DATA( iOriginator ) = aOriginator.AllocL();

    FLAT_DATA( iIapId ) = aIAPId;

    CMceSession::ConstructL();

    delete aContactParameters;

    }