/*

* Copyright (c) 2008 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 <sipstrconsts.h>

#include "mcesession.h"

#include "mceinsession.h"

#include "mcemanager.h"

#include "mceinsessionobserver.h"

#include "mcesessionobserver.h"

#include "mcestreamobserver.h"

#include "mcetransactionobserver.h"

#include "mceintransactionobserver.h"

#include "mcertpobserver.h"

#include "mcefcmsgobserver.h"

#include "mcetransactiondatacontainer.h"

#include "mcefactory.h"

#include "mceitcsender.h"

#include "mcesessionreceiver.h"

#include "mceclientserver.h"

#include "mceevents.h"

#include "mceserial.h"

#include "mceitcsender.h"

#include "mcesessionreceiver.h"

#include "mce.h"

#include "mcecomsession.h"

#include "mcecommediasink.h"

#include "mcecommediasource.h"

#include "mcestreambundle.h"

#include "mceclilogs.h"

#define _FLAT_DATA static_cast<CMceComSession*>( iFlatData )

#define FLAT_DATA( data ) _FLAT_DATA->data

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

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

// CMceSession::~CMceSession

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

//

CMceSession::~CMceSession()

    {

    MCECLI_DEBUG("CMceSession::~CMceSession, Entry")

    //causes EMceItcClientCancelReceive

    delete iReceiver;

    iReceiver = NULL;

    if ( iManager && iFlatData )

        {

        //causes EMceItcDeleteSession

        iManager->UnregisterSession( this );

        }

    delete iFlatData;

    delete iSender;

    iMediaStreams.ResetAndDestroy();

    iBundles.ResetAndDestroy();

    MCECLI_DEBUG("CMceSession::~CMceSession, Exit")

    }

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

// CMceSession::State

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

//

EXPORT_C CMceSession::TState CMceSession::State() const

    {

    return FLAT_DATA( iState );

    }

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

// CMceSession::GetSIPParams

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

//

void CMceSession::GetSIPParams( CDesC8Array*& aHeaders, 

                                HBufC8*& aContentType,

                                CDesC8Array*& aContentHeaders )

    {

    CDesC8Array* sipHeaders = FLAT_DATA( iSIPHeaders );

    HBufC8* sipContentType = FLAT_DATA( iSIPContentType );

    CDesC8Array* sipContentHeaders = FLAT_DATA( iSIPContentHeaders );

    FLAT_DATA( iSIPHeaders ) = NULL;

    FLAT_DATA( iSIPContentType ) = NULL;

    FLAT_DATA( iSIPContentHeaders ) = NULL;

    aHeaders = sipHeaders;

    aContentType = sipContentType;

    aContentHeaders = sipContentHeaders;

    }

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

// CMceSession::SetSIPParams

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

//

void CMceSession::SetSIPParams( CDesC8Array* aHeaders, 

                                HBufC8* aContentType,

                                CDesC8Array* aContentHeaders )

    {

    delete FLAT_DATA( iSIPHeaders );

    FLAT_DATA( iSIPHeaders ) = aHeaders;

    delete FLAT_DATA( iSIPContentType );

    FLAT_DATA( iSIPContentType ) = aContentType;

    delete FLAT_DATA( iSIPContentHeaders );

    FLAT_DATA( iSIPContentHeaders ) = aContentHeaders;

    }

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

// CMceSession::SIPParamsCleanup

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

//

void CMceSession::SIPParamsCleanup( TAny* aSession )

    {

    if ( !aSession )

        {

        return;

        }

    CMceSession* session = reinterpret_cast< CMceSession* >( aSession );

    session->iFlatData->iSIPHeaders = 0;

    session->iFlatData->iSIPContentType = 0;

    session->iFlatData->iSIPContentHeaders = 0;

    }

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

// CMceSession::ConnectionActive

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

//

EXPORT_C TBool CMceSession::ConnectionActive() const

    {

    return FLAT_DATA( iIsConnectionActive );

    }

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

// CMceSession::AddStreamL

// If called from InternalizeL, iManager is NULL and don't initialize stream.

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

//

void CMceSession::AddStreamL( CMceMediaStream* aMediaStream )

    {

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

	__ASSERT_ALWAYS( iMediaStreams.Find( aMediaStream ) == KErrNotFound,

					 User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( !aMediaStream->BoundStream() ||

                     aMediaStream->Binder(), User::Leave( KErrArgument ) );

	aMediaStream->AddedL();

	if ( iManager && StreamInitializeCondition( *aMediaStream ) )

		{

		// Initialize stream to get the supported codecs

    	aMediaStream->InitializeL( iManager, *this );

		}

    DoAddStreamL( aMediaStream );

    }

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

// CMceSession::DoAddStreamL

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

//

void CMceSession::DoAddStreamL( CMceMediaStream* aMediaStream )

    {

    iMediaStreams.AppendL( aMediaStream );

    }

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

// CMceSession::RemoveStreamL

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

//

EXPORT_C void CMceSession::RemoveStreamL( CMceMediaStream& aMediaStream )

    {

    MCECLI_DEBUG("CMceSession::RemoveStreamL, Entry")

    __ASSERT_ALWAYS( State() == CMceSession::EIdle || 

                     State() == CMceSession::EIncoming ||

                     State() == CMceSession::EEstablished,

                     User::Leave( KErrNotReady ) );

    TInt index = iMediaStreams.Find( &aMediaStream );

    if ( index >= 0 )

        {

        CMceMediaStream* stream = iMediaStreams[ index ];

        iMediaStreams.Remove( index );

        delete stream;

        }

    MCECLI_DEBUG("CMceSession::RemoveStreamL, Exit")

    }

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

// CMceSession::InitializeL

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

//

void CMceSession::InitializeL( 

    TBool aClientSideMedia, 

    TBool aDiscardUnusedCodecs )

    {

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

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

        {

        if ( aClientSideMedia )

            {

            iMediaStreams[i]->InitializeL( iManager, *this );

            }

        iMediaStreams[i]->InitializeL( *this, aDiscardUnusedCodecs );

        }

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

        {

        iBundles[i]->InitializeL( *this );

        }

    }

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

// CMceSession::UpdateL

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

//

EXPORT_C void CMceSession::UpdateL(

             TUint32 aTimeout,

             CDesC8Array* aHeaders, 

             HBufC8* aContentType,

             HBufC8* aContent,

             CDesC8Array* aContentHeaders ) 

    {

    MCECLI_DEBUG("CMceSession::UpdateL, Entry")

    TState state = State();

    MCECLI_DEBUG_CLISTATE( "state", state )

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

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

    User::LeaveIfError( 

        ( aContentType && aContent ) || 

       !( aContentType || aContent || aContentHeaders ) ? 

        KErrNone : KErrArgument );

    // Leave if in incoming state givem too small timeout value

    User::LeaveIfError( !( aTimeout > 0 && State() == CMceSession::EIncoming ) ||

        aTimeout <= SessionTimer() ? KErrNone : KErrArgument );

    // initialize streams

    InitializeL( EFalse ); 

    SetSIPParams( aHeaders, aContentType, aContentHeaders );

    if( !( aTimeout == 0 && State() == CMceSession::EIncoming ) )

        {

        FLAT_DATA( iTimeout ) = 

            ( aTimeout < FLAT_DATA( iMinSE ) ?  FLAT_DATA( iMinSE ) : aTimeout );    

        }

	SendUpdateL( aContent );   

	MCECLI_DEBUG("CMceSession::UpdateL, Exit")

    }

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

// CMceSession::SendUpdateL

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

//

void CMceSession::SendUpdateL( HBufC8* aContent )				            

    {

    MCECLI_DEBUG("CMceSession::SendUpdateL, Entry")

    TCleanupItem sipParamsCleanup( SIPParamsCleanup, this );

    CleanupStack::PushL( sipParamsCleanup );

    TMceIds ids;

	PrepareForITC( ids );

	ids.iState = State();

	CMceMsgObject<CMceSession>* msg = 

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

    CleanupStack::PushL( msg );

    // Don't pass aContent's ownership. Delete it when this function can't leave

	// anymore

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

    CleanupStack::PopAndDestroy( msg );

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

	TState state = State();

    MCECLI_DEBUG_CLISTATE( "CMceSession::SendUpdateL, after ITC, state", state )

    if ( ids.iStatus != KErrNone )

        {

        MCECLI_DEBUG("CMceSession::SendUpdateL, update failed. rollback")

    	TMceIds ids2;

        SynchronizeL( ids2 );

        state = State();

        MCECLI_DEBUG_CLISTATE( "CMceSession::SendUpdateL, after ITC, state", state )

        CleanupStack::Pop(); // sipParamsCleanup

        SetSIPParams( NULL, NULL, NULL );

        MMceSessionObserver* observer = iManager->SessionObserver();

        TMceTransactionDataContainer* container = iManager->TransactionContainer();

        if ( observer && container )

            {

            container->SetStatusCode( ids2.iStatus );

            observer->UpdateFailed( *this, container );

            container->Clear();

            }

        }

    else

        {

        CleanupStack::Pop(); // sipParamsCleanup

        SetSIPParams( NULL, NULL, NULL );

        }

	delete aContent;

    MCECLI_DEBUG("CMceSession::SendUpdateL, Exit")

    }

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

// CMceSession::SynchronizeL

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

//

void CMceSession::SynchronizeL( TMceIds& aIds )

    {

    MCECLI_DEBUG("CMceSession::SynchronizeL, Entry")

    PrepareForITC( aIds );

    aIds.iState = State();

    HBufC8* encodedSrvSession = iSender->ReadStringL( aIds, EMceItcGetSession );

    CleanupStack::PushL( encodedSrvSession );

    CMceMsgObject<CMceSession>* srvSession = 

            new (ELeave) CMceMsgObject<CMceSession>();

    CleanupStack::PushL( srvSession );

    srvSession->DecodeL( *encodedSrvSession );

    srvSession->PushL();

    UpdateL( *srvSession->iObject );

    CleanupStack::PopAndDestroy( srvSession );

    CleanupStack::PopAndDestroy( encodedSrvSession );

    MCECLI_DEBUG("CMceSession::SynchronizeL, Exit")

    }

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

// CMceSession::TerminateL

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

//

EXPORT_C void CMceSession::TerminateL( CDesC8Array* aHeaders,

					                   HBufC8* aContentType,

					                   HBufC8* aContent ) 

    {

    MCECLI_DEBUG("CMceSession::TerminateL, Entry")

    TState state = State();

    MCECLI_DEBUG_CLISTATE( "state", state )

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

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

    User::LeaveIfError( 

        ( aContentType && aContent ) || !( aContentType || aContent ) ? 

        KErrNone : KErrArgument );

	TMceIds ids;

	PrepareForITC( ids );

	ids.iState = State();

    CMceMsgSIPData* sipData = new (ELeave) CMceMsgSIPData( SipStrConsts::EBye,

                                                           *aHeaders, *aContentType );

    CleanupStack::PushL( sipData );

    sipData->OwnershipRollbackPushLC();

    iSender->SendL( ids, EMceItcTerminateSession, *sipData, aContent );

    CleanupStack::Pop(); // sipData->OwnershipRollbackPushLC()

    sipData->Close();

    CleanupStack::PopAndDestroy( sipData );

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

   	state = State();

    MCECLI_DEBUG_CLISTATE( "CMceSession::TerminateL, after ITC, state", state )

    MCECLI_DEBUG("CMceSession::TerminateL, Exit")

    }

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

// CMceSession::Streams

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

//

EXPORT_C const RPointerArray<CMceMediaStream>& CMceSession::Streams() const

    {

    return iMediaStreams;

    }

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

// CMceSession::Recipient

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

//

EXPORT_C const TDesC8& CMceSession::Recipient() const

    {

    return *FLAT_DATA( iRecipient );

    }

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

// CMceSession::Originator

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

//

EXPORT_C const TDesC8& CMceSession::Originator() const

    {

    return *FLAT_DATA( iOriginator );

    }

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

// CMceSession::Originator

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

//

EXPORT_C TUint32 CMceSession::SessionTimer() const

    {

    return FLAT_DATA( iTimeout );

    }

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

// CMceSession::SetSessionSDPLinesL

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

//

EXPORT_C void CMceSession::SetSessionSDPLinesL( CDesC8Array* aSessionSDPLines )

    {

    MCECLI_DEBUG("CMceSession::SetSessionSDPLinesL, Entry")

    User::LeaveIfError( State() == CMceSession::EIdle ||

		                State() == CMceSession::EIncoming ||

		                State() == CMceSession::EEstablished ? 

		                KErrNone : KErrNotReady );

    CDesC8Array* lines = ( aSessionSDPLines ? aSessionSDPLines :

        new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );	                

    delete FLAT_DATA( iLocalSessionSDPLines );

    FLAT_DATA( iLocalSessionSDPLines ) = lines;

    MCECLI_DEBUG("CMceSession::SetSessionSDPLinesL, Exit")

    }

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

// CMceSession::SessionSDPLinesL

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

//

EXPORT_C MDesC8Array* CMceSession::SessionSDPLinesL()

    {

    CDesC8Array*  lines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    CleanupStack::PushL( lines );

    for ( TInt i=0; i < FLAT_DATA( iRemoteSessionSDPLines )->Count(); i++ )

        {

        lines->AppendL( FLAT_DATA( iRemoteSessionSDPLines )->MdcaPoint( i ) );

        }

    CleanupStack::Pop( lines );

    return lines;

    }

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

// CMceRefer::AssociatedEvents

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

//

EXPORT_C RPointerArray< CMceEvent >* CMceSession::AssociatedEventsL() const

    {

    return NULL;

    }

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

// CMceRefer::AssociatedRefers

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

//

EXPORT_C RPointerArray< CMceRefer >* CMceSession::AssociatedRefersL() const

    {

    return NULL;

    }

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

// CMceSession::GetModifierL

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

//

EXPORT_C void CMceSession::GetModifierL( TMceSessionModifier aModifier,

                            TUint& aValue ) const

    {

    __ASSERT_ALWAYS( aModifier < KMceMaxSessionModifiers, 

                     User::Leave( KErrArgument ) );

    TUint value = _FLAT_DATA->Modifier( aModifier );

    aValue = value;

    }

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

// CMceSession::SetModifierL

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

//

EXPORT_C void CMceSession::SetModifierL( TMceSessionModifier aModifier, 

                            TUint aValue )        

    {

    __ASSERT_ALWAYS( aModifier < KMceMaxSessionModifiers, 

                     User::Leave( KErrArgument ) );

    _FLAT_DATA->Modifier( aModifier ) = aValue;

    if ( aModifier == KMceSecPreconditions && aValue == KMcePreconditionsE2ESupported )

    	{

    	_FLAT_DATA->Modifier( KMcePreconditions ) = KMcePreconditionsNotUsed;

    	}

    if ( aModifier == KMcePreconditions && aValue == KMcePreconditionsSupported &&

    	_FLAT_DATA->Modifier( KMceSecPreconditions ) != KMcePreconditionsE2ESupported )

    	{

    	_FLAT_DATA->Modifier( KMceSecPreconditions ) = KMcePreconditionsNotUsed;

    	}