/*

* 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:  Local holded state for hold state machine.

*

*/

#include    <badesca.h>

#include    <mcesession.h>

#include    <mcertpsource.h>

#include    <mcertpsink.h>

#include    <mcemediastream.h>

#include    <mceaudiostream.h>

#include    "svpholdoutstate.h"

#include    "svpholdcontext.h"

#include    "svpholdcontroller.h"

#include    "svpholdobserver.h"

#include    "svpholdattributehandler.h"

#include    "svpholdmediahandler.h"

#include    "svplogger.h"

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

// CSVPHoldOutState::CSVPHoldOutState

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

CSVPHoldOutState::CSVPHoldOutState()

    {

    }

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

// CSVPHoldOutState::NewLC

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

CSVPHoldOutState* CSVPHoldOutState::NewLC()

    {

    CSVPHoldOutState* self = new ( ELeave ) CSVPHoldOutState;

    CleanupStack::PushL( self );

    return self;

    }

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

// CSVPHoldOutState::~CSVPHoldOutState

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

CSVPHoldOutState::~CSVPHoldOutState()

    {

    }

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

// CSVPHoldOutState::DoApplyL

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

//

void CSVPHoldOutState::DoApplyL( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldOutState::DoApply" );

    CMceSession* session = aContext.SessionObject();

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

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    TInt audioStreamsHandled = 0;

    TInt streamCount = streams.Count();

    SVPDEBUG2( "CSVPHoldÓutState::DoApply - stream count = %i", streamCount ); 

    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

            SVPDEBUG2( "CSVPHoldOutState::DoApply - Hold request is = %i",

                        aContext.HoldRequest() );

            nextState = PerformRequestL( aContext, *mediaStream, *session );

            audioStreamsHandled++;                

            }

        }

    if ( 0 == audioStreamsHandled )

        {

        SVPDEBUG1(

        "CSVPHoldOutState::DoApply - No audio streams found!" );

        User::Leave( KErrSVPHoldStateError );

        }

    if ( aContext.ForceHoldOccured() )

        {

        nextState = KSVPHoldConnectedStateIndex;

        aContext.SetForceHold( EFalse ); 

        }

    aContext.SetCurrentStateL( aContext, nextState );

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

    }

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

// CSVPHoldOutState::PerformRequestL

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

//

TSVPHoldStateIndex 

CSVPHoldOutState::PerformRequestL( CSVPHoldContext& aContext,

                                   CMceMediaStream& aMediaStream,

                                   CMceSession& aSession )

    {

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalResume:

            {

            ResumeSessionLocallyL( aContext, aMediaStream, aSession );

            break;

            }

        case ESVPRemoteDoubleHold:

            {

            RemoteSessionDoubleHoldL( aContext, aMediaStream, aSession );

            break;

            }                    

        case ESVPLocalHold:

        case ESVPLocalDoubleHold:

        case ESVPLocalDoubleHoldResume:

        case ESVPRemoteHold:

        case ESVPRemoteResume:

        case ESVPRemoteDoubleHoldResume:

            {

            // Cannot occur in Out state

            SVPDEBUG1( "CSVPHoldOutState::PerformRequestL - StateError" );

            User::Leave( KErrSVPHoldStateError );                    

            }

        default:

            {

            // No state change needed:

            nextState = KSVPHoldOutStateIndex;

            // Error in previous request solving

            SVPDEBUG2( "CSVPHoldOutState::PerformRequestL - Error, request %i",

                        aContext.HoldRequest() );

            User::Leave( KErrSVPHoldStateError );

            }               

        }    

    return nextState;

    }

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

// CSVPHoldOutState::ResumeSessionLocallyL

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

//

void CSVPHoldOutState::ResumeSessionLocallyL( CSVPHoldContext& aContext,

                                              CMceMediaStream& aMediaStream,

                                              CMceSession& aSession )

    {

    SVPDEBUG1( "CSVPHoldOutState::ResumeSessionLocallyL - In" );

    // Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPLocalResume );        		    

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldOutState::ResumeSessionLocallyL - done" );    

    }

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

// CSVPHoldOutState::RemoteSessionDoubleHoldL

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

//

void CSVPHoldOutState::RemoteSessionDoubleHoldL( CSVPHoldContext& aContext,

                                                 CMceMediaStream& aMediaStream,

                                                 CMceSession& aSession )

    {

    SVPDEBUG1(

    "CSVPHoldOutState::RemoteSessionDoubleHoldL - In" );

    MDesC8Array* attributeLines = aMediaStream.MediaAttributeLinesL();

    CleanupDeletePushL( attributeLines );

    // Check that request has reasonable direction attribute:

    TSVPHoldRequestType attribute =

                  aContext.SolveRequestL( aSession,

                                          attributeLines );

    if ( ESVPNoType == attribute )

        {

        // Not hold request

        SVPDEBUG1( "CSVPHoldOutState::RemoteSessionDoubleHoldL:");

        SVPDEBUG1( "Not hold request" );

        User::Leave( KErrSVPHoldNotHoldRequest );

        }

    CleanupStack::PopAndDestroy( attributeLines );

    // Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPRemoteDoubleHold );

    // Update session

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldOutState::RemoteSessionDoubleHoldL - done" );    

    }

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

// CSVPHoldOutState::DoEnter

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

//

void CSVPHoldOutState::DoEnter( CSVPHoldContext& aContext )

    {

    SVPDEBUG2( "CSVPHoldOutState::DoEnter - Request %i",

                aContext.HoldRequest() );

    TInt err = KErrNone;

    TRAP( err, aContext.MediaHandler().DisableAudioL( aContext ) );

    // succesfull action is informed to client

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalHold:

            {

            SVPDEBUG1( 

            "CSVPHoldOutState::DoEnter - LocalHold" );

            if ( err )

                {

                aContext.HoldObserver().HoldRequestFailed();

                }

            else

                {

                aContext.HoldObserver().SessionLocallyHeld();

                }

            break;

            }

        case ESVPRemoteDoubleHoldResume:

            {

            SVPDEBUG1(

            "CSVPHoldOutState::DoEnter - ESVPRemoteDoubleHoldResume" );

            if ( err )

                {

                //aContext.HoldObserver().ResumeRequestFailed();

                }

            else

                {

                aContext.HoldObserver().SessionRemoteResumed();

                }

            break;            

            }

        default:

            {

            // Nothing to do; occurs only with state rollback

            SVPDEBUG1( "CSVPHoldOutState::DoEnter - Default" );

            break;

            }

        }

    }

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

// CSVPHoldOutState::IsOutEstablishingStateActive

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

//

TBool CSVPHoldOutState::IsOutEstablishingStateActive()

    {

    return EFalse;

    }