/*

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

*

*/

#include    <badesca.h>

#include    <mcesession.h>

#include    <mcertpsource.h>

#include    <mcertpsink.h>

#include    <mcemediastream.h>

#include    <mceaudiostream.h>

#include    "svpholddhstate.h"

#include    "svpholdcontroller.h"

#include    "svpholdobserver.h"

#include    "svpholdmediahandler.h"

#include    "svplogger.h"

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

// CSVPHoldDHState::CSVPHoldDHState

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

//

CSVPHoldDHState::CSVPHoldDHState()

    {

    }

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

// CSVPHoldDHState::NewL

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

//

CSVPHoldDHState* CSVPHoldDHState::NewLC()

    {

    CSVPHoldDHState* self = new ( ELeave ) CSVPHoldDHState;

    CleanupStack::PushL( self );

    return self;

    }

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

// CSVPHoldDHState::~CSVPHoldDHState

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

//

CSVPHoldDHState::~CSVPHoldDHState()

    {

    }

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

// CSVPHoldDHState::DoApplyL

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

//

void CSVPHoldDHState::DoApplyL( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldDHState::DoApply" );

    CMceSession* session = aContext.SessionObject();

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

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    TInt audioStreamsHandled = 0;

    TInt streamCount = streams.Count();    

    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

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

            audioStreamsHandled++;                

            }

        }

    if ( 0 == audioStreamsHandled )

        {

        SVPDEBUG1( "CSVPHoldDHState::DoApply - No streams - Leave" );

        User::Leave( KErrSVPHoldStateError );

        }    

    aContext.SetCurrentStateL( aContext, nextState );

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

    }

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

// CSVPHoldDHState::PerformRequestL

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

//

TSVPHoldStateIndex 

CSVPHoldDHState::PerformRequestL( CSVPHoldContext& aContext,

                                  CMceMediaStream& aMediaStream,

                                  CMceSession& aSession )

    {

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalDoubleHoldResume:

            {

            ResumeDoubleHoldSessionLocallyL( aContext, aMediaStream, aSession );

            break;

            }                    

        case ESVPRemoteDoubleHoldResume:

            {

            RemoteDoubleHoldSessionResumeL( aContext, aMediaStream, aSession );

            break;

            }

        case ESVPLocalHold:

        case ESVPLocalResume:

        case ESVPLocalDoubleHold:

        case ESVPRemoteHold:

        case ESVPRemoteResume:

        case ESVPRemoteDoubleHold:

            {

            // Cannot occur in doublehold state

            User::Leave( KErrSVPHoldStateError );

            break;                

            }

        default:

            {

            // Error in request solving,no state change needed:

            nextState = KSVPHoldDHStateIndex;

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

                        aContext.HoldRequest() );

            break;

            }                    

        }    

    return nextState;

    }

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

// CSVPHoldDHState::ResumeDoubleHoldSessionLocallyL

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

//

void CSVPHoldDHState::

ResumeDoubleHoldSessionLocallyL( CSVPHoldContext& aContext,

                                 CMceMediaStream& aMediaStream,

                                 CMceSession& aSession )

    {

    SVPDEBUG1( "CSVPHoldDHState::ResumeDoubleHoldSessionLocallyL - In" );

    // Local resume from double holded stream. Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPLocalDoubleHoldResume );        		    

    // Update session

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldDHState::ResumeDoubleHoldSessionLocallyL - done" );    

    }

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

// CSVPHoldDHState::RemoteSoubleHoldSessionResumeL

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

//

void CSVPHoldDHState::

RemoteDoubleHoldSessionResumeL( CSVPHoldContext& aContext,

                                CMceMediaStream& aMediaStream,

                                CMceSession& aSession )

    {

    // Remote Resume from double holded stream:

    SVPDEBUG1( "CSVPHoldDHState::RemoteDoubleHoldSessionResumeL - 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( "CSVPHoldDHState::RemoteSoubleHoldSessionResumeL:");

        SVPDEBUG1( "Not hold request" );

        User::Leave( KErrSVPHoldNotHoldRequest );

        }

    CleanupStack::PopAndDestroy( attributeLines );

    // Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPRemoteDoubleHoldResume );        		    

    // Update session

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldDHState::RemoteSoubleHoldSessionResumeL - done" );    

    }

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

// CSVPHoldDHState::DoEnter

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

//

void CSVPHoldDHState::DoEnter( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldDHState::DoEnter" );

    TInt err = KErrNone;

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

    // succesfull action is informed to client

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalDoubleHold:

            {

            SVPDEBUG1( "CSVPHoldDHState::DoEnter - LocalDoubleHold" );

            aContext.HoldObserver().SessionLocallyHeld();

            break;

            }

        case ESVPRemoteDoubleHold:

            {

            SVPDEBUG1( "CSVPHoldDHState::DoEnter - RemoteDoubleHold" );

            aContext.HoldObserver().SessionRemoteHeld();

            break;

            }

        default:

            {

            // Nothing to do; occurs only with state rollback

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

            break;

            }

        }

    }

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

// CSVPHoldDHState::IsOutEstablishingStateActive

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

//

TBool CSVPHoldDHState::IsOutEstablishingStateActive()

    {

    return EFalse;

    }