/*

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

#define CMCECSSUBSESSION_H

//  INCLUDES

#include <e32base.h>

#include <stringpool.h>

#include <sipconnection.h>

#include "mcesrv.h"

#include "mceclientserver.h"

#include "mcesip.h"

#include "fcsession.h"

//FORWARD DECLARATION

class CSIPProfile;

class CMceCsSession;

class CMceCsSessionImplementation;

class CMceCsSubSessionReceiver;

class CMceServerCore;

class TMceIds;

class CMceMsgBase;

class CMceSipManager;

class CMceSipConnection;

class CSIPServerTransaction;

class CSIPClientTransaction;

class CSIPDialogAssocBase;

class CSIPClientTransaction;

class CSIPTransactionBase;

class CSIPDialog;

class CDesC8Array;

class TMceStateTransitionEvent;

class CSIPProfileRegistry;

#define LAST_REQUEST_IND iPendingReceivedRequests.Count()-1

#define CURRENT_REQUEST_IND LAST_REQUEST_IND

#define CURRENT_REQUEST()\

    ( iPendingReceivedRequests.Count() == 0 ?\

      NULL : iPendingReceivedRequests[ LAST_REQUEST_IND ] )

#define FIRST_REQUEST()\

    ( iPendingReceivedRequests.Count() == 0 ?\

      NULL : iPendingReceivedRequests[ 0 ] )

// CLASS DECLARATION

/**

* Client-Server sub-session is the base class

* for SIP sessions, which have created to encapsulate

* SIP dialogs.

* This class provides methods to handle CS subsession

* specifig ITC functions and to receive SIP requests and 

* responses.

*

*  @lib 

*  @since

*/

