/*
* Copyright (c) 2007 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:  Idle state implementation
*
*/

#include <sdpdocument.h>
#include "nspstateidle.h"
#include "nspevents.h"
#include "nspsession.h"
#include "nspactionset.h"
#include "nspsessiondata.h"
#include "nspdefs.h"

#define REMOTELITE( aData ) \
    ( aData.SubState() == CNSPSessionData::ESubRemoteLite ||\
      aData.SubState() == CNSPSessionData::ESubAll )

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CNSPStateIdle::CNSPStateIdle
// ---------------------------------------------------------------------------
//
CNSPStateIdle::CNSPStateIdle()
    {
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::NewL
// ---------------------------------------------------------------------------
//
CNSPStateIdle* CNSPStateIdle::NewL()
    {
    CNSPStateIdle* self = CNSPStateIdle::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::NewLC
// ---------------------------------------------------------------------------
//
CNSPStateIdle* CNSPStateIdle::NewLC()
    {
    CNSPStateIdle* self = new ( ELeave ) CNSPStateIdle;
    CleanupStack::PushL( self );
    return self;
    }


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


// ---------------------------------------------------------------------------
// CNSPStateIdle::DoAcceptL
// ---------------------------------------------------------------------------
//
TBool CNSPStateIdle::DoAcceptL( TNSPStateMachineEvent& aEvent )
    {
    User::LeaveIfError(
            TNSPStateMachineEvent::ECreateOffer == aEvent.Request() ||
            TNSPStateMachineEvent::EResolve == aEvent.Request() ||
            TNSPStateMachineEvent::EReservationStatus == aEvent.Request() ||
            TNSPStateMachineEvent::ECloseSession == aEvent.Request() ?
                    KErrNone : KErrArgument );
    
    return ETrue;
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::DoStateEntryL
// ---------------------------------------------------------------------------
//
void CNSPStateIdle::DoStateEntryL( TNSPStateMachineEvent& aEvent )
    {
    aEvent.CallbackType() = TEventReturnStatus::EInitialized;
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::DoReverse
// ---------------------------------------------------------------------------
//
void CNSPStateIdle::DoReverse( TNSPStateMachineEvent& aEvent )
    {
    CNSPSession& session = aEvent.Session();
    session.Data().SetOffer( NULL );
    session.Data().SetAnswer( NULL );
    session.Role() = CNSPSession::EUndefined;
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::DoApplyL
// ---------------------------------------------------------------------------
//
void CNSPStateIdle::DoApplyL( TNSPStateMachineEvent& aEvent )
    {
    switch( aEvent.Request() )
        {
        case TNSPStateMachineEvent::ECreateOffer:
            {
            ApplyCreateOfferL( aEvent );
            break;
            }
        
        case TNSPStateMachineEvent::EResolve:
            {
            ApplyResolveL( aEvent );
            break;
            }
        
        case TNSPStateMachineEvent::EReservationStatus:
            {
            aEvent.Status() = KNatAsync;
            break;
            }
        
        case TNSPStateMachineEvent::ECloseSession:
            {
            aEvent.Status() = KNatReady;
            break;
            }
        
        default:
            {
            User::Leave( KErrArgument );
            }
        }
    }

// ---------------------------------------------------------------------------
// CNSPStateIdle::DoExitL
// ---------------------------------------------------------------------------
//
void CNSPStateIdle::DoExitL( TNSPStateMachineEvent& aEvent )
    {
    CNSPSession& session = aEvent.Session();
    
    switch( aEvent.Request() )
        {
        case TNSPStateMachineEvent::ECreateOffer:
            {
            session.Data().SetOffer( aEvent.Offer()->CloneL() );
            session.Role() = CNSPSession::EOfferer;
            break;
            }
        
        case TNSPStateMachineEvent::EResolve:
            {
            session.Data().SetOffer( aEvent.Offer()->CloneL() );
            session.Data().SetAnswer( aEvent.Answer()->CloneL() );
            session.Role() = CNSPSession::EAnswerer;
            break;
            }
        
        default:
            {
            User::Leave( KErrArgument );
            }
        }
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::ApplyCreateOfferL
// ---------------------------------------------------------------------------
//
void CNSPStateIdle::ApplyCreateOfferL( TNSPStateMachineEvent& aEvent ) const
    {
    aEvent.Session().Actions().CreateStreamsL( *aEvent.Offer() );
    aEvent.NextState() = KStateIndexLocalCand;
    aEvent.Status() = KNatAsync;
    }


// ---------------------------------------------------------------------------
// CNSPStateIdle::ApplyResolveL
// ---------------------------------------------------------------------------
//
void CNSPStateIdle::ApplyResolveL( TNSPStateMachineEvent& aEvent ) const
    {
    TNatReturnStatus status = KNatReady;
    CNSPSession& session = aEvent.Session();
    
    session.Actions().CreateStreamsL( *aEvent.Answer() );
    status = session.Actions().GetSessionModifiersL(
    			*aEvent.Offer(), CNSPSession::EAnswerer );
    
    CNSPSessionData& sessionData = session.Data();
    if ( status == KNatAsync && !REMOTELITE( sessionData ) )
        {
        session.Actions().RestartWithoutIce();
        }
    
    aEvent.NextState() = KStateIndexLocalCand;
    aEvent.Status() = KNatAsync;
    }


// end of file