// Copyright (c) 2005-2009 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:

// CSIPTransitionEngine definition file

// 

//

/**

 @file

 @internalComponent

*/

#ifndef TRANSITIONENGINE_H

#define TRANSITIONENGINE_H

#include <e32base.h>

#include <sip.h>

#include <sipobserver.h>

#include <sipconnectionobserver.h>

#include <sipprofileregistryobserver.h>

#include <sipprofile.h>

#include <sipprofileregistry.h>

#include <sipfromheader.h>

#include <siptoheader.h>

#include <sipcontactheader.h>

#include <sipmessageelements.h>

#include <siprequestelements.h>

#include <sipresponseelements.h>

#include <siprefresh.h>

#include <sipregistrationbinding.h>

#include <sipdialog.h>

#include <sipinvitedialogassoc.h>

#include <sipsubscribedialogassoc.h>

#include <sipnotifydialogassoc.h>

#include <sipreferdialogassoc.h>

#include <sipservertransaction.h>

#include <sipclienttransaction.h>

#include <sipaddress.h>

#include <sdpdocument.h>

#include <sipcontenttypeheader.h>

#include <sdpcodecstringconstants.h>

#include <sdpcodecstringpool.h>

#include <sipstrings.h>

#include <sipstrconsts.h>  

#include <sipcseqheader.h>

#include <sipeventheader.h>

#include <sipexpiresheader.h>

#include <sipacceptheader.h>

#include "siphlcommontypes.h"

#include <siperr.h>

#include <siphttpdigestchallengeobserver.h>

#include <siphttpdigest.h>

#ifdef __FLOG_ACTIVE

	// This will do the logging if logging is enabled

    #include <comms-infras/ss_log.h>

#endif

class CSipStateMachine;

class MSIPRegistrationClient

/**

To be implemented by whoever uses CSIPTransitionEngine to Register

at the SIP registrar - see CSIPTransitionEngine::RegisterL

*/

	{

	public:

	/**

	Called by the TE when the requested registration is complete

	@param aError error indication, if KErrNone - the registration 

	has been successful, non-successful otherwise.

	*/	

	virtual void RegistrationComplete(TInt aError) = 0;

	/**

	Called by the TE when 'this' has been unregistered either as a result of:

	- previously issued deregistration request

	- unregistered by the registrar

	@param aError error indication

	*/	

	virtual void DeRegistrationComplete(TInt aError) = 0;

	/**

	Called by the TE when a error occurs which has to be notified to "its"

	connection providers

	@param aError error indication

	*/

	virtual void ErrorOccurred(TInt aError) = 0;

	/**

	Called by the State Machine to flag that a peer is calling.

    @return the SIP profileId the TE will use to identify 'this'

	*/	

	virtual TUint32 GetProfileId() = 0;

	/**

	Called by the TransitionEngien Manager to obtain the AppUId of the

	Conn Provider when Detaching

	@return the appUid stored by the ConnProvider

	*/

	virtual TUid	GetAppUid() = 0;

	};   

class CSIPTransitionEngine : public CBase,

							 MSIPConnectionObserver,

							 MSIPProfileRegistryObserver,

							 MSIPHttpDigestChallengeObserver