class CMceCsSubSession : public CBase

    {

public: //enums

    enum TType

        {

        EUnknown = -1,

        EInSession,

        EOutSession,

        EOutSIPSession

        };

public: // Constructors and destructor

	/**

	* Destructor.

	*/

	~CMceCsSubSession();

public: // New functions

	/**

	* Returns client type of session.

	* The type represents type of dialog used in session.

	* @return client type of session

	*/

    TMceCsSessionType ClientType() const;

	/**

	* Returns type of session

	* @return type of session

	*/

    TType Type() const;

	/**

	* Returns SIP connection instance

	* @return SIP connection

	*/

    CMceSipConnection& SIPConnection() const;

	/**

	* Returns SIP manager instance

	* @return SIP manager

	*/

    CMceSipManager& Manager() const;

	/**

	* Returns server core instance

	* @return server core

	*/

	CMceServerCore& ServerCore() const;

    /**

    * Returns client

    * @return client

    */

    CMceCsSessionImplementation& Client() const;

	/**

	* Returns floor control session instance

	* @return floor control session

	*/

	const CFCSession* FCSession() const;

	/**

	* 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 from the client.

	*/

	void ServiceL( TMceIds& aIds, 

	               TMceItcFunctions aFunction, 

	               const RMessage2& aMessage );

	/**

	* Sends data via callback mechanism to client session

	* @param aIds set of ids defining ITC callback context

	* @return system wide error

	*/

    TInt SendToClient( TMceIds& aIds );

	/**

	* Sends data via callback mechanism to client session

	* @param aIds set of ids defining ITC callback context

	* @param aContext encoded context of message

	* @param aContent content of message

	*/

    void SendToClientL( TMceIds& aIds, HBufC8* aContext, HBufC8* aContent );

	/**

	* Sends error via callback mechanism to client session

	* @param aIds set of ids defining ITC callback context

	* @param aError the error

	* @return system wide error

	*/

	TInt SendErrorToClient( TMceIds& aIds, TInt aError );

    /**

	* Resets the initial INVITE.

	*/

    void ResetInitialInvite();

    /**

	* Controls whether the session should generate automatically event 

	* at next state change.

	* @param aIsEnabled

	*/

    void SetAutoEvent( TBool aIsEnabled );

    /**

	* Checks whether the session should automatically generate an event 

	* at next state change.

	* @return ETrue if event should be generated, otherwise EFalse

	*/

	TBool AutoEvent();

	/**

	* Stores event which will be used when automatic event generation

	* occurs. Request which is associated with the event may be defined.

	* @param aEvent, ownership is not transferred

	* @param aAssociatedRequest, ownership is not transferred

	*/

	void StoreAutoEventL( TMceStateTransitionEvent* aEvent,

	                      CSIPServerTransaction* aAssociatedRequest );

    /**

	* Returns stored automatic event.

	* @return event or null

	*/

	TMceStateTransitionEvent* StoredAutoEvent();

    /**

    * Checks if profile configured.

    *

    * @return return ETrue if profile configured.

    */

	TBool ProfileConfigured() const;

	/**

    * Return profile

    *

    * @return return profile of the connection

    */

	CSIPProfile& Profile() const;

    /**

    * Set profile

    *

    * @param aProfile Profile to be used

    */

    void SetProfile( CSIPProfile& aProfile );

    /**

    * Check Profile contact secure status 

    *

    * @return True if profile contact with sipsUri or tls

    */

	TBool IsProfileContactSecureL();

	/**

    * Return NextHop

    *

    * @return NextHop TInetAddr

    */

	TInetAddr* NextHopL( TInetAddr& aNextHop );

	void RemoveCompletedRequests( TBool aAll = EFalse );

public://SIP adaptation methods

	/**

	* Initializes incoming dialog

	* @param aTransaction server transaction representing a request,

	* which caused dialog creation

	*/

    void InitializeIncomingDialogL( CSIPServerTransaction* aTransaction );

	/**

	* Handles SIP request, which has been received inside a dialog

	* @param aTransaction server transaction representing a request

	* @param aDialog dialog to wich transaction belongs

	* @return ETrue, if session handled the request

	*/

    TBool DialogRequestReceived( CSIPServerTransaction* aTransaction,

    											CSIPDialog& aDialog );

	/**

	* Handles SIP request, which has been received inside a dialog.

	* this will call DialogResponseReceived

	* @param aTransaction server transaction representing a request

	* @param aDialogAssoc the dialog

	*/

    void ResponseReceivedWithinDialog( CSIPClientTransaction& aTransaction,

                                       	CSIPDialogAssocBase& aDialogAssoc );

	/**

	* Handles SIP response, which has been received inside a dialog

    * @param aTransaction client transaction representing a response

	*/

    void DialogResponseReceived( CSIPClientTransaction& aTransaction  );

    /**

    * Handles SIP request, which has been received outside a dialog

    * @param aTransaction server transaction representing a request

	* @return ETrue, if session handled the request

    */

    TBool MessageRequestReceived( CSIPServerTransaction* aTransaction );

	/**

	* Handles SIP response, which has been received outside a dialog

    * @param aTransaction client transaction representing a response

	*/

    void MessageResponseReceived( CSIPClientTransaction& aTransaction );

    /*

	* 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

    */

    virtual void InviteCompleted( CSIPClientTransaction& 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 aState indicates the current connection state        

	*/

    void ConnectionStateChanged( CSIPConnection::TState aState );

    /**

	* Handles situation where an asynchronous error has occured 

	* related to a request within an existing dialog.

    *

    * @param aError error code

    * @param aTransaction the transaction

    */

    virtual void ErrorOccured( TInt aError, CSIPTransactionBase& aTransaction );

	/**

	* Returns dialog id

	* @return dialog id

	*/

    TUint32 DialogId() const;

	/**

	* Returns ETrue, if client has called ready to receive

	* @return ETrue, if client has called ready to receive

	*/

    TBool ClientExists();

	/**

	* Returns SIP dialog (assoc)

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

	*/

    virtual CSIPDialogAssocBase* Dialog() const;

	/**

	* Returns current (pending) request

	* @return server transaction representing the request

	*/

    CSIPServerTransaction& Request() const;

    /**

    * Returns initial request which caused session creation.

    * @return server transaction representing the initial request

    */

    CSIPServerTransaction& InitialRequest() const;

	/**

	* Transferes ownership of current (pending) request

	* @return server transaction representing the request

	*/

    CSIPServerTransaction* PopRequest();

	/**

	* Returns current (pending) response

	* @return client transaction representing the request

	*/

    CSIPClientTransaction& Response() const;

	/**

	* Transferes ownership of current (pending) response

	* @return completed client transaction or NULL if there is no 

	* pending response or transaction is not completed.

	*/

    CSIPClientTransaction* PopResponse();

	/**

	* Stores SIP dialog 

	* @param aType the type of session

	* @param aDialog SIP dialog

	* @param aDialogId generated dialog id

	*/

    void SetDialog( TType aType, 

                    CSIPDialogAssocBase* aDialog, 

                    TUint32 aDialogId );

	/**

	* Sets client transaction which is waiting response from peer

	* @param aTransaction the pending transaction

	*/

    void SetPendingTransactionL( 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

	*/

    virtual TBool Consumes( CSIPDialog& aDialog, 

                            CSIPServerTransaction& aTransaction, 

                            TBool& aAssociatesWithDialog );

	/**

	* Returns ETrue, if session will consume the transaction

	* @param aTransaction pending or new (incoming) transaction

	* @return ETrue, if session will consume the transaction

	*/

    virtual TBool Consumes( CSIPTransactionBase& aTransaction );

	/**

	* Returns ETrue, if session accepts transaction

	* @param aTransaction new (incoming) transaction

	* @return ETrue, if session will accepts the transaction

	*/

    virtual TBool AcceptDialogTransaction( CSIPServerTransaction& aTransaction );

	/**

	* Returns ETrue, if session accepts stand-alone transaction

	* @param aTransaction new (incoming) stand-alone transaction

	* @return ETrue, if session will accepts the stand-alone transaction

	*/

    virtual TBool AcceptStandAloneTransaction( CSIPServerTransaction& aTransaction );

	/**

	* Returns all pending transactions

	* @return pending transactions as an array

	*/

    const RPointerArray<CSIPClientTransaction>& PendingTransactions();

    const RPointerArray<CSIPServerTransaction>& PendingReceivedRequests();

	/**

	* Returns pending transaction based on type

	* @param aType type of transaction

	* @return pending transactions or NULL. Ownership is NOT transfered

	*/

    CSIPClientTransaction* PendingTransaction( RStringF aType );

    /**

    * Returns the default headers

    * @param aMethodInd the methond index in SIP strings

    * @return default headers

    */

    CDesC8Array& DefaultHeaders( TInt aMethodInd );

    /**

    * Stores client's message content

    * @param aClientContent the message content

    */

    void StoreClientContent( HBufC8* aClientContent );

    /**

    * Transferes ownership of client message content

    * @return client content

    */

    HBufC8* PopClientContent();

    /**

    * Removes the pending transaction.

    * @param aTransaction the transaction to be removed

    * @return ETrue if the transaction was removed.

    */

    TBool RemovePendingTrx( CSIPClientTransaction& aTransaction );

public://abstract methods

	/**

	* Executes ITC function called by client.

	* Default implementation leaves with KErrNotSupported

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

	*/

    virtual HBufC8* DoServiceL( TMceIds& aIds, 

                                TMceItcFunctions aFunction );

	/**

	* Executes ITC function called by client.

	* Default implementation leaves with KErrNotSupported

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @param aMessage message context from client

	*/

    virtual void DoServiceL( TMceIds& aIds, 

                             TMceItcFunctions aFunction, 

		     	             const TDesC8& aMessage );

	/**

	* Executes ITC function called by client.

	* Default implementation leaves with KErrNotSupported

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @param aMessage message context from client

	*/

    virtual void DoServiceL( TMceIds& aIds, 

                             TMceItcFunctions aFunction, 

		     	             TPtr8& aMessage );

	/**

	* Executes ITC function called by client.

	* Default implementation leaves with KErrNotSupported

	* @param aIds set of ids defining ITC call context

	* @param aFunction ITC function to be executed

	* @param aMessage decoded message context from client

	*/

    virtual void DoServiceL( TMceIds& aIds, 

                             TMceItcFunctions aFunction, 

		     	             CMceMsgBase& aMessage );

	/**

	* Returns ETrue, if session can be deleted

	* @return ETrue, if session can be deleted

	*/

    virtual TBool CanDispose() = 0;

	/**

	* Initializes incoming dialog

	* @param aTransaction server transaction representing a request,

	* which caused dialog creation

	*/

    virtual void DoInitializeIncomingDialogL( 

                            CSIPServerTransaction& aTransaction ) = 0;

    /**

	* Handles situation where an asynchronous error has occured 

	* related to a request within an existing dialog.