/*

* Copyright (c) 2004-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:

*

*/

#ifndef _SIPEXSIPENGINE_H_

#define _SIPEXSIPENGINE_H_

// INCLUDES

#include <e32base.h>

#include <e32std.h>

#include <e32math.h>

#include <s32mem.h>

#include <in_sock.h>

#include <sip.h>

#include <sipdialog.h>

#include <sipobserver.h>

#include <sipinvitedialogassoc.h>

#include <sipconnectionobserver.h>

#include <sipservertransaction.h>

#include <sipmessageelements.h>

#include <siprequestelements.h>

#include <sdpdocument.h>

#include <sdpmediafield.h>

#include <sdporiginfield.h>

#include <sdpconnectionfield.h>

#include <sdpcodecstringconstants.h>

#include <sdpcodecstringpool.h>

#include <sipprofile.h>

#include <sipprofileregistry.h>

#include <sipprofileregistryobserver.h>

#include <sipaddress.h>

#include <sipcontenttypeheader.h>

#include <sipfromheader.h>

#include "SIPExSIPEngineObserver.h"

#include "SIPExSIPIdleState.h"

#include "SIPExSIPClientEstablishingState.h"

#include "SIPExSIPClientOfferingState.h"

#include "SIPExSIPServerOfferingState.h"

#include "SIPExSIPServerEstablishingState.h"

#include "SIPExSIPEstablishedState.h"

#include "SIPExSIPTerminatingState.h"

// FORWARD DECLARATIONS

class CSIP;

class CSIPDialog;

class CSIPServerTransaction;

class CSIPMessageElements;

class CSIPRequestElements;

class CSIPAddress;

class CSIPContentTypeHeader;

class CSIPFromHeader;

class MSIPExSIPEngineObserver;

class CSIPExSIPIdleState;

class CSIPExSIPClientEstablishingState;

class CSIPExSIPClientOfferingState;

class CSIPExSIPServerOfferingState;

class CSIPExSIPServerEstablishingState;

class CSIPExSIPEstablishedState;

class CSIPExSIPTerminatingState;

// CLASS DECLARATION

/**

* CSIPExSIPEngine

* Class for implementing the SIP Engine for the SIP

* Example Application. The Engine provides API functions

* for other parts of the Application, and maintains an

* internal state machine to handle the SIP session.

*/

