/*

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

*

*/

#include    <badesca.h>

#include    <mcesession.h>

#include    <mcemediastream.h>

#include    <mcertpsource.h>

#include    <mcertpsink.h>

#include    <mceaudiostream.h>

#include    <mcemediasource.h>

#include    <mcemediasink.h>

#include    "svpholdconnectedstate.h"

#include    "svpholdcontroller.h"

#include    "svpholdattributehandler.h"

#include    "svpholdobserver.h"

#include    "svpholdmediahandler.h"

#include    "svplogger.h"

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

// CSVPHoldConnectedState::CSVPHoldConnectedState

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

CSVPHoldConnectedState::CSVPHoldConnectedState()

    {

    }

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

// CSVPHoldConnectedState::NewLC

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

CSVPHoldConnectedState* CSVPHoldConnectedState::NewLC()

    {

    CSVPHoldConnectedState* self = new ( ELeave ) CSVPHoldConnectedState;

    CleanupStack::PushL( self );

    return self;

    }

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

// CSVPHoldConnectedState::~CSVPHoldConnectedState

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

CSVPHoldConnectedState::~CSVPHoldConnectedState()

    {

    }

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

// CSVPHoldConnectedState::DoApplyL

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

//

void CSVPHoldConnectedState::DoApplyL( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldConnectedState::DoApply" );

    CMceSession* session = aContext.SessionObject();

    CMceSession::TState sessionState = session->State();

    SVPDEBUG2( "CSVPHoldConnectedState::DoApply - MCE Session state is = %i",

                sessionState );

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

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    TInt audioStreamsHandled = 0;

    TInt streamCount = streams.Count();

    SVPDEBUG2( "CSVPHoldConnectedState::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( "CSVPHoldConnectedState::DoApply - Hold request is = %i",

                        aContext.HoldRequest() );

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

            audioStreamsHandled++;

            }

        }

    if ( 0 == audioStreamsHandled )

        {

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

        User::Leave( KErrSVPHoldStateError );

        }    

    aContext.SetCurrentStateL( aContext, nextState );

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

    }

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

// CSVPHoldConnectedState::PerformRequestL

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

//

TSVPHoldStateIndex 

CSVPHoldConnectedState::PerformRequestL( CSVPHoldContext& aContext,

                                         CMceMediaStream& aMediaStream,

                                         CMceSession& aSession )

    {

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex;

    switch ( aContext.HoldRequest() )

        {

        case ESVPLocalHold:

            {

            HoldSessionLocallyL( aContext, aMediaStream, aSession );

            break;

            }

        case ESVPRemoteHold:

            {

            RemoteSessionHoldL( aContext, aMediaStream, aSession );

            break;

            }                    

        case ESVPLocalResume:

        case ESVPLocalDoubleHold:

        case ESVPLocalDoubleHoldResume:

        case ESVPRemoteResume:

        case ESVPRemoteDoubleHold:

        case ESVPRemoteDoubleHoldResume:

            {

            // Cannot occur in connected state

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

            User::Leave( KErrSVPHoldStateError );                    

            }

        default:

            {

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

            nextState = KSVPHoldConnectedStateIndex;

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

                        aContext.HoldRequest() );

            break;

            }

        }

    return nextState;

    }

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

// CSVPHoldConnectedState::HoldSessionLocallyL

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

//

void CSVPHoldConnectedState::

HoldSessionLocallyL( CSVPHoldContext& aContext,

                     CMceMediaStream& aMediaStream,

                     CMceSession& aSession )

    {

    SVPDEBUG1( "CSVPHoldConnectedState::HoldSessionLocallyL - IN" );

    // Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPLocalHold );

    // Disable all sources and sinks:

    aContext.MediaHandler().DisableAudioL( aContext );

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldConnectedState::HoldSessionLocallyL done" );    

    }

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

// CSVPHoldConnectedState::RemoteSessionHoldL

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

//

void CSVPHoldConnectedState::

RemoteSessionHoldL( CSVPHoldContext& aContext,

                      CMceMediaStream& aMediaStream,

                      CMceSession& aSession )

    {

    SVPDEBUG1( "CSVPHoldConnectedState::RemoteSessionHoldL - In" );

    MDesC8Array* sessionAttributeLines = aSession.SessionSDPLinesL();

    CleanupDeletePushL( sessionAttributeLines );

    TSVPHoldRequestType attribute =

                      aContext.SolveRequestL( aSession,

                                              sessionAttributeLines ); 

    CleanupStack::PopAndDestroy( sessionAttributeLines );

    MDesC8Array* attributeLines = aMediaStream.MediaAttributeLinesL();

    CleanupDeletePushL( attributeLines );

    // Check that request has reasonable direction attribute:

    if ( ESVPNoType == attribute )

        {

        attribute = aContext.SolveRequestL( aSession,

                                            attributeLines,

                                            ETrue);        

        }

    if ( ESVPNoType == attribute )

        {

        // Not hold request

        SVPDEBUG1( "CSVPHoldConnectedState::RemoteSessionHoldL:");

        SVPDEBUG1( "Not hold request" );

        User::Leave( KErrSVPHoldNotHoldRequest );

        }

    CleanupStack::PopAndDestroy( attributeLines );

    // Handle media stream:

    aContext.MediaHandler().

        PerformMediaActionL( aMediaStream,

                             ESVPRemoteHold );

    // Update session

    aSession.UpdateL();

    SVPDEBUG1( "CSVPHoldConnectedState::RemoteSessionHoldL - done" );

    }

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

// CSVPHoldConnectedState::DoEnter

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

//

void CSVPHoldConnectedState::DoEnter( CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldConnectedState::DoEnter" );

    TInt err = KErrNone;

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

    // succesfull action is informed to client

    switch ( aContext.HoldRequest() )

        {

        case ESVPRemoteResume:

            {

            SVPDEBUG1( "CSVPHoldConnectedState::DoEnter - RemoteResume" );

            aContext.HoldObserver().SessionRemoteResumed();

            break;

            }

        case ESVPLocalResume:

            {

            SVPDEBUG1( "CSVPHoldConnectedState::DoEnter - LocalResume" );

            aContext.HoldObserver().SessionLocallyResumed();

            break;

            }

        default:

            {

            // Nothing to do; occurs only with state rollback

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

            break;

            }

        }

    }

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

// CSVPHoldConnectedState::IsOutEstablishingStateActive

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

//

TBool CSVPHoldConnectedState::IsOutEstablishingStateActive()

    {

    return EFalse;

    }