/*

* 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:   

*

*/

#ifndef CMCESIPSESSION_H

#define CMCESIPSESSION_H

// INCLUDES

#include <e32base.h>

#include "mcesrv.h"

#include "mcecssubsession.h"

#include "mcesipmanager.h"

#include "mcestate.h"

#include "fcobserver.h"

#include "mceexpirationhandler.h"

#include "mcereliableobserver.h"

// FORWARD DECLARATION

class CSIPProfile;

class CMceSipStateMachine;

class CMceComSession;

class TMceActionSet;

class TMceFCActionSet;

class CMceSipExtensions;

class CDesC8Array;

class CMceReliableSender;

// CLASS DECLARATION

/**

* This class represents SIP session

* 

* Class provides methods to handle SIP session

* specifig ITC functions and to receive SIP requests and 

* responses.

*  @lib 

*  @since

*/

class CMceSipSession : public CMceCsSubSession,

					   public MMceMediaSessionObserver,

                       public MMCEExpirationHandler,

                       public MFCObserver,

                       public MMceReliableObserver

	{

public: //enums

    enum TSubState

        {

        ENone,

        EOffering,

        EAnswering,

        EUpdating,

        ERefreshing,

        };

public: // Constructors and destructor

	/**

	* Two-phased constructor.

	* @param aClientSession client

	* @param aSIPConnection SIP connection 

	* @param aStateMachine SIP session state machine

	* @param aProfile SIP Profile

	* @return SIP session

	*/

	static CMceSipSession* NewL( CMceCsSession& aClientSession, 

	                             CMceSipConnection& aSIPConnection,

								 CMceSipStateMachine& aStateMachine, 

								 CSIPProfile& aProfile );

	/**

	* Two-phased constructor.

	* @param aClientSession client

	* @param aSIPConnection SIP connection 

	* @param aStateMachine SIP session state machine

	* @param aProfile SIP Profile

	* @return SIP session

	*/

	static CMceSipSession* NewLC( CMceCsSession& aClientSession, 

	                              CMceSipConnection& aSIPConnection,

								  CMceSipStateMachine& aStateMachine, 

								  CSIPProfile& aProfile );

	/**

	* Two-phased constructor.

	* @param aClientSession client

	* @param aSIPConnection SIP connection 

	* @param aStateMachine SIP session state machine

	* @return SIP session

	*/

	static CMceSipSession* NewLC( CMceCsSession& aClientSession, 

	                              CMceSipConnection& aSIPConnection,

								  CMceSipStateMachine& aStateMachine ); 

	/**

	* Destructor.

	*/

	~CMceSipSession();

public: // New

	/**

	* Returns actions set

	* @return action set

	*/

    TMceActionSet Actions();

    /**

	* Returns floor control actions set

	* @return floor control action set

	*/

    TMceFCActionSet FCActions();

	/**

	* Sets substate of session

	* @param aSubState substate of session

	*/

    void SetSubState( TSubState aSubState );

	/**

	* Returns substate of session

	* @return substate of session

	*/

    TSubState SubState();

    /**

    * Returns Reliable Sender 

    * @return Reliable Sender

    */

	CMceReliableSender& ReliableSender();

	/**

    * Re-Create an outgoing dialog 

    */

	void ReCreateOutgoingDialogL();

	/**

	* Create outgoing dialog from 3xx response

	*/ 

	void CreateDialogFrom3XXResponseL();

	/** 

	* Re-Use dialog

	* @return KErrNone if it passes

	*/

	TInt ReUseDialog();

	/** 

	* Returns Status for ForcedSDPSending Flag. 

	* @return ETrue when resource reservation ongoing otherwise EFalse

	*/

	TBool ForceSDPSendingStatus();

	/** 

	* Returns the previous state of sip session

	* @return StateInded

	*/

	TMceStateIndex PreviousState();	

public: // from CMceCsSubSession

	/**

	* Executes ITC function called by client.

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @return aReturnMessage buffer to store message context,

	* which will be wrote back to client

	*/

    HBufC8* DoServiceL( TMceIds& aIds, 

                        TMceItcFunctions aFunction );

	/**

	* Executes ITC function called by client.

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @param aMessage message context from client

	*/

    void DoServiceL( TMceIds& aIds, 

                     TMceItcFunctions aFunction, 

     	             const TDesC8& aMessage );

	/**

	* Executes ITC function called by client.

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @param aMessage message context from client

	*/

    void DoServiceL( TMceIds& aIds, 

                     TMceItcFunctions aFunction, 

     	             TPtr8& aMessage );

	/**

	* Executes ITC function called by client.

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @param aMessage decoded message context from client

	*/

    void DoServiceL( TMceIds& aIds, 

                     TMceItcFunctions aFunction, 

     	             CMceMsgBase& aMessage );

	/**

	* Returns ETrue, if session can be deleted

	* @return ETrue, if session can be deleted

	*/

    TBool CanDispose();

	/**

	* Initializes incoming dialog

	* @param aTransaction server transaction representing a request,

	* which caused dialog creation

	*/

    void DoInitializeIncomingDialogL( CSIPServerTransaction& aTransaction );

    /**

    * Called when error has been occured within dialog

    * @param aError error code

    */

    void ErrorOccured( TInt aError );

    /**

	* Handles situation where an asynchronous error has occured 

	* related to a request within an existing dialog.

    *

    * @param aError error code

    * @param aTransaction the transaction

    */

    void DoErrorOccured( TInt aError, CSIPTransactionBase& aTransaction );

    /**

	* Handles situation where SIP connection state has changed.

    * If connection state has changed to EInactive or EUnavailable,

	* SIP stack terminates all pending SIP client transactions and no

    * errors are reported back to the client about the terminated

    * transactions.

	* @param aIsActive indicates if the current connection is active

    */

    void DoConnectionStateChanged( TBool aIsActive );

    /**

    * Handles situation where incoming INVITE was 

    * canceled with the CANCEL

    */

    void Canceled();

    /**

    * Creates new incoming dialog (association)

    * @param aInitialRequest request causing creation

    * @return created dialog association

    */

    CSIPDialogAssocBase* CreateIncomingDialogL( 

                                    CSIPServerTransaction& aInitialRequest );

    /**

    * Creates outgoing dialog (association) based on given parameters 

    * @param aDialogType type of new dialog

    * @param aParams parameters for creation

    * @return created dialog association

    */

    CSIPDialogAssocBase* CreateOutgoingDialogL( TMceDialogType aDialogType, 

                                                CDesC8Array& aParams,

                                                CSIPDialog& aExistingDialog );

    /**

    * Creates outgoing dialog (association) based on given parameters 

    * @param aDialogType type of new dialog

    * @param aParams parameters for creation

    * @return created dialog association

    */

    CSIPDialogAssocBase* CreateOutgoingDialogL( TMceDialogType aDialogType,

                                                CDesC8Array& aParams );

public: //CMceCsSubSession

	/**

	* Returns SIP dialog (assoc)

	* @return SIP dialog or NULL if it does not exist

	*/

    CSIPDialogAssocBase* Dialog() const;

    /**

    * Handles situation where SIP stack has completed UAC core INVITE 

    * transaction 64*T1 seconds after the reception of the first 

    * 2xx response. No more 2xx responses can be received to the issued 

    * single INVITE.

    * @param aTransaction client transaction representing a response

    */

    void InviteCompleted( CSIPClientTransaction& aTransaction );

   	/**

	* Returns ETrue, if session will consume the transaction

	* @param aDialog SIP dialog

	* @param aTransaction the pending transaction

	* @return ETrue, if session will consume the transaction

	*/

    TBool Consumes( CSIPDialog& aDialog, CSIPServerTransaction& aTransaction, 

                	 TBool& aAssociatesWithDialog );

protected: //CMceCsSubSession

    /**

    * Checks if session accepts method of incoming request

    * @param aMethod the method

    * @return ETrue, if session will accept

    */

    TBool AcceptMethod( RStringF aMethod );

    /**

    * Called when request has been received. 

    * Request can be obtained by calling Request() method

    * @param aInsideDialog tells whether request was received inside dialog

    * @param aDialog SIP Dialog to which request belongs

    */

    void RequestReceived( TBool aInsideDialog, CSIPDialog& aDialog  );

    /**

    * Called when response (2XX) has been received to pending transaction.

    * Response can be obtained by calling Response() method

    */

    void ResponseReceived();

    /**

    * Called when response (1XX) has been received to pending transaction.

    * Response can be obtained by calling Response() method

    */

    void ProvisionalResponseReceived();

    /**

    * Called when response (3XX) has been received to pending transaction.

    * Response can be obtained by calling Response() method

    */

    void RedirectionResponseReceived();

    /**

    * Called when error response (4XX-7XX) has been received 

    * to pending transaction. 

    * Response can be obtained by calling Response() method

    */

    void ErrorResponseReceived();

    /**

    * Called when stand-alone request has been received.

    * Request can be obtained by calling Request() method

    */

    void StandAloneRequestReceived();

    /**

    * Called when stand-alone response (any) has been received 

    * to pending transaction. 

    * Response can be obtained by calling Response() method

    * @param aResponseType response type

    */

    void StandAloneResponseReceived( TMceSipResponseType aResponseType );

    /**

    * Handles situation where session must be forcefully terminated

    * @return ETrue, if session can be deleted. If there are 

    * pending operations, which cannot be done within this call, EFalse

    * is returned.

    */

    TBool Terminate();

public: // from MMceMediaSessionObserver

    /**

    * Callback function to indicate MCC session

    * is updated.

    * @param aSession session body

    */

    virtual void Updated( CMceComSession& aSession );

    /**

    * Callback function to indicate that network 

    * resource reservation is now ready

    */

    void Reserved( CMceComSession& aSession );

    /**

    * Callback function to indicate that event has been received

    * @param aEvent, received event

    */

    void EventReceived( TMceMccComEvent& aEvent );

	/**

    * Callback function to indicate MCC session was stopped

    * @param aSession session body

    */

	void SessionClosed( CMceComSession& aSession );

    /**

    * Callback function to indicate about error

    * @param aEvent, received event

    */

    void MediaError( TMceMccComEvent& aEvent );

    /**

    * Callback function to indicate about new media session due fork

    * @param aSession, new session, onwership is been transfered

    */

    void SessionCreatedL ( CMceComSession* aSession );

public: // From MMCEExpirationHandler	

	/**

    * Callback function to indicate about expiration of

    * session timer. RFC 4028

    * @param aTimerId timer Id

    * @param aTimerParam timer param

    */

    void TimerExpiredL( TMceTimerId aTimerId, TAny* aTimerParam );

public: // From MFCObserver

    /**

	* A FC message has been received from the network.        

    * @param aData The Data received from FCsession specific plugIn 

    *        The ownership is transferred.

	* @param aFCSession The Session which data is received to.

    */

	void FCReceivedData( HBufC8* aData, const CFCSession* aFCSession );

	/**

	* An asynchronous error has occurred in the FC related to the

	* given session indicated.

	* @param aError KErrNone succesfully, otherwise system wide or Socket 

	*               error code

	* @param aFCSession The Session which error is received to.

	*/

	void FCErrorNotify( TInt aErrCode, const CFCSession* aFCSession );

public: // From MCEReliableObserver

    /**

    * Callback Function, this will be called when reliable sender, retransmission 

    * timer expires, i.e. reliable sender has sent transaction for 64T1 and has not 

    * got the corresponding PRACK.

    * 

    */

    void NoPrackReceived( CSIPServerTransaction& aTransaction );

    /**

    * Callback Function indicates reliable sender has failed. This may be called 

    * when a transaction is in progress and UA tries to send another reliable response.

    */

    void ReliableFailed( CSIPServerTransaction& aTransaction, TInt aError );

public: //New Functions

	/**

    * Returns pending invite transaction

    * @return pending invite transaction

    */

    CSIPClientTransaction* InviteTransaction();

	/**

    * Returns current state

    * @param aMarkExit indicates, if current state is marked as exit state

    * @return current state

    */

    CMceState& CurrentState( TBool aMarkExit = EFalse );

	/**

    * Create body

    * @param aSession

    */

	/**

    * Returns session body

    * @return session body

    */

    CMceComSession* Body();

	/**

    * Returns session body candidate

    * @return session body candidate

    */

    CMceComSession* BodyCandidate();

	/**

    * Returns active session body 

    * @return active session body 

    */

    CMceComSession& ActiveBody();

    /**

    * Sets the latest offer

    * @param aSdpDocument the latest offer

    */