class CSIPExSIPEngine: public CBase,

							   MSIPObserver,

							   MSIPConnectionObserver,

							   MSIPProfileRegistryObserver

	{

    public: // Constructors and destructor

		/**

		* NewL

		* Create new instance of SIP Engine.

		* @param aAppUid Application uid.

		* @param aObserver Pointer to the Engine Observer.

		* @return Pointer to new SIP Engine instance.

		*/

		IMPORT_C static CSIPExSIPEngine* NewL( TUid aAppUid,

												MSIPExSIPEngineObserver* aObserver );

		/**

		* Destructor.

		*/

		virtual ~CSIPExSIPEngine();

	private:

		/**

		* C++ default constructor.

		*/

		CSIPExSIPEngine();

		/**

		* 2nd phase construction.

		* @param aAppUid Application uid.

		* @param aObserver Pointer to the Engine Observer.

		*/

		void ConstructL( TUid aAppUid,

						 MSIPExSIPEngineObserver* aObserver );

	public:	// New functions - services provided by the SIP Engine

		/**

		* EnableProfileL

		* Enable the default profile.

		* Callback is notified when operation is complete.

		* Leaves if default SIP profile is not found or profile type is not expected.

		* Returns true if profile was registered immediately after enabling.

		*/

		IMPORT_C TBool EnableProfileL();

		/**

		* DisableProfile

		* Disable the current profile.

		* Callback is notified when operation is complete.

		*/

		IMPORT_C void DisableProfileL();

		/**

		* SendInvite

		* Create and send an INVITE to the recipient

		* identified by the parameter.

		* @param aSipUri Address of the recipient.

		*/

		IMPORT_C void SendInviteL( const TDesC8& aSipUri );

		/**

		* CancelInvite

		* CANCEL a previously sent INVITE. If a final

		* response for the INVITE has been sent, the

		* CANCEL request fails.

		*/

		IMPORT_C void CancelInviteL();

		/**

		* AcceptInvite

		* Send a 200 (OK) response to an INVITE sent

		* by a remote party.

		* @param aIPAddr local ip-address.

		*/

		IMPORT_C void AcceptInviteL(const TInetAddr& aIPAddr );

		/**

		* DeclineInvite

		* Send a 488 (Not Acceptable Here) response to

		* an INVITE sent by a remote party.

		*/

		IMPORT_C void DeclineInviteL();

		/**

		* EndSession

		* Terminate the SIP session by sending a BYE

		* request.

		*/

		IMPORT_C void EndSessionL();

		/**

		* CreateIML

		* Create an instant message and send it to the

		* remote party using the MESSAGE method.

		* @param aMessage The message to be sent.

		* @param aSipUri Address of the recipient.

		*/

		IMPORT_C void CreateIML( const TDesC8& aMessage,

							 	 const TDesC8& aSipUri );

	public:		// State machine & internal functionality

		/**

		* IMReceivedL

		* An instant message has been received from the

		* network. Inform the observer.

		* @param aTransaction Contains message elements.

		* Ownership is transferred.

		*/

		void IMReceivedL( CSIPServerTransaction* aTransaction );

		/**

		* IMReceived

		* A non-leaving version of the IMReceivedL, the

		* possible errors are trapped.

		* @param aTransaction Contains message elements.

		* Ownership is transferred.

		*/

		void IMReceived( CSIPServerTransaction* aTransaction );

		/**

		* SetCurrentState

		* Sets the active state of the state machine.

		* @param aState The current state.

		*/

		void SetCurrentState( CSIPExSIPStateBase* aState );

		/**

		* Connection

		* Sets the active connection.

		*/

		CSIPConnection& ConnectionL();

		/**

		* Profile

		* Returns the enabled profile.

		*/

		CSIPProfile& Profile();

		/**

		* SetServerTx

		* Sets the current Server Transaction.

		* The ownership is transferred to the Engine.

		* @param aTx The transaction.

		*/

		void SetServerTx( CSIPServerTransaction* aTx );

		/**

		* ServerTx

		* Gets the current Server Transaction.

		*/

		CSIPServerTransaction& ServerTx();

		/**

		* SetClientTx

		* Sets the current Client Transaction.

		* The ownership is transferred to the Engine.

		* @param aTx The transaction.

		*/

		void SetClientTx( CSIPClientTransaction* aTx );

		/**

		* ClearClientTx

		* Deletes the current Client Transaction.

		*/

		void ClearClientTx();

		/**

		* ClientTx

		* Gets the current Client Transaction.

		*/

		CSIPClientTransaction& ClientTx();

		/**

		* SetDialogAssoc

		* Sets the current Invite Dialog Association.

		* @param aAssoc The Dialog Assoc.

		*/

		void SetDialogAssoc( CSIPInviteDialogAssoc& aAssoc );

		/**

		* DialogAssoc

		* Returns the current Invite Dialog Association.

		*/

		CSIPInviteDialogAssoc& DialogAssoc();

	public:		// Methods from base classes

// From MSIPObserver

		/**

		* IncomingRequest (from MSIPObserver)

		* A SIP request has been received from the network.		

		* @param aIapId The IapId from which

		*        the SIP request was received. 

		* @param aTransaction contains local address,

		*        remote address of a sip message,

		*        as well as optional SIP message method, headers and body.

		*        The ownership is transferred.        

        */

		void IncomingRequest( TUint32 aIapId,

							  CSIPServerTransaction* aTransaction );

		/**

		* TimedOut (from MSIPObserver)

		*/

		void TimedOut( CSIPServerTransaction& aSIPServerTransaction );

// From MSIPConnectionObserver

		/**

		* IncomingRequest (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 );

		/**

		* IncomingRequest (from MSIPConnectionObserver)

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

		* The client must resolve the actual dialog association to which

		* this request belongs.

		*

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

		/**

		* IncomingResponse (from MSIPConnectionObserver)

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

		*/

		void IncomingResponse( CSIPClientTransaction& aTransaction,

							   CSIPInviteDialogAssoc* aDialogAssoc );

		/**

		* IncomingResponse (from MSIPConnectionObserver)

		*/

		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; 

		*		 KErrCouldNotConnect if the refresh has failed

		*		 due to the suspended connection.

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

		*        KErrCouldNotConnect if the refresh has failed

		*		 due to the suspended connection.

		* @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 ProfileRegistryEventOccurred( TUint32 aProfileId, TEvent aEvent );

		/**

		* 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 ProfileRegistryErrorOccurred( TUint32 aProfileId, TInt aError );

	public:	// Methods internal to the Engine

		/**

		* CreateToHeaderLC

		* Return a To header object based on URI.

		* @param aSipUri The URI address as a string.

		* @return Pointer to CSIPToHeader instance.

		* Ownership is transferred.

		*/

		CSIPToHeader* CreateToHeaderLC( const TDesC8& aSipUri );

		/**

		* CreateReqElementsLC

		* Return a RequestElements object based on URI.

		* @param aSipUri The URI address as a string.

		* @return Pointer to CSIPRequestElements instance.

		*/

		CSIPRequestElements* CreateReqElementsLC( const TDesC8& aSipUri );

		/**

		* CreateMessageElementsLC

		* Instantiate a Message Elements object.

		* @return Pointer to CSIPMessageElements instance.

		* Ownership is transferred.

		*/