/*

* Copyright (c) 2006-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:  Base class for session context

*

*/

#include    <s32mem.h>

#include    <in_sock.h>

#include    <in_pkt.h>

#include    <badesca.h>

#include    <mcesession.h>

#include    <mcemanager.h>

#include    <mcetransactiondatacontainer.h>

#include    <mcertpsource.h>

#include    <mcertpsink.h>

#include    <mcemediastream.h>

#include    <mceaudiostream.h>

#include    <sdpcodecstringpool.h>

#include    <sdpcodecstringconstants.h>

#include    <sdpdocument.h>

#include    <sdpconnectionfield.h>

#include    "svpholdcontext.h"

#include    "svpholdoutstate.h"

#include    "svpholdinestablishingstate.h"

#include    "svpholdoutestablishingstate.h"

#include    "svpholdinstate.h"

#include    "svpholdconnectedstate.h"

#include    "svpholddhstate.h"

#include    "svpholdcontroller.h"

#include    "svpholdmediahandler.h"

#include    "svpholdattributehandler.h"

#include    "svpholdobserver.h"

#include    "svplogger.h"

#include    "svpaudioutility.h"

#include    "svpsipconsts.h"

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

// CSVPHoldContext::CSVPHoldContext

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

//

CSVPHoldContext::CSVPHoldContext( TMceTransactionDataContainer& aContainer,

                                  TBool aIsMobileOriginated ) :

        iStates( NULL ),

        iObserver( NULL ),

        iCurrentState( NULL ),

        iHoldRequest( ESVPNoType ),

        iSession( NULL ),

        iOutgoing( ETrue ),

        iAttributeHandler( NULL ),

        iMediaHandler( NULL ),

        iFirstAttempt( ETrue ),

        iRemoteRequestNotProcessed( ETrue ),

        iContainer( aContainer ),

        iAllowAudioHandling( EFalse ),

        iResponseStatusCode( KErrNotFound ),

        iForceHoldOccured( EFalse ),

        iTimedOut( EFalse ),

        iRollBack( EFalse ),

        iHoldFail( EFalse ),

        iResumeFail( EFalse ),

        iMuted( EFalse ),

        iCrossOver( EFalse ),

        iCallRequest( EFalse )

    {

    iIsMobileOriginated = aIsMobileOriginated;

    }

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

// CSVPHoldContext::ConstructL

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

//

void CSVPHoldContext::ConstructL( CMceSession& aSession,

                                  MSVPHoldObserver* aObserver )

    {

    SVPDEBUG1( "CSVPHoldContext::ConstructL In" );

    iObserver = aObserver;

    // Create the states in the state array.

    InitializeStateArrayL();

    iAttributeHandler = CSVPHoldAttributeHandler::NewL();

    iMediaHandler = CSVPHoldMediaHandler::NewL();

    SetSessionObject( &aSession );

    // Initialize connected state to current state. Note, that it is not

    // applied yet.

    SetCurrentStateL( *this, KSVPHoldConnectedStateIndex );

    SetAudioHandlingAllowed( ETrue );

    SVPDEBUG1( "CSVPHoldContext::ConstructL Done" );

    }

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

// CSVPHoldContext::NewL

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

//

