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

#include    "mcesession.h"
#include    "mcemediastream.h"
#include    "mceaudiostream.h"
#include    "svpholdinestablishingstate.h"
#include    "svpholdcontroller.h"
#include    "svpholdattributehandler.h"
#include    "svplogger.h"


// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::CSVPHoldInEstablishingState
// ---------------------------------------------------------------------------
//
CSVPHoldInEstablishingState::CSVPHoldInEstablishingState()
    {
    }

// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::NewL
// ---------------------------------------------------------------------------
//
CSVPHoldInEstablishingState* CSVPHoldInEstablishingState::NewLC()
    {
    CSVPHoldInEstablishingState* self = 
        new ( ELeave ) CSVPHoldInEstablishingState;

    CleanupStack::PushL( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::~CSVPHoldInEstablishingState
// ---------------------------------------------------------------------------
//
CSVPHoldInEstablishingState::~CSVPHoldInEstablishingState()
    {
    }

// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::DoApplyL
// ---------------------------------------------------------------------------
//
void CSVPHoldInEstablishingState::DoApplyL( CSVPHoldContext& aContext )
    {
    SVPDEBUG1( "CSVPHoldInEstablishingState::DoApply" );

    TSVPHoldStateIndex nextState = KSVPHoldEstablishingStateIndex; 
    
    const RPointerArray< CMceMediaStream >& streams =
        aContext.SessionObject()->Streams();
    
    const TInt streamCount = streams.Count();
    
    if ( !aContext.SpecialResponseHandling( nextState ) )
        {
        for ( TInt i = 0; i < streamCount; i++ )
            {
            CMceMediaStream* mediaStream = streams[ i ];
            if ( KMceAudio == mediaStream->Type() )
                {
                // This media is audio stream. Handling depends on the request
                switch ( aContext.HoldRequest() )
                    {
                    case ESVPRemoteHold:
                        {
                        // From Connected state
                        HandleRemoteHolding( nextState );
                        break;
                        }
                        
                    case ESVPRemoteResume:
                        {
                        // From In state
                        HandleRemoteResuming( nextState );
                        break;
                        }

                    case ESVPRemoteDoubleHold:
                        {
                        // From Out state
                        HandleRemoteHolding( nextState,
                                             KSVPHoldDHStateIndex );
                        break;
                        }

                     case ESVPRemoteDoubleHoldResume:
                        {
                        // From Doublehold state
                        HandleRemoteResuming( nextState,
                                              KSVPHoldOutStateIndex );
                        break;
                        }

                    case ESVPLocalHold:
                    case ESVPLocalResume:
                    case ESVPLocalDoubleHold:
                    case ESVPLocalDoubleHoldResume:
                        {
                        SVPDEBUG1(
                        "CSVPHoldInEstablishingState::DoApply\
                         - Local action - State Error" );
                        User::Leave( KErrSVPHoldStateError );
                        break;
                        }
                        
                    default:
                        {
                        // Error in request solving
                        SVPDEBUG2(
                        "CSVPHoldInEstablishingState::DoApply - Error, request %i",
                                                        aContext.HoldRequest() );
                        break;
                        }
                    }
                }
            }           
        }

    aContext.SetCurrentStateL( aContext, nextState );
    SVPDEBUG1( "CSVPHoldInEstablishingState::DoApply - Handled" );
    }
    
// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::DoEnter
// ---------------------------------------------------------------------------
//
void CSVPHoldInEstablishingState::DoEnter( CSVPHoldContext& /*aContext*/ )
    {
    // Nothing to do.
    SVPDEBUG1( "CSVPHoldInEstablishingState::DoEnter" );
    }
    
// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::IsOutEstablishingStateActive
// ---------------------------------------------------------------------------
//
TBool CSVPHoldInEstablishingState::IsOutEstablishingStateActive()
    {
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::HandleRemoteHoldingL
// ---------------------------------------------------------------------------
//
void CSVPHoldInEstablishingState::
HandleRemoteHolding( TSVPHoldStateIndex& aNextState,
                     TSVPHoldStateIndex aState )
    {
    SVPDEBUG1(
    "CSVPHoldInEstablishingState::HandleRemoteHoldingL" );
    
    if ( KSVPHoldDHStateIndex == aState )
        {
        SVPDEBUG1(
        "CSVPHoldOutEstablishingState::HandleLocalHoldingL\
         - Next KSVPHoldDHStateIndex" );
        aNextState = KSVPHoldDHStateIndex;                
        }
    else
        {
        aNextState = KSVPHoldInStateIndex;
        }
            
    SVPDEBUG1(
    "CSVPHoldInEstablishingState::HandleRemoteHoldingL - Done" );
    }

// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::HandleRemoteResumingL
// ---------------------------------------------------------------------------
//
void CSVPHoldInEstablishingState::
HandleRemoteResuming( TSVPHoldStateIndex& aNextState,
                      TSVPHoldStateIndex aState )
    {
    if ( KSVPHoldOutStateIndex == aState )
        {
        SVPDEBUG1(
        "CSVPHoldInEstablishingState::HandleRemoteResumingL KSVPHoldOutStateIndex" )
        
        aNextState = KSVPHoldOutStateIndex;
        }
    else
        {
        SVPDEBUG1(
        "CSVPHoldInEstablishingState::HandleRemoteResumingL KSVPHoldConnectedStateIndex" )
        
        aNextState = KSVPHoldConnectedStateIndex;
        }
    }
    
// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::CheckAttribute
// ---------------------------------------------------------------------------
//
TInt CSVPHoldInEstablishingState::
CheckAttribute( MDesC8Array* aAttributeLines,
                KSVPHoldAttributeIndex aNeededAttribute,
                TSVPHoldStateIndex& aNextState,
                CSVPHoldContext& aContext )
    {
    // Checks direction attribute from request whether it is acceptable or not.
    SVPDEBUG1( "CSVPHoldInEstablishingState::CheckAttribute" );

    KSVPHoldAttributeIndex requestAttribute =
        aContext.AttributeHandler().FindDirectionAttribute( aAttributeLines );
        
    if ( aNeededAttribute == requestAttribute )
        {
        return DefineDefaultCaseStateChange( aContext, aNextState );
        }
        
    else if ( KSVPHoldSendrecvIndex == aNeededAttribute &&
              KErrNotFound == requestAttribute )
        {
        // If there is no direction attribute at all, default is sendrecv
        SVPDEBUG1(
        "CSVPHoldInEstablishingState::CheckAttributeL - No attribute" );
        aNextState = KSVPHoldConnectedStateIndex;
        return KErrNone;
        }
        
    else if ( KSVPHoldSendonlyIndex == aNeededAttribute &&
              KErrNotFound == requestAttribute )
        {
        // no-op request received
        SVPDEBUG1(
        "CSVPHoldInEstablishingState::CheckAttributeL - No-op" );
        aNextState = KSVPHoldConnectedStateIndex;
        return KErrNone;
        }
        
    else
        {
        // Do not change the aNextState
        SVPDEBUG1(
        "CSVPHoldInEstablishingState::CheckAttributeL - else" );
        return KErrSVPHoldUnacceptableResponseAttribute;
        }
    }

// ---------------------------------------------------------------------------
// CSVPHoldInEstablishingState::DefineDefaultCaseStateChange
// ---------------------------------------------------------------------------
//
TInt CSVPHoldInEstablishingState::
DefineDefaultCaseStateChange( CSVPHoldContext& aContext,
                          TSVPHoldStateIndex& aNextState )
    {
    switch ( aContext.HoldRequest() )
        {
        case ESVPRemoteHold:
            {
            aNextState = KSVPHoldInStateIndex;
            return KErrNone;
            }
            
        case ESVPRemoteResume:
            {
            aNextState = KSVPHoldConnectedStateIndex;
            return KErrNone;
            }
            
        case ESVPRemoteDoubleHold:
            {
            aNextState = KSVPHoldDHStateIndex;
            return KErrNone;
            }
            
        case ESVPRemoteDoubleHoldResume:
            {
            aNextState = KSVPHoldOutStateIndex;
            return KErrNone;
            }
            
        default:
            {
            SVPDEBUG1(
            "CSVPHoldInEstablishingState::CheckAttributeL - Default" );
            return KErrSVPHoldUnacceptableResponseAttribute;
            }
        }
    }