/**

 SIPTransitionEngine 

 This class implements the following set of methods

 - Call back methods which are called by the Sip stack. These trigger transition in the State Machines

 - Call back methods which are triggered by the Profile Manager (for Registration, Profile events)

@internalComponent

@released since v9.2

*/						

	{

public:

	friend class CSIPTransitionEngineBundle;

	//New Functions - Services provided by CSIPTransitionEngine

	/**

	This method is called by a Connection Provider to initialize

	Registration

	@param aRegistrationClient , an object which implements MSIPRegistrationClient  interface ( a SIPCPR)

	*/

	IMPORT_C void RegisterL(MSIPRegistrationClient* aConnProv);

	/**

	This method is called by a Connection Provider to initialize

	DeRegistration

	@param aRegistrationClient , an object which implements MSIPRegistrationClient interface ( a SIPCPR)

	*/

	IMPORT_C void Deregister(MSIPRegistrationClient* aConnProv);

	/**

	This method is called by a State Machine, to register itself

	with the TransitionEngine

	@param aStateMachine Register Instance of State machine with TE

	*/

	IMPORT_C void AddStateMachineL(CSipStateMachine* aStateMachine);

	/**

	This method is called by a Connection Provider to initialize

	Registration

	@return profile id of a matching profile already available with TransitionEngine

	@param  aProfileId , profile id to be matached

	*/

	IMPORT_C TUint32 FindDuplicateProfile(TUint32 aProfileId);

	/**

	This method is called to add a Credentials structure to a list of credentials

	maintained by the TransitionEngine

	*/

	IMPORT_C void AddCredentialsL(TSIPCredentials aCredential);

	/**

	Returns the 'from' field associated with the given profile. 

	@param aProfileId the id of the profile the 'from' field should pertain to.

	@return the 'from' field associated with aProfileId. Given 'this' has been

	asked to register the profile.

	*/

    IMPORT_C const TDesC8* GetFromField(TUint32 aProfileId) const;

	/**

	This method associates the SIP transaction with a particular State machine

	@param  aStateMachine	Instance of the state machine

	@param  aTransaction	which will be associated with the state machine

	*/

	void	SetTransaction(CSipStateMachine* aStateMachine, CSIPTransactionBase* aTransaction);

	/**

	This method associates the SIP Dialog association with a particular State machine

	@param  aStateMachine	Instance of the state machine

	@param  aDialoAssoc		which will be associated with the state machine

	*/

	void	SetDialogAssoc(CSipStateMachine* aStateMachine, CSIPDialogAssocBase* aDialoAssoc);

	/**

	This method will cleanup the transition engine related to a particular state machine

	@param  aStateMachine	which needs to be cleaned up

	*/

	void	Cleanup(CSipStateMachine * aStateMachine);

	/**

	This method will find the state machine to handle the incoming call.

	*/

	CSipStateMachine* 	FindSMForIncomingCall();

	/**

	This method will find the state machine which is associated with the particular

	transaction.

	@param  aTransaction which needs to be matched with SM

	*/

	CSipStateMachine*	FindStateMachine(CSIPTransactionBase& aTransaction);

	/**

	This method will find the state machine which is associated with the particular

	Dialog.

	@param  aDialogAssoc which needs to be matched with SM

	*/

	CSipStateMachine*	FindStateMachine(CSIPDialogAssocBase& aDialogAssoc);

	/**

	Overloaded method will find the state machine which is associated with the particular

	Dialog.

	@param  aDialogAssoc which needs to be matched with SM

	*/

	CSipStateMachine*	FindStateMachine(CSIPDialogAssocBase* aDialogAssoc);

	/**

	Overloaded method will find the state machine which is associated with the particular

	Dialog.

	@param  aDialogAssoc which needs to be matched with SM

	*/

	CSipStateMachine*	FindStateMachine(CSIPDialog& aDialogAssoc);

	/**

	Overloaded method will find the state machine which is associated with the particular

	Dialog.

	@param  aTransaction which needs to be matched with SM

	*/

	CSipStateMachine*	FindStateMachine(const CSIPTransactionBase* aTransaction);

	/**

	This method will return the SIP connection associated with the Transition Engine

	*/

	CSIPConnection* 	GetSipConnection();

	/**

	This method returns the handle of the registration client associated with the 

	profile Id

	@param  aProfileId for registration association

	*/

	MSIPRegistrationClient*	FindRegistrationClient(TUint32 aProfileId);

	/**

	This function increases the reference count 

    */

	void Attach();

	/**

	This function decreases the reference count 

    */

    //todo

    TInt Detach();

   	//TInt Detach(MSIPRegistrationClient* aRegClient);

	/**

	This function returns an IAP id

    */

	TInt IapId();

	// Methods from base classes

	// From MSIPConnectionObserver

	/**

	A SIP request outside a dialog has been received from the network.

	@param aTransaction SIP server transaction. The ownership is transferred.

    */

	void	IncomingRequest( CSIPServerTransaction* aTransaction );

	/**

	A SIP request within a dialog has been received 

	@param aTransaction SIP server transaction. The ownership is transferred.

	@param aDialog the dialog that this transaction belongs to.        

	*/

	void IncomingRequest( CSIPServerTransaction* aTransaction,

						  CSIPDialog& aDialog );

	/**

	IncomingResponse (from MSIPConnectionObserver)

	*/

	void IncomingResponse( CSIPClientTransaction& aTransaction );

	/**

	A SIP response that is within a dialog association or creates a dialog association.

    @param aTransaction contains response elements.

	@param aDialogAssoc a dialog association.        

	*/

	void IncomingResponse( CSIPClientTransaction& aTransaction,

						   CSIPDialogAssocBase& aDialogAssoc );

    /**

	IncomingResponse (from MSIPConnectionObserver)

	Multiple SIP responses have been received to the single INVITE due to the forking proxy. 

	Note that each response creates a separate INVITE dialog association.Multiple responses 

	can arrive until SIP stack completes UAC core INVITE transaction.If clients deletes INVITE 

	transaction after first SIP response other possible responses will be consumed by the implementation.

	@param aTransaction contains response elements

	@param aDialogAssoc INVITE dialog association;

	*/

	void IncomingResponse( CSIPClientTransaction& aTransaction,

						   CSIPInviteDialogAssoc* aDialogAssoc );

	/**

	IncomingResponse (from MSIPConnectionObserver)

	@param aTransaction contains response elements

	@param aRegistration contains the Registration Binding

	*/

	void IncomingResponse( CSIPClientTransaction& aTransaction,

						   CSIPRegistrationBinding& aRegistration );

	/**

	An asynchronous error has occurred in the stack related to the

	request indicated by the given transaction.

	@param aError system wide or sip error code

	@param aTransaction failed transaction.

	@param aSIPConnection a SIP connection        

	*/

	void ErrorOccured( TInt aError, CSIPTransactionBase& aTransaction );

	/**

	An asynchronous error has occurred in the stack related

	to the request indicated by the given transaction.

	@param aError system wide or sip error code

	@param aTransaction the failed transaction.

	@param aRegistration the failed registration.        

	*/

	void ErrorOccured( TInt aError,

					   CSIPClientTransaction& aTransaction,

					   CSIPRegistrationBinding& aRegistration );

	/**

	An asynchronous error has occured related to a request within an existing dialog.

	@param aError system wide or sip error code

	@param aTransaction the failed transaction.

	@param aDialogAssoc the failed dialog associoation.        

	*/

	void ErrorOccured( TInt aError,

					   CSIPTransactionBase& aTransaction,

					   CSIPDialogAssocBase& aDialogAssoc );

	/**

	An asynchronous error has occured related to a refresh 

    @param aError system wide or sip error code

	@param aSIPRefresh original refresh object.        

	*/

	void ErrorOccured( TInt aError, CSIPRefresh& aSIPRefresh );

	/**

	An asynchronous error has occured related to a periodical refresh

    that relates to a registration.

    @param aError system wide or sip error code; 

	@param aRegistration associated registration.

	*/

	void ErrorOccured( TInt aError,

					   CSIPRegistrationBinding& aRegistration );

	/**

	An asynchronous error has occured related to a periodical refresh

    that belongs to SIP dialog association.

    @param aError system wide or sip error code; 

	@param aDialogAssoc SIP dialog association.        

	*/

	void ErrorOccured( TInt aError,

					   CSIPDialogAssocBase& aDialogAssoc );

    /**

	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.

    If the INVITE transaction does not create a dialog, or the INVITE transaction encounters 

    an error, this event will not be sent.

    @param aTransaction a complete UAC core INVITE transaction

	*/

    void InviteCompleted( CSIPClientTransaction& aTransaction );

   	/**

    Invite was canceled with the CANCEL

    @param aTransaction a canceled INVITE UAS transaction

    */

    void InviteCanceled( CSIPServerTransaction& aTransaction );

	/**

	Connection state has changed.If connection state has changed to EInactive or EUnavailable,

	SIP stack has removed all stand-alone SIP refreshes, registrations and dialog associations 

	that client requested to refresh. Client may re-issue refresh requests (stand-alone, 

	registration or dialog association related) when connection becomes EActive again.

	SIP stack also terminates all pending sip client transactions and no errors are reported back 

	to the client about the terminated transactions nor about removed refreshes in order to 

	avoid event flood.

	@param aState indicates the current connection state        

	*/

	void ConnectionStateChanged( CSIPConnection::TState aState );

	//From MSIPProfileRegistryObserver

	/** 

	An event related to SIP Profile has accorred

	@param aProfileId a profile Id

	@param aEvent an occurred event

	*/

	void ProfileRegistryErrorOccurred(TUint32 aProfileId, TInt aError);

	/**

	An asynchronous error has occurred related to SIP profile Event is send to 

	those observers, who have the corresponding profile instantiated.

	@param aProfileId the id of failed profile 

	@param aError an occurred error

	*/

	void ProfileRegistryEventOccurred(TUint32 aProfileId, TEvent aEvent);

	/**

	SIP request resulted in 401/407 response that contains

	a challenge.

	@param aRealm a realm for which the challenge was received

	*/

	void ChallengeReceived(const TDesC8& aRealm);

private:

	/**

	Instantiation function will be called from a friend class

	@param  aSip 	Handle to the SIP

	@param  aIapId	IAP on which the connection will be created

	*/

	static CSIPTransitionEngine* NewL(CSIP& aSip, TInt aIapId);

	/**

	constructor of the class

	*/

	CSIPTransitionEngine(CSIP& aSip, TInt aIapId);

	/**

	destructor of the class

	*/

	~CSIPTransitionEngine();

	/**

	2nd phase construction of the class

	*/

	void	ConstructL();

	/**

	This method handles the incoming request if it comes outside of a existing dialog

	@param  aTransaction The transaction associated with the new dialog.

	*/

	void IncomingRequestL( CSIPServerTransaction* aTransaction );

	/**

	This method handles the requests coming inside a Dialog

	@param  aTransaction The transaction associated with the new dialog.

	@param  aDialog  Handle to the dialog itself

	*/

	void IncomingRequestL( CSIPServerTransaction* aTransaction, CSIPDialog& aDialog );

	/**

	This method is used to walkthrough the array of credentials 

	and set them once a challenge is recieved

	@param aRealm - Realm of the issuer of the challenge

	*/

	TBool FindAndSetCredentials(const TDesC8& aRealm);

	void IncomingRequestHandlerL(CSIPServerTransaction* aTransaction);

private:

	// For Logging

	__FLOG_DECLARATION_MEMBER;

	// The IAP id of the CSipConnection

	TUint 						iIapId;

	// The connection state 

	CSIPConnection::TState		iConnState;

	// Handle to the SIP stack

	CSIP&						iSIP;

	// Handle to the SIP connection towards a particular IAP

	CSIPConnection*				iConnection;