/*

* 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:  Outgoing request establishing state for hold state machine.

*

*/

#include    <badesca.h>

#include    "mcesession.h"

#include    "mcemediastream.h"

#include    "mceaudiostream.h"

#include    "svpholdoutestablishingstate.h"

#include    "svpholdcontext.h"

#include    "svpholdcontroller.h"

#include    "svpholdattributehandler.h"

#include    "svpholdobserver.h"

#include    "svplogger.h"

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

// CSVPHoldOutEstablishingState::CSVPHoldOutEstablishingState

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

CSVPHoldOutEstablishingState::CSVPHoldOutEstablishingState()

    {

    }

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

// CSVPHoldOutEstablishingState::NewLC

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

CSVPHoldOutEstablishingState* CSVPHoldOutEstablishingState::NewLC()

    {

    CSVPHoldOutEstablishingState* self = 

        new ( ELeave ) CSVPHoldOutEstablishingState;

    CleanupStack::PushL( self );

    return self;

    }

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

// CSVPHoldOutEstablishingState::~CSVPHoldOutEstablishingState

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

CSVPHoldOutEstablishingState::~CSVPHoldOutEstablishingState()

    {

    }

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

// CSVPHoldOutEstablishingState::DoApplyL

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

//

void CSVPHoldOutEstablishingState::DoApplyL( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldOutEstablishingState::DoApply" );

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex; 

    CMceSession* session = aContext.SessionObject();

    const RPointerArray< CMceMediaStream >& streams = session->Streams();

    TInt streamCount = streams.Count();

    // Hold / Resume handling depends on the response received from network and

    // timers; any differences from normal handled in SpecialResponseHandling:

    if ( !aContext.SpecialResponseHandling( nextState ) )

        {

        for ( TInt i = 0; i < streamCount; i++ )

            {

            CMceMediaStream* mediaStream = streams[ i ];

            TMceMediaType mediaType = mediaStream->Type();

            if ( KMceAudio == mediaType )

                {

                // This media is audio stream. Handling depends on the request

                switch ( aContext.HoldRequest() )

                    {

                    case ESVPLocalHold:

                    case ESVPLocalResume:

                    case ESVPLocalDoubleHold:

                    case ESVPLocalDoubleHoldResume:

                        {

                        HandleLocalHoldL( aContext, mediaStream, nextState );

                        break;

                        }

                    case ESVPRemoteHold:

                    case ESVPRemoteResume:

                    case ESVPRemoteDoubleHold:

                    case ESVPRemoteDoubleHoldResume:

                        {

                        SVPDEBUG1(

                        "CSVPHoldOutEstablishingState::DoApply\

                         - Remote action - State Error" );                   

                        User::Leave( KErrSVPHoldStateError );

                        }

                    default:

                        {

                        // Error in request solving

                        SVPDEBUG2(

                        "CSVPHoldOutEstablishingState::CSVPHoldOutEstablishingState\

                         - Error, request %i",

                        aContext.HoldRequest() );

                        break;

                        }

                    }

                }

            }    

        }

    aContext.SetCurrentStateL( aContext, nextState );

    SVPDEBUG1( "CSVPHoldOutEstablishingState::DoApply - Handled" );

    }

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

// CSVPHoldOutEstablishingState::DoEnter

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

//

void CSVPHoldOutEstablishingState::DoEnter( CSVPHoldContext& /*aContext*/ )

    {

    SVPDEBUG1( "CSVPHoldOutEstablishingState::DoEnter" );

    }

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

// CSVPHoldOutEstablishingState::IsOutEstablishingStateActive

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

//

TBool CSVPHoldOutEstablishingState::IsOutEstablishingStateActive()

    {

    return ETrue;

    }

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

// CSVPHoldOutEstablishingState::HandleLocalHoldL

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

//

void CSVPHoldOutEstablishingState::

HandleLocalHoldL( CSVPHoldContext& aContext,

                  CMceMediaStream* aMediaStream,

                  TSVPHoldStateIndex& aNextState )

    {

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalHold:

            {

            // From Connected state

            HandleLocalHoldingL( aContext,

                                 aMediaStream,

                                 aNextState );

            break;

            }

        case ESVPLocalResume:

            {

            // From Out state

            HandleLocalResumingL( aContext,

                                  aMediaStream,

                                  aNextState );

            break;

            }

        case ESVPLocalDoubleHold:

            {

            // From In state

            HandleLocalHoldingL( aContext,

                                 aMediaStream,

                                 aNextState,

                                 KSVPHoldDHStateIndex );

            break;

            }

         case ESVPLocalDoubleHoldResume:

            {

            // From Doublehold state

            HandleLocalResumingL( aContext,

                                  aMediaStream,

                                  aNextState,

                                  KSVPHoldInStateIndex );

            break;

            }       

        }

    }

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

