MSRP Chat and File Sharing FrameWork - Initial Contribution from Nokia.
MSRP Implementation as per RFC 4975 and RCS specifications that supports
1. Multiple one to one chat data sessions as per RCS/RFC 4975 specifications.
2. Multiple file Sharing sessions as per RCS.
3. Data Chunking requirements as per 4975.
3. MSRP Connection sharing requirements as per RFC 4975
/*
* Copyright (c) 2006-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:
* Name : CTransactionUser.h
* Part of : TransactionUser
* Version : SIP/5.0
*
*/
/**
@internalComponent
*/
#ifndef CTRANSACTIONUSER_H
#define CTRANSACTIONUSER_H
// INCLUDES
#include <e32base.h>
#include <bamdesca.h>
#include <stringpool.h>
#include <commsdattypesv1_1.h>
#include "sipinternalstates.h"
#include "MTransactionUser.h"
#include "MServerTaFactory.h"
#include "MConnectionStateObserver.h"
// FORWARD DECLARATIONS
class MSIPRequestRouter;
class MTimerManager;
class CSipConnectionMgr;
class MSipDialogs;
class MSipRegistrations;
class MSipRegistrationContact;
class CDeleteMgr;
class CSIPSec;
class CTransactionMgr;
class MTransactionOwner;
class CTransactionStore;
class CUserAgent;
class CCancelUAC;
class CUserAgentCreateParams;
class CTimerValueRetriever;
class CSIPMessageUtility;
class CInviteUAC_Start;
class CInviteUAC_ResolveAddress;
class CInviteUAC_WaitResponse;
class CInviteUAC_WaitAckFromApp;
class CInviteUAC_ResolveAckAddress;
class CInviteUAC_SendingAck;
class CInviteUAC_WaitTransactionToEnd;
class CInviteUAC_WaitAuthentication;
class CNormalUAC_Start;
class CNormalUAC_ResolveAddress;
class CNormalUAC_WaitResponse;
class CNormalUAC_WaitAuthentication;
class CInviteUAS_Start;
class CInviteUAS_GetTxOwner;
class CInviteUAS_WaitRespFromApp;
class CInviteUAS_Accepted;
class CInviteUAS_Rejected;
class CNormalUAS_Start;
class CNormalUAS_GetTxOwner;
class CNormalUAS_WaitRespFromApp;
class CNormalUAS_FinalRespSent;
class CCancelUAC_Start;
class CCancelUAC_ResolveAddress;
class CCancelUAC_WaitResponse;
class CCancelUAC_WaitAuthentication;
class CCancelUAS_Start;
class CCancelUAS_FinalRespSent;
// CLASS DECLARATION
/**
* CTransactionUser class is the interface for using TransactionUser subsystem.
*/
class CTransactionUser :
public CBase,
public MTransactionUser,
public MServerTaFactory,
public MConnectionStateObserver
{
public: // Constructors and destructor
/**
* Creates TransactionUser subsystem.
*
* @pre aRouter != NULL, aTimers != NULL
*
* @param aRouter Router interface. Ownership isn't transferred.
* @param aTimers Lwtimer interface. Ownership isn't transferred.
* @param aObserver Callback to pass connection state information
* @return value New CTransactionUser object, ownership is transferred.
*/
static CTransactionUser* NewL(MSIPRequestRouter* aRouter,
MTimerManager* aTimers,
MConnectionStateObserver& aObserver);
/**
* Destructor. All existing transactions are immediately stopped.
*/
~CTransactionUser();
public : // From MTransactionUser
void SendL(TTransactionId& aTransactionId,
TRegistrationId aRegistrationId,
CSIPRequest* aRequest,
MTransactionOwner* aObserver,
CURIContainer& aRemoteTarget,
const TSIPTransportParams& aTransportParams,
TBool aDeleteRequest);
MTransactionHeaders* SendAndGetHeadersL(
TTransactionId& aTransactionId,
TRegistrationId aRegistrationId,
CSIPRequest* aRequest,
MTransactionOwner* aObserver,
CURIContainer& aRemoteTarget,
const TSIPTransportParams& aTransportParams,
TBool aDeleteRequest);
void SendL(TTransactionId aTransactionId,
CSIPResponse* aResponse,
const TSIPTransportParams& aTransportParams) const;
void SendL(TTransactionId aTransactionId,
CSIPResponse* aResponse,
MTransactionOwner* aObserver,
const TSIPTransportParams& aTransportParams) const;
void SendCancelL(TTransactionId aInviteTaId,
TTransactionId& aCancelTaId,
MTransactionOwner* aObserver);
TInt ClearTransactionOwner(TTransactionId aTransactionId) const;
TInt ClearTransactionOwner(MTransactionOwner* aObserver) const;
void GetLocalAddress(TUint32 aIapId, TInetAddr& aAddr) const;
void FreeResources(MSIPNATBindingObserver& aSIPNATBindingObserver );
MTransactionHeaders*
TransactionHeadersL(TTransactionId aTransactionId) const;
void MakeTagL(TDes8& aTag) const;
virtual TInt NextHopIP(
const TTransactionId& aTransactionId, TInetAddr& aAddr);
public: // From MServerTaFactory
virtual MReceiverObserver*
NewTransactionL(CSIPRequest& aRequest,
const TSIPTransportParams& aParams,
TTransactionId& aTransactionId);
public: // From MConnectionStateObserver
void ConnectionStateChangedL(TUint32 aIapId, CSIPConnection::TState aState);
public: // New functions
/**
* Returns a reference to SIPSec.
*
* @returns SIPSec
*/
CSIPSec& SIPSec();
/**
* Returns a reference to SIP ConnnectionMgr.
*
* @returns ConnectionMgr
*/
CSipConnectionMgr& SipConnectionMgr();
/**
* Gives the address of SIP Dialogs subsystem to TransactionUser subsystem.
*
* @pre aSipDialogs != NULL
*
* @param aSipDialogs IN: address of SIP Dialogs subsystem. Ownership isn't
* transferred
*/
void SetDialogs(MSipDialogs* aSipDialogs);
/**
* Gives the interfaces of SIP Registrations subsystem for TransactionUser
* subsystem.
*
* @pre aSipRegistrations != NULL, aRegistrationContact != NULL
*
* @param aSipRegistrations IN: interface for checking AORs. Ownership
* isn't transferred
* @param aRegistrationContact IN: interface for obtaining Contact header.
* Ownership isn't transferred
*/
void SetRegistrations(MSipRegistrations* aSipRegistrations,
MSipRegistrationContact* aRegistrationContact);
/**
* Obtains the state of the specified transaction.
*
* @param aTransactionId TransactionId of the transaction whose state is
* requested.
* @param aState OUT: Transaction state
* @leave KErrNotFound if no such transaction exists.
*/
void GetStateL(TTransactionId aTransactionId,
CSIPInternalStates::TState& aState) const;
private: // Constructors, for internal use
CTransactionUser(MSIPRequestRouter* aRouter,
MTimerManager* aTimers,
MConnectionStateObserver& aStateObserver);
void ConstructL();
private: // New functions, for internal use
/**
* Builds UA state machines by creating the state objects and linking them
* together.
*/
void ConstructUaStateMachinesL();
/**
* Generate a new value to be used as a CSeq sequence number.
*
* @return value Sequence number
*/
TUint32 NewCSeqValue();
/**
* Fills the common parameters for creating a new UA.
*
* @param aTransactionId Transaction id for the new UserAgent
* @param aObserver Callback to the upper layer. Can be NULL. Ownership
* isn't transferred.
* @param aDeleteOutgoingMsg If ETrue, UserAgent deletes iOutgoingMsg when
* UserAgent itself is deleted.
* @param aParams IN: Transport parameters to be used when handing a SIP
* message to SIP Connection Mgr.
* @return Object containing the common parameters for all UserAgent types.
* Ownership is transferred.
*/
CUserAgentCreateParams* FillUserAgentParamsLC(TTransactionId aTransactionId,
MTransactionOwner* aObserver,
TBool aDeleteOutgoingMsg,
const TSIPTransportParams& aParams) const;
/**
* Creates an UAS for handling a SIP request received from network.
*
* @param aTaId TransactionId for the UAS
* @param aMethod Method of the SIP request
* @param aParams IN: Transport parameters to be used when handing a SIP
* message to SIP Connection Mgr.
* @return value New UA object, ownership is transferred
*/
CUserAgent* CreateUasL(TTransactionId aTaId,
RStringF aMethod,
const TSIPTransportParams& aParams) const;
/**
* Creates an UAC for sending a new SIP request to network.
*
* @param aTaId TransactionId for the UAC
* @param aMethod Method of the SIP request
* @param aObserver Callback where UAC sends the response and other events
* @param aDeleteRequest If ETrue, UAC will delete the SIP request when UAC
* ends. If EFalse, UAC doesn't delete the SIP request. In either case,
* UAC can modify the request.
* @param aCSeqNumber CSeq sequence number for UAC to use, unless filled by
* upper layer.
* @param aParams IN: Transport parameters to be used when handing a SIP
* request to SIP Connection Mgr.
* @return value New UA object, ownership is transferred
*/
CUserAgent* CreateUacL(TTransactionId aTaId,
RStringF aMethod,
MTransactionOwner& aObserver,
TBool aDeleteRequest,
TUint32 aCSeqNumber,
const TSIPTransportParams& aParams) const;
/**
* Creates UAC for sending CANCEL request to network.
*
* @param aTaId TransactionId for the UAC
* @param aObserver Callback where UAC sends the response an other events
* @param aCSeqNumber CSeq sequence number for UAC to use, unless filled by
* upper layer.
* @param aParams IN: Transport parameters to be used when handing a SIP
* request to SIP Connection Mgr.
* @return value New CancelUAC object, ownership is transferred
*/
CCancelUAC*
CreateCancelUacL(TTransactionId aTaId,
MTransactionOwner& aObserver,
TUint32 aCSeqNumber,
const TSIPTransportParams& aParams) const;
/**
* Returns the Timer Retriever Mapped bearer type
* @param aIapID IapID for which bearer type needs to be determined
*/
TInt TimerRetrieverMappedBearerTypeL(TUint32 aIapID) const;
private: // Data
//Determines where incoming requests are routed. Not owned.
MSIPRequestRouter* iRouter;
//Timer services. Not owned.
MTimerManager* iTimers;
//Connection state changes are reported to this callback
MConnectionStateObserver& iStateObserver;
//Dialog subsystem. Not owned.
MSipDialogs* iDialogs;
//Registration subsystem. Not owned.
MSipRegistrations* iRegistrations;
//Used for filling in information to Contact-headers of outgoing SIP
//messages. Not owned.
MSipRegistrationContact* iRegistrationContact;
//Transport layer. Owned.
CSipConnectionMgr* iConnectionMgr;
//Contains information of all existing transactions and UAs. Owned.
CTransactionStore* iTransactionStore;
//Used for freeing memory asynchronously. Owned.
CDeleteMgr* iDeleteMgr;
//There is one instance of each UA state object. They're all owned.
//Invite user agent client states
CInviteUAC_Start* iInviteUAC_Start;
CInviteUAC_ResolveAddress* iInviteUAC_ResolveAddress;
CInviteUAC_WaitResponse* iInviteUAC_WaitResponse;
CInviteUAC_WaitAckFromApp* iInviteUAC_WaitAckFromApp;
CInviteUAC_ResolveAckAddress* iInviteUAC_ResolveAckAddress;
CInviteUAC_SendingAck* iInviteUAC_SendingAck;
CInviteUAC_WaitTransactionToEnd* iInviteUAC_WaitTransactionToEnd;
CInviteUAC_WaitAuthentication* iInviteUAC_WaitAuthentication;
//Non-Invite user agent client states
CNormalUAC_Start* iNormalUAC_Start;
CNormalUAC_ResolveAddress* iNormalUAC_ResolveAddress;
CNormalUAC_WaitResponse* iNormalUAC_WaitResponse;
CNormalUAC_WaitAuthentication* iNormalUAC_WaitAuthentication;
//Cancel user agent client states
CCancelUAC_Start* iCancelUAC_Start;
CCancelUAC_ResolveAddress* iCancelUAC_ResolveAddress;
CCancelUAC_WaitResponse* iCancelUAC_WaitResponse;
CCancelUAC_WaitAuthentication* iCancelUAC_WaitAuthentication;
//Invite user agent server states
CInviteUAS_Start* iInviteUAS_Start;
CInviteUAS_GetTxOwner* iInviteUAS_GetTxOwner;
CInviteUAS_WaitRespFromApp* iInviteUAS_WaitRespFromApp;
CInviteUAS_Accepted* iInviteUAS_Accepted;
CInviteUAS_Rejected* iInviteUAS_Rejected;
//Non-Invite user agent server states
CNormalUAS_Start* iNormalUAS_Start;
CNormalUAS_GetTxOwner* iNormalUAS_GetTxOwner;
CNormalUAS_WaitRespFromApp* iNormalUAS_WaitRespFromApp;
CNormalUAS_FinalRespSent* iNormalUAS_FinalRespSent;
//Cancel user agent server states
CCancelUAS_Start* iCancelUAS_Start;
CCancelUAS_FinalRespSent* iCancelUAS_FinalRespSent;
//Counter used to produce CSeq numbers for outgoing requests when the upper
//layers have not filled the CSeq number.
TUint32 iCSeqCounter;
//Transaction layer. Owned.
CTransactionMgr* iTransactionMgr;
//Timer values, owned.
CTimerValueRetriever* iTimerValueRetriever;
//SIP message manipulating utilities. Owned.
CSIPMessageUtility* iSIPMsgUtility;
//SIP Security subsystem. Owned.
CSIPSec* iSIPSec;
private: // For testing purposes
#ifdef CPPUNIT_TEST
friend class CTransactionUser_Test;
#endif
void __DbgTestInvariant() const;
};
#endif // end of CTRANSACTIONUSER_H
// End of File