CSVPHoldContext* CSVPHoldContext::NewL( 

                            CMceSession& aSession,

                            TMceTransactionDataContainer& aContainer,

                            MSVPHoldObserver* aObserver,

                            TBool aIsMobileOriginated )

    {    

    CSVPHoldContext* self = new ( ELeave ) CSVPHoldContext( aContainer,

                                                            aIsMobileOriginated );

    CleanupStack::PushL( self );

    self->ConstructL( aSession, aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSVPHoldContext::IsStateTransitionAccepted

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

//

TBool CSVPHoldContext::

IsStateTransitionAccepted( const TSVPHoldStateIndex aStateIndex )

    {

    TSVPHoldStateIndex current = CurrentState();

    switch( current )

        {

        case KErrNotFound:

            {

            // Only connected state can be the first one.

            if ( KSVPHoldConnectedStateIndex == aStateIndex )

                {

                return ETrue;

                }

            else

                {

                return EFalse;

                }

            }

        case KSVPHoldConnectedStateIndex:

        case KSVPHoldInStateIndex:

        case KSVPHoldDHStateIndex:

            { 

            // From main states transitions to in or out establishing

            // states are accepted.

            if ( KSVPHoldEstablishingStateIndex  == aStateIndex )

                {

                return ETrue;

                }

            else

                {

                return EFalse;

                }

            }

        case KSVPHoldOutStateIndex:

            {

            // From hold out state transitions to in and out establishing

            // and connected states are accepted.

            if ( KSVPHoldEstablishingStateIndex  == aStateIndex ||

                 KSVPHoldConnectedStateIndex  == aStateIndex )

                {

                return ETrue;

                }

            else

                {

                return EFalse;

                }

            }

        case KSVPHoldEstablishingStateIndex:

            {

            // From establishing states transitions to main states

            // are accepted.

            if ( KSVPHoldEstablishingStateIndex == aStateIndex ||

                 KSVPHoldConnectedStateIndex  == aStateIndex ||

                 KSVPHoldOutStateIndex == aStateIndex ||

                 KSVPHoldInStateIndex == aStateIndex ||

                 KSVPHoldDHStateIndex == aStateIndex )

                {

                return ETrue;

                }

            else

                {

                return EFalse;

                }

            }

        default:

            {

            // Should not come here, since all the states are handled

            SVPDEBUG1( "CSVPHoldContext::IsStateTransitionAccepted - Error" );

            return EFalse;

            }

        }

    }

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

// CSVPHoldContext::~CSVPHoldContext

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

//

CSVPHoldContext::~CSVPHoldContext()

    {

    SVPDEBUG1( "CSVPHoldContext::~CSVPHoldContext - In" );

    if ( iStates )

        {

        iStates->ResetAndDestroy();

        iStates->Close();

        delete iStates;

        }

    delete iAttributeHandler;

    delete iMediaHandler;

    SVPDEBUG1( "CSVPHoldContext::~CSVPHoldContext - Done" );

    }

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

// CSVPHoldContext::InitializeStateArrayL

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

//

void CSVPHoldContext::InitializeStateArrayL()

    {

    // Create state array

    iStates = new ( ELeave ) RPointerArray< CSVPHoldStateBase >

                                                ( KSVPHoldStateArraySize );

    // States are created here:

    // Connected state

    CSVPHoldConnectedState* connectedState =

                    CSVPHoldConnectedState::NewLC();

    User::LeaveIfError( iStates->Insert( connectedState,

                                         KSVPHoldConnectedStateIndex ) );

    CleanupStack::Pop( connectedState );

    // Establishing state initialized to outgoing (MO hold)

    CSVPHoldOutEstablishingState* outEstState =

                    CSVPHoldOutEstablishingState::NewLC();

    User::LeaveIfError( iStates->Insert( outEstState,

                                         KSVPHoldEstablishingStateIndex ) );

    CleanupStack::Pop( outEstState );

    // Outgoing state (MO hold)

    CSVPHoldOutState* outState =

                    CSVPHoldOutState::NewLC();

    User::LeaveIfError( iStates->Insert( outState,

                                         KSVPHoldOutStateIndex ) );

    CleanupStack::Pop( outState );

    // Incoming state (MT hold)

    CSVPHoldInState* inState =

                    CSVPHoldInState::NewLC();

    User::LeaveIfError( iStates->Insert( inState,

                                         KSVPHoldInStateIndex ) );

    CleanupStack::Pop( inState );

    // Doublehold state (MO & MT simultaneous hold)

    CSVPHoldDHState* dhState =

                    CSVPHoldDHState::NewLC();

    User::LeaveIfError( iStates->Insert( dhState,

                                         KSVPHoldDHStateIndex ) );

    CleanupStack::Pop( dhState );

    }

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

// CSVPHoldContext::SetCurrentStateL

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

//

void CSVPHoldContext::SetCurrentStateL( CSVPHoldContext& aContext,

                                        TSVPHoldStateIndex aStateIndex )

    {

    // Check that the transition is valid:

    if ( !IsStateTransitionAccepted( aStateIndex ) )

        {

        SVPDEBUG2( "CSVPHoldContext::SetCurrentStateL - State error, New: %i",

                    aStateIndex );

        User::Leave( KErrSVPHoldStateError );

        }        

    else

        {

        SVPDEBUG2( "CSVPHoldContext::SetCurrentStateL - Set state from %i",

                    CurrentState() );

        SVPDEBUG2( "CSVPHoldContext::SetCurrentStateL - Set state to %i",

                    aStateIndex );

        iCurrentState = ( *iStates )[ aStateIndex ];

        iCurrentState->Enter( aContext );

        iAllowAudioHandling = ETrue;

        }

    }

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

// CSVPHoldContext::CurrentState

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

//

TSVPHoldStateIndex CSVPHoldContext::CurrentState() const

   {

   return iStates->Find( iCurrentState );

   }

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

// CSVPHoldContext::ApplyCurrentStateL

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

//

void CSVPHoldContext::ApplyCurrentStateL( CMceSession* aSession,

                    TSVPHoldDesiredTransition aTransition )

    {

    SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL IN" )

    // Set back to false, because new hold/resume attemp starts

    iRollBack = EFalse;

    SetSessionObject( aSession );

    if ( ToEstablishing() && FirstAttempt() )

        {

        SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL - New request" )

        iHoldRequest = RequestType( aTransition );

        UpdateEstablishingStateL();

        }

    if ( ESVPHoldIncoming == aTransition )

        {

        SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL - Remote request" )

        iHoldRequest = RequestType( aTransition );        

        SetRemoteRequestNotProcessed( ETrue );

        iCurrentState->ApplyL( *this );

        }

    else

        {

        SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL - Local request" )

        iHoldRequest = RequestType( aTransition );

        if ( ESVPLocalResume == iHoldRequest )

            {

            SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL - Enable oldway hold" );

            // establish Old way hold support 

            aSession->SetModifierL( KMceMediaDirection, 

                                    KMceMediaDirectionWithAddress );

            }

        iCurrentState->ApplyL( *this );

        }

    SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL OUT" )

    }

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

// CSVPHoldContext::ApplyCurrentStateL

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

//

void CSVPHoldContext::ApplyCurrentStateL()

    {

    if ( KSVPHoldEstablishingStateIndex == CurrentState() )

        {

        SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL2" );

        iCurrentState->ApplyL( *this );

        }

    else

        {

        SVPDEBUG1( "CSVPHoldContext::ApplyCurrentStateL2 - State error" );

        User::Leave( KErrSVPHoldStateError );

        }

    }

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

// CSVPHoldContext::SetSessionObject

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

//

void CSVPHoldContext::SetSessionObject( CMceSession* aSession )

    {

    iSession = aSession;

    }

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

// CSVPHoldContext::SessionObject

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

//

CMceSession* CSVPHoldContext::SessionObject()

    {

    return iSession;

    }

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

// CSVPHoldContext::HoldRequest

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

//

TSVPHoldRequestType CSVPHoldContext::HoldRequest()

    {

    return iHoldRequest;

    }

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

// CSVPHoldContext::IsRemoteRequest

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

//

TBool CSVPHoldContext::IsRemoteRequest()

    {

    TSVPHoldRequestType request = HoldRequest();

    if ( ESVPRemoteHold == request || ESVPRemoteResume == request ||

         ESVPRemoteDoubleHold == request ||

         ESVPRemoteDoubleHoldResume == request )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CSVPHoldContext::HoldEvent

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

//

MCCPCallObserver::TCCPCallEvent CSVPHoldContext::HoldEvent()

    {

    return iHoldEvent;

    }

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

// CSVPHoldContext::SetFirstAttempt

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

//

void CSVPHoldContext::SetFirstAttempt( TBool aValue )

    {

    iFirstAttempt = aValue;

    }

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

// CSVPHoldContext::FirstAttempt

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

//

TBool CSVPHoldContext::FirstAttempt()

    {

    return iFirstAttempt;

    }

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

// CSVPHoldContext::SetRemoteRequestNotProcessed

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

//

void CSVPHoldContext::SetRemoteRequestNotProcessed( TBool aValue )

    {

    iRemoteRequestNotProcessed = aValue;

    }

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

// CSVPHoldContext::RemoteRequestNotProcessed

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

//

TBool CSVPHoldContext::RemoteRequestNotProcessed()

    {

    return iRemoteRequestNotProcessed;

    }

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

// CSVPHoldContext::SetAudioHandlingAllowed

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

//

void CSVPHoldContext::SetAudioHandlingAllowed( TBool aValue )

    {

    iAllowAudioHandling = aValue;

    }

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

// CSVPHoldContext::AudioHandlingAllowed

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

//

TBool CSVPHoldContext::AudioHandlingAllowed()

    {

    return iAllowAudioHandling;

    }

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

// CSVPHoldContext::CheckOldwayHoldL

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

//

TSVPHoldRequestType CSVPHoldContext::

CheckOldwayHoldL( CMceSession& aSession,

                  TSVPHoldRequestType aPresumedRequest )

    {

    SVPDEBUG1( "CSVPHoldContext::CheckOldwayHoldL" );

    TBool oldWayHold = EFalse;    

    const RPointerArray< CMceMediaStream >& mediaStreams = aSession.Streams();

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

        {

        CMceAudioStream* stream = 

            static_cast< CMceAudioStream* >( mediaStreams[ i ] );

        if ( !SVPAudioUtility::IsDownlinkStream( *stream ) )

            {

            if ( !stream->IsEnabled() )

                {

                oldWayHold = ETrue;

                }

            }

        else if ( stream->BoundStream() )

            {

            CMceMediaStream& boundStream = stream->BoundStreamL();

            if ( !boundStream.IsEnabled() )

                {

                oldWayHold = ETrue;

                }

            }

        }