/*
* Copyright (c) 2003 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: Tcp CirWatcher
*
*
*/
#ifndef __TCPCIRWATCHER_H__
#define __TCPCIRWATCHER_H__
// INCLUDES
#include <in_sock.h>
#include <es_sock.h>
#include <msgbearerobscallback.h>
#include "ImpsIpCirWatcherAPI.h"
#include "TcpCirWatcherTimerCallback.h"
//FORWARD DECLARATIONS
class CTcpCirWatcherTimer;
class TTcpWatcherParameters;
class MImpsConnectionManager;
class MImpsBearerObserverCallback;
// CLASS DECLARATION
class CTcpCirWatcher : public CImpsTcpCirWatcher,
public MMsgBearerObsCallback,
public MTcpCirWatcherTimerCallback
{
public: // Constructors and destructor
/**
* Two-phased constructor.
* @param TTcpWatcherParameters Parameter wrapper object
* @return CTcpCirWatcher
*/
static CTcpCirWatcher* NewL( TTcpWatcherParameters* aParameters );
/**
* Destructor.
*/
virtual ~CTcpCirWatcher();
public: //New functions
/**
* Start a TCP Watcher. This is an asynchronous request
* that completes as soon as the watcher receives a response
* to the HELO request. In such case the watcher completes the
* client's request and starts to ping the server in intervals
* defined in the constructor call (default) or by the dedicated
* method SetPingInterval(). The new value becomes effective
* as soon as the ping request following the change of the value
* has been issued.
*
* It should be noted that the call to this method means anything
* only when the watcher is at idle state. In other words, the
* watcher must be stopped before an attempt to start it again may
* take place. If, for instance, the client wishes to change the
* server to which the watcher is connected, it must first call
* StopTCPWatcher() method and only then initiate a new connection
* to a different server.
*
* NOTE: The contents of TDesC8& parameters are NOT copied. Thus the
* client must make sure that the data the descriptors point to
* exist at least as long as it takes the watcher to complete the
* client's request.
*
* @param aStatus Request status of the client
* @param aServerPort Port number of the server
* @param aServerAddress Address of the server
* @param aCSPSessionID ID of the client's CSP Session
*/
virtual void StartTCPWatcherL( TRequestStatus& aStatus,
const TUint aServerport,
const TDesC& aServerAddress,
const TDesC8& aCSPSessionID );
/**
* Stops a TCP Watcher. This is a synchronous request
* which cancels all socket reads and writes and,
* eventually, closes the outbound socket, too.
*/
virtual void StopTCPWatcher();
/**
* Returns the current state of the watcher. This method comes
* in handy for example in situations where a GPRS resume has
* just been occurred. In such case the client is able to ask
* whether or not the watcher has recovered from the event.
*/
virtual TUint WatcherStatus() const;
/**
* Set the value of the PING timer.
*/
virtual void SetPingInterval( const TInt aPingInterval );
#ifdef _DEBUG
/**
* A global logging function
*/
static void WriteToLog( TRefByValue<const TDesC8> aFmt, ... );
#endif
private:
/**
* C++ default constructor is public, because
* FinishConstuctL() takes care of memory reservations.
*/
CTcpCirWatcher( const TInt aPingInterval,
MImpsCirReceiver& aCirReceiver,
MMsgConnManager& aConnManager );
/**
* Connect a TCP Socket to the server
*/
void ConnectTCPSocketL();
/**
* Send the initial "Hello World!" message
*/
void SendHELOMessageL();
/**
* Receive data from the socket
*/
void ReceiveFromSocket();
/**
* Wait for response to the HELO request
* (=receive data from the socket)
*/
void WaitForHELOResponse();
/**
* Send a ping request
*/
void SendPingL();
/**
* Handle a timer event
*/
void HandleTimerEventL( const TUint aExpiredRequest );
/**
* Handle a succesful request completion
*/
void HandleRequestCompletionL();
/**
* Handle bearer suspension
*/
void HandleBearerSuspension();
/**
* Handle bearer activation
*/
void HandleBearerActivationL();
/**
* Handle an erroneous request completion
*/
void HandleErrorL( const TInt aError );
/**
* Determine the state of the socket
*/
void DetermineSocketStateL( const TInt aError );
/**
* Check the validity of the sender
*/
TBool CheckAddressValidity();
/**
* Send the received CIR message to client
*/
void ReportCirL();
/**
* Complete the request of the client application with an error
*/
void CompleteWithError( const TInt aError );
/**
* Reset the necessary member variables before connecting
*/
void Reset();
/**
* Save the necessary parameters before connecting
*/
void SetConnectionDetailsL( const TDesC& aServerAddress,
const TDesC8& aCSPSessionID,
const TUint aServerPort );
/**
* Wait for timer to expire
*/
void WaitForNextPing();
/**
* Handle a change in the status of the bearer.
*/
void HandleBearerEventL( TBool aIsAuthClose, TMsgBearerEvent aBearerEvent );
/**
* Return the name of the listener
*/
#ifdef _DEBUG
TPtrC8 Name() const;
#endif
/**
* Delete the watcher's log file
*/
void DeleteLogFileL();
/**
* Symbian OS second-phase constructor.
*/
void ConstructL();
/**
* From CActive
*/
void RunL();
/**
* From CActive
*/
void DoCancel();
private: //Data
enum TImpsCIRWatcherState
{
EImpsCIRWatcherIdle = KImpsCIRWatcherIdle,
EImpsCIRWatcherUnknown = KImpsCIRWatcherUnknown,
EImpsCIRWatcherAwaitingDNS = KImpsCIRWatcherAwaitingDNS,
EImpsCIRWatcherConnectingTCPSocket = KImpsCIRWatcherConnectingTCPSocket,
EImpsCIRWatcherSendingHELOMessage = KImpsCIRWatcherSendingHELOMessage,
EImpsCIRWatcherReceivingHELOResponse = KImpsCIRWatcherReceivingHELOResponse,
EImpsCIRWatcherReceivingFromSocket = KImpsCIRWatcherReceivingFromSocket,
EImpsCIRWatcherSendingPINGRequest = KImpsCIRWatcherSendingPINGRequest,
EImpsCIRWatcherWaitingPINGResponse = KImpsCIRWatcherWaitingPINGResponse,
EImpsCIRWatcherBearerSuspended = KImpsCIRWatcherBearerSuspended,
EImpsCIRWatcherStopping = KImpsCIRWatcherStopping
};
TUint iServerPort;
TUint iConnRetries;
TInt iPingRetries;
TInt iCompletionCode;
TBool iClientRequestPending;
RSocket iTCPCIRSocket;
TBuf8<512> iSocketReceiveBuffer;
TSockXfrLength iRecvLength;
HBufC8* iCSPSessionID;
HBufC8* iSocketSendBuffer;
HBufC* iAddressBuffer;
TInt iPingInterval;
TInetAddr iSocketAddress;
HBufC8* iPacket;
TRequestStatus* iClientStatus;
TNameEntry iHostAddressDnsEntry;
RHostResolver iHostResolver;
MImpsCirReceiver& iCirReceiver;
CTcpCirWatcherTimer* iWatcherTimer;
MMsgConnManager& iConnectionManager;
TImpsCIRWatcherState iWatcherStatus;
TImpsCIRWatcherState iLastGoodWatcherStatus;
RSocketServ iSocketSession;
RConnection iConnection;
};
#endif
// End of File