/*

* Copyright (c) 2005 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:    MT event is established.

*

*/

// INCLUDE FILES

#include <sipsubscriptionstateheader.h>

#include <sipnotifydialogassoc.h>

#include <sipdialog.h>

#include "mcesipeventhelper.h"

#include "mceeventsubscribemtestablishedstate.h"

#include "mcesip.h"

#include "mceeventslogs.h"

// ============================ MEMBER FUNCTIONS ===============================

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

// CMceEventSubscribeMtEstablishedState::CMceEventSubscribeMtEstablishedState

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMceEventSubscribeMtEstablishedState::CMceEventSubscribeMtEstablishedState()

    {

    }

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

// CMceEventSubscribeMtEstablishedState::~CMceEventSubscribeMtEstablishedState

// Destructor

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

//

CMceEventSubscribeMtEstablishedState::~CMceEventSubscribeMtEstablishedState()

    {

    }

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

// CMceEventSubscribeMtEstablishedState::ProcessSubscribeStateL

// Ápply concrete state.

// Be noticed that it will be also update, unsubscribe

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

//

void CMceEventSubscribeMtEstablishedState::HandleL(CMceComEvent& aEvent )

    {

    MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleL, Entry");

    User::LeaveIfError( aEvent.SIPEvent().Dialog() ?

        KErrNone : KMceEventStateError );

    User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type() == 

        SIPStrings::StringF( SipStrConsts::ENotify ) ?

        KErrNone : KMceEventStateError );

    // Set subscription state and parameters

    TInt nextState = KErrNotFound;		    

    CSIPSubscriptionStateHeader& subStateHeader = 

		( static_cast< CSIPNotifyDialogAssoc* >

		( aEvent.SIPEvent().Dialog() ) )->SubscriptionState();

    switch ( aEvent.PreviousAction() )

        {

        case EMceItcNotify:

            {

            subStateHeader.SetSubStateValueL( KStateActive );

            subStateHeader.SetExpiresParameterL( aEvent.RefreshInterval() );

            nextState = KMceEstablishingEventStateIndex;

		    break;

            }

        case EMceItcTerminateEvent:

            {

            subStateHeader.SetSubStateValueL( KStateTerminated );

            RStringF expires = SIPStrings::StringF( SipStrConsts::EExpires );

            subStateHeader.DeleteParam( expires );

            nextState = KMceTerminatingEventStateIndex;

            break;

            }

        default:

            {

            // Other actions not supported

            User::Leave( KMceEventStateError );

            break;

            }

        }

    CSIPMessageElements* message = 

	    MCESIPEventHelper::CreateMessageElementsLC( aEvent,

	                                                SipStrConsts::ENotify );

    CSIPClientTransaction* transaction = 

	    ( static_cast< CSIPNotifyDialogAssoc* >

	    ( aEvent.SIPEvent().Dialog() ) )->SendNotifyL( message );

	CleanupStack::Pop( message );

	CleanupStack::PushL( transaction );

    aEvent.SIPEvent().SetPendingTransactionL( transaction );

	CleanupStack::Pop( transaction );

	aEvent.EventContext().SetCurrentStateL( aEvent, nextState );

	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleL, Exit");

	}

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

// CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL

// Ápply concrete state.

// Be noticed that it will be also update, unsubscribe

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

//

void CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL(

													CMceComEvent& aEvent )

	{

	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL, Entry");

	User::LeaveIfError( aEvent.SIPEvent().Dialog() ?

	    KErrNone : KMceEventStateError );

	User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type() 

        == SIPStrings::StringF( SipStrConsts::ENotify ) ?

        KErrNone : KMceEventStateError );

    CSIPServerTransaction& serverTA = aEvent.SIPEvent().Request();

    CSIPServerTransaction* serverTACheck = &serverTA;

	User::LeaveIfError( serverTACheck ? KErrNone : KMceEventStateError );

	//Received Subscribe from Mo there is noaction in the previous action

	User::LeaveIfError( aEvent.PreviousAction() == KErrNotFound ?

	    KErrNone : KMceEventStateError );

    User::LeaveIfError( CSIPDialog::EConfirmed == 

        aEvent.SIPEvent().Dialog()->Dialog().State() ?

        KErrNone : KMceEventStateError );

    User::LeaveIfError( serverTA.RequestElements() ? KErrNone : KErrCorrupt );

	const CSIPMessageElements& subscribeMsg = 

	    serverTA.RequestElements()->MessageElements();

	//receiveing MO Subscribe Update or Mo Subscribe Terminate

	//Check the expire header so knows which state should go

	//Observer inform the incomingsubscribe and send response and notify

    TBool terminated = EFalse;

    CSIPResponseElements* response = 

        MCESIPEventHelper::SubscribeRequestReceivedLC( aEvent, subscribeMsg );

    if ( response->StatusCode() == KMceSipOK )

		{

		MCESIPEventHelper::HandleExpireHeaderL( subscribeMsg, terminated );

        aEvent.SIPEvent().Request().SendResponseL( response );

        CleanupStack::Pop( response );

        // Send notify

        TInt nextState = KErrNotFound;

		CSIPNotifyDialogAssoc* dialogAssoc = 

    		static_cast <CSIPNotifyDialogAssoc* >

    		( aEvent.SIPEvent().Dialog() ); 

        CSIPSubscriptionStateHeader& subscrState = 

            dialogAssoc->SubscriptionState();

		if ( terminated )

            {

            subscrState.SetSubStateValueL( KStateTerminated );

			RStringF expires = SIPStrings::StringF( SipStrConsts::EExpires );

            subscrState.DeleteParam( expires );

            nextState = KMceTerminatingEventStateIndex;

            }

		else

            {

            //when subscription state is active

            subscrState.SetSubStateValueL( KStateActive );

			subscrState.SetExpiresParameterL( aEvent.RefreshInterval() );

			nextState = KMceEstablishedEventStateIndex;

            }

        CSIPMessageElements* notifyMsg = 

            MCESIPEventHelper::CreateMessageElementsLC( 

                                                aEvent,

                                                SipStrConsts::ENotify );

		CSIPClientTransaction* tx = dialogAssoc->SendNotifyL( notifyMsg );

		CleanupStack::Pop( notifyMsg );

		CleanupStack::PushL( tx );

	    aEvent.SIPEvent().SetPendingTransactionL( tx );

		CleanupStack::Pop( tx );	

	    aEvent.EventContext().SetCurrentStateL( aEvent, nextState );

        }

	else

	  	{

	    aEvent.SIPEvent().Request().SendResponseL( response );

	    CleanupStack::Pop( response );

	    }

	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleReceiveRequestL, Exit");

	}

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

// CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL

// Ápply concrete state.

// Be noticed that it will be also update, unsubscribe

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

//	

void CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL( 

												CMceComEvent& aEvent )

	{

	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL, Entry");

	//MT

	//Getting subscribe->sendResponse->Send Notify and now getting response

	//Checking if getting the error after sending the Subscribe

	User::LeaveIfError( &aEvent.SIPEvent().Response() ?

	    KErrNone : KMceEventStateError );

	User::LeaveIfError( aEvent.SIPEvent().Response().Type()==

	    SIPStrings::StringF( SipStrConsts::ENotify ) ?

	    KErrNone : KMceEventStateError );

    //Get response from sending subscribe in Established state

    aEvent.SetPreviousAction( KErrNotFound ); 

    const CSIPResponseElements& response = 

    			*aEvent.SIPEvent().Response().ResponseElements();

    const CSIPResponseElements* responseCheck = &response;

    User::LeaveIfError( responseCheck ? KErrNone : KErrCorrupt );

    //Notify the subsession the response received

    //From the MtIdle 

    //Getting subscribe->sendResponse->Send Notify and now getting response

    TUint statusCode = response.StatusCode();

    if (statusCode >= KMceSipOK)

		{

		CMceEvent::TState nextClientState = CMceEvent::EPending;

		TMceEventStateIndex nextState = KErrNotFound;

        if (statusCode < KMceSipMultipleChoices )

            {

            nextClientState = CMceEvent::EActive;

            nextState = KMceEstablishedEventStateIndex;

            }

        else 

            {

            nextClientState = CMceEvent::ETerminated;

            nextState = KMceTerminatedEventStateIndex;

            }

        aEvent.SIPEvent().ClientStateChangedL( nextClientState, ETrue );

        aEvent.EventContext().SetCurrentStateL( aEvent, nextState );

        }

	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishedState::HandleResponseReceivedL, Exit");

	}

//  End of File