// CSVPHoldOutEstablishingState::HandleLocalHoldingL

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

//

void CSVPHoldOutEstablishingState::

HandleLocalHoldingL( CSVPHoldContext& aContext,

                     CMceMediaStream* mediaStream,

                     TSVPHoldStateIndex& aNextState,

                     TSVPHoldStateIndex aState )

    {

    SVPDEBUG1(

    "CSVPHoldOutEstablishingState::HandleLocalHoldingL" );

    MDesC8Array* attributeLines = mediaStream->MediaAttributeLinesL();

    CleanupDeletePushL( attributeLines );

    if ( KSVPHoldDHStateIndex == aState )

        {

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::HandleLocalHoldingL\

         - Next KSVPHoldDHStateIndex" );

        //aNextState = KSVPHoldDHStateIndex;

        KSVPHoldAttributeIndex neededAttribute = KSVPHoldInactiveIndex;

        CheckAttributeL( attributeLines,

                         neededAttribute,

                         aNextState,

                         aContext );

        }

    else

        {

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::HandleLocalHoldingL\

         - Next KSVPHoldOutStateIndex" );

        //aNextState = KSVPHoldOutStateIndex;

        KSVPHoldAttributeIndex neededAttribute = KSVPHoldRecvonlyIndex;

        CheckAttributeL( attributeLines,

                         neededAttribute,

                         aNextState,

                         aContext );

        }

    CleanupStack::PopAndDestroy( attributeLines );

    SVPDEBUG1( "CSVPHoldOutEstablishingState::HandleLocalHoldingL - Done" );

    }

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

// CSVPHoldOutEstablishingState::HandleLocalResumingL

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

//

void CSVPHoldOutEstablishingState::

HandleLocalResumingL( CSVPHoldContext& aContext,

                      CMceMediaStream* mediaStream,

                      TSVPHoldStateIndex& aNextState,

                      TSVPHoldStateIndex aState )

    {

    SVPDEBUG1(

    "CSVPHoldOutEstablishingState::HandleLocalResumingL" );

    MDesC8Array* attributeLines = mediaStream->MediaAttributeLinesL();

    CleanupDeletePushL( attributeLines );

    if ( KSVPHoldInStateIndex == aState )

        {

        // Resume from doublehold:

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::HandleLocalResumingL\

         - Next KSVPHoldInStateIndex" );

        //aNextState = KSVPHoldInStateIndex;

        KSVPHoldAttributeIndex neededAttribute = KSVPHoldSendonlyIndex;

        CheckAttributeL( attributeLines,

                         neededAttribute,

                         aNextState,

                         aContext );    

        }

    else

        {

        // Basic resume:

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::HandleLocalResumingL\

         - Next KSVPHoldConnectedStateIndex" );

        //aNextState = KSVPHoldConnectedStateIndex;

        KSVPHoldAttributeIndex neededAttribute = KSVPHoldSendrecvIndex;

        CheckAttributeL( attributeLines,

                         neededAttribute,

                         aNextState,

                         aContext );                                  

        }

    CleanupStack::PopAndDestroy( attributeLines );

    SVPDEBUG1(

    "CSVPHoldOutEstablishingState::HandleLocalResumingL - Done" );

    }

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

// CSVPHoldOutEstablishingState::CheckAttributeL

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

//

TInt CSVPHoldOutEstablishingState::

