/*
* 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          : Transmitter.h
* Part of       : Transaction
* Version       : SIP/5.0
*
*/




/**
 @internalComponent
*/

#ifndef TRANSMITTER_H
#define TRANSMITTER_H

// INCLUDES
#include <e32base.h>
#include <in_sock.h>

#include "SipStackServerDefs.h"

// FORWARD DECLARATIONS
class CUri8;
class MSipConnectionMgr;
class CSIPRequest;
class CSIPResponse;
class TSIPTransportParams;
class MSendStatus;

// CLASS DECLARATION

/*
 * CTransmitter handles sending data to ConnectionMgr.
 *
 * Every CUserAgent owns one CTransmitter instance, and the associated
 * CTransaction uses the same CTransmitter object for sending.
 *
 * In case of a 2xx response to an INVITE, the InviteUAS/InviteUAC also use the
 * CTransmitter. CUserAgent can use the same instance as the CTransaction was
 * using since they are never both sending at the same time.
 */
class CTransmitter : public CActive
	{
public: // Constructors and destructor

	/**
	 * Creates an instance of CTransmitter.
	 *	 
	 * @param aConnectionMgr ConnectionMgr to be used for sending.
	 * @return value New CTransmitter object, ownership is transferred.
	 */
	static CTransmitter* NewL(MSipConnectionMgr& aConnectionMgr);

	~CTransmitter();

public: // From CActive:

	void DoCancel();

	void RunL();

	TInt RunError(TInt aError);

public: // New functions

	/**
	 * Send a SIP request message to network. 
	 *
	 * @pre aObserver != NULL
	 *
	 * @param aReq SIP request to be sent. Ownership is not transferred.
	 * @param aAddress Address where the message will be sent
	 * @param aForceUDP ETrue if transport protocol must remain UDP
	 * @param aParams Transport parameters that are given to ConnectionMgr when
	 *	sending the SIP request.
	 * @param aOutboundProxy outbound proxy, NULL pointer if not used.
     *        The ownership is not transferred.
	 * @param aObserver Callback which CTransmitter will use after it has
	 *	served the sending of the message. Since CUserAgent and CTransaction
	 *	share a common CTransmitter object, the MSendStatus callback is passed
	 *  on every SendRequestL/SendResponseL call, so CTransmitter calls the
	 *  correct object. Ownership isn't	transferred.	 
	 */
	void SendRequestL(CSIPRequest& aReq,
					  const TInetAddr& aAddress,
					  TBool aForceUDP,
					  const TSIPTransportParams& aParams,
					  const CUri8* aOutboundProxy,
					  MSendStatus* aObserver);

	/**
	 * Send a SIP response message to network. 
	 *
	 * @pre aObserver != NULL
	 *
	 * @param aResp SIP response to be sent. Ownership is not transferred.
	 * @param aParams Transport parameters that are given to ConnectionMgr when
	 *	sending the SIP response.
	 * @param aObserver Callback which CTransmitter will use after it has
	 *	served the sending of the message. Since CUserAgent and CTransaction
	 *	share a common CTransmitter object, the MSendStatus callback is passed
	 *  on every SendRequestL/SendResponseL call, so CTransmitter calls the
	 *  correct object. Ownership isn't	transferred.
	 * @param aTransactionId TransactionId of transaction that sends the
	 *	response.
	 */
	void SendResponseL(CSIPResponse& aResp,
					   const TSIPTransportParams& aParams,
					   MSendStatus* aObserver,
					   TTransactionId aTransactionId);

	/**
	 * The user of CTransmitter indicates it doesn't want any events to the
	 * callback it has provided earlier in SendRequestL or SendResponseL.
	 *
	 * E.g. a CTransaction is ending, but it doesn't use CTransmitter::Cancel()
	 * to make sure CTransmitter won't use callback anymore, since in case some
	 * other CTransaction instance or CUserAgent is currently sending, their
	 * sending would get canceled.	 
	 *
	 * @param aObserver Callback which CTransmitter shouldn't use anymore.
	 *	In case CTransmitter is already serving another user (meaning its
	 *  iObserver != aObserver), nothing is done. Ownership isn't transferred.
	 * @return value -
	 */
	void DetachCallback(MSendStatus* aObserver);

	/**
	 * Tells ConnectionMgr to clear any references to SIP responses associated
	 * with the aTransactionId.
	 *
	 * @param aTransactionId Identifies the transaction
	 * @param aAlso2xx Indicates if 2xx responses are also included
	 */
	void CancelSendResponses(TTransactionId aTransactionId,
							 TBool aAlso2xx) const;

    /**
	 * Disconnect TCP connection to the remote host
	 *
	 * @param aRemoteAddr Address of the remote host
	 * @param aParams Transport parameters
	 */
	void TcpDisconnect(TInetAddr& aRemoteAddr,
					   const TSIPTransportParams& aParams) const;

private: // New functions, for internal use

	CTransmitter(MSipConnectionMgr& aConnectionMgr);

    /**
	 * Converts certain error codes into CSIP::ETransportFailure, to indicate
     * a transport layer error has occurred but UAC might have a chance to
     * try again.
	 *
	 * @param aError Error code received from ConnectionMgr
	 * @return Error code which will be used instead of the aError
	 */
	TInt MapErrorCode(TInt aError) const;

private: // Data

	//Callback to the object of the most recent SendRequestL/SendResponseL
	//call. Not owned.
	MSendStatus* iObserver;

    //Transport layer used for sending
	MSipConnectionMgr& iConnectionMgr;

#ifdef CPPUNIT_TEST	
	friend class CTransmitter_Test;
	friend class CInviteCTa_Completed_Test;
#endif
	};

#endif // end of TRANSMITTER_H

// End of File