/*

* 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:    State for established MO refer.

*

*/

// INCLUDE FILES

#include "mceeventrefermoestablishedstate.h"

#include "mcesipeventhelper.h"

#include "mcesip.h"

#include "mceeventslogs.h"

#include <sipcontenttypeheader.h>

#include <sipdialogassocbase.h>

#include <sipdialog.h>

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

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

// CMceEventReferMoEstablishedState::CMceEventReferMoEstablishedState

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

// might leave.

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

//

CMceEventReferMoEstablishedState::CMceEventReferMoEstablishedState()

    {

    }

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

// CMceEventReferMoEstablishedState::~CMceEventReferMoEstablishedState

// Destructor

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

//

CMceEventReferMoEstablishedState::~CMceEventReferMoEstablishedState()

    {

    }

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

// CMceEventReferMoEstablishedState::ProcessReferStateL

// Ápply concrete state.

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

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

//

void CMceEventReferMoEstablishedState::HandleL( CMceComEvent& aEvent )

    {

    if(aEvent.PreviousAction() == EMceItcTerminateEvent)

		{

		// TBD: terminate REFER with SUBSCRIBE

		}

	else

	    {

	    // Other actions not supported.

	    User::Leave( KMceEventStateError );

	    }

    }

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

// CMceEventReferMoEstablishedState::HandleReceiveRequestL

// Ápply concrete state.

// Be noticed that it will be also Refer/Bye or Refer/Invite(update)

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

//

void CMceEventReferMoEstablishedState::HandleReceiveRequestL( 

														CMceComEvent& aEvent )

	{

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

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

	    KErrNone : KMceEventStateError );

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

	CSIPServerTransaction* serverTranCheck = &serverTran;

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

	//Received Notify for MO, there is no action in the previous action

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

        KErrNone : KMceEventStateError );

     User::LeaveIfError( CSIPDialog::EConfirmed ==

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

	        KErrNone : KMceEventStateError );

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

	//Receiving Notify and Send 200

	//Check the Notify Subscription state so knows which state should go

	//Observer inform the notify received, and Established

	const CSIPMessageElements& msgElem = 

	    serverTran.RequestElements()->MessageElements();

    CSIPResponseElements* response = 

        MCESIPEventHelper::ReferNotifyRequestReceivedLC( aEvent, msgElem );

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

		{

		if ( !aEvent.SilentSuppression() )

		    {

		    // Do not notify the observer, is silent suppression is on

		    CDesC8Array* headers = 

		        MceSip::UserHeadersToTextArrayL( 

		                            serverTran, 

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

    		CleanupStack::PushL( headers );

            HBufC8* contenttype= NULL;

            if( msgElem.ContentType() )

    	        {

    	        contenttype = msgElem.ContentType()->ToTextValueL();	

    	        }

            CleanupStack::PushL( contenttype );

            HBufC8* content = msgElem.Content().AllocLC();

            aEvent.SIPEvent().NotifyReceivedL( headers,

    					                       contenttype,

						                       content );

            CleanupStack::Pop( content );

	        CleanupStack::Pop( contenttype );

	        CleanupStack::Pop( headers );		

            }

		TBool terminated = EFalse;

        MCESIPEventHelper::HandleSubscriptionStateHeaderL( msgElem,

                                                           terminated );

        serverTran.SendResponseL( response );

        CleanupStack::Pop( response );

        if ( terminated )

            {

            // when the subscription state is terminated

            //receive notify send 200 OK

            aEvent.EventContext().SetCurrentStateL( 

                                        aEvent, 

                                        KMceTerminatedEventStateIndex );

            //Go Terminated directly        

            if ( !aEvent.SilentSuppression() )

		        {

		        // Do not notify the observer, is silent suppression is on

                aEvent.SIPEvent().ClientStateChangedL(

                                                    CMceRefer::ETerminated,

                                                    EFalse );

		        }

            }

        else

            {

            //when subscription state is active

            aEvent.EventContext().SetCurrentStateL( 

                    	                aEvent, 

                    	                KMceEstablishedEventStateIndex );

            }

        }

	 else

        {

            //when the notify request is bad, state doesn't change

        serverTran.SendResponseL( response );

        CleanupStack::Pop( response );

        }	

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

	}

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

// CMceEventReferMoEstablishedState::HandleResponseReceivedL

// Ápply concrete state.

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

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

//	

void CMceEventReferMoEstablishedState::HandleResponseReceivedL( 

												CMceComEvent& aEvent )

	{

	MCEEVENTS_DEBUG(

		"CMceEventReferMoEstablishedState::HandleResponseReceivedL, Entry");

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

	    KErrNone : KMceEventStateError );

    const CSIPResponseElements& response = 

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

    const CSIPResponseElements* responseCheck = &response;

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

    TUint statusCode = response.StatusCode();

	// Only case when we should come here is when REFER's 200 OK response

	// and the first NOTIFY message have swapped

    if ( statusCode >= KMceSipOK && statusCode < KMceSipMultipleChoices )

	    {

        aEvent.SetPreviousAction( KErrNotFound ); 	    	

	    }

	else 

		{ // Other cases are not allowed

		MCEEVENTS_DEBUG(

			"CMceEventReferMoEstablishedState::HandleResponseReceivedL, LEAVE!");        

		User::Leave( KMceEventStateError );	

		}

	MCEEVENTS_DEBUG(

		"CMceEventReferMoEstablishedState::HandleResponseReceivedL, Exit");   

    }

//  End of File