/*
* 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 subscribe is received and waiting for action from client.
*
*/





// INCLUDE FILES
#include "mceeventsubscribemtestablishingstate.h"
#include <sipsubscriptionstateheader.h>
#include <sipresponseelements.h>
#include <sipnotifydialogassoc.h>
#include "mcesip.h"
#include "mcesipeventhelper.h"
#include "mceeventslogs.h"

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

// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishingState::CMceEventSubscribeMtEstablishingState
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMceEventSubscribeMtEstablishingState::CMceEventSubscribeMtEstablishingState()
    {
    }
    
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishingState::~CMceEventSubscribeMtEstablishingState
// Destructor
// -----------------------------------------------------------------------------
//
CMceEventSubscribeMtEstablishingState::~CMceEventSubscribeMtEstablishingState()
    {
    }

// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishingState::ProcessSubscribeStateL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//
void CMceEventSubscribeMtEstablishingState::HandleL( CMceComEvent& aEvent)
    {
    MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishingState::HandleL, Entry");        
    //Check after the receiving Subscribe, client want to accept/Reject the event
    User::LeaveIfError( aEvent.SIPEvent().Dialog() ?
        KErrNone : KMceEventStateError );
        
    User::LeaveIfError( aEvent.SIPEvent().Dialog()->Type() 
        == SIPStrings::StringF( SipStrConsts::ENotify ) ?
        KErrNone : KMceEventStateError );
        
    User::LeaveIfError( &aEvent.SIPEvent().Request() ?
        KErrNone : KMceEventStateError );
        
    const CSIPRequestElements* request = 
        aEvent.SIPEvent().Request().RequestElements();
    User::LeaveIfError( request ? KErrNone : KErrCorrupt );
     
    CSIPResponseElements* response = NULL;	

    switch( aEvent.PreviousAction() )
        {
        case EMceItcAcceptEvent:
            {
            //Accept event	
            response = MCESIPEventHelper::CreateResponseL( 
                                                    aEvent,
                                                    KMceSipOK );
    	    break;
            }
        case EMceItcRejectEvent:
            {
            //Reject event
            response = MCESIPEventHelper::CreateResponseL( 
                                                    aEvent,
                                                    KMceSipDecline );
    	    
    	    aEvent.EventContext().SetCurrentStateL( 
                                            aEvent, 
                                            KMceTerminatedEventStateIndex );
    	    break;
            }
        case EMceItcRespondEvent:
            {
            //Respond event 
    	    RStringF reason = 
    	        SIPStrings::Pool().OpenFStringL( aEvent.ReasonPhrase() );
    	    CleanupClosePushL( reason );
    	    response = MCESIPEventHelper::CreateResponseL( 
                                                    aEvent,
                                                    aEvent.StatusCode(),
                                                    reason,
                                                    ETrue /*aAddClientData*/ );
    	    
    	    CleanupStack::PopAndDestroy(); // reason
            break;
            }
        default:
            {
            User::Leave( KMceEventStateError );
            break;
            }
        }
        
    CleanupStack::PushL( response );
   	aEvent.SIPEvent().Request().SendResponseL( response );
   	CleanupStack::Pop( response );
	//then sendNotify
	if ( response->StatusCode() == KMceSipOK|| 
		response->StatusCode() == aEvent.StatusCode() )
		{
		if( response->StatusCode() >= KMceSipOK )
			{
	        if ( response->StatusCode() < KMceSipMultipleChoices )
		
				{
				CSIPSubscriptionStateHeader& subStateHeader = 
				( static_cast< CSIPNotifyDialogAssoc* >
				( aEvent.SIPEvent().Dialog() ) )->SubscriptionState();
	        	
	        	subStateHeader.SetSubStateValueL( KStateActive );
	        	subStateHeader.SetExpiresParameterL( aEvent.RefreshInterval() );
	        	
	        	// message elements
	        	CSIPMessageElements* notifyMsg = 
                    MCESIPEventHelper::CreateMessageElementsLC( 
                                                aEvent,
                                                SipStrConsts::ENotify );
				CSIPClientTransaction* transaction = 
					( static_cast< CSIPNotifyDialogAssoc* >
					( aEvent.SIPEvent().Dialog() ) )->SendNotifyL( notifyMsg );
			    CleanupStack::Pop( notifyMsg );
				CleanupStack::PushL( transaction );
				aEvent.SIPEvent().SetPendingTransactionL( transaction );
				CleanupStack::Pop( transaction );
				aEvent.EventContext().SetCurrentStateL( 
		                                aEvent, 
		                                KMceEstablishedEventStateIndex );
				}
			else
				{
				aEvent.EventContext().SetCurrentStateL( 
				                          aEvent, 
				                          KMceTerminatedEventStateIndex );
				}
			}
		}
	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishingState::HandleL, Exit");   
    }

// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishingState::HandleReceiveRequestL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//
void CMceEventSubscribeMtEstablishingState::HandleReceiveRequestL( 
													CMceComEvent& /*aEvent*/ )
	{
	}
	
// -----------------------------------------------------------------------------
// CMceEventSubscribeMtEstablishingState::HandleResponseReceivedL
// Ápply concrete state.
// Be noticed that it will be also update, unsubscribe
// -----------------------------------------------------------------------------
//	
void CMceEventSubscribeMtEstablishingState::HandleResponseReceivedL(
													CMceComEvent& aEvent )
	{
	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishingState::HandleResponseReceivedL, Entry");   
	User::LeaveIfError( &aEvent.SIPEvent().Response() ?
	    KErrNone : KMceEventStateError );
        
    User::LeaveIfError( aEvent.SIPEvent().Response().Type() 
        == SIPStrings::StringF( SipStrConsts::ENotify ) ?
        KErrNone : KMceEventStateError );
    
    User::LeaveIfError( aEvent.PreviousAction()== EMceItcNotify ?
        KErrNone : KMceEventStateError );
            
    const CSIPResponseElements* response = 
        aEvent.SIPEvent().Response().ResponseElements();
    User::LeaveIfError( response ? KErrNone : KErrCorrupt );
    
 	aEvent.SetPreviousAction( KErrNotFound ); 
    
    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;
            }
		MCEEVENTS_DEBUG_NEXTCLIENTSTATE("NextClientState :", nextClientState )				            
		MCEEVENTS_DEBUG_NEXTSTATE("NextState :", nextState )		            
        aEvent.SIPEvent().ClientStateChangedL( nextClientState, ETrue );
        aEvent.EventContext().SetCurrentStateL( aEvent, nextState );
        }
	MCEEVENTS_DEBUG("CMceEventSubscribeMtEstablishingState::HandleResponseReceivedL, Exit");           
    }

//  End of File