CheckAttributeL( MDesC8Array* aAttributeLines,

                KSVPHoldAttributeIndex aNeededAttribute,

                TSVPHoldStateIndex& aNextState,

                CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldOutEstablishingState::CheckAttributeL" );

    KSVPHoldAttributeIndex responseAttribute =

        aContext.AttributeHandler().FindDirectionAttribute( aAttributeLines );

    if ( KErrNotFound == responseAttribute )

        {

        SVPDEBUG1( "CSVPHoldOutEstablishingState::CheckAttributeL - Session level" );

        MDesC8Array* sessionAttributeLines =

            aContext.SessionObject()->SessionSDPLinesL();

        responseAttribute =

            aContext.AttributeHandler().FindDirectionAttribute(

                sessionAttributeLines );

        aContext.SessionObject()->SetSessionSDPLinesL(

            static_cast<CDesC8Array*>( sessionAttributeLines ) );

        SVPDEBUG1( "CSVPHoldOutEstablishingState::CheckAttributeL - Session level done" );

        }

    if ( aNeededAttribute == responseAttribute || 

         KErrNotFound == responseAttribute )

        {

        // If there is no attributes in response; but 200Ok is received;

        // state change is done based to default cases.

        return DefineDefaultCaseStateChange( aContext, aNextState );

        }

    else if ( KSVPHoldSendrecvIndex == aNeededAttribute &&

              KErrNotFound == responseAttribute )

        {

        // If there is no direction attribute at all, default is sendrecv

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::CheckAttributeL - No attribute" );

        aNextState = KSVPHoldConnectedStateIndex;

        return KErrNone;

        }

    else if ( KSVPHoldSendrecvIndex == aNeededAttribute &&

              KSVPHoldRecvonlyIndex == responseAttribute )

        {

        // Radvision client fix (it responds to resume with recvonly)

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::CheckAttributeL - recvonly to resume.." );

        aNextState = KSVPHoldConnectedStateIndex;

        return KErrNone;

        }

    else if ( KSVPHoldRecvonlyIndex == aNeededAttribute &&

              KSVPHoldInactiveIndex == responseAttribute )

        {

        // Inactive response to local hold is allowed

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::CheckAttributeL - No attribute" );

        aNextState = KSVPHoldOutStateIndex;

        return KErrNone;

        }

    else if( KSVPHoldSendonlyIndex == responseAttribute &&

             KSVPHoldInactiveIndex == aNeededAttribute )

        {

        // Sendonly response to local DH (accept for IOP)

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::CheckAttributeL - Sendonly to Inactive request" );

        aNextState = KSVPHoldDHStateIndex;

        return KErrNone;        

        }

    else if( KSVPHoldSendonlyIndex == aNeededAttribute &&

             KSVPHoldInactiveIndex == responseAttribute )

        {

        // Inactive response to local DH resume (accept for IOP)

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::CheckAttributeL - Inactive to DH resume request" );

        aNextState = KSVPHoldInStateIndex;

        return KErrNone;        

        }   

    else if ( KSVPHoldSendrecvIndex == responseAttribute )

        {

        // Response has sendrecv -attribute

        return ResolveStateFromSendRecvIndex( aNeededAttribute, aNextState );

        }

    else

        {

        SVPDEBUG1(

        "CSVPHoldOutEstablishingState::CheckAttributeL - else" );

        return KErrNone;

        }        

    }

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

// CSVPHoldOutEstablishingState::DefineDefaultCaseStateChange

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

//

TInt CSVPHoldOutEstablishingState::

DefineDefaultCaseStateChange( CSVPHoldContext& aContext,

                              TSVPHoldStateIndex& aNextState )

    {

    SVPDEBUG1( "CSVPHoldOutEstablishingState::DefineDefaultCaseStateChange" );

    // Basic cases (e.g for holding "sendonly" answer has "recvonly")

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalHold:

            {

            SVPDEBUG1( "    ESVPLocalHold" );

            aNextState = KSVPHoldOutStateIndex;

            return KErrNone;

            }

        case ESVPLocalResume:

            {

            SVPDEBUG1( "    ESVPLocalResume" );

            aNextState = KSVPHoldConnectedStateIndex;

            return KErrNone;

            }

        case ESVPLocalDoubleHold:

            {

            SVPDEBUG1( "    ESVPLocalDoubleHold" );

            aNextState = KSVPHoldDHStateIndex;

            return KErrNone;

            }

        case ESVPLocalDoubleHoldResume:

            {

            SVPDEBUG1( "    ESVPLocalDoubleHoldResume" );

            aNextState = KSVPHoldInStateIndex;

            return KErrNone;

            }

        default:

            {

            SVPDEBUG1(

            "CSVPHoldOutEstablishingState::DefineDefaultCaseStateChange" );

             return KErrNone;

            }

        }    

    }

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

// CSVPHoldOutEstablishingState::ResolveStateFromSendRecvIndex

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

//

TInt CSVPHoldOutEstablishingState::

ResolveStateFromSendRecvIndex( KSVPHoldAttributeIndex aNeededAttribute,

                               TSVPHoldStateIndex& aNextState )

    {

    SVPDEBUG1( "CSVPHoldOutEstablishingState::ResolveStateFromSendRecvIndex" );

    switch ( aNeededAttribute )

        {

        case KSVPHoldRecvonlyIndex:

            {

            aNextState = KSVPHoldOutStateIndex;

            return KErrNone;

            }

        case KSVPHoldInactiveIndex:

            {

            aNextState = KSVPHoldDHStateIndex;

            return KErrNone;

            }

        case KSVPHoldSendonlyIndex:

            {

            aNextState = KSVPHoldInStateIndex;

            return KErrNone;

            }

        default:

            {

            SVPDEBUG1(

            "CSVPHoldOutEstablishingState::CheckAttributeL - Last default" );

            return KErrNone;

            }

        }

    }