diff -r 000000000000 -r 307788aac0a8 sipproviderplugins/sipprovider/sipstatemachine/inc/SipStateMachine.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sipproviderplugins/sipprovider/sipstatemachine/inc/SipStateMachine.h	Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,689 @@
+// 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:
+// CSipStateMachine definition file
+// 
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+
+#ifndef SIP_STATEMACHINE_H
+#define SIP_STATEMACHINE_H
+
+#include "transitionengine.h"
+#include "SipStateBase.h"
+#include "siphlcommontypes.h"
+
+#ifdef __FLOG_ACTIVE
+	// This will do the logging if logging is enabled
+    #include <comms-infras/ss_log.h>
+#endif
+
+
+// Forward Declarations
+class CStateIdle;
+class CStateSessionInitiation;
+class CStateSessionEstablished;
+class CStateSessionTerminate;
+class CSipStateMachine;
+
+
+class TCommandContext
+/**This class represents the Handles of the SIP stack that is required
+for a particular state machine. Using these handles the State machine
+interact with the Stack to achieve a particular functionality
+
+@internalComponent
+@released since v9.2
+ */
+	{
+public:
+	CSipStateBase * 			iCommandState;
+	CSIPClientTransaction*		iClientTx;
+	CSIPClientTransaction*		iCancelClientTx;
+	CSIPServerTransaction*		iServerTx;
+	CSIPInviteDialogAssoc*		iDialogAssoc;
+	CSIPRegistrationBinding*	iRegBinding;
+	CSIPSubscribeDialogAssoc*	iSubsDialogAssoc;
+	TBool						iAckCancel;
+	};
+
+class TCallTerminateCode
+/** This class will contain the call termiated error codes that needs to be sent to
+the calling application
+*/
+	{
+public:
+	TInt	iErrorCode;
+	TInt	iSipCode;
+	};
+
+
+class MSIPStateMachineClient
+/**
+To be implemented by whoever uses CSipStateMachine and wishes to
+be notified about completions and events.
+
+@internalComponent
+@released since v9.2
+*/
+	{
+	public:
+
+	/**
+	Called by the State Machine that call has been established
+	*/
+	virtual void CallEstablished() = 0;
+
+	/**
+	Called by the State Machine when the running or being established
+	call has been terminated. Can either:
+	- acknowledge local termination
+	- flag termination by the peer
+	- flag error during the call or during its establishment
+
+	@param aError system wide error, SIP proprietary error or KErrNoError if no error.
+	*/
+	virtual void CallTerminated(TInt aError, TInt aSipCode) = 0;
+
+	/**
+	Called by the State Machine to flag that a peer is calling.
+
+    @param aCallParams the description of the call.
+	*/
+	virtual void IncomingCall(TIncomingCallParameters& aCallParams) = 0;
+
+	/**
+	Called by the State Machine to flag that credentials are
+	required for the pending call to proceed.
+
+    @param aRealm the description of the credentials
+	*/
+	virtual void CredentialsRequired(const TDesC8 & aRealm) = 0;
+
+	/**
+	Called by the state machine when some notifications arrived
+
+	@param aNotification contains notification Information
+	*/
+	virtual void ReceiveNotification(TDesC8 & aNotification) = 0;
+	};
+
+
+class CSipStateMachine : public CActive
+/**
+This class contains the complete logic for all SIP realted functionalities supported
+by this release of High Level API.
+
+@internalComponent
+@released since v9.2
+*/
+
+	{
+public:
+	/**
+	Static Member furnction to give life to Sip State Machine
+
+	@param aTe Handle to the Transition engine, whicn encapsulated the sip stack.
+	@param aClient, Handle to the Notification client for callback notifications
+	*/
+	IMPORT_C static CSipStateMachine * NewL(CSIPTransitionEngine * aTe, MSIPStateMachineClient* aClient, TBool aSMDirection );
+
+	/**
+	This method is responsible for Answering an Incoming call. With call to this
+	method the client is accepting a call, and call will be established. After this
+	only StopCall() will work, not RejectCall();
+	*/
+	IMPORT_C TInt AcceptCall();
+
+	/**
+	This method is responsible Starting an outgoing call.
+	*/
+	IMPORT_C TInt StartCall();
+
+	/**
+	This method is responsible to terminate an ongoing call.
+	*/
+	IMPORT_C TInt StopCall();
+
+	/**
+	This method Rejects an incoming call.
+	*/
+	IMPORT_C TInt RejectCall();
+
+	/**
+	This function will Return the handle to the Sip Paramters of the state machine
+	*/
+	IMPORT_C TSipParams & GetSipParams();
+
+	/**
+	This method paves the way for the state machine to delete itself
+	*/
+	IMPORT_C void DeleteWhenReady();
+
+	/**
+    Implementing Pure virtual of Base class , cancels any outstanding request
+    */
+   	virtual void DoCancel();
+
+   	/**
+    Implementing Pure virtual of Base class. This function calls the functionality
+    associated with the states
+    */
+	virtual void RunL();
+
+	/**
+	Overriding the base member function, will get called in case of an error
+	*/
+	virtual TInt RunError(TInt aError);
+
+	/**
+    Set the suspend state of the State machine. Using this call one can bring
+    state machine into suspended mode from active mode and vice versa
+
+    @param aSuspendRequest Tells whether to put state machine into suspended or active mode
+    */
+    void SetSuspendRequest(TBool aSuspendRequest);
+
+    /**
+    This function will actually start the SIP State machine.
+
+    @param aClientStatus Current status of the State machine Task
+    @param aErrorEvent currently not implemented, for future use
+    */
+    void Start( TRequestStatus* aClientStatus, CSipStateBase* aErrorEvent);
+
+	/**
+	Function will be called in The RunL gets executed in event of an
+	error
+	*/
+	void OnError();
+
+	/**
+	This function is meant for cleanup activities and get called when the
+	state machine is about to complete.
+	*/
+	void OnCompletion();
+
+	/**
+	This function gets triggered from the TE in case a SIP Response comes for
+	this state machine.
+
+	@param aMsgBundle Message specific to Handle SIP request or response
+	*/
+	void IncomingResponse(TSipMsgBundle aMsgBundle);
+
+	/**
+	This function gets triggered from the TE in case a SIP Request comes for
+	this state machine.
+
+	@param aMsgBundle Message specific to Handle SIP request or response
+	*/
+	void IncomingRequest(TSipMsgBundle aMsgBundle);
+
+	/**
+	This function gets triggered from the TE when an error is encounterd pertaining
+	to this state machine request or response.
+
+	@param aErrBundle Message specific to Handle SIP request or response
+	*/
+	void ErrorOccured(TSipMsgBundle aErrBundle);
+
+	/**
+	This function gets triggered from the TE after around 3-4 minutes when a call is
+	established. This is meant for cleaning up of the client transaction. In some case
+	a call can ne terminated before this function can gets called. In that case the client
+	transaction will be deleted before call termination and this function implementation
+	will not make any sense.
+
+	@param aTransaction Handle to the client transaction that should be deleted
+	*/
+	void InviteCompleted(CSIPClientTransaction& aTransaction);
+
+	/**
+	This function will generate the response for the incoming invite
+
+	@param aTransaction Sever Transaction using which the response must be sent
+	@param aType The type of responses that must be sent by this function call
+	*/
+	void GenerateInviteResponseL(CSIPServerTransaction *& aTransaction,TSipHLConsts::SIP_RESPONSE_TYPE aType);
+
+	/**
+	This function will generate the response for the incoming subscribe method
+
+	@param aTransaction Sever Transaction using which the response must be sent
+	@param aType The type of responses that must be sent by this function call
+	*/
+	void GenerateSubscribeResponseL(CSIPServerTransaction *& aTransaction,TSipHLConsts::SIP_RESPONSE_TYPE aType);
+
+	/**
+	This function will get called in case any request comes when a dialog is
+	established, and the incoming request matched to the existing dialog
+
+	@param aMsgBundle Message specific to Handle SIP request or response
+	*/
+	void IncomingRequestInsideDialog(TSipMsgBundle aMsgBundle);
+
+	/**
+	This function will get called in case any request comes doesnt matches
+	with any of the existing dialog
+
+	@param aMsgBundle Message specific to Handle SIP request or response
+	*/
+	void IncomingRequestOutsideDialog(TSipMsgBundle & aMsgBundle);
+
+	/**
+	This function will scheduler the state machine RunL to be called in next cycle
+	in not alreay active
+	*/
+	void MakeActive ();
+
+	/**
+	This function will issue a request complete onto itself and force the RunL method
+	of the state machine to get called
+
+	@param aErrCode Current status of the state machine
+	*/
+	void MarkRequestComplete(TInt aErrCode);
+
+	/**
+	This function will return the Handle to the Transition engine that is with
+	the current state machine
+	*/
+	CSIPTransitionEngine *GetTe();
+
+	/**
+	This function will return the pointer to the currently active state
+	*/
+	CSipStateBase * GetActiveState();
+
+	/**
+	This function will call the terminated callback to the application client
+	*/
+	void CallTerminateCallback();
+
+	/**
+	This function will notify the client about incoming calls
+	*/
+	void CallIncomingCallback();
+
+	/**
+	This function will call the extablished callback onto the client
+	*/
+	void CallEstablishedCallback();
+
+	/**
+	This functin will call the notification callback onto the client
+	*/
+	void CallNotificationCallback(TPtrC8 aNotifyData);
+
+	/**
+	This function will returns the handle to the state requested
+
+	@param aNextState Handle to the request which is to be returned
+	*/
+	CSipStateBase * GetNextState (TSipHLConsts::SIP_STATES aNextState);
+
+	/**
+	This function returns the First/Oldesst element of the SIP message Bundle
+	*/
+	TSipMsgBundle	GetSipMessageBundle();
+
+	/**
+	This function tells the state machine that it is being called from upper layer
+	or the lower layer. Upper Layer being the client which instantiated the state
+	machine and lower layer is the TE, which call State machine to either give some
+	information to the user or to get some functionality done
+
+	@param aStimulus Identifier of the upper or lower layer
+	*/
+	void	SetSIPStimulus(TSipHLConsts::SIP_SM_STIMULUS aStimulus);
+
+	/**
+	This function will return the command context of the state machine
+	*/
+	TCommandContext & GetCommandContext();
+
+	/**
+	This function will return whether the state machine is for handling incoming call
+	*/
+	TBool GetIncomingStatus();
+
+	/**
+	This function will return ETrue if thsi state machine represents
+	the current active outgoing session
+	*/
+	TBool GetOutgoingStatus();
+
+	/**
+	This function will reset the outgoing status of the state machine
+	*/
+	void SetOutgoingStatus(TBool aStatus);
+
+	/**
+	This function will do cleanup activities before terminting the state machine
+	*/
+	void Cleanup();
+
+	/**
+	This function will invite the functionalities of doing a sip registration
+	*/
+	void SendRegisterMessageL();
+
+	/**
+	This function will invite the functionalities of doing a sip Unregistration
+	*/
+	void SendUnRegisterMessageL();
+
+	/**
+	This function will invite the functionalities of doing a sip Invite
+	*/
+	void SendInviteMessageL();
+
+	/**
+	This function will Send the acknowledgement of the Sucess response of
+	the Invitation.
+	*/
+	void SendAckForInviteL();
+
+	/**
+	This function will send the cancellation for the onging invite
+	*/
+	void SendCancelL();
+
+	/**
+	This function will terminte the ongoing session by sending a SIP
+	bye
+	*/
+	void SendByeL();
+
+	/**
+	This function will send the response of an incoming bye from remote user
+	*/
+	void SendByeResponseL();
+
+	/**
+	This function will invite the functionalities of doing a sip Subscribe
+	*/
+	void SendSubscribeMessageL();
+
+	/**
+	This function will invite the functionalities of doing a sip UnSubscribe
+	*/
+	void SendUnSubscribeMessageL();
+	/**
+	This function will set the status of call terminate call back
+
+	@param aCallTerminateCallBack
+	*/
+	void SetCallTerminateCallBack(TBool aCallTerminateCallback);
+
+	/**
+	This method is called by the TransditionEngine when
+	it ignores a challenge recieved on a session represented by
+	this StateMachine
+
+	@param aRealm - The realm on which the challenge was recieved
+	*/
+	void	ChallengeIgnored(const TDesC8& aRealm);
+
+	/**
+	This function will set the error that occurred in processing of SIP Message
+
+	@param aError - SIP Error Message
+	*/
+	void SetGeneralError(TInt aError);
+
+	/**
+	This function will set the SIP Specific codes
+
+	@param aError - SIP Message code
+	*/
+	void SetSIPError(TInt aError);
+
+	/**
+	This function copy the notification data from the Server Transaction
+	*/
+	HBufC8 * GenerateNotificationData();
+
+	/**
+	Destructor of the class
+	*/
+	~CSipStateMachine();
+
+private:
+
+	/**
+	The constructor of the class.
+
+	@param aTe Handle to the Transition Engine
+	@param aClient Handle to the callback Notifications
+	*/
+	CSipStateMachine(CSIPTransitionEngine * aTe, MSIPStateMachineClient* aClient, TBool aSmDirection);
+
+	/**
+	2nd Phase construction method of the State machine, which actually starts the
+	state machine
+	*/
+	void ConstructL();
+
+	/**
+	This method is to give instructions pertaining to SIP request to the state
+	machine
+
+	@param aRequest Enumeration which defines a set of Requests that are supported
+	*/
+	TInt SendSIPRequest(TSipHLConsts::SIP_REQUESTS aRequest);
+
+	/**
+	This method is to respond for any incoming request that comes to the client
+	and need user response, e.g Answering an Incoming call
+
+	@param aResponse Enumeration which defines a set of supported responses
+	*/
+	TInt SendSIPResponse(TSipHLConsts::SIP_RESPONSES aResponse);
+
+	/**
+	This function will Create the TO header from the descriptor
+
+	@param aSipUri The Uri which sould constitute the to header
+	*/
+	CSIPToHeader* CreateToHeaderLC( const TDesC8& aSipUri );
+
+	/**
+	This function will Create the From header from the descriptor
+
+	@param aSipUri The Uri which sould constitute the from header
+	*/
+	CSIPFromHeader* CreateFromHeaderLC( const TDesC8& aSipUri );
+
+	/**
+	This function will Create SDP body from the CSdpDocument
+
+	@param aContent The pointer from which content body should be made
+	*/
+	HBufC8* GetContentBodyL( CSdpDocument* aContent );
+
+	/**
+	This function generates the incoming call parameters from the server
+	transaction available with the current state machine
+
+	@param aParam store the incoming call parameters
+	*/
+	void GenerateIncomingCallParameters(TIncomingCallParameters & aParam);
+
+
+private:
+	// For Logging
+	__FLOG_DECLARATION_MEMBER;
+
+	// True when the SM recieves call from the client
+	TBool iClientStimulus;
+
+	// True when the SM recieves the call from TE
+	TBool iServerStimulus;
+
+	// True in case of error, can be either through client or TE
+	TBool iServerErrorStimulus;
+
+	// set the status of the State machine
+	TBool iSuspendRequest;
+
+	// Array of Sip Message bundles
+	RArray <TSipMsgBundle> 	iSipMsgBundle;
+
+	// Current Request Status of the state machine
+	TRequestStatus * iClientStatus;
+
+	// Handle to the active state of the state machine
+	CSipStateBase  * iActiveState;
+
+	// handle to the error state of the state machine
+	CSipStateBase  * iErrorState;
+
+	// handle to the command context of this state machine
+	TCommandContext iCommandCntx;
+
+	// Handle to the current parameter set for this state machine
+	TSipParams	iSipParams;
+
+	// Handle to the Transition engine
+	CSIPTransitionEngine 	 * iTe;
+
+	// handle to the Idle State
+	CStateIdle  			 * iStateIdle;
+
+	// handle to the Session Initialisation State
+	CStateSessionInitiation  * iStateSessionInit;
+
+	// handle to the Session Established State
+	CStateSessionEstablished * iStateSessionEstablished;
+
+	// handle to the Terminated state
+	CStateSessionTerminate	 * iStateSessionTerminate;
+
+	// Handle to the callback clinet for SIP notifications
+	MSIPStateMachineClient		 * iClient;
+
+	// Handle to Values that should be passed onto the client
+	TUriHolder	iUriValues;
+
+	// This contains the Error values to be sent to Calling application
+	TCallTerminateCode	iCallTerminateCode;
+
+	// This variable will mark the state machine to be used only
+	// for incoming calls
+	TBool	iIncomingStateMachine;
+
+	// This variable will tell whther to call the Terminate notification
+	// when the state is going to terminated state
+	TBool	iCallTerminateCallback;
+
+	//This flag indicates if this StateMachine represents the current
+	//active outgoing session
+	TBool 	isActiveOutgoingSession;
+
+	// This flag will tell whether the state machine is a Invite state machine
+	TBool	isInviteSM;
+
+	// This flag will tell whether the state machine is a subscribe state machine
+	TBool	isSubscribeSM;
+
+	// This flag will tell the state machine whether to delete it or not
+	TBool	iDeleteMeNow;
+	};
+
+
+
+inline void CSipStateMachine::SetSuspendRequest( TBool aSuspendRequest )
+/**
+ */
+   {
+   iSuspendRequest = aSuspendRequest;
+   }
+
+
+inline TSipMsgBundle CSipStateMachine::GetSipMessageBundle()
+/**
+ */
+ 	{
+ 	TSipMsgBundle  CurrBundle;
+	CurrBundle.iStatusCode = 0;
+        CurrBundle.iErrCode = 0;
+	CurrBundle.iRequest = TSipHLConsts::ERequestNone;
+	CurrBundle.iResponse = TSipHLConsts::EResponseNone;
+	CurrBundle.iServTransaction = 0;
+	CurrBundle.iClientTransaction = 0;
+	CurrBundle.iDialog = 0;
+ 	if (iSipMsgBundle.Count() > 0)
+ 		{
+ 		CurrBundle = iSipMsgBundle[0];
+ 		iSipMsgBundle.Remove(0);
+ 		}
+ 	else
+ 		{
+ 		CurrBundle.iStatusCode = -1;
+ 		}
+ 	return CurrBundle;
+ 	}
+
+inline void	CSipStateMachine::SetSIPStimulus(TSipHLConsts::SIP_SM_STIMULUS aStimulus)
+/**
+ */
+	{
+	if (aStimulus == TSipHLConsts::EClientStimulus)
+		{
+		iClientStimulus = ETrue;
+		}
+	if (aStimulus == TSipHLConsts::EServerStimulus)
+		{
+		iServerStimulus = ETrue;
+		}
+	}
+
+
+inline TCommandContext & CSipStateMachine::GetCommandContext()
+/**
+ */
+ 	{
+ 	return iCommandCntx;
+ 	}
+
+inline void CSipStateMachine::SetCallTerminateCallBack(TBool aCallTerminateCallBack)
+/**
+ */
+	{
+	iCallTerminateCallback = aCallTerminateCallBack;
+	}
+
+inline void CSipStateMachine::SetGeneralError(TInt aError)
+/**
+ */
+ 	{
+ 	iCallTerminateCode.iErrorCode = aError;
+ 	}
+
+inline void CSipStateMachine::SetSIPError(TInt aError)
+/**
+ */
+ 	{
+ 	iCallTerminateCode.iSipCode = aError;
+ 	}
+
+
+#endif
+