/*

* 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:  Remote 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    "svpholdinstate.h" 

#include    "svpholdcontext.h"

#include    "svpholdcontroller.h"

#include    "svpholdobserver.h"

#include    "svpholdmediahandler.h"

#include    "svplogger.h"

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

// CSVPHoldInState::CSVPHoldInState

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

//

CSVPHoldInState::CSVPHoldInState()

    {

    }

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

// CSVPHoldInState::NewLC

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

//

CSVPHoldInState* CSVPHoldInState::NewLC()

    {

    CSVPHoldInState* self = new ( ELeave ) CSVPHoldInState;

    CleanupStack::PushL( self );

    return self;

    }

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

// CSVPHoldInState::~CSVPHoldInState

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

//

CSVPHoldInState::~CSVPHoldInState()

    {

    }

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

// CSVPHoldInState::DoApplyL

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

//

void CSVPHoldInState::DoApplyL( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldInState::DoApply" )

    CMceSession* session = aContext.SessionObject();

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

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    SVPDEBUG2( "CSVPHoldInState::DoApply streams: %d", streams.Count() )

    TInt audioStreamsHandled = 0;

    TInt streamCount = streams.Count();

    while ( streamCount )

        {

        streamCount--;

        CMceMediaStream* mediaStream = streams[ streamCount ];

        if ( KMceAudio == mediaStream->Type() )

            {

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

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

                        aContext.HoldRequest() )

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

            audioStreamsHandled++;

            }

        }

    if ( 0 == audioStreamsHandled )

        {

        SVPDEBUG1( "CSVPHoldInState::DoApply KErrSVPHoldStateError" )

        User::Leave( KErrSVPHoldStateError );

        }    

    aContext.SetCurrentStateL( aContext, nextState );

    SVPDEBUG1( "CSVPHoldInState::DoApply - Handled" )

    }

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

// CSVPHoldInState::PerformRequestL

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

//

TSVPHoldStateIndex 

CSVPHoldInState::PerformRequestL( CSVPHoldContext& aContext,

                                  CMceMediaStream& aMediaStream,

                                  CMceSession& aSession )

    {

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalDoubleHold:

            {

            LocalSessionDoubleHoldL( aContext, aMediaStream, aSession );

            break;

            }                    

        case ESVPRemoteResume:

            {

            RemoteSessionResumeL( aContext, aMediaStream, aSession );

            break;

            }                   

        case ESVPLocalHold:

        case ESVPLocalDoubleHoldResume:

        case ESVPLocalResume:

        case ESVPRemoteHold:

        case ESVPRemoteDoubleHold:

        case ESVPRemoteDoubleHoldResume:

            {

            // Cannot occur in In state

            User::Leave( KErrSVPHoldStateError );

            break;

            }

        default:

            {

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

            nextState = KSVPHoldInStateIndex;

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

                        aContext.HoldRequest() );

            break;

            }                    

        }

    return nextState;

    }

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

// CSVPHoldInState::LocalSessionDoubleHoldL

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

//

void CSVPHoldInState::LocalSessionDoubleHoldL( CSVPHoldContext& aContext,

                                               CMceMediaStream& aMediaStream,

                                               CMceSession& aSession )

    {

    SVPDEBUG1( "CSVPHoldInState::LocalSessionDoubleHoldL - In" );

    // Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPLocalDoubleHold );

    // Update session

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldInState::LocalSessionDoubleHoldL - done" );   

    }

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

// CSVPHoldInState::RemoteSessionResumeL

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

//

void CSVPHoldInState::RemoteSessionResumeL( CSVPHoldContext& aContext,

                                            CMceMediaStream& aMediaStream,

                                            CMceSession& aSession )

    {

    SVPDEBUG1( "CSVPHoldInState::RemoteSessionResumeL - In" )

    MDesC8Array* attributeLines = aMediaStream.MediaAttributeLinesL();

    CleanupDeletePushL( attributeLines );

    // Check that request has reasonable direction attribute:

    if ( ESVPNoType == aContext.SolveRequestL( aSession, attributeLines ) )

        {

        // Not hold request

        SVPDEBUG1( "CSVPHoldInState::RemoteSessionResumeL ESVPNoType")

        User::Leave( KErrSVPHoldNotHoldRequest );

        }

    CleanupStack::PopAndDestroy( attributeLines );

    // Handle media stream:

    aContext.MediaHandler().PerformMediaActionL(

        aMediaStream, ESVPRemoteResume );

    // Update session

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldInState::RemoteSessionResumeL - done" )

    }

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

// CSVPHoldInState::DoEnter

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

//

void CSVPHoldInState::DoEnter( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldInState::DoEnter" );

    TInt err = KErrNone;

    // succesfull action is informed to client

    switch ( aContext.HoldRequest() )

        {

        case ESVPRemoteHold:

            {

            SVPDEBUG1( "CSVPHoldInState::DoEnter - RemoteHold" );

            // For music on hold IOP with some vendors leave speaker enabled:

            TBool leaveSpeakerEnabled = ETrue;

            TRAP( err, aContext.MediaHandler().

                            DisableAudioL( aContext,

                                           leaveSpeakerEnabled ) );

            aContext.HoldObserver().SessionRemoteHeld();

            break;

            }

        case ESVPLocalDoubleHoldResume:

            {

            SVPDEBUG1( "CSVPHoldInState::DoEnter - Local DH resume" );

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

            aContext.HoldObserver().SessionLocallyResumed();

            break;

            }

        default:

            {

            // Nothing to do; occurs only with state rollback

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

            break;

            }        

        }

    if ( aContext.RemoteRequestNotProcessed() )

        {

        SVPDEBUG1( "CSVPHoldInState::DoEnter - Remote request completed" );

        aContext.SetRemoteRequestNotProcessed( EFalse );

        }

    }

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

// CSVPHoldInState::IsOutEstablishingStateActive

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

//

TBool CSVPHoldInState::IsOutEstablishingStateActive()

    {

    return EFalse;

    }