diff -r 000000000000 -r 307788aac0a8 sipproviderplugins/sipprovider/sipstatemachine/inc/transitionengine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sipproviderplugins/sipprovider/sipstatemachine/inc/transitionengine.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,580 @@ +// 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include "siphlcommontypes.h" +#include + +#include +#include + +#ifdef __FLOG_ACTIVE + // This will do the logging if logging is enabled + #include +#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); + +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; + // Handle to the SIP Profile Registry + CSIPProfileRegistry* iProfileRegistry; + // Handle to the wait till the Connection Starts + CActiveSchedulerWait iActiveWait; + // Reference count + TInt iRefCount; + //Digest Class Instance for Setting Credentials + CSIPHttpDigest *iDigest; + // Holder of Registration clients + RPointerArray iRegClientArray; + // Holder of SIP profiles + RPointerArray iProfileArray; + // Holder of SIP state machine + RPointerArray iSMArray; + //Holder of TSIPCredentials + RArray iCredentialsArray; + }; + + +inline CSIPConnection * CSIPTransitionEngine::GetSipConnection() +/** +Return the CSIp connection +*/ + { + return iConnection; + } + +inline void CSIPTransitionEngine::Attach() +/** +Increments the refrence count +*/ + { + iRefCount++; + } +//todo +inline TInt CSIPTransitionEngine::Detach() +//inline TInt CSIPTransitionEngine::Detach(MSIPRegistrationClient* aRegClient) +/** +Decrements the reference count +*/ + { + return --iRefCount; + } + +inline TInt CSIPTransitionEngine::IapId() +/** +returns the IAP id +*/ + { + return iIapId; + } + + +#endif