/*

* 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 "mcesession.h"

//#include "mceinsession.h"

#include "mcemanager.h"

#include "mcestreambundle.h"

#include "mcemediastream.h"

#include "mceinsessionobserver.h"

#include "mcesessionobserver.h"

#include "mcestreamobserver.h"

#include "mcertpobserver.h"

#include "mcetransactiondatacontainer.h"

#include "mussessionsimulator.h"

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

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

// CMceSession::~CMceSession

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

//

EXPORT_C CMceSession::~CMceSession()

    {

    delete iHeaders;

    delete iSessionSDPLines;

    delete iOriginator;

    delete iRecipient;

    iMediaStreams.ResetAndDestroy();

    iBundles.ResetAndDestroy();

    }

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

// CMceSession::State

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

//

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

    {

    return iState;

    }

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

// CMceSession::ConnectionActive

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

//

EXPORT_C TBool CMceSession::ConnectionActive() const

    {

    return iIsConnectionActive;

    }

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

// CMceSession::RemoveStreamL

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

//

EXPORT_C void CMceSession::RemoveStreamL( CMceMediaStream& aMediaStream )

    {

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

        {

        if ( &aMediaStream == iMediaStreams[i] )

            {

            delete iMediaStreams[i];

            iMediaStreams.Remove( i );

            return;

            }

        }

    User::Leave( KErrNotFound );

    }

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

// CMceSession::AddStreamL

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

//

EXPORT_C void CMceSession::AddStreamL( CMceMediaStream* aMediaStream )

    {

    User::LeaveIfError( iMediaStreams.Find( aMediaStream ) != KErrNotFound ? 

                                            KErrArgument : KErrNone );

    aMediaStream->InitializeL( *this ); // Initialize before taking ownership

    iMediaStreams.AppendL( aMediaStream );

    }

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

// CMceSession::UpdateL

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

//

EXPORT_C void CMceSession::UpdateL(

             TUint32 aTimeout,

             CDesC8Array* aHeaders, 

             HBufC8* aContentType,

             HBufC8* aContent,

             CDesC8Array* aContentHeaders ) 

    {

    User::LeaveIfError( iState != 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 );

    InitializeL(); 

    iTimeout = aTimeout;

    delete iHeaders; 

    iHeaders = aHeaders;

    delete aContentType;

    delete aContentHeaders;

    if ( iState == EIncoming )

        {

        iState = EReserving;

        RestartSimulator();

        }

    else

        {

        iState = EOffering;

        }

    }

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

// CMceSession::InitializeL

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

//

/*

void CMceSession::InitializeL()

    {

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

        {

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

        }

    }

  */  

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

// CMceSession::TerminateL

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

//

EXPORT_C void CMceSession::TerminateL( CDesC8Array* aHeaders,

					                   HBufC8* aContentType,

					                   HBufC8* aContent ) 

    {

    __ASSERT_ALWAYS( iState != CMceSession::EIdle, User::Leave( KErrNotReady ) );

    delete iHeaders;

    iHeaders = aHeaders;

    delete aContentType;

    delete aContent;

   	iState = CMceSession::ETerminating;

   	RestartSimulator();

    }

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

// CMceSession::Streams

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

//

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

    {

    return iMediaStreams;

    }

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

// CMceSession::Recipient

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

//

EXPORT_C const TDesC8& CMceSession::Recipient() const

    {

    return *iRecipient;

    }

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

// CMceSession::Originator

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

//

EXPORT_C const TDesC8& CMceSession::Originator() const

    {

    return *iOriginator;

    }

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

//

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

//

EXPORT_C void CMceSession::SetSessionSDPLinesL( CDesC8Array* aSessionSDPLines )

    {

    delete iSessionSDPLines;

    iSessionSDPLines = aSessionSDPLines;

    }

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

//

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

//

EXPORT_C MDesC8Array* CMceSession::SessionSDPLinesL()

    {

    if ( iSessionSDPLines )

        {

        CDesC8Array* array = new ( ELeave ) CDesC8ArrayFlat( 1 );

        CleanupStack::PushL( array );

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

            {

            array->AppendL( iSessionSDPLines->MdcaPoint(i) );

            }

        CleanupStack::Pop( array );

        return array;

        }

    return NULL;

    }

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

//

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

//

EXPORT_C TUint32 CMceSession::SessionTimer() const

    {

    return iTimeout;

    }

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

// CMceSession::AddBundleL

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

//

EXPORT_C void CMceSession::AddBundleL( CMceStreamBundle* aBundle )

    {

    iBundles.AppendL( aBundle );

    }

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

// CMceSession::RemoveBundleL

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

//

EXPORT_C void CMceSession::RemoveBundleL( CMceStreamBundle& aBundle )

    {

    TInt index = iBundles.Find( &aBundle );

    User::LeaveIfError( index );

    iBundles.Remove( index );

    }

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

// CMceSession::Bundles

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

//

EXPORT_C const RPointerArray< CMceStreamBundle >& CMceSession::Bundles() const

    {

    return iBundles;

    }

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

// CMceSession::GetModifierL

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

//

EXPORT_C void CMceSession::GetModifierL( TMceSessionModifier aModifier,

                                         TUint& aValue ) const

    {

    if ( aModifier == KMcePreconditions )

        {

        if ( iForceInternetSignaling )

            {

            aValue = KMcePreconditionsNotUsed;

            }

        else

            {

            aValue = KMcePreconditionsSupported;

            }

        return;

        }

    User::Leave( KErrNotFound );

    }

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

// CMceSession::SetModifierL

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

//

EXPORT_C void CMceSession::SetModifierL( TMceSessionModifier aModifier, 

                                         TUint aValue )        

    {

    if ( aModifier == KMcePreconditions )

        {

        if ( aValue == KMcePreconditionsNotUsed )

            {

            iForceInternetSignaling = ETrue;

            }

        else

            {

            iForceInternetSignaling = EFalse;

            }

        return;

        }

    else if ( aModifier == KMce100Rel )

        {

        if ( aValue >= 0 && aValue <= 2 )

            {

            i100RelUsage = aValue;

            return;

            }

        }

    User::LeaveIfError( KErrNotSupported );

    }

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

// CMceSession::Profile

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

//

EXPORT_C TUint32 CMceSession::Profile() const

    {

    return iProfileId;

    }

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

// CMceSession::CMceSession

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

//

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

 : iProfileId( aProfileId ),

   iManager( aManager ),

   iState( CMceSession::EIdle),

   iIsConnectionActive( ETrue ),

   iForceInternetSignaling( EFalse ),

   i100RelUsage( 1 ), // MCE default

   iFailWithCode( KErrNone ),

   iReasonPhrase( KNullDesC8() ),

   iReasonCode( 0 )

    {

    }

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

// CMceSession::Manager

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

//

CMceManager& CMceSession::Manager() const

    {

    return *iManager;

    }

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

// CMceSession::ConstructL

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

//

void CMceSession::ConstructL()

    {

    }

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

// CMceSession::InitializeL

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

//

void CMceSession::InitializeL()

    {

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

        {

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

        }

    /*    

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

        {

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

        }

    */

    }

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

// CMceSession::RestartSimulator

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

//

void CMceSession::RestartSimulator()

    {

    if( iManager->iSessionSimulator->IsRunning())

        {

        iManager->iSessionSimulator->Stop();

        }

    iManager->iSessionSimulator->StartL